#include "rsync.h"

#include "inums.h"

#include "ifuncs.h"

extern int dry_run;

extern int do_xfers;

extern int stdout_format_has_i;

extern int logfile_format_has_i;

extern int am_root;

extern int operator_path_resolve;

extern int am_server;

extern int am_daemon;

extern int inc_recurse;

extern int relative_paths;

extern int implied_dirs;

extern int keep_dirlinks;

extern int write_devices;

extern int preserve_acls;

extern int preserve_xattrs;

extern int preserve_links;

extern int preserve_devices;

extern int preserve_specials;

extern int drop_devices;

extern int preserve_hard_links;

extern int preserve_executability;

extern int preserve_perms;

extern int preserve_mtimes;

extern int omit_dir_times;

extern int omit_link_times;

extern int delete_mode;

extern int delete_before;

extern int delete_during;

extern int delete_after;

extern int missing_args;

extern int msgdone_cnt;

extern int ignore_errors;

extern int remove_source_files;

extern int delay_updates;

extern int delay_symlinks;

extern int update_only;

extern int human_readable;

extern int ignore_existing;

extern int ignore_non_existing;

extern int want_xattr_optim;

extern int modify_window;

extern int inplace;

extern int append_mode;

extern int make_backups;

extern int csum_length;

extern int xfer_sum_len;

extern int ignore_times;

extern int size_only;

extern OFF_T max_size;

extern OFF_T min_size;

extern int io_error;

extern int flist_eof;

extern int allowed_lull;

extern int sock_f_out;

extern int protocol_version;

extern int file_total;

extern int fuzzy_basis;

extern int always_checksum;

extern int flist_csum_len;

extern char *partial_dir;

extern int alt_dest_type;

extern int whole_file;

extern int list_only;

extern int read_batch;

extern int write_batch;

extern int safe_symlinks;

extern int32 block_size;

extern int unsort_ndx;

extern int max_delete;

extern int force_delete;

extern int one_file_system;

extern int skipped_deletes;

extern dev_t filesystem_dev;

extern mode_t orig_umask;

extern uid_t our_uid;

extern char *tmpdir;

extern char *basis_dir[MAX_BASIS_DIRS+1];

extern struct file_list *cur_flist, *first_flist, *dir_flist;

extern filter_rule_list filter_list, daemon_filter_list;

int maybe_ATTRS_REPORT = 0;

int maybe_ATTRS_ACCURATE_TIME = 0;

static dev_t dev_zero;

static int deldelay_size = 0, deldelay_cnt = 0;

static char *deldelay_buf = NULL;

static int deldelay_fd = -1;

static int loopchk_limit;

static int dir_tweaking;

static int symlink_timeset_failed_flags;

static int need_retouch_dir_times;

static int need_retouch_dir_perms;

static const char *solo_file = NULL;

struct deferred_symlink {

};

static int defer_symlinks;

static item_list deferred_symlinks = EMPTY_ITEM_LIST;

#ifdef SUPPORT_LINKS

static void defer_symlink(struct file_struct *file, int ndx, const char *fname,

int itemizing, enum logcode code)

{

struct deferred_symlink *ds

= EXPAND_ITEM_LIST(&deferred_symlinks, struct deferred_symlink, 100);

ds->file = file;

ds->ndx = ndx;

if (!(ds->fname = strdup(fname)))

out_of_memory("defer_symlink");

ds->itemizing = itemizing;

ds->code = code;

}

#ifdef SUPPORT_HARD_LINKS

static void handle_skipped_hlink(struct file_struct *file, int itemizing,

enum logcode code, int f_out);

#define EARLY_DELAY_DONE_MSG() (!delay_updates && !defer_symlinks)

#define EARLY_DELETE_DONE_MSG() \

(!(delete_during == 2 || delete_after || defer_symlinks))

static int start_delete_delay_temp(void)

{

char fnametmp[MAXPATHLEN];

int save_dry_run = dry_run;

dry_run = 0;

if (!get_tmpname(fnametmp, "deldelay", False)

|| (deldelay_fd = do_mkstemp(fnametmp, 0600)) < 0) {

rprintf(FINFO, "NOTE: Unable to create delete-delay temp file%s.\n",

inc_recurse ? "" : " -- switching to --delete-after");

delete_during = 0;

delete_after = !inc_recurse;

dry_run = save_dry_run;

return 0;

}

unlink(fnametmp);

dry_run = save_dry_run;

return 1;

}

