Tweaking the license text a bit more.
[rsync/rsync.git] / io.c
diff --git a/io.c b/io.c
index c91007e..0ab9f57 100644 (file)
--- a/io.c
+++ b/io.c
@@ -4,11 +4,11 @@
  * Copyright (C) 1996-2001 Andrew Tridgell
  * Copyright (C) 1996 Paul Mackerras
  * Copyright (C) 2001, 2002 Martin Pool <mbp@samba.org>
- * Copyright (C) 2003, 2004, 2005, 2006 Wayne Davison
+ * Copyright (C) 2003-2007 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,
@@ -16,9 +16,8 @@
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, visit the http://fsf.org website.
  */
 
 /* Rsync provides its own multiplexing system, which is used to send
@@ -41,21 +40,27 @@ extern int am_server;
 extern int am_daemon;
 extern int am_sender;
 extern int am_generator;
+extern int inc_recurse;
+extern int io_error;
 extern int eol_nulls;
+extern int flist_eof;
 extern int read_batch;
 extern int csum_length;
 extern int checksum_seed;
 extern int protocol_version;
-extern int remove_sent_files;
+extern int remove_source_files;
 extern int preserve_hard_links;
 extern char *filesfrom_host;
 extern struct stats stats;
-extern struct file_list *the_file_list;
+extern struct file_list *cur_flist, *first_flist;
+#ifdef ICONV_OPTION
+extern iconv_t ic_send, ic_recv;
+#endif
 
 const char phase_unknown[] = "unknown";
 int ignore_timeout = 0;
 int batch_fd = -1;
-int batch_gen_fd = -1;
+int msgdone_cnt = 0;
 
 /* Ignore an EOF error if non-zero. See whine_about_eof(). */
 int kluge_around_eof = 0;
@@ -65,6 +70,18 @@ int msg_fd_out = -1;
 int sock_f_in = -1;
 int sock_f_out = -1;
 
+static int iobuf_f_in = -1;
+static char *iobuf_in;
+static size_t iobuf_in_siz;
+static size_t iobuf_in_ndx;
+static size_t iobuf_in_remaining;
+
+static int iobuf_f_out = -1;
+static char *iobuf_out;
+static int iobuf_out_cnt;
+
+int flist_forward_from = -1;
+
 static int io_multiplexing_out;
 static int io_multiplexing_in;
 static time_t last_io_in;
@@ -77,6 +94,9 @@ static int write_batch_monitor_out = -1;
 static int io_filesfrom_f_in = -1;
 static int io_filesfrom_f_out = -1;
 static char io_filesfrom_buf[2048];
+#ifdef ICONV_OPTION
+static char iconv_buf[sizeof io_filesfrom_buf / 2];
+#endif
 static char *io_filesfrom_bp;
 static char io_filesfrom_lastchar;
 static int io_filesfrom_buflen;
@@ -85,7 +105,19 @@ static int select_timeout = SELECT_TIMEOUT;
 static int active_filecnt = 0;
 static OFF_T active_bytecnt = 0;
 
