projects / openssl.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix some clang warnings.
[openssl.git] / crypto / md4 / md4_dgst.c
diff --git a/crypto/md4/md4_dgst.c b/crypto/md4/md4_dgst.c
index 81488ae2e27d97ee3607fecf59fe6182429c7896..47ee9af1624666ed0373e2fba7a64639a10eb4e0 100644 (file)
--- a/crypto/md4/md4_dgst.c
+++ b/crypto/md4/md4_dgst.c
@@ -57,10 +57,10 @@
  */
 
 #include <stdio.h>
  */
 
 #include <stdio.h>
-#include "md4_locl.h"
 #include <openssl/opensslv.h>
 #include <openssl/opensslv.h>
+#include "md4_locl.h"
 
 
-const char *MD4_version="MD4" OPENSSL_VERSION_PTEXT;
+const char MD4_version[]="MD4" OPENSSL_VERSION_PTEXT;
 
 /* Implemented from RFC1186 The MD4 Message-Digest Algorithm
  */
 
 /* Implemented from RFC1186 The MD4 Message-Digest Algorithm
  */
@@ -70,130 +70,28 @@ const char *MD4_version="MD4" OPENSSL_VERSION_PTEXT;
 #define INIT_DATA_C (unsigned long)0x98badcfeL
 #define INIT_DATA_D (unsigned long)0x10325476L
 
 #define INIT_DATA_C (unsigned long)0x98badcfeL
 #define INIT_DATA_D (unsigned long)0x10325476L
 
-void MD4_Init(MD4_CTX *c)
+int MD4_Init(MD4_CTX *c)
        {
        {
+       memset (c,0,sizeof(*c));
        c->A=INIT_DATA_A;
        c->B=INIT_DATA_B;
        c->C=INIT_DATA_C;
        c->D=INIT_DATA_D;
        c->A=INIT_DATA_A;
        c->B=INIT_DATA_B;
        c->C=INIT_DATA_C;
        c->D=INIT_DATA_D;
-       c->Nl=0;
-       c->Nh=0;
-       c->num=0;
+       return 1;
        }
 
        }
 