static int flush_delete_delay(void)

{

if (deldelay_fd < 0 && !start_delete_delay_temp())

return 0;

if (write(deldelay_fd, deldelay_buf, deldelay_cnt) != deldelay_cnt) {

rsyserr(FERROR, errno, "flush of delete-delay buffer");

delete_during = 0;

delete_after = !inc_recurse;

close(deldelay_fd);

return 0;

}

deldelay_cnt = 0;

return 1;

}

static int remember_delete(struct file_struct *file, const char *fname, int flags)

{

int len;

if (deldelay_cnt == deldelay_size && !flush_delete_delay())

return 0;

if (flags & DEL_NO_UID_WRITE)

deldelay_buf[deldelay_cnt++] = '!';

while (1) {

len = snprintf(deldelay_buf + deldelay_cnt, deldelay_size - deldelay_cnt,

"%x %s%c", (int)file->mode, fname, '\0');

if ((deldelay_cnt += len) <= deldelay_size)

break;

deldelay_cnt -= len;

if (!flush_delete_delay())

return 0;

}

return 1;

}

static int read_delay_line(char *buf, int *flags_p)

{

static int read_pos = 0;

unsigned int mode;

int j, len;

char *bp, *past_space;

while (1) {

for (j = read_pos; j < deldelay_cnt && deldelay_buf[j]; j++) {}

if (j < deldelay_cnt)

break;

if (deldelay_fd < 0) {

if (j > read_pos)

goto invalid_data;

return -1;

}

deldelay_cnt -= read_pos;

if (deldelay_cnt == deldelay_size)

goto invalid_data;

if (deldelay_cnt && read_pos) {

memmove(deldelay_buf, deldelay_buf + read_pos,

deldelay_cnt);

}

len = read(deldelay_fd, deldelay_buf + deldelay_cnt,

deldelay_size - deldelay_cnt);

if (len == 0) {

if (deldelay_cnt) {

rprintf(FERROR, "ERROR: unexpected EOF in delete-delay file.\n");

}

return -1;

}

if (len < 0) {

rsyserr(FERROR, errno,

"reading delete-delay file");

return -1;

}

deldelay_cnt += len;

read_pos = 0;

}

bp = deldelay_buf + read_pos;

if (*bp == '!') {

bp++;

*flags_p = DEL_NO_UID_WRITE;

} else

*flags_p = 0;

if (sscanf(bp, "%x ", &mode) != 1) {

goto invalid_data;

}

past_space = strchr(bp, ' ');

if (!past_space) {

goto invalid_data;

}

past_space++;

/* Name length + NUL. Computed from past_space directly: the old

len = (deldelay_buf + j) - past_space + 1;

read_pos = j + 1;

if (len > MAXPATHLEN) {

rprintf(FERROR, "ERROR: filename too long in delete-delay file.\n");

return -1;

}

/* The caller needs the name in a MAXPATHLEN buffer, so we copy it

memcpy(buf, past_space, len);

return mode;

invalid_data:

rprintf(FERROR, "ERROR: invalid data in delete-delay file.\n");

return -1;

}

static void do_delayed_deletions(char *delbuf)

{

int mode, flags;

if (deldelay_fd >= 0) {

if (deldelay_cnt && !flush_delete_delay())

return;

lseek(deldelay_fd, 0, 0);

}

while ((mode = read_delay_line(delbuf, &flags)) >= 0)

delete_item(delbuf, mode, flags | DEL_RECURSE);

if (deldelay_fd >= 0)

close(deldelay_fd);

}

static void delete_in_dir(char *fbuf, struct file_struct *file, dev_t fs_dev)

{

static int already_warned = 0;

static struct hashtable *dev_tbl;

struct file_list *dirlist;

char delbuf[MAXPATHLEN];

int dlen, i;

if (!fbuf) {

change_local_filter_dir(NULL, 0, 0);

return;

}

if (DEBUG_GTE(DEL, 2))

rprintf(FINFO, "delete_in_dir(%s)\n", fbuf);

if (allowed_lull)

maybe_send_keepalive(time(NULL), MSK_ALLOW_FLUSH);

if (io_error & IOERR_GENERAL && !ignore_errors) {

if (already_warned)

return;

rprintf(FINFO,

"IO error encountered -- skipping file deletion\n");

already_warned = 1;

return;

}

dlen = strlen(fbuf);

change_local_filter_dir(fbuf, dlen, F_DEPTH(file));

if (one_file_system) {

if (!dev_tbl)

dev_tbl = hashtable_create(16, HT_KEY64);

if (file->flags & FLAG_TOP_DIR) {

hashtable_find(dev_tbl, fs_dev+1, "");

filesystem_dev = fs_dev;

} else if (filesystem_dev != fs_dev) {

if (!hashtable_find(dev_tbl, fs_dev+1, NULL))

return;

filesystem_dev = fs_dev; /* it's a prior top-dir dev */

}

}

