X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/0ba481368c2a44d6d6a2f361fa12df432d9d304b..b52c1d9d3aec51afbc9d1c5561d2b70d8bcecf54:/io.c diff --git a/io.c b/io.c index b58eff0c..e57d0708 100644 --- a/io.c +++ b/io.c @@ -1,6 +1,8 @@ -/* - Copyright (C) Andrew Tridgell 1996 +/* -*- c-file-style: "linux" -*- + + Copyright (C) 1996-2001 by Andrew Tridgell Copyright (C) Paul Mackerras 1996 + Copyright (C) 2001 by Martin Pool 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 @@ -27,18 +29,24 @@ /* if no timeout is specified then use a 60 second select timeout */ #define SELECT_TIMEOUT 60 -extern int bwlimit; - static int io_multiplexing_out; static int io_multiplexing_in; static int multiplex_in_fd; static int multiplex_out_fd; static time_t last_io; -static int eof_error=1; +static int no_flush; + +extern int bwlimit; extern int verbose; extern int io_timeout; extern struct stats stats; + +/** Ignore EOF errors while reading a module listing if the remote + version is 24 or less. */ +int kludge_around_eof = False; + + static int io_error_fd = -1; static void read_loop(int fd, char *buf, int len); @@ -47,6 +55,8 @@ static void check_timeout(void) { extern int am_server, am_daemon; time_t t; + + err_list_push(); if (!io_timeout) return; @@ -59,7 +69,7 @@ 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 second - exiting\n", + rprintf(FERROR,"io timeout after %d seconds - exiting\n", (int)(t-last_io)); } exit_cleanup(RERR_TIMEOUT); @@ -80,6 +90,8 @@ static void read_error_fd(void) int fd = io_error_fd; int tag, len; + /* io_error_fd is temporarily disabled -- is this meant to + * prevent indefinite recursion? */ io_error_fd = -1; read_loop(fd, buf, 4); @@ -101,21 +113,68 @@ static void read_error_fd(void) } -static int no_flush; +static void whine_about_eof (void) +{ + /** + It's almost always an error to get an EOF when we're trying + to read from the network, because the protocol is + self-terminating. + + However, there is one unfortunate cases where it is not, + which is rsync <2.4.6 sending a list of modules on a + server, since the list is terminated by closing the socket. + So, for the section of the program where that is a problem + (start_socket_client), kludge_around_eof is True and we + just exit. + */ + + if (kludge_around_eof) + exit_cleanup (0); + else { + rprintf (FERROR, + "%s: connection unexpectedly closed " + "(%.0f bytes read so far)\n", + RSYNC_NAME, (double)stats.total_read); + + exit_cleanup (RERR_STREAMIO); + } +} + + +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)); + exit_cleanup(RERR_STREAMIO); +} + -/* read from a socket with IO timeout. return the number of - bytes read. If no bytes can be read then exit, never return - a number <= 0 */ -static int read_timeout(int fd, char *buf, int len) +/*! + * Read from a socket with IO 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 + * actually report an "unexpected EOF" error here. Since it's a + * fairly common mistake to try to use rsh when ssh is required, we + * should trap that: if we fail to read any data at all, we should + * give a better explanation. We can tell whether the connection has + * started by looking e.g. at whether the remote version is known yet. + */ +static int read_timeout (int fd, char *buf, int len) { int n, ret=0; io_flush(); while (ret == 0) { + /* until we manage to read *something* */ fd_set fds; struct timeval tv; int fd_count = fd+1; + int count; FD_ZERO(&fds); FD_SET(fd, &fds); @@ -129,11 +188,16 @@ static int read_timeout(int fd, char *buf, int len) errno = 0; - if (select(fd_count, &fds, NULL, NULL, &tv) < 1) { + count = select(fd_count, &fds, NULL, NULL, &tv); + + if (count == 0) { + check_timeout(); + } + + if (count <= 0) { if (errno == EBADF) { exit_cleanup(RERR_SOCKETIO); } - check_timeout(); continue; } @@ -152,38 +216,27 @@ static int read_timeout(int fd, char *buf, int len) if (io_timeout) last_io = time(NULL); continue; + } else if (n == 0) { + whine_about_eof (); + return -1; /* doesn't return */ + } else if (n == -1) { + if (errno == EINTR || errno == EWOULDBLOCK || + errno == EAGAIN) + continue; + else + die_from_readerr (errno); } - - if (n == -1 && errno == EINTR) { - continue; - } - - if (n == -1 && - (errno == EWOULDBLOCK || errno == EAGAIN)) { - continue; - } - - - if (n == 0) { - if (eof_error) { - rprintf(FERROR,"unexpected EOF in read_timeout\n"); - } - exit_cleanup(RERR_STREAMIO); - } - - /* this prevents us trying to write errors on a dead socket */ - io_multiplexing_close(); - - rprintf(FERROR,"read error: %s\n", strerror(errno)); - exit_cleanup(RERR_STREAMIO); } return ret; } -/* continue trying to read len bytes - don't return until len - has been read */ -static void read_loop(int fd, char *buf, int len) + + + +/*! Continue trying to read len bytes - don't return until len has + been read. */ +static void read_loop (int fd, char *buf, int len) { while (len) { int n = read_timeout(fd, buf, len); @@ -193,16 +246,20 @@ static void read_loop(int fd, char *buf, int len) } } -/* read from the file descriptor handling multiplexing - - return number of bytes read - never return <= 0 */ + +/** + * Read from the file descriptor handling multiplexing - return number + * of bytes read. + * + * Never returns <= 0. + */ static int read_unbuffered(int fd, char *buf, int len) { static int remaining; int tag, ret=0; char line[1024]; - if (!io_multiplexing_in || fd != multiplex_in_fd) + if (!io_multiplexing_in || fd != multiplex_in_fd) return read_timeout(fd, buf, len); while (ret == 0) { @@ -214,7 +271,7 @@ static int read_unbuffered(int fd, char *buf, int len) continue; } - read_loop(fd, line, 4); + read_loop (fd, line, 4); tag = IVAL(line, 0); remaining = tag & 0xFFFFFF; @@ -248,7 +305,7 @@ static int read_unbuffered(int fd, char *buf, int len) /* 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,int N) +static void readfd (int fd, char *buffer, int N) { int ret; int total=0; @@ -256,7 +313,7 @@ static void readfd(int fd,char *buffer,int N) while (total < N) { io_flush(); - ret = read_unbuffered(fd,buffer + total,N-total); + ret = read_unbuffered (fd, buffer + total, N-total); total += ret; } @@ -306,14 +363,14 @@ void read_buf(int f,char *buf,int len) void read_sbuf(int f,char *buf,int len) { - read_buf(f,buf,len); + read_buf (f,buf,len); buf[len] = 0; } unsigned char read_byte(int f) { unsigned char c; - read_buf(f,(char *)&c,1); + read_buf (f, (char *)&c, 1); return c; } @@ -325,6 +382,8 @@ static void writefd_unbuffered(int fd,char *buf,int len) int fd_count, count; struct timeval tv; + err_list_push(); + no_flush++; while (total < len) { @@ -349,11 +408,14 @@ static void writefd_unbuffered(int fd,char *buf,int len) &w_fds,NULL, &tv); + if (count == 0) { + check_timeout(); + } + if (count <= 0) { if (errno == EBADF) { exit_cleanup(RERR_SOCKETIO); } - check_timeout(); continue; } @@ -363,7 +425,6 @@ static void writefd_unbuffered(int fd,char *buf,int len) if (FD_ISSET(fd, &w_fds)) { int ret, n = len-total; - ret = write(fd,buf+total,n); if (ret == -1 && errno == EINTR) { @@ -377,7 +438,10 @@ static void writefd_unbuffered(int fd,char *buf,int len) } if (ret <= 0) { - rprintf(FERROR,"erroring writing %d bytes - exiting\n", len); + rprintf(FERROR, + "error writing %d unbuffered bytes" + " - exiting: %s\n", len, + strerror(errno)); exit_cleanup(RERR_STREAMIO); } @@ -445,6 +509,9 @@ static void mplex_write(int fd, enum logcode code, char *buf, int len) void io_flush(void) { int fd = multiplex_out_fd; + + err_list_push(); + if (!io_buffer_count || no_flush) return; if (io_multiplexing_out) { @@ -466,21 +533,12 @@ void io_end_buffering(int fd) } } -/* some OSes have a bug where an exit causes the pending writes on - a socket to be flushed. Do an explicit shutdown to try to prevent this */ -void io_shutdown(void) -{ - if (multiplex_out_fd != -1) close(multiplex_out_fd); - if (io_error_fd != -1) close(io_error_fd); - multiplex_out_fd = -1; - io_error_fd = -1; -} - - static void writefd(int fd,char *buf,int len) { stats.total_written += len; + err_list_push(); + if (!io_buffer || fd != multiplex_out_fd) { writefd_unbuffered(fd, buf, len); return; @@ -507,6 +565,11 @@ void write_int(int f,int32 x) writefd(f,b,4); } + +/* + * Note: int64 may actually be a 32-bit type if ./configure couldn't find any + * 64-bit types on this platform. + */ void write_longint(int f, int64 x) { extern int remote_version; @@ -541,10 +604,10 @@ void write_byte(int f,unsigned char c) write_buf(f,(char *)&c,1); } + + int read_line(int f, char *buf, int maxlen) { - eof_error = 0; - while (maxlen) { buf[0] = 0; read_buf(f, buf, 1); @@ -563,8 +626,6 @@ int read_line(int f, char *buf, int maxlen) return 0; } - eof_error = 1; - return 1; } @@ -576,7 +637,7 @@ void io_printf(int fd, const char *format, ...) int len; va_start(ap, format); - len = vslprintf(buf, sizeof(buf), format, ap); + len = vsnprintf(buf, sizeof(buf), format, ap); va_end(ap); if (len < 0) exit_cleanup(RERR_STREAMIO); @@ -613,14 +674,6 @@ int io_multiplex_write(enum logcode code, char *buf, int len) return 1; } -/* write a message to the special error fd */ -int io_error_write(int f, enum logcode code, char *buf, int len) -{ - if (f == -1) return 0; - mplex_write(f, code, buf, len); - return 1; -} - /* stop output multiplexing */ void io_multiplexing_close(void) {