Use 0-length MSG_DATA when MSG_NOOP is not available
[rsync.git] / receiver.c
index abe1f663c7dc2a43085a75cde7e9f0c2cb28ac35..39c5e490dc96f80c9e2b139957b1881b39157027 100644 (file)
-/* -*- c-file-style: "linux" -*-
-
-   Copyright (C) 1996-2000 by Andrew Tridgell
-   Copyright (C) Paul Mackerras 1996
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
+/*
+ * Routines only used by the receiving process.
+ *
+ * Copyright (C) 1996-2000 Andrew Tridgell
+ * Copyright (C) 1996 Paul Mackerras
+ * Copyright (C) 2003-2009 Wayne Davison
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, visit the http://fsf.org website.
+ */
 
 #include "rsync.h"
 
 extern int verbose;
+extern int dry_run;
 extern int do_xfers;
-extern int am_daemon;
 extern int am_server;
 extern int do_progress;
+extern int inc_recurse;
 extern int log_before_transfer;
-extern int log_format_has_i;
-extern int daemon_log_format_has_i;
+extern int stdout_format_has_i;
+extern int logfile_format_has_i;
 extern int csum_length;
 extern int read_batch;
 extern int write_batch;
 extern int batch_gen_fd;
 extern int protocol_version;
 extern int relative_paths;
-extern int keep_dirlinks;
 extern int preserve_hard_links;
 extern int preserve_perms;
-extern int io_error;
+extern int preserve_xattrs;
 extern int basis_dir_cnt;
 extern int make_backups;
 extern int cleanup_got_literal;
-extern int remove_sent_files;
-extern int module_id;
-extern int ignore_errors;
-extern int orig_umask;
+extern int remove_source_files;
+extern int append_mode;
+extern int sparse_files;
 extern int keep_partial;
 extern int checksum_seed;
 extern int inplace;
 extern int delay_updates;
+extern mode_t orig_umask;
 extern struct stats stats;
-extern char *log_format;
 extern char *tmpdir;
 extern char *partial_dir;
 extern char *basis_dir[];
-extern struct file_list *the_file_list;
-extern struct filter_list_struct server_filter_list;
-
-#define SLOT_SIZE      (16*1024)       /* Desired size in bytes */
-#define PER_SLOT_BITS  (SLOT_SIZE * 8) /* Number of bits per slot */
-#define PER_SLOT_INTS  (SLOT_SIZE / 4) /* Number of int32s per slot */
-
-static uint32 **delayed_bits = NULL;
-static int delayed_slot_cnt = 0;
-static int phase = 0;
-
-static void init_delayed_bits(int max_ndx)
-{
-       delayed_slot_cnt = (max_ndx + PER_SLOT_BITS - 1) / PER_SLOT_BITS;
-
-       if (!(delayed_bits = (uint32**)calloc(delayed_slot_cnt, sizeof (uint32*))))
-               out_of_memory("set_delayed_bit");
-}
-
-static void set_delayed_bit(int ndx)
-{
-       int slot = ndx / PER_SLOT_BITS;
-       ndx %= PER_SLOT_BITS;
-
-       if (!delayed_bits[slot]) {
-               if (!(delayed_bits[slot] = (uint32*)calloc(PER_SLOT_INTS, 4)))
-                       out_of_memory("set_delayed_bit");
-       }
-
-       delayed_bits[slot][ndx/32] |= 1u << (ndx % 32);
-}
-
-/* Call this with -1 to start checking from 0.  Returns -1 at the end. */
-static int next_delayed_bit(int after)
-{
-       uint32 bits, mask;
-       int i, ndx = after + 1;
-       int slot = ndx / PER_SLOT_BITS;
-       ndx %= PER_SLOT_BITS;
-
-       mask = (1u << (ndx % 32)) - 1;
-       for (i = ndx / 32; slot < delayed_slot_cnt; slot++, i = mask = 0) {
-               if (!delayed_bits[slot])
-                       continue;
-               for ( ; i < PER_SLOT_INTS; i++, mask = 0) {
-                       if (!(bits = delayed_bits[slot][i] & ~mask))
-                               continue;
-                       /* The xor magic figures out the lowest enabled bit in
-                        * bits, and the switch quickly computes log2(bit). */
-                       switch (bits ^ (bits & (bits-1))) {
-#define LOG2(n) case 1u << n: return slot*PER_SLOT_BITS + i*32 + n
-                           LOG2(0);  LOG2(1);  LOG2(2);  LOG2(3);
-                           LOG2(4);  LOG2(5);  LOG2(6);  LOG2(7);
-                           LOG2(8);  LOG2(9);  LOG2(10); LOG2(11);
-                           LOG2(12); LOG2(13); LOG2(14); LOG2(15);
-                           LOG2(16); LOG2(17); LOG2(18); LOG2(19);
-                           LOG2(20); LOG2(21); LOG2(22); LOG2(23);
-                           LOG2(24); LOG2(25); LOG2(26); LOG2(27);
-                           LOG2(28); LOG2(29); LOG2(30); LOG2(31);
-                       }
-                       return -1; /* impossible... */
-               }
-       }
-
-       return -1;
-}
+extern struct file_list *cur_flist, *first_flist, *dir_flist;
+extern struct filter_list_struct daemon_filter_list;
 
