X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/55d5937dd62be7224de88e40bdba8b91af4295cc..d62bcc17f303f30d1e3df1051b1390202a21cf9c:/io.c

diff --git a/io.c b/io.c
index 3ca13df5..c9691ed1 100644
--- a/io.c
+++ b/io.c
@@ -1,19 +1,19 @@
 /* -*- c-file-style: "linux" -*-
- * 
- * Copyright (C) 1996-2001 by Andrew Tridgell 
+ *
+ * Copyright (C) 1996-2001 by Andrew Tridgell
  * Copyright (C) Paul Mackerras 1996
  * Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
- * 
+ *
  * 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.
@@ -22,7 +22,7 @@
 /**
  * @file io.c
  *
- * Socket and pipe IO utilities used in rsync.
+ * Socket and pipe I/O utilities used in rsync.
  *
  * rsync provides its own multiplexing system, which is used to send
  * stderr and stdout over a single socket.  We need this because
@@ -41,14 +41,17 @@
 
 static int io_multiplexing_out;
 static int io_multiplexing_in;
-static int multiplex_in_fd;
-static int multiplex_out_fd;
+static int multiplex_in_fd = -1;
+static int multiplex_out_fd = -1;
 static time_t last_io;
 static int no_flush;
 
 extern int bwlimit;
 extern int verbose;
 extern int io_timeout;
+extern int am_server;
+extern int am_daemon;
+extern int am_sender;
 extern struct stats stats;
 
 
@@ -60,9 +63,9 @@ const char phase_unknown[] = "unknown";
  * not very helpful.  So instead we try to make io_phase_name point to
  * something useful.
  *
- * For buffered/multiplexed IO these names will be somewhat
+ * For buffered/multiplexed I/O these names will be somewhat
  * approximate; perhaps for ease of support we would rather make the
- * buffer always flush when a single application-level IO finishes.
+ * buffer always flush when a single application-level I/O finishes.
  *
  * @todo Perhaps we want some simple stack functionality, but there's
  * no need to overdo it.
@@ -74,8 +77,9 @@ const char *io_read_phase = phase_unknown;
     version is 24 or less. */
 int kludge_around_eof = False;
 
+int msg_fd_in = -1;
+int msg_fd_out = -1;
 
-static int io_error_fd = -1;
 static int io_filesfrom_f_in = -1;
 static int io_filesfrom_f_out = -1;
 static char io_filesfrom_buf[2048];
@@ -85,14 +89,44 @@ static int io_filesfrom_buflen;
 
 static void read_loop(int fd, char *buf, size_t len);
 