dirlist = get_dirlist(fbuf, dlen, 0);

/* If an item in dirlist is not found in flist, delete it

for (i = dirlist->used; i--; ) {

struct file_struct *fp = dirlist->files[i];

if (!F_IS_ACTIVE(fp))

continue;

if (fp->flags & FLAG_MOUNT_DIR && S_ISDIR(fp->mode)) {

if (INFO_GTE(MOUNT, 1))

rprintf(FINFO, "cannot delete mount point: %s\n",

f_name(fp, NULL));

continue;

}

/* Here we want to match regardless of file type. Replacement

if (flist_find_ignore_dirness(cur_flist, fp) < 0) {

int flags = DEL_RECURSE;

if (!(fp->mode & S_IWUSR) && !am_root && fp->flags & FLAG_OWNED_BY_US)

flags |= DEL_NO_UID_WRITE;

f_name(fp, delbuf);

if (delete_during == 2) {

if (!remember_delete(fp, delbuf, flags))

break;

} else

delete_item(delbuf, fp->mode, flags);

}

}

flist_free(dirlist);

}

static void do_delete_pass(void)

{

char fbuf[MAXPATHLEN];

STRUCT_STAT st;

int j;

/* dry_run is incremented when the destination doesn't exist yet. */

if (dry_run > 1 || list_only)

return;

for (j = 0; j < cur_flist->used; j++) {

struct file_struct *file = cur_flist->sorted[j];

if (!F_IS_ACTIVE(file))

continue;

f_name(file, fbuf);

if (!(file->flags & FLAG_CONTENT_DIR)) {

change_local_filter_dir(fbuf, strlen(fbuf), F_DEPTH(file));

continue;

}

if (DEBUG_GTE(DEL, 1) && file->flags & FLAG_TOP_DIR)

rprintf(FINFO, "deleting in %s\n", fbuf);

if (link_stat(fbuf, &st, keep_dirlinks) < 0

|| !S_ISDIR(st.st_mode))

continue;

delete_in_dir(fbuf, file, st.st_dev);

}

delete_in_dir(NULL, NULL, dev_zero);

if (INFO_GTE(FLIST, 2) && !am_server) {

rprintf(FINFO, " ");

rput_progress();

}

}

static inline int mtime_differs(STRUCT_STAT *stp, struct file_struct *file)

{

#ifdef ST_MTIME_NSEC

return !same_time(stp->st_mtime, stp->ST_MTIME_NSEC, file->modtime, F_MOD_NSEC_or_0(file));

return !same_time(stp->st_mtime, 0, file->modtime, 0);

}

static inline int any_time_differs(stat_x *sxp, struct file_struct *file, UNUSED(const char *fname))

{

int differs = mtime_differs(&sxp->st, file);

#ifdef SUPPORT_CRTIMES

if (!differs && crtimes_ndx) {

if (sxp->crtime == 0)

sxp->crtime = get_create_time(fname, &sxp->st);

differs = !same_time(sxp->crtime, 0, F_CRTIME(file), 0);

}

return differs;

}

static inline int perms_differ(struct file_struct *file, stat_x *sxp)