-#ifndef md4_block_host_order
-void md4_block_host_order (MD4_CTX *c, const void *data, int num)
-       {
-       const MD4_LONG *X=data;
-       register unsigned long A,B,C,D;
-       /*
-        * In case you wonder why A-D are declared as long and not
-        * as MD4_LONG. Doing so results in slight performance
-        * boost on LP64 architectures. The catch is we don't
-        * really care if 32 MSBs of a 64-bit register get polluted
-        * with eventual overflows as we *save* only 32 LSBs in
-        * *either* case. Now declaring 'em long excuses the compiler
-        * from keeping 32 MSBs zeroed resulting in 13% performance
-        * improvement under SPARC Solaris7/64 and 5% under AlphaLinux.
-        * Well, to be honest it should say that this *prevents* 
-        * performance degradation.
-        *
-        *                              <appro@fy.chalmers.se>
-        */
-
-       A=c->A;
-       B=c->B;
-       C=c->C;
-       D=c->D;
-
-       for (;num--;X+=HASH_LBLOCK)
-               {
-       /* Round 0 */
-       R0(A,B,C,D,X[ 0], 3,0);
-       R0(D,A,B,C,X[ 1], 7,0);
-       R0(C,D,A,B,X[ 2],11,0);
-       R0(B,C,D,A,X[ 3],19,0);
-       R0(A,B,C,D,X[ 4], 3,0);
-       R0(D,A,B,C,X[ 5], 7,0);
-       R0(C,D,A,B,X[ 6],11,0);
-       R0(B,C,D,A,X[ 7],19,0);
-       R0(A,B,C,D,X[ 8], 3,0);
-       R0(D,A,B,C,X[ 9], 7,0);
-       R0(C,D,A,B,X[10],11,0);
-       R0(B,C,D,A,X[11],19,0);
-       R0(A,B,C,D,X[12], 3,0);
-       R0(D,A,B,C,X[13], 7,0);
-       R0(C,D,A,B,X[14],11,0);
-       R0(B,C,D,A,X[15],19,0);
-       /* Round 1 */
-       R1(A,B,C,D,X[ 0], 3,0x5A827999L);
-       R1(D,A,B,C,X[ 4], 5,0x5A827999L);
-       R1(C,D,A,B,X[ 8], 9,0x5A827999L);
-       R1(B,C,D,A,X[12],13,0x5A827999L);
-       R1(A,B,C,D,X[ 1], 3,0x5A827999L);
-       R1(D,A,B,C,X[ 5], 5,0x5A827999L);
-       R1(C,D,A,B,X[ 9], 9,0x5A827999L);
-       R1(B,C,D,A,X[13],13,0x5A827999L);
-       R1(A,B,C,D,X[ 2], 3,0x5A827999L);
-       R1(D,A,B,C,X[ 6], 5,0x5A827999L);
-       R1(C,D,A,B,X[10], 9,0x5A827999L);
-       R1(B,C,D,A,X[14],13,0x5A827999L);
-       R1(A,B,C,D,X[ 3], 3,0x5A827999L);
-       R1(D,A,B,C,X[ 7], 5,0x5A827999L);
-       R1(C,D,A,B,X[11], 9,0x5A827999L);
-       R1(B,C,D,A,X[15],13,0x5A827999L);
-       /* Round 2 */
-       R2(A,B,C,D,X[ 0], 3,0x6ED9EBA1);
-       R2(D,A,B,C,X[ 8], 9,0x6ED9EBA1);
-       R2(C,D,A,B,X[ 4],11,0x6ED9EBA1);
-       R2(B,C,D,A,X[12],15,0x6ED9EBA1);
-       R2(A,B,C,D,X[ 2], 3,0x6ED9EBA1);
-       R2(D,A,B,C,X[10], 9,0x6ED9EBA1);
-       R2(C,D,A,B,X[ 6],11,0x6ED9EBA1);
-       R2(B,C,D,A,X[14],15,0x6ED9EBA1);
-       R2(A,B,C,D,X[ 1], 3,0x6ED9EBA1);
-       R2(D,A,B,C,X[ 9], 9,0x6ED9EBA1);
-       R2(C,D,A,B,X[ 5],11,0x6ED9EBA1);
-       R2(B,C,D,A,X[13],15,0x6ED9EBA1);
-       R2(A,B,C,D,X[ 3], 3,0x6ED9EBA1);
-       R2(D,A,B,C,X[11], 9,0x6ED9EBA1);
-       R2(C,D,A,B,X[ 7],11,0x6ED9EBA1);
-       R2(B,C,D,A,X[15],15,0x6ED9EBA1);
-
-       A = c->A += A;
-       B = c->B += B;
-       C = c->C += C;
-       D = c->D += D;
-               }
-       }
-#endif
-
 #ifndef md4_block_data_order
 #ifdef X
 #undef X
 #endif
 #ifndef md4_block_data_order
 #ifdef X
 #undef X
 #endif
