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