Use 0-length MSG_DATA when MSG_NOOP is not available
[rsync.git] / receiver.c
index 06f75f8a16f9ed4ef2935dd9e2ce13583af73509..39c5e490dc96f80c9e2b139957b1881b39157027 100644 (file)
@@ -3,11 +3,11 @@
  *
  * Copyright (C) 1996-2000 Andrew Tridgell
  * Copyright (C) 1996 Paul Mackerras
- * Copyright (C) 2003, 2004, 2005, 2006 Wayne Davison
+ * 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 2 of the License, or
+ * 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,
  * 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.,
- * 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
+ * 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_server;
 extern int do_progress;
-extern int incremental;
+extern int inc_recurse;
 extern int log_before_transfer;
 extern int stdout_format_has_i;
 extern int logfile_format_has_i;
@@ -38,6 +38,7 @@ extern int protocol_version;
 extern int relative_paths;
 extern int preserve_hard_links;
 extern int preserve_perms;
+extern int preserve_xattrs;
 extern int basis_dir_cnt;
 extern int make_backups;
 extern int cleanup_got_literal;
@@ -48,17 +49,19 @@ 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 *tmpdir;
 extern char *partial_dir;
 extern char *basis_dir[];
-extern struct file_list *cur_flist, *first_flist;
-extern struct filter_list_struct server_filter_list;
+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;
+static int updating_basis_or_equiv;
 
 /*
  * get_tmpname() - create a tmp filename for a given filename
@@ -81,10 +84,10 @@ static int updating_basis;
  *   As long as it's unique, rsync will work.
  */
 