-void md4_block_data_order (MD4_CTX *c, const void *data_, int num)
+void md4_block_data_order (MD4_CTX *c, const void *data_, size_t num)
        {
        const unsigned char *data=data_;
        {
        const unsigned char *data=data_;
-       register unsigned long A,B,C,D,l;
-       /*
-        * In case you wonder why A-D are declared as long and not
-        * as MD4_LONG. Doing so results in slight performance
-        * boost on LP64 architectures. The catch is we don't
-        * really care if 32 MSBs of a 64-bit register get polluted
-        * with eventual overflows as we *save* only 32 LSBs in
-        * *either* case. Now declaring 'em long excuses the compiler
-        * from keeping 32 MSBs zeroed resulting in 13% performance
-        * improvement under SPARC Solaris7/64 and 5% under AlphaLinux.
-        * Well, to be honest it should say that this *prevents* 
-        * performance degradation.
-        *
-        *                              <appro@fy.chalmers.se>
-        */
+       register unsigned MD32_REG_T A,B,C,D,l;
 #ifndef MD32_XARRAY
        /* See comment in crypto/sha/sha_locl.h for details. */
 #ifndef MD32_XARRAY
        /* See comment in crypto/sha/sha_locl.h for details. */
-       unsigned long   XX0, XX1, XX2, XX3, XX4, XX5, XX6, XX7,
-                       XX8, XX9,XX10,XX11,XX12,XX13,XX14,XX15;
+       unsigned MD32_REG_T     XX0, XX1, XX2, XX3, XX4, XX5, XX6, XX7,
+                               XX8, XX9,XX10,XX11,XX12,XX13,XX14,XX15;
 # define X(i)  XX##i
 #else
        MD4_LONG XX[MD4_LBLOCK];
 # define X(i)  XX##i
 #else
        MD4_LONG XX[MD4_LBLOCK];
@@ -207,22 +105,23 @@ void md4_block_data_order (MD4_CTX *c, const void *data_, int num)
 
        for (;num--;)
                {
 
        for (;num--;)
                {
-       HOST_c2l(data,l); X( 0)=l;              HOST_c2l(data,l); X( 1)=l;
+       (void)HOST_c2l(data,l); X( 0)=l;
+       (void)HOST_c2l(data,l); X( 1)=l;
        /* Round 0 */
        /* Round 0 */
-       R0(A,B,C,D,X( 0), 3,0); HOST_c2l(data,l); X( 2)=l;
-       R0(D,A,B,C,X( 1), 7,0); HOST_c2l(data,l); X( 3)=l;
-       R0(C,D,A,B,X( 2),11,0); HOST_c2l(data,l); X( 4)=l;
-       R0(B,C,D,A,X( 3),19,0); HOST_c2l(data,l); X( 5)=l;
-       R0(A,B,C,D,X( 4), 3,0); HOST_c2l(data,l); X( 6)=l;
-       R0(D,A,B,C,X( 5), 7,0); HOST_c2l(data,l); X( 7)=l;
-       R0(C,D,A,B,X( 6),11,0); HOST_c2l(data,l); X( 8)=l;
-       R0(B,C,D,A,X( 7),19,0); HOST_c2l(data,l); X( 9)=l;
-       R0(A,B,C,D,X( 8), 3,0); HOST_c2l(data,l); X(10)=l;
-       R0(D,A,B,C,X( 9), 7,0); HOST_c2l(data,l); X(11)=l;
-       R0(C,D,A,B,X(10),11,0); HOST_c2l(data,l); X(12)=l;
-       R0(B,C,D,A,X(11),19,0); HOST_c2l(data,l); X(13)=l;
-       R0(A,B,C,D,X(12), 3,0); HOST_c2l(data,l); X(14)=l;
-       R0(D,A,B,C,X(13), 7,0); HOST_c2l(data,l); X(15)=l;
+       R0(A,B,C,D,X( 0), 3,0); (void)HOST_c2l(data,l); X( 2)=l;
+       R0(D,A,B,C,X( 1), 7,0); (void)HOST_c2l(data,l); X( 3)=l;
+       R0(C,D,A,B,X( 2),11,0); (void)HOST_c2l(data,l); X( 4)=l;
+       R0(B,C,D,A,X( 3),19,0); (void)HOST_c2l(data,l); X( 5)=l;
+       R0(A,B,C,D,X( 4), 3,0); (void)HOST_c2l(data,l); X( 6)=l;
+       R0(D,A,B,C,X( 5), 7,0); (void)HOST_c2l(data,l); X( 7)=l;
+       R0(C,D,A,B,X( 6),11,0); (void)HOST_c2l(data,l); X( 8)=l;
+       R0(B,C,D,A,X( 7),19,0); (void)HOST_c2l(data,l); X( 9)=l;
+       R0(A,B,C,D,X( 8), 3,0); (void)HOST_c2l(data,l); X(10)=l;
+       R0(D,A,B,C,X( 9), 7,0); (void)HOST_c2l(data,l); X(11)=l;
+       R0(C,D,A,B,X(10),11,0); (void)HOST_c2l(data,l); X(12)=l;
+       R0(B,C,D,A,X(11),19,0); (void)HOST_c2l(data,l); X(13)=l;
+       R0(A,B,C,D,X(12), 3,0); (void)HOST_c2l(data,l); X(14)=l;
+       R0(D,A,B,C,X(13), 7,0); (void)HOST_c2l(data,l); X(15)=l;
        R0(C,D,A,B,X(14),11,0);
        R0(B,C,D,A,X(15),19,0);
        /* Round 1 */
        R0(C,D,A,B,X(14),11,0);
        R0(B,C,D,A,X(15),19,0);
        /* Round 1 */
@@ -267,19 +166,3 @@ void md4_block_data_order (MD4_CTX *c, const void *data_, int num)
                }
        }
 #endif
                }
        }
 #endif
-
-#ifdef undef
-int printit(unsigned long *l)
-       {
-       int i,ii;
-
-       for (i=0; i<2; i++)
-               {
-               for (ii=0; ii<8; ii++)
-                       {
-                       fprintf(stderr,"%08lx ",l[i*8+ii]);
-                       }
-               fprintf(stderr,"\n");
-               }
-       }
-#endif
Unnamed repository; edit this file 'description' to name the repository.