X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/8b35435f7cc4708400c652434615ce48dc493de4..6f82f7a6f67bd9f5dd88bc3977c1f633405244f0:/io.c diff --git a/io.c b/io.c index 6cdbe6bf..dac0744d 100644 --- a/io.c +++ b/io.c @@ -1,5 +1,6 @@ -/* - Copyright (C) Andrew Tridgell 1996 +/* -*- c-file-style: "linux" -*- + + Copyright (C) 1996-2001 by Andrew Tridgell Copyright (C) Paul Mackerras 1996 This program is free software; you can redistribute it and/or modify @@ -27,6 +28,8 @@ /* 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; @@ -37,19 +40,16 @@ extern int verbose; extern int io_timeout; extern struct stats stats; -static int buffer_f_in = -1; static int io_error_fd = -1; static void read_loop(int fd, char *buf, int len); -void setup_readbuffer(int f_in) -{ - buffer_f_in = f_in; -} - static void check_timeout(void) { + extern int am_server, am_daemon; time_t t; + + err_list_push(); if (!io_timeout) return; @@ -61,8 +61,10 @@ static void check_timeout(void) t = time(NULL); if (last_io && io_timeout && (t-last_io) >= io_timeout) { - rprintf(FERROR,"io timeout after %d second - exiting\n", - (int)(t-last_io)); + if (!am_server && !am_daemon) { + rprintf(FERROR,"io timeout after %d seconds - exiting\n", + (int)(t-last_io)); + } exit_cleanup(RERR_TIMEOUT); } } @@ -81,6 +83,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); @@ -104,9 +108,17 @@ static void read_error_fd(void) static int no_flush; -/* 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 */ +/* + * 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; @@ -159,10 +171,18 @@ static int read_timeout(int fd, char *buf, int len) continue; } + if (n == -1 && + (errno == EWOULDBLOCK || errno == EAGAIN)) { + continue; + } + if (n == 0) { if (eof_error) { - rprintf(FERROR,"unexpected EOF in read_timeout\n"); + rprintf(FERROR, + "%s: connection to server unexpectedly closed" + " (%.0f bytes read so far)\n", + RSYNC_NAME, (double)stats.total_read); } exit_cleanup(RERR_STREAMIO); } @@ -313,11 +333,7 @@ unsigned char read_byte(int f) return c; } - - -/* write len bytes to fd, possibly reading from buffer_f_in if set - in order to unclog the pipe. don't return until all len - bytes have been written */ +/* write len bytes to fd */ static void writefd_unbuffered(int fd,char *buf,int len) { int total = 0; @@ -325,6 +341,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) { @@ -363,18 +381,39 @@ 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?n:1); + 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) { - 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); } + /* Sleep after writing to limit I/O bandwidth */ + if (bwlimit) + { + tv.tv_sec = 0; + tv.tv_usec = ret * 1000 / bwlimit; + while (tv.tv_usec > 1000000) + { + tv.tv_sec++; + tv.tv_usec -= 1000000; + } + select(0, NULL, NULL, NULL, &tv); + } + total += ret; if (io_timeout) @@ -426,6 +465,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) { @@ -436,6 +478,8 @@ void io_flush(void) io_buffer_count = 0; } + +/* XXX: fd is ignored, which seems a little strange. */ void io_end_buffering(int fd) { io_flush(); @@ -449,6 +493,8 @@ 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; @@ -475,6 +521,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; @@ -544,7 +595,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); @@ -581,22 +632,9 @@ 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) { io_multiplexing_out = 0; } -void io_close_input(int fd) -{ - buffer_f_in = -1; -} -