Tweak the noop_io_until_death() timeout and comment it.

[rsync/rsync.git] / io.c

diff --git a/io.c b/io.c
index b717b43..08afdd9 100644 (file)
--- a/io.c
+++ b/io.c
@@ -614,21 +614,20 @@ static char *perform_io(size_t needed, int flags)
                        if (iobuf.raw_flushing_ends_before
                         || (!iobuf.msg.len && iobuf.out.len > iobuf.out_empty_len && !(flags & PIO_NEED_MSGROOM))) {
                                if (OUT_MULTIPLEXED && !iobuf.raw_flushing_ends_before) {
-                                       size_t val;
-
                                        /* The iobuf.raw_flushing_ends_before value can point off the end
                                         * of the iobuf.out buffer for a while, for easier subtracting. */
                                        iobuf.raw_flushing_ends_before = iobuf.out.pos + iobuf.out.len;
 
                                        SIVAL(iobuf.out.buf + iobuf.raw_data_header_pos, 0,
                                              ((MPLEX_BASE + (int)MSG_DATA)<<24) + iobuf.out.len - 4);
-                                       if ((val = iobuf.out.size - iobuf.raw_data_header_pos) < 4) {
+                                       if (iobuf.raw_data_header_pos + 4 > iobuf.out.size) {
+                                               int siz = (int)(iobuf.raw_data_header_pos + 4 - iobuf.out.size);
                                                /* We used some of the overflow bytes, so move them. */
                                                if (DEBUG_GTE(IO, 4)) {
                                                        rprintf(FINFO, "[%s] wrap-bytes moved: %d (perform_io)\n",
-                                                               who_am_i(), (int)val);
+                                                               who_am_i(), siz);
                                                }
-                                               memcpy(iobuf.out.buf, iobuf.out.buf + iobuf.out.size, 4 - val);
+                                               memcpy(iobuf.out.buf, iobuf.out.buf + iobuf.out.size, siz);
                                        }
 
                                        if (DEBUG_GTE(IO, 1)) {
@@ -677,8 +676,7 @@ static char *perform_io(size_t needed, int flags)
                }
 
                if (extra_flist_sending_enabled) {
-                       if (file_total - file_old_total < MAX_FILECNT_LOOKAHEAD
-                        && file_total - file_old_total >= MIN_FILECNT_LOOKAHEAD)
+                       if (file_total - file_old_total < MAX_FILECNT_LOOKAHEAD)
                                tv.tv_sec = 0;
                        else {
                                extra_flist_sending_enabled = False;
@@ -775,8 +773,7 @@ static char *perform_io(size_t needed, int flags)
                                if (iobuf.raw_flushing_ends_before)
                                        iobuf.raw_flushing_ends_before -= out->size;
                                out->pos = 0;
-                       }
-                       if (out->pos == iobuf.raw_flushing_ends_before)
+                       } else if (out->pos == iobuf.raw_flushing_ends_before)
                                iobuf.raw_flushing_ends_before = 0;
                        if ((out->len -= n) == empty_buf_len) {
                                out->pos = 0;
@@ -810,7 +807,12 @@ void noop_io_until_death(void)
        char buf[1024];
 
        kluge_around_eof = 1;
-       set_io_timeout(protocol_version >= 31 ? 10 : 1);
+       /* For protocol 31: setting an I/O timeout ensures that if something
+        * inexplicably weird happens, we won't hang around forever.  For older
+        * protocols: we can't tell the other side to die, so we linger a brief
+        * time (to try to give our error messages time to arrive) and then let
+        * the "unexpectedly" closed socket tell them to die. */
+       set_io_timeout(protocol_version >= 31 ? 30 : 1);
 
        while (1)
                read_buf(iobuf.in_fd, buf, sizeof buf);
@@ -833,7 +835,7 @@ int send_msg(enum msgcode code, const char *buf, size_t len, int convert)
        if (convert > 0 && ic_send == (iconv_t)-1)
                convert = 0;
        if (convert > 0) {
-               /* Ensuring double-size room leaves space for a potential conversion. */
+               /* Ensuring double-size room leaves space for maximal conversion expansion. */
                if (iobuf.msg.len + len*2 + 4 > iobuf.msg.size)
                        perform_io(len*2 + 4, PIO_NEED_MSGROOM);
        } else
@@ -846,7 +848,7 @@ int send_msg(enum msgcode code, const char *buf, size_t len, int convert)
                pos -= iobuf.msg.size;
        hdr = iobuf.msg.buf + pos;
 
-       iobuf.msg.len += 4; /* Leave room for the coming header bytes. */
+       iobuf.msg.len += 4; /* Allocate room for the coming header bytes. */
 
 #ifdef ICONV_OPTION
        if (convert > 0) {
@@ -883,10 +885,10 @@ int send_msg(enum msgcode code, const char *buf, size_t len, int convert)
        SIVAL(hdr, 0, ((MPLEX_BASE + (int)code)<<24) + len);
        /* If the header used any overflow bytes, move them to the start. */
        if ((pos = hdr+4 - iobuf.msg.buf) > iobuf.msg.size) {
-               size_t siz = pos - iobuf.msg.size;
+               int siz = (int)(pos - iobuf.msg.size);
                if (DEBUG_GTE(IO, 4))
-                       rprintf(FINFO, "[%s] wrap-bytes moved: %d (send_msg)\n", who_am_i(), (int)siz);
-               memcpy(iobuf.msg.buf, hdr+4 - siz, siz);
+                       rprintf(FINFO, "[%s] wrap-bytes moved: %d (send_msg)\n", who_am_i(), siz);
+               memcpy(iobuf.msg.buf, iobuf.msg.buf + iobuf.msg.size, siz);
        }
 
        if (want_debug && convert > 0)
@@ -1167,7 +1169,8 @@ BOOL io_start_buffering_out(int f_out)
        if (iobuf.out.buf) {
                if (iobuf.out_fd == -1)
                        iobuf.out_fd = f_out;
-               assert(f_out == iobuf.out_fd);
+               else
+                       assert(f_out == iobuf.out_fd);
                return False;
        }
 
@@ -1189,7 +1192,8 @@ BOOL io_start_buffering_in(int f_in)
        if (iobuf.in.buf) {
                if (iobuf.in_fd == -1)
                        iobuf.in_fd = f_in;
-               assert(f_in == iobuf.in_fd);
+               else
+                       assert(f_in == iobuf.in_fd);
                return False;
        }