md5.diff

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