{

if (preserve_perms)

return !BITS_EQUAL(sxp->st.st_mode, file->mode, CHMOD_BITS);

if (preserve_executability)

return (sxp->st.st_mode & 0111 ? 1 : 0) ^ (file->mode & 0111 ? 1 : 0);

return 0;

}

static inline int ownership_differs(struct file_struct *file, stat_x *sxp)

{

if (am_root && uid_ndx && sxp->st.st_uid != (uid_t)F_OWNER(file))

return 1;

if (gid_ndx && !(file->flags & FLAG_SKIP_GROUP) && sxp->st.st_gid != (gid_t)F_GROUP(file))

return 1;

return 0;

}

#ifdef SUPPORT_ACLS

static inline int acls_differ(const char *fname, struct file_struct *file, stat_x *sxp)

{

if (preserve_acls) {

if (!ACL_READY(*sxp))

get_acl(fname, sxp);

if (set_acl(NULL, file, sxp, file->mode))

return 1;

}

return 0;

}

#ifdef SUPPORT_XATTRS

static inline int xattrs_differ(const char *fname, struct file_struct *file, stat_x *sxp)

{

if (preserve_xattrs) {

if (!XATTR_READY(*sxp))

get_xattr(fname, -1, sxp);

if (xattr_diff(file, sxp, 0))

return 1;

}

return 0;

}

int unchanged_attrs(const char *fname, struct file_struct *file, stat_x *sxp)

{

if (S_ISLNK(file->mode)) {

#ifdef CAN_SET_SYMLINK_TIMES

if (preserve_mtimes && !omit_link_times && any_time_differs(sxp, file, fname))

return 0;

#ifdef CAN_CHMOD_SYMLINK

if (perms_differ(file, sxp))

return 0;

#ifdef CAN_CHOWN_SYMLINK

if (ownership_differs(file, sxp))

return 0;

#if defined SUPPORT_ACLS && 0 /* no current symlink-ACL support */

if (acls_differ(fname, file, sxp))

return 0;

#if defined SUPPORT_XATTRS && !defined NO_SYMLINK_XATTRS

if (xattrs_differ(fname, file, sxp))

return 0;

} else {

if (preserve_mtimes && any_time_differs(sxp, file, fname))

return 0;

if (perms_differ(file, sxp))

return 0;

if (ownership_differs(file, sxp))

return 0;

#ifdef SUPPORT_ACLS

if (acls_differ(fname, file, sxp))

return 0;

#ifdef SUPPORT_XATTRS

if (xattrs_differ(fname, file, sxp))

return 0;

}

return 1;

}

void itemize(const char *fnamecmp, struct file_struct *file, int ndx, int statret,

stat_x *sxp, int32 iflags, uchar fnamecmp_type,

const char *xname)