-int get_tmpname(char *fnametmp, char *fname)
+int get_tmpname(char *fnametmp, const char *fname)
 {
        int maxname, added, length = 0;
-       char *f;
+       const char *f;
 
        if (tmpdir) {
                /* Note: this can't overflow, so the return value is safe */
@@ -108,7 +111,7 @@ int get_tmpname(char *fnametmp, char *fname)
        maxname = MIN(MAXPATHLEN - 7 - length, NAME_MAX - 8);
 
        if (maxname < 1) {
-               rprintf(FERROR, "temporary filename too long: %s\n", fname);
+               rprintf(FERROR_XFER, "temporary filename too long: %s\n", fname);
                fnametmp[0] = '\0';
                return 0;
        }
@@ -121,15 +124,52 @@ int get_tmpname(char *fnametmp, char *fname)
        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;
@@ -155,22 +195,24 @@ static int receive_data(int f_in, char *fname_r, int fd_r, OFF_T size_r,
                sum.flength = (OFF_T)sum.count * sum.blength;
                if (sum.remainder)
                        sum.flength -= sum.blength - sum.remainder;
-               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 (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, errno, "lseek of %s returned %.0f, not %.0f",
+                       rsyserr(FERROR_XFER, errno, "lseek of %s returned %.0f, not %.0f",
                                full_fname(fname), (double)j, (double)offset);
                        exit_cleanup(RERR_FILEIO);
                }
@@ -218,14 +260,14 @@ static int receive_data(int f_in, char *fname_r, int fd_r, OFF_T size_r,
                        sum_update(map, len);
                }
 
-               if (updating_basis) {
+               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 ((pos = do_lseek(fd, len, SEEK_CUR)) != offset) {
-                                       rsyserr(FERROR, errno,
+                                       rsyserr(FERROR_XFER, errno,
                                                "lseek of %s returned %.0f, not %.0f",
                                                full_fname(fname),
                                                (double)pos, (double)offset);
@@ -243,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)
@@ -252,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;
 }
@@ -294,7 +339,7 @@ static void handle_delayed_updates(char *local_name)
                        /* 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), partialptr);
                        } else {
@@ -307,24 +352,68 @@ static void handle_delayed_updates(char *local_name)
        }
 }
 
-static int get_next_gen_ndx(int fd, int next_gen_ndx, int desired_ndx)
+static void no_batched_update(int ndx, BOOL is_redo)
 {
-       while (next_gen_ndx < desired_ndx) {
-               if (next_gen_ndx >= 0) {
-                       rprintf(FINFO,
-                               "(No batched update for%s \"%s\")\n",
-                               redoing ? " resend of" : "",
-                               f_name(cur_flist->files[next_gen_ndx], NULL));
-               }
-               next_gen_ndx = read_int(fd);
-               if (next_gen_ndx == -1) {
-                       if (incremental)
-                               next_gen_ndx = first_flist->prev->count + first_flist->prev->ndx_start;
-                       else
-                               next_gen_ndx = cur_flist->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 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;
                }
        }
-       return next_gen_ndx;
+
+       if (next_ndx == desired_ndx) {
+               next_ndx = -1;
+               return 1;
+       }
+
+       return 0;
 }
 
 /**
@@ -333,7 +422,6 @@ static int get_next_gen_ndx(int fd, int next_gen_ndx, int desired_ndx)
  * Receiver process runs on the same host as the generator process. */
 int recv_files(int f_in, char *local_name)
 {
-       int next_gen_ndx = -1;
        int fd1,fd2;
        STRUCT_STAT st;
        int iflags, xlen;
@@ -348,53 +436,63 @@ int recv_files(int f_in, char *local_name)
        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 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", cur_flist->count);
+               rprintf(FINFO, "recv_files(%d) starting\n", cur_flist->used);
 
        if (delay_updates)
-               delayed_bits = bitbag_create(cur_flist->count + 1);
-
-       updating_basis = inplace;
+               delayed_bits = bitbag_create(cur_flist->used + 1);
 
        while (1) {
                cleanup_disable();
 
                /* This call also sets cur_flist. */
-               ndx = read_ndx_and_attrs(f_in, -1, &iflags,
-                                        &fnamecmp_type, xname, &xlen);
+               ndx = read_ndx_and_attrs(f_in, &iflags, &fnamecmp_type,
+                                        xname, &xlen);
                if (ndx == NDX_DONE) {
-                       if (incremental && first_flist) {
+                       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;
-                       }
-                       if (read_batch && cur_flist) {
-                               int high = incremental
-                                   ? first_flist->prev->count + first_flist->prev->ndx_start
-                                   : cur_flist->count;
-                               get_next_gen_ndx(batch_gen_fd, next_gen_ndx, high);
-                               next_gen_ndx = -1;
-                       }
+                       } else if (read_batch && first_flist)
+                               gen_wants_ndx(first_flist->used);
                        if (++phase > max_phase)
                                break;
                        if (verbose > 2)
                                rprintf(FINFO, "recv_files phase=%d\n", phase);
                        if (phase == 2 && delay_updates)
                                handle_delayed_updates(local_name);
-                       send_msg(MSG_DONE, "", 0);
+                       send_msg(MSG_DONE, "", 0, 0);
                        continue;
                }
 
-               file = cur_flist->files[ndx - cur_flist->ndx_start];
+               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", 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) {
@@ -408,8 +506,9 @@ int recv_files(int f_in, char *local_name)
                        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;
-                               sparse_files = -sparse_files;
                                csum_length = SUM_LENGTH;
                                redoing = 1;
                        }
@@ -417,24 +516,42 @@ int recv_files(int f_in, char *local_name)
                        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;
-                               sparse_files = -sparse_files;
                                csum_length = SHORT_SUM_LENGTH;
                                redoing = 0;
                        }
                }
 
-               stats.current_file_index = ndx;
+               if (!am_server && do_progress)
+                       set_current_file_index(file, ndx);
                stats.num_transferred_files++;
                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 */
                        log_item(FCLIENT, file, &stats, iflags, NULL);
                        if (read_batch)
@@ -442,24 +559,12 @@ int recv_files(int f_in, char *local_name)
                        continue;
                }
                if (write_batch < 0) {
-                       log_item(FINFO, file, &stats, iflags, NULL);
+                       log_item(FCLIENT, file, &stats, iflags, NULL);
                        if (!am_server)
                                discard_receive_data(f_in, F_LENGTH(file));
                        continue;
                }
 
-               if (read_batch) {
-                       next_gen_ndx = get_next_gen_ndx(batch_gen_fd, next_gen_ndx, ndx);
-                       if (ndx < next_gen_ndx) {
-                               rprintf(FINFO,
-                                       "(Skipping batched update for \"%s\")\n",
-                                       fname);
-                               discard_receive_data(f_in, F_LENGTH(file));
-                               continue;
-                       }
-                       next_gen_ndx = -1;
-               }
-
                partialptr = partial_dir ? partial_dir_fname(fname) : fname;
 
                if (protocol_version >= 29) {
@@ -474,7 +579,6 @@ int recv_files(int f_in, char *local_name)
                                fnamecmp = get_backup_name(fname);
                                break;
                        case FNAMECMP_FUZZY:
-                               updating_basis = 0;
                                if (file->dirname) {
                                        pathjoin(fnamecmpbuf, MAXPATHLEN,
                                                 file->dirname, xname);
@@ -483,7 +587,6 @@ int recv_files(int f_in, char *local_name)
                                        fnamecmp = xname;
                                break;
                        default:
-                               updating_basis = 0;
                                if (fnamecmp_type >= basis_dir_cnt) {
                                        rprintf(FERROR,
                                                "invalid basis_dir index: %d.\n",
@@ -495,15 +598,19 @@ int recv_files(int f_in, 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 > 0) {
                                if (!(fnamecmp = get_backup_name(fname)))
                                        fnamecmp = fname;
+                               else
+                                       fnamecmp_type = FNAMECMP_BACKUP;
                        } else if (partial_dir && partialptr)
                                fnamecmp = partialptr;
                        else
@@ -530,14 +637,19 @@ int recv_files(int f_in, char *local_name)
                        }
                }
 
+               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, errno, "fstat %s failed",
+                       rsyserr(FERROR_XFER, errno, "fstat %s failed",
                                full_fname(fnamecmp));
                        discard_receive_data(f_in, F_LENGTH(file));
                        close(fd1);
+                       if (inc_recurse)
+                               send_msg_int(MSG_NO_SEND, ndx);
                        continue;
                }
 
@@ -547,10 +659,12 @@ int recv_files(int f_in, 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, F_LENGTH(file));
                        close(fd1);
+                       if (inc_recurse)
+                               send_msg_int(MSG_NO_SEND, ndx);
                        continue;
                }
 
@@ -563,55 +677,38 @@ int recv_files(int f_in, char *local_name)
                 * mode based on the local permissions and some heuristics. */
                if (!preserve_perms) {
                        int exists = fd1 != -1;
-                       file->mode = dest_mode(file->mode, st.st_mode, exists);
+#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 the file "inplace" */
                if (inplace)  {
                        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, F_LENGTH(file));
-                               if (fd1 != -1)
-                                       close(fd1);
-                               continue;
                        }
                } else {
-                       if (!get_tmpname(fnametmp,fname)) {
-                               discard_receive_data(f_in, F_LENGTH(file));
-                               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) == 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, F_LENGTH(file));
-                               if (fd1 != -1)
-                                       close(fd1);
-                               continue;
-                       }
+                       fd2 = open_tmpfile(fnametmp, fname, file);
+                       if (fd2 != -1)
+                               cleanup_set(fnametmp, partialptr, file, fd1, fd2);
+               }
 
