checksum.c

   1 /*
   2  * Routines to support checksumming of bytes.
   3  *
   4  * Copyright (C) 1996 Andrew Tridgell
   5  * Copyright (C) 1996 Paul Mackerras
   6  * Copyright (C) 2004-2007 Wayne Davison
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
  20  */
  21
  22 #include "rsync.h"
  23
  24 int csum_length = SHORT_SUM_LENGTH; /* initial value */
  25
  26 #define CSUM_CHUNK 64
  27
  28 extern int checksum_seed;
  29 extern int protocol_version;
  30
  31 /*
  32   a simple 32 bit checksum that can be upadted from either end
  33   (inspired by Mark Adler's Adler-32 checksum)
  34   */
  35 uint32 get_checksum1(char *buf1, int32 len)
  36 {
  37     int32 i;
  38     uint32 s1, s2;
  39     schar *buf = (schar *)buf1;
  40
  41     s1 = s2 = 0;
  42     for (i = 0; i < (len-4); i+=4) {
  43         s2 += 4*(s1 + buf[i]) + 3*buf[i+1] + 2*buf[i+2] + buf[i+3] +
  44           10*CHAR_OFFSET;
  45         s1 += (buf[i+0] + buf[i+1] + buf[i+2] + buf[i+3] + 4*CHAR_OFFSET);
  46     }
  47     for (; i < len; i++) {
  48         s1 += (buf[i]+CHAR_OFFSET); s2 += s1;
  49     }
  50     return (s1 & 0xffff) + (s2 << 16);
  51 }
  52
  53
  54 void get_checksum2(char *buf, int32 len, char *sum)
  55 {
  56         int32 i;
  57         static char *buf1;
  58         static int32 len1;
  59         struct mdfour m;
  60
  61         if (len > len1) {
  62                 if (buf1)
  63                         free(buf1);
  64                 buf1 = new_array(char, len+4);
  65                 len1 = len;
  66                 if (!buf1)
  67                         out_of_memory("get_checksum2");
  68         }
  69
  70         mdfour_begin(&m);
  71
  72         memcpy(buf1,buf,len);
  73         if (checksum_seed) {
  74                 SIVAL(buf1,len,checksum_seed);
  75                 len += 4;
  76         }
  77
  78         for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) {
  79                 mdfour_update(&m, (uchar *)(buf1+i), CSUM_CHUNK);
  80         }
  81         /*
  82          * Prior to version 27 an incorrect MD4 checksum was computed
  83          * by failing to call mdfour_tail() for block sizes that
  84          * are multiples of 64.  This is fixed by calling mdfour_update()
  85          * even when there are no more bytes.
  86          */
  87         if (len - i > 0 || protocol_version >= 27) {
  88                 mdfour_update(&m, (uchar *)(buf1+i), (len-i));
  89         }
  90
  91         mdfour_result(&m, (uchar *)sum);
  92 }
  93
  94
  95 void file_checksum(char *fname,char *sum,OFF_T size)
  96 {
  97         struct map_struct *buf;
  98         OFF_T i, len = size;
  99         struct mdfour m;
 100         int32 remainder;
 101         int fd;
 102
 103         memset(sum,0,MD4_SUM_LENGTH);
 104
 105         fd = do_open(fname, O_RDONLY, 0);
 106         if (fd == -1)
 107                 return;
 108
 109         buf = map_file(fd, size, MAX_MAP_SIZE, CSUM_CHUNK);
 110
 111         mdfour_begin(&m);
 112
 113         for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) {
 114                 mdfour_update(&m, (uchar *)map_ptr(buf, i, CSUM_CHUNK),
 115                               CSUM_CHUNK);
 116         }
 117
 118         /* Prior to version 27 an incorrect MD4 checksum was computed
 119          * by failing to call mdfour_tail() for block sizes that
 120          * are multiples of 64.  This is fixed by calling mdfour_update()
 121          * even when there are no more bytes. */
 122         remainder = (int32)(len - i);
 123         if (remainder > 0 || protocol_version >= 27)
 124                 mdfour_update(&m, (uchar *)map_ptr(buf, i, remainder), remainder);
 125
 126         mdfour_result(&m, (uchar *)sum);
 127
 128         close(fd);
 129         unmap_file(buf);
 130 }
 131
 132
 133 static int32 sumresidue;
 134 static char sumrbuf[CSUM_CHUNK];
 135 static struct mdfour md;
 136
 137 void sum_init(int seed)
 138 {
 139         char s[4];
 140         mdfour_begin(&md);
 141         sumresidue = 0;
 142         SIVAL(s, 0, seed);
 143         sum_update(s, 4);
 144 }
 145
 146 /**
 147  * Feed data into an MD4 accumulator, md.  The results may be
 148  * retrieved using sum_end().  md is used for different purposes at
 149  * different points during execution.
 150  *
 151  * @todo Perhaps get rid of md and just pass in the address each time.
 152  * Very slightly clearer and slower.
 153  **/
 154 void sum_update(const char *p, int32 len)
 155 {
 156         if (len + sumresidue < CSUM_CHUNK) {
 157                 memcpy(sumrbuf + sumresidue, p, len);
 158                 sumresidue += len;
 159                 return;
 160         }
 161
 162         if (sumresidue) {
 163                 int32 i = CSUM_CHUNK - sumresidue;
 164                 memcpy(sumrbuf + sumresidue, p, i);
 165                 mdfour_update(&md, (uchar *)sumrbuf, CSUM_CHUNK);
 166                 len -= i;
 167                 p += i;
 168         }
 169
 170         while (len >= CSUM_CHUNK) {
 171                 mdfour_update(&md, (uchar *)p, CSUM_CHUNK);
 172                 len -= CSUM_CHUNK;
 173                 p += CSUM_CHUNK;
 174         }
 175
 176         sumresidue = len;
 177         if (sumresidue)
 178                 memcpy(sumrbuf, p, sumresidue);
 179 }
 180
 181 void sum_end(char *sum)
 182 {
 183         if (sumresidue || protocol_version >= 27)
 184                 mdfour_update(&md, (uchar *)sumrbuf, sumresidue);
 185
 186         mdfour_result(&md, (uchar *)sum);
 187 }