{

if (statret >= 0) { /* A from-dest-dir statret can == 1! */

int keep_time = !preserve_mtimes ? 0

: S_ISDIR(file->mode) ? !omit_dir_times

: S_ISLNK(file->mode) ? !omit_link_times

: 1;

if (S_ISREG(file->mode) && F_LENGTH(file) != sxp->st.st_size)

iflags |= ITEM_REPORT_SIZE;

if (file->flags & FLAG_TIME_FAILED) { /* symlinks only */

if (iflags & ITEM_LOCAL_CHANGE)

iflags |= symlink_timeset_failed_flags;

} else if (keep_time

? mtime_differs(&sxp->st, file)

: iflags & (ITEM_TRANSFER|ITEM_LOCAL_CHANGE) && !(iflags & ITEM_MATCHED)

&& (!(iflags & ITEM_XNAME_FOLLOWS) || *xname))

iflags |= ITEM_REPORT_TIME;

if (atimes_ndx && !S_ISDIR(file->mode) && !S_ISLNK(file->mode)

&& !same_time(F_ATIME(file), 0, sxp->st.st_atime, 0))

iflags |= ITEM_REPORT_ATIME;

#ifdef SUPPORT_CRTIMES

if (crtimes_ndx) {

if (sxp->crtime == 0)

sxp->crtime = get_create_time(fnamecmp, &sxp->st);

if (!same_time(sxp->crtime, 0, F_CRTIME(file), 0))

iflags |= ITEM_REPORT_CRTIME;

}

#ifndef CAN_CHMOD_SYMLINK

if (S_ISLNK(file->mode)) {

;

} else

if (preserve_perms) {

if (!BITS_EQUAL(sxp->st.st_mode, file->mode, CHMOD_BITS))

iflags |= ITEM_REPORT_PERMS;

} else if (preserve_executability

&& ((sxp->st.st_mode & 0111 ? 1 : 0) ^ (file->mode & 0111 ? 1 : 0)))

iflags |= ITEM_REPORT_PERMS;

if (uid_ndx && am_root && (uid_t)F_OWNER(file) != sxp->st.st_uid)

iflags |= ITEM_REPORT_OWNER;

if (gid_ndx && !(file->flags & FLAG_SKIP_GROUP) && sxp->st.st_gid != (gid_t)F_GROUP(file))

iflags |= ITEM_REPORT_GROUP;

#ifdef SUPPORT_ACLS

if (preserve_acls && !S_ISLNK(file->mode)) {

if (!ACL_READY(*sxp))

get_acl(fnamecmp, sxp);

if (set_acl(NULL, file, sxp, file->mode))

iflags |= ITEM_REPORT_ACL;

}

#ifdef SUPPORT_XATTRS

if (preserve_xattrs) {

if (!XATTR_READY(*sxp))

get_xattr(fnamecmp, -1, sxp);

if (xattr_diff(file, sxp, 1))

iflags |= ITEM_REPORT_XATTR;

}

} else {

#ifdef SUPPORT_XATTRS

if (preserve_xattrs && xattr_diff(file, NULL, 1))

iflags |= ITEM_REPORT_XATTR;

iflags |= ITEM_IS_NEW;

}

iflags &= 0xffff;

if ((iflags & (SIGNIFICANT_ITEM_FLAGS|ITEM_REPORT_XATTR) || INFO_GTE(NAME, 2)

|| stdout_format_has_i > 1 || (xname && *xname)) && !read_batch) {

if (protocol_version >= 29) {

if (ndx >= 0)

write_ndx(sock_f_out, ndx);

write_shortint(sock_f_out, iflags);

if (iflags & ITEM_BASIS_TYPE_FOLLOWS)

write_byte(sock_f_out, fnamecmp_type);

if (iflags & ITEM_XNAME_FOLLOWS)

write_vstring(sock_f_out, xname, strlen(xname));

#ifdef SUPPORT_XATTRS

if (preserve_xattrs && do_xfers

&& iflags & (ITEM_REPORT_XATTR|ITEM_TRANSFER)) {

int fd = iflags & ITEM_REPORT_XATTR

&& !(want_xattr_optim && BITS_SET(iflags, ITEM_XNAME_FOLLOWS|ITEM_LOCAL_CHANGE))

? sock_f_out : -1;

send_xattr_request(NULL, file, fd);

}

} else if (ndx >= 0) {

enum logcode code = logfile_format_has_i ? FINFO : FCLIENT;

log_item(code, file, iflags, xname);

}

}

}

static enum filetype get_file_type(mode_t mode)

{

if (S_ISREG(mode))

return FT_REG;

if (S_ISLNK(mode))

return FT_SYMLINK;

if (S_ISDIR(mode))

return FT_DIR;

if (IS_SPECIAL(mode))

return FT_SPECIAL;

if (IS_DEVICE(mode))

return FT_DEVICE;

return FT_UNSUPPORTED;

}

int quick_check_ok(enum filetype ftype, const char *fn, struct file_struct *file, STRUCT_STAT *st)

