Add, forgotten in last commit.

[gnulib.git] / lib / md5.c

diff --git a/lib/md5.c b/lib/md5.c
index 39d2bb4..511a029 100644 (file)
--- a/lib/md5.c
+++ b/lib/md5.c
@@ -1,8 +1,8 @@
-/* md5.c - Functions to compute MD5 message digest of files or memory blocks
+/* Functions to compute MD5 message digest of files or memory blocks.

    according to the definition of MD5 in RFC 1321 from April 1992.
    according to the definition of MD5 in RFC 1321 from April 1992.

-   Copyright (C) 1995, 1996, 2001, 2003, 2004 Free Software Foundation, Inc.
-   NOTE: The canonical source of this file is maintained with the GNU C
-   Library.  Bugs can be reported to bug-glibc@prep.ai.mit.edu.
+   Copyright (C) 1995,1996,1997,1999,2000,2001,2005
+       Free Software Foundation, Inc.
+   This file is part of the GNU C Library.

 
    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the
 
    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the


@@ -16,7 +16,7 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software Foundation,
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software Foundation,

-   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */

 
 /* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.  */
 
 
 /* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.  */
 


@@ -27,9 +27,11 @@
 #include "md5.h"
 
 #include <stddef.h>
 #include "md5.h"
 
 #include <stddef.h>

+#include <stdlib.h>

 #include <string.h>
 #include <string.h>

+#include <sys/types.h>

 
 

-#ifdef USE_UNLOCKED_IO
+#if USE_UNLOCKED_IO

 # include "unlocked-io.h"
 #endif
 
 # include "unlocked-io.h"
 #endif
 


@@ -57,10 +59,8 @@
 #endif
 
 #define BLOCKSIZE 4096
 #endif
 
 #define BLOCKSIZE 4096

-/* Ensure that BLOCKSIZE is a multiple of 64.  */

 #if BLOCKSIZE % 64 != 0
 #if BLOCKSIZE % 64 != 0