-                       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 */
@@ -635,41 +732,50 @@ int recv_files(int f_in, char *local_name)
                }
 
                if ((recv_ok && (!delay_updates || !partialptr)) || inplace) {
-                       char *temp_copy_name;
                        if (partialptr == fname)
-                               partialptr = temp_copy_name = NULL;
-                       else if (*partial_dir == '/')
-                               temp_copy_name = NULL;
-                       else
-                               temp_copy_name = partialptr;
-                       finish_transfer(fname, fnametmp, temp_copy_name,
-                                       file, recv_ok, 1);
-                       if (fnamecmp == partialptr) {
+                               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, NULL,
-                                       file, recv_ok, !partial_dir);
-                       if (delay_updates && recv_ok) {
-                               bitbag_set_bit(delayed_bits, ndx);
+               } 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_source_files || incremental
+               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);
-               } else if (!recv_ok) {
-                       enum logcode msgtype = redoing || read_batch ? FERROR : FINFO;
-                       if (msgtype == FERROR || verbose) {
+                       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";
@@ -677,22 +783,32 @@ int recv_files(int f_in, 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, fname, keptstr, redostr);
+                                       errstr, local_name ? f_name(file, NULL) : fname,
+                                       keptstr, redostr);
                        }
                        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 (incremental)
+                       } 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;
                }
        }
        if (make_backups < 0)