{

switch (ftype) {

case FT_REG:

if (st->st_size != F_LENGTH(file))

return 0;

/* If always_checksum is set then we use the checksum instead

if (always_checksum > 0) {

char sum[MAX_DIGEST_LEN];

file_checksum(fn, st, sum);

return memcmp(sum, F_SUM(file), flist_csum_len) == 0;

}

if (size_only > 0)

return 1;

if (ignore_times)

return 0;

if (mtime_differs(st, file))

return 0;

break;

case FT_DIR:

break;

case FT_SYMLINK: {

#ifdef SUPPORT_LINKS

char lnk[MAXPATHLEN];

int len = do_readlink(fn, lnk, MAXPATHLEN-1);

if (len <= 0)

return 0;

lnk[len] = '\0';

if (strcmp(lnk, F_SYMLINK(file)) != 0)

return 0;

break;

return -1;

}

case FT_SPECIAL:

if (!BITS_EQUAL(file->mode, st->st_mode, _S_IFMT))

return 0;

break;

case FT_DEVICE: {

uint32 *devp = F_RDEV_P(file);

if (st->st_rdev != MAKEDEV(DEV_MAJOR(devp), DEV_MINOR(devp)))

return 0;

break;

}

case FT_UNSUPPORTED:

return -1;

}

return 1;

}

static void sum_sizes_sqroot(struct sum_struct *sum, int64 len)

{

int32 blength;

int s2length;

/* The strong sum can be no longer than the negotiated checksum digest:

int max_s2length = MIN(SUM_LENGTH, xfer_sum_len);

int64 l;

if (len < 0) {

/* The file length overflowed our int64 var, so we can't process this file. */

sum->count = -1; /* indicate overflow error */

return;

}

if (block_size)

blength = block_size;

else if (len <= BLOCK_SIZE * BLOCK_SIZE)

blength = BLOCK_SIZE;

else {

int32 max_blength = protocol_version < 30 ? OLD_MAX_BLOCK_SIZE : MAX_BLOCK_SIZE;

int32 c;

for (c = 1, l = len; l >>= 2; c <<= 1) {}

if (c < 0 || c >= max_blength)

blength = max_blength;

else {

blength = 0;

do {

blength |= c;

if (len < (int64)blength * blength)

blength &= ~c;

c >>= 1;

} while (c >= 8); /* round to multiple of 8 */

blength = MAX(blength, BLOCK_SIZE);

}

}

if (protocol_version < 27) {

s2length = csum_length;

} else if (csum_length == SUM_LENGTH) {

s2length = max_s2length;

} else {

int32 c;

int b = BLOCKSUM_BIAS;

for (l = len; l >>= 1; b += 2) {}

for (c = blength; (c >>= 1) && b; b--) {}

/* add a bit, subtract rollsum, round up. */

s2length = (b + 1 - 32 + 7) / 8; /* --optimize in compiler-- */

s2length = MAX(s2length, csum_length);

s2length = MIN(s2length, max_s2length);

}

sum->flength = len;

sum->blength = blength;

sum->s2length = s2length;

sum->remainder = (int32)(len % blength);

sum->count = (int32)(l = (len / blength) + (sum->remainder != 0));

if ((int64)sum->count != l)

sum->count = -1;

if (sum->count && DEBUG_GTE(DELTASUM, 2)) {

rprintf(FINFO,

"count=%s rem=%ld blength=%ld s2length=%d flength=%s\n",

big_num(sum->count), (long)sum->remainder, (long)sum->blength,

sum->s2length, big_num(sum->flength));

}

}

static int generate_and_send_sums(int fd, OFF_T len, int f_out, int f_copy)

{

int32 i;

struct map_struct *mapbuf;

struct sum_struct sum;

OFF_T offset = 0;

sum_sizes_sqroot(&sum, len);

if (sum.count < 0)

return -1;

write_sum_head(f_out, &sum);

if (append_mode > 0 && f_copy < 0)

return 0;

if (len > 0)

mapbuf = map_file(fd, len, MAX_MAP_SIZE, sum.blength);

else

mapbuf = NULL;

for (i = 0; i < sum.count; i++) {

int32 n1 = (int32)MIN(len, (OFF_T)sum.blength);

char *map = map_ptr(mapbuf, offset, n1);

char sum2[MAX_DIGEST_LEN];

uint32 sum1;

len -= n1;

offset += n1;

if (f_copy >= 0) {

full_write(f_copy, map, n1);

if (append_mode > 0)

continue;

}

sum1 = get_checksum1(map, n1);

get_checksum2(map, n1, sum2);

if (DEBUG_GTE(DELTASUM, 3)) {

rprintf(FINFO,

"chunk[%s] offset=%s len=%ld sum1=%08lx\n",

big_num(i), big_num(offset - n1), (long)n1,

(unsigned long)sum1);

}

write_int(f_out, sum1);

write_buf(f_out, sum2, sum.s2length);

}

if (mapbuf)

unmap_file(mapbuf);

return 0;

}

