X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/182dca5c80c40c5abe429a6c5307be25cc4b4d90..5fb543d5879ec3ad8f3e68a92b1766ece1b8326a:/io.c diff --git a/io.c b/io.c index fda04dd8..aae64b75 100644 --- a/io.c +++ b/io.c @@ -24,17 +24,18 @@ */ #include "rsync.h" -static int total_written = 0; -static int total_read = 0; +static int64 total_written; +static int64 total_read; extern int verbose; +extern int sparse_files; -int write_total(void) +int64 write_total(void) { return total_written; } -int read_total(void) +int64 read_total(void) { return total_read; } @@ -48,10 +49,10 @@ void setup_nonblocking(int f_in,int f_out) } -static char *read_buffer = NULL; -static char *read_buffer_p = NULL; -static int read_buffer_len = 0; -static int read_buffer_size = 0; +static char *read_buffer; +static char *read_buffer_p; +static int read_buffer_len; +static int read_buffer_size; /* This function was added to overcome a deadlock problem when using @@ -61,6 +62,8 @@ static void read_check(int f) { int n; + if (f == -1) return; + if (read_buffer_len == 0) { read_buffer_p = read_buffer; } @@ -68,6 +71,9 @@ static void read_check(int f) if ((n=num_waiting(f)) <= 0) return; + /* things could deteriorate if we read in really small chunks */ + if (n < 10) n = 1024; + if (read_buffer_p != read_buffer) { memmove(read_buffer,read_buffer_p,read_buffer_len); read_buffer_p = read_buffer; @@ -94,16 +100,27 @@ static int readfd(int fd,char *buffer,int N) { int ret; int total=0; + + if (read_buffer_len < N) + read_check(buffer_f_in); while (total < N) { - if (read_buffer_len > 0) { + if (read_buffer_len > 0 && buffer_f_in == fd) { ret = MIN(read_buffer_len,N-total); memcpy(buffer+total,read_buffer_p,ret); read_buffer_p += ret; read_buffer_len -= ret; } else { - ret = read(fd,buffer + total,N - total); + while ((ret = read(fd,buffer + total,N - total)) == -1) { + fd_set fds; + + if (errno != EAGAIN && errno != EWOULDBLOCK) + return -1; + FD_ZERO(&fds); + FD_SET(fd, &fds); + select(fd+1, &fds, NULL, NULL, NULL); + } } if (ret <= 0) @@ -116,59 +133,118 @@ static int readfd(int fd,char *buffer,int N) int read_int(int f) { + int ret; char b[4]; - if (readfd(f,b,4) != 4) { + if ((ret=readfd(f,b,4)) != 4) { if (verbose > 1) - fprintf(stderr,"Error reading %d bytes : %s\n",4,strerror(errno)); - exit(1); + fprintf(FERROR,"(%d) Error reading %d bytes : %s\n", + getpid(),4,ret==-1?strerror(errno):"EOF"); + exit_cleanup(1); } total_read += 4; return IVAL(b,0); } +int64 read_longint(int f) +{ + extern int remote_version; + int64 ret; + char b[8]; + ret = read_int(f); + + if (ret != -1) return ret; + +#ifndef HAVE_LONGLONG + fprintf(FERROR,"Integer overflow - attempted 64 bit offset\n"); + exit_cleanup(1); +#else + if (remote_version >= 16) { + if ((ret=readfd(f,b,8)) != 8) { + if (verbose > 1) + fprintf(FERROR,"(%d) Error reading %d bytes : %s\n", + getpid(),8,ret==-1?strerror(errno):"EOF"); + exit_cleanup(1); + } + total_read += 8; + ret = IVAL(b,0) | (((int64)IVAL(b,4))<<32); + } +#endif + + return ret; +} + void read_buf(int f,char *buf,int len) { - if (readfd(f,buf,len) != len) { + int ret; + if ((ret=readfd(f,buf,len)) != len) { if (verbose > 1) - fprintf(stderr,"Error reading %d bytes : %s\n",len,strerror(errno)); - exit(1); + fprintf(FERROR,"(%d) Error reading %d bytes : %s\n", + getpid(),len,ret==-1?strerror(errno):"EOF"); + exit_cleanup(1); } total_read += len; } unsigned char read_byte(int f) { - char c; - read_buf(f,&c,1); - return (unsigned char)c; + unsigned char c; + read_buf(f,(char *)&c,1); + return c; } -int read_write(int fd_in,int fd_out,int size) + +static char last_byte; +static int last_sparse; + +int sparse_end(int f) { - static char *buf=NULL; - static int bufsize = WRITE_BLOCK_SIZE; - int total=0; - - if (!buf) { - buf = (char *)malloc(bufsize); - if (!buf) out_of_memory("read_write"); + if (last_sparse) { + lseek(f,-1,SEEK_CUR); + return (write(f,&last_byte,1) == 1 ? 0 : -1); } + last_sparse = 0; + return 0; +} + +int write_sparse(int f,char *buf,int len) +{ + int l1=0,l2=0; + int ret; + + if (!sparse_files) + return write(f,buf,len); + + for (l1=0;l1 0) + last_sparse=1; + + if (l1 > 0) + lseek(f,l1,SEEK_CUR); - while (total < size) { - int n = MIN(size-total,bufsize); - read_buf(fd_in,buf,n); - if (write(fd_out,buf,n) != n) - return total; - total += n; + if (l1 == len) + return len; + + if ((ret=write(f,buf+l1,len-(l1+l2))) != len-(l1+l2)) { + if (ret == -1 || ret == 0) return ret; + return (l1+ret); } - return total; + + if (l2 > 0) + lseek(f,l2,SEEK_CUR); + + return len; } static int writefd(int fd,char *buf,int len) { int total = 0; - fd_set fds; + fd_set w_fds, r_fds; + int fd_count, count, got_select=0; struct timeval tv; if (buffer_f_in == -1) @@ -179,17 +255,51 @@ static int writefd(int fd,char *buf,int len) if (ret == 0) return total; - if (ret == -1 && errno != EWOULDBLOCK) - return total?total:-1; + if (ret == -1 && !(errno == EWOULDBLOCK || errno == EAGAIN)) + return -1; + + if (ret == -1 && got_select) { + /* hmmm, we got a write select on the fd and then failed to write. + Why doesn't that mean that the fd is dead? It doesn't on some + systems it seems (eg. IRIX) */ + u_sleep(1000); +#if 0 + fprintf(FERROR,"write exception\n"); + exit_cleanup(1); +#endif + } + + got_select = 0; + if (ret == -1) { read_check(buffer_f_in); - FD_ZERO(&fds); - FD_SET(fd,&fds); + fd_count = fd+1; + FD_ZERO(&w_fds); + FD_ZERO(&r_fds); + FD_SET(fd,&w_fds); + if (buffer_f_in != -1) { + FD_SET(buffer_f_in,&r_fds); + if (buffer_f_in > fd) + fd_count = buffer_f_in+1; + } + tv.tv_sec = BLOCKING_TIMEOUT; tv.tv_usec = 0; - select(16,NULL,&fds,NULL,&tv); + count = select(fd_count,buffer_f_in == -1? NULL: &r_fds, + &w_fds,NULL,&tv); + if (count == -1 && errno != EINTR) { + if (verbose > 1) + fprintf(FERROR,"select error: %s\n", strerror(errno)); + exit_cleanup(1); + } + + if (count == 0) continue; + + if (FD_ISSET(fd, &w_fds)) { + got_select = 1; + } } else { total += ret; } @@ -202,20 +312,47 @@ static int writefd(int fd,char *buf,int len) void write_int(int f,int x) { + int ret; char b[4]; SIVAL(b,0,x); - if (writefd(f,b,4) != 4) { - fprintf(stderr,"write_int failed : %s\n",strerror(errno)); - exit(1); + if ((ret=writefd(f,b,4)) != 4) { + fprintf(FERROR,"write_int failed : %s\n", + ret==-1?strerror(errno):"EOF"); + exit_cleanup(1); } total_written += 4; } +void write_longint(int f, int64 x) +{ + extern int remote_version; + char b[8]; + int ret; + + if (remote_version < 16 || x <= 0x7FFFFFFF) { + write_int(f, (int)x); + return; + } + + write_int(f, -1); + SIVAL(b,0,(x&0xFFFFFFFF)); + SIVAL(b,4,((x>>32)&0xFFFFFFFF)); + + if ((ret=writefd(f,b,8)) != 8) { + fprintf(FERROR,"write_longint failed : %s\n", + ret==-1?strerror(errno):"EOF"); + exit_cleanup(1); + } + total_written += 8; +} + void write_buf(int f,char *buf,int len) { - if (writefd(f,buf,len) != len) { - fprintf(stderr,"write_buf failed : %s\n",strerror(errno)); - exit(1); + int ret; + if ((ret=writefd(f,buf,len)) != len) { + fprintf(FERROR,"write_buf failed : %s\n", + ret==-1?strerror(errno):"EOF"); + exit_cleanup(1); } total_written += len; }