+struct redo_list {
+	struct redo_list *next;
+	int num;
+};
+
+static struct redo_list *redo_list_head;
+static struct redo_list *redo_list_tail;
+
+struct msg_list {
+	struct msg_list *next;
+	char *buf;
+	int len;
+};
+
+static struct msg_list *msg_list_head;
+static struct msg_list *msg_list_tail;
+
+static void redo_list_add(int num)
+{
+	struct redo_list *rl;
+
+	if (!(rl = new(struct redo_list)))
+		exit_cleanup(RERR_MALLOC);
+	rl->next = NULL;
+	rl->num = num;
+	if (redo_list_tail)
+		redo_list_tail->next = rl;
+	else
+		redo_list_head = rl;
+	redo_list_tail = rl;
+}
+
 static void check_timeout(void)
 {
-	extern int am_server, am_daemon;
 	time_t t;
 
-	err_list_push();
-
-	if (!io_timeout) return;
+	if (!io_timeout)
+		return;
 
 	if (!last_io) {
 		last_io = time(NULL);
@@ -103,48 +137,167 @@ static void check_timeout(void)
 
 	if (last_io && io_timeout && (t-last_io) >= io_timeout) {
 		if (!am_server && !am_daemon) {
-			rprintf(FERROR,"io timeout after %d seconds - exiting\n", 
+			rprintf(FERROR, "io timeout after %d seconds - exiting\n",
 				(int)(t-last_io));
 		}
 		exit_cleanup(RERR_TIMEOUT);
 	}
 }
 
-/** Setup the fd used to propagate errors */
-void io_set_error_fd(int fd)
+/** Setup the fd used to receive MSG_* messages.  Only needed when
+ * we're the generator because the sender and receiver both use the
+ * multiplexed I/O setup. */
+void set_msg_fd_in(int fd)
+{
+	msg_fd_in = fd;
+}
+
+/** Setup the fd used to send our MSG_* messages.  Only needed when
+ * we're the receiver because the generator and the sender both use
+ * the multiplexed I/O setup. */
+void set_msg_fd_out(int fd)
+{
+	msg_fd_out = fd;
+	set_nonblocking(msg_fd_out);
+}
+
+/* Add a message to the pending MSG_* list. */
+static void msg_list_add(int code, char *buf, int len)
+{
+	struct msg_list *ml;
+
+	if (!(ml = new(struct msg_list)))
+		exit_cleanup(RERR_MALLOC);
+	ml->next = NULL;
+	if (!(ml->buf = new_array(char, len+4)))
+		exit_cleanup(RERR_MALLOC);
+	SIVAL(ml->buf, 0, ((code+MPLEX_BASE)<<24) | len);
+	memcpy(ml->buf+4, buf, len);
+	ml->len = len+4;
+	if (msg_list_tail)
+		msg_list_tail->next = ml;
+	else
+		msg_list_head = ml;
+	msg_list_tail = ml;
+}
+
+void send_msg(enum msgcode code, char *buf, int len)
 {
-	io_error_fd = fd;
+	msg_list_add(code, buf, len);
+	msg_list_push(NORMAL_FLUSH);
 }
 
-/** Read some data from the error fd and write it to the write log code */
-static void read_error_fd(void)
+/** Read a message from the MSG_* fd and dispatch it.  This is only
+ * called by the generator. */
+static void read_msg_fd(void)
 {
 	char buf[200];
 	size_t n;
-	int fd = io_error_fd;
+	int fd = msg_fd_in;
 	int tag, len;
 
-	/* io_error_fd is temporarily disabled -- is this meant to
-	 * prevent indefinite recursion? */
-	io_error_fd = -1;
+	/* Temporarily disable msg_fd_in.  This is needed because we
+	 * may call a write routine that could try to call us back. */
+	msg_fd_in = -1;
 
 	read_loop(fd, buf, 4);
 	tag = IVAL(buf, 0);
 
 	len = tag & 0xFFFFFF;
-	tag = tag >> 24;
-	tag -= MPLEX_BASE;
+	tag = (tag >> 24) - MPLEX_BASE;
 
-	while (len) {
-		n = len;
-		if (n > (sizeof buf - 1))
-			n = sizeof buf - 1;
-		read_loop(fd, buf, n);
-		rwrite((enum logcode)tag, buf, n);
-		len -= n;
+	switch (tag) {
+	case MSG_DONE:
+		if (len != 0) {
+			rprintf(FERROR, "invalid message %d:%d\n", tag, len);
+			exit_cleanup(RERR_STREAMIO);
+		}
+		redo_list_add(-1);
+		break;
+	case MSG_REDO:
+		if (len != 4) {
+			rprintf(FERROR, "invalid message %d:%d\n", tag, len);
+			exit_cleanup(RERR_STREAMIO);
+		}
+		read_loop(fd, buf, 4);
+		redo_list_add(IVAL(buf,0));
+		break;
+	case MSG_INFO:
+	case MSG_ERROR:
+	case MSG_LOG:
+		while (len) {
+			n = len;
+			if (n >= sizeof buf)
+				n = sizeof buf - 1;
+			read_loop(fd, buf, n);
+			rwrite((enum logcode)tag, buf, n);
+			len -= n;
+		}
+		break;
+	default:
+		rprintf(FERROR, "unknown message %d:%d\n", tag, len);
+		exit_cleanup(RERR_STREAMIO);
 	}
 
-	io_error_fd = fd;
+	msg_fd_in = fd;
+}
+
+/* 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 called by the receiver. */
+int msg_list_push(int flush_it_all)
+{
+	static int written = 0;
+	struct timeval tv;
+	fd_set fds;
+
+	if (msg_fd_out < 0)
+		return -1;
+
+	while (msg_list_head) {
+		struct msg_list *ml = msg_list_head;
+		int n = write(msg_fd_out, ml->buf + written, ml->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 = io_timeout ? io_timeout : SELECT_TIMEOUT;
+			tv.tv_usec = 0;
+			if (!select(msg_fd_out+1, NULL, &fds, NULL, &tv))
+				check_timeout();
+		} else if ((written += n) == ml->len) {
+			free(ml->buf);
+			msg_list_head = ml->next;
+			if (!msg_list_head)
+				msg_list_tail = NULL;
+			free(ml);
+			written = 0;
+		}
+	}
+	return 1;
+}
+
+int get_redo_num(void)
+{
+	struct redo_list *next;
+	int num;
+
+	while (!redo_list_head)
+		read_msg_fd();
+
+	num = redo_list_head->num;
+	next = redo_list_head->next;
+	free(redo_list_head);
+	redo_list_head = next;
+	if (!next)
+		redo_list_tail = NULL;
+
+	return num;
 }
 
 /**
@@ -181,10 +334,9 @@ static void whine_about_eof(void)
 	if (kludge_around_eof)
 		exit_cleanup(0);
 	else {
-		rprintf(FERROR,
-			"%s: connection unexpectedly closed "
+		rprintf(FERROR, RSYNC_NAME ": connection unexpectedly closed "
 			"(%.0f bytes read so far)\n",
-			RSYNC_NAME, (double)stats.total_read);
+			(double)stats.total_read);
 
 		exit_cleanup(RERR_STREAMIO);
 	}
@@ -196,14 +348,13 @@ static void die_from_readerr(int err)
 	/* this prevents us trying to write errors on a dead socket */
 	io_multiplexing_close();
 
-	rprintf(FERROR, "%s: read error: %s\n",
-		RSYNC_NAME, strerror(err));
+	rsyserr(FERROR, err, "read error");
 	exit_cleanup(RERR_STREAMIO);
 }
 
 
 /**
- * Read from a socket with IO timeout. return the number of bytes
+ * Read from a socket with I/O timeout. return the number of bytes
  * read. If no bytes can be read then exit, never return a number <= 0.
  *
  * TODO: If the remote shell connection fails, then current versions
@@ -215,9 +366,9 @@ static void die_from_readerr(int err)
  */
 static int read_timeout(int fd, char *buf, size_t len)
 {
-	int n, ret=0;
+	int n, ret = 0;
 
-	io_flush();
+	io_flush(NORMAL_FLUSH);
 
 	while (ret == 0) {
 		/* until we manage to read *something* */
@@ -228,14 +379,15 @@ static int read_timeout(int fd, char *buf, size_t len)
 
 		FD_ZERO(&r_fds);
 		FD_SET(fd, &r_fds);
-		if (io_error_fd != -1) {
-			FD_SET(io_error_fd, &r_fds);
-			if (io_error_fd >= fd_count) fd_count = io_error_fd+1;
+		if (msg_fd_in >= 0) {
+			FD_SET(msg_fd_in, &r_fds);
+			if (msg_fd_in >= fd_count)
+				fd_count = msg_fd_in+1;
 		}
-		if (io_filesfrom_f_out != -1) {
+		if (io_filesfrom_f_out >= 0) {
 			int new_fd;
 			if (io_filesfrom_buflen == 0) {
-				if (io_filesfrom_f_in != -1) {
+				if (io_filesfrom_f_in >= 0) {
 					FD_SET(io_filesfrom_f_in, &r_fds);
 					new_fd = io_filesfrom_f_in;
 				} else {
@@ -247,7 +399,8 @@ static int read_timeout(int fd, char *buf, size_t len)
 				FD_SET(io_filesfrom_f_out, &w_fds);
 				new_fd = io_filesfrom_f_out;
 			}
-			if (new_fd >= fd_count) fd_count = new_fd+1;
+			if (new_fd >= fd_count)
+				fd_count = new_fd+1;
 		}
 
 		tv.tv_sec = io_timeout?io_timeout:SELECT_TIMEOUT;
@@ -260,6 +413,7 @@ static int read_timeout(int fd, char *buf, size_t len)
 			       NULL, &tv);
 
 		if (count == 0) {
+			msg_list_push(NORMAL_FLUSH);
 			check_timeout();
 		}
 
@@ -270,12 +424,10 @@ static int read_timeout(int fd, char *buf, size_t len)
 			continue;
 		}
 
+		if (msg_fd_in >= 0 && FD_ISSET(msg_fd_in, &r_fds))
+			read_msg_fd();
 
-		if (io_error_fd != -1 && FD_ISSET(io_error_fd, &r_fds)) {
-			read_error_fd();
-		}
-
-		if (io_filesfrom_f_out != -1) {
+		if (io_filesfrom_f_out >= 0) {
 			if (io_filesfrom_buflen) {
 				if (FD_ISSET(io_filesfrom_f_out, &w_fds)) {
 					int l = write(io_filesfrom_f_out,
@@ -291,7 +443,7 @@ static int read_timeout(int fd, char *buf, size_t len)
 						io_filesfrom_f_out = -1;
 					}
 				}
-			} else if (io_filesfrom_f_in != -1) {
+			} else if (io_filesfrom_f_in >= 0) {
 				if (FD_ISSET(io_filesfrom_f_in, &r_fds)) {
 					int l = read(io_filesfrom_f_in,
 						     io_filesfrom_buf,
@@ -353,9 +505,9 @@ static int read_timeout(int fd, char *buf, size_t len)
 		} else if (n == 0) {
 			whine_about_eof();
 			return -1; /* doesn't return */
-		} else if (n == -1) {
-			if (errno == EINTR || errno == EWOULDBLOCK ||
-			    errno == EAGAIN) 
+		} else if (n < 0) {
+			if (errno == EINTR || errno == EWOULDBLOCK
+			    || errno == EAGAIN)
 				continue;
 			die_from_readerr(errno);
 		}
@@ -433,56 +585,77 @@ static void read_loop(int fd, char *buf, size_t len)
 /**
  * Read from the file descriptor handling multiplexing - return number
  * of bytes read.
- * 
- * Never returns <= 0. 
+ *
+ * Never returns <= 0.
  */
 static int read_unbuffered(int fd, char *buf, size_t len)
 {
 	static size_t remaining;
 	int tag, ret = 0;
 	char line[1024];
+	static char *buffer;
+	static size_t bufferIdx = 0;
+	static size_t bufferSz;
 
-	if (!io_multiplexing_in || fd != multiplex_in_fd)
+	if (fd != multiplex_in_fd)
 		return read_timeout(fd, buf, len);
 
+	if (!io_multiplexing_in && remaining == 0) {
+		if (!buffer) {
+			bufferSz = 2 * IO_BUFFER_SIZE;
+			buffer   = new_array(char, bufferSz);
+			if (!buffer) out_of_memory("read_unbuffered");
+		}
+		remaining = read_timeout(fd, buffer, bufferSz);
+		bufferIdx = 0;
+	}
+
 	while (ret == 0) {
 		if (remaining) {
 			len = MIN(len, remaining);
-			read_loop(fd, buf, len);
+			memcpy(buf, buffer + bufferIdx, len);
+			bufferIdx += len;
 			remaining -= len;
 			ret = len;
-			continue;
+			break;
 		}
 
 		read_loop(fd, line, 4);
 		tag = IVAL(line, 0);
 
 		remaining = tag & 0xFFFFFF;
-		tag = tag >> 24;
-
-		if (tag == MPLEX_BASE)
-			continue;
-
-		tag -= MPLEX_BASE;
-
-		if (tag != FERROR && tag != FINFO) {
+		tag = (tag >> 24) - MPLEX_BASE;
+
+		switch (tag) {
+		case MSG_DATA:
+			if (!buffer || remaining > bufferSz) {
+				buffer = realloc_array(buffer, char, remaining);
+				if (!buffer) out_of_memory("read_unbuffered");
+				bufferSz = remaining;
+			}
+			read_loop(fd, buffer, remaining);
+			bufferIdx = 0;
+			break;
+		case MSG_INFO:
+		case MSG_ERROR:
+			if (remaining >= sizeof line) {
+				rprintf(FERROR, "multiplexing overflow %d:%ld\n\n",
+					tag, (long)remaining);
+				exit_cleanup(RERR_STREAMIO);
+			}
+			read_loop(fd, line, remaining);
+			rwrite((enum logcode)tag, line, remaining);
+			remaining = 0;
+			break;
+		default:
 			rprintf(FERROR, "unexpected tag %d\n", tag);
 			exit_cleanup(RERR_STREAMIO);
 		}
-
-		if (remaining > sizeof line - 1) {
-			rprintf(FERROR, "multiplexing overflow %ld\n\n",
-				(long)remaining);
-			exit_cleanup(RERR_STREAMIO);
-		}
-
-		read_loop(fd, line, remaining);
-		line[remaining] = 0;
-
-		rprintf((enum logcode) tag, "%s", line);
-		remaining = 0;
 	}
 
+	if (remaining == 0)
+		io_flush(NORMAL_FLUSH);
+
 	return ret;
 }
 
@@ -496,11 +669,9 @@ static int read_unbuffered(int fd, char *buf, size_t len)
 static void readfd(int fd, char *buffer, size_t N)
 {
 	int  ret;
-	size_t total=0;  
+	size_t total = 0;
 
 	while (total < N) {
-		io_flush();
-
 		ret = read_unbuffered(fd, buffer + total, N-total);
 		total += ret;
 	}
@@ -600,7 +771,7 @@ static void writefd_unbuffered(int fd,char *buf,size_t len)
 	int fd_count, count;
 	struct timeval tv;
 
-	err_list_push();
+	msg_list_push(NORMAL_FLUSH);
 
 	no_flush++;
 
@@ -609,24 +780,22 @@ static void writefd_unbuffered(int fd,char *buf,size_t len)
 		FD_SET(fd,&w_fds);
 		fd_count = fd;
 
-		if (io_error_fd != -1) {
+		if (msg_fd_in >= 0) {
 			FD_ZERO(&r_fds);
-			FD_SET(io_error_fd,&r_fds);
-			if (io_error_fd > fd_count) 
-				fd_count = io_error_fd;
+			FD_SET(msg_fd_in,&r_fds);
+			if (msg_fd_in > fd_count)
+				fd_count = msg_fd_in;
 		}
 
 		tv.tv_sec = io_timeout?io_timeout:SELECT_TIMEOUT;
 		tv.tv_usec = 0;
 
 		errno = 0;
-
-		count = select(fd_count+1,
-			       io_error_fd != -1?&r_fds:NULL,
-			       &w_fds,NULL,
-			       &tv);
+		count = select(fd_count+1, msg_fd_in >= 0 ? &r_fds : NULL,
+			       &w_fds, NULL, &tv);
 
 		if (count == 0) {
+			msg_list_push(NORMAL_FLUSH);
 			check_timeout();
 		}
 
@@ -637,38 +806,35 @@ static void writefd_unbuffered(int fd,char *buf,size_t len)
 			continue;
 		}
 
-		if (io_error_fd != -1 && FD_ISSET(io_error_fd, &r_fds)) {
-			read_error_fd();
-		}
+		if (msg_fd_in >= 0 && FD_ISSET(msg_fd_in, &r_fds))
+			read_msg_fd();
 
 		if (FD_ISSET(fd, &w_fds)) {
 			int ret;
 			size_t n = len-total;
 			ret = write(fd,buf+total,n);
 
-			if (ret == -1 && errno == EINTR) {
-				continue;
-			}
-
-			if (ret == -1 && 
-			    (errno == EWOULDBLOCK || errno == EAGAIN)) {
-				msleep(1);
-				continue;
+			if (ret < 0) {
+				if (errno == EINTR)
+					continue;
+				if (errno == EWOULDBLOCK || errno == EAGAIN) {
+					msleep(1);
+					continue;
+				}
 			}
 
 			if (ret <= 0) {
 				/* Don't try to write errors back
 				 * across the stream */
 				io_multiplexing_close();
-				rprintf(FERROR, RSYNC_NAME
-					": writefd_unbuffered failed to write %ld bytes: phase \"%s\": %s\n",
-					(long) len, io_write_phase, 
-					strerror(errno));
+				rsyserr(FERROR, errno,
+					"writefd_unbuffered failed to write %ld bytes: phase \"%s\"",
+					(long) len, io_write_phase);
 				exit_cleanup(RERR_STREAMIO);
 			}
 
 			sleep_for_bwlimit(ret);
- 
+
 			total += ret;
 
 			if (io_timeout)
@@ -683,7 +849,7 @@ static void writefd_unbuffered(int fd,char *buf,size_t len)
 static char *io_buffer;
 static int io_buffer_count;
 
-void io_start_buffering(int fd)
+void io_start_buffering_out(int fd)
 {
 	if (io_buffer) return;
 	multiplex_out_fd = fd;
@@ -692,11 +858,16 @@ void io_start_buffering(int fd)
 	io_buffer_count = 0;
 }
 
+void io_start_buffering_in(int fd)
+{
+	multiplex_in_fd = fd;
+}
+
 /**
  * Write an message to a multiplexed stream. If this fails then rsync
  * exits.
  **/
-static void mplex_write(int fd, enum logcode code, char *buf, size_t len)
+static void mplex_write(int fd, enum msgcode code, char *buf, size_t len)
 {
 	char buffer[4096];
 	size_t n = len;
@@ -719,26 +890,26 @@ static void mplex_write(int fd, enum logcode code, char *buf, size_t len)
 }
 
 
-void io_flush(void)
+void io_flush(int flush_it_all)
 {
 	int fd = multiplex_out_fd;
 
-	err_list_push();
+	msg_list_push(flush_it_all);
 
-	if (!io_buffer_count || no_flush) return;
+	if (!io_buffer_count || no_flush)
+		return;
 
-	if (io_multiplexing_out) {
-		mplex_write(fd, FNONE, io_buffer, io_buffer_count);
-	} else {
+	if (io_multiplexing_out)
+		mplex_write(fd, MSG_DATA, io_buffer, io_buffer_count);
+	else
 		writefd_unbuffered(fd, io_buffer, io_buffer_count);
-	}
 	io_buffer_count = 0;
 }
 
 
 void io_end_buffering(void)
 {
-	io_flush();
+	io_flush(NORMAL_FLUSH);
 	if (!io_multiplexing_out) {
 		free(io_buffer);
 		io_buffer = NULL;
@@ -749,7 +920,7 @@ static void writefd(int fd,char *buf,size_t len)
 {
 	stats.total_written += len;
 
-	err_list_push();
+	msg_list_push(NORMAL_FLUSH);
 
 	if (!io_buffer || fd != multiplex_out_fd) {
 		writefd_unbuffered(fd, buf, len);
@@ -765,7 +936,8 @@ static void writefd(int fd,char *buf,size_t len)
 			io_buffer_count += n;
 		}
 
-		if (io_buffer_count == IO_BUFFER_SIZE) io_flush();
+		if (io_buffer_count == IO_BUFFER_SIZE)
+			io_flush(NORMAL_FLUSH);
 	}
 }
 
@@ -831,10 +1003,11 @@ void write_byte(int f,unsigned char c)
 
 
 /**
- * Read a line of up to @p maxlen characters into @p buf.  Does not
- * contain a trailing newline or carriage return.
+ * Read a line of up to @p maxlen characters into @p buf (not counting
+ * the trailing null).  Strips the (required) trailing newline and all
+ * carriage returns.
  *
- * @return 1 for success; 0 for io error or truncation.
+ * @return 1 for success; 0 for I/O error or truncation.
  **/
 int read_line(int f, char *buf, size_t maxlen)
 {
@@ -843,27 +1016,21 @@ int read_line(int f, char *buf, size_t maxlen)
 		read_buf(f, buf, 1);
 		if (buf[0] == 0)
 			return 0;
-		if (buf[0] == '\n') {
-			buf[0] = 0;
+		if (buf[0] == '\n')
 			break;
-		}
 		if (buf[0] != '\r') {
 			buf++;
 			maxlen--;
 		}
 	}
-	if (maxlen == 0) {
-		*buf = 0;
-		return 0;
-	}
-
-	return 1;
+	*buf = '\0';
+	return maxlen > 0;
 }
 
 
 void io_printf(int fd, const char *format, ...)
 {
-	va_list ap;  
+	va_list ap;
 	char buf[1024];
 	int len;
 
@@ -877,35 +1044,35 @@ void io_printf(int fd, const char *format, ...)
 }
 
 
-/** Setup for multiplexing an error stream with the data stream */
+/** Setup for multiplexing a MSG_* stream with the data stream. */
 void io_start_multiplex_out(int fd)
 {
 	multiplex_out_fd = fd;
-	io_flush();
-	io_start_buffering(fd);
+	io_flush(NORMAL_FLUSH);
+	io_start_buffering_out(fd);
 	io_multiplexing_out = 1;
 }
 
-/** Setup for multiplexing an error stream with the data stream */
+/** Setup for multiplexing a MSG_* stream with the data stream. */
 void io_start_multiplex_in(int fd)
 {
 	multiplex_in_fd = fd;
-	io_flush();
+	io_flush(NORMAL_FLUSH);
 	io_multiplexing_in = 1;
 }
 
-/** Write an message to the multiplexed error stream */
-int io_multiplex_write(enum logcode code, char *buf, size_t len)
+/** Write an message to the multiplexed data stream. */
+int io_multiplex_write(enum msgcode code, char *buf, size_t len)
 {
 	if (!io_multiplexing_out) return 0;
 
-	io_flush();
+	io_flush(NORMAL_FLUSH);
 	stats.total_written += (len+4);
 	mplex_write(multiplex_out_fd, code, buf, len);
 	return 1;
 }
 
-/** Stop output multiplexing */
+/** Stop output multiplexing. */
 void io_multiplexing_close(void)
 {
 	io_multiplexing_out = 0;