* sha1.h: Change to use version 3 of the GNU General Public License and tidy up forma...

* sha1.c: Likewise.

diff --git a/ld/ChangeLog b/ld/ChangeLog
index be99d2b4ec2fe46ca259af5af88b8793e98306ba..3a2463e89dd34f864375bff2071d96ae67207e1c 100644 (file)
--- a/ld/ChangeLog
+++ b/ld/ChangeLog
@@ -1,3 +1,9 @@
+2007-07-21  Nick Clifton  <nickc@redhat.com>
+
+       * sha1.h: Change to use version 3 of the GNU General Public
+       License and tidy up formatting.
+       * sha1.c: Likewise.
+
 2007-07-19  Roland McGrath  <roland@redhat.com>
 
        * genscripts.sh (source_em, fragment): New sh functions.

diff --git a/ld/sha1.c b/ld/sha1.c
index 035f898c71f1dae4fab2ed3c48ef125be0e66b5d..d1569ed209d187f816f0aefc882247634df53fac 100644 (file)
--- a/ld/sha1.c
+++ b/ld/sha1.c
@@ -1,12 +1,13 @@
 /* sha1.c - Functions to compute SHA1 message digest of files or
    memory blocks according to the NIST specification FIPS-180-1.
 
-   Copyright (C) 2000, 2001, 2003, 2004, 2005, 2006 Free Software
-   Foundation, Inc.
+   Copyright (C) 2007 Free Software Foundation, Inc.
+
+   This file is part of the GNU Binutils.
 
    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
-   Free Software Foundation; either version 2, or (at your option) any
+   Free Software Foundation; either version 3, or (at your option) any
    later version.
 
    This program is distributed in the hope that it will be useful,
@@ -20,13 +21,10 @@
 
 /* Written by Scott G. Miller
    Credits:
-      Robert Klep <robert@ilse.nl>  -- Expansion function fix
-*/
+      Robert Klep <robert@ilse.nl>  -- Expansion function fix  */
 
 #include <config.h>
-
 #include "sha1.h"
-
 #include <stddef.h>
 #include <string.h>
 
@@ -54,6 +52,7 @@ static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ...  */ };
 /* Take a pointer to a 160 bit block of data (five 32 bit ints) and
    initialize it to the start constants of the SHA1 algorithm.  This
    must be called before using hash in the call to sha1_hash.  */
+
 void
 sha1_init_ctx (struct sha1_ctx *ctx)
 {
@@ -72,6 +71,7 @@ sha1_init_ctx (struct sha1_ctx *ctx)
 
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32-bit value.  */
+
 void *
 sha1_read_ctx (const struct sha1_ctx *ctx, void *resbuf)
 {
@@ -89,6 +89,7 @@ sha1_read_ctx (const struct sha1_ctx *ctx, void *resbuf)
 
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32-bit value.  */
+
 void *
 sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf)
 {
@@ -116,6 +117,7 @@ sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf)
 /* Compute SHA1 message digest for bytes read from STREAM.  The
    resulting message digest number will be written into the 16 bytes
    beginning at RESBLOCK.  */
+
 int
 sha1_stream (FILE *stream, void *resblock)
 {
@@ -163,8 +165,7 @@ sha1_stream (FILE *stream, void *resblock)
        }
 
       /* Process buffer with BLOCKSIZE bytes.  Note that
-                       BLOCKSIZE % 64 == 0
-       */
+                       BLOCKSIZE % 64 == 0.  */
       sha1_process_block (buffer, BLOCKSIZE, &ctx);
     }
 
@@ -183,6 +184,7 @@ sha1_stream (FILE *stream, void *resblock)
    result is always in little endian byte order, so that a byte-wise
    output yields to the wanted ASCII representation of the message
    digest.  */