-static void read_loop(int fd, char *buf, size_t len);
+static char int_byte_extra[64] = {
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* (00 - 3F)/4 */
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* (40 - 7F)/4 */
+       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* (80 - BF)/4 */
+       2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 5, 6, /* (C0 - FF)/4 */
+};
+
+static void readfd(int fd, char *buffer, size_t N);
+static void writefd(int fd, const char *buf, size_t len);
+static void writefd_unbuffered(int fd, const char *buf, size_t len);
+static void decrement_active_files(int ndx);
+static void decrement_flist_in_progress(int ndx, int redo);
+static void mplex_write(int fd, enum msgcode code, const char *buf, size_t len, int convert);
 
 struct flist_ndx_item {
        struct flist_ndx_item *next;
@@ -100,7 +132,7 @@ static struct flist_ndx_list redo_list, hlink_list;
 
 struct msg_list_item {
        struct msg_list_item *next;
-       int len;
+       char convert;
        char buf[1];
 };
 
@@ -108,7 +140,7 @@ struct msg_list {
        struct msg_list_item *head, *tail;
 };
 
-static struct msg_list msg2genr, msg2sndr;
+static struct msg_list msg_queue;
 
 static void flist_ndx_push(struct flist_ndx_list *lp, int ndx)
 {
@@ -204,7 +236,7 @@ void set_msg_fd_out(int fd)
 }
 
 /* Add a message to the pending MSG_* list. */
-static void msg_list_add(struct msg_list *lst, int code, char *buf, int len)
+static void msg_list_add(struct msg_list *lst, int code, const char *buf, int len, int convert)
 {
        struct msg_list_item *m;
        int sz = len + 4 + sizeof m[0] - 1;
@@ -212,7 +244,7 @@ static void msg_list_add(struct msg_list *lst, int code, char *buf, int len)
        if (!(m = (struct msg_list_item *)new_array(char, sz)))
                out_of_memory("msg_list_add");
        m->next = NULL;
-       m->len = len + 4;
+       m->convert = convert;
        SIVAL(m->buf, 0, ((code+MPLEX_BASE)<<24) | len);
        memcpy(m->buf + 4, buf, len);
        if (lst->tail)
@@ -222,6 +254,36 @@ static void msg_list_add(struct msg_list *lst, int code, char *buf, int len)
        lst->tail = m;
 }
 
+static void msg_flush(void)
+{
+       if (am_generator) {
+               while (msg_queue.head && io_multiplexing_out) {
+                       struct msg_list_item *m = msg_queue.head;
+                       int len = IVAL(m->buf, 0) & 0xFFFFFF;
+                       int tag = *((uchar*)m->buf+3) - MPLEX_BASE;
+                       if (!(msg_queue.head = m->next))
+                               msg_queue.tail = NULL;
+                       stats.total_written += len + 4;
+                       defer_forwarding_messages++;
+                       mplex_write(sock_f_out, tag, m->buf + 4, len, m->convert);
+                       defer_forwarding_messages--;
+                       free(m);
+               }
+       } else {
+               while (msg_queue.head) {
+                       struct msg_list_item *m = msg_queue.head;
+                       int len = IVAL(m->buf, 0) & 0xFFFFFF;
+                       int tag = *((uchar*)m->buf+3) - MPLEX_BASE;
+                       if (!(msg_queue.head = m->next))
+                               msg_queue.tail = NULL;
+                       defer_forwarding_messages++;
+                       mplex_write(msg_fd_out, tag, m->buf + 4, len, m->convert);
+                       defer_forwarding_messages--;
+                       free(m);
+               }
+       }
+}
+
 /* Read a message from the MSG_* fd and handle it.  This is called either
  * during the early stages of being a local sender (up through the sending
  * of the file list) or when we're the generator (to fetch the messages
@@ -230,14 +292,17 @@ static void read_msg_fd(void)
 {
        char buf[2048];
        size_t n;
+       struct file_list *flist;
        int fd = msg_fd_in;
        int tag, len;
 
        /* Temporarily disable msg_fd_in.  This is needed to avoid looping back
         * to this routine from writefd_unbuffered(). */
+       no_flush++;
        msg_fd_in = -1;
+       defer_forwarding_messages++;
 
-       read_loop(fd, buf, 4);
+       readfd(fd, buf, 4);
        tag = IVAL(buf, 0);
 
        len = tag & 0xFFFFFF;
@@ -245,55 +310,80 @@ static void read_msg_fd(void)
 
        switch (tag) {
        case MSG_DONE:
-               if (len != 0 || !am_generator) {
-                       rprintf(FERROR, "invalid message %d:%d\n", tag, len);
+               if (len < 0 || len > 1 || !am_generator) {
+                 invalid_msg:
+                       rprintf(FERROR, "invalid message %d:%d [%s%s]\n",
+                               tag, len, who_am_i(),
+                               inc_recurse ? "/inc" : "");
                        exit_cleanup(RERR_STREAMIO);
                }
-               flist_ndx_push(&redo_list, -1);
+               if (len) {
+                       readfd(fd, buf, len);
+                       stats.total_read = read_varlong(fd, 3);
+               }
+               msgdone_cnt++;
                break;
        case MSG_REDO:
-               if (len != 4 || !am_generator) {
-                       rprintf(FERROR, "invalid message %d:%d\n", tag, len);
-                       exit_cleanup(RERR_STREAMIO);
-               }
-               read_loop(fd, buf, 4);
-               if (remove_sent_files)
+               if (len != 4 || !am_generator)
+                       goto invalid_msg;
+               readfd(fd, buf, 4);
+               if (remove_source_files)
                        decrement_active_files(IVAL(buf,0));
                flist_ndx_push(&redo_list, IVAL(buf,0));
+               if (inc_recurse)
+                       decrement_flist_in_progress(IVAL(buf,0), 1);
                break;
-       case MSG_DELETED:
-               if (len >= (int)sizeof buf || !am_generator) {
-                       rprintf(FERROR, "invalid message %d:%d\n", tag, len);
-                       exit_cleanup(RERR_STREAMIO);
+       case MSG_FLIST:
+               if (len != 4 || !am_generator || !inc_recurse)
+                       goto invalid_msg;
+               readfd(fd, buf, 4);
+               /* Read extra file list from receiver. */
+               assert(iobuf_in != NULL);
+               assert(iobuf_f_in == fd);
+               if (verbose > 3) {
+                       rprintf(FINFO, "[%s] receiving flist for dir %d\n",
+                               who_am_i(), IVAL(buf,0));
                }
-               read_loop(fd, buf, len);
-               if (defer_forwarding_messages)
-                       msg_list_add(&msg2sndr, MSG_DELETED, buf, len);
-               else
-                       io_multiplex_write(MSG_DELETED, buf, len);
+               flist = recv_file_list(fd);
+               flist->parent_ndx = IVAL(buf,0);
+               break;
+       case MSG_FLIST_EOF:
+               if (len != 0 || !am_generator || !inc_recurse)
+                       goto invalid_msg;
+               flist_eof = 1;
+               break;
+       case MSG_DELETED:
+               if (len >= (int)sizeof buf || !am_generator)
+                       goto invalid_msg;
+               readfd(fd, buf, len);
+               send_msg(MSG_DELETED, buf, len, 1);
                break;
        case MSG_SUCCESS:
-               if (len != 4 || !am_generator) {
-                       rprintf(FERROR, "invalid message %d:%d\n", tag, len);
-                       exit_cleanup(RERR_STREAMIO);
-               }
-               read_loop(fd, buf, len);
-               if (remove_sent_files) {
+               if (len != 4 || !am_generator)
+                       goto invalid_msg;
+               readfd(fd, buf, len);
+               if (remove_source_files) {
                        decrement_active_files(IVAL(buf,0));
-                       if (defer_forwarding_messages)
-                               msg_list_add(&msg2sndr, MSG_SUCCESS, buf, len);
-                       else
-                               io_multiplex_write(MSG_SUCCESS, buf, len);
+                       send_msg(MSG_SUCCESS, buf, len, 0);
                }
                if (preserve_hard_links)
                        flist_ndx_push(&hlink_list, IVAL(buf,0));
+               if (inc_recurse)
+                       decrement_flist_in_progress(IVAL(buf,0), 0);
+               break;
+       case MSG_NO_SEND:
+               if (len != 4 || !am_generator)
+                       goto invalid_msg;
+               readfd(fd, buf, len);
+               if (inc_recurse)
+                       decrement_flist_in_progress(IVAL(buf,0), 0);
                break;
        case MSG_SOCKERR:
-               if (!am_generator) {
-                       rprintf(FERROR, "invalid message %d:%d\n", tag, len);
-                       exit_cleanup(RERR_STREAMIO);
-               }
-               close_multiplexing_out();
+       case MSG_CLIENT:
+               if (!am_generator)
+                       goto invalid_msg;
+               if (tag == MSG_SOCKERR)
+                       io_end_multiplex_out();
                /* FALL THROUGH */
        case MSG_INFO:
        case MSG_ERROR:
@@ -302,11 +392,8 @@ static void read_msg_fd(void)
                        n = len;
                        if (n >= sizeof buf)
                                n = sizeof buf - 1;
-                       read_loop(fd, buf, n);
-                       if (am_generator && am_server && defer_forwarding_messages)
-                               msg_list_add(&msg2sndr, tag, buf, n);
-                       else
-                               rwrite((enum logcode)tag, buf, n);
+                       readfd(fd, buf, n);
+                       rwrite((enum logcode)tag, buf, n, !am_generator);
                        len -= n;
                }
                break;
@@ -316,90 +403,151 @@ static void read_msg_fd(void)
                exit_cleanup(RERR_STREAMIO);
        }
 
+       no_flush--;
        msg_fd_in = fd;
+       if (!--defer_forwarding_messages)
+               msg_flush();
 }
 
 /* This is used by the generator to limit how many file transfers can
- * be active at once when --remove-sent-files is specified.  Without
+ * be active at once when --remove-source-files is specified.  Without
  * this, sender-side deletions were mostly happening at the end. */
 void increment_active_files(int ndx, int itemizing, enum logcode code)
 {
        /* TODO: tune these limits? */
        while (active_filecnt >= (active_bytecnt >= 128*1024 ? 10 : 50)) {
-               if (hlink_list.head)
-                       check_for_finished_hlinks(itemizing, code);
-               read_msg_fd();
+               check_for_finished_files(itemizing, code, 0);
+               if (iobuf_out_cnt)
+                       io_flush(NORMAL_FLUSH);
+               else
+                       read_msg_fd();
        }
 
        active_filecnt++;
-       active_bytecnt += the_file_list->files[ndx]->length;
+       active_bytecnt += F_LENGTH(cur_flist->files[ndx - cur_flist->ndx_start]);
 }
 
-void decrement_active_files(int ndx)
+static void decrement_active_files(int ndx)
 {
+       struct file_list *flist = flist_for_ndx(ndx);
+       assert(flist != NULL);
        active_filecnt--;
-       active_bytecnt -= the_file_list->files[ndx]->length;
+       active_bytecnt -= F_LENGTH(flist->files[ndx - flist->ndx_start]);
 }
 
-/* Try to push messages off the list onto the wire.  If we leave with more
- * to do, return 0.  On error, return -1.  If everything flushed, return 1.
- * This is only active in the receiver. */
-static int msg2genr_flush(int flush_it_all)
+static void decrement_flist_in_progress(int ndx, int redo)
 {
-       static int written = 0;
-       struct timeval tv;
-       fd_set fds;
+       struct file_list *flist = cur_flist ? cur_flist : first_flist;
 
-       if (msg_fd_out < 0)
-               return -1;
+       while (ndx < flist->ndx_start) {
+               if (flist == first_flist) {
+                 invalid_ndx:
+                       rprintf(FERROR,
+                               "Invalid file index: %d (%d - %d) [%s]\n",
+                               ndx, first_flist->ndx_start,
+                               first_flist->prev->ndx_start + first_flist->prev->used - 1,
+                               who_am_i());
+                       exit_cleanup(RERR_PROTOCOL);
+               }
+               flist = flist->prev;
+       }
+       while (ndx >= flist->ndx_start + flist->used) {
+               if (!(flist = flist->next))
+                       goto invalid_ndx;
+       }
 
-       while (msg2genr.head) {
-               struct msg_list_item *m = msg2genr.head;
-               int n = write(msg_fd_out, m->buf + written, m->len - written);
-               if (n < 0) {
-                       if (errno == EINTR)
-                               continue;
-                       if (errno != EWOULDBLOCK && errno != EAGAIN)
-                               return -1;
-                       if (!flush_it_all)
-                               return 0;
-                       FD_ZERO(&fds);
-                       FD_SET(msg_fd_out, &fds);
-                       tv.tv_sec = select_timeout;
-                       tv.tv_usec = 0;
-                       if (!select(msg_fd_out+1, NULL, &fds, NULL, &tv))
-                               check_timeout();
-               } else if ((written += n) == m->len) {
-                       msg2genr.head = m->next;
-                       if (!msg2genr.head)
-                               msg2genr.tail = NULL;
-                       free(m);
-                       written = 0;
+       flist->in_progress--;
+       if (redo)
+               flist->to_redo++;
+}
+
+/* Write an message to a multiplexed stream. If this fails, rsync exits. */
+static void mplex_write(int fd, enum msgcode code, const char *buf, size_t len, int convert)
+{
+       char buffer[BIGPATHBUFLEN]; /* Oversized for use by iconv code. */
+       size_t n = len;
+
+       SIVAL(buffer, 0, ((MPLEX_BASE + (int)code)<<24) + len);
+
+#ifdef ICONV_OPTION
+       if (convert && ic_send == (iconv_t)-1)
+#endif
+               convert = 0;
+
+       if (convert || n > 1024 - 4) /* BIGPATHBUFLEN can handle 1024 bytes */
+               n = 0;
+       else
+               memcpy(buffer + 4, buf, n);
+
+       writefd_unbuffered(fd, buffer, n+4);
+
+       len -= n;
+       buf += n;
+
+#ifdef ICONV_OPTION
+       if (convert) {
+               iconv(ic_send, NULL, 0, NULL, 0);
+               defer_forwarding_messages++;
+               while (len) {
+                       ICONV_CONST char *ibuf = (ICONV_CONST char *)buf;
+                       char *obuf = buffer;
+                       size_t ocnt = sizeof buffer;
+                       while (len && iconv(ic_send, &ibuf,&len,
+                                           &obuf,&ocnt) == (size_t)-1) {
+                               if (errno == E2BIG || !ocnt)
+                                       break;
+                               *obuf++ = *ibuf++;
+                               ocnt--, len--;
+                       }
+                       n = obuf - buffer;
+                       writefd_unbuffered(fd, buffer, n);
                }
+               if (!--defer_forwarding_messages)
+                       msg_flush();
+       } else
+#endif
+       if (len) {
+               defer_forwarding_messages++;
+               writefd_unbuffered(fd, buf, len);
+               if (!--defer_forwarding_messages)
+                       msg_flush();
        }
-       return 1;
 }
 
-void send_msg(enum msgcode code, char *buf, int len)
+int send_msg(enum msgcode code, const char *buf, int len, int convert)
 {
        if (msg_fd_out < 0) {
-               io_multiplex_write(code, buf, len);
-               return;
+               if (!defer_forwarding_messages)
+                       return io_multiplex_write(code, buf, len, convert);
+               if (!io_multiplexing_out)
+                       return 0;
+               msg_list_add(&msg_queue, code, buf, len, convert);
+               return 1;
        }
-       msg_list_add(&msg2genr, code, buf, len);
-       msg2genr_flush(NORMAL_FLUSH);
+       if (flist_forward_from >= 0)
+               msg_list_add(&msg_queue, code, buf, len, convert);
+       else
+               mplex_write(msg_fd_out, code, buf, len, convert);
+       return 1;
 }
 
-int get_redo_num(int itemizing, enum logcode code)
+void send_msg_int(enum msgcode code, int num)
 {
-       while (1) {
-               if (hlink_list.head)
-                       check_for_finished_hlinks(itemizing, code);
-               if (redo_list.head)
-                       break;
+       char numbuf[4];
+       SIVAL(numbuf, 0, num);
+       send_msg(code, numbuf, 4, 0);
+}
+
+void wait_for_receiver(void)
+{
+       if (iobuf_out_cnt)
+               io_flush(NORMAL_FLUSH);
+       else
                read_msg_fd();
-       }
+}
 
+int get_redo_num(void)
+{
        return flist_ndx_pop(&redo_list);
 }
 
@@ -472,7 +620,7 @@ static int read_timeout(int fd, char *buf, size_t len)
 {
        int n, cnt = 0;
 
-       io_flush(NORMAL_FLUSH);
+       io_flush(FULL_FLUSH);
 
        while (cnt == 0) {
                /* until we manage to read *something* */
@@ -484,11 +632,6 @@ static int read_timeout(int fd, char *buf, size_t len)
                FD_ZERO(&r_fds);
                FD_ZERO(&w_fds);
                FD_SET(fd, &r_fds);
-               if (msg2genr.head) {
-                       FD_SET(msg_fd_out, &w_fds);
-                       if (msg_fd_out > maxfd)
-                               maxfd = msg_fd_out;
-               }
                if (io_filesfrom_f_out >= 0) {
                        int new_fd;
                        if (io_filesfrom_buflen == 0) {
@@ -515,15 +658,14 @@ static int read_timeout(int fd, char *buf, size_t len)
                count = select(maxfd + 1, &r_fds, &w_fds, NULL, &tv);
 
                if (count <= 0) {
-                       if (errno == EBADF)
+                       if (errno == EBADF) {
+                               defer_forwarding_messages = 0;
                                exit_cleanup(RERR_SOCKETIO);
+                       }
                        check_timeout();
                        continue;
                }
 
-               if (msg2genr.head && FD_ISSET(msg_fd_out, &w_fds))
-                       msg2genr_flush(NORMAL_FLUSH);
-
                if (io_filesfrom_f_out >= 0) {
                        if (io_filesfrom_buflen) {
                                if (FD_ISSET(io_filesfrom_f_out, &w_fds)) {
@@ -535,7 +677,7 @@ static int read_timeout(int fd, char *buf, size_t len)
                                                        io_filesfrom_bp = io_filesfrom_buf;
                                                else
                                                        io_filesfrom_bp += l;
-                                       } else {
+                                       } else if (errno != EINTR) {
                                                /* XXX should we complain? */
                                                io_filesfrom_f_out = -1;
                                        }
@@ -546,11 +688,13 @@ static int read_timeout(int fd, char *buf, size_t len)
                                                     io_filesfrom_buf,
                                                     sizeof io_filesfrom_buf);
                                        if (l <= 0) {
-                                               /* Send end-of-file marker */
-                                               io_filesfrom_buf[0] = '\0';
-                                               io_filesfrom_buf[1] = '\0';
-                                               io_filesfrom_buflen = io_filesfrom_lastchar? 2 : 1;
-                                               io_filesfrom_f_in = -1;
+                                               if (l == 0 || errno != EINTR) {
+                                                       /* Send end-of-file marker */
+                                                       io_filesfrom_buf[0] = '\0';
+                                                       io_filesfrom_buf[1] = '\0';
+                                                       io_filesfrom_buflen = io_filesfrom_lastchar? 2 : 1;
+                                                       io_filesfrom_f_in = -1;
+                                               }
                                        } else {
                                                if (!eol_nulls) {
                                                        char *s = io_filesfrom_buf + l;
@@ -601,7 +745,7 @@ static int read_timeout(int fd, char *buf, size_t len)
 
                        /* Don't write errors on a dead socket. */
                        if (fd == sock_f_in) {
-                               close_multiplexing_out();
+                               io_end_multiplex_out();
                                rsyserr(FSOCKERR, errno, "read error");
                        } else
                                rsyserr(FERROR, errno, "read error");
@@ -619,10 +763,8 @@ static int read_timeout(int fd, char *buf, size_t len)
        return cnt;
 }
 
-/**
- * Read a line into the "fname" buffer (which must be at least MAXPATHLEN
- * characters long).
- */
+/* Read a line into the "fname" buffer (which must be at least MAXPATHLEN
+ * characters long). */
 int read_filesfrom_line(int fd, char *fname)
 {
        char ch, *s, *eob = fname + MAXPATHLEN - 1;
@@ -637,13 +779,19 @@ int read_filesfrom_line(int fd, char *fname)
                if (cnt < 0 && (errno == EWOULDBLOCK
                  || errno == EINTR || errno == EAGAIN)) {
                        struct timeval tv;
-                       fd_set fds;
-                       FD_ZERO(&fds);
-                       FD_SET(fd, &fds);
+                       fd_set r_fds, e_fds;
+                       FD_ZERO(&r_fds);
+                       FD_SET(fd, &r_fds);
+                       FD_ZERO(&e_fds);
+                       FD_SET(fd, &e_fds);
                        tv.tv_sec = select_timeout;
                        tv.tv_usec = 0;
-                       if (!select(fd+1, &fds, NULL, NULL, &tv))
+                       if (!select(fd+1, &r_fds, NULL, &e_fds, &tv))
                                check_timeout();
+                       if (FD_ISSET(fd, &e_fds)) {
+                               rsyserr(FINFO, errno,
+                                       "select exception on fd %d", fd);
+                       }
                        continue;
                }
                if (cnt != 1)
@@ -666,42 +814,57 @@ int read_filesfrom_line(int fd, char *fname)
        return s - fname;
 }
 
-static char *iobuf_out;
-static int iobuf_out_cnt;
-
-void io_start_buffering_out(void)
+int io_start_buffering_out(int f_out)
 {
-       if (iobuf_out)
-               return;
+       if (iobuf_out) {
+               assert(f_out == iobuf_f_out);
+               return 0;
+       }
        if (!(iobuf_out = new_array(char, IO_BUFFER_SIZE)))
                out_of_memory("io_start_buffering_out");
        iobuf_out_cnt = 0;
+       iobuf_f_out = f_out;
+       return 1;
 }
 
-static char *iobuf_in;
-static size_t iobuf_in_siz;
-
-void io_start_buffering_in(void)
+int io_start_buffering_in(int f_in)
 {
-       if (iobuf_in)
-               return;
+       if (iobuf_in) {
+               assert(f_in == iobuf_f_in);
+               return 0;
+       }
        iobuf_in_siz = 2 * IO_BUFFER_SIZE;
        if (!(iobuf_in = new_array(char, iobuf_in_siz)))
                out_of_memory("io_start_buffering_in");
+       iobuf_f_in = f_in;
+       return 1;
 }
 
-void io_end_buffering(void)
+void io_end_buffering_in(void)
 {
-       io_flush(NORMAL_FLUSH);
-       if (!io_multiplexing_out) {
-               free(iobuf_out);
-               iobuf_out = NULL;
-       }
+       if (!iobuf_in)
+               return;
+       free(iobuf_in);
+       iobuf_in = NULL;
+       iobuf_in_ndx = 0;
+       iobuf_in_remaining = 0;
+       iobuf_f_in = -1;
+}
+
+void io_end_buffering_out(void)
+{
+       if (!iobuf_out)
+               return;
+       io_flush(FULL_FLUSH);
+       free(iobuf_out);
+       iobuf_out = NULL;
+       iobuf_f_out = -1;
 }
 
-void maybe_flush_socket(void)
+void maybe_flush_socket(int important)
 {
-       if (iobuf_out && iobuf_out_cnt && time(NULL) - last_io_out >= 5)
+       if (iobuf_out && iobuf_out_cnt
+        && (important || time(NULL) - last_io_out >= 5))
                io_flush(NORMAL_FLUSH);
 }
 
@@ -711,14 +874,31 @@ void maybe_send_keepalive(void)
                if (!iobuf_out || !iobuf_out_cnt) {
                        if (protocol_version < 29)
                                return; /* there's nothing we can do */
-                       write_int(sock_f_out, the_file_list->count);
-                       write_shortint(sock_f_out, ITEM_IS_NEW);
+                       if (protocol_version >= 30)
+                               send_msg(MSG_NOOP, "", 0, 0);
+                       else {
+                               write_int(sock_f_out, cur_flist->used);
+                               write_shortint(sock_f_out, ITEM_IS_NEW);
+                       }
                }
                if (iobuf_out)
                        io_flush(NORMAL_FLUSH);
        }
 }
 
+void start_flist_forward(int f_in)
+{
+       assert(iobuf_out != NULL);
+       assert(iobuf_f_out == msg_fd_out);
+       flist_forward_from = f_in;
+}
+
+void stop_flist_forward()
+{
+       flist_forward_from = -1;
+       io_flush(FULL_FLUSH);
+}
+
 /**
  * Continue trying to read len bytes - don't return until len has been
  * read.
@@ -741,26 +921,24 @@ static void read_loop(int fd, char *buf, size_t len)
  */
 static int readfd_unbuffered(int fd, char *buf, size_t len)
 {
-       static size_t remaining;
-       static size_t iobuf_in_ndx;
        size_t msg_bytes;
        int tag, cnt = 0;
        char line[BIGPATHBUFLEN];
 
-       if (!iobuf_in || fd != sock_f_in)
+       if (!iobuf_in || fd != iobuf_f_in)
                return read_timeout(fd, buf, len);
 
-       if (!io_multiplexing_in && remaining == 0) {
-               remaining = read_timeout(fd, iobuf_in, iobuf_in_siz);
+       if (!io_multiplexing_in && iobuf_in_remaining == 0) {
+               iobuf_in_remaining = read_timeout(fd, iobuf_in, iobuf_in_siz);
                iobuf_in_ndx = 0;
        }
 
        while (cnt == 0) {
-               if (remaining) {
-                       len = MIN(len, remaining);
+               if (iobuf_in_remaining) {
+                       len = MIN(len, iobuf_in_remaining);
                        memcpy(buf, iobuf_in + iobuf_in_ndx, len);
                        iobuf_in_ndx += len;
-                       remaining -= len;
+                       iobuf_in_remaining -= len;
                        cnt = len;
                        break;
                }
@@ -780,13 +958,46 @@ static int readfd_unbuffered(int fd, char *buf, size_t len)
                                iobuf_in_siz = msg_bytes;
                        }
                        read_loop(fd, iobuf_in, msg_bytes);
-                       remaining = msg_bytes;
+                       iobuf_in_remaining = msg_bytes;
                        iobuf_in_ndx = 0;
                        break;
+               case MSG_NOOP:
+                       if (am_sender)
+                               maybe_send_keepalive();
+                       break;
+               case MSG_IO_ERROR:
+                       if (msg_bytes != 4)
+                               goto invalid_msg;
+                       read_loop(fd, line, msg_bytes);
+                       io_error |= IVAL(line, 0);
+                       break;
                case MSG_DELETED:
                        if (msg_bytes >= sizeof line)
                                goto overflow;
-                       read_loop(fd, line, msg_bytes);
+#ifdef ICONV_OPTION
+                       if (ic_recv != (iconv_t)-1) {
+                               ICONV_CONST char *ibuf;
+                               char *obuf = line;
+                               size_t icnt, ocnt = sizeof line - 1;
+                               int add_null = 0;
+                               iconv(ic_send, NULL, 0, NULL, 0);
+                               while (msg_bytes) {
+                                       icnt = msg_bytes > sizeof iconv_buf
+                                            ? sizeof iconv_buf : msg_bytes;
+                                       read_loop(fd, iconv_buf, icnt);
+                                       if (!(msg_bytes -= icnt) && !iconv_buf[icnt-1])
+                                               icnt--, add_null = 1;
+                                       ibuf = (ICONV_CONST char *)iconv_buf;
+                                       if (iconv(ic_send, &ibuf,&icnt,
+                                                 &obuf,&ocnt) == (size_t)-1)
+                                               goto overflow; // XXX
+                               }
+                               if (add_null)
+                                       *obuf++ = '\0';
+                               msg_bytes = obuf - line;
+                       } else
+#endif
+                               read_loop(fd, line, msg_bytes);
                        /* A directory name was sent with the trailing null */
                        if (msg_bytes > 0 && !line[msg_bytes-1])
                                log_delete(line, S_IFDIR);
@@ -797,6 +1008,7 @@ static int readfd_unbuffered(int fd, char *buf, size_t len)
                        break;
                case MSG_SUCCESS:
                        if (msg_bytes != 4) {
+                         invalid_msg:
                                rprintf(FERROR, "invalid multi-message %d:%ld [%s]\n",
                                        tag, (long)msg_bytes, who_am_i());
                                exit_cleanup(RERR_STREAMIO);
@@ -804,6 +1016,12 @@ static int readfd_unbuffered(int fd, char *buf, size_t len)
                        read_loop(fd, line, msg_bytes);
                        successful_send(IVAL(line, 0));
                        break;
+               case MSG_NO_SEND:
+                       if (msg_bytes != 4)
+                               goto invalid_msg;
+                       read_loop(fd, line, msg_bytes);
+                       send_msg_int(MSG_NO_SEND, IVAL(line, 0));
+                       break;
                case MSG_INFO:
                case MSG_ERROR:
                        if (msg_bytes >= sizeof line) {
@@ -814,7 +1032,7 @@ static int readfd_unbuffered(int fd, char *buf, size_t len)
                                exit_cleanup(RERR_STREAMIO);
                        }
                        read_loop(fd, line, msg_bytes);
-                       rwrite((enum logcode)tag, line, msg_bytes);
+                       rwrite((enum logcode)tag, line, msg_bytes, 1);
                        break;
                default:
                        rprintf(FERROR, "unexpected tag %d [%s]\n",
@@ -823,17 +1041,14 @@ static int readfd_unbuffered(int fd, char *buf, size_t len)
                }
        }
 
-       if (remaining == 0)
+       if (iobuf_in_remaining == 0)
                io_flush(NORMAL_FLUSH);
 
        return cnt;
 }
 
-/**
- * Do a buffered read from @p fd.  Don't return until all @p n bytes
- * have been read.  If all @p n can't be read then exit with an
- * error.
- **/
+/* Do a buffered read from fd.  Don't return until all N bytes have
+ * been read.  If all N can't be read then exit with an error. */
 static void readfd(int fd, char *buffer, size_t N)
 {
        int  cnt;
@@ -849,15 +1064,18 @@ static void readfd(int fd, char *buffer, size_t N)
                        exit_cleanup(RERR_FILEIO);
        }
 
+       if (fd == flist_forward_from)
+               writefd(iobuf_f_out, buffer, total);
+
        if (fd == sock_f_in)
                stats.total_read += total;
 }
 
-int read_shortint(int f)
+unsigned short read_shortint(int f)
 {
-       uchar b[2];
-       readfd(f, (char *)b, 2);
-       return (b[1] << 8) + b[0];
+       char b[2];
+       readfd(f, b, 2);
+       return (UVAL(b, 1) << 8) + UVAL(b, 0);
 }
 
 int32 read_int(int f)
@@ -865,39 +1083,113 @@ int32 read_int(int f)
        char b[4];
        int32 num;
 
-       readfd(f,b,4);
-       num = IVAL(b,0);
-       if (num == (int32)0xffffffff)
-               return -1;
+       readfd(f, b, 4);
+       num = IVAL(b, 0);
+#if SIZEOF_INT32 > 4
+       if (num & (int32)0x80000000)
+               num |= ~(int32)0xffffffff;
+#endif
        return num;
 }
 
+int32 read_varint(int f)
+{
+       union {
+           char b[5];
+           int32 x;
+       } u;
+       uchar ch;
+       int extra;
+
+       u.x = 0;
+       readfd(f, (char*)&ch, 1);
+       extra = int_byte_extra[ch / 4];
+       if (extra) {
+               uchar bit = ((uchar)1<<(8-extra));
+               if (extra >= (int)sizeof u.b) {
+                       rprintf(FERROR, "Overflow in read_varint()\n");
+                       exit_cleanup(RERR_STREAMIO);
+               }
+               readfd(f, u.b, extra);
+               u.b[extra] = ch & (bit-1);
+       } else
+               u.b[0] = ch;
+#if CAREFUL_ALIGNMENT
+       u.x = IVAL(u.b,0);
+#endif
+#if SIZEOF_INT32 > 4
+       if (u.x & (int32)0x80000000)
+               u.x |= ~(int32)0xffffffff;
+#endif
+       return u.x;
+}
+
+int64 read_varlong(int f, uchar min_bytes)
+{
+       union {
+           char b[9];
+           int64 x;
+       } u;
+       char b2[8];
+       int extra;
+
+#if SIZEOF_INT64 < 8
+       memset(u.b, 0, 8);
+#else
+       u.x = 0;
+#endif
+       readfd(f, b2, min_bytes);
+       memcpy(u.b, b2+1, min_bytes-1);
+       extra = int_byte_extra[CVAL(b2, 0) / 4];
+       if (extra) {
+               uchar bit = ((uchar)1<<(8-extra));
+               if (min_bytes + extra > (int)sizeof u.b) {
+                       rprintf(FERROR, "Overflow in read_varlong()\n");
+                       exit_cleanup(RERR_STREAMIO);
+               }
+               readfd(f, u.b + min_bytes - 1, extra);
+               u.b[min_bytes + extra - 1] = CVAL(b2, 0) & (bit-1);
+#if SIZEOF_INT64 < 8
+               if (min_bytes + extra > 5 || u.b[4] || CVAL(u.b,3) & 0x80) {
+                       rprintf(FERROR, "Integer overflow: attempted 64-bit offset\n");
+                       exit_cleanup(RERR_UNSUPPORTED);
+               }
+#endif
+       } else
+               u.b[min_bytes + extra - 1] = CVAL(b2, 0);
+#if SIZEOF_INT64 < 8
+       u.x = IVAL(u.b,0);
+#elif CAREFUL_ALIGNMENT
+       u.x = IVAL(u.b,0) | (((int64)IVAL(u.b,4))<<32);
+#endif
+       return u.x;
+}
+
 int64 read_longint(int f)
 {
-       int64 num;
-       char b[8];
-       num = read_int(f);
+#if SIZEOF_INT64 >= 8
+       char b[9];
+#endif
+       int32 num = read_int(f);
 
-       if ((int32)num != (int32)0xffffffff)
+       if (num != (int32)0xffffffff)
                return num;
 
 #if SIZEOF_INT64 < 8
        rprintf(FERROR, "Integer overflow: attempted 64-bit offset\n");
        exit_cleanup(RERR_UNSUPPORTED);
 #else
-       readfd(f,b,8);
-       num = IVAL(b,0) | (((int64)IVAL(b,4))<<32);
+       readfd(f, b, 8);
+       return IVAL(b,0) | (((int64)IVAL(b,4))<<32);
 #endif
-
-       return num;
 }
 
-void read_buf(int f,char *buf,size_t len)
+void read_buf(int f, char *buf, size_t len)
 {
        readfd(f,buf,len);
 }
 
-void read_sbuf(int f,char *buf,size_t len)
+void read_sbuf(int f, char *buf, size_t len)
 {
        readfd(f, buf, len);
        buf[len] = '\0';
@@ -946,7 +1238,7 @@ void read_sum_head(int f, struct sum_struct *sum)
                exit_cleanup(RERR_PROTOCOL);
        }
        sum->s2length = protocol_version < 27 ? csum_length : (int)read_int(f);
-       if (sum->s2length < 0 || sum->s2length > MD4_SUM_LENGTH) {
+       if (sum->s2length < 0 || sum->s2length > MAX_DIGEST_LEN) {
                rprintf(FERROR, "Invalid checksum length %d [%s]\n",
                        sum->s2length, who_am_i());
                exit_cleanup(RERR_PROTOCOL);
@@ -1037,24 +1329,27 @@ static void sleep_for_bwlimit(int bytes_written)
  *
  * This function underlies the multiplexing system.  The body of the
  * application never calls this function directly. */
-static void writefd_unbuffered(int fd,char *buf,size_t len)
+static void writefd_unbuffered(int fd, const char *buf, size_t len)
 {
        size_t n, total = 0;
-       fd_set w_fds, r_fds;
+       fd_set w_fds, r_fds, e_fds;
        int maxfd, count, cnt, using_r_fds;
-       int defer_save = defer_forwarding_messages;
+       int defer_inc = 0;
        struct timeval tv;
 
-       no_flush++;
+       if (no_flush++)
+               defer_forwarding_messages++, defer_inc++;
 
        while (total < len) {
                FD_ZERO(&w_fds);
-               FD_SET(fd,&w_fds);
+               FD_SET(fd, &w_fds);
+               FD_ZERO(&e_fds);
+               FD_SET(fd, &e_fds);
                maxfd = fd;
 
                if (msg_fd_in >= 0) {
                        FD_ZERO(&r_fds);
-                       FD_SET(msg_fd_in,&r_fds);
+                       FD_SET(msg_fd_in, &r_fds);
                        if (msg_fd_in > maxfd)
                                maxfd = msg_fd_in;
                        using_r_fds = 1;
@@ -1066,7 +1361,7 @@ static void writefd_unbuffered(int fd,char *buf,size_t len)
 
                errno = 0;
                count = select(maxfd + 1, using_r_fds ? &r_fds : NULL,
-                              &w_fds, NULL, &tv);
+                              &w_fds, &e_fds, &tv);
 
                if (count <= 0) {
                        if (count < 0 && errno == EBADF)
@@ -1075,6 +1370,11 @@ static void writefd_unbuffered(int fd,char *buf,size_t len)
                        continue;
                }
 
+               if (FD_ISSET(fd, &e_fds)) {
+                       rsyserr(FINFO, errno,
+                               "select exception on fd %d", fd);
+               }
+
                if (using_r_fds && FD_ISSET(msg_fd_in, &r_fds))
                        read_msg_fd();
 
@@ -1098,7 +1398,10 @@ static void writefd_unbuffered(int fd,char *buf,size_t len)
 
                        /* Don't try to write errors back across the stream. */
                        if (fd == sock_f_out)
-                               close_multiplexing_out();
+                               io_end_multiplex_out();
+                       /* Don't try to write errors down a failing msg pipe. */
+                       if (am_server && fd == msg_fd_out)
+                               exit_cleanup(RERR_STREAMIO);
                        rsyserr(FERROR, errno,
                                "writefd_unbuffered failed to write %ld bytes [%s]",
                                (long)len, who_am_i());
@@ -1114,7 +1417,7 @@ static void writefd_unbuffered(int fd,char *buf,size_t len)
                }
 
                total += cnt;
-               defer_forwarding_messages = 1;
+               defer_forwarding_messages++, defer_inc++;
 
                if (fd == sock_f_out) {
                        if (io_timeout || am_generator)
@@ -1123,78 +1426,28 @@ static void writefd_unbuffered(int fd,char *buf,size_t len)
                }
        }
 
-       defer_forwarding_messages = defer_save;
        no_flush--;
-}
-
-static void msg2sndr_flush(void)
-{
-       if (defer_forwarding_messages)
-               return;
-
-       while (msg2sndr.head && io_multiplexing_out) {
-               struct msg_list_item *m = msg2sndr.head;
-               if (!(msg2sndr.head = m->next))
-                       msg2sndr.tail = NULL;
-               stats.total_written += m->len;
-               defer_forwarding_messages = 1;
-               writefd_unbuffered(sock_f_out, m->buf, m->len);
-               defer_forwarding_messages = 0;
-               free(m);
-       }
-}
-
-/**
- * Write an message to a multiplexed stream. If this fails then rsync
- * exits.
- **/
-static void mplex_write(enum msgcode code, char *buf, size_t len)
-{
-       char buffer[1024];
-       size_t n = len;
-
-       SIVAL(buffer, 0, ((MPLEX_BASE + (int)code)<<24) + len);
-
-       if (n > sizeof buffer - 4)
-               n = 0;
-       else
-               memcpy(buffer + 4, buf, n);
-
-       writefd_unbuffered(sock_f_out, buffer, n+4);
-
-       len -= n;
-       buf += n;
-
-       if (len) {
-               defer_forwarding_messages = 1;
-               writefd_unbuffered(sock_f_out, buf, len);
-               defer_forwarding_messages = 0;
-               msg2sndr_flush();
-       }
+       if (!(defer_forwarding_messages -= defer_inc))
+               msg_flush();
 }
 
 void io_flush(int flush_it_all)
 {
-       msg2genr_flush(flush_it_all);
-       msg2sndr_flush();
-
        if (!iobuf_out_cnt || no_flush)
                return;
 
        if (io_multiplexing_out)
-               mplex_write(MSG_DATA, iobuf_out, iobuf_out_cnt);
+               mplex_write(sock_f_out, MSG_DATA, iobuf_out, iobuf_out_cnt, 0);
        else
-               writefd_unbuffered(sock_f_out, iobuf_out, iobuf_out_cnt);
+               writefd_unbuffered(iobuf_f_out, iobuf_out, iobuf_out_cnt);
        iobuf_out_cnt = 0;
+
+       if (flush_it_all && !defer_forwarding_messages)
+               msg_flush();
 }
 
-static void writefd(int fd,char *buf,size_t len)
+static void writefd(int fd, const char *buf, size_t len)
 {
-       if (fd == msg_fd_out) {
-               rprintf(FERROR, "Internal error: wrong write used in receiver.\n");
-               exit_cleanup(RERR_PROTOCOL);
-       }
-
        if (fd == sock_f_out)
                stats.total_written += len;
 
@@ -1203,7 +1456,7 @@ static void writefd(int fd,char *buf,size_t len)
                        exit_cleanup(RERR_FILEIO);
        }
 
-       if (!iobuf_out || fd != sock_f_out) {
+       if (!iobuf_out || fd != iobuf_f_out) {
                writefd_unbuffered(fd, buf, len);
                return;
        }
@@ -1222,19 +1475,73 @@ static void writefd(int fd,char *buf,size_t len)
        }
 }
 
-void write_shortint(int f, int x)
+void write_shortint(int f, unsigned short x)
 {
-       uchar b[2];
-       b[0] = x;
-       b[1] = x >> 8;
-       writefd(f, (char *)b, 2);
+       char b[2];
+       b[0] = (char)x;
+       b[1] = (char)(x >> 8);
+       writefd(f, b, 2);
 }
 
-void write_int(int f,int32 x)
+void write_int(int f, int32 x)
 {
        char b[4];
-       SIVAL(b,0,x);
-       writefd(f,b,4);
+       SIVAL(b, 0, x);
+       writefd(f, b, 4);
+}
+
+void write_varint(int f, int32 x)
+{
+       char b[5];
+       uchar bit;
+       int cnt = 4;
+
+       SIVAL(b, 1, x);
+
+       while (cnt > 1 && b[cnt] == 0)
+               cnt--;
+       bit = ((uchar)1<<(7-cnt+1));
+       if (CVAL(b, cnt) >= bit) {
+               cnt++;
+               *b = ~(bit-1);
+       } else if (cnt > 1)
+               *b = b[cnt] | ~(bit*2-1);
+       else
+               *b = b[cnt];
+
+       writefd(f, b, cnt);
+}
+
+void write_varlong(int f, int64 x, uchar min_bytes)
+{
+       char b[9];
+       uchar bit;
+       int cnt = 8;
+
+       SIVAL(b, 1, x);
+#if SIZEOF_INT64 >= 8
+       SIVAL(b, 5, x >> 32);
+#else
+       if (x <= 0x7FFFFFFF && x >= 0)
+               memset(b + 5, 0, 4);
+       else {
+               rprintf(FERROR, "Integer overflow: attempted 64-bit offset\n");
+               exit_cleanup(RERR_UNSUPPORTED);
+       }
+#endif
+
+       while (cnt > min_bytes && b[cnt] == 0)
+               cnt--;
+       bit = ((uchar)1<<(7-cnt+min_bytes));
+       if (CVAL(b, cnt) >= bit) {
+               cnt++;
+               *b = ~(bit-1);
+       } else if (cnt > min_bytes)
+               *b = b[cnt] | ~(bit*2-1);
+       else
+               *b = b[cnt];
+
+       writefd(f, b, cnt);
 }
 
 /*
@@ -1243,10 +1550,11 @@ void write_int(int f,int32 x)
  */
 void write_longint(int f, int64 x)
 {
-       char b[8];
+       char b[12], * const s = b+4;
 
-       if (x <= 0x7FFFFFFF) {
-               write_int(f, (int)x);
+       SIVAL(s, 0, x);
+       if (x <= 0x7FFFFFFF && x >= 0) {
+               writefd(f, s, 4);
                return;
        }
 
@@ -1254,21 +1562,19 @@ void write_longint(int f, int64 x)
        rprintf(FERROR, "Integer overflow: attempted 64-bit offset\n");
        exit_cleanup(RERR_UNSUPPORTED);
 #else
-       write_int(f, (int32)0xFFFFFFFF);
-       SIVAL(b,0,(x&0xFFFFFFFF));
-       SIVAL(b,4,((x>>32)&0xFFFFFFFF));
-
-       writefd(f,b,8);
+       memset(b, 0xFF, 4);
+       SIVAL(s, 4, x >> 32);
+       writefd(f, b, 12);
 #endif
 }
 
-void write_buf(int f,char *buf,size_t len)
+void write_buf(int f, const char *buf, size_t len)
 {
        writefd(f,buf,len);
 }
 
 /** Write a string to the connection */
-void write_sbuf(int f, char *buf)
+void write_sbuf(int f, const char *buf)
 {
        writefd(f, buf, strlen(buf));
 }
@@ -1278,7 +1584,7 @@ void write_byte(int f, uchar c)
        writefd(f, (char *)&c, 1);
 }
 
-void write_vstring(int f, char *str, int len)
+void write_vstring(int f, const char *str, int len)
 {
        uchar lenbuf[3], *lb = lenbuf;
 
@@ -1298,6 +1604,88 @@ void write_vstring(int f, char *str, int len)
                writefd(f, str, len);
 }
 
+/* Send a file-list index using a byte-reduction method. */
+void write_ndx(int f, int32 ndx)
+{
+       static int32 prev_positive = -1, prev_negative = 1;
+       int32 diff, cnt = 0;
+       char b[6];
+
+       if (protocol_version < 30 || read_batch) {
+               write_int(f, ndx);
+               return;
+       }
+
+       /* Send NDX_DONE as a single-byte 0 with no side effects.  Send
+        * negative nums as a positive after sending a leading 0xFF. */
+       if (ndx >= 0) {
+               diff = ndx - prev_positive;
+               prev_positive = ndx;
+       } else if (ndx == NDX_DONE) {
+               *b = 0;
+               writefd(f, b, 1);
+               return;
+       } else {
+               b[cnt++] = (char)0xFF;
+               ndx = -ndx;
+               diff = ndx - prev_negative;
+               prev_negative = ndx;
+       }
+
+       /* A diff of 1 - 253 is sent as a one-byte diff; a diff of 254 - 32767
+        * or 0 is sent as a 0xFE + a two-byte diff; otherwise we send 0xFE
+        * & all 4 bytes of the (non-negative) num with the high-bit set. */
+       if (diff < 0xFE && diff > 0)
+               b[cnt++] = (char)diff;
+       else if (diff < 0 || diff > 0x7FFF) {
+               b[cnt++] = (char)0xFE;
+               b[cnt++] = (char)((ndx >> 24) | 0x80);
+               b[cnt++] = (char)ndx;
+               b[cnt++] = (char)(ndx >> 8);
+               b[cnt++] = (char)(ndx >> 16);
+       } else {
+               b[cnt++] = (char)0xFE;
+               b[cnt++] = (char)(diff >> 8);
+               b[cnt++] = (char)diff;
+       }
+       writefd(f, b, cnt);
+}
+
+/* Receive a file-list index using a byte-reduction method. */
+int32 read_ndx(int f)
+{
+       static int32 prev_positive = -1, prev_negative = 1;
+       int32 *prev_ptr, num;
+       char b[4];
+
+       if (protocol_version < 30)
+               return read_int(f);
+
+       readfd(f, b, 1);
+       if (CVAL(b, 0) == 0xFF) {
+               readfd(f, b, 1);
+               prev_ptr = &prev_negative;
+       } else if (CVAL(b, 0) == 0)
+               return NDX_DONE;
+       else
+               prev_ptr = &prev_positive;
+       if (CVAL(b, 0) == 0xFE) {
+               readfd(f, b, 2);
+               if (CVAL(b, 0) & 0x80) {
+                       b[3] = CVAL(b, 0) & ~0x80;
+                       b[0] = b[1];
+                       readfd(f, b+1, 2);
+                       num = IVAL(b, 0);
+               } else
+                       num = (UVAL(b,0)<<8) + UVAL(b,1) + *prev_ptr;
+       } else
+               num = UVAL(b, 0) + *prev_ptr;
+       *prev_ptr = num;
+       if (prev_ptr == &prev_negative)
+               num = -num;
+       return num;
+}
+
 /**
  * Read a line of up to @p maxlen characters into @p buf (not counting
  * the trailing null).  Strips the (required) trailing newline and all
@@ -1348,7 +1736,7 @@ void io_printf(int fd, const char *format, ...)
 void io_start_multiplex_out(void)
 {
        io_flush(NORMAL_FLUSH);
-       io_start_buffering_out();
+       io_start_buffering_out(sock_f_out);
        io_multiplexing_out = 1;
 }
 
@@ -1356,37 +1744,36 @@ void io_start_multiplex_out(void)
 void io_start_multiplex_in(void)
 {
        io_flush(NORMAL_FLUSH);
-       io_start_buffering_in();
+       io_start_buffering_in(sock_f_in);
        io_multiplexing_in = 1;
 }
 
 /** Write an message to the multiplexed data stream. */
-int io_multiplex_write(enum msgcode code, char *buf, size_t len)
+int io_multiplex_write(enum msgcode code, const char *buf, size_t len, int convert)
 {
        if (!io_multiplexing_out)
                return 0;
-
        io_flush(NORMAL_FLUSH);
        stats.total_written += (len+4);
-       mplex_write(code, buf, len);
+       mplex_write(sock_f_out, code, buf, len, convert);
        return 1;
 }
 
-void close_multiplexing_in(void)
+void io_end_multiplex_in(void)
 {
        io_multiplexing_in = 0;
+       io_end_buffering_in();
 }
 
 /** Stop output multiplexing. */
-void close_multiplexing_out(void)
+void io_end_multiplex_out(void)
 {
        io_multiplexing_out = 0;
+       io_end_buffering_out();
 }
 
 void start_write_batch(int fd)
 {
-       write_stream_flags(batch_fd);
-
        /* Some communication has already taken place, but we don't
         * enable batch writing until here so that we can write a
         * canonical record of the communication even though the