+static struct bitbag *delayed_bits = NULL;
+static int phase = 0, redoing = 0;
+static flist_ndx_list batch_redo_list;
+/* We're either updating the basis file or an identical copy: */
+static int updating_basis_or_equiv;
 
 /*
  * get_tmpname() - create a tmp filename for a given filename
@@ -143,17 +84,15 @@ static int next_delayed_bit(int after)
  *   As long as it's unique, rsync will work.
  */
 
-static int get_tmpname(char *fnametmp, char *fname)
+int get_tmpname(char *fnametmp, const char *fname)
 {
-       char *f;
-       int     length = 0;
-       int     maxname;
+       int maxname, added, length = 0;
+       const char *f;
 
        if (tmpdir) {
                /* Note: this can't overflow, so the return value is safe */
                length = strlcpy(fnametmp, tmpdir, MAXPATHLEN - 2);
                fnametmp[length++] = '/';
-               fnametmp[length] = '\0';        /* always NULL terminated */
        }
 
        if ((f = strrchr(fname, '/')) != NULL) {
@@ -166,32 +105,71 @@ static int get_tmpname(char *fnametmp, char *fname)
        } else
                f = fname;
        fnametmp[length++] = '.';
-       fnametmp[length] = '\0';                /* always NULL terminated */
 
+       /* The maxname value is bufsize, and includes space for the '\0'.
+        * (Note that NAME_MAX get -8 for the leading '.' above.) */
        maxname = MIN(MAXPATHLEN - 7 - length, NAME_MAX - 8);
 
        if (maxname < 1) {
-               rprintf(FERROR, "temporary filename too long: %s\n",
-                       safe_fname(fname));
+               rprintf(FERROR_XFER, "temporary filename too long: %s\n", fname);
                fnametmp[0] = '\0';
                return 0;
        }
 
-       strlcpy(fnametmp + length, f, maxname);
-       strcat(fnametmp + length, ".XXXXXX");
+       added = strlcpy(fnametmp + length, f, maxname);
+       if (added >= maxname)
+               added = maxname - 1;
+       memcpy(fnametmp + length + added, ".XXXXXX", 8);
 
        return 1;
 }
 
+/* Opens a temporary file for writing.
+ * Success: Writes name into fnametmp, returns fd.
+ * Failure: Clobbers fnametmp, returns -1.
+ * Calling cleanup_set() is the caller's job. */
+int open_tmpfile(char *fnametmp, const char *fname, struct file_struct *file)
+{
+       int fd;
+
+       if (!get_tmpname(fnametmp, fname))
+               return -1;
+
+       /* We initially set the perms without the setuid/setgid bits or group
+        * access to ensure that there is no race condition.  They will be
+        * correctly updated after the right owner and group info is set.
+        * (Thanks to snabb@epipe.fi for pointing this out.) */
+       fd = do_mkstemp(fnametmp, file->mode & INITACCESSPERMS);
+
+#if 0
+       /* In most cases parent directories will already exist because their
+        * information should have been previously transferred, but that may
+        * not be the case with -R */
+       if (fd == -1 && relative_paths && errno == ENOENT
+           && create_directory_path(fnametmp) == 0) {
+               /* Get back to name with XXXXXX in it. */
+               get_tmpname(fnametmp, fname);
+               fd = do_mkstemp(fnametmp, file->mode & INITACCESSPERMS);
+       }
+#endif
+
+       if (fd == -1) {
+               rsyserr(FERROR_XFER, errno, "mkstemp %s failed",
+                       full_fname(fnametmp));
+               return -1;
+       }
+
+       return fd;
+}
 
 static int receive_data(int f_in, char *fname_r, int fd_r, OFF_T size_r,
-                       char *fname, int fd, OFF_T total_size)
+                       const char *fname, int fd, OFF_T total_size)
 {
-       static char file_sum1[MD4_SUM_LENGTH];
-       static char file_sum2[MD4_SUM_LENGTH];
+       static char file_sum1[MAX_DIGEST_LEN];
+       static char file_sum2[MAX_DIGEST_LEN];
        struct map_struct *mapbuf;
        struct sum_struct sum;
-       int32 len;
+       int32 len, sum_len;
        OFF_T offset = 0;
        OFF_T offset2;
        char *data;
@@ -205,13 +183,41 @@ static int receive_data(int f_in, char *fname_r, int fd_r, OFF_T size_r,
                mapbuf = map_file(fd_r, size_r, read_size, sum.blength);
                if (verbose > 2) {
                        rprintf(FINFO, "recv mapped %s of size %.0f\n",
-                               safe_fname(fname_r), (double)size_r);
+                               fname_r, (double)size_r);
                }
        } else
                mapbuf = NULL;
 
        sum_init(checksum_seed);
 