+
 void *
 sha1_buffer (const char *buffer, size_t len, void *resblock)
 {
@@ -230,7 +232,7 @@ sha1_process_bytes (const void *buffer, size_t len, struct sha1_ctx *ctx)
   if (len >= 64)
     {
 #if !_STRING_ARCH_unaligned
-# define alignof(type) offsetof (struct { char c; type x; }, x)
+# define alignof(type)  offsetof (struct { char c; type x; }, x)
 # define UNALIGNED_P(p) (((size_t) p) % alignof (uint32_t) != 0)
       if (UNALIGNED_P (buffer))
        while (len > 64)
@@ -267,16 +269,16 @@ sha1_process_bytes (const void *buffer, size_t len, struct sha1_ctx *ctx)
 
 /* --- Code below is the primary difference between md5.c and sha1.c --- */
 
-/* SHA1 round constants */
+/* SHA1 round constants.  */
 #define K1 0x5a827999
 #define K2 0x6ed9eba1
 #define K3 0x8f1bbcdc
 #define K4 0xca62c1d6
 
 /* Round functions.  Note that F2 is the same as F4.  */
-#define F1(B,C,D) ( D ^ ( B & ( C ^ D ) ) )
+#define F1(B,C,D) (D ^ (B & (C ^ D)))
 #define F2(B,C,D) (B ^ C ^ D)
-#define F3(B,C,D) ( ( B & C ) | ( D & ( B | C ) ) )
+#define F3(B,C,D) ((B & C) | (D & (B | C)))
 #define F4(B,C,D) (B ^ C ^ D)
 
 /* Process LEN bytes of BUFFER, accumulating context into CTX.
@@ -305,107 +307,112 @@ sha1_process_block (const void *buffer, size_t len, struct sha1_ctx *ctx)
 
 #define rol(x, n) (((x) << (n)) | ((uint32_t) (x) >> (32 - (n))))
 
-#define M(I) ( tm =   x[I&0x0f] ^ x[(I-14)&0x0f] \
-                   ^ x[(I-8)&0x0f] ^ x[(I-3)&0x0f] \
-              , (x[I&0x0f] = rol(tm, 1)) )
-
-#define R(A,B,C,D,E,F,K,M)  do { E += rol( A, 5 )     \
-                                     + F( B, C, D )  \
-                                     + K             \
-                                     + M;            \
-                                B = rol( B, 30 );    \
-                              } while(0)
+#define M(I) (tm = x[I & 0x0f]       ^ x[(I - 14) & 0x0f] \
+                ^ x[(I - 8) & 0x0f] ^ x[(I - 3) & 0x0f]  \
+              , (x[I & 0x0f] = rol (tm, 1)))
+
+#define R(A,B,C,D,E,F,K,M)     \
+  do                           \
+    {                          \
+      E += rol (A, 5)          \
+       + F (B, C, D)           \
+       + K                     \
+       + M;                    \
+      B = rol (B, 30);         \
+    }                          \
+  while (0)
 
   while (words < endp)
     {
       uint32_t tm;
       int t;
+
       for (t = 0; t < 16; t++)
        {
          x[t] = SWAP (*words);
          words++;
        }
 
-      R( a, b, c, d, e, F1, K1, x[ 0] );
-      R( e, a, b, c, d, F1, K1, x[ 1] );
-      R( d, e, a, b, c, F1, K1, x[ 2] );
-      R( c, d, e, a, b, F1, K1, x[ 3] );
-      R( b, c, d, e, a, F1, K1, x[ 4] );
-      R( a, b, c, d, e, F1, K1, x[ 5] );
-      R( e, a, b, c, d, F1, K1, x[ 6] );
-      R( d, e, a, b, c, F1, K1, x[ 7] );
-      R( c, d, e, a, b, F1, K1, x[ 8] );
-      R( b, c, d, e, a, F1, K1, x[ 9] );
-      R( a, b, c, d, e, F1, K1, x[10] );
-      R( e, a, b, c, d, F1, K1, x[11] );
-      R( d, e, a, b, c, F1, K1, x[12] );
-      R( c, d, e, a, b, F1, K1, x[13] );
-      R( b, c, d, e, a, F1, K1, x[14] );
-      R( a, b, c, d, e, F1, K1, x[15] );
-      R( e, a, b, c, d, F1, K1, M(16) );
-      R( d, e, a, b, c, F1, K1, M(17) );
-      R( c, d, e, a, b, F1, K1, M(18) );
-      R( b, c, d, e, a, F1, K1, M(19) );
-      R( a, b, c, d, e, F2, K2, M(20) );
-      R( e, a, b, c, d, F2, K2, M(21) );
-      R( d, e, a, b, c, F2, K2, M(22) );
-      R( c, d, e, a, b, F2, K2, M(23) );
-      R( b, c, d, e, a, F2, K2, M(24) );
-      R( a, b, c, d, e, F2, K2, M(25) );
-      R( e, a, b, c, d, F2, K2, M(26) );
-      R( d, e, a, b, c, F2, K2, M(27) );
-      R( c, d, e, a, b, F2, K2, M(28) );
-      R( b, c, d, e, a, F2, K2, M(29) );
-      R( a, b, c, d, e, F2, K2, M(30) );
-      R( e, a, b, c, d, F2, K2, M(31) );
-      R( d, e, a, b, c, F2, K2, M(32) );
-      R( c, d, e, a, b, F2, K2, M(33) );
-      R( b, c, d, e, a, F2, K2, M(34) );
-      R( a, b, c, d, e, F2, K2, M(35) );
-      R( e, a, b, c, d, F2, K2, M(36) );
-      R( d, e, a, b, c, F2, K2, M(37) );
-      R( c, d, e, a, b, F2, K2, M(38) );
-      R( b, c, d, e, a, F2, K2, M(39) );
-      R( a, b, c, d, e, F3, K3, M(40) );
-      R( e, a, b, c, d, F3, K3, M(41) );
-      R( d, e, a, b, c, F3, K3, M(42) );
-      R( c, d, e, a, b, F3, K3, M(43) );
-      R( b, c, d, e, a, F3, K3, M(44) );
-      R( a, b, c, d, e, F3, K3, M(45) );
-      R( e, a, b, c, d, F3, K3, M(46) );
-      R( d, e, a, b, c, F3, K3, M(47) );
-      R( c, d, e, a, b, F3, K3, M(48) );
-      R( b, c, d, e, a, F3, K3, M(49) );
-      R( a, b, c, d, e, F3, K3, M(50) );
-      R( e, a, b, c, d, F3, K3, M(51) );
-      R( d, e, a, b, c, F3, K3, M(52) );
-      R( c, d, e, a, b, F3, K3, M(53) );
-      R( b, c, d, e, a, F3, K3, M(54) );
-      R( a, b, c, d, e, F3, K3, M(55) );
-      R( e, a, b, c, d, F3, K3, M(56) );
-      R( d, e, a, b, c, F3, K3, M(57) );
-      R( c, d, e, a, b, F3, K3, M(58) );
-      R( b, c, d, e, a, F3, K3, M(59) );
-      R( a, b, c, d, e, F4, K4, M(60) );
-      R( e, a, b, c, d, F4, K4, M(61) );
-      R( d, e, a, b, c, F4, K4, M(62) );
-      R( c, d, e, a, b, F4, K4, M(63) );
-      R( b, c, d, e, a, F4, K4, M(64) );
-      R( a, b, c, d, e, F4, K4, M(65) );
-      R( e, a, b, c, d, F4, K4, M(66) );
-      R( d, e, a, b, c, F4, K4, M(67) );
-      R( c, d, e, a, b, F4, K4, M(68) );
-      R( b, c, d, e, a, F4, K4, M(69) );
-      R( a, b, c, d, e, F4, K4, M(70) );
-      R( e, a, b, c, d, F4, K4, M(71) );
-      R( d, e, a, b, c, F4, K4, M(72) );
-      R( c, d, e, a, b, F4, K4, M(73) );
-      R( b, c, d, e, a, F4, K4, M(74) );
-      R( a, b, c, d, e, F4, K4, M(75) );
-      R( e, a, b, c, d, F4, K4, M(76) );
-      R( d, e, a, b, c, F4, K4, M(77) );
-      R( c, d, e, a, b, F4, K4, M(78) );
-      R( b, c, d, e, a, F4, K4, M(79) );
+      R (a, b, c, d, e, F1, K1, x[ 0]);
+      R (e, a, b, c, d, F1, K1, x[ 1]);
+      R (d, e, a, b, c, F1, K1, x[ 2]);
+      R (c, d, e, a, b, F1, K1, x[ 3]);
+      R (b, c, d, e, a, F1, K1, x[ 4]);
+      R (a, b, c, d, e, F1, K1, x[ 5]);
+      R (e, a, b, c, d, F1, K1, x[ 6]);
+      R (d, e, a, b, c, F1, K1, x[ 7]);
+      R (c, d, e, a, b, F1, K1, x[ 8]);
+      R (b, c, d, e, a, F1, K1, x[ 9]);
+      R (a, b, c, d, e, F1, K1, x[10]);
+      R (e, a, b, c, d, F1, K1, x[11]);
+      R (d, e, a, b, c, F1, K1, x[12]);
+      R (c, d, e, a, b, F1, K1, x[13]);
+      R (b, c, d, e, a, F1, K1, x[14]);
+      R (a, b, c, d, e, F1, K1, x[15]);
+      R (e, a, b, c, d, F1, K1, M(16));
+      R (d, e, a, b, c, F1, K1, M(17));
+      R (c, d, e, a, b, F1, K1, M(18));
+      R (b, c, d, e, a, F1, K1, M(19));
+      R (a, b, c, d, e, F2, K2, M(20));
+      R (e, a, b, c, d, F2, K2, M(21));
+      R (d, e, a, b, c, F2, K2, M(22));
+      R (c, d, e, a, b, F2, K2, M(23));
+      R (b, c, d, e, a, F2, K2, M(24));
+      R (a, b, c, d, e, F2, K2, M(25));
+      R (e, a, b, c, d, F2, K2, M(26));
+      R (d, e, a, b, c, F2, K2, M(27));
+      R (c, d, e, a, b, F2, K2, M(28));
+      R (b, c, d, e, a, F2, K2, M(29));
+      R (a, b, c, d, e, F2, K2, M(30));
+      R (e, a, b, c, d, F2, K2, M(31));
+      R (d, e, a, b, c, F2, K2, M(32));
+      R (c, d, e, a, b, F2, K2, M(33));
+      R (b, c, d, e, a, F2, K2, M(34));
+      R (a, b, c, d, e, F2, K2, M(35));
+      R (e, a, b, c, d, F2, K2, M(36));
+      R (d, e, a, b, c, F2, K2, M(37));
+      R (c, d, e, a, b, F2, K2, M(38));
+      R (b, c, d, e, a, F2, K2, M(39));
+      R (a, b, c, d, e, F3, K3, M(40));
+      R (e, a, b, c, d, F3, K3, M(41));
+      R (d, e, a, b, c, F3, K3, M(42));
+      R (c, d, e, a, b, F3, K3, M(43));
+      R (b, c, d, e, a, F3, K3, M(44));
+      R (a, b, c, d, e, F3, K3, M(45));
+      R (e, a, b, c, d, F3, K3, M(46));
+      R (d, e, a, b, c, F3, K3, M(47));
+      R (c, d, e, a, b, F3, K3, M(48));
+      R (b, c, d, e, a, F3, K3, M(49));
+      R (a, b, c, d, e, F3, K3, M(50));
+      R (e, a, b, c, d, F3, K3, M(51));
+      R (d, e, a, b, c, F3, K3, M(52));
+      R (c, d, e, a, b, F3, K3, M(53));
+      R (b, c, d, e, a, F3, K3, M(54));
+      R (a, b, c, d, e, F3, K3, M(55));
+      R (e, a, b, c, d, F3, K3, M(56));
+      R (d, e, a, b, c, F3, K3, M(57));
+      R (c, d, e, a, b, F3, K3, M(58));
+      R (b, c, d, e, a, F3, K3, M(59));
+      R (a, b, c, d, e, F4, K4, M(60));
+      R (e, a, b, c, d, F4, K4, M(61));
+      R (d, e, a, b, c, F4, K4, M(62));
+      R (c, d, e, a, b, F4, K4, M(63));
+      R (b, c, d, e, a, F4, K4, M(64));
+      R (a, b, c, d, e, F4, K4, M(65));
+      R (e, a, b, c, d, F4, K4, M(66));
+      R (d, e, a, b, c, F4, K4, M(67));
+      R (c, d, e, a, b, F4, K4, M(68));
+      R (b, c, d, e, a, F4, K4, M(69));
+      R (a, b, c, d, e, F4, K4, M(70));
+      R (e, a, b, c, d, F4, K4, M(71));
+      R (d, e, a, b, c, F4, K4, M(72));
+      R (c, d, e, a, b, F4, K4, M(73));
+      R (b, c, d, e, a, F4, K4, M(74));
+      R (a, b, c, d, e, F4, K4, M(75));
+      R (e, a, b, c, d, F4, K4, M(76));
+      R (d, e, a, b, c, F4, K4, M(77));
+      R (c, d, e, a, b, F4, K4, M(78));
+      R (b, c, d, e, a, F4, K4, M(79));
 
       a = ctx->A += a;
       b = ctx->B += b;

diff --git a/ld/sha1.h b/ld/sha1.h
index 9545f0b2becf8a68aea272365ae34fb876deff18..43b6dde9a9a74d212c8a1479f32b8d08805ef944 100644 (file)
--- a/ld/sha1.h
+++ b/ld/sha1.h
@@ -1,10 +1,12 @@
 /* Declarations of functions and data types used for SHA1 sum
    library functions.
-   Copyright (C) 2000, 2001, 2003, 2005, 2006 Free Software Foundation, Inc.
+   Copyright (C) 2007 Free Software Foundation, Inc.
+
+   This file is part of the GNU Binutils.
 
    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
-   Free Software Foundation; either version 2, or (at your option) any
+   Free Software Foundation; either version 3, or (at your option) any
    later version.
 
    This program is distributed in the hope that it will be useful,
@@ -17,10 +19,10 @@
    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
 
 #ifndef SHA1_H
-# define SHA1_H 1
+#define SHA1_H 1
 
-# include <stdio.h>
-# include <stdint.h>
+#include <stdio.h>
+#include <stdint.h>
 
 /* Structure to save state of computation between the single steps.  */
 struct sha1_ctx
@@ -43,7 +45,7 @@ extern void sha1_init_ctx (struct sha1_ctx *ctx);
 /* Starting with the result of former calls of this function (or the
    initialization function update the context for the next LEN bytes
    starting at BUFFER.
-   It is necessary that LEN is a multiple of 64!!! */
+   It is necessary that LEN is a multiple of 64!  */
 extern void sha1_process_block (const void *buffer, size_t len,
                                struct sha1_ctx *ctx);
 
@@ -63,7 +65,6 @@ extern void sha1_process_bytes (const void *buffer, size_t len,
    aligned for a 32 bits value.  */
 extern void *sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf);
 
-
 /* Put result from CTX in first 20 bytes following RESBUF.  The result is
    always in little endian byte order, so that a byte-wise output yields
    to the wanted ASCII representation of the message digest.
@@ -72,7 +73,6 @@ extern void *sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf);
    aligned for a 32 bits value.  */
 extern void *sha1_read_ctx (const struct sha1_ctx *ctx, void *resbuf);
 
-
 /* Compute SHA1 message digest for bytes read from STREAM.  The
    resulting message digest number will be written into the 20 bytes
    beginning at RESBLOCK.  */
@@ -84,4 +84,4 @@ extern int sha1_stream (FILE *stream, void *resblock);
    digest.  */
 extern void *sha1_buffer (const char *buffer, size_t len, void *resblock);
 
-#endif
+#endif /* SHA1_H */