1 /* -*- c-file-style: "linux" -*-
3 rsync -- fast file replication program
5 Copyright (C) 1996-2000 by Andrew Tridgell
6 Copyright (C) Paul Mackerras 1996
7 Copyright (C) 2002 by Martin Pool <mbp@samba.org>
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 extern int log_format_has_i;
29 extern int log_format_has_o_or_i;
30 extern int daemon_log_format_has_i;
34 extern int relative_paths;
35 extern int keep_dirlinks;
36 extern int preserve_links;
37 extern int preserve_devices;
38 extern int preserve_hard_links;
39 extern int preserve_perms;
40 extern int preserve_uid;
41 extern int preserve_gid;
42 extern int preserve_times;
43 extern int omit_dir_times;
44 extern int delete_during;
45 extern int remove_sent_files;
46 extern int update_only;
47 extern int opt_ignore_existing;
49 extern int make_backups;
50 extern int csum_length;
51 extern int ignore_times;
53 extern OFF_T max_size;
54 extern int io_timeout;
55 extern int protocol_version;
56 extern int fuzzy_basis;
57 extern int always_checksum;
58 extern char *partial_dir;
59 extern char *basis_dir[];
60 extern int compare_dest;
62 extern int whole_file;
63 extern int local_server;
65 extern int read_batch;
66 extern int only_existing;
67 extern int orig_umask;
68 extern int safe_symlinks;
69 extern long block_size; /* "long" because popt can't set an int32. */
70 extern struct stats stats;
72 extern struct filter_list_struct server_filter_list;
74 static int unchanged_attrs(struct file_struct *file, STRUCT_STAT *st)
77 && (st->st_mode & CHMOD_BITS) != (file->mode & CHMOD_BITS))
80 if (am_root && preserve_uid && st->st_uid != file->uid)
83 if (preserve_gid && file->gid != GID_NONE && st->st_gid != file->gid)
90 #define SID_UPDATING ITEM_UPDATING
91 #define SID_REPORT_CHECKSUM ITEM_REPORT_CHECKSUM
92 #define SID_USING_ALT_BASIS ITEM_USING_ALT_BASIS
93 /* This flag doesn't get sent, so it must be outside 0xffff. */
94 #define SID_NO_DEST_AND_NO_UPDATE (1<<16)
96 static void itemize(struct file_struct *file, int statret, STRUCT_STAT *st,
97 int32 sflags, int f_out, int ndx)
99 int iflags = sflags & 0xffff;
102 if (S_ISREG(file->mode) && file->length != st->st_size)
103 iflags |= ITEM_REPORT_SIZE;
104 if (!(sflags & SID_NO_DEST_AND_NO_UPDATE)) {
105 int keep_time = !preserve_times ? 0
106 : S_ISDIR(file->mode) ? !omit_dir_times
107 : !S_ISLNK(file->mode);
109 if ((iflags & ITEM_UPDATING && !keep_time)
110 || (keep_time && file->modtime != st->st_mtime))
111 iflags |= ITEM_REPORT_TIME;
112 if (preserve_perms && file->mode != st->st_mode)
113 iflags |= ITEM_REPORT_PERMS;
114 if (preserve_uid && am_root && file->uid != st->st_uid)
115 iflags |= ITEM_REPORT_OWNER;
116 if (preserve_gid && file->gid != GID_NONE
117 && st->st_gid != file->gid)
118 iflags |= ITEM_REPORT_GROUP;
121 iflags |= ITEM_IS_NEW | ITEM_UPDATING;
123 if ((iflags || verbose > 1) && !read_batch) {
124 if (protocol_version >= 29) {
126 write_int(f_out, ndx);
127 write_shortint(f_out, iflags);
129 log_recv(file, &stats, iflags);
134 /* Perform our quick-check heuristic for determining if a file is unchanged. */
135 static int unchanged_file(char *fn, struct file_struct *file, STRUCT_STAT *st)
137 if (st->st_size != file->length)
140 /* if always checksum is set then we use the checksum instead
141 of the file time to determine whether to sync */
142 if (always_checksum && S_ISREG(st->st_mode)) {
143 char sum[MD4_SUM_LENGTH];
144 file_checksum(fn, sum, st->st_size);
145 return memcmp(sum, file->u.sum, protocol_version < 21 ? 2
146 : MD4_SUM_LENGTH) == 0;
155 return cmp_modtime(st->st_mtime, file->modtime) == 0;
160 * set (initialize) the size entries in the per-file sum_struct
161 * calculating dynamic block and checksum sizes.
163 * This is only called from generate_and_send_sums() but is a separate
164 * function to encapsulate the logic.
166 * The block size is a rounded square root of file length.
168 * The checksum size is determined according to:
169 * blocksum_bits = BLOCKSUM_EXP + 2*log2(file_len) - log2(block_len)
170 * provided by Donovan Baarda which gives a probability of rsync
171 * algorithm corrupting data and falling back using the whole md4
174 * This might be made one of several selectable heuristics.
176 static void sum_sizes_sqroot(struct sum_struct *sum, int64 len)
182 blength = block_size;
183 else if (len <= BLOCK_SIZE * BLOCK_SIZE)
184 blength = BLOCK_SIZE;
189 for (c = 1, l = len, cnt = 0; l >>= 2; c <<= 1, cnt++) {}
190 if (cnt >= 31 || c >= MAX_BLOCK_SIZE)
191 blength = MAX_BLOCK_SIZE;
196 if (len < (int64)blength * blength)
199 } while (c >= 8); /* round to multiple of 8 */
200 blength = MAX(blength, BLOCK_SIZE);
204 if (protocol_version < 27) {
205 s2length = csum_length;
206 } else if (csum_length == SUM_LENGTH) {
207 s2length = SUM_LENGTH;
211 int b = BLOCKSUM_BIAS;
212 for (l = len; l >>= 1; b += 2) {}
213 for (c = blength; c >>= 1 && b; b--) {}
214 /* add a bit, subtract rollsum, round up. */
215 s2length = (b + 1 - 32 + 7) / 8; /* --optimize in compiler-- */
216 s2length = MAX(s2length, csum_length);
217 s2length = MIN(s2length, SUM_LENGTH);
221 sum->blength = blength;
222 sum->s2length = s2length;
223 sum->count = (len + (blength - 1)) / blength;
224 sum->remainder = (len % blength);
226 if (sum->count && verbose > 2) {
228 "count=%.0f rem=%ld blength=%ld s2length=%d flength=%.0f\n",
229 (double)sum->count, (long)sum->remainder, (long)sum->blength,
230 sum->s2length, (double)sum->flength);
236 * Generate and send a stream of signatures/checksums that describe a buffer
238 * Generate approximately one checksum every block_len bytes.
240 static void generate_and_send_sums(int fd, OFF_T len, int f_out, int f_copy)
243 struct map_struct *mapbuf;
244 struct sum_struct sum;
247 sum_sizes_sqroot(&sum, len);
250 mapbuf = map_file(fd, len, MAX_MAP_SIZE, sum.blength);
254 write_sum_head(f_out, &sum);
256 for (i = 0; i < sum.count; i++) {
257 int32 n1 = (int32)MIN(len, (OFF_T)sum.blength);
258 char *map = map_ptr(mapbuf, offset, n1);
259 uint32 sum1 = get_checksum1(map, n1);
260 char sum2[SUM_LENGTH];
263 full_write(f_copy, map, n1);
265 get_checksum2(map, n1, sum2);
269 "chunk[%.0f] offset=%.0f len=%ld sum1=%08lx\n",
270 (double)i, (double)offset, (long)n1,
271 (unsigned long)sum1);
273 write_int(f_out, sum1);
274 write_buf(f_out, sum2, sum.s2length);
284 /* Try to find a filename in the same dir as "fname" with a similar name. */
285 static int find_fuzzy(struct file_struct *file, struct file_list *dirlist)
287 int fname_len, fname_suf_len;
288 const char *fname_suf, *fname = file->basename;
289 uint32 lowest_dist = 0x7FFFFFFF;
290 int j, lowest_j = -1;
292 fname_len = strlen(fname);
293 fname_suf = find_filename_suffix(fname, fname_len, &fname_suf_len);
295 for (j = 0; j < dirlist->count; j++) {
296 struct file_struct *fp = dirlist->files[j];
297 const char *suf, *name;
301 if (!S_ISREG(fp->mode) || !fp->length
302 || fp->flags & FLAG_NO_FUZZY)
307 if (fp->length == file->length
308 && fp->modtime == file->modtime) {
311 "fuzzy size/modtime match for %s\n",
318 suf = find_filename_suffix(name, len, &suf_len);
320 dist = fuzzy_distance(name, len, fname, fname_len);
321 /* Add some extra weight to how well the suffixes match. */
322 dist += fuzzy_distance(suf, suf_len, fname_suf, fname_suf_len)
325 rprintf(FINFO, "fuzzy distance for %s = %d.%05d\n",
326 name, (int)(dist>>16), (int)(dist&0xFFFF));
328 if (dist <= lowest_dist) {
338 /* Acts on flist->file's ndx'th item, whose name is fname. If a directory,
339 * make sure it exists, and has the right permissions/timestamp info. For
340 * all other non-regular files (symlinks, etc.) we create them here. For
341 * regular files that have changed, we try to find a basis file and then
342 * start sending checksums.
344 * Note that f_out is set to -1 when doing final directory-permission and
345 * modification-time repair. */
346 static void recv_generator(char *fname, struct file_list *flist,
347 struct file_struct *file, int ndx,
348 int f_out, int f_out_name)
350 static int missing_below = -1, excluded_below = -1;
351 static char *fuzzy_dirname = NULL;
352 static struct file_list *fuzzy_dirlist = NULL;
353 struct file_struct *fuzzy_file = NULL;
354 int fd = -1, f_copy = -1;
355 STRUCT_STAT st, partial_st;
356 struct file_struct *back_file = NULL;
357 int statret, stat_errno;
358 char *fnamecmp, *partialptr, *backupptr = NULL;
359 char fnamecmpbuf[MAXPATHLEN];
360 int itemizing, maybe_PERMS_REPORT;
367 if (protocol_version >= 29) {
369 code = daemon_log_format_has_i ? 0 : FLOG;
370 maybe_PERMS_REPORT = log_format_has_i ? 0 : PERMS_REPORT;
371 } else if (am_daemon) {
372 itemizing = daemon_log_format_has_i && !dry_run;
373 code = itemizing || dry_run ? FCLIENT : FINFO;
374 maybe_PERMS_REPORT = PERMS_REPORT;
375 } else if (!am_server) {
376 itemizing = log_format_has_i;
377 code = itemizing ? 0 : FINFO;
378 maybe_PERMS_REPORT = log_format_has_i ? 0 : PERMS_REPORT;
382 maybe_PERMS_REPORT = PERMS_REPORT;
387 flist_free(fuzzy_dirlist);
388 fuzzy_dirlist = NULL;
389 fuzzy_dirname = NULL;
391 if (missing_below >= 0) {
399 rprintf(FINFO, "recv_generator(%s,%d)\n",
400 safe_fname(fname), ndx);
403 if (server_filter_list.head) {
404 if (excluded_below >= 0) {
405 if (file->dir.depth > excluded_below)
409 if (check_filter(&server_filter_list, fname,
410 S_ISDIR(file->mode)) < 0) {
411 if (S_ISDIR(file->mode))
412 excluded_below = file->dir.depth;
416 "skipping server-excluded file \"%s\"\n",
423 if (missing_below >= 0 && file->dir.depth <= missing_below) {
431 if (fuzzy_basis && S_ISREG(file->mode)) {
432 char *dn = file->dirname ? file->dirname : ".";
433 /* Yes, identical dirnames are guaranteed to have
434 * identical pointers at this point. */
435 if (fuzzy_dirname != dn) {
437 flist_free(fuzzy_dirlist);
439 fuzzy_dirlist = get_dirlist(fuzzy_dirname, 1);
443 statret = link_stat(fname, &st,
444 keep_dirlinks && S_ISDIR(file->mode));
448 if (only_existing && statret == -1 && stat_errno == ENOENT) {
449 /* we only want to update existing files */
451 rprintf(FINFO, "not creating new file \"%s\"\n",
457 if (statret == 0 && !preserve_perms
458 && S_ISDIR(st.st_mode) == S_ISDIR(file->mode)) {
459 /* if the file exists already and we aren't perserving
460 * permissions then act as though the remote end sent
461 * us the file permissions we already have */
462 file->mode = (file->mode & ~CHMOD_BITS)
463 | (st.st_mode & CHMOD_BITS);
466 if (S_ISDIR(file->mode)) {
467 /* The file to be received is a directory, so we need
468 * to prepare appropriately. If there is already a
469 * file of that name and it is *not* a directory, then
470 * we need to delete it. If it doesn't exist, then
471 * (perhaps recursively) create it. */
472 if (statret == 0 && !S_ISDIR(st.st_mode)) {
473 delete_file(fname, st.st_mode, DEL_TERSE);
476 if (dry_run && statret != 0 && missing_below < 0) {
477 missing_below = file->dir.depth;
480 if (itemizing && f_out != -1)
481 itemize(file, statret, &st, 0, f_out, ndx);
482 if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
483 if (!relative_paths || errno != ENOENT
484 || create_directory_path(fname, orig_umask) < 0
485 || do_mkdir(fname, file->mode) < 0) {
486 rsyserr(FERROR, errno,
487 "recv_generator: mkdir %s failed",
491 if (set_perms(fname, file, statret ? NULL : &st, 0)
492 && verbose && code && f_out != -1)
493 rprintf(code, "%s/\n", safe_fname(fname));
494 if (delete_during && f_out != -1 && csum_length != SUM_LENGTH
495 && (file->flags & FLAG_DEL_HERE))
496 delete_in_dir(flist, fname, file);
500 if (max_size && file->length > max_size) {
502 rprintf(FINFO, "%s is over max-size\n",
508 if (preserve_links && S_ISLNK(file->mode)) {
510 if (safe_symlinks && unsafe_symlink(file->u.link, fname)) {
513 "ignoring unsafe symlink %s -> \"%s\"\n",
515 safe_fname(file->u.link));
520 char lnk[MAXPATHLEN];
523 if (!S_ISDIR(st.st_mode)
524 && (len = readlink(fname, lnk, MAXPATHLEN-1)) > 0) {
526 /* A link already pointing to the
527 * right place -- no further action
529 if (strcmp(lnk, file->u.link) == 0) {
531 itemize(file, 0, &st, 0,
534 set_perms(fname, file, &st,
539 /* Not the right symlink (or not a symlink), so
541 if (S_ISLNK(st.st_mode))
542 delete_file(fname, st.st_mode, DEL_TERSE);
544 delete_file(fname, st.st_mode, DEL_TERSE);
548 if (do_symlink(file->u.link,fname) != 0) {
549 rsyserr(FERROR, errno, "symlink %s -> \"%s\" failed",
550 full_fname(fname), safe_fname(file->u.link));
552 set_perms(fname,file,NULL,0);
554 itemize(file, statret, &st, SID_UPDATING,
557 if (code && verbose) {
558 rprintf(code, "%s -> %s\n", safe_fname(fname),
559 safe_fname(file->u.link));
561 if (remove_sent_files && !dry_run) {
563 SIVAL(numbuf, 0, ndx);
564 send_msg(MSG_SUCCESS, numbuf, 4);
571 if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
573 st.st_mode != file->mode ||
574 st.st_rdev != file->u.rdev) {
575 if (IS_DEVICE(st.st_mode))
576 delete_file(fname, st.st_mode, DEL_TERSE);
578 delete_file(fname, st.st_mode, DEL_TERSE);
582 rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
584 (int)file->mode, (int)file->u.rdev);
586 if (do_mknod(fname,file->mode,file->u.rdev) != 0) {
587 rsyserr(FERROR, errno, "mknod %s failed",
590 set_perms(fname,file,NULL,0);
592 itemize(file, statret, &st, SID_UPDATING,
595 if (code && verbose) {
596 rprintf(code, "%s\n",
602 itemize(file, statret, &st, 0,
605 set_perms(fname, file, &st, maybe_PERMS_REPORT);
610 if (preserve_hard_links && hard_link_check(file, HL_CHECK_MASTER))
613 if (!S_ISREG(file->mode)) {
614 rprintf(FINFO, "skipping non-regular file \"%s\"\n",
620 fnamecmp_type = FNAMECMP_FNAME;
622 if (statret != 0 && basis_dir[0] != NULL) {
623 int fallback_match = -1;
627 pathjoin(fnamecmpbuf, sizeof fnamecmpbuf,
628 basis_dir[i], fname);
629 if (link_stat(fnamecmpbuf, &st, 0) == 0
630 && S_ISREG(st.st_mode)) {
636 } else if (match_level == 2
637 && !unchanged_attrs(file, &st))
639 if (!unchanged_file(fnamecmpbuf, file, &st))
643 if (!unchanged_attrs(file, &st))
649 } while (basis_dir[++i] != NULL);
651 if (match_level < 3) {
653 pathjoin(fnamecmpbuf, sizeof fnamecmpbuf,
654 basis_dir[i], fname);
657 if (link_dest && match_level == 3 && !dry_run) {
658 if (do_link(fnamecmpbuf, fname) < 0) {
660 rsyserr(FINFO, errno,
662 full_fname(fnamecmpbuf),
665 fnamecmp = fnamecmpbuf;
671 fnamecmp = fnamecmpbuf;
677 if (statret == 0 && !S_ISREG(st.st_mode)) {
678 if (delete_file(fname, st.st_mode, DEL_TERSE) != 0)
684 if (partial_dir && (partialptr = partial_dir_fname(fname)) != NULL
685 && link_stat(partialptr, &partial_st, 0) == 0
686 && S_ISREG(partial_st.st_mode)) {
688 goto prepare_to_open;
692 if (statret != 0 && fuzzy_basis && dry_run <= 1) {
693 int j = find_fuzzy(file, fuzzy_dirlist);
695 fuzzy_file = fuzzy_dirlist->files[j];
696 f_name_to(fuzzy_file, fnamecmpbuf);
698 rprintf(FINFO, "fuzzy basis selected for %s: %s\n",
699 safe_fname(fname), safe_fname(fnamecmpbuf));
701 st.st_mode = fuzzy_file->mode;
702 st.st_size = fuzzy_file->length;
703 st.st_mtime = fuzzy_file->modtime;
705 fnamecmp = fnamecmpbuf;
706 fnamecmp_type = FNAMECMP_FUZZY;
711 if (preserve_hard_links && hard_link_check(file, HL_SKIP))
713 if (stat_errno == ENOENT)
716 rsyserr(FERROR, stat_errno,
717 "recv_generator: failed to stat %s",
723 if (opt_ignore_existing && fnamecmp_type == FNAMECMP_FNAME) {
725 rprintf(FINFO, "%s exists\n", safe_fname(fname));
729 if (update_only && fnamecmp_type == FNAMECMP_FNAME
730 && cmp_modtime(st.st_mtime, file->modtime) > 0) {
732 rprintf(FINFO, "%s is newer\n", safe_fname(fname));
736 if (!compare_dest && fnamecmp_type <= FNAMECMP_BASIS_DIR_HIGH)
738 else if (fnamecmp_type == FNAMECMP_FUZZY)
740 else if (unchanged_file(fnamecmp, file, &st)) {
742 itemize(file, statret, &st,
743 fnamecmp_type == FNAMECMP_FNAME
744 ? 0 : SID_NO_DEST_AND_NO_UPDATE,
747 if (fnamecmp_type == FNAMECMP_FNAME)
748 set_perms(fname, file, &st, maybe_PERMS_REPORT);
755 fnamecmp = partialptr;
756 fnamecmp_type = FNAMECMP_PARTIAL_DIR;
760 if (dry_run || read_batch)
762 if (whole_file > 0) {
769 int j = flist_find(fuzzy_dirlist, file);
770 if (j >= 0) /* don't use changing file as future fuzzy basis */
771 fuzzy_dirlist->files[j]->flags |= FLAG_NO_FUZZY;
775 fd = do_open(fnamecmp, O_RDONLY, 0);
778 rsyserr(FERROR, errno, "failed to open %s, continuing",
779 full_fname(fnamecmp));
781 /* pretend the file didn't exist */
782 if (preserve_hard_links && hard_link_check(file, HL_SKIP))
788 if (inplace && make_backups) {
789 if (!(backupptr = get_backup_name(fname))) {
793 if (!(back_file = make_file(fname, NULL, NO_FILTERS))) {
795 goto pretend_missing;
797 if (robust_unlink(backupptr) && errno != ENOENT) {
798 rsyserr(FERROR, errno, "unlink %s",
799 full_fname(backupptr));
804 if ((f_copy = do_open(backupptr,
805 O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, 0600)) < 0) {
806 rsyserr(FERROR, errno, "open %s",
807 full_fname(backupptr));
812 fnamecmp_type = FNAMECMP_BACKUP;
816 rprintf(FINFO, "gen mapped %s of size %.0f\n",
817 safe_fname(fnamecmp), (double)st.st_size);
821 rprintf(FINFO, "generating and sending sums for %d\n", ndx);
824 write_int(f_out, ndx);
826 int iflags = SID_UPDATING;
828 iflags |= SID_REPORT_CHECKSUM;
829 if (inplace && fnamecmp_type != FNAMECMP_FNAME)
830 iflags |= SID_USING_ALT_BASIS;
831 itemize(file, statret, &st, iflags, f_out, -1);
833 if (f_out_name >= 0) {
834 write_byte(f_out_name, fnamecmp_type);
835 if (fnamecmp_type == FNAMECMP_FUZZY) {
836 uchar lenbuf[3], *lb = lenbuf;
837 int len = strlen(fuzzy_file->basename);
839 #if MAXPATHLEN > 0x7FFF
840 *lb++ = len / 0x10000 + 0x80;
843 *lb++ = len / 0x100 + 0x80;
847 write_buf(f_out_name, (char*)lenbuf, lb - lenbuf + 1);
848 write_buf(f_out_name, fuzzy_file->basename, len);
852 if (dry_run || read_batch)
856 generate_and_send_sums(fd, st.st_size, f_out, f_copy);
860 set_perms(backupptr, back_file, NULL, 0);
862 rprintf(FINFO, "backed up %s to %s\n",
863 safe_fname(fname), safe_fname(backupptr));
870 write_sum_head(f_out, NULL);
874 void generate_files(int f_out, struct file_list *flist, char *local_name,
879 char fbuf[MAXPATHLEN];
880 int need_retouch_dir_times = preserve_times && !omit_dir_times;
881 int need_retouch_dir_perms = 0;
882 int save_only_existing = only_existing;
883 int save_opt_ignore_existing = opt_ignore_existing;
886 rprintf(FINFO, "generator starting pid=%ld count=%d\n",
887 (long)getpid(), flist->count);
891 rprintf(FINFO, "delta-transmission %s\n",
893 ? "disabled for local transfer or --whole-file"
897 /* We expect to just sit around now, so don't exit on a timeout.
898 * If we really get a timeout then the other process should exit. */
901 for (i = 0; i < flist->count; i++) {
902 struct file_struct *file = flist->files[i];
903 struct file_struct copy;
908 /* We need to ensure that any dirs we create have writeable
909 * permissions during the time we are putting files within
910 * them. This is then fixed after the transfer is done. */
911 if (!am_root && S_ISDIR(file->mode) && !(file->mode & S_IWUSR)) {
913 copy.mode |= S_IWUSR; /* user write */
915 need_retouch_dir_perms = 1;
918 recv_generator(local_name ? local_name : f_name_to(file, fbuf),
919 flist, file, i, f_out, f_out_name);
921 recv_generator(NULL, NULL, NULL, 0, -1, -1);
923 delete_in_dir(NULL, NULL, NULL);
926 csum_length = SUM_LENGTH;
927 only_existing = max_size = opt_ignore_existing = 0;
928 update_only = always_checksum = size_only = 0;
932 rprintf(FINFO,"generate_files phase=%d\n",phase);
934 write_int(f_out, -1);
936 /* files can cycle through the system more than once
937 * to catch initial checksum errors */
938 while ((i = get_redo_num()) != -1) {
939 struct file_struct *file = flist->files[i];
940 recv_generator(local_name ? local_name : f_name_to(file, fbuf),
941 flist, file, i, f_out, f_out_name);
945 only_existing = save_only_existing;
946 opt_ignore_existing = save_opt_ignore_existing;
949 rprintf(FINFO,"generate_files phase=%d\n",phase);
951 write_int(f_out, -1);
953 /* Read post-redo-phase MSG_DONE and any prior messages. */
956 if (preserve_hard_links)
959 if ((need_retouch_dir_perms || need_retouch_dir_times)
960 && !list_only && !local_name && !dry_run) {
961 /* Now we need to fix any directory permissions that were
962 * modified during the transfer and/or re-set any tweaked
963 * modified-time values. */
964 for (i = 0; i < flist->count; i++) {
965 struct file_struct *file = flist->files[i];
966 if (!file->basename || !S_ISDIR(file->mode))
968 if (!need_retouch_dir_times && file->mode & S_IWUSR)
970 recv_generator(local_name ? local_name : f_name(file),
971 flist, file, i, -1, -1);
974 recv_generator(NULL, NULL, NULL, 0, -1, -1);
977 rprintf(FINFO,"generate_files finished\n");