-/* FIXME-someday (soon?): use #error instead of this kludge.  */
-"invalid BLOCKSIZE"
+# error "invalid BLOCKSIZE"

 #endif
 
 /* This array contains the bytes used to pad the buffer to the next
 #endif
 
 /* This array contains the bytes used to pad the buffer to the next


@@ -90,10 +90,10 @@ md5_init_ctx (struct md5_ctx *ctx)
 void *
 md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
 {
 void *
 md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
 {

-  ((md5_uint32 *) resbuf)[0] = SWAP (ctx->A);
-  ((md5_uint32 *) resbuf)[1] = SWAP (ctx->B);
-  ((md5_uint32 *) resbuf)[2] = SWAP (ctx->C);
-  ((md5_uint32 *) resbuf)[3] = SWAP (ctx->D);
+  ((uint32_t *) resbuf)[0] = SWAP (ctx->A);
+  ((uint32_t *) resbuf)[1] = SWAP (ctx->B);
+  ((uint32_t *) resbuf)[2] = SWAP (ctx->C);
+  ((uint32_t *) resbuf)[3] = SWAP (ctx->D);

 
   return resbuf;
 }
 
   return resbuf;
 }


@@ -107,7 +107,7 @@ void *
 md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
 {
   /* Take yet unprocessed bytes into account.  */
 md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
 {
   /* Take yet unprocessed bytes into account.  */

-  md5_uint32 bytes = ctx->buflen;
+  uint32_t bytes = ctx->buflen;

   size_t pad;
 
   /* Now count remaining bytes.  */
   size_t pad;
 
   /* Now count remaining bytes.  */


@@ -119,8 +119,8 @@ md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
   memcpy (&ctx->buffer[bytes], fillbuf, pad);
 
   /* Put the 64-bit file length in *bits* at the end of the buffer.  */
   memcpy (&ctx->buffer[bytes], fillbuf, pad);
 
   /* Put the 64-bit file length in *bits* at the end of the buffer.  */

-  *(md5_uint32 *) &ctx->buffer[bytes + pad] = SWAP (ctx->total[0] << 3);
-  *(md5_uint32 *) &ctx->buffer[bytes + pad + 4] = SWAP ((ctx->total[1] << 3) |
+  *(uint32_t *) &ctx->buffer[bytes + pad] = SWAP (ctx->total[0] << 3);
+  *(uint32_t *) &ctx->buffer[bytes + pad + 4] = SWAP ((ctx->total[1] << 3) |

                                                        (ctx->total[0] >> 29));
 
   /* Process last bytes.  */
                                                        (ctx->total[0] >> 29));
 
   /* Process last bytes.  */


@@ -246,8 +246,14 @@ md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
   if (len >= 64)
     {
 #if !_STRING_ARCH_unaligned
   if (len >= 64)
     {
 #if !_STRING_ARCH_unaligned

-# define alignof(type) offsetof (struct { char c; type x; }, x)
-# define UNALIGNED_P(p) (((size_t) p) % alignof (md5_uint32) != 0)
+/* To check alignment gcc has an appropriate operator.  Other
+   compilers don't.  */
+# if __GNUC__ >= 2
+#  define UNALIGNED_P(p) (((uintptr_t) p) % __alignof__ (uint32_t) != 0)
+# else
+#  define alignof(type) offsetof (struct { char c; type x; }, x)
+#  define UNALIGNED_P(p) (((size_t) p) % alignof (uint32_t) != 0)
+# endif

       if (UNALIGNED_P (buffer))
        while (len > 64)
          {
       if (UNALIGNED_P (buffer))
        while (len > 64)
          {


@@ -297,14 +303,14 @@ md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
 void
 md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
 {
 void
 md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
 {

-  md5_uint32 correct_words[16];
-  const md5_uint32 *words = buffer;
-  size_t nwords = len / sizeof (md5_uint32);
-  const md5_uint32 *endp = words + nwords;
-  md5_uint32 A = ctx->A;
-  md5_uint32 B = ctx->B;
-  md5_uint32 C = ctx->C;
-  md5_uint32 D = ctx->D;
+  uint32_t correct_words[16];
+  const uint32_t *words = buffer;
+  size_t nwords = len / sizeof (uint32_t);
+  const uint32_t *endp = words + nwords;
+  uint32_t A = ctx->A;
+  uint32_t B = ctx->B;
+  uint32_t C = ctx->C;
+  uint32_t D = ctx->D;

 
   /* First increment the byte count.  RFC 1321 specifies the possible
      length of the file up to 2^64 bits.  Here we only compute the
 
   /* First increment the byte count.  RFC 1321 specifies the possible
      length of the file up to 2^64 bits.  Here we only compute the


@@ -317,11 +323,11 @@ md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
      the loop.  */
   while (words < endp)
     {
      the loop.  */
   while (words < endp)
     {

-      md5_uint32 *cwp = correct_words;
-      md5_uint32 A_save = A;
-      md5_uint32 B_save = B;
-      md5_uint32 C_save = C;
-      md5_uint32 D_save = D;
+      uint32_t *cwp = correct_words;
+      uint32_t A_save = A;
+      uint32_t B_save = B;
+      uint32_t C_save = C;
+      uint32_t D_save = D;

 
       /* First round: using the given function, the context and a constant
         the next context is computed.  Because the algorithms processing
 
       /* First round: using the given function, the context and a constant
         the next context is computed.  Because the algorithms processing


@@ -335,15 +341,22 @@ md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
         {                                                              \
          a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;             \
          ++words;                                                      \
         {                                                              \
          a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;             \
          ++words;                                                      \

-         a = rol (a, s);                                               \
+         CYCLIC (a, s);                                                \

          a += b;                                                       \
         }                                                              \
       while (0)
 
          a += b;                                                       \
         }                                                              \
       while (0)
 

+      /* It is unfortunate that C does not provide an operator for
+        cyclic rotation.  Hope the C compiler is smart enough.  */
+#define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
+

       /* Before we start, one word to the strange constants.
         They are defined in RFC 1321 as
 
       /* Before we start, one word to the strange constants.
         They are defined in RFC 1321 as
 

-        T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64, or
+        T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
+
+        Here is an equivalent invocation using Perl:
+

         perl -e 'foreach(1..64){printf "0x%08x\n", int (4294967296 * abs (sin $_))}'
        */
 
         perl -e 'foreach(1..64){printf "0x%08x\n", int (4294967296 * abs (sin $_))}'
        */
 


@@ -370,10 +383,10 @@ md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
         argument specifying the function to use.  */
 #undef OP
 #define OP(f, a, b, c, d, k, s, T)                                     \
         argument specifying the function to use.  */
 #undef OP
 #define OP(f, a, b, c, d, k, s, T)                                     \

-      do                                                               \
+      do                                                               \

        {                                                               \
          a += f (b, c, d) + correct_words[k] + T;                      \
        {                                                               \
          a += f (b, c, d) + correct_words[k] + T;                      \

-         a = rol (a, s);                                               \
+         CYCLIC (a, s);                                                \

          a += b;                                                       \
        }                                                               \
       while (0)
          a += b;                                                       \
        }                                                               \
       while (0)