static struct file_struct *find_fuzzy(struct file_struct *file, struct file_list *dirlist_array[], uchar *fnamecmp_type_ptr)

{

int fname_len, fname_suf_len;

const char *fname_suf, *fname = file->basename;

uint32 lowest_dist = 25 << 16; /* ignore a distance greater than 25 */

int i, j;

struct file_struct *lowest_fp = NULL;

fname_len = strlen(fname);

fname_suf = find_filename_suffix(fname, fname_len, &fname_suf_len);

/* Try to find an exact size+mtime match first. */

for (i = 0; i < fuzzy_basis; i++) {

struct file_list *dirlist = dirlist_array[i];

if (!dirlist)

continue;

for (j = 0; j < dirlist->used; j++) {

struct file_struct *fp = dirlist->files[j];

if (!F_IS_ACTIVE(fp))

continue;

if (!S_ISREG(fp->mode) || !F_LENGTH(fp) || fp->flags & FLAG_FILE_SENT)

continue;

if (F_LENGTH(fp) == F_LENGTH(file) && same_time(fp->modtime, 0, file->modtime, 0)) {

if (DEBUG_GTE(FUZZY, 2))

rprintf(FINFO, "fuzzy size/modtime match for %s\n", f_name(fp, NULL));

*fnamecmp_type_ptr = FNAMECMP_FUZZY + i;

return fp;

}

}

}

for (i = 0; i < fuzzy_basis; i++) {

struct file_list *dirlist = dirlist_array[i];

if (!dirlist)

continue;

for (j = 0; j < dirlist->used; j++) {

struct file_struct *fp = dirlist->files[j];

const char *suf, *name;

int len, suf_len;

uint32 dist;

if (!F_IS_ACTIVE(fp))

continue;

if (!S_ISREG(fp->mode) || !F_LENGTH(fp) || fp->flags & FLAG_FILE_SENT)

continue;

name = fp->basename;

len = strlen(name);

suf = find_filename_suffix(name, len, &suf_len);

dist = fuzzy_distance(name, len, fname, fname_len, lowest_dist);

/* Add some extra weight to how well the suffixes match unless we've already disqualified

if (dist < 0xFFFF0000U) {

dist += fuzzy_distance(suf, suf_len, fname_suf, fname_suf_len, 0xFFFF0000U) * 10;

}

if (DEBUG_GTE(FUZZY, 2)) {

rprintf(FINFO, "fuzzy distance for %s = %d.%05d\n",

f_name(fp, NULL), (int)(dist>>16), (int)(dist&0xFFFF));

}

if (dist <= lowest_dist) {

lowest_dist = dist;

lowest_fp = fp;

*fnamecmp_type_ptr = FNAMECMP_FUZZY + i;

}

}

}

return lowest_fp;

}

static int copy_altdest_file(const char *src, const char *dest, struct file_struct *file)

{

char buf[MAXPATHLEN];

const char *copy_to, *partialptr;

int save_preserve_xattrs = preserve_xattrs;

int ok, fd_w;

if (inplace) {

/* Let copy_file open the destination in place. */

fd_w = -1;

copy_to = dest;

} else {

fd_w = open_tmpfile(buf, dest, file);

if (fd_w < 0)

return -1;

copy_to = buf;

}

cleanup_set(copy_to, NULL, NULL, -1, -1);

if (copy_file(src, copy_to, fd_w, file->mode) < 0) {

if (INFO_GTE(COPY, 1)) {

rsyserr(FINFO, errno, "copy_file %s => %s",

full_fname(src), copy_to);

}

/* Try to clean up. copy_to's parent components are peer-named

do_unlink_at(copy_to);

cleanup_disable();

return -1;

}

partialptr = partial_dir ? partial_dir_fname(dest) : NULL;

preserve_xattrs = 0; /* xattrs were copied with file */

ok = finish_transfer(dest, copy_to, src, partialptr, file, 1, 0);

preserve_xattrs = save_preserve_xattrs;

cleanup_disable();

return ok ? 0 : -1;

}

static int basis_link_stat(const char *path, STRUCT_STAT *stp)

{