md5.diff

   1 --- old/Makefile.in
   2 +++ new/Makefile.in
   3 @@ -26,7 +26,7 @@ VERSION=@VERSION@
   4  .SUFFIXES: .c .o
   5
   6  HEADERS=byteorder.h config.h errcode.h proto.h rsync.h lib/pool_alloc.h
   7 -LIBOBJ=lib/wildmatch.o lib/compat.o lib/snprintf.o lib/mdfour.o \
   8 +LIBOBJ=lib/wildmatch.o lib/compat.o lib/snprintf.o lib/mdfour.o lib/md5.o \
   9         lib/permstring.o lib/pool_alloc.o @LIBOBJS@
  10  ZLIBOBJ=zlib/deflate.o zlib/inffast.o zlib/inflate.o zlib/inftrees.o \
  11         zlib/trees.o zlib/zutil.o zlib/adler32.o zlib/compress.o zlib/crc32.o
  12 --- old/checksum.c
  13 +++ new/checksum.c
  14 @@ -18,6 +18,7 @@
  15  */
  16
  17  #include "rsync.h"
  18 +#include "lib/md5.h"
  19
  20  int csum_length=2; /* initial value */
  21
  22 @@ -25,6 +26,7 @@ int csum_length=2; /* initial value */
  23
  24  extern int checksum_seed;
  25  extern int protocol_version;
  26 +extern int use_md5;
  27
  28  /*
  29    a simple 32 bit checksum that can be upadted from either end
  30 @@ -55,6 +57,7 @@ void get_checksum2(char *buf, int32 len,
  31         static char *buf1;
  32         static int32 len1;
  33         struct mdfour m;
  34 +       md5_context ctx;
  35
  36         if (len > len1) {
  37                 if (buf1)
  38 @@ -65,7 +68,10 @@ void get_checksum2(char *buf, int32 len,
  39                         out_of_memory("get_checksum2");
  40         }
  41
  42 -       mdfour_begin(&m);
  43 +       if (use_md5)
  44 +               md5_starts(&ctx);
  45 +       else
  46 +               mdfour_begin(&m);
  47
  48         memcpy(buf1,buf,len);
  49         if (checksum_seed) {
  50 @@ -74,7 +80,10 @@ void get_checksum2(char *buf, int32 len,
  51         }
  52
  53         for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) {
  54 -               mdfour_update(&m, (uchar *)(buf1+i), CSUM_CHUNK);
  55 +               if (use_md5)
  56 +                       md5_update(&ctx, (uchar *)(buf1+i), CSUM_CHUNK);
  57 +               else
  58 +                       mdfour_update(&m, (uchar *)(buf1+i), CSUM_CHUNK);
  59         }
  60         /*
  61          * Prior to version 27 an incorrect MD4 checksum was computed
  62 @@ -83,10 +92,16 @@ void get_checksum2(char *buf, int32 len,
  63          * even when there are no more bytes.
  64          */
  65         if (len - i > 0 || protocol_version >= 27) {
  66 -               mdfour_update(&m, (uchar *)(buf1+i), (len-i));
  67 +               if (use_md5)
  68 +                       md5_update(&ctx, (uchar *)(buf1+i), len-i);
  69 +               else
  70 +                       mdfour_update(&m, (uchar *)(buf1+i), len-i);
  71         }
  72
  73 -       mdfour_result(&m, (uchar *)sum);
  74 +       if (use_md5)
  75 +               md5_finish(&ctx, (uchar *)sum);
  76 +       else
  77 +               mdfour_result(&m, (uchar *)sum);
  78  }
  79
  80
  81 @@ -97,6 +112,7 @@ void file_checksum(char *fname,char *sum
  82         int fd;
  83         OFF_T len = size;
  84         struct mdfour m;
  85 +       md5_context ctx;
  86
  87         memset(sum,0,MD4_SUM_LENGTH);
  88
  89 @@ -106,21 +122,36 @@ void file_checksum(char *fname,char *sum
  90
  91         buf = map_file(fd, size, MAX_MAP_SIZE, CSUM_CHUNK);
  92
  93 -       mdfour_begin(&m);
  94 +       if (use_md5)
  95 +               md5_starts(&ctx);
  96 +       else
  97 +               mdfour_begin(&m);
  98
  99         for(i = 0; i + CSUM_CHUNK <= len; i += CSUM_CHUNK) {
 100 -               mdfour_update(&m, (uchar *)map_ptr(buf, i, CSUM_CHUNK),
 101 -                             CSUM_CHUNK);
 102 +               if (use_md5) {
 103 +                       md5_update(&ctx, (uchar *)map_ptr(buf, i, CSUM_CHUNK),
 104 +                                  CSUM_CHUNK);
 105 +               } else {
 106 +                       mdfour_update(&m, (uchar *)map_ptr(buf, i, CSUM_CHUNK),
 107 +                                     CSUM_CHUNK);
 108 +               }
 109         }
 110
 111         /* Prior to version 27 an incorrect MD4 checksum was computed
 112          * by failing to call mdfour_tail() for block sizes that
 113          * are multiples of 64.  This is fixed by calling mdfour_update()
 114          * even when there are no more bytes. */
 115 -       if (len - i > 0 || protocol_version >= 27)
 116 -               mdfour_update(&m, (uchar *)map_ptr(buf, i, len-i), len-i);
 117 +       if (len - i > 0 || protocol_version >= 27) {
 118 +               if (use_md5)
 119 +                       md5_update(&ctx, (uchar *)map_ptr(buf, i, len-i), len-i);
 120 +               else
 121 +                       mdfour_update(&m, (uchar *)map_ptr(buf, i, len-i), len-i);
 122 +       }
 123
 124 -       mdfour_result(&m, (uchar *)sum);
 125 +       if (use_md5)
 126 +               md5_finish(&ctx, (uchar *)sum);
 127 +       else
 128 +               mdfour_result(&m, (uchar *)sum);
 129
 130         close(fd);
 131         unmap_file(buf);
 132 @@ -130,11 +161,15 @@ void file_checksum(char *fname,char *sum
 133  static int32 sumresidue;
 134  static char sumrbuf[CSUM_CHUNK];
 135  static struct mdfour md;
 136 +static md5_context ctxd;
 137
 138  void sum_init(int seed)
 139  {
 140         char s[4];
 141 -       mdfour_begin(&md);
 142 +       if (use_md5)
 143 +               md5_starts(&ctxd);
 144 +       else
 145 +               mdfour_begin(&md);
 146         sumresidue = 0;
 147         SIVAL(s, 0, seed);
 148         sum_update(s, 4);
 149 @@ -159,13 +194,19 @@ void sum_update(char *p, int32 len)
 150         if (sumresidue) {
 151                 int32 i = CSUM_CHUNK - sumresidue;
 152                 memcpy(sumrbuf + sumresidue, p, i);
 153 -               mdfour_update(&md, (uchar *)sumrbuf, CSUM_CHUNK);
 154 +               if (use_md5)
 155 +                       md5_update(&ctxd, (uchar *)sumrbuf, CSUM_CHUNK);
 156 +               else
 157 +                       mdfour_update(&md, (uchar *)sumrbuf, CSUM_CHUNK);
 158                 len -= i;
 159                 p += i;
 160         }
 161
 162         while (len >= CSUM_CHUNK) {
 163 -               mdfour_update(&md, (uchar *)p, CSUM_CHUNK);
 164 +               if (use_md5)
 165 +                       md5_update(&ctxd, (uchar *)p, CSUM_CHUNK);
 166 +               else
 167 +                       mdfour_update(&md, (uchar *)p, CSUM_CHUNK);
 168                 len -= CSUM_CHUNK;
 169                 p += CSUM_CHUNK;
 170         }
 171 @@ -177,8 +218,15 @@ void sum_update(char *p, int32 len)
 172
 173  void sum_end(char *sum)
 174  {
 175 -       if (sumresidue || protocol_version >= 27)
 176 -               mdfour_update(&md, (uchar *)sumrbuf, sumresidue);
 177 +       if (sumresidue || protocol_version >= 27) {
 178 +               if (use_md5)
 179 +                       md5_update(&ctxd, (uchar *)sumrbuf, sumresidue);
 180 +               else
 181 +                       mdfour_update(&md, (uchar *)sumrbuf, sumresidue);
 182 +       }
 183
 184 -       mdfour_result(&md, (uchar *)sum);
 185 +       if (use_md5)
 186 +               md5_finish(&ctxd, (uchar *)sum);
 187 +       else
 188 +               mdfour_result(&md, (uchar *)sum);
 189  }
 190 --- old/lib/md5.c
 191 +++ new/lib/md5.c
 192 @@ -0,0 +1,344 @@
 193 +/*
 194 + *  RFC 1321 compliant MD5 implementation
 195 + *
 196 + *  Copyright (C) 2001-2003  Christophe Devine
 197 + *
 198 + *  This program is free software; you can redistribute it and/or modify
 199 + *  it under the terms of the GNU General Public License as published by
 200 + *  the Free Software Foundation; either version 2 of the License, or
 201 + *  (at your option) any later version.
 202 + *
 203 + *  This program is distributed in the hope that it will be useful,
 204 + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 205 + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 206 + *  GNU General Public License for more details.
 207 + *
 208 + *  You should have received a copy of the GNU General Public License
 209 + *  along with this program; if not, write to the Free Software
 210 + *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 211 + */
 212 +
 213 +
 214 +#include "rsync.h"
 215 +#include "md5.h"
 216 +
 217 +#define GET_UINT32(n,b,i)                       \
 218 +{                                               \
 219 +    (n) = ( (uint32) (b)[(i)    ]       )       \
 220 +        | ( (uint32) (b)[(i) + 1] <<  8 )       \
 221 +        | ( (uint32) (b)[(i) + 2] << 16 )       \
 222 +        | ( (uint32) (b)[(i) + 3] << 24 );      \
 223 +}
 224 +
 225 +#define PUT_UINT32(n,b,i)                       \
 226 +{                                               \
 227 +    (b)[(i)    ] = (uchar) ( (n)       );       \
 228 +    (b)[(i) + 1] = (uchar) ( (n) >>  8 );       \
 229 +    (b)[(i) + 2] = (uchar) ( (n) >> 16 );       \
 230 +    (b)[(i) + 3] = (uchar) ( (n) >> 24 );       \
 231 +}
 232 +
 233 +void md5_starts( md5_context *ctx )
 234 +{
 235 +    ctx->total[0] = 0;
 236 +    ctx->total[1] = 0;
 237 +
 238 +    ctx->state[0] = 0x67452301;
 239 +    ctx->state[1] = 0xEFCDAB89;
 240 +    ctx->state[2] = 0x98BADCFE;
 241 +    ctx->state[3] = 0x10325476;
 242 +}
 243 +
 244 +void md5_process( md5_context *ctx, uchar data[64] )
 245 +{
 246 +    uint32 X[16], A, B, C, D;
 247 +
 248 +    GET_UINT32( X[0],  data,  0 );
 249 +    GET_UINT32( X[1],  data,  4 );
 250 +    GET_UINT32( X[2],  data,  8 );
 251 +    GET_UINT32( X[3],  data, 12 );
 252 +    GET_UINT32( X[4],  data, 16 );
 253 +    GET_UINT32( X[5],  data, 20 );
 254 +    GET_UINT32( X[6],  data, 24 );
 255 +    GET_UINT32( X[7],  data, 28 );
 256 +    GET_UINT32( X[8],  data, 32 );
 257 +    GET_UINT32( X[9],  data, 36 );
 258 +    GET_UINT32( X[10], data, 40 );
 259 +    GET_UINT32( X[11], data, 44 );
 260 +    GET_UINT32( X[12], data, 48 );
 261 +    GET_UINT32( X[13], data, 52 );
 262 +    GET_UINT32( X[14], data, 56 );
 263 +    GET_UINT32( X[15], data, 60 );
 264 +
 265 +#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
 266 +
 267 +#define P(a,b,c,d,k,s,t)                                \
 268 +{                                                       \
 269 +    a += F(b,c,d) + X[k] + t; a = S(a,s) + b;           \
 270 +}
 271 +
 272 +    A = ctx->state[0];
 273 +    B = ctx->state[1];
 274 +    C = ctx->state[2];
 275 +    D = ctx->state[3];
 276 +
 277 +#define F(x,y,z) (z ^ (x & (y ^ z)))
 278 +
 279 +    P( A, B, C, D,  0,  7, 0xD76AA478 );
 280 +    P( D, A, B, C,  1, 12, 0xE8C7B756 );
 281 +    P( C, D, A, B,  2, 17, 0x242070DB );
 282 +    P( B, C, D, A,  3, 22, 0xC1BDCEEE );
 283 +    P( A, B, C, D,  4,  7, 0xF57C0FAF );
 284 +    P( D, A, B, C,  5, 12, 0x4787C62A );
 285 +    P( C, D, A, B,  6, 17, 0xA8304613 );
 286 +    P( B, C, D, A,  7, 22, 0xFD469501 );
 287 +    P( A, B, C, D,  8,  7, 0x698098D8 );
 288 +    P( D, A, B, C,  9, 12, 0x8B44F7AF );
 289 +    P( C, D, A, B, 10, 17, 0xFFFF5BB1 );
 290 +    P( B, C, D, A, 11, 22, 0x895CD7BE );
 291 +    P( A, B, C, D, 12,  7, 0x6B901122 );
 292 +    P( D, A, B, C, 13, 12, 0xFD987193 );
 293 +    P( C, D, A, B, 14, 17, 0xA679438E );
 294 +    P( B, C, D, A, 15, 22, 0x49B40821 );
 295 +
 296 +#undef F
 297 +
 298 +#define F(x,y,z) (y ^ (z & (x ^ y)))
 299 +
 300 +    P( A, B, C, D,  1,  5, 0xF61E2562 );
 301 +    P( D, A, B, C,  6,  9, 0xC040B340 );
 302 +    P( C, D, A, B, 11, 14, 0x265E5A51 );
 303 +    P( B, C, D, A,  0, 20, 0xE9B6C7AA );
 304 +    P( A, B, C, D,  5,  5, 0xD62F105D );
 305 +    P( D, A, B, C, 10,  9, 0x02441453 );
 306 +    P( C, D, A, B, 15, 14, 0xD8A1E681 );
 307 +    P( B, C, D, A,  4, 20, 0xE7D3FBC8 );
 308 +    P( A, B, C, D,  9,  5, 0x21E1CDE6 );
 309 +    P( D, A, B, C, 14,  9, 0xC33707D6 );
 310 +    P( C, D, A, B,  3, 14, 0xF4D50D87 );
 311 +    P( B, C, D, A,  8, 20, 0x455A14ED );
 312 +    P( A, B, C, D, 13,  5, 0xA9E3E905 );
 313 +    P( D, A, B, C,  2,  9, 0xFCEFA3F8 );
 314 +    P( C, D, A, B,  7, 14, 0x676F02D9 );
 315 +    P( B, C, D, A, 12, 20, 0x8D2A4C8A );
 316 +
 317 +#undef F
 318 +
 319 +#define F(x,y,z) (x ^ y ^ z)
 320 +
 321 +    P( A, B, C, D,  5,  4, 0xFFFA3942 );
 322 +    P( D, A, B, C,  8, 11, 0x8771F681 );
 323 +    P( C, D, A, B, 11, 16, 0x6D9D6122 );
 324 +    P( B, C, D, A, 14, 23, 0xFDE5380C );
 325 +    P( A, B, C, D,  1,  4, 0xA4BEEA44 );
 326 +    P( D, A, B, C,  4, 11, 0x4BDECFA9 );
 327 +    P( C, D, A, B,  7, 16, 0xF6BB4B60 );
 328 +    P( B, C, D, A, 10, 23, 0xBEBFBC70 );
 329 +    P( A, B, C, D, 13,  4, 0x289B7EC6 );
 330 +    P( D, A, B, C,  0, 11, 0xEAA127FA );
 331 +    P( C, D, A, B,  3, 16, 0xD4EF3085 );
 332 +    P( B, C, D, A,  6, 23, 0x04881D05 );
 333 +    P( A, B, C, D,  9,  4, 0xD9D4D039 );
 334 +    P( D, A, B, C, 12, 11, 0xE6DB99E5 );
 335 +    P( C, D, A, B, 15, 16, 0x1FA27CF8 );
 336 +    P( B, C, D, A,  2, 23, 0xC4AC5665 );
 337 +
 338 +#undef F
 339 +
 340 +#define F(x,y,z) (y ^ (x | ~z))
 341 +
 342 +    P( A, B, C, D,  0,  6, 0xF4292244 );
 343 +    P( D, A, B, C,  7, 10, 0x432AFF97 );
 344 +    P( C, D, A, B, 14, 15, 0xAB9423A7 );
 345 +    P( B, C, D, A,  5, 21, 0xFC93A039 );
 346 +    P( A, B, C, D, 12,  6, 0x655B59C3 );
 347 +    P( D, A, B, C,  3, 10, 0x8F0CCC92 );
 348 +    P( C, D, A, B, 10, 15, 0xFFEFF47D );
 349 +    P( B, C, D, A,  1, 21, 0x85845DD1 );
 350 +    P( A, B, C, D,  8,  6, 0x6FA87E4F );
 351 +    P( D, A, B, C, 15, 10, 0xFE2CE6E0 );
 352 +    P( C, D, A, B,  6, 15, 0xA3014314 );
 353 +    P( B, C, D, A, 13, 21, 0x4E0811A1 );
 354 +    P( A, B, C, D,  4,  6, 0xF7537E82 );
 355 +    P( D, A, B, C, 11, 10, 0xBD3AF235 );
 356 +    P( C, D, A, B,  2, 15, 0x2AD7D2BB );
 357 +    P( B, C, D, A,  9, 21, 0xEB86D391 );
 358 +
 359 +#undef F
 360 +
 361 +    ctx->state[0] += A;
 362 +    ctx->state[1] += B;
 363 +    ctx->state[2] += C;
 364 +    ctx->state[3] += D;
 365 +}
 366 +
 367 +void md5_update( md5_context *ctx, uchar *input, uint32 length )
 368 +{
 369 +    uint32 left, fill;
 370 +
 371 +    if( ! length ) return;
 372 +
 373 +    left = ctx->total[0] & 0x3F;
 374 +    fill = 64 - left;
 375 +
 376 +    ctx->total[0] += length;
 377 +    ctx->total[0] &= 0xFFFFFFFF;
 378 +
 379 +    if( ctx->total[0] < length )
 380 +        ctx->total[1]++;
 381 +
 382 +    if( left && length >= fill )
 383 +    {
 384 +        memcpy( (void *) (ctx->buffer + left),
 385 +                (void *) input, fill );
 386 +        md5_process( ctx, ctx->buffer );
 387 +        length -= fill;
 388 +        input  += fill;
 389 +        left = 0;
 390 +    }
 391 +
 392 +    while( length >= 64 )
 393 +    {
 394 +        md5_process( ctx, input );
 395 +        length -= 64;
 396 +        input  += 64;
 397 +    }
 398 +
 399 +    if( length )
 400 +    {
 401 +        memcpy( (void *) (ctx->buffer + left),
 402 +                (void *) input, length );
 403 +    }
 404 +}
 405 +
 406 +static uchar md5_padding[64] =
 407 +{
 408 + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 409 +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 410 +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 411 +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 412 +};
 413 +
 414 +void md5_finish( md5_context *ctx, uchar digest[16] )
 415 +{
 416 +    uint32 last, padn;
 417 +    uint32 high, low;
 418 +    uchar msglen[8];
 419 +
 420 +    high = ( ctx->total[0] >> 29 )
 421 +         | ( ctx->total[1] <<  3 );
 422 +    low  = ( ctx->total[0] <<  3 );
 423 +
 424 +    PUT_UINT32( low,  msglen, 0 );
 425 +    PUT_UINT32( high, msglen, 4 );
 426 +
 427 +    last = ctx->total[0] & 0x3F;
 428 +    padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
 429 +
 430 +    md5_update( ctx, md5_padding, padn );
 431 +    md5_update( ctx, msglen, 8 );
 432 +
 433 +    PUT_UINT32( ctx->state[0], digest,  0 );
 434 +    PUT_UINT32( ctx->state[1], digest,  4 );
 435 +    PUT_UINT32( ctx->state[2], digest,  8 );
 436 +    PUT_UINT32( ctx->state[3], digest, 12 );
 437 +}
 438 +
 439 +#ifdef TEST
 440 +
 441 +#include <stdlib.h>
 442 +#include <stdio.h>
 443 +
 444 +/*
 445 + * those are the standard RFC 1321 test vectors
 446 + */
 447 +
 448 +static char *msg[] =
 449 +{
 450 +    "",
 451 +    "a",
 452 +    "abc",
 453 +    "message digest",
 454 +    "abcdefghijklmnopqrstuvwxyz",
 455 +    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
 456 +    "12345678901234567890123456789012345678901234567890123456789012" \
 457 +        "345678901234567890"
 458 +};
 459 +
 460 +static char *val[] =
 461 +{
 462 +    "d41d8cd98f00b204e9800998ecf8427e",
 463 +    "0cc175b9c0f1b6a831c399e269772661",
 464 +    "900150983cd24fb0d6963f7d28e17f72",
 465 +    "f96b697d7cb7938d525a2f31aaf161d0",
 466 +    "c3fcd3d76192e4007dfb496cca67e13b",
 467 +    "d174ab98d277d9f5a5611c2c9f419d9f",
 468 +    "57edf4a22be3c955ac49da2e2107b67a"
 469 +};
 470 +
 471 +int main( int argc, char *argv[] )
 472 +{
 473 +    FILE *f;
 474 +    int i, j;
 475 +    char output[33];
 476 +    md5_context ctx;
 477 +    unsigned char buf[1000];
 478 +    unsigned char md5sum[16];
 479 +
 480 +    if( argc < 2 )
 481 +    {
 482 +        printf( "\n MD5 Validation Tests:\n\n" );
 483 +
 484 +        for( i = 0; i < 7; i++ )
 485 +        {
 486 +            printf( " Test %d ", i + 1 );
 487 +
 488 +            md5_starts( &ctx );
 489 +            md5_update( &ctx, (uchar *) msg[i], strlen( msg[i] ) );
 490 +            md5_finish( &ctx, md5sum );
 491 +
 492 +            for( j = 0; j < 16; j++ )
 493 +            {
 494 +                sprintf( output + j * 2, "%02x", md5sum[j] );
 495 +            }
 496 +
 497 +            if( memcmp( output, val[i], 32 ) )
 498 +            {
 499 +                printf( "failed!\n" );
 500 +                return( 1 );
 501 +            }
 502 +
 503 +            printf( "passed.\n" );
 504 +        }
 505 +
 506 +        printf( "\n" );
 507 +    }
 508 +    else
 509 +    {
 510 +        if( ! ( f = fopen( argv[1], "rb" ) ) )
 511 +        {
 512 +            perror( "fopen" );
 513 +            return( 1 );
 514 +        }
 515 +
 516 +        md5_starts( &ctx );
 517 +
 518 +        while( ( i = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
 519 +        {
 520 +            md5_update( &ctx, buf, i );
 521 +        }
 522 +
 523 +        md5_finish( &ctx, md5sum );
 524 +
 525 +        for( j = 0; j < 16; j++ )
 526 +        {
 527 +            printf( "%02x", md5sum[j] );
 528 +        }
 529 +
 530 +        printf( "  %s\n", argv[1] );
 531 +    }
 532 +
 533 +    return( 0 );
 534 +}
 535 +
 536 +#endif
 537 --- old/lib/md5.h
 538 +++ new/lib/md5.h
 539 @@ -0,0 +1,14 @@
 540 +#ifndef _MD5_H
 541 +#define _MD5_H
 542 +
 543 +typedef struct {
 544 +    uint32 total[2];
 545 +    uint32 state[4];
 546 +    uchar buffer[64];
 547 +} md5_context;
 548 +
 549 +void md5_starts(md5_context *ctx);
 550 +void md5_update(md5_context *ctx, uchar *input, uint32 length);
 551 +void md5_finish(md5_context *ctx, uchar digest[16]);
 552 +
 553 +#endif /* md5.h */
 554 --- old/options.c
 555 +++ new/options.c
 556 @@ -116,6 +116,7 @@ int inplace = 0;
 557  int delay_updates = 0;
 558  long block_size = 0; /* "long" because popt can't set an int32. */
 559
 560 +int use_md5 = 0;
 561
 562  /** Network address family. **/
 563  #ifdef INET6
 564 @@ -367,6 +368,7 @@ void usage(enum logcode F)
 565    rprintf(F,"     --only-write-batch=FILE like --write-batch but w/o updating destination\n");
 566    rprintf(F,"     --read-batch=FILE       read a batched update from FILE\n");
 567    rprintf(F,"     --protocol=NUM          force an older protocol version to be used\n");
 568 +  rprintf(F,"     --md5                   use MD5 checksums instead of MD4\n");
 569  #ifdef INET6
 570    rprintf(F," -4, --ipv4                  prefer IPv4\n");
 571    rprintf(F," -6, --ipv6                  prefer IPv6\n");
 572 @@ -473,6 +475,7 @@ static struct poptOption long_options[]
 573    {"whole-file",      'W', POPT_ARG_VAL,    &whole_file, 1, 0, 0 },
 574    {"no-whole-file",    0,  POPT_ARG_VAL,    &whole_file, 0, 0, 0 },
 575    {"no-W",             0,  POPT_ARG_VAL,    &whole_file, 0, 0, 0 },
 576 +  {"md5",              0,  POPT_ARG_NONE,   &use_md5, 0, 0, 0 },
 577    {"checksum",        'c', POPT_ARG_NONE,   &always_checksum, 0, 0, 0 },
 578    {"block-size",      'B', POPT_ARG_LONG,   &block_size, 0, 0, 0 },
 579    {"compare-dest",     0,  POPT_ARG_STRING, 0, OPT_COMPARE_DEST, 0, 0 },
 580 @@ -1608,6 +1611,9 @@ void server_options(char **args,int *arg
 581                 args[ac++] = arg;
 582         }
 583
 584 +       if (use_md5)
 585 +               args[ac++] = "--md5";
 586 +
 587         if (backup_dir) {
 588                 args[ac++] = "--backup-dir";
 589                 args[ac++] = backup_dir;