+       if (append_mode > 0) {
+               OFF_T j;
+               sum.flength = (OFF_T)sum.count * sum.blength;
+               if (sum.remainder)
+                       sum.flength -= sum.blength - sum.remainder;
+               if (append_mode == 2) {
+                       for (j = CHUNK_SIZE; j < sum.flength; j += CHUNK_SIZE) {
+                               if (do_progress)
+                                       show_progress(offset, total_size);
+                               sum_update(map_ptr(mapbuf, offset, CHUNK_SIZE),
+                                          CHUNK_SIZE);
+                               offset = j;
+                       }
+                       if (offset < sum.flength) {
+                               int32 len = (int32)(sum.flength - offset);
+                               if (do_progress)
+                                       show_progress(offset, total_size);
+                               sum_update(map_ptr(mapbuf, offset, len), len);
+                       }
+               }
+               offset = sum.flength;
+               if (fd != -1 && (j = do_lseek(fd, offset, SEEK_SET)) != offset) {
+                       rsyserr(FERROR_XFER, errno, "lseek of %s returned %.0f, not %.0f",
+                               full_fname(fname), (double)j, (double)offset);
+                       exit_cleanup(RERR_FILEIO);
+               }
+       }
+
        while ((i = recv_token(f_in, &data)) != 0) {
                if (do_progress)
                        show_progress(offset, total_size);
@@ -254,15 +260,17 @@ static int receive_data(int f_in, char *fname_r, int fd_r, OFF_T size_r,
                        sum_update(map, len);
                }
 
-               if (inplace) {
+               if (updating_basis_or_equiv) {
                        if (offset == offset2 && fd != -1) {
+                               OFF_T pos;
                                if (flush_write_file(fd) < 0)
                                        goto report_write_error;
                                offset += len;
-                               if (do_lseek(fd, len, SEEK_CUR) != offset) {
-                                       rsyserr(FERROR, errno,
-                                               "lseek failed on %s",
-                                               full_fname(fname));
+                               if ((pos = do_lseek(fd, len, SEEK_CUR)) != offset) {
+                                       rsyserr(FERROR_XFER, errno,
+                                               "lseek of %s returned %.0f, not %.0f",
+                                               full_fname(fname),
+                                               (double)pos, (double)offset);
                                        exit_cleanup(RERR_FILEIO);
                                }
                                continue;
@@ -277,8 +285,11 @@ static int receive_data(int f_in, char *fname_r, int fd_r, OFF_T size_r,
                goto report_write_error;
 
 #ifdef HAVE_FTRUNCATE
-       if (inplace && fd != -1)
-               ftruncate(fd, offset);
+       if (inplace && fd != -1
+        && ftruncate(fd, offset) < 0) {
+               rsyserr(FERROR_XFER, errno, "ftruncate failed on %s",
+                       full_fname(fname));
+       }
 #endif
 
        if (do_progress)
@@ -286,20 +297,20 @@ static int receive_data(int f_in, char *fname_r, int fd_r, OFF_T size_r,
 
        if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
            report_write_error:
-               rsyserr(FERROR, errno, "write failed on %s",
+               rsyserr(FERROR_XFER, errno, "write failed on %s",
                        full_fname(fname));
                exit_cleanup(RERR_FILEIO);
        }
 
-       sum_end(file_sum1);
+       sum_len = sum_end(file_sum1);
 
        if (mapbuf)
                unmap_file(mapbuf);
 
-       read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
+       read_buf(f_in, file_sum2, sum_len);
        if (verbose > 2)
                rprintf(FINFO,"got file_sum\n");
-       if (fd != -1 && memcmp(file_sum1, file_sum2, MD4_SUM_LENGTH) != 0)
+       if (fd != -1 && memcmp(file_sum1, file_sum2, sum_len) != 0)
                return 0;
        return 1;
 }
@@ -310,129 +321,178 @@ static void discard_receive_data(int f_in, OFF_T length)
        receive_data(f_in, NULL, -1, 0, NULL, -1, length);
 }
 
-static void handle_delayed_updates(struct file_list *flist, char *local_name)
+static void handle_delayed_updates(char *local_name)
 {
-       char *fname, *partialptr, numbuf[4];
-       int i;
+       char *fname, *partialptr;
+       int ndx;
 
-       for (i = -1; (i = next_delayed_bit(i)) >= 0; ) {
-               struct file_struct *file = flist->files[i];
-               fname = local_name ? local_name : f_name(file);
+       for (ndx = -1; (ndx = bitbag_next_bit(delayed_bits, ndx)) >= 0; ) {
+               struct file_struct *file = cur_flist->files[ndx];
+               fname = local_name ? local_name : f_name(file, NULL);
                if ((partialptr = partial_dir_fname(fname)) != NULL) {
-                       if (make_backups && !make_backup(fname))
+                       if (make_backups > 0 && !make_backup(fname))
                                continue;
                        if (verbose > 2) {
                                rprintf(FINFO, "renaming %s to %s\n",
-                                       safe_fname(partialptr),
-                                       safe_fname(fname));
+                                       partialptr, fname);
                        }
+                       /* We don't use robust_rename() here because the
+                        * partial-dir must be on the same drive. */
                        if (do_rename(partialptr, fname) < 0) {
-                               rsyserr(FERROR, errno,
+                               rsyserr(FERROR_XFER, errno,
                                        "rename failed for %s (from %s)",
-                                       full_fname(fname),
-                                       safe_fname(partialptr));
+                                       full_fname(fname), partialptr);
                        } else {
-                               if (remove_sent_files
-                                   || (preserve_hard_links
-                                    && file->link_u.links)) {
-                                       SIVAL(numbuf, 0, i);
-                                       send_msg(MSG_SUCCESS,numbuf,4);
-                               }
-                               handle_partial_dir(partialptr,
-                                                  PDIR_DELETE);
+                               if (remove_source_files
+                                || (preserve_hard_links && F_IS_HLINKED(file)))
+                                       send_msg_int(MSG_SUCCESS, ndx);
+                               handle_partial_dir(partialptr, PDIR_DELETE);
                        }
                }
        }
 }
 
-static int get_next_gen_i(int batch_gen_fd, int next_gen_i, int desired_i)
+static void no_batched_update(int ndx, BOOL is_redo)
 {
-       while (next_gen_i < desired_i) {
-               if (next_gen_i >= 0) {
-                       rprintf(FINFO,
-                               "(No batched update for%s \"%s\")\n",
-                               phase ? " resend of" : "",
-                               safe_fname(f_name(the_file_list->files[next_gen_i])));
-               }
-               next_gen_i = read_int(batch_gen_fd);
-               if (next_gen_i == -1)
-                       next_gen_i = the_file_list->count;
+       struct file_list *flist = flist_for_ndx(ndx, "no_batched_update");
+       struct file_struct *file = flist->files[ndx - flist->ndx_start];
+
+       rprintf(FERROR_XFER, "(No batched update for%s \"%s\")\n",
+               is_redo ? " resend of" : "", f_name(file, NULL));
+
+       if (inc_recurse && !dry_run)
+               send_msg_int(MSG_NO_SEND, ndx);
+}
+
+static int we_want_redo(int desired_ndx)
+{
+       static int redo_ndx = -1;
+
+       while (redo_ndx < desired_ndx) {
+               if (redo_ndx >= 0)
+                       no_batched_update(redo_ndx, True);
+               if ((redo_ndx = flist_ndx_pop(&batch_redo_list)) < 0)
+                       return 0;
+       }
+
+       if (redo_ndx == desired_ndx) {
+               redo_ndx = -1;
+               return 1;
        }
-       return next_gen_i;
+
+       return 0;
 }
 
+static int gen_wants_ndx(int desired_ndx)
+{
+       static int next_ndx = -1;
+       static int done_cnt = 0;
+       static BOOL got_eof = False;
+       int flist_num = first_flist->flist_num;
+
+       if (got_eof)
+               return 0;
+
+       while (next_ndx < desired_ndx) {
+               if (inc_recurse && flist_num <= done_cnt)
+                       return 0;
+               if (next_ndx >= 0)
+                       no_batched_update(next_ndx, False);
+               if ((next_ndx = read_int(batch_gen_fd)) < 0) {
+                       if (inc_recurse) {
+                               done_cnt++;
+                               continue;
+                       }
+                       got_eof = True;
+                       return 0;
+               }
+       }
+
+       if (next_ndx == desired_ndx) {
+               next_ndx = -1;
+               return 1;
+       }
+
+       return 0;
+}
 
 /**
  * main routine for receiver process.
  *
  * Receiver process runs on the same host as the generator process. */
-int recv_files(int f_in, struct file_list *flist, char *local_name)
+int recv_files(int f_in, char *local_name)
 {
-       int next_gen_i = -1;
        int fd1,fd2;
        STRUCT_STAT st;
        int iflags, xlen;
        char *fname, fbuf[MAXPATHLEN];
        char xname[MAXPATHLEN];
        char fnametmp[MAXPATHLEN];
-       char *fnamecmp, *partialptr, numbuf[4];
+       char *fnamecmp, *partialptr;
        char fnamecmpbuf[MAXPATHLEN];
        uchar fnamecmp_type;
        struct file_struct *file;
        struct stats initial_stats;
-       int save_make_backups = make_backups;
-       int itemizing = am_daemon ? daemon_log_format_has_i
-                     : !am_server && log_format_has_i;
+       int itemizing = am_server ? logfile_format_has_i : stdout_format_has_i;
+       enum logcode log_code = log_before_transfer ? FLOG : FINFO;
        int max_phase = protocol_version >= 29 ? 2 : 1;
-       int i, recv_ok;
+       int dflt_perms = (ACCESSPERMS & ~orig_umask);
+#ifdef SUPPORT_ACLS
+       const char *parent_dirname = "";
+#endif
+       int ndx, recv_ok;
 
        if (verbose > 2)
-               rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
-
-       if (flist->hlink_pool) {
-               pool_destroy(flist->hlink_pool);
-               flist->hlink_pool = NULL;
-       }
+               rprintf(FINFO, "recv_files(%d) starting\n", cur_flist->used);
 
        if (delay_updates)
-               init_delayed_bits(flist->count);
+               delayed_bits = bitbag_create(cur_flist->used + 1);
 
        while (1) {
                cleanup_disable();
 
-               i = read_int(f_in);
-               if (i == -1) {
-                       if (read_batch) {
-                               get_next_gen_i(batch_gen_fd, next_gen_i,
-                                              flist->count);
-                               next_gen_i = -1;
-                       }
+               /* This call also sets cur_flist. */
+               ndx = read_ndx_and_attrs(f_in, &iflags, &fnamecmp_type,
+                                        xname, &xlen);
+               if (ndx == NDX_DONE) {
+                       if (inc_recurse && first_flist) {
+                               if (read_batch)
+                                       gen_wants_ndx(first_flist->used + first_flist->ndx_start);
+                               flist_free(first_flist);
+                               if (first_flist)
+                                       continue;
+                       } else if (read_batch && first_flist)
+                               gen_wants_ndx(first_flist->used);
                        if (++phase > max_phase)
                                break;
-                       csum_length = SUM_LENGTH;
                        if (verbose > 2)
                                rprintf(FINFO, "recv_files phase=%d\n", phase);
                        if (phase == 2 && delay_updates)
-                               handle_delayed_updates(flist, local_name);
-                       send_msg(MSG_DONE, "", 0);
-                       if (keep_partial && !partial_dir)
-                               make_backups = 0; /* prevents double backup */
+                               handle_delayed_updates(local_name);
+                       send_msg(MSG_DONE, "", 0, 0);
                        continue;
                }
 
-               iflags = read_item_attrs(f_in, -1, i, &fnamecmp_type,
-                                        xname, &xlen);
-               if (iflags == ITEM_IS_NEW) /* no-op packet */
-                       continue;
-
-               file = flist->files[i];
-               fname = local_name ? local_name : f_name_to(file, fbuf);
+               if (ndx - cur_flist->ndx_start >= 0)
+                       file = cur_flist->files[ndx - cur_flist->ndx_start];
+               else
+                       file = dir_flist->files[cur_flist->parent_ndx];
+               fname = local_name ? local_name : f_name(file, fbuf);
 
                if (verbose > 2)
-                       rprintf(FINFO, "recv_files(%s)\n", safe_fname(fname));
+                       rprintf(FINFO, "recv_files(%s)\n", fname);
+
+#ifdef SUPPORT_XATTRS
+               if (iflags & ITEM_REPORT_XATTR && do_xfers)
+                       recv_xattr_request(file, f_in);
+#endif
 
                if (!(iflags & ITEM_TRANSFER)) {
                        maybe_log_item(file, iflags, itemizing, xname);
+#ifdef SUPPORT_XATTRS
+                       if (preserve_xattrs && iflags & ITEM_REPORT_XATTR && do_xfers)
+                               set_file_attrs(fname, file, NULL, fname, 0);
+#endif
                        continue;
                }
                if (phase == 2) {
@@ -442,42 +502,69 @@ int recv_files(int f_in, struct file_list *flist, char *local_name)
                        exit_cleanup(RERR_PROTOCOL);
                }
 
-               stats.current_file_index = i;
+               if (file->flags & FLAG_FILE_SENT) {
+                       if (csum_length == SHORT_SUM_LENGTH) {
+                               if (keep_partial && !partial_dir)
+                                       make_backups = -make_backups; /* prevents double backup */
+                               if (append_mode)
+                                       sparse_files = -sparse_files;
+                               append_mode = -append_mode;
+                               csum_length = SUM_LENGTH;
+                               redoing = 1;
+                       }
+               } else {
+                       if (csum_length != SHORT_SUM_LENGTH) {
+                               if (keep_partial && !partial_dir)
+                                       make_backups = -make_backups;
+                               if (append_mode)
+                                       sparse_files = -sparse_files;
+                               append_mode = -append_mode;
+                               csum_length = SHORT_SUM_LENGTH;
+                               redoing = 0;
+                       }
+               }
+
+               if (!am_server && do_progress)
+                       set_current_file_index(file, ndx);
                stats.num_transferred_files++;
-               stats.total_transferred_size += file->length;
+               stats.total_transferred_size += F_LENGTH(file);
+
                cleanup_got_literal = 0;
 
-               if (server_filter_list.head
-                   && check_filter(&server_filter_list, fname, 0) < 0) {
+               if (daemon_filter_list.head
+                   && check_filter(&daemon_filter_list, FLOG, fname, 0) < 0) {
                        rprintf(FERROR, "attempt to hack rsync failed.\n");
                        exit_cleanup(RERR_PROTOCOL);
                }
 
+               if (read_batch) {
+                       int wanted = redoing
+                                  ? we_want_redo(ndx)
+                                  : gen_wants_ndx(ndx);
+                       if (!wanted) {
+                               rprintf(FINFO,
+                                       "(Skipping batched update for%s \"%s\")\n",
+                                       redoing ? " resend of" : "",
+                                       fname);
+                               discard_receive_data(f_in, F_LENGTH(file));
+                               file->flags |= FLAG_FILE_SENT;
+                               continue;
+                       }
+               }
+
                if (!do_xfers) { /* log the transfer */
-                       if (!am_server && log_format)
-                               log_item(file, &stats, iflags, NULL);
+                       log_item(FCLIENT, file, &stats, iflags, NULL);
                        if (read_batch)
-                               discard_receive_data(f_in, file->length);
+                               discard_receive_data(f_in, F_LENGTH(file));
                        continue;
                }
                if (write_batch < 0) {
-                       log_item(file, &stats, iflags, NULL);
+                       log_item(FCLIENT, file, &stats, iflags, NULL);
                        if (!am_server)
-                               discard_receive_data(f_in, file->length);
+                               discard_receive_data(f_in, F_LENGTH(file));
                        continue;
                }
 
-               if (read_batch) {
-                       next_gen_i = get_next_gen_i(batch_gen_fd, next_gen_i, i);
-                       if (i < next_gen_i) {
-                               rprintf(FINFO, "(Skipping batched update for \"%s\")\n",
-                                       safe_fname(fname));
-                               discard_receive_data(f_in, file->length);
-                               continue;
-                       }
-                       next_gen_i = -1;
-               }
-
                partialptr = partial_dir ? partial_dir_fname(fname) : fname;
 
                if (protocol_version >= 29) {
@@ -511,15 +598,19 @@ int recv_files(int f_in, struct file_list *flist, char *local_name)
                                fnamecmp = fnamecmpbuf;
                                break;
                        }
-                       if (!fnamecmp || (server_filter_list.head
-                         && check_filter(&server_filter_list, fname, 0) < 0))
+                       if (!fnamecmp || (daemon_filter_list.head
+                         && check_filter(&daemon_filter_list, FLOG, fname, 0) < 0)) {
                                fnamecmp = fname;
+                               fnamecmp_type = FNAMECMP_FNAME;
+                       }
                } else {
                        /* Reminder: --inplace && --partial-dir are never
                         * enabled at the same time. */
-                       if (inplace && make_backups) {
+                       if (inplace && make_backups > 0) {
                                if (!(fnamecmp = get_backup_name(fname)))
                                        fnamecmp = fname;
+                               else
+                                       fnamecmp_type = FNAMECMP_BACKUP;
                        } else if (partial_dir && partialptr)
                                fnamecmp = partialptr;
                        else
@@ -546,11 +637,19 @@ int recv_files(int f_in, struct file_list *flist, char *local_name)
                        }
                }
 
-               if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
-                       rsyserr(FERROR, errno, "fstat %s failed",
+               updating_basis_or_equiv = inplace
+                   && (fnamecmp == fname || fnamecmp_type == FNAMECMP_BACKUP);
+
+               if (fd1 == -1) {
+                       st.st_mode = 0;
+                       st.st_size = 0;
+               } else if (do_fstat(fd1,&st) != 0) {
+                       rsyserr(FERROR_XFER, errno, "fstat %s failed",
                                full_fname(fnamecmp));
-                       discard_receive_data(f_in, file->length);
+                       discard_receive_data(f_in, F_LENGTH(file));
                        close(fd1);
+                       if (inc_recurse)
+                               send_msg_int(MSG_NO_SEND, ndx);
                        continue;
                }
 
@@ -560,10 +659,12 @@ int recv_files(int f_in, struct file_list *flist, char *local_name)
                         * and the underlying robust_unlink could cope
                         * with directories
                         */
-                       rprintf(FERROR,"recv_files: %s is a directory\n",
+                       rprintf(FERROR_XFER, "recv_files: %s is a directory\n",
                                full_fname(fnamecmp));
-                       discard_receive_data(f_in, file->length);
+                       discard_receive_data(f_in, F_LENGTH(file));
                        close(fd1);
+                       if (inc_recurse)
+                               send_msg_int(MSG_NO_SEND, ndx);
                        continue;
                }
 
@@ -572,74 +673,55 @@ int recv_files(int f_in, struct file_list *flist, char *local_name)
                        fd1 = -1;
                }
 
-               if (fd1 != -1 && !preserve_perms) {
-                       /* if the file exists already and we aren't preserving
-                        * permissions then act as though the remote end sent
-                        * us the file permissions we already have */
-                       file->mode = st.st_mode;
+               /* If we're not preserving permissions, change the file-list's
+                * mode based on the local permissions and some heuristics. */
+               if (!preserve_perms) {
+                       int exists = fd1 != -1;
+#ifdef SUPPORT_ACLS
+                       const char *dn = file->dirname ? file->dirname : ".";
+                       if (parent_dirname != dn
+                        && strcmp(parent_dirname, dn) != 0) {
+                               dflt_perms = default_perms_for_dir(dn);
+                               parent_dirname = dn;
+                       }
+#endif
+                       file->mode = dest_mode(file->mode, st.st_mode,
+                                              dflt_perms, exists);
                }
 
-               /* We now check to see if we are writing file "inplace" */
+               /* We now check to see if we are writing the file "inplace" */
                if (inplace)  {
-                       fd2 = do_open(fname, O_WRONLY|O_CREAT, 0);
+                       fd2 = do_open(fname, O_WRONLY|O_CREAT, 0600);
                        if (fd2 == -1) {
-                               rsyserr(FERROR, errno, "open %s failed",
+                               rsyserr(FERROR_XFER, errno, "open %s failed",
                                        full_fname(fname));
-                               discard_receive_data(f_in, file->length);
-                               if (fd1 != -1)
-                                       close(fd1);
-                               continue;
                        }
                } else {
-                       if (!get_tmpname(fnametmp,fname)) {
-                               discard_receive_data(f_in, file->length);
-                               if (fd1 != -1)
-                                       close(fd1);
-                               continue;
-                       }
-
-                       /* we initially set the perms without the
-                        * setuid/setgid bits to ensure that there is no race
-                        * condition. They are then correctly updated after
-                        * the lchown. Thanks to snabb@epipe.fi for pointing
-                        * this out.  We also set it initially without group
-                        * access because of a similar race condition. */
-                       fd2 = do_mkstemp(fnametmp, file->mode & INITACCESSPERMS);
-
-                       /* in most cases parent directories will already exist
-                        * because their information should have been previously
-                        * transferred, but that may not be the case with -R */
-                       if (fd2 == -1 && relative_paths && errno == ENOENT
-                           && create_directory_path(fnametmp, orig_umask) == 0) {
-                               /* Get back to name with XXXXXX in it. */
-                               get_tmpname(fnametmp, fname);
-                               fd2 = do_mkstemp(fnametmp, file->mode & INITACCESSPERMS);
-                       }
-                       if (fd2 == -1) {
-                               rsyserr(FERROR, errno, "mkstemp %s failed",
-                                       full_fname(fnametmp));
-                               discard_receive_data(f_in, file->length);
-                               if (fd1 != -1)
-                                       close(fd1);
-                               continue;
-                       }
-
-                       if (partialptr)
+                       fd2 = open_tmpfile(fnametmp, fname, file);
+                       if (fd2 != -1)
                                cleanup_set(fnametmp, partialptr, file, fd1, fd2);
                }
 
+               if (fd2 == -1) {
+                       discard_receive_data(f_in, F_LENGTH(file));
+                       if (fd1 != -1)
+                               close(fd1);
+                       if (inc_recurse)
+                               send_msg_int(MSG_NO_SEND, ndx);
+                       continue;
+               }
+
                /* log the transfer */
                if (log_before_transfer)
-                       log_item(file, &initial_stats, iflags, NULL);
+                       log_item(FCLIENT, file, &initial_stats, iflags, NULL);
                else if (!am_server && verbose && do_progress)
-                       rprintf(FINFO, "%s\n", safe_fname(fname));
+                       rprintf(FINFO, "%s\n", fname);
 
                /* recv file data */
                recv_ok = receive_data(f_in, fnamecmp, fd1, st.st_size,
-                                      fname, fd2, file->length);
+                                      fname, fd2, F_LENGTH(file));
 
-               if (!log_before_transfer)
-                       log_item(file, &initial_stats, iflags, NULL);
+               log_item(log_code, file, &initial_stats, iflags, NULL);
 
                if (fd1 != -1)
                        close(fd1);
@@ -650,35 +732,50 @@ int recv_files(int f_in, struct file_list *flist, char *local_name)
                }
 
                if ((recv_ok && (!delay_updates || !partialptr)) || inplace) {
-                       finish_transfer(fname, fnametmp, file, recv_ok, 1);
-                       if (partialptr != fname && fnamecmp == partialptr) {
+                       if (partialptr == fname)
+                               partialptr = NULL;
+                       if (!finish_transfer(fname, fnametmp, fnamecmp,
+                                            partialptr, file, recv_ok, 1))
+                               recv_ok = -1;
+                       else if (fnamecmp == partialptr) {
                                do_unlink(partialptr);
                                handle_partial_dir(partialptr, PDIR_DELETE);
                        }
-               } else if (keep_partial && partialptr
-                   && handle_partial_dir(partialptr, PDIR_CREATE)) {
-                       finish_transfer(partialptr, fnametmp, file, recv_ok,
-                                       !partial_dir);
-                       if (delay_updates && recv_ok) {
-                               set_delayed_bit(i);
+               } else if (keep_partial && partialptr) {
+                       if (!handle_partial_dir(partialptr, PDIR_CREATE)) {
+                               rprintf(FERROR,
+                                   "Unable to create partial-dir for %s -- discarding %s.\n",
+                                   local_name ? local_name : f_name(file, NULL),
+                                   recv_ok ? "completed file" : "partial file");
+                               do_unlink(fnametmp);
                                recv_ok = -1;
-                       }
-               } else {
-                       partialptr = NULL;
+                       } else if (!finish_transfer(partialptr, fnametmp, fnamecmp, NULL,
+                                                   file, recv_ok, !partial_dir))
+                               recv_ok = -1;
+                       else if (delay_updates && recv_ok) {
+                               bitbag_set_bit(delayed_bits, ndx);
+                               recv_ok = 2;
+                       } else
+                               partialptr = NULL;
+               } else
                        do_unlink(fnametmp);
-               }
 
                cleanup_disable();
 
-               if (recv_ok > 0) {
-                       if (remove_sent_files
-                           || (preserve_hard_links && file->link_u.links)) {
-                               SIVAL(numbuf, 0, i);
-                               send_msg(MSG_SUCCESS, numbuf, 4);
-                       }
-               } else if (!recv_ok) {
-                       int msgtype = phase || read_batch ? FERROR : FINFO;
-                       if (msgtype == FERROR || verbose) {
+               if (read_batch)
+                       file->flags |= FLAG_FILE_SENT;
+
+               switch (recv_ok) {
+               case 2:
+                       break;
+               case 1:
+                       if (remove_source_files || inc_recurse
+                        || (preserve_hard_links && F_IS_HLINKED(file)))
+                               send_msg_int(MSG_SUCCESS, ndx);
+                       break;
+               case 0: {
+                       enum logcode msgtype = redoing ? FERROR_XFER : FWARNING;
+                       if (msgtype == FERROR_XFER || verbose) {
                                char *errstr, *redostr, *keptstr;
                                if (!(keep_partial && partialptr) && !inplace)
                                        keptstr = "discarded";
@@ -686,28 +783,39 @@ int recv_files(int f_in, struct file_list *flist, char *local_name)
                                        keptstr = "put into partial-dir";
                                else
                                        keptstr = "retained";
-                               if (msgtype == FERROR) {
+                               if (msgtype == FERROR_XFER) {
                                        errstr = "ERROR";
                                        redostr = "";
                                } else {
                                        errstr = "WARNING";
-                                       redostr = " (will try again)";
+                                       redostr = read_batch ? " (may try again)"
+                                                            : " (will try again)";
                                }
                                rprintf(msgtype,
                                        "%s: %s failed verification -- update %s%s.\n",
-                                       errstr, safe_fname(fname),
+                                       errstr, local_name ? f_name(file, NULL) : fname,
                                        keptstr, redostr);
                        }
-                       if (!phase) {
-                               SIVAL(numbuf, 0, i);
-                               send_msg(MSG_REDO, numbuf, 4);
-                       }
+                       if (!redoing) {
+                               if (read_batch)
+                                       flist_ndx_push(&batch_redo_list, ndx);
+                               send_msg_int(MSG_REDO, ndx);
+                               file->flags |= FLAG_FILE_SENT;
+                       } else if (inc_recurse)
+                               send_msg_int(MSG_NO_SEND, ndx);
+                       break;
+                   }
+               case -1:
+                       if (inc_recurse)
+                               send_msg_int(MSG_NO_SEND, ndx);
+                       break;
                }
        }
-       make_backups = save_make_backups;
+       if (make_backups < 0)
+               make_backups = -make_backups;
 
        if (phase == 2 && delay_updates) /* for protocol_version < 29 */
-               handle_delayed_updates(flist, local_name);
+               handle_delayed_updates(local_name);
 
        if (verbose > 2)
                rprintf(FINFO,"recv_files finished\n");