2 * Routines that are exclusive to the generator process.
4 * Copyright (C) 1996-2000 Andrew Tridgell
5 * Copyright (C) 1996 Paul Mackerras
6 * Copyright (C) 2002 Martin Pool <mbp@samba.org>
7 * Copyright (C) 2003-2022 Wayne Davison
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 3 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 along
20 * with this program; if not, visit the http://fsf.org website.
29 extern int stdout_format_has_i
;
30 extern int logfile_format_has_i
;
34 extern int inc_recurse
;
35 extern int relative_paths
;
36 extern int implied_dirs
;
37 extern int keep_dirlinks
;
38 extern int preserve_acls
;
39 extern int preserve_xattrs
;
40 extern int preserve_links
;
41 extern int preserve_devices
;
42 extern int write_devices
;
43 extern int preserve_specials
;
44 extern int preserve_hard_links
;
45 extern int preserve_executability
;
46 extern int preserve_perms
;
47 extern int preserve_mtimes
;
48 extern int omit_dir_times
;
49 extern int omit_link_times
;
50 extern int delete_mode
;
51 extern int delete_before
;
52 extern int delete_during
;
53 extern int delete_after
;
54 extern int missing_args
;
55 extern int msgdone_cnt
;
56 extern int ignore_errors
;
57 extern int remove_source_files
;
58 extern int delay_updates
;
59 extern int update_only
;
60 extern int human_readable
;
61 extern int ignore_existing
;
62 extern int ignore_non_existing
;
63 extern int want_xattr_optim
;
64 extern int modify_window
;
66 extern int append_mode
;
67 extern int make_backups
;
68 extern int csum_length
;
69 extern int ignore_times
;
71 extern OFF_T max_size
;
72 extern OFF_T min_size
;
75 extern int allowed_lull
;
76 extern int sock_f_out
;
77 extern int protocol_version
;
78 extern int file_total
;
79 extern int fuzzy_basis
;
80 extern int always_checksum
;
81 extern int flist_csum_len
;
82 extern char *partial_dir
;
83 extern int alt_dest_type
;
84 extern int whole_file
;
86 extern int read_batch
;
87 extern int write_batch
;
88 extern int safe_symlinks
;
89 extern int32 block_size
;
90 extern int unsort_ndx
;
91 extern int max_delete
;
92 extern int force_delete
;
93 extern int one_file_system
;
94 extern int skipped_deletes
;
95 extern dev_t filesystem_dev
;
96 extern mode_t orig_umask
;
99 extern char *basis_dir
[MAX_BASIS_DIRS
+1];
100 extern struct file_list
*cur_flist
, *first_flist
, *dir_flist
;
101 extern filter_rule_list filter_list
, daemon_filter_list
;
103 int maybe_ATTRS_REPORT
= 0;
104 int maybe_ATTRS_ACCURATE_TIME
= 0;
106 static dev_t dev_zero
;
107 static int deldelay_size
= 0, deldelay_cnt
= 0;
108 static char *deldelay_buf
= NULL
;
109 static int deldelay_fd
= -1;
110 static int loopchk_limit
;
111 static int dir_tweaking
;
112 static int symlink_timeset_failed_flags
;
113 static int need_retouch_dir_times
;
114 static int need_retouch_dir_perms
;
115 static const char *solo_file
= NULL
;
117 /* Forward declarations. */
118 #ifdef SUPPORT_HARD_LINKS
119 static void handle_skipped_hlink(struct file_struct
*file
, int itemizing
,
120 enum logcode code
, int f_out
);
123 #define EARLY_DELAY_DONE_MSG() (!delay_updates)
124 #define EARLY_DELETE_DONE_MSG() (!(delete_during == 2 || delete_after))
126 static int start_delete_delay_temp(void)
128 char fnametmp
[MAXPATHLEN
];
129 int save_dry_run
= dry_run
;
132 if (!get_tmpname(fnametmp
, "deldelay", False
)
133 || (deldelay_fd
= do_mkstemp(fnametmp
, 0600)) < 0) {
134 rprintf(FINFO
, "NOTE: Unable to create delete-delay temp file%s.\n",
135 inc_recurse
? "" : " -- switching to --delete-after");
137 delete_after
= !inc_recurse
;
138 dry_run
= save_dry_run
;
142 dry_run
= save_dry_run
;
146 static int flush_delete_delay(void)
148 if (deldelay_fd
< 0 && !start_delete_delay_temp())
150 if (write(deldelay_fd
, deldelay_buf
, deldelay_cnt
) != deldelay_cnt
) {
151 rsyserr(FERROR
, errno
, "flush of delete-delay buffer");
153 delete_after
= !inc_recurse
;
161 static int remember_delete(struct file_struct
*file
, const char *fname
, int flags
)
165 if (deldelay_cnt
== deldelay_size
&& !flush_delete_delay())
168 if (flags
& DEL_NO_UID_WRITE
)
169 deldelay_buf
[deldelay_cnt
++] = '!';
172 len
= snprintf(deldelay_buf
+ deldelay_cnt
, deldelay_size
- deldelay_cnt
,
173 "%x %s%c", (int)file
->mode
, fname
, '\0');
174 if ((deldelay_cnt
+= len
) <= deldelay_size
)
177 if (!flush_delete_delay())
184 static int read_delay_line(char *buf
, int *flags_p
)
186 static int read_pos
= 0;
189 char *bp
, *past_space
;
192 for (j
= read_pos
; j
< deldelay_cnt
&& deldelay_buf
[j
]; j
++) {}
193 if (j
< deldelay_cnt
)
195 if (deldelay_fd
< 0) {
200 deldelay_cnt
-= read_pos
;
201 if (deldelay_cnt
== deldelay_size
)
203 if (deldelay_cnt
&& read_pos
) {
204 memmove(deldelay_buf
, deldelay_buf
+ read_pos
,
207 len
= read(deldelay_fd
, deldelay_buf
+ deldelay_cnt
,
208 deldelay_size
- deldelay_cnt
);
211 rprintf(FERROR
, "ERROR: unexpected EOF in delete-delay file.\n");
216 rsyserr(FERROR
, errno
,
217 "reading delete-delay file");
224 bp
= deldelay_buf
+ read_pos
;
227 *flags_p
= DEL_NO_UID_WRITE
;
231 if (sscanf(bp
, "%x ", &mode
) != 1) {
233 rprintf(FERROR
, "ERROR: invalid data in delete-delay file.\n");
236 past_space
= strchr(bp
, ' ') + 1;
237 len
= j
- read_pos
- (past_space
- bp
) + 1; /* count the '\0' */
240 if (len
> MAXPATHLEN
) {
241 rprintf(FERROR
, "ERROR: filename too long in delete-delay file.\n");
245 /* The caller needs the name in a MAXPATHLEN buffer, so we copy it
246 * instead of returning a pointer to our buffer. */
247 memcpy(buf
, past_space
, len
);
252 static void do_delayed_deletions(char *delbuf
)
256 if (deldelay_fd
>= 0) {
257 if (deldelay_cnt
&& !flush_delete_delay())
259 lseek(deldelay_fd
, 0, 0);
261 while ((mode
= read_delay_line(delbuf
, &flags
)) >= 0)
262 delete_item(delbuf
, mode
, flags
| DEL_RECURSE
);
263 if (deldelay_fd
>= 0)
267 /* This function is used to implement per-directory deletion, and is used by
268 * all the --delete-WHEN options. Note that the fbuf pointer must point to a
269 * MAXPATHLEN buffer with the name of the directory in it (the functions we
270 * call will append names onto the end, but the old dir value will be restored
272 static void delete_in_dir(char *fbuf
, struct file_struct
*file
, dev_t fs_dev
)
274 static int already_warned
= 0;
275 static struct hashtable
*dev_tbl
;
276 struct file_list
*dirlist
;
277 char delbuf
[MAXPATHLEN
];
281 change_local_filter_dir(NULL
, 0, 0);
285 if (DEBUG_GTE(DEL
, 2))
286 rprintf(FINFO
, "delete_in_dir(%s)\n", fbuf
);
289 maybe_send_keepalive(time(NULL
), MSK_ALLOW_FLUSH
);
291 if (io_error
& IOERR_GENERAL
&& !ignore_errors
) {
295 "IO error encountered -- skipping file deletion\n");
301 change_local_filter_dir(fbuf
, dlen
, F_DEPTH(file
));
303 if (one_file_system
) {
305 dev_tbl
= hashtable_create(16, HT_KEY64
);
306 if (file
->flags
& FLAG_TOP_DIR
) {
307 hashtable_find(dev_tbl
, fs_dev
+1, "");
308 filesystem_dev
= fs_dev
;
309 } else if (filesystem_dev
!= fs_dev
) {
310 if (!hashtable_find(dev_tbl
, fs_dev
+1, NULL
))
312 filesystem_dev
= fs_dev
; /* it's a prior top-dir dev */
316 dirlist
= get_dirlist(fbuf
, dlen
, 0);
318 /* If an item in dirlist is not found in flist, delete it
319 * from the filesystem. */
320 for (i
= dirlist
->used
; i
--; ) {
321 struct file_struct
*fp
= dirlist
->files
[i
];
322 if (!F_IS_ACTIVE(fp
))
324 if (fp
->flags
& FLAG_MOUNT_DIR
&& S_ISDIR(fp
->mode
)) {
325 if (INFO_GTE(MOUNT
, 1))
326 rprintf(FINFO
, "cannot delete mount point: %s\n",
330 /* Here we want to match regardless of file type. Replacement
331 * of a file with one of another type is handled separately by
332 * a delete_item call with a DEL_MAKE_ROOM flag. */
333 if (flist_find_ignore_dirness(cur_flist
, fp
) < 0) {
334 int flags
= DEL_RECURSE
;
335 if (!(fp
->mode
& S_IWUSR
) && !am_root
&& fp
->flags
& FLAG_OWNED_BY_US
)
336 flags
|= DEL_NO_UID_WRITE
;
338 if (delete_during
== 2) {
339 if (!remember_delete(fp
, delbuf
, flags
))
342 delete_item(delbuf
, fp
->mode
, flags
);
349 /* This deletes any files on the receiving side that are not present on the
350 * sending side. This is used by --delete-before and --delete-after. */
351 static void do_delete_pass(void)
353 char fbuf
[MAXPATHLEN
];
357 /* dry_run is incremented when the destination doesn't exist yet. */
358 if (dry_run
> 1 || list_only
)
361 for (j
= 0; j
< cur_flist
->used
; j
++) {
362 struct file_struct
*file
= cur_flist
->sorted
[j
];
364 if (!F_IS_ACTIVE(file
))
369 if (!(file
->flags
& FLAG_CONTENT_DIR
)) {
370 change_local_filter_dir(fbuf
, strlen(fbuf
), F_DEPTH(file
));
374 if (DEBUG_GTE(DEL
, 1) && file
->flags
& FLAG_TOP_DIR
)
375 rprintf(FINFO
, "deleting in %s\n", fbuf
);
377 if (link_stat(fbuf
, &st
, keep_dirlinks
) < 0
378 || !S_ISDIR(st
.st_mode
))
381 delete_in_dir(fbuf
, file
, st
.st_dev
);
383 delete_in_dir(NULL
, NULL
, dev_zero
);
385 if (INFO_GTE(FLIST
, 2) && !am_server
)
386 rprintf(FINFO
, " \r");
389 static inline int mtime_differs(STRUCT_STAT
*stp
, struct file_struct
*file
)
392 return !same_time(stp
->st_mtime
, stp
->ST_MTIME_NSEC
, file
->modtime
, F_MOD_NSEC_or_0(file
));
394 return !same_time(stp
->st_mtime
, 0, file
->modtime
, 0);
398 static inline int any_time_differs(stat_x
*sxp
, struct file_struct
*file
, UNUSED(const char *fname
))
400 int differs
= mtime_differs(&sxp
->st
, file
);
401 #ifdef SUPPORT_CRTIMES
402 if (!differs
&& crtimes_ndx
) {
403 if (sxp
->crtime
== 0)
404 sxp
->crtime
= get_create_time(fname
, &sxp
->st
);
405 differs
= !same_time(sxp
->crtime
, 0, F_CRTIME(file
), 0);
411 static inline int perms_differ(struct file_struct
*file
, stat_x
*sxp
)
414 return !BITS_EQUAL(sxp
->st
.st_mode
, file
->mode
, CHMOD_BITS
);
416 if (preserve_executability
)
417 return (sxp
->st
.st_mode
& 0111 ? 1 : 0) ^ (file
->mode
& 0111 ? 1 : 0);
422 static inline int ownership_differs(struct file_struct
*file
, stat_x
*sxp
)
424 if (am_root
&& uid_ndx
&& sxp
->st
.st_uid
!= (uid_t
)F_OWNER(file
))
427 if (gid_ndx
&& !(file
->flags
& FLAG_SKIP_GROUP
) && sxp
->st
.st_gid
!= (gid_t
)F_GROUP(file
))
434 static inline int acls_differ(const char *fname
, struct file_struct
*file
, stat_x
*sxp
)
437 if (!ACL_READY(*sxp
))
439 if (set_acl(NULL
, file
, sxp
, file
->mode
))
447 #ifdef SUPPORT_XATTRS
448 static inline int xattrs_differ(const char *fname
, struct file_struct
*file
, stat_x
*sxp
)
450 if (preserve_xattrs
) {
451 if (!XATTR_READY(*sxp
))
452 get_xattr(fname
, sxp
);
453 if (xattr_diff(file
, sxp
, 0))
461 int unchanged_attrs(const char *fname
, struct file_struct
*file
, stat_x
*sxp
)
463 if (S_ISLNK(file
->mode
)) {
464 #ifdef CAN_SET_SYMLINK_TIMES
465 if (preserve_mtimes
&& !omit_link_times
&& any_time_differs(sxp
, file
, fname
))
468 #ifdef CAN_CHMOD_SYMLINK
469 if (perms_differ(file
, sxp
))
472 #ifdef CAN_CHOWN_SYMLINK
473 if (ownership_differs(file
, sxp
))
476 #if defined SUPPORT_ACLS && 0 /* no current symlink-ACL support */
477 if (acls_differ(fname
, file
, sxp
))
480 #if defined SUPPORT_XATTRS && !defined NO_SYMLINK_XATTRS
481 if (xattrs_differ(fname
, file
, sxp
))
485 if (preserve_mtimes
&& any_time_differs(sxp
, file
, fname
))
487 if (perms_differ(file
, sxp
))
489 if (ownership_differs(file
, sxp
))
492 if (acls_differ(fname
, file
, sxp
))
495 #ifdef SUPPORT_XATTRS
496 if (xattrs_differ(fname
, file
, sxp
))
504 void itemize(const char *fnamecmp
, struct file_struct
*file
, int ndx
, int statret
,
505 stat_x
*sxp
, int32 iflags
, uchar fnamecmp_type
,
508 if (statret
>= 0) { /* A from-dest-dir statret can == 1! */
509 int keep_time
= !preserve_mtimes
? 0
510 : S_ISDIR(file
->mode
) ? !omit_dir_times
511 : S_ISLNK(file
->mode
) ? !omit_link_times
514 if (S_ISREG(file
->mode
) && F_LENGTH(file
) != sxp
->st
.st_size
)
515 iflags
|= ITEM_REPORT_SIZE
;
516 if (file
->flags
& FLAG_TIME_FAILED
) { /* symlinks only */
517 if (iflags
& ITEM_LOCAL_CHANGE
)
518 iflags
|= symlink_timeset_failed_flags
;
520 ? mtime_differs(&sxp
->st
, file
)
521 : iflags
& (ITEM_TRANSFER
|ITEM_LOCAL_CHANGE
) && !(iflags
& ITEM_MATCHED
)
522 && (!(iflags
& ITEM_XNAME_FOLLOWS
) || *xname
))
523 iflags
|= ITEM_REPORT_TIME
;
524 if (atimes_ndx
&& !S_ISDIR(file
->mode
) && !S_ISLNK(file
->mode
)
525 && !same_time(F_ATIME(file
), 0, sxp
->st
.st_atime
, 0))
526 iflags
|= ITEM_REPORT_ATIME
;
527 #ifdef SUPPORT_CRTIMES
529 if (sxp
->crtime
== 0)
530 sxp
->crtime
= get_create_time(fnamecmp
, &sxp
->st
);
531 if (!same_time(sxp
->crtime
, 0, F_CRTIME(file
), 0))
532 iflags
|= ITEM_REPORT_CRTIME
;
535 #ifndef CAN_CHMOD_SYMLINK
536 if (S_ISLNK(file
->mode
)) {
540 if (preserve_perms
) {
541 if (!BITS_EQUAL(sxp
->st
.st_mode
, file
->mode
, CHMOD_BITS
))
542 iflags
|= ITEM_REPORT_PERMS
;
543 } else if (preserve_executability
544 && ((sxp
->st
.st_mode
& 0111 ? 1 : 0) ^ (file
->mode
& 0111 ? 1 : 0)))
545 iflags
|= ITEM_REPORT_PERMS
;
546 if (uid_ndx
&& am_root
&& (uid_t
)F_OWNER(file
) != sxp
->st
.st_uid
)
547 iflags
|= ITEM_REPORT_OWNER
;
548 if (gid_ndx
&& !(file
->flags
& FLAG_SKIP_GROUP
) && sxp
->st
.st_gid
!= (gid_t
)F_GROUP(file
))
549 iflags
|= ITEM_REPORT_GROUP
;
551 if (preserve_acls
&& !S_ISLNK(file
->mode
)) {
552 if (!ACL_READY(*sxp
))
553 get_acl(fnamecmp
, sxp
);
554 if (set_acl(NULL
, file
, sxp
, file
->mode
))
555 iflags
|= ITEM_REPORT_ACL
;
558 #ifdef SUPPORT_XATTRS
559 if (preserve_xattrs
) {
560 if (!XATTR_READY(*sxp
))
561 get_xattr(fnamecmp
, sxp
);
562 if (xattr_diff(file
, sxp
, 1))
563 iflags
|= ITEM_REPORT_XATTR
;
567 #ifdef SUPPORT_XATTRS
568 if (preserve_xattrs
&& xattr_diff(file
, NULL
, 1))
569 iflags
|= ITEM_REPORT_XATTR
;
571 iflags
|= ITEM_IS_NEW
;
575 if ((iflags
& (SIGNIFICANT_ITEM_FLAGS
|ITEM_REPORT_XATTR
) || INFO_GTE(NAME
, 2)
576 || stdout_format_has_i
> 1 || (xname
&& *xname
)) && !read_batch
) {
577 if (protocol_version
>= 29) {
579 write_ndx(sock_f_out
, ndx
);
580 write_shortint(sock_f_out
, iflags
);
581 if (iflags
& ITEM_BASIS_TYPE_FOLLOWS
)
582 write_byte(sock_f_out
, fnamecmp_type
);
583 if (iflags
& ITEM_XNAME_FOLLOWS
)
584 write_vstring(sock_f_out
, xname
, strlen(xname
));
585 #ifdef SUPPORT_XATTRS
586 if (preserve_xattrs
&& do_xfers
587 && iflags
& (ITEM_REPORT_XATTR
|ITEM_TRANSFER
)) {
588 int fd
= iflags
& ITEM_REPORT_XATTR
589 && !(want_xattr_optim
&& BITS_SET(iflags
, ITEM_XNAME_FOLLOWS
|ITEM_LOCAL_CHANGE
))
591 send_xattr_request(NULL
, file
, fd
);
594 } else if (ndx
>= 0) {
595 enum logcode code
= logfile_format_has_i
? FINFO
: FCLIENT
;
596 log_item(code
, file
, iflags
, xname
);
601 static enum filetype
get_file_type(mode_t mode
)
609 if (IS_SPECIAL(mode
))
613 return FT_UNSUPPORTED
;
616 /* Perform our quick-check heuristic for determining if a file is unchanged. */
617 int quick_check_ok(enum filetype ftype
, const char *fn
, struct file_struct
*file
, STRUCT_STAT
*st
)
621 if (st
->st_size
!= F_LENGTH(file
))
624 /* If always_checksum is set then we use the checksum instead
625 * of the file mtime to determine whether to sync. */
626 if (always_checksum
> 0) {
627 char sum
[MAX_DIGEST_LEN
];
628 file_checksum(fn
, st
, sum
);
629 return memcmp(sum
, F_SUM(file
), flist_csum_len
) == 0;
638 if (mtime_differs(st
, file
))
645 char lnk
[MAXPATHLEN
];
646 int len
= do_readlink(fn
, lnk
, MAXPATHLEN
-1);
650 if (strcmp(lnk
, F_SYMLINK(file
)) != 0)
658 if (!BITS_EQUAL(file
->mode
, st
->st_mode
, _S_IFMT
))
662 uint32
*devp
= F_RDEV_P(file
);
663 if (st
->st_rdev
!= MAKEDEV(DEV_MAJOR(devp
), DEV_MINOR(devp
)))
674 * set (initialize) the size entries in the per-file sum_struct
675 * calculating dynamic block and checksum sizes.
677 * This is only called from generate_and_send_sums() but is a separate
678 * function to encapsulate the logic.
680 * The block size is a rounded square root of file length.
682 * The checksum size is determined according to:
683 * blocksum_bits = BLOCKSUM_BIAS + 2*log2(file_len) - log2(block_len)
684 * provided by Donovan Baarda which gives a probability of rsync
685 * algorithm corrupting data and falling back using the whole md4
688 * This might be made one of several selectable heuristics.
690 static void sum_sizes_sqroot(struct sum_struct
*sum
, int64 len
)
697 /* The file length overflowed our int64 var, so we can't process this file. */
698 sum
->count
= -1; /* indicate overflow error */
703 blength
= block_size
;
704 else if (len
<= BLOCK_SIZE
* BLOCK_SIZE
)
705 blength
= BLOCK_SIZE
;
707 int32 max_blength
= protocol_version
< 30 ? OLD_MAX_BLOCK_SIZE
: MAX_BLOCK_SIZE
;
710 for (c
= 1, l
= len
, cnt
= 0; l
>>= 2; c
<<= 1, cnt
++) {}
711 if (c
< 0 || c
>= max_blength
)
712 blength
= max_blength
;
717 if (len
< (int64
)blength
* blength
)
720 } while (c
>= 8); /* round to multiple of 8 */
721 blength
= MAX(blength
, BLOCK_SIZE
);
725 if (protocol_version
< 27) {
726 s2length
= csum_length
;
727 } else if (csum_length
== SUM_LENGTH
) {
728 s2length
= SUM_LENGTH
;
731 int b
= BLOCKSUM_BIAS
;
732 for (l
= len
; l
>>= 1; b
+= 2) {}
733 for (c
= blength
; (c
>>= 1) && b
; b
--) {}
734 /* add a bit, subtract rollsum, round up. */
735 s2length
= (b
+ 1 - 32 + 7) / 8; /* --optimize in compiler-- */
736 s2length
= MAX(s2length
, csum_length
);
737 s2length
= MIN(s2length
, SUM_LENGTH
);
741 sum
->blength
= blength
;
742 sum
->s2length
= s2length
;
743 sum
->remainder
= (int32
)(len
% blength
);
744 sum
->count
= (int32
)(l
= (len
/ blength
) + (sum
->remainder
!= 0));
746 if ((int64
)sum
->count
!= l
)
749 if (sum
->count
&& DEBUG_GTE(DELTASUM
, 2)) {
751 "count=%s rem=%ld blength=%ld s2length=%d flength=%s\n",
752 big_num(sum
->count
), (long)sum
->remainder
, (long)sum
->blength
,
753 sum
->s2length
, big_num(sum
->flength
));
759 * Generate and send a stream of signatures/checksums that describe a buffer
761 * Generate approximately one checksum every block_len bytes.
763 static int generate_and_send_sums(int fd
, OFF_T len
, int f_out
, int f_copy
)
766 struct map_struct
*mapbuf
;
767 struct sum_struct sum
;
770 sum_sizes_sqroot(&sum
, len
);
773 write_sum_head(f_out
, &sum
);
775 if (append_mode
> 0 && f_copy
< 0)
779 mapbuf
= map_file(fd
, len
, MAX_MAP_SIZE
, sum
.blength
);
783 for (i
= 0; i
< sum
.count
; i
++) {
784 int32 n1
= (int32
)MIN(len
, (OFF_T
)sum
.blength
);
785 char *map
= map_ptr(mapbuf
, offset
, n1
);
786 char sum2
[SUM_LENGTH
];
793 full_write(f_copy
, map
, n1
);
798 sum1
= get_checksum1(map
, n1
);
799 get_checksum2(map
, n1
, sum2
);
801 if (DEBUG_GTE(DELTASUM
, 3)) {
803 "chunk[%s] offset=%s len=%ld sum1=%08lx\n",
804 big_num(i
), big_num(offset
- n1
), (long)n1
,
805 (unsigned long)sum1
);
807 write_int(f_out
, sum1
);
808 write_buf(f_out
, sum2
, sum
.s2length
);
818 /* Try to find a filename in the same dir as "fname" with a similar name. */
819 static struct file_struct
*find_fuzzy(struct file_struct
*file
, struct file_list
*dirlist_array
[], uchar
*fnamecmp_type_ptr
)
821 int fname_len
, fname_suf_len
;
822 const char *fname_suf
, *fname
= file
->basename
;
823 uint32 lowest_dist
= 25 << 16; /* ignore a distance greater than 25 */
825 struct file_struct
*lowest_fp
= NULL
;
827 fname_len
= strlen(fname
);
828 fname_suf
= find_filename_suffix(fname
, fname_len
, &fname_suf_len
);
830 /* Try to find an exact size+mtime match first. */
831 for (i
= 0; i
< fuzzy_basis
; i
++) {
832 struct file_list
*dirlist
= dirlist_array
[i
];
837 for (j
= 0; j
< dirlist
->used
; j
++) {
838 struct file_struct
*fp
= dirlist
->files
[j
];
840 if (!F_IS_ACTIVE(fp
))
843 if (!S_ISREG(fp
->mode
) || !F_LENGTH(fp
) || fp
->flags
& FLAG_FILE_SENT
)
846 if (F_LENGTH(fp
) == F_LENGTH(file
) && same_time(fp
->modtime
, 0, file
->modtime
, 0)) {
847 if (DEBUG_GTE(FUZZY
, 2))
848 rprintf(FINFO
, "fuzzy size/modtime match for %s\n", f_name(fp
, NULL
));
849 *fnamecmp_type_ptr
= FNAMECMP_FUZZY
+ i
;
856 for (i
= 0; i
< fuzzy_basis
; i
++) {
857 struct file_list
*dirlist
= dirlist_array
[i
];
862 for (j
= 0; j
< dirlist
->used
; j
++) {
863 struct file_struct
*fp
= dirlist
->files
[j
];
864 const char *suf
, *name
;
868 if (!F_IS_ACTIVE(fp
))
871 if (!S_ISREG(fp
->mode
) || !F_LENGTH(fp
) || fp
->flags
& FLAG_FILE_SENT
)
876 suf
= find_filename_suffix(name
, len
, &suf_len
);
878 dist
= fuzzy_distance(name
, len
, fname
, fname_len
);
879 /* Add some extra weight to how well the suffixes match. */
880 dist
+= fuzzy_distance(suf
, suf_len
, fname_suf
, fname_suf_len
) * 10;
881 if (DEBUG_GTE(FUZZY
, 2)) {
882 rprintf(FINFO
, "fuzzy distance for %s = %d.%05d\n",
883 f_name(fp
, NULL
), (int)(dist
>>16), (int)(dist
&0xFFFF));
885 if (dist
<= lowest_dist
) {
888 *fnamecmp_type_ptr
= FNAMECMP_FUZZY
+ i
;
896 /* Copy a file found in our --copy-dest handling. */
897 static int copy_altdest_file(const char *src
, const char *dest
, struct file_struct
*file
)
899 char buf
[MAXPATHLEN
];
900 const char *copy_to
, *partialptr
;
901 int save_preserve_xattrs
= preserve_xattrs
;
905 /* Let copy_file open the destination in place. */
909 fd_w
= open_tmpfile(buf
, dest
, file
);
914 cleanup_set(copy_to
, NULL
, NULL
, -1, -1);
915 if (copy_file(src
, copy_to
, fd_w
, file
->mode
) < 0) {
916 if (INFO_GTE(COPY
, 1)) {
917 rsyserr(FINFO
, errno
, "copy_file %s => %s",
918 full_fname(src
), copy_to
);
920 /* Try to clean up. */
925 partialptr
= partial_dir
? partial_dir_fname(dest
) : NULL
;
926 preserve_xattrs
= 0; /* xattrs were copied with file */
927 ok
= finish_transfer(dest
, copy_to
, src
, partialptr
, file
, 1, 0);
928 preserve_xattrs
= save_preserve_xattrs
;
933 /* This is only called for regular files. We return -2 if we've finished
934 * handling the file, -1 if no dest-linking occurred, or a non-negative
935 * value if we found an alternate basis file. If we're called with the
936 * find_exact_for_existing flag, the destination file already exists, so
937 * we only try to find an exact alt-dest match. In this case, the returns
938 * are only -2 & -1 (both as above). */
939 static int try_dests_reg(struct file_struct
*file
, char *fname
, int ndx
,
940 char *cmpbuf
, stat_x
*sxp
, int find_exact_for_existing
,
941 int itemizing
, enum logcode code
)
943 STRUCT_STAT real_st
= sxp
->st
;
949 pathjoin(cmpbuf
, MAXPATHLEN
, basis_dir
[j
], fname
);
950 if (link_stat(cmpbuf
, &sxp
->st
, 0) < 0 || !S_ISREG(sxp
->st
.st_mode
))
952 if (match_level
== 0) {
956 if (!quick_check_ok(FT_REG
, cmpbuf
, file
, &sxp
->st
))
958 if (match_level
== 1) {
962 if (unchanged_attrs(cmpbuf
, file
, sxp
)) {
968 } while (basis_dir
[++j
] != NULL
);
971 goto got_nothing_for_ya
;
973 if (j
!= best_match
) {
975 pathjoin(cmpbuf
, MAXPATHLEN
, basis_dir
[j
], fname
);
976 if (link_stat(cmpbuf
, &sxp
->st
, 0) < 0)
977 goto got_nothing_for_ya
;
980 if (match_level
== 3 && alt_dest_type
!= COPY_DEST
) {
981 if (find_exact_for_existing
) {
982 if (alt_dest_type
== LINK_DEST
&& real_st
.st_dev
== sxp
->st
.st_dev
&& real_st
.st_ino
== sxp
->st
.st_ino
)
984 if (do_unlink(fname
) < 0 && errno
!= ENOENT
)
985 goto got_nothing_for_ya
;
987 #ifdef SUPPORT_HARD_LINKS
988 if (alt_dest_type
== LINK_DEST
) {
989 if (!hard_link_one(file
, fname
, cmpbuf
, 1))
992 set_file_attrs(fname
, file
, sxp
, NULL
, 0);
993 if (preserve_hard_links
&& F_IS_HLINKED(file
))
994 finish_hard_link(file
, fname
, ndx
, &sxp
->st
, itemizing
, code
, j
);
995 if (!maybe_ATTRS_REPORT
&& (INFO_GTE(NAME
, 2) || stdout_format_has_i
> 1)) {
996 itemize(cmpbuf
, file
, ndx
, 1, sxp
,
997 ITEM_LOCAL_CHANGE
| ITEM_XNAME_FOLLOWS
,
1004 itemize(cmpbuf
, file
, ndx
, 0, sxp
, 0, 0, NULL
);
1006 if (INFO_GTE(NAME
, 2) && maybe_ATTRS_REPORT
)
1007 rprintf(FCLIENT
, "%s is uptodate\n", fname
);
1011 if (find_exact_for_existing
)
1012 goto got_nothing_for_ya
;
1014 if (match_level
>= 2) {
1015 #ifdef SUPPORT_HARD_LINKS
1016 try_a_copy
: /* Copy the file locally. */
1018 if (!dry_run
&& copy_altdest_file(cmpbuf
, fname
, file
) < 0) {
1019 if (find_exact_for_existing
) /* Can get here via hard-link failure */
1020 goto got_nothing_for_ya
;
1024 itemize(cmpbuf
, file
, ndx
, 0, sxp
, ITEM_LOCAL_CHANGE
, 0, NULL
);
1025 if (maybe_ATTRS_REPORT
1026 && ((!itemizing
&& INFO_GTE(NAME
, 1) && match_level
== 2)
1027 || (INFO_GTE(NAME
, 2) && match_level
== 3))) {
1028 code
= match_level
== 3 ? FCLIENT
: FINFO
;
1029 rprintf(code
, "%s%s\n", fname
,
1030 match_level
== 3 ? " is uptodate" : "");
1032 #ifdef SUPPORT_HARD_LINKS
1033 if (preserve_hard_links
&& F_IS_HLINKED(file
))
1034 finish_hard_link(file
, fname
, ndx
, &sxp
->st
, itemizing
, code
, -1);
1039 return FNAMECMP_BASIS_DIR_LOW
+ j
;
1046 /* This is only called for non-regular files. We return -2 if we've finished
1047 * handling the file, or -1 if no dest-linking occurred, or a non-negative
1048 * value if we found an alternate basis file. */
1049 static int try_dests_non(struct file_struct
*file
, char *fname
, int ndx
,
1050 char *cmpbuf
, stat_x
*sxp
, int itemizing
,
1053 int best_match
= -1;
1054 int match_level
= 0;
1055 enum filetype ftype
= get_file_type(file
->mode
);
1058 #ifndef SUPPORT_LINKS
1059 if (ftype
== FT_SYMLINK
)
1062 if (ftype
== FT_REG
|| ftype
== FT_UNSUPPORTED
) {
1064 "internal: try_dests_non() called with invalid mode (%o)\n",
1066 exit_cleanup(RERR_UNSUPPORTED
);
1070 pathjoin(cmpbuf
, MAXPATHLEN
, basis_dir
[j
], fname
);
1071 if (link_stat(cmpbuf
, &sxp
->st
, 0) < 0)
1073 if (ftype
!= get_file_type(sxp
->st
.st_mode
))
1075 if (match_level
< 1) {
1079 if (!quick_check_ok(ftype
, cmpbuf
, file
, &sxp
->st
))
1081 if (match_level
< 2) {
1085 if (unchanged_attrs(cmpbuf
, file
, sxp
)) {
1090 } while (basis_dir
[++j
] != NULL
);
1095 if (j
!= best_match
) {
1097 pathjoin(cmpbuf
, MAXPATHLEN
, basis_dir
[j
], fname
);
1098 if (link_stat(cmpbuf
, &sxp
->st
, 0) < 0)
1102 if (match_level
== 3) {
1103 #ifdef SUPPORT_HARD_LINKS
1104 if (alt_dest_type
== LINK_DEST
1105 #ifndef CAN_HARDLINK_SYMLINK
1106 && !S_ISLNK(file
->mode
)
1108 #ifndef CAN_HARDLINK_SPECIAL
1109 && !IS_SPECIAL(file
->mode
) && !IS_DEVICE(file
->mode
)
1111 && !S_ISDIR(file
->mode
)) {
1112 if (do_link(cmpbuf
, fname
) < 0) {
1113 rsyserr(FERROR_XFER
, errno
,
1114 "failed to hard-link %s with %s",
1118 if (preserve_hard_links
&& F_IS_HLINKED(file
))
1119 finish_hard_link(file
, fname
, ndx
, NULL
, itemizing
, code
, -1);
1123 if (itemizing
&& stdout_format_has_i
1124 && (INFO_GTE(NAME
, 2) || stdout_format_has_i
> 1)) {
1125 int chg
= alt_dest_type
== COMPARE_DEST
&& ftype
!= FT_DIR
? 0
1126 : ITEM_LOCAL_CHANGE
+ (match_level
== 3 ? ITEM_XNAME_FOLLOWS
: 0);
1127 char *lp
= match_level
== 3 ? "" : NULL
;
1128 itemize(cmpbuf
, file
, ndx
, 0, sxp
, chg
+ ITEM_MATCHED
, 0, lp
);
1130 if (INFO_GTE(NAME
, 2) && maybe_ATTRS_REPORT
) {
1131 rprintf(FCLIENT
, "%s%s is uptodate\n",
1132 fname
, ftype
== FT_DIR
? "/" : "");
1140 static void list_file_entry(struct file_struct
*f
)
1142 char permbuf
[PERMSTRING_SIZE
];
1143 const char *mtime_str
= timestring(f
->modtime
);
1144 int size_width
= human_readable
? 14 : 11;
1145 int mtime_width
= 1 + strlen(mtime_str
);
1146 int atime_width
= atimes_ndx
? mtime_width
: 0;
1147 int crtime_width
= crtimes_ndx
? mtime_width
: 0;
1149 if (!F_IS_ACTIVE(f
)) {
1150 /* this can happen if duplicate names were removed */
1154 /* TODO: indicate '+' if the entry has an ACL. */
1156 if (missing_args
== 2 && f
->mode
== 0) {
1157 rprintf(FINFO
, "%-*s %s\n",
1158 10 + 1 + size_width
+ mtime_width
+ atime_width
+ crtime_width
, "*missing",
1161 const char *atime_str
= atimes_ndx
&& !S_ISDIR(f
->mode
) ? timestring(F_ATIME(f
)) : "";
1162 const char *crtime_str
= crtimes_ndx
? timestring(F_CRTIME(f
)) : "";
1163 const char *arrow
, *lnk
;
1165 permstring(permbuf
, f
->mode
);
1167 #ifdef SUPPORT_LINKS
1168 if (preserve_links
&& S_ISLNK(f
->mode
)) {
1175 rprintf(FINFO
, "%s %*s %s%*s%*s %s%s%s\n",
1176 permbuf
, size_width
, human_num(F_LENGTH(f
)),
1177 timestring(f
->modtime
), atime_width
, atime_str
, crtime_width
, crtime_str
,
1178 f_name(f
, NULL
), arrow
, lnk
);
1182 static int phase
= 0;
1183 static int dflt_perms
;
1185 static int implied_dirs_are_missing
;
1186 /* Helper for recv_generator's skip_dir and dry_missing_dir tests. */
1187 static BOOL
is_below(struct file_struct
*file
, struct file_struct
*subtree
)
1189 return F_DEPTH(file
) > F_DEPTH(subtree
)
1190 && (!implied_dirs_are_missing
|| f_name_has_prefix(file
, subtree
));
1193 /* Acts on the indicated item in cur_flist whose name is fname. If a dir,
1194 * make sure it exists, and has the right permissions/timestamp info. For
1195 * all other non-regular files (symlinks, etc.) we create them here. For
1196 * regular files that have changed, we try to find a basis file and then
1197 * start sending checksums. The ndx is the file's unique index value.
1199 * The fname parameter must point to a MAXPATHLEN buffer! (e.g it gets
1200 * passed to delete_item(), which can use it during a recursive delete.)
1202 * Note that f_out is set to -1 when doing final directory-permission and
1203 * modification-time repair. */
1204 static void recv_generator(char *fname
, struct file_struct
*file
, int ndx
,
1205 int itemizing
, enum logcode code
, int f_out
)
1207 static const char *parent_dirname
= "";
1208 static struct file_struct
*prior_dir_file
= NULL
;
1209 /* Missing dir not created due to --dry-run; will still be scanned. */
1210 static struct file_struct
*dry_missing_dir
= NULL
;
1211 /* Missing dir whose contents are skipped altogether due to
1212 * --ignore-non-existing, daemon exclude, or mkdir failure. */
1213 static struct file_struct
*skip_dir
= NULL
;
1214 static struct file_list
*fuzzy_dirlist
[MAX_BASIS_DIRS
+1];
1215 static int need_fuzzy_dirlist
= 0;
1216 struct file_struct
*fuzzy_file
= NULL
;
1217 int fd
= -1, f_copy
= -1;
1219 STRUCT_STAT partial_st
;
1220 struct file_struct
*back_file
= NULL
;
1221 int statret
, real_ret
, stat_errno
;
1222 char *fnamecmp
, *partialptr
, *backupptr
= NULL
;
1223 char fnamecmpbuf
[MAXPATHLEN
];
1224 uchar fnamecmp_type
;
1225 int del_opts
= delete_mode
|| force_delete
? DEL_RECURSE
: 0;
1226 enum filetype stype
, ftype
= get_file_type(file
->mode
);
1227 int is_dir
= ftype
!= FT_DIR
? 0
1228 : inc_recurse
&& ndx
!= cur_flist
->ndx_start
- 1 ? -1
1231 if (DEBUG_GTE(GENR
, 1))
1232 rprintf(FINFO
, "recv_generator(%s,%d)\n", fname
, ndx
);
1236 || (is_dir
&& !implied_dirs
&& file
->flags
& FLAG_IMPLIED_DIR
))
1238 list_file_entry(file
);
1242 maybe_ATTRS_ACCURATE_TIME
= always_checksum
? ATTRS_ACCURATE_TIME
: 0;
1245 if (is_below(file
, skip_dir
)) {
1247 file
->flags
|= FLAG_MISSING_DIR
;
1248 #ifdef SUPPORT_HARD_LINKS
1249 else if (F_IS_HLINKED(file
))
1250 handle_skipped_hlink(file
, itemizing
, code
, f_out
);
1258 if (daemon_filter_list
.head
&& (*fname
!= '.' || fname
[1])) {
1259 if (check_filter(&daemon_filter_list
, FLOG
, fname
, is_dir
) < 0) {
1262 #ifdef SUPPORT_HARD_LINKS
1263 if (F_IS_HLINKED(file
))
1264 handle_skipped_hlink(file
, itemizing
, code
, f_out
);
1266 rprintf(FERROR_XFER
,
1267 "ERROR: daemon refused to receive %s \"%s\"\n",
1268 is_dir
? "directory" : "file", fname
);
1270 goto skipping_dir_contents
;
1275 if (dry_run
> 1 || (dry_missing_dir
&& is_below(file
, dry_missing_dir
))) {
1277 parent_is_dry_missing
:
1278 for (i
= 0; i
< fuzzy_basis
; i
++) {
1279 if (fuzzy_dirlist
[i
]) {
1280 flist_free(fuzzy_dirlist
[i
]);
1281 fuzzy_dirlist
[i
] = NULL
;
1284 parent_dirname
= "";
1286 stat_errno
= ENOENT
;
1288 const char *dn
= file
->dirname
? file
->dirname
: ".";
1289 dry_missing_dir
= NULL
;
1290 if (parent_dirname
!= dn
&& strcmp(parent_dirname
, dn
) != 0) {
1291 /* Each parent dir must be in the file list or the flist data is bad.
1292 * Optimization: most of the time the parent dir will be the last dir
1293 * this function was asked to process in the file list. */
1295 && (*dn
!= '.' || dn
[1]) /* Avoid an issue with --relative and the "." dir. */
1296 && (!prior_dir_file
|| strcmp(dn
, f_name(prior_dir_file
, NULL
)) != 0)) {
1297 int ok
= 0, j
= flist_find_name(cur_flist
, dn
, -1);
1299 struct file_struct
*f
= cur_flist
->sorted
[j
];
1300 if (S_ISDIR(f
->mode
) || (missing_args
== 2 && !file
->mode
&& !f
->mode
))
1303 /* The --delete-missing-args option can actually put invalid entries into
1304 * the file list, so if that option was specified, we'll just complain about
1305 * it and allow it. */
1306 if (!ok
&& missing_args
== 2 && file
->mode
== 0 && j
< 0)
1307 rprintf(FERROR
, "WARNING: parent dir is absent in the file list: %s\n", dn
);
1309 rprintf(FERROR
, "ABORTING due to invalid path from sender: %s/%s\n",
1310 dn
, file
->basename
);
1311 exit_cleanup(RERR_PROTOCOL
);
1314 if (relative_paths
&& !implied_dirs
&& file
->mode
!= 0
1315 && do_stat(dn
, &sx
.st
) < 0) {
1317 goto parent_is_dry_missing
;
1318 if (make_path(fname
, MKP_DROP_NAME
| MKP_SKIP_SLASH
) < 0) {
1319 rsyserr(FERROR_XFER
, errno
,
1320 "recv_generator: mkdir %s failed",
1326 for (i
= 0; i
< fuzzy_basis
; i
++) {
1327 if (fuzzy_dirlist
[i
]) {
1328 flist_free(fuzzy_dirlist
[i
]);
1329 fuzzy_dirlist
[i
] = NULL
;
1332 need_fuzzy_dirlist
= 1;
1335 if (!preserve_perms
)
1336 dflt_perms
= default_perms_for_dir(dn
);
1339 parent_dirname
= dn
;
1341 statret
= link_stat(fname
, &sx
.st
, keep_dirlinks
&& is_dir
);
1345 if (missing_args
== 2 && file
->mode
== 0) {
1346 if (filter_list
.head
&& check_filter(&filter_list
, FINFO
, fname
, is_dir
) < 0)
1349 delete_item(fname
, sx
.st
.st_mode
, del_opts
);
1353 if (ignore_non_existing
> 0 && statret
== -1 && stat_errno
== ENOENT
) {
1358 file
->flags
|= FLAG_MISSING_DIR
;
1360 #ifdef SUPPORT_HARD_LINKS
1361 else if (F_IS_HLINKED(file
))
1362 handle_skipped_hlink(file
, itemizing
, code
, f_out
);
1364 if (INFO_GTE(SKIP
, 1)) {
1365 rprintf(FINFO
, "not creating new %s \"%s\"\n",
1366 is_dir
? "directory" : "file", fname
);
1371 if (statret
== 0 && !(sx
.st
.st_mode
& S_IWUSR
)
1372 && !am_root
&& sx
.st
.st_uid
== our_uid
)
1373 del_opts
|= DEL_NO_UID_WRITE
;
1376 stype
= get_file_type(sx
.st
.st_mode
);
1378 stype
= FT_UNSUPPORTED
;
1380 if (ignore_existing
> 0 && statret
== 0
1381 && (!is_dir
|| stype
!= FT_DIR
)) {
1382 if (INFO_GTE(SKIP
, 1) && is_dir
>= 0) {
1383 const char *suf
= "";
1384 if (INFO_GTE(SKIP
, 2)) {
1386 suf
= " (type change)";
1387 else if (!quick_check_ok(ftype
, fname
, file
, &sx
.st
))
1388 suf
= always_checksum
? " (sum change)" : " (file change)";
1389 else if (!unchanged_attrs(fname
, file
, &sx
))
1390 suf
= " (attr change)";
1392 suf
= " (uptodate)";
1394 rprintf(FINFO
, "%s exists%s\n", fname
, suf
);
1396 #ifdef SUPPORT_HARD_LINKS
1397 if (F_IS_HLINKED(file
))
1398 handle_skipped_hlink(file
, itemizing
, code
, f_out
);
1407 if (!implied_dirs
&& file
->flags
& FLAG_IMPLIED_DIR
)
1410 /* For --fake-super, the dir must be useable by the copying
1411 * user, just like it would be for root. */
1412 added_perms
= S_IRUSR
|S_IWUSR
|S_IXUSR
;
1416 if (!preserve_mtimes
|| omit_dir_times
)
1418 /* In inc_recurse mode we want to make sure any missing
1419 * directories get created while we're still processing
1420 * the parent dir (which allows us to touch the parent
1421 * dir's mtime right away). We will handle the dir in
1422 * full later (right before we handle its contents). */
1425 || delete_item(fname
, sx
.st
.st_mode
, del_opts
| DEL_FOR_DIR
) != 0))
1426 goto cleanup
; /* Any errors get reported later. */
1427 if (do_mkdir(fname
, (file
->mode
|added_perms
) & 0700) == 0)
1428 file
->flags
|= FLAG_DIR_CREATED
;
1431 /* The file to be received is a directory, so we need
1432 * to prepare appropriately. If there is already a
1433 * file of that name and it is *not* a directory, then
1434 * we need to delete it. If it doesn't exist, then
1435 * (perhaps recursively) create it. */
1436 if (statret
== 0 && stype
!= FT_DIR
) {
1437 if (delete_item(fname
, sx
.st
.st_mode
, del_opts
| DEL_FOR_DIR
) != 0)
1438 goto skipping_dir_contents
;
1441 if (dry_run
&& statret
!= 0) {
1442 if (!dry_missing_dir
)
1443 dry_missing_dir
= file
;
1444 file
->flags
|= FLAG_MISSING_DIR
;
1446 init_stat_x(&real_sx
);
1449 if (file
->flags
& FLAG_DIR_CREATED
)
1451 if (!preserve_perms
) { /* See comment in non-dir code below. */
1452 file
->mode
= dest_mode(file
->mode
, sx
.st
.st_mode
, dflt_perms
, statret
== 0);
1454 if (statret
!= 0 && basis_dir
[0] != NULL
) {
1455 int j
= try_dests_non(file
, fname
, ndx
, fnamecmpbuf
, &sx
, itemizing
, code
);
1460 } else if (j
>= 0) {
1462 fnamecmp
= fnamecmpbuf
;
1465 if (itemizing
&& f_out
!= -1) {
1466 itemize(fnamecmp
, file
, ndx
, statret
, &sx
,
1467 statret
? ITEM_LOCAL_CHANGE
: 0, 0, NULL
);
1469 if (real_ret
!= 0 && do_mkdir(fname
,file
->mode
|added_perms
) < 0 && errno
!= EEXIST
) {
1470 if (!relative_paths
|| errno
!= ENOENT
1471 || make_path(fname
, MKP_DROP_NAME
| MKP_SKIP_SLASH
) < 0
1472 || (do_mkdir(fname
, file
->mode
|added_perms
) < 0 && errno
!= EEXIST
)) {
1473 rsyserr(FERROR_XFER
, errno
,
1474 "recv_generator: mkdir %s failed",
1476 skipping_dir_contents
:
1477 rprintf(FERROR
, "*** Skipping any contents from this failed directory ***\n");
1479 file
->flags
|= FLAG_MISSING_DIR
;
1484 #ifdef SUPPORT_XATTRS
1485 if (preserve_xattrs
&& statret
== 1)
1486 copy_xattrs(fnamecmpbuf
, fname
);
1488 if (set_file_attrs(fname
, file
, real_ret
? NULL
: &real_sx
, NULL
, 0)
1489 && INFO_GTE(NAME
, 1) && code
!= FNONE
&& f_out
!= -1)
1490 rprintf(code
, "%s/\n", fname
);
1492 /* We need to ensure that the dirs in the transfer have both
1493 * readable and writable permissions during the time we are
1494 * putting files within them. This is then restored to the
1495 * former permissions after the transfer is done. */
1497 if (!am_root
&& (file
->mode
& S_IRWXU
) != S_IRWXU
&& dir_tweaking
) {
1498 mode_t mode
= file
->mode
| S_IRWXU
;
1499 if (do_chmod(fname
, mode
) < 0) {
1500 rsyserr(FERROR_XFER
, errno
,
1501 "failed to modify permissions on %s",
1504 need_retouch_dir_perms
= 1;
1508 if (real_ret
!= 0 && one_file_system
)
1509 real_sx
.st
.st_dev
= filesystem_dev
;
1511 if (one_file_system
) {
1512 uint32
*devp
= F_DIR_DEV_P(file
);
1513 DEV_MAJOR(devp
) = major(real_sx
.st
.st_dev
);
1514 DEV_MINOR(devp
) = minor(real_sx
.st
.st_dev
);
1517 else if (delete_during
&& f_out
!= -1 && !phase
1518 && !(file
->flags
& FLAG_MISSING_DIR
)) {
1519 if (file
->flags
& FLAG_CONTENT_DIR
)
1520 delete_in_dir(fname
, file
, real_sx
.st
.st_dev
);
1522 change_local_filter_dir(fname
, strlen(fname
), F_DEPTH(file
));
1524 prior_dir_file
= file
;
1528 /* If we're not preserving permissions, change the file-list's
1529 * mode based on the local permissions and some heuristics. */
1530 if (!preserve_perms
) {
1531 int exists
= statret
== 0 && stype
!= FT_DIR
;
1532 file
->mode
= dest_mode(file
->mode
, sx
.st
.st_mode
, dflt_perms
, exists
);
1535 #ifdef SUPPORT_HARD_LINKS
1536 if (preserve_hard_links
&& F_HLINK_NOT_FIRST(file
)
1537 && hard_link_check(file
, ndx
, fname
, statret
, &sx
, itemizing
, code
))
1541 if (preserve_links
&& ftype
== FT_SYMLINK
) {
1542 #ifdef SUPPORT_LINKS
1543 const char *sl
= F_SYMLINK(file
);
1544 if (safe_symlinks
&& unsafe_symlink(sl
, fname
)) {
1545 if (INFO_GTE(NAME
, 1)) {
1547 /* fname contains the destination path, but we
1548 * want to report the source path. */
1549 fname
= f_name(file
, NULL
);
1552 "ignoring unsafe symlink \"%s\" -> \"%s\"\n",
1558 if (stype
== FT_SYMLINK
&& quick_check_ok(stype
, fname
, file
, &sx
.st
)) {
1559 /* The link is pointing to the right place. */
1560 set_file_attrs(fname
, file
, &sx
, NULL
, maybe_ATTRS_REPORT
);
1562 itemize(fname
, file
, ndx
, 0, &sx
, 0, 0, NULL
);
1563 #ifdef SUPPORT_HARD_LINKS
1564 if (preserve_hard_links
&& F_IS_HLINKED(file
))
1565 finish_hard_link(file
, fname
, ndx
, &sx
.st
, itemizing
, code
, -1);
1567 if (remove_source_files
== 1)
1568 goto return_with_success
;
1571 } else if (basis_dir
[0] != NULL
) {
1572 int j
= try_dests_non(file
, fname
, ndx
, fnamecmpbuf
, &sx
, itemizing
, code
);
1574 #ifndef CAN_HARDLINK_SYMLINK
1575 if (alt_dest_type
== LINK_DEST
) {
1576 /* Resort to --copy-dest behavior. */
1579 if (alt_dest_type
!= COPY_DEST
)
1583 } else if (j
>= 0) {
1585 fnamecmp
= fnamecmpbuf
;
1588 if (atomic_create(file
, fname
, sl
, NULL
, MAKEDEV(0, 0), &sx
, statret
== 0 ? DEL_FOR_SYMLINK
: 0)) {
1589 set_file_attrs(fname
, file
, NULL
, NULL
, 0);
1591 if (statret
== 0 && stype
!= FT_SYMLINK
)
1593 itemize(fnamecmp
, file
, ndx
, statret
, &sx
,
1594 ITEM_LOCAL_CHANGE
|ITEM_REPORT_CHANGE
, 0, NULL
);
1596 if (code
!= FNONE
&& INFO_GTE(NAME
, 1))
1597 rprintf(code
, "%s -> %s\n", fname
, sl
);
1598 #ifdef SUPPORT_HARD_LINKS
1599 if (preserve_hard_links
&& F_IS_HLINKED(file
))
1600 finish_hard_link(file
, fname
, ndx
, NULL
, itemizing
, code
, -1);
1602 /* This does not check remove_source_files == 1
1603 * because this is one of the items that the old
1604 * --remove-sent-files option would remove. */
1605 if (remove_source_files
)
1606 goto return_with_success
;
1612 if ((am_root
&& preserve_devices
&& ftype
== FT_DEVICE
)
1613 || (preserve_specials
&& ftype
== FT_SPECIAL
)) {
1616 if (ftype
== FT_DEVICE
) {
1617 uint32
*devp
= F_RDEV_P(file
);
1618 rdev
= MAKEDEV(DEV_MAJOR(devp
), DEV_MINOR(devp
));
1619 del_for_flag
= DEL_FOR_DEVICE
;
1622 del_for_flag
= DEL_FOR_SPECIAL
;
1627 else if (quick_check_ok(ftype
, fname
, file
, &sx
.st
)) {
1628 /* The device or special file is identical. */
1629 set_file_attrs(fname
, file
, &sx
, NULL
, maybe_ATTRS_REPORT
);
1631 itemize(fname
, file
, ndx
, 0, &sx
, 0, 0, NULL
);
1632 #ifdef SUPPORT_HARD_LINKS
1633 if (preserve_hard_links
&& F_IS_HLINKED(file
))
1634 finish_hard_link(file
, fname
, ndx
, &sx
.st
, itemizing
, code
, -1);
1636 if (remove_source_files
== 1)
1637 goto return_with_success
;
1640 } else if (basis_dir
[0] != NULL
) {
1641 int j
= try_dests_non(file
, fname
, ndx
, fnamecmpbuf
, &sx
, itemizing
, code
);
1643 #ifndef CAN_HARDLINK_SPECIAL
1644 if (alt_dest_type
== LINK_DEST
) {
1645 /* Resort to --copy-dest behavior. */
1648 if (alt_dest_type
!= COPY_DEST
)
1652 } else if (j
>= 0) {
1654 fnamecmp
= fnamecmpbuf
;
1657 if (DEBUG_GTE(GENR
, 1)) {
1658 rprintf(FINFO
, "mknod(%s, 0%o, [%ld,%ld])\n",
1659 fname
, (int)file
->mode
,
1660 (long)major(rdev
), (long)minor(rdev
));
1662 if (atomic_create(file
, fname
, NULL
, NULL
, rdev
, &sx
, del_for_flag
)) {
1663 set_file_attrs(fname
, file
, NULL
, NULL
, 0);
1665 itemize(fnamecmp
, file
, ndx
, statret
, &sx
,
1666 ITEM_LOCAL_CHANGE
|ITEM_REPORT_CHANGE
, 0, NULL
);
1668 if (code
!= FNONE
&& INFO_GTE(NAME
, 1))
1669 rprintf(code
, "%s\n", fname
);
1670 #ifdef SUPPORT_HARD_LINKS
1671 if (preserve_hard_links
&& F_IS_HLINKED(file
))
1672 finish_hard_link(file
, fname
, ndx
, NULL
, itemizing
, code
, -1);
1674 if (remove_source_files
== 1)
1675 goto return_with_success
;
1680 if (ftype
!= FT_REG
) {
1681 if (INFO_GTE(NONREG
, 1)) {
1683 fname
= f_name(file
, NULL
);
1684 rprintf(FINFO
, "skipping non-regular file \"%s\"\n", fname
);
1689 if (max_size
>= 0 && F_LENGTH(file
) > max_size
) {
1690 if (INFO_GTE(SKIP
, 1)) {
1692 fname
= f_name(file
, NULL
);
1693 rprintf(FINFO
, "%s is over max-size\n", fname
);
1697 if (min_size
>= 0 && F_LENGTH(file
) < min_size
) {
1698 if (INFO_GTE(SKIP
, 1)) {
1700 fname
= f_name(file
, NULL
);
1701 rprintf(FINFO
, "%s is under min-size\n", fname
);
1706 if (update_only
> 0 && statret
== 0 && file
->modtime
- sx
.st
.st_mtime
< modify_window
) {
1707 if (INFO_GTE(SKIP
, 1))
1708 rprintf(FINFO
, "%s is newer\n", fname
);
1709 #ifdef SUPPORT_HARD_LINKS
1710 if (F_IS_HLINKED(file
))
1711 handle_skipped_hlink(file
, itemizing
, code
, f_out
);
1716 fnamecmp_type
= FNAMECMP_FNAME
;
1718 if (statret
== 0 && !(stype
== FT_REG
|| (write_devices
&& stype
== FT_DEVICE
))) {
1719 if (delete_item(fname
, sx
.st
.st_mode
, del_opts
| DEL_FOR_FILE
) != 0)
1722 stat_errno
= ENOENT
;
1725 if (basis_dir
[0] != NULL
&& (statret
!= 0 || alt_dest_type
!= COPY_DEST
)) {
1726 int j
= try_dests_reg(file
, fname
, ndx
, fnamecmpbuf
, &sx
, statret
== 0, itemizing
, code
);
1728 if (remove_source_files
== 1)
1729 goto return_with_success
;
1733 fnamecmp
= fnamecmpbuf
;
1739 init_stat_x(&real_sx
);
1740 real_sx
.st
= sx
.st
; /* Don't copy xattr/acl pointers, as they would free wrong. */
1743 if (partial_dir
&& (partialptr
= partial_dir_fname(fname
)) != NULL
1744 && link_stat(partialptr
, &partial_st
, 0) == 0
1745 && S_ISREG(partial_st
.st_mode
)) {
1747 goto prepare_to_open
;
1751 if (statret
!= 0 && fuzzy_basis
) {
1752 if (need_fuzzy_dirlist
) {
1753 const char *dn
= file
->dirname
? file
->dirname
: ".";
1755 strlcpy(fnamecmpbuf
, dn
, sizeof fnamecmpbuf
);
1756 for (i
= 0; i
< fuzzy_basis
; i
++) {
1757 if (i
&& pathjoin(fnamecmpbuf
, MAXPATHLEN
, basis_dir
[i
-1], dn
) >= MAXPATHLEN
)
1759 fuzzy_dirlist
[i
] = get_dirlist(fnamecmpbuf
, -1, GDL_IGNORE_FILTER_RULES
| GDL_PERHAPS_DIR
);
1760 if (fuzzy_dirlist
[i
] && fuzzy_dirlist
[i
]->used
== 0) {
1761 flist_free(fuzzy_dirlist
[i
]);
1762 fuzzy_dirlist
[i
] = NULL
;
1765 need_fuzzy_dirlist
= 0;
1768 /* Sets fnamecmp_type to FNAMECMP_FUZZY or above. */
1769 fuzzy_file
= find_fuzzy(file
, fuzzy_dirlist
, &fnamecmp_type
);
1771 f_name(fuzzy_file
, fnamecmpbuf
);
1772 if (DEBUG_GTE(FUZZY
, 1)) {
1773 rprintf(FINFO
, "fuzzy basis selected for %s: %s\n",
1774 fname
, fnamecmpbuf
);
1776 sx
.st
.st_size
= F_LENGTH(fuzzy_file
);
1778 fnamecmp
= fnamecmpbuf
;
1783 #ifdef SUPPORT_HARD_LINKS
1784 if (preserve_hard_links
&& F_HLINK_NOT_LAST(file
)) {
1785 cur_flist
->in_progress
++;
1789 if (stat_errno
== ENOENT
)
1791 rsyserr(FERROR_XFER
, stat_errno
, "recv_generator: failed to stat %s",
1796 if (fnamecmp_type
<= FNAMECMP_BASIS_DIR_HIGH
)
1798 else if (fnamecmp_type
>= FNAMECMP_FUZZY
)
1800 else if (quick_check_ok(FT_REG
, fnamecmp
, file
, &sx
.st
)) {
1802 do_unlink(partialptr
);
1803 handle_partial_dir(partialptr
, PDIR_DELETE
);
1805 set_file_attrs(fname
, file
, &sx
, NULL
, maybe_ATTRS_REPORT
| maybe_ATTRS_ACCURATE_TIME
);
1807 itemize(fnamecmp
, file
, ndx
, statret
, &sx
, 0, 0, NULL
);
1808 #ifdef SUPPORT_HARD_LINKS
1809 if (preserve_hard_links
&& F_IS_HLINKED(file
))
1810 finish_hard_link(file
, fname
, ndx
, &sx
.st
, itemizing
, code
, -1);
1812 if (remove_source_files
!= 1)
1814 return_with_success
:
1816 send_msg_int(MSG_SUCCESS
, ndx
);
1820 if (append_mode
> 0 && sx
.st
.st_size
>= F_LENGTH(file
)) {
1821 #ifdef SUPPORT_HARD_LINKS
1822 if (F_IS_HLINKED(file
))
1823 handle_skipped_hlink(file
, itemizing
, code
, f_out
);
1831 fnamecmp
= partialptr
;
1832 fnamecmp_type
= FNAMECMP_PARTIAL_DIR
;
1839 if (read_batch
|| whole_file
) {
1840 if (inplace
&& make_backups
> 0 && fnamecmp_type
== FNAMECMP_FNAME
) {
1841 if (!(backupptr
= get_backup_name(fname
)))
1843 if (!(back_file
= make_file(fname
, NULL
, NULL
, 0, NO_FILTERS
)))
1844 goto pretend_missing
;
1845 if (copy_file(fname
, backupptr
, -1, back_file
->mode
) < 0) {
1846 unmake_file(back_file
);
1854 if (fuzzy_dirlist
[0]) {
1855 int j
= flist_find(fuzzy_dirlist
[0], file
);
1856 if (j
>= 0) /* don't use changing file as future fuzzy basis */
1857 fuzzy_dirlist
[0]->files
[j
]->flags
|= FLAG_FILE_SENT
;
1861 if ((fd
= do_open(fnamecmp
, O_RDONLY
, 0)) < 0) {
1862 rsyserr(FERROR
, errno
, "failed to open %s, continuing",
1863 full_fname(fnamecmp
));
1865 /* pretend the file didn't exist */
1866 #ifdef SUPPORT_HARD_LINKS
1867 if (preserve_hard_links
&& F_HLINK_NOT_LAST(file
)) {
1868 cur_flist
->in_progress
++;
1872 statret
= real_ret
= -1;
1876 if (inplace
&& make_backups
> 0 && fnamecmp_type
== FNAMECMP_FNAME
) {
1877 if (!(backupptr
= get_backup_name(fname
))) {
1881 if (!(back_file
= make_file(fname
, NULL
, NULL
, 0, NO_FILTERS
))) {
1883 goto pretend_missing
;
1885 if (robust_unlink(backupptr
) && errno
!= ENOENT
) {
1886 rsyserr(FERROR_XFER
, errno
, "unlink %s",
1887 full_fname(backupptr
));
1888 unmake_file(back_file
);
1893 if ((f_copy
= do_open(backupptr
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_EXCL
, 0600)) < 0) {
1894 rsyserr(FERROR_XFER
, errno
, "open %s", full_fname(backupptr
));
1895 unmake_file(back_file
);
1900 fnamecmp_type
= FNAMECMP_BACKUP
;
1903 if (DEBUG_GTE(DELTASUM
, 3)) {
1904 rprintf(FINFO
, "gen mapped %s of size %s\n",
1905 fnamecmp
, big_num(sx
.st
.st_size
));
1908 if (DEBUG_GTE(DELTASUM
, 2))
1909 rprintf(FINFO
, "generating and sending sums for %d\n", ndx
);
1912 if (remove_source_files
&& !delay_updates
&& !phase
&& !dry_run
)
1913 increment_active_files(ndx
, itemizing
, code
);
1914 if (inc_recurse
&& (!dry_run
|| write_batch
< 0))
1915 cur_flist
->in_progress
++;
1916 #ifdef SUPPORT_HARD_LINKS
1917 if (preserve_hard_links
&& F_IS_HLINKED(file
))
1918 file
->flags
|= FLAG_FILE_SENT
;
1920 write_ndx(f_out
, ndx
);
1922 int iflags
= ITEM_TRANSFER
;
1923 if (always_checksum
> 0)
1924 iflags
|= ITEM_REPORT_CHANGE
;
1925 if (fnamecmp_type
!= FNAMECMP_FNAME
)
1926 iflags
|= ITEM_BASIS_TYPE_FOLLOWS
;
1927 if (fnamecmp_type
>= FNAMECMP_FUZZY
)
1928 iflags
|= ITEM_XNAME_FOLLOWS
;
1929 itemize(fnamecmp
, file
, -1, real_ret
, &real_sx
, iflags
, fnamecmp_type
,
1930 fuzzy_file
? fuzzy_file
->basename
: NULL
);
1931 free_stat_x(&real_sx
);
1935 #ifdef SUPPORT_HARD_LINKS
1936 if (preserve_hard_links
&& F_IS_HLINKED(file
))
1937 finish_hard_link(file
, fname
, ndx
, &sx
.st
, itemizing
, code
, -1);
1944 if (statret
!= 0 || whole_file
)
1945 write_sum_head(f_out
, NULL
);
1946 else if (sx
.st
.st_size
<= 0) {
1947 write_sum_head(f_out
, NULL
);
1950 if (generate_and_send_sums(fd
, sx
.st
.st_size
, f_out
, f_copy
) < 0) {
1952 "WARNING: file is too large for checksum sending: %s\n",
1954 write_sum_head(f_out
, NULL
);
1961 int save_preserve_xattrs
= preserve_xattrs
;
1964 #ifdef SUPPORT_XATTRS
1965 if (preserve_xattrs
) {
1966 copy_xattrs(fname
, backupptr
);
1967 preserve_xattrs
= 0;
1970 set_file_attrs(backupptr
, back_file
, NULL
, NULL
, 0);
1971 preserve_xattrs
= save_preserve_xattrs
;
1972 if (INFO_GTE(BACKUP
, 1)) {
1973 rprintf(FINFO
, "backed up %s to %s\n",
1976 unmake_file(back_file
);
1982 /* If we are replacing an existing hard link, symlink, device, or special file,
1983 * create a temp-name item and rename it into place. A symlimk specifies slnk,
1984 * a hard link specifies hlnk, otherwise we create a device based on rdev.
1985 * Specify 0 for the del_for_flag if there is not a file to replace. This
1986 * returns 1 on success and 0 on failure. */
1987 int atomic_create(struct file_struct
*file
, char *fname
, const char *slnk
, const char *hlnk
,
1988 dev_t rdev
, stat_x
*sxp
, int del_for_flag
)
1990 char tmpname
[MAXPATHLEN
];
1991 const char *create_name
;
1992 int skip_atomic
, dir_in_the_way
= del_for_flag
&& S_ISDIR(sxp
->st
.st_mode
);
1994 if (!del_for_flag
|| dir_in_the_way
|| tmpdir
|| !get_tmpname(tmpname
, fname
, True
))
2000 if (make_backups
> 0 && !dir_in_the_way
) {
2001 if (!make_backup(fname
, skip_atomic
))
2003 } else if (skip_atomic
) {
2004 int del_opts
= delete_mode
|| force_delete
? DEL_RECURSE
: 0;
2005 if (delete_item(fname
, sxp
->st
.st_mode
, del_opts
| del_for_flag
) != 0)
2010 create_name
= skip_atomic
? fname
: tmpname
;
2013 #ifdef SUPPORT_LINKS
2014 if (do_symlink(slnk
, create_name
) < 0) {
2015 rsyserr(FERROR_XFER
, errno
, "symlink %s -> \"%s\" failed",
2016 full_fname(create_name
), slnk
);
2023 #ifdef SUPPORT_HARD_LINKS
2024 if (!hard_link_one(file
, create_name
, hlnk
, 0))
2030 if (do_mknod(create_name
, file
->mode
, rdev
) < 0) {
2031 rsyserr(FERROR_XFER
, errno
, "mknod %s failed",
2032 full_fname(create_name
));
2038 if (do_rename(tmpname
, fname
) < 0) {
2039 rsyserr(FERROR_XFER
, errno
, "rename %s -> \"%s\" failed",
2040 full_fname(tmpname
), full_fname(fname
));
2049 #ifdef SUPPORT_HARD_LINKS
2050 static void handle_skipped_hlink(struct file_struct
*file
, int itemizing
,
2051 enum logcode code
, int f_out
)
2053 char fbuf
[MAXPATHLEN
];
2055 struct file_list
*save_flist
= cur_flist
;
2057 /* If we skip the last item in a chain of links and there was a
2058 * prior non-skipped hard-link waiting to finish, finish it now. */
2059 if ((new_last_ndx
= skip_hard_link(file
, &cur_flist
)) < 0)
2062 file
= cur_flist
->files
[new_last_ndx
- cur_flist
->ndx_start
];
2063 cur_flist
->in_progress
--; /* undo prior increment */
2065 recv_generator(fbuf
, file
, new_last_ndx
, itemizing
, code
, f_out
);
2067 cur_flist
= save_flist
;
2071 static void touch_up_dirs(struct file_list
*flist
, int ndx
)
2073 static int counter
= 0;
2074 struct file_struct
*file
;
2081 end
= flist
->used
- 1;
2085 /* Fix any directory permissions that were modified during the
2086 * transfer and/or re-set any tweaked modified-time values. */
2087 for (i
= start
; i
<= end
; i
++, counter
++) {
2088 file
= flist
->files
[i
];
2089 if (!F_IS_ACTIVE(file
))
2091 if (!S_ISDIR(file
->mode
)
2092 || (!implied_dirs
&& file
->flags
& FLAG_IMPLIED_DIR
))
2094 if (DEBUG_GTE(TIME
, 2)) {
2095 fname
= f_name(file
, NULL
);
2096 rprintf(FINFO
, "touch_up_dirs: %s (%d)\n",
2099 /* Be sure not to retouch permissions with --fake-super. */
2100 fix_dir_perms
= !am_root
&& !(file
->mode
& S_IWUSR
);
2101 if (file
->flags
& FLAG_MISSING_DIR
|| !(need_retouch_dir_times
|| fix_dir_perms
))
2103 fname
= f_name(file
, NULL
);
2105 do_chmod(fname
, file
->mode
);
2106 if (need_retouch_dir_times
) {
2108 if (link_stat(fname
, &st
, 0) == 0 && mtime_differs(&st
, file
)) {
2109 st
.st_mtime
= file
->modtime
;
2110 #ifdef ST_MTIME_NSEC
2111 st
.ST_MTIME_NSEC
= F_MOD_NSEC_or_0(file
);
2113 set_times(fname
, &st
);
2116 if (counter
>= loopchk_limit
) {
2118 maybe_send_keepalive(time(NULL
), MSK_ALLOW_FLUSH
);
2120 maybe_flush_socket(0);
2126 void check_for_finished_files(int itemizing
, enum logcode code
, int check_redo
)
2128 struct file_struct
*file
;
2129 struct file_list
*flist
;
2130 char fbuf
[MAXPATHLEN
];
2134 #ifdef SUPPORT_HARD_LINKS
2135 if (preserve_hard_links
&& (ndx
= get_hlink_num()) != -1) {
2136 int send_failed
= (ndx
== -2);
2138 ndx
= get_hlink_num();
2139 flist
= flist_for_ndx(ndx
, "check_for_finished_files.1");
2140 file
= flist
->files
[ndx
- flist
->ndx_start
];
2141 assert(file
->flags
& FLAG_HLINKED
);
2143 handle_skipped_hlink(file
, itemizing
, code
, sock_f_out
);
2145 finish_hard_link(file
, f_name(file
, fbuf
), ndx
, NULL
, itemizing
, code
, -1);
2146 flist
->in_progress
--;
2151 if (check_redo
&& (ndx
= get_redo_num()) != -1) {
2152 OFF_T save_max_size
= max_size
;
2153 OFF_T save_min_size
= min_size
;
2154 csum_length
= SUM_LENGTH
;
2157 ignore_existing
= -ignore_existing
;
2158 ignore_non_existing
= -ignore_non_existing
;
2159 update_only
= -update_only
;
2160 always_checksum
= -always_checksum
;
2161 size_only
= -size_only
;
2162 append_mode
= -append_mode
;
2163 make_backups
= -make_backups
; /* avoid dup backup w/inplace */
2167 cur_flist
= flist_for_ndx(ndx
, "check_for_finished_files.2");
2169 file
= cur_flist
->files
[ndx
- cur_flist
->ndx_start
];
2171 strlcpy(fbuf
, solo_file
, sizeof fbuf
);
2174 recv_generator(fbuf
, file
, ndx
, itemizing
, code
, sock_f_out
);
2175 cur_flist
->to_redo
--;
2179 csum_length
= SHORT_SUM_LENGTH
;
2180 max_size
= save_max_size
;
2181 min_size
= save_min_size
;
2182 ignore_existing
= -ignore_existing
;
2183 ignore_non_existing
= -ignore_non_existing
;
2184 update_only
= -update_only
;
2185 always_checksum
= -always_checksum
;
2186 size_only
= -size_only
;
2187 append_mode
= -append_mode
;
2188 make_backups
= -make_backups
;
2193 if (cur_flist
== first_flist
)
2196 /* We only get here if inc_recurse is enabled. */
2197 if (first_flist
->in_progress
|| first_flist
->to_redo
)
2200 write_ndx(sock_f_out
, NDX_DONE
);
2201 if (!read_batch
&& !flist_eof
) {
2203 for (flist
= first_flist
; flist
!= cur_flist
; flist
= flist
->next
)
2204 old_total
+= flist
->used
;
2205 maybe_flush_socket(!flist_eof
&& file_total
- old_total
< MIN_FILECNT_LOOKAHEAD
/2);
2208 if (delete_during
== 2 || !dir_tweaking
) {
2209 /* Skip directory touch-up. */
2210 } else if (first_flist
->parent_ndx
>= 0)
2211 touch_up_dirs(dir_flist
, first_flist
->parent_ndx
);
2213 flist_free(first_flist
); /* updates first_flist */
2217 void generate_files(int f_out
, const char *local_name
)
2219 int i
, ndx
, next_loopchk
= 0;
2220 char fbuf
[MAXPATHLEN
];
2223 int save_info_flist
= info_levels
[INFO_FLIST
];
2224 int save_info_progress
= info_levels
[INFO_PROGRESS
];
2226 if (protocol_version
>= 29) {
2228 maybe_ATTRS_REPORT
= stdout_format_has_i
? 0 : ATTRS_REPORT
;
2229 code
= logfile_format_has_i
? FNONE
: FLOG
;
2230 } else if (am_daemon
) {
2231 itemizing
= logfile_format_has_i
&& do_xfers
;
2232 maybe_ATTRS_REPORT
= ATTRS_REPORT
;
2233 code
= itemizing
|| !do_xfers
? FCLIENT
: FINFO
;
2234 } else if (!am_server
) {
2235 itemizing
= stdout_format_has_i
;
2236 maybe_ATTRS_REPORT
= stdout_format_has_i
? 0 : ATTRS_REPORT
;
2237 code
= itemizing
? FNONE
: FINFO
;
2240 maybe_ATTRS_REPORT
= ATTRS_REPORT
;
2243 solo_file
= local_name
;
2244 dir_tweaking
= !(list_only
|| solo_file
|| dry_run
);
2245 need_retouch_dir_times
= preserve_mtimes
&& !omit_dir_times
;
2246 loopchk_limit
= allowed_lull
? allowed_lull
* 5 : 200;
2247 symlink_timeset_failed_flags
= ITEM_REPORT_TIME
2248 | (protocol_version
>= 30 || !am_server
? ITEM_REPORT_TIMEFAIL
: 0);
2249 implied_dirs_are_missing
= relative_paths
&& !implied_dirs
&& protocol_version
< 30;
2251 if (DEBUG_GTE(GENR
, 1))
2252 rprintf(FINFO
, "generator starting pid=%d\n", (int)getpid());
2254 if (delete_before
&& !solo_file
&& cur_flist
->used
> 0)
2256 if (delete_during
== 2) {
2257 deldelay_size
= BIGPATHBUFLEN
* 4;
2258 deldelay_buf
= new_array(char, deldelay_size
);
2260 info_levels
[INFO_FLIST
] = info_levels
[INFO_PROGRESS
] = 0;
2262 if (append_mode
> 0 || whole_file
< 0)
2264 if (DEBUG_GTE(FLIST
, 1)) {
2265 rprintf(FINFO
, "delta-transmission %s\n",
2267 ? "disabled for local transfer or --whole-file"
2271 dflt_perms
= (ACCESSPERMS
& ~orig_umask
);
2274 #ifdef SUPPORT_HARD_LINKS
2275 if (preserve_hard_links
&& inc_recurse
) {
2276 while (!flist_eof
&& file_total
< MIN_FILECNT_LOOKAHEAD
/2)
2277 wait_for_receiver();
2281 if (inc_recurse
&& cur_flist
->parent_ndx
>= 0) {
2282 struct file_struct
*fp
= dir_flist
->files
[cur_flist
->parent_ndx
];
2284 strlcpy(fbuf
, solo_file
, sizeof fbuf
);
2287 ndx
= cur_flist
->ndx_start
- 1;
2288 recv_generator(fbuf
, fp
, ndx
, itemizing
, code
, f_out
);
2289 if (delete_during
&& dry_run
< 2 && !list_only
2290 && !(fp
->flags
& FLAG_MISSING_DIR
)) {
2291 if (fp
->flags
& FLAG_CONTENT_DIR
) {
2293 if (one_file_system
) {
2294 uint32
*devp
= F_DIR_DEV_P(fp
);
2295 dirdev
= MAKEDEV(DEV_MAJOR(devp
), DEV_MINOR(devp
));
2297 dirdev
= MAKEDEV(0, 0);
2298 delete_in_dir(fbuf
, fp
, dirdev
);
2300 change_local_filter_dir(fbuf
, strlen(fbuf
), F_DEPTH(fp
));
2303 for (i
= cur_flist
->low
; i
<= cur_flist
->high
; i
++) {
2304 struct file_struct
*file
= cur_flist
->sorted
[i
];
2306 if (!F_IS_ACTIVE(file
))
2312 ndx
= i
+ cur_flist
->ndx_start
;
2315 strlcpy(fbuf
, solo_file
, sizeof fbuf
);
2318 recv_generator(fbuf
, file
, ndx
, itemizing
, code
, f_out
);
2320 check_for_finished_files(itemizing
, code
, 0);
2322 if (i
+ cur_flist
->ndx_start
>= next_loopchk
) {
2324 maybe_send_keepalive(time(NULL
), MSK_ALLOW_FLUSH
);
2326 maybe_flush_socket(0);
2327 next_loopchk
+= loopchk_limit
;
2332 write_ndx(f_out
, NDX_DONE
);
2337 check_for_finished_files(itemizing
, code
, 1);
2338 if (cur_flist
->next
|| flist_eof
)
2340 wait_for_receiver();
2342 } while ((cur_flist
= cur_flist
->next
) != NULL
);
2345 delete_in_dir(NULL
, NULL
, dev_zero
);
2347 if (DEBUG_GTE(GENR
, 1))
2348 rprintf(FINFO
, "generate_files phase=%d\n", phase
);
2351 check_for_finished_files(itemizing
, code
, 1);
2354 wait_for_receiver();
2358 if (DEBUG_GTE(GENR
, 1))
2359 rprintf(FINFO
, "generate_files phase=%d\n", phase
);
2361 write_ndx(f_out
, NDX_DONE
);
2363 /* Reduce round-trip lag-time for a useless delay-updates phase. */
2364 if (protocol_version
>= 29 && EARLY_DELAY_DONE_MSG())
2365 write_ndx(f_out
, NDX_DONE
);
2367 if (protocol_version
>= 31 && EARLY_DELETE_DONE_MSG()) {
2368 if ((INFO_GTE(STATS
, 2) && (delete_mode
|| force_delete
)) || read_batch
)
2369 write_del_stats(f_out
);
2370 if (EARLY_DELAY_DONE_MSG()) /* Can't send this before delay */
2371 write_ndx(f_out
, NDX_DONE
);
2374 /* Read MSG_DONE for the redo phase (and any prior messages). */
2376 check_for_finished_files(itemizing
, code
, 0);
2377 if (msgdone_cnt
> 1)
2379 wait_for_receiver();
2382 if (protocol_version
>= 29) {
2384 if (DEBUG_GTE(GENR
, 1))
2385 rprintf(FINFO
, "generate_files phase=%d\n", phase
);
2386 if (!EARLY_DELAY_DONE_MSG()) {
2387 write_ndx(f_out
, NDX_DONE
);
2388 if (protocol_version
>= 31 && EARLY_DELETE_DONE_MSG())
2389 write_ndx(f_out
, NDX_DONE
);
2391 /* Read MSG_DONE for delay-updates phase & prior messages. */
2392 while (msgdone_cnt
== 2)
2393 wait_for_receiver();
2396 info_levels
[INFO_FLIST
] = save_info_flist
;
2397 info_levels
[INFO_PROGRESS
] = save_info_progress
;
2399 if (delete_during
== 2)
2400 do_delayed_deletions(fbuf
);
2401 if (delete_after
&& !solo_file
&& file_total
> 0)
2404 if (max_delete
>= 0 && skipped_deletes
) {
2406 "Deletions stopped due to --max-delete limit (%d skipped)\n",
2408 io_error
|= IOERR_DEL_LIMIT
;
2411 if (protocol_version
>= 31) {
2412 if (!EARLY_DELETE_DONE_MSG()) {
2413 if (INFO_GTE(STATS
, 2) || read_batch
)
2414 write_del_stats(f_out
);
2415 write_ndx(f_out
, NDX_DONE
);
2418 /* Read MSG_DONE for late-delete phase & prior messages. */
2419 while (msgdone_cnt
== 3)
2420 wait_for_receiver();
2423 if ((need_retouch_dir_perms
|| need_retouch_dir_times
)
2424 && dir_tweaking
&& (!inc_recurse
|| delete_during
== 2))
2425 touch_up_dirs(dir_flist
, -1);
2427 if (DEBUG_GTE(GENR
, 1))
2428 rprintf(FINFO
, "generate_files finished\n");