X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/1b01b295c960fd6b9fb0c3fdb961010c22b2c898..0f78b81511be65d8fe21af1e6ac674f9e80ac29d:/checksum.c diff --git a/checksum.c b/checksum.c index 20158363..a86904b1 100644 --- a/checksum.c +++ b/checksum.c @@ -1,21 +1,24 @@ -/* - Copyright (C) Andrew Tridgell 1996 - Copyright (C) Paul Mackerras 1996 - - 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. -*/ +/* + * Routines to support checksumming of bytes. + * + * Copyright (C) 1996 Andrew Tridgell + * Copyright (C) 1996 Paul Mackerras + * Copyright (C) 2004, 2005 Wayne Davison + * + * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ #include "rsync.h" @@ -23,23 +26,24 @@ int csum_length=2; /* initial value */ #define CSUM_CHUNK 64 -int checksum_seed = 0; -extern int remote_version; +extern int checksum_seed; +extern int protocol_version; /* a simple 32 bit checksum that can be upadted from either end (inspired by Mark Adler's Adler-32 checksum) */ -uint32 get_checksum1(char *buf,int len) +uint32 get_checksum1(char *buf1, int32 len) { - int i; + int32 i; uint32 s1, s2; + schar *buf = (schar *)buf1; s1 = s2 = 0; for (i = 0; i < (len-4); i+=4) { - s2 += 4*(s1 + buf[i]) + 3*buf[i+1] + 2*buf[i+2] + buf[i+3] + + s2 += 4*(s1 + buf[i]) + 3*buf[i+1] + 2*buf[i+2] + buf[i+3] + 10*CHAR_OFFSET; - s1 += (buf[i+0] + buf[i+1] + buf[i+2] + buf[i+3] + 4*CHAR_OFFSET); + s1 += (buf[i+0] + buf[i+1] + buf[i+2] + buf[i+3] + 4*CHAR_OFFSET); } for (; i < len; i++) { s1 += (buf[i]+CHAR_OFFSET); s2 += s1; @@ -48,147 +52,136 @@ uint32 get_checksum1(char *buf,int len) } -static void sum_put(MDstruct *md,char *sum) -{ - SIVAL(sum,0,md->buffer[0]); - if (csum_length <= 4) return; - SIVAL(sum,4,md->buffer[1]); - if (csum_length <= 8) return; - SIVAL(sum,8,md->buffer[2]); - if (csum_length <= 12) return; - SIVAL(sum,12,md->buffer[3]); -} - - -void get_checksum2(char *buf,int len,char *sum) +void get_checksum2(char *buf, int32 len, char *sum) { - int i; - MDstruct MD; - static char *buf1 = NULL; - static int len1 = 0; - - if (len > len1) { - if (buf1) free(buf1); - buf1 = (char *)malloc(len+4); - len1 = len; - if (!buf1) out_of_memory("get_checksum2"); - } - - MDbegin(&MD); - - bcopy(buf,buf1,len); - if (checksum_seed) { - SIVAL(buf1,len,checksum_seed); - len += 4; - } - - for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) { - MDupdate(&MD, buf1+i, CSUM_CHUNK*8); - } - if (len - i > 0) - MDupdate(&MD, buf1+i, (len-i)*8); - - sum_put(&MD,sum); + int32 i; + static char *buf1; + static int32 len1; + struct mdfour m; + + if (len > len1) { + if (buf1) + free(buf1); + buf1 = new_array(char, len+4); + len1 = len; + if (!buf1) + out_of_memory("get_checksum2"); + } + + mdfour_begin(&m); + + memcpy(buf1,buf,len); + if (checksum_seed) { + SIVAL(buf1,len,checksum_seed); + len += 4; + } + + for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) { + mdfour_update(&m, (uchar *)(buf1+i), CSUM_CHUNK); + } + /* + * Prior to version 27 an incorrect MD4 checksum was computed + * by failing to call mdfour_tail() for block sizes that + * are multiples of 64. This is fixed by calling mdfour_update() + * even when there are no more bytes. + */ + if (len - i > 0 || protocol_version >= 27) { + mdfour_update(&m, (uchar *)(buf1+i), (len-i)); + } + + mdfour_result(&m, (uchar *)sum); } -void file_checksum(char *fname,char *sum,off_t size) +void file_checksum(char *fname,char *sum,OFF_T size) { - int i; - MDstruct MD; - struct map_struct *buf; - int fd; - int len = size; - char tmpchunk[CSUM_CHUNK]; - - bzero(sum,csum_length); + OFF_T i; + struct map_struct *buf; + int fd; + OFF_T len = size; + struct mdfour m; - fd = open(fname,O_RDONLY); - if (fd == -1) return; + memset(sum,0,MD4_SUM_LENGTH); - buf = map_file(fd,size); + fd = do_open(fname, O_RDONLY, 0); + if (fd == -1) + return; - MDbegin(&MD); + buf = map_file(fd, size, MAX_MAP_SIZE, CSUM_CHUNK); - for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) { - bcopy(map_ptr(buf,i,CSUM_CHUNK),tmpchunk,CSUM_CHUNK); - MDupdate(&MD, tmpchunk, CSUM_CHUNK*8); - } + mdfour_begin(&m); - if (len - i > 0) { - bcopy(map_ptr(buf,i,len-i),tmpchunk,len-i); - MDupdate(&MD, tmpchunk, (len-i)*8); - } + for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) { + mdfour_update(&m, (uchar *)map_ptr(buf, i, CSUM_CHUNK), + CSUM_CHUNK); + } - sum_put(&MD,sum); - - close(fd); - unmap_file(buf); -} + /* Prior to version 27 an incorrect MD4 checksum was computed + * by failing to call mdfour_tail() for block sizes that + * are multiples of 64. This is fixed by calling mdfour_update() + * even when there are no more bytes. */ + if (len - i > 0 || protocol_version >= 27) + mdfour_update(&m, (uchar *)map_ptr(buf, i, len-i), len-i); + mdfour_result(&m, (uchar *)sum); -void checksum_init(void) -{ - if (remote_version >= 14) - csum_length = 2; /* adaptive */ - else - csum_length = SUM_LENGTH; + close(fd); + unmap_file(buf); } - -static MDstruct sumMD; -static int sumresidue; +static int32 sumresidue; static char sumrbuf[CSUM_CHUNK]; +static struct mdfour md; -void sum_init(void) +void sum_init(int seed) { - char s[4]; - MDbegin(&sumMD); - sumresidue=0; - SIVAL(s,0,checksum_seed); - sum_update(s,4); + char s[4]; + mdfour_begin(&md); + sumresidue = 0; + SIVAL(s, 0, seed); + sum_update(s, 4); } -void sum_update(char *p,int len) +/** + * Feed data into an MD4 accumulator, md. The results may be + * retrieved using sum_end(). md is used for different purposes at + * different points during execution. + * + * @todo Perhaps get rid of md and just pass in the address each time. + * Very slightly clearer and slower. + **/ +void sum_update(char *p, int32 len) { - int i; - if (len + sumresidue < CSUM_CHUNK) { - bcopy(p,sumrbuf+sumresidue,len); - sumresidue += len; - return; - } - - if (sumresidue) { - i = MIN(CSUM_CHUNK-sumresidue,len); - bcopy(p,sumrbuf+sumresidue,i); - MDupdate(&sumMD, sumrbuf, (i+sumresidue)*8); - len -= i; - p += i; - } - - for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) { - bcopy(p+i,sumrbuf,CSUM_CHUNK); - MDupdate(&sumMD, sumrbuf, CSUM_CHUNK*8); - } - - if (len - i > 0) { - sumresidue = len-i; - bcopy(p+i,sumrbuf,sumresidue); - } else { - sumresidue = 0; - } + if (len + sumresidue < CSUM_CHUNK) { + memcpy(sumrbuf + sumresidue, p, len); + sumresidue += len; + return; + } + + if (sumresidue) { + int32 i = CSUM_CHUNK - sumresidue; + memcpy(sumrbuf + sumresidue, p, i); + mdfour_update(&md, (uchar *)sumrbuf, CSUM_CHUNK); + len -= i; + p += i; + } + + while (len >= CSUM_CHUNK) { + mdfour_update(&md, (uchar *)p, CSUM_CHUNK); + len -= CSUM_CHUNK; + p += CSUM_CHUNK; + } + + sumresidue = len; + if (sumresidue) + memcpy(sumrbuf, p, sumresidue); } void sum_end(char *sum) { - if (sumresidue) - MDupdate(&sumMD, sumrbuf, sumresidue*8); + if (sumresidue || protocol_version >= 27) + mdfour_update(&md, (uchar *)sumrbuf, sumresidue); - SIVAL(sum,0,sumMD.buffer[0]); - SIVAL(sum,4,sumMD.buffer[1]); - SIVAL(sum,8,sumMD.buffer[2]); - SIVAL(sum,12,sumMD.buffer[3]); + mdfour_result(&md, (uchar *)sum); } - -