Merge remote branch 'origin/mdb.master'

[openldap] / libraries / liblutil / md5.c

diff --git a/libraries/liblutil/md5.c b/libraries/liblutil/md5.c
index 9fbf7e2755962ff04d6f2d2f18a5e47eed845874..12bb58b68c13d4d92f0dff6c4b4c1282d5d14d7c 100644 (file)
--- a/libraries/liblutil/md5.c
+++ b/libraries/liblutil/md5.c
@@ -1,7 +1,21 @@
-/*
- * Modified by Kurt D. Zeilenga for inclusion into OpenLDAP
- * I hereby disclaim copyright in any changes I have made; this
- * code remains in the public domain.
+/* md5.c -- MD5 message-digest algorithm */
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 1998-2011 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* This work was adapted for inclusion in OpenLDAP Software by
+ * Kurt D. Zeilenga based upon code developed by Colin Plumb
+ * and subsequently modified by Jim Kingdon. 
  */
 
 /*
@@ -39,12 +53,12 @@
 #include <lutil_md5.h>
 
 /* Little-endian byte-swapping routines.  Note that these do not
-   depend on the size of datatypes such as uint32, nor do they require
+   depend on the size of datatypes such as ber_uint_t, nor do they require
    us to detect the endianness of the machine we are running on.  It
    is possible they should be macros for speed, but I would be
    surprised if they were a performance bottleneck for MD5.  */
 
-static uint32
+static ber_uint_t
 getu32( const unsigned char *addr )
 {
        return (((((unsigned long)addr[3] << 8) | addr[2]) << 8)
@@ -52,7 +66,7 @@ getu32( const unsigned char *addr )
 }
 
 static void
-putu32( uint32 data, unsigned char *addr )
+putu32( ber_uint_t data, unsigned char *addr )
 {
        addr[0] = (unsigned char)data;
        addr[1] = (unsigned char)(data >> 8);
@@ -84,15 +98,15 @@ void
 lutil_MD5Update(
     struct lutil_MD5Context    *ctx,
     const unsigned char                *buf,
-    unsigned int               len
+    ber_len_t          len
 )
 {
-       uint32 t;
+       ber_uint_t t;
 
        /* Update bitcount */
 
        t = ctx->bits[0];
-       if ((ctx->bits[0] = (t + ((uint32)len << 3)) & 0xffffffff) < t)
+       if ((ctx->bits[0] = (t + ((ber_uint_t)len << 3)) & 0xffffffff) < t)
                ctx->bits[1]++; /* Carry from low to high */
        ctx->bits[1] += len >> 29;
 
@@ -105,10 +119,10 @@ lutil_MD5Update(
 
                t = 64-t;
                if (len < t) {
-                       memcpy(p, buf, len);
+                       AC_MEMCPY(p, buf, len);
                        return;
                }
-               memcpy(p, buf, t);
+               AC_MEMCPY(p, buf, t);
                lutil_MD5Transform(ctx->buf, ctx->in);
                buf += t;
                len -= t;
@@ -117,7 +131,7 @@ lutil_MD5Update(
        /* Process data in 64-byte chunks */
 
        while (len >= 64) {
-               memcpy(ctx->in, buf, 64);
+               AC_MEMCPY(ctx->in, buf, 64);
                lutil_MD5Transform(ctx->buf, ctx->in);
                buf += 64;
                len -= 64;
@@ -125,7 +139,7 @@ lutil_MD5Update(
 
        /* Handle any remaining bytes of data. */
 
-       memcpy(ctx->in, buf, len);
+       AC_MEMCPY(ctx->in, buf, len);
 }
 
 /*
@@ -152,14 +166,14 @@ lutil_MD5Final( unsigned char *digest, struct lutil_MD5Context *ctx )
        /* Pad out to 56 mod 64 */
        if (count < 8) {
                /* Two lots of padding:  Pad the first block to 64 bytes */
-               memset(p, 0, count);
+               memset(p, '\0', count);
                lutil_MD5Transform(ctx->buf, ctx->in);
 
                /* Now fill the next block with 56 bytes */
-               memset(ctx->in, 0, 56);
+               memset(ctx->in, '\0', 56);
        } else {
                /* Pad block to 56 bytes */
-               memset(p, 0, count-8);
+               memset(p, '\0', count-8);
        }
 
        /* Append length in bits and transform */
@@ -171,7 +185,7 @@ lutil_MD5Final( unsigned char *digest, struct lutil_MD5Context *ctx )
        putu32(ctx->buf[1], digest + 4);
        putu32(ctx->buf[2], digest + 8);
        putu32(ctx->buf[3], digest + 12);
-       memset(ctx, 0, sizeof(ctx));    /* In case it's sensitive */
+       memset(ctx, '\0', sizeof(*ctx));        /* In case it's sensitive */
 }
 
 #ifndef ASM_MD5
@@ -194,10 +208,10 @@ lutil_MD5Final( unsigned char *digest, struct lutil_MD5Context *ctx )
  * the data and converts bytes into longwords for this routine.
  */
 void
-lutil_MD5Transform( uint32 *buf, const unsigned char *inraw )
+lutil_MD5Transform( ber_uint_t *buf, const unsigned char *inraw )
 {
-       register uint32 a, b, c, d;
-       uint32 in[16];
+       register ber_uint_t a, b, c, d;
+       ber_uint_t in[16];
        int i;
 
        for (i = 0; i < 16; ++i)
@@ -292,7 +306,7 @@ int
 main (int  argc, char **argv )
 {
        struct lutil_MD5Context context;
-       unsigned char checksum[16];
+       unsigned char checksum[LUTIL_MD5_BYTES];
        int i;
        int j;
 
@@ -307,7 +321,7 @@ main (int  argc, char **argv )
                lutil_MD5Init (&context);
                lutil_MD5Update (&context, argv[j], strlen (argv[j]));
                lutil_MD5Final (checksum, &context);
-               for (i = 0; i < 16; i++)
+               for (i = 0; i < LUTIL_MD5_BYTES; i++)
                {
                        printf ("%02x", (unsigned int) checksum[i]);
                }