size_t-fication of message digest APIs. We should size_t-fy more APIs...

diff --git a/crypto/engine/eng_openssl.c b/crypto/engine/eng_openssl.c
index 5e20555fc0da578403d5b5c21ecca75edcf550c0..dd16d3bc6a09bf0385ab9eb83a584cdb242a9488 100644 (file)
--- a/crypto/engine/eng_openssl.c
+++ b/crypto/engine/eng_openssl.c
@@ -305,7 +305,7 @@ static int test_sha1_init(EVP_MD_CTX *ctx)
 #endif
        return SHA1_Init(ctx->md_data);
        }
 #endif
        return SHA1_Init(ctx->md_data);
        }

-static int test_sha1_update(EVP_MD_CTX *ctx,const void *data,unsigned long count)
+static int test_sha1_update(EVP_MD_CTX *ctx,const void *data,size_t count)

        {
 #ifdef TEST_ENG_OPENSSL_SHA_P_UPDATE
        fprintf(stderr, "(TEST_ENG_OPENSSL_SHA) test_sha1_update() called\n");
        {
 #ifdef TEST_ENG_OPENSSL_SHA_P_UPDATE
        fprintf(stderr, "(TEST_ENG_OPENSSL_SHA) test_sha1_update() called\n");

diff --git a/crypto/evp/digest.c b/crypto/evp/digest.c
index bd014ac81d28384ceeb2b8142bb696773626ab40..7d8421079b20bc8a2e238d1606a30c0a301b0daa 100644 (file)
--- a/crypto/evp/digest.c
+++ b/crypto/evp/digest.c
@@ -208,9 +208,9 @@ skip_to_init:
        }
 
 int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data,
        }
 
 int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data,

-            unsigned int count)
+            size_t count)

        {
        {

-       return ctx->digest->update(ctx,data,(unsigned long)count);
+       return ctx->digest->update(ctx,data,count);

        }
 
 /* The caller can assume that this removes any secret data from the context */
        }
 
 /* The caller can assume that this removes any secret data from the context */


@@ -285,7 +285,7 @@ int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in)
        return 1;
        }
 
        return 1;
        }
 

-int EVP_Digest(const void *data, unsigned int count,
+int EVP_Digest(const void *data, size_t count,

                unsigned char *md, unsigned int *size, const EVP_MD *type, ENGINE *impl)
        {
        EVP_MD_CTX ctx;
                unsigned char *md, unsigned int *size, const EVP_MD *type, ENGINE *impl)
        {
        EVP_MD_CTX ctx;

diff --git a/crypto/evp/evp.h b/crypto/evp/evp.h
index 6adbe891a0dcfa753be0a036b50730ac18cb5c02..47c8fc72a018529eaf5931d6ca6f274de90562ef 100644 (file)
--- a/crypto/evp/evp.h
+++ b/crypto/evp/evp.h
@@ -227,7 +227,7 @@ struct env_md_st
        int md_size;
        unsigned long flags;
        int (*init)(EVP_MD_CTX *ctx);
        int md_size;
        unsigned long flags;
        int (*init)(EVP_MD_CTX *ctx);

-       int (*update)(EVP_MD_CTX *ctx,const void *data,unsigned long count);
+       int (*update)(EVP_MD_CTX *ctx,const void *data,size_t count);

        int (*final)(EVP_MD_CTX *ctx,unsigned char *md);
        int (*copy)(EVP_MD_CTX *to,const EVP_MD_CTX *from);
        int (*cleanup)(EVP_MD_CTX *ctx);
        int (*final)(EVP_MD_CTX *ctx,unsigned char *md);
        int (*copy)(EVP_MD_CTX *to,const EVP_MD_CTX *from);
        int (*cleanup)(EVP_MD_CTX *ctx);


@@ -490,9 +490,9 @@ int     EVP_MD_CTX_copy_ex(EVP_MD_CTX *out,const EVP_MD_CTX *in);
 #define EVP_MD_CTX_test_flags(ctx,flgs) ((ctx)->flags&(flgs))
 int    EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl);
 int    EVP_DigestUpdate(EVP_MD_CTX *ctx,const void *d,
 #define EVP_MD_CTX_test_flags(ctx,flgs) ((ctx)->flags&(flgs))
 int    EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl);
 int    EVP_DigestUpdate(EVP_MD_CTX *ctx,const void *d,

-                        unsigned int cnt);
+                        size_t cnt);

 int    EVP_DigestFinal_ex(EVP_MD_CTX *ctx,unsigned char *md,unsigned int *s);
 int    EVP_DigestFinal_ex(EVP_MD_CTX *ctx,unsigned char *md,unsigned int *s);

-int    EVP_Digest(const void *data, unsigned int count,
+int    EVP_Digest(const void *data, size_t count,

                unsigned char *md, unsigned int *size, const EVP_MD *type, ENGINE *impl);
 
 int     EVP_MD_CTX_copy(EVP_MD_CTX *out,const EVP_MD_CTX *in);  
                unsigned char *md, unsigned int *size, const EVP_MD *type, ENGINE *impl);
 
 int     EVP_MD_CTX_copy(EVP_MD_CTX *out,const EVP_MD_CTX *in);  

diff --git a/crypto/evp/m_dss.c b/crypto/evp/m_dss.c
index c4c5f0bbe691f71fe9ff0d9b05489c5ebc68aa93..020f19c44bb656a447d5c500eb0d3404b0a8352f 100644 (file)
--- a/crypto/evp/m_dss.c
+++ b/crypto/evp/m_dss.c
@@ -67,7 +67,7 @@
 static int init(EVP_MD_CTX *ctx)
        { return SHA1_Init(ctx->md_data); }
 
 static int init(EVP_MD_CTX *ctx)
        { return SHA1_Init(ctx->md_data); }
 

-static int update(EVP_MD_CTX *ctx,const void *data,unsigned long count)
+static int update(EVP_MD_CTX *ctx,const void *data,size_t count)

        { return SHA1_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)
        { return SHA1_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)

diff --git a/crypto/evp/m_dss1.c b/crypto/evp/m_dss1.c
index 6b65bfd54b88ec7ef15e430f70ff3008c7afdb21..a20056f04b62876a6696ed41e09cfccdcfa809ec 100644 (file)
--- a/crypto/evp/m_dss1.c
+++ b/crypto/evp/m_dss1.c
@@ -69,7 +69,7 @@
 static int init(EVP_MD_CTX *ctx)
        { return SHA1_Init(ctx->md_data); }
 
 static int init(EVP_MD_CTX *ctx)
        { return SHA1_Init(ctx->md_data); }
 

-static int update(EVP_MD_CTX *ctx,const void *data,unsigned long count)
+static int update(EVP_MD_CTX *ctx,const void *data,size_t count)

        { return SHA1_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)
        { return SHA1_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)

diff --git a/crypto/evp/m_ecdsa.c b/crypto/evp/m_ecdsa.c
index 26e4206e5ad2160bfdb37698ce9e0965ff3f6795..fad270faca2b39e3d8087bdabc6fec9fb4fea10c 100644 (file)
--- a/crypto/evp/m_ecdsa.c
+++ b/crypto/evp/m_ecdsa.c
@@ -119,7 +119,7 @@
 static int init(EVP_MD_CTX *ctx)
        { return SHA1_Init(ctx->md_data); }
 
 static int init(EVP_MD_CTX *ctx)
        { return SHA1_Init(ctx->md_data); }
 

-static int update(EVP_MD_CTX *ctx,const void *data,unsigned long count)
+static int update(EVP_MD_CTX *ctx,const void *data,size_t count)

        { return SHA1_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)
        { return SHA1_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)

diff --git a/crypto/evp/m_md2.c b/crypto/evp/m_md2.c
index e577d26411b6ddd6eb1430877c116e77de3d3949..1eae4ed38cb4e9d4dcefe63f87fed2f48d727520 100644 (file)
--- a/crypto/evp/m_md2.c
+++ b/crypto/evp/m_md2.c
@@ -70,7 +70,7 @@
 static int init(EVP_MD_CTX *ctx)
        { return MD2_Init(ctx->md_data); }
 
 static int init(EVP_MD_CTX *ctx)
        { return MD2_Init(ctx->md_data); }
 

-static int update(EVP_MD_CTX *ctx,const void *data,unsigned long count)
+static int update(EVP_MD_CTX *ctx,const void *data,size_t count)

        { return MD2_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)
        { return MD2_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)

diff --git a/crypto/evp/m_md4.c b/crypto/evp/m_md4.c
index 787d6554c1b7b7feb8cb965267c2b9ee1906d0c7..0fb84b6d1ec2e7bda42e3f970b4fdfd98a9a1d55 100644 (file)
--- a/crypto/evp/m_md4.c
+++ b/crypto/evp/m_md4.c
@@ -70,7 +70,7 @@
 static int init(EVP_MD_CTX *ctx)
        { return MD4_Init(ctx->md_data); }
 
 static int init(EVP_MD_CTX *ctx)
        { return MD4_Init(ctx->md_data); }
 

-static int update(EVP_MD_CTX *ctx,const void *data,unsigned long count)
+static int update(EVP_MD_CTX *ctx,const void *data,size_t count)

        { return MD4_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)
        { return MD4_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)

diff --git a/crypto/evp/m_md5.c b/crypto/evp/m_md5.c
index a214315abe5c91cb14be55d48fcbc02ec69d56e2..21288ee6361e9183b2eb7b2ca04eb8de225b5719 100644 (file)
--- a/crypto/evp/m_md5.c
+++ b/crypto/evp/m_md5.c
@@ -70,7 +70,7 @@
 static int init(EVP_MD_CTX *ctx)
        { return MD5_Init(ctx->md_data); }
 
 static int init(EVP_MD_CTX *ctx)
        { return MD5_Init(ctx->md_data); }
 

-static int update(EVP_MD_CTX *ctx,const void *data,unsigned long count)
+static int update(EVP_MD_CTX *ctx,const void *data,size_t count)

        { return MD5_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)
        { return MD5_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)

diff --git a/crypto/evp/m_mdc2.c b/crypto/evp/m_mdc2.c
index 14e8175790e9ff8b0018a6e5f6288c5739bb73d6..36c4e9b1343688d7f5b10b3ee50e90d37b0bc8ae 100644 (file)
--- a/crypto/evp/m_mdc2.c
+++ b/crypto/evp/m_mdc2.c
@@ -70,7 +70,7 @@
 static int init(EVP_MD_CTX *ctx)
        { return MDC2_Init(ctx->md_data); }
 
 static int init(EVP_MD_CTX *ctx)
        { return MDC2_Init(ctx->md_data); }
 

-static int update(EVP_MD_CTX *ctx,const void *data,unsigned long count)
+static int update(EVP_MD_CTX *ctx,const void *data,size_t count)

        { return MDC2_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)
        { return MDC2_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)

diff --git a/crypto/evp/m_null.c b/crypto/evp/m_null.c
index f6f0a1d2c05f1abdf15ec79f8e493134a7d06e6c..cb0721699dba3b3c07ea484b90137bb33a62934f 100644 (file)
--- a/crypto/evp/m_null.c
+++ b/crypto/evp/m_null.c
@@ -65,7 +65,7 @@
 static int init(EVP_MD_CTX *ctx)
        { return 1; }
 
 static int init(EVP_MD_CTX *ctx)
        { return 1; }
 

-static int update(EVP_MD_CTX *ctx,const void *data,unsigned long count)
+static int update(EVP_MD_CTX *ctx,const void *data,size_t count)

        { return 1; }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)
        { return 1; }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)

diff --git a/crypto/evp/m_ripemd.c b/crypto/evp/m_ripemd.c
index 93910a44abf632591f68aebe4cda20070ccdcc40..087ad2d30ac81deab87bf6887ead6bcfdc4b27f8 100644 (file)
--- a/crypto/evp/m_ripemd.c
+++ b/crypto/evp/m_ripemd.c
@@ -70,7 +70,7 @@
 static int init(EVP_MD_CTX *ctx)
        { return RIPEMD160_Init(ctx->md_data); }
 
 static int init(EVP_MD_CTX *ctx)
        { return RIPEMD160_Init(ctx->md_data); }
 

-static int update(EVP_MD_CTX *ctx,const void *data,unsigned long count)
+static int update(EVP_MD_CTX *ctx,const void *data,size_t count)

        { return RIPEMD160_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)
        { return RIPEMD160_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)

diff --git a/crypto/evp/m_sha.c b/crypto/evp/m_sha.c
index f3b96107578e3b0dcb437532143c064a99438477..64b397fa0302ad65c0eca9a494f7e089a1cc854e 100644 (file)
--- a/crypto/evp/m_sha.c
+++ b/crypto/evp/m_sha.c
@@ -69,7 +69,7 @@
 static int init(EVP_MD_CTX *ctx)
        { return SHA_Init(ctx->md_data); }
 
 static int init(EVP_MD_CTX *ctx)
        { return SHA_Init(ctx->md_data); }
 

-static int update(EVP_MD_CTX *ctx,const void *data,unsigned long count)
+static int update(EVP_MD_CTX *ctx,const void *data,size_t count)

        { return SHA_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)
        { return SHA_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)

diff --git a/crypto/evp/m_sha1.c b/crypto/evp/m_sha1.c
index 364b3688779fa11f502a71c570d9e2ead43cfa69..7a791a6f71a548766b24400de957b548dd65dca1 100644 (file)
--- a/crypto/evp/m_sha1.c
+++ b/crypto/evp/m_sha1.c
@@ -69,7 +69,7 @@
 static int init(EVP_MD_CTX *ctx)
        { return SHA1_Init(ctx->md_data); }
 
 static int init(EVP_MD_CTX *ctx)
        { return SHA1_Init(ctx->md_data); }
 

-static int update(EVP_MD_CTX *ctx,const void *data,unsigned long count)
+static int update(EVP_MD_CTX *ctx,const void *data,size_t count)

        { return SHA1_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)
        { return SHA1_Update(ctx->md_data,data,count); }
 
 static int final(EVP_MD_CTX *ctx,unsigned char *md)

diff --git a/crypto/hmac/hmac.c b/crypto/hmac/hmac.c
index f7392a0dae96d74a1c0f5e71945fd136d9fcc3bd..50765e227bf2ef0a3a0c134537dc390c7bff4d23 100644 (file)
--- a/crypto/hmac/hmac.c
+++ b/crypto/hmac/hmac.c
@@ -121,7 +121,7 @@ void HMAC_Init(HMAC_CTX *ctx, const void *key, int len,
        HMAC_Init_ex(ctx,key,len,md, NULL);
        }
 
        HMAC_Init_ex(ctx,key,len,md, NULL);
        }
 

-void HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, int len)
+void HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, size_t len)

        {
        EVP_DigestUpdate(&ctx->md_ctx,data,len);
        }
        {
        EVP_DigestUpdate(&ctx->md_ctx,data,len);
        }


@@ -156,7 +156,7 @@ void HMAC_CTX_cleanup(HMAC_CTX *ctx)
        }
 
 unsigned char *HMAC(const EVP_MD *evp_md, const void *key, int key_len,
        }
 
 unsigned char *HMAC(const EVP_MD *evp_md, const void *key, int key_len,

-                   const unsigned char *d, int n, unsigned char *md,
+                   const unsigned char *d, size_t n, unsigned char *md,

                    unsigned int *md_len)
        {
        HMAC_CTX c;
                    unsigned int *md_len)
        {
        HMAC_CTX c;

diff --git a/crypto/hmac/hmac.h b/crypto/hmac/hmac.h
index 72077ad19e5a750a4b0f257338e549cd8a360944..251c95fadea8cfb04421404b130f12a9d397e11f 100644 (file)
--- a/crypto/hmac/hmac.h
+++ b/crypto/hmac/hmac.h
@@ -94,10 +94,10 @@ void HMAC_Init(HMAC_CTX *ctx, const void *key, int len,
               const EVP_MD *md); /* deprecated */
 void HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len,
                  const EVP_MD *md, ENGINE *impl);
               const EVP_MD *md); /* deprecated */
 void HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len,
                  const EVP_MD *md, ENGINE *impl);

-void HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, int len);
+void HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, size_t len);

 void HMAC_Final(HMAC_CTX *ctx, unsigned char *md, unsigned int *len);
 unsigned char *HMAC(const EVP_MD *evp_md, const void *key, int key_len,
 void HMAC_Final(HMAC_CTX *ctx, unsigned char *md, unsigned int *len);
 unsigned char *HMAC(const EVP_MD *evp_md, const void *key, int key_len,

-                   const unsigned char *d, int n, unsigned char *md,
+                   const unsigned char *d, size_t n, unsigned char *md,

                    unsigned int *md_len);
 
 
                    unsigned int *md_len);
 
 

diff --git a/crypto/md2/md2.h b/crypto/md2/md2.h
index 6fcb9b1bdc43d42c032c97d25393f56fd8c570fc..45bf4cc29c84ed07b29a209dec14bf326bd2467f 100644 (file)
--- a/crypto/md2/md2.h
+++ b/crypto/md2/md2.h
@@ -81,9 +81,9 @@ typedef struct MD2state_st
 
 const char *MD2_options(void);
 int MD2_Init(MD2_CTX *c);
 
 const char *MD2_options(void);
 int MD2_Init(MD2_CTX *c);

-int MD2_Update(MD2_CTX *c, const unsigned char *data, unsigned long len);
+int MD2_Update(MD2_CTX *c, const unsigned char *data, size_t len);

 int MD2_Final(unsigned char *md, MD2_CTX *c);
 int MD2_Final(unsigned char *md, MD2_CTX *c);

-unsigned char *MD2(const unsigned char *d, unsigned long n,unsigned char *md);
+unsigned char *MD2(const unsigned char *d, size_t n,unsigned char *md);

 #ifdef  __cplusplus
 }
 #endif
 #ifdef  __cplusplus
 }
 #endif

diff --git a/crypto/md2/md2_dgst.c b/crypto/md2/md2_dgst.c
index ecb64f0ec40d360ce3457077b4c22f5f82fdc4ab..15e77d60be1778b4eef116b70eaae7be40a6166c 100644 (file)
--- a/crypto/md2/md2_dgst.c
+++ b/crypto/md2/md2_dgst.c
@@ -125,7 +125,7 @@ int MD2_Init(MD2_CTX *c)
        return 1;
        }
 
        return 1;
        }
 

-int MD2_Update(MD2_CTX *c, const unsigned char *data, unsigned long len)
+int MD2_Update(MD2_CTX *c, const unsigned char *data, size_t len)

        {
        register UCHAR *p;
 
        {
        register UCHAR *p;
 


@@ -145,7 +145,7 @@ int MD2_Update(MD2_CTX *c, const unsigned char *data, unsigned long len)
                        }
                else
                        {
                        }
                else
                        {

-                       memcpy(&(p[c->num]),data,(int)len);
+                       memcpy(&(p[c->num]),data,len);

                        /* data+=len; */
                        c->num+=(int)len;
                        return 1;
                        /* data+=len; */
                        c->num+=(int)len;
                        return 1;


@@ -159,7 +159,7 @@ int MD2_Update(MD2_CTX *c, const unsigned char *data, unsigned long len)
                data+=MD2_BLOCK;
                len-=MD2_BLOCK;
                }
                data+=MD2_BLOCK;
                len-=MD2_BLOCK;
                }

-       memcpy(p,data,(int)len);
+       memcpy(p,data,len);

        c->num=(int)len;
        return 1;
        }
        c->num=(int)len;
        return 1;
        }

diff --git a/crypto/md2/md2_one.c b/crypto/md2/md2_one.c
index 835160ef56d1bcf4470bd3f79633d4a137c63f79..dab35071acd2dec09d66e9be2c663810cacb6a18 100644 (file)
--- a/crypto/md2/md2_one.c
+++ b/crypto/md2/md2_one.c
@@ -63,7 +63,7 @@
 /* This is a separate file so that #defines in cryptlib.h can
  * map my MD functions to different names */
 
 /* This is a separate file so that #defines in cryptlib.h can
  * map my MD functions to different names */
 

-unsigned char *MD2(const unsigned char *d, unsigned long n, unsigned char *md)
+unsigned char *MD2(const unsigned char *d, size_t n, unsigned char *md)

        {
        MD2_CTX c;
        static unsigned char m[MD2_DIGEST_LENGTH];
        {
        MD2_CTX c;
        static unsigned char m[MD2_DIGEST_LENGTH];

diff --git a/crypto/md32_common.h b/crypto/md32_common.h
index 307ec30dfc32417eef04a0dd4e5e0050a3d5530e..535ea85d16de5a0a886570338a1a129a52b42e72 100644 (file)
--- a/crypto/md32_common.h
+++ b/crypto/md32_common.h
@@ -410,21 +410,21 @@
  * Time for some action:-)
  */
 
  * Time for some action:-)
  */
 

-int HASH_UPDATE (HASH_CTX *c, const void *data_, unsigned long len)
+int HASH_UPDATE (HASH_CTX *c, const void *data_, size_t len)

        {
        const unsigned char *data=data_;
        register HASH_LONG * p;
        {
        const unsigned char *data=data_;
        register HASH_LONG * p;

-       register unsigned long l;
+       register HASH_LONG l;

        int sw,sc,ew,ec;
 
        if (len==0) return 1;
 
        int sw,sc,ew,ec;
 
        if (len==0) return 1;
 

-       l=(c->Nl+(len<<3))&0xffffffffL;
+       l=(c->Nl+(((HASH_LONG)len)<<3))&0xffffffffUL;

        /* 95-05-24 eay Fixed a bug with the overflow handling, thanks to
         * Wei Dai <weidai@eskimo.com> for pointing it out. */
        if (l < c->Nl) /* overflow */
                c->Nh++;
        /* 95-05-24 eay Fixed a bug with the overflow handling, thanks to
         * Wei Dai <weidai@eskimo.com> for pointing it out. */
        if (l < c->Nl) /* overflow */
                c->Nh++;

-       c->Nh+=(len>>29);
+       c->Nh+=(len>>29);       /* might cause compiler warning on 16-bit */

        c->Nl=l;
 
        if (c->num != 0)
        c->Nl=l;
 
        if (c->num != 0)

diff --git a/crypto/md4/md4.h b/crypto/md4/md4.h
index 7a7b23682f8d68f0b952090a7a9d5a224f0f7c43..9a5b6603fe3e3b2b112e4c7e2f7167fc90c4d978 100644 (file)
--- a/crypto/md4/md4.h
+++ b/crypto/md4/md4.h
@@ -105,9 +105,9 @@ typedef struct MD4state_st
        } MD4_CTX;
 
 int MD4_Init(MD4_CTX *c);
        } MD4_CTX;
 
 int MD4_Init(MD4_CTX *c);

-int MD4_Update(MD4_CTX *c, const void *data, unsigned long len);
+int MD4_Update(MD4_CTX *c, const void *data, size_t len);

 int MD4_Final(unsigned char *md, MD4_CTX *c);
 int MD4_Final(unsigned char *md, MD4_CTX *c);

-unsigned char *MD4(const unsigned char *d, unsigned long n, unsigned char *md);
+unsigned char *MD4(const unsigned char *d, size_t n, unsigned char *md);

 void MD4_Transform(MD4_CTX *c, const unsigned char *b);
 #ifdef  __cplusplus
 }
 void MD4_Transform(MD4_CTX *c, const unsigned char *b);
 #ifdef  __cplusplus
 }

diff --git a/crypto/md4/md4_dgst.c b/crypto/md4/md4_dgst.c
index 7afb7185b68a72f201db82f33c43a1d025279d97..d4c7057f13b5ce58a5c12ac46b08c4a167eb5957 100644 (file)
--- a/crypto/md4/md4_dgst.c
+++ b/crypto/md4/md4_dgst.c
@@ -83,7 +83,7 @@ int MD4_Init(MD4_CTX *c)
        }
 
 #ifndef md4_block_host_order
        }
 
 #ifndef md4_block_host_order

-void md4_block_host_order (MD4_CTX *c, const void *data, int num)
+void md4_block_host_order (MD4_CTX *c, const void *data, size_t num)

        {
        const MD4_LONG *X=data;
        register unsigned MD32_REG_T A,B,C,D;
        {
        const MD4_LONG *X=data;
        register unsigned MD32_REG_T A,B,C,D;


@@ -159,7 +159,7 @@ void md4_block_host_order (MD4_CTX *c, const void *data, int num)
 #ifdef X
 #undef X
 #endif
 #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_;
        register unsigned MD32_REG_T A,B,C,D,l;
        {
        const unsigned char *data=data_;
        register unsigned MD32_REG_T A,B,C,D,l;

diff --git a/crypto/md4/md4_locl.h b/crypto/md4/md4_locl.h
index a8d31d7a73f5ecbb5fccb549edfb27331dd8b0d3..7e219b17eac66f799af36d06bfb2dfe9fbd7aab7 100644 (file)
--- a/crypto/md4/md4_locl.h
+++ b/crypto/md4/md4_locl.h
@@ -65,8 +65,8 @@
 #define MD4_LONG_LOG2 2 /* default to 32 bits */
 #endif
 
 #define MD4_LONG_LOG2 2 /* default to 32 bits */
 #endif
 

-void md4_block_host_order (MD4_CTX *c, const void *p,int num);
-void md4_block_data_order (MD4_CTX *c, const void *p,int num);
+void md4_block_host_order (MD4_CTX *c, const void *p,size_t num);
+void md4_block_data_order (MD4_CTX *c, const void *p,size_t num);

 
 #if defined(__i386) || defined(__i386__) || defined(_M_IX86) || defined(__INTEL__)
 /*
 
 #if defined(__i386) || defined(__i386__) || defined(_M_IX86) || defined(__INTEL__)
 /*

diff --git a/crypto/md4/md4_one.c b/crypto/md4/md4_one.c
index 00565507e4bb2154d3c088739f67f421212a1d9a..64601b62dfa9fda1d177c7103134d1a717c9ecd9 100644 (file)
--- a/crypto/md4/md4_one.c
+++ b/crypto/md4/md4_one.c
@@ -65,7 +65,7 @@
 #include <openssl/ebcdic.h>
 #endif
 
 #include <openssl/ebcdic.h>
 #endif
 

-unsigned char *MD4(const unsigned char *d, unsigned long n, unsigned char *md)
+unsigned char *MD4(const unsigned char *d, size_t n, unsigned char *md)

        {
        MD4_CTX c;
        static unsigned char m[MD4_DIGEST_LENGTH];
        {
        MD4_CTX c;
        static unsigned char m[MD4_DIGEST_LENGTH];

diff --git a/crypto/md5/md5.h b/crypto/md5/md5.h
index a252e02115439f943bd8094fbf5c558a2ad53d80..587d947b9a4fcd0032c91c7c8afabaf582668c72 100644 (file)
--- a/crypto/md5/md5.h
+++ b/crypto/md5/md5.h
@@ -105,9 +105,9 @@ typedef struct MD5state_st
        } MD5_CTX;
 
 int MD5_Init(MD5_CTX *c);
        } MD5_CTX;
 
 int MD5_Init(MD5_CTX *c);

-int MD5_Update(MD5_CTX *c, const void *data, unsigned long len);
+int MD5_Update(MD5_CTX *c, const void *data, size_t len);

 int MD5_Final(unsigned char *md, MD5_CTX *c);
 int MD5_Final(unsigned char *md, MD5_CTX *c);

-unsigned char *MD5(const unsigned char *d, unsigned long n, unsigned char *md);
+unsigned char *MD5(const unsigned char *d, size_t n, unsigned char *md);

 void MD5_Transform(MD5_CTX *c, const unsigned char *b);
 #ifdef  __cplusplus
 }
 void MD5_Transform(MD5_CTX *c, const unsigned char *b);
 #ifdef  __cplusplus
 }

diff --git a/crypto/md5/md5_dgst.c b/crypto/md5/md5_dgst.c
index 9c7abc36972e9bba9133f3873622b5e85a78a4ce..f97f48e55bb8ba0844653f7895bef77e035b1bdf 100644 (file)
--- a/crypto/md5/md5_dgst.c
+++ b/crypto/md5/md5_dgst.c
@@ -83,7 +83,7 @@ int MD5_Init(MD5_CTX *c)
        }
 
 #ifndef md5_block_host_order
        }
 
 #ifndef md5_block_host_order

-void md5_block_host_order (MD5_CTX *c, const void *data, int num)
+void md5_block_host_order (MD5_CTX *c, const void *data, size_t num)

        {
        const MD5_LONG *X=data;
        register unsigned MD32_REG_T A,B,C,D;
        {
        const MD5_LONG *X=data;
        register unsigned MD32_REG_T A,B,C,D;


@@ -176,7 +176,7 @@ void md5_block_host_order (MD5_CTX *c, const void *data, int num)
 #ifdef X
 #undef X
 #endif
 #ifdef X
 #undef X
 #endif

-void md5_block_data_order (MD5_CTX *c, const void *data_, int num)
+void md5_block_data_order (MD5_CTX *c, const void *data_, size_t num)

        {
        const unsigned char *data=data_;
        register unsigned MD32_REG_T A,B,C,D,l;
        {
        const unsigned char *data=data_;
        register unsigned MD32_REG_T A,B,C,D,l;

diff --git a/crypto/md5/md5_locl.h b/crypto/md5/md5_locl.h
index 9e360da732ab2721a623ea24f5ec1d61b92a2a31..b29f0de7e32ad087d63215972545d0f331d86721 100644 (file)
--- a/crypto/md5/md5_locl.h
+++ b/crypto/md5/md5_locl.h
@@ -69,13 +69,13 @@
 # if defined(__i386) || defined(__i386__) || defined(_M_IX86) || defined(__INTEL__)
 #  define md5_block_host_order md5_block_asm_host_order
 # elif defined(__sparc) && defined(OPENSSL_SYS_ULTRASPARC)
 # if defined(__i386) || defined(__i386__) || defined(_M_IX86) || defined(__INTEL__)
 #  define md5_block_host_order md5_block_asm_host_order
 # elif defined(__sparc) && defined(OPENSSL_SYS_ULTRASPARC)

-   void md5_block_asm_data_order_aligned (MD5_CTX *c, const MD5_LONG *p,int num);
+   void md5_block_asm_data_order_aligned (MD5_CTX *c, const MD5_LONG *p,size_t num);

 #  define HASH_BLOCK_DATA_ORDER_ALIGNED md5_block_asm_data_order_aligned
 # endif
 #endif
 
 #  define HASH_BLOCK_DATA_ORDER_ALIGNED md5_block_asm_data_order_aligned
 # endif
 #endif
 

-void md5_block_host_order (MD5_CTX *c, const void *p,int num);
-void md5_block_data_order (MD5_CTX *c, const void *p,int num);
+void md5_block_host_order (MD5_CTX *c, const void *p,size_t num);
+void md5_block_data_order (MD5_CTX *c, const void *p,size_t num);

 
 #if defined(__i386) || defined(__i386__) || defined(_M_IX86) || defined(__INTEL__)
 /*
 
 #if defined(__i386) || defined(__i386__) || defined(_M_IX86) || defined(__INTEL__)
 /*

diff --git a/crypto/md5/md5_one.c b/crypto/md5/md5_one.c
index c5dd2d81db49373db908cb14814b2eeb2363ce9d..9918243ea2f68e1e229f4e9d186d8a3fddb803bc 100644 (file)
--- a/crypto/md5/md5_one.c
+++ b/crypto/md5/md5_one.c
@@ -65,7 +65,7 @@
 #include <openssl/ebcdic.h>
 #endif
 
 #include <openssl/ebcdic.h>
 #endif
 

-unsigned char *MD5(const unsigned char *d, unsigned long n, unsigned char *md)
+unsigned char *MD5(const unsigned char *d, size_t n, unsigned char *md)

        {
        MD5_CTX c;
        static unsigned char m[MD5_DIGEST_LENGTH];
        {
        MD5_CTX c;
        static unsigned char m[MD5_DIGEST_LENGTH];

diff --git a/crypto/mdc2/mdc2.h b/crypto/mdc2/mdc2.h
index 793a8a0f13fb9fe764eac07f3ea8b32163409250..6490e5c7d35fd46ebd0ef79a84c7ffa1140f9b75 100644 (file)
--- a/crypto/mdc2/mdc2.h
+++ b/crypto/mdc2/mdc2.h
@@ -82,9 +82,9 @@ typedef struct mdc2_ctx_st
 
 
 int MDC2_Init(MDC2_CTX *c);
 
 
 int MDC2_Init(MDC2_CTX *c);

-int MDC2_Update(MDC2_CTX *c, const unsigned char *data, unsigned long len);
+int MDC2_Update(MDC2_CTX *c, const unsigned char *data, size_t len);

 int MDC2_Final(unsigned char *md, MDC2_CTX *c);
 int MDC2_Final(unsigned char *md, MDC2_CTX *c);

-unsigned char *MDC2(const unsigned char *d, unsigned long n,
+unsigned char *MDC2(const unsigned char *d, size_t n,

        unsigned char *md);
 
 #ifdef  __cplusplus
        unsigned char *md);
 
 #ifdef  __cplusplus

diff --git a/crypto/mdc2/mdc2_one.c b/crypto/mdc2/mdc2_one.c
index 37f06c8d77cfee5ee5194449e302b7390a025dc0..cd569aa865a6c3c7260b30c4437dcb3506410704 100644 (file)
--- a/crypto/mdc2/mdc2_one.c
+++ b/crypto/mdc2/mdc2_one.c
@@ -60,7 +60,7 @@
 #include "cryptlib.h"
 #include <openssl/mdc2.h>
 
 #include "cryptlib.h"
 #include <openssl/mdc2.h>
 

-unsigned char *MDC2(const unsigned char *d, unsigned long n, unsigned char *md)
+unsigned char *MDC2(const unsigned char *d, size_t n, unsigned char *md)

        {
        MDC2_CTX c;
        static unsigned char m[MDC2_DIGEST_LENGTH];
        {
        MDC2_CTX c;
        static unsigned char m[MDC2_DIGEST_LENGTH];

diff --git a/crypto/mdc2/mdc2dgst.c b/crypto/mdc2/mdc2dgst.c
index 32daa9b0da35944af7f9bd6987ee0025125ec622..aa9ba0ee6bd982cb4436d4f1c80e34d2cf2a2204 100644 (file)
--- a/crypto/mdc2/mdc2dgst.c
+++ b/crypto/mdc2/mdc2dgst.c
@@ -74,7 +74,7 @@
                        *((c)++)=(unsigned char)(((l)>>16L)&0xff), \
                        *((c)++)=(unsigned char)(((l)>>24L)&0xff))
 
                        *((c)++)=(unsigned char)(((l)>>16L)&0xff), \
                        *((c)++)=(unsigned char)(((l)>>24L)&0xff))
 

-static void mdc2_body(MDC2_CTX *c, const unsigned char *in, unsigned int len);
+static void mdc2_body(MDC2_CTX *c, const unsigned char *in, size_t len);

 int MDC2_Init(MDC2_CTX *c)
        {
        c->num=0;
 int MDC2_Init(MDC2_CTX *c)
        {
        c->num=0;


@@ -84,9 +84,9 @@ int MDC2_Init(MDC2_CTX *c)
        return 1;
        }
 
        return 1;
        }
 

-int MDC2_Update(MDC2_CTX *c, const unsigned char *in, unsigned long len)
+int MDC2_Update(MDC2_CTX *c, const unsigned char *in, size_t len)

        {
        {

-       int i,j;
+       size_t i,j;

 
        i=c->num;
        if (i != 0)
 
        i=c->num;
        if (i != 0)


@@ -94,7 +94,7 @@ int MDC2_Update(MDC2_CTX *c, const unsigned char *in, unsigned long len)
                if (i+len < MDC2_BLOCK)
                        {
                        /* partial block */
                if (i+len < MDC2_BLOCK)
                        {
                        /* partial block */

-                       memcpy(&(c->data[i]),in,(int)len);
+                       memcpy(&(c->data[i]),in,len);

                        c->num+=(int)len;
                        return 1;
                        }
                        c->num+=(int)len;
                        return 1;
                        }


@@ -109,25 +109,25 @@ int MDC2_Update(MDC2_CTX *c, const unsigned char *in, unsigned long len)
                        mdc2_body(c,&(c->data[0]),MDC2_BLOCK);
                        }
                }
                        mdc2_body(c,&(c->data[0]),MDC2_BLOCK);
                        }
                }

-       i=(int)(len&(unsigned long)~(MDC2_BLOCK-1));
+       i=len&~((size_t)MDC2_BLOCK-1);

        if (i > 0) mdc2_body(c,in,i);
        if (i > 0) mdc2_body(c,in,i);

-       j=(int)len-i;
+       j=len-i;

        if (j > 0)
                {
                memcpy(&(c->data[0]),&(in[i]),j);
        if (j > 0)
                {
                memcpy(&(c->data[0]),&(in[i]),j);

-               c->num=j;
+               c->num=(int)j;

                }
        return 1;
        }
 
                }
        return 1;
        }
 

-static void mdc2_body(MDC2_CTX *c, const unsigned char *in, unsigned int len)
+static void mdc2_body(MDC2_CTX *c, const unsigned char *in, size_t len)

        {
        register DES_LONG tin0,tin1;
        register DES_LONG ttin0,ttin1;
        DES_LONG d[2],dd[2];
        DES_key_schedule k;
        unsigned char *p;
        {
        register DES_LONG tin0,tin1;
        register DES_LONG ttin0,ttin1;
        DES_LONG d[2],dd[2];
        DES_key_schedule k;
        unsigned char *p;

-       unsigned int i;
+       size_t i;

 
        for (i=0; i<len; i+=8)
                {
 
        for (i=0; i<len; i+=8)
                {

diff --git a/crypto/ripemd/ripemd.h b/crypto/ripemd/ripemd.h
index 78d5f365605b5baf400bec0d762d1564169993fb..a664e742afe80f753b6b5c387297e7f8a9ebd6d7 100644 (file)
--- a/crypto/ripemd/ripemd.h
+++ b/crypto/ripemd/ripemd.h
@@ -91,9 +91,9 @@ typedef struct RIPEMD160state_st
        } RIPEMD160_CTX;
 
 int RIPEMD160_Init(RIPEMD160_CTX *c);
        } RIPEMD160_CTX;
 
 int RIPEMD160_Init(RIPEMD160_CTX *c);

-int RIPEMD160_Update(RIPEMD160_CTX *c, const void *data, unsigned long len);
+int RIPEMD160_Update(RIPEMD160_CTX *c, const void *data, size_t len);

 int RIPEMD160_Final(unsigned char *md, RIPEMD160_CTX *c);
 int RIPEMD160_Final(unsigned char *md, RIPEMD160_CTX *c);

-unsigned char *RIPEMD160(const unsigned char *d, unsigned long n,
+unsigned char *RIPEMD160(const unsigned char *d, size_t n,

        unsigned char *md);
 void RIPEMD160_Transform(RIPEMD160_CTX *c, const unsigned char *b);
 #ifdef  __cplusplus
        unsigned char *md);
 void RIPEMD160_Transform(RIPEMD160_CTX *c, const unsigned char *b);
 #ifdef  __cplusplus

diff --git a/crypto/ripemd/rmd_dgst.c b/crypto/ripemd/rmd_dgst.c
index f351f00eea0e4b9355a406f611a0969bcb5e9de1..03a286dfccfa32d1eb60879cc77320599ff4eb56 100644 (file)
--- a/crypto/ripemd/rmd_dgst.c
+++ b/crypto/ripemd/rmd_dgst.c
@@ -63,10 +63,10 @@
 const char *RMD160_version="RIPE-MD160" OPENSSL_VERSION_PTEXT;
 
 #  ifdef RMD160_ASM
 const char *RMD160_version="RIPE-MD160" OPENSSL_VERSION_PTEXT;
 
 #  ifdef RMD160_ASM

-     void ripemd160_block_x86(RIPEMD160_CTX *c, unsigned long *p,int num);
+     void ripemd160_block_x86(RIPEMD160_CTX *c, unsigned long *p,size_t num);

 #    define ripemd160_block ripemd160_block_x86
 #  else
 #    define ripemd160_block ripemd160_block_x86
 #  else

-     void ripemd160_block(RIPEMD160_CTX *c, unsigned long *p,int num);
+     void ripemd160_block(RIPEMD160_CTX *c, unsigned long *p,size_t num);

 #  endif
 
 int RIPEMD160_Init(RIPEMD160_CTX *c)
 #  endif
 
 int RIPEMD160_Init(RIPEMD160_CTX *c)


@@ -87,7 +87,7 @@ int RIPEMD160_Init(RIPEMD160_CTX *c)
 #undef X
 #endif
 #define X(i)   XX[i]
 #undef X
 #endif
 #define X(i)   XX[i]

-void ripemd160_block_host_order (RIPEMD160_CTX *ctx, const void *p, int num)
+void ripemd160_block_host_order (RIPEMD160_CTX *ctx, const void *p, size_t num)

        {
        const RIPEMD160_LONG *XX=p;
        register unsigned MD32_REG_T A,B,C,D,E;
        {
        const RIPEMD160_LONG *XX=p;
        register unsigned MD32_REG_T A,B,C,D,E;


@@ -287,7 +287,7 @@ void ripemd160_block_host_order (RIPEMD160_CTX *ctx, const void *p, int num)
 #ifdef X
 #undef X
 #endif
 #ifdef X
 #undef X
 #endif

-void ripemd160_block_data_order (RIPEMD160_CTX *ctx, const void *p, int num)
+void ripemd160_block_data_order (RIPEMD160_CTX *ctx, const void *p, size_t num)

        {
        const unsigned char *data=p;
        register unsigned MD32_REG_T A,B,C,D,E;
        {
        const unsigned char *data=p;
        register unsigned MD32_REG_T A,B,C,D,E;

diff --git a/crypto/ripemd/rmd_locl.h b/crypto/ripemd/rmd_locl.h
index 7b835dfbd4f81b2acde539989752943af5faf700..8eb0d288d6413a82894dc6ec056d76f183bc14e9 100644 (file)
--- a/crypto/ripemd/rmd_locl.h
+++ b/crypto/ripemd/rmd_locl.h
@@ -76,8 +76,8 @@
 # endif
 #endif
 
 # endif
 #endif
 

-void ripemd160_block_host_order (RIPEMD160_CTX *c, const void *p,int num);
-void ripemd160_block_data_order (RIPEMD160_CTX *c, const void *p,int num);
+void ripemd160_block_host_order (RIPEMD160_CTX *c, const void *p,size_t num);
+void ripemd160_block_data_order (RIPEMD160_CTX *c, const void *p,size_t num);

 
 #if defined(__i386) || defined(__i386__) || defined(_M_IX86) || defined(__INTEL__)
 #define ripemd160_block_data_order ripemd160_block_host_order
 
 #if defined(__i386) || defined(__i386__) || defined(_M_IX86) || defined(__INTEL__)
 #define ripemd160_block_data_order ripemd160_block_host_order

diff --git a/crypto/ripemd/rmd_one.c b/crypto/ripemd/rmd_one.c
index f8b580c33a3a128591f0a051c260e3fbcdda5c2a..bfc4d83fe0a8dd82e90bf1b75ac30a0eabf4fec0 100644 (file)
--- a/crypto/ripemd/rmd_one.c
+++ b/crypto/ripemd/rmd_one.c
@@ -61,7 +61,7 @@
 #include <openssl/ripemd.h>
 #include <openssl/crypto.h>
 
 #include <openssl/ripemd.h>
 #include <openssl/crypto.h>
 

-unsigned char *RIPEMD160(const unsigned char *d, unsigned long n,
+unsigned char *RIPEMD160(const unsigned char *d, size_t n,

             unsigned char *md)
        {
        RIPEMD160_CTX c;
             unsigned char *md)
        {
        RIPEMD160_CTX c;

diff --git a/crypto/sha/sha.h b/crypto/sha/sha.h
index 9ef21414e50ca293f5ce956b239bdf7e460f11d8..aa4c9dd5d708afa39763a59255882fec4481b427 100644 (file)
--- a/crypto/sha/sha.h
+++ b/crypto/sha/sha.h
@@ -102,16 +102,16 @@ typedef struct SHAstate_st
 
 #ifndef OPENSSL_NO_SHA0
 int SHA_Init(SHA_CTX *c);
 
 #ifndef OPENSSL_NO_SHA0
 int SHA_Init(SHA_CTX *c);

-int SHA_Update(SHA_CTX *c, const void *data, unsigned long len);
+int SHA_Update(SHA_CTX *c, const void *data, size_t len);

 int SHA_Final(unsigned char *md, SHA_CTX *c);
 int SHA_Final(unsigned char *md, SHA_CTX *c);

-unsigned char *SHA(const unsigned char *d, unsigned long n,unsigned char *md);
+unsigned char *SHA(const unsigned char *d, size_t n, unsigned char *md);

 void SHA_Transform(SHA_CTX *c, const unsigned char *data);
 #endif
 #ifndef OPENSSL_NO_SHA1
 int SHA1_Init(SHA_CTX *c);
 void SHA_Transform(SHA_CTX *c, const unsigned char *data);
 #endif
 #ifndef OPENSSL_NO_SHA1
 int SHA1_Init(SHA_CTX *c);

-int SHA1_Update(SHA_CTX *c, const void *data, unsigned long len);
+int SHA1_Update(SHA_CTX *c, const void *data, size_t len);

 int SHA1_Final(unsigned char *md, SHA_CTX *c);
 int SHA1_Final(unsigned char *md, SHA_CTX *c);

-unsigned char *SHA1(const unsigned char *d, unsigned long n,unsigned char *md);
+unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md);

 void SHA1_Transform(SHA_CTX *c, const unsigned char *data);
 #endif
 
 void SHA1_Transform(SHA_CTX *c, const unsigned char *data);
 #endif
 

diff --git a/crypto/sha/sha1_one.c b/crypto/sha/sha1_one.c
index 20e660c71df72de695e6d7ad965db19a9f8bf54d..582b25394cdea9b447a9cf8edda66808c0dd9194 100644 (file)
--- a/crypto/sha/sha1_one.c
+++ b/crypto/sha/sha1_one.c
@@ -62,7 +62,7 @@
 #include <openssl/crypto.h>
 
 #ifndef OPENSSL_NO_SHA1
 #include <openssl/crypto.h>
 
 #ifndef OPENSSL_NO_SHA1

-unsigned char *SHA1(const unsigned char *d, unsigned long n, unsigned char *md)
+unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md)

        {
        SHA_CTX c;
        static unsigned char m[SHA_DIGEST_LENGTH];
        {
        SHA_CTX c;
        static unsigned char m[SHA_DIGEST_LENGTH];

diff --git a/crypto/sha/sha_locl.h b/crypto/sha/sha_locl.h
index 48c0ac6422d85fe58b16bbf1eec1b443272fe53c..01fc6e22eb7cf58b9a427a39eb96e47e3ec2c348 100644 (file)
--- a/crypto/sha/sha_locl.h
+++ b/crypto/sha/sha_locl.h
@@ -92,8 +92,8 @@
 # define HASH_BLOCK_DATA_ORDER         sha_block_data_order
 # define Xupdate(a,ix,ia,ib,ic,id)     (ix=(a)=(ia^ib^ic^id))
 
 # define HASH_BLOCK_DATA_ORDER         sha_block_data_order
 # define Xupdate(a,ix,ia,ib,ic,id)     (ix=(a)=(ia^ib^ic^id))
 

-  void sha_block_host_order (SHA_CTX *c, const void *p,int num);
-  void sha_block_data_order (SHA_CTX *c, const void *p,int num);
+  void sha_block_host_order (SHA_CTX *c, const void *p,size_t num);
+  void sha_block_data_order (SHA_CTX *c, const void *p,size_t num);

 
 #elif defined(SHA_1)
 
 
 #elif defined(SHA_1)
 


@@ -123,8 +123,8 @@
 #   define HASH_BLOCK_DATA_ORDER_ALIGNED       sha1_block_asm_data_order
 #  endif
 # endif
 #   define HASH_BLOCK_DATA_ORDER_ALIGNED       sha1_block_asm_data_order
 #  endif
 # endif

-  void sha1_block_host_order (SHA_CTX *c, const void *p,int num);
-  void sha1_block_data_order (SHA_CTX *c, const void *p,int num);
+  void sha1_block_host_order (SHA_CTX *c, const void *p,size_t num);
+  void sha1_block_data_order (SHA_CTX *c, const void *p,size_t num);

 
 #else
 # error "Either SHA_0 or SHA_1 must be defined."
 
 #else
 # error "Either SHA_0 or SHA_1 must be defined."


@@ -223,7 +223,7 @@ int HASH_INIT (SHA_CTX *c)
 #endif
 
 #ifndef DONT_IMPLEMENT_BLOCK_HOST_ORDER
 #endif
 
 #ifndef DONT_IMPLEMENT_BLOCK_HOST_ORDER

-void HASH_BLOCK_HOST_ORDER (SHA_CTX *c, const void *d, int num)
+void HASH_BLOCK_HOST_ORDER (SHA_CTX *c, const void *d, size_t num)

        {
        const SHA_LONG *W=d;
        register unsigned MD32_REG_T A,B,C,D,E,T;
        {
        const SHA_LONG *W=d;
        register unsigned MD32_REG_T A,B,C,D,E,T;


@@ -348,7 +348,7 @@ void HASH_BLOCK_HOST_ORDER (SHA_CTX *c, const void *d, int num)
 #endif
 
 #ifndef DONT_IMPLEMENT_BLOCK_DATA_ORDER
 #endif
 
 #ifndef DONT_IMPLEMENT_BLOCK_DATA_ORDER

-void HASH_BLOCK_DATA_ORDER (SHA_CTX *c, const void *p, int num)
+void HASH_BLOCK_DATA_ORDER (SHA_CTX *c, const void *p, size_t num)

        {
        const unsigned char *data=p;
        register unsigned MD32_REG_T A,B,C,D,E,T,l;
        {
        const unsigned char *data=p;
        register unsigned MD32_REG_T A,B,C,D,E,T,l;


@@ -505,7 +505,7 @@ void HASH_BLOCK_DATA_ORDER (SHA_CTX *c, const void *p, int num)
        A=ROTATE(A,5)+T+xa;         } while(0)
 
 #ifndef DONT_IMPLEMENT_BLOCK_HOST_ORDER
        A=ROTATE(A,5)+T+xa;         } while(0)
 
 #ifndef DONT_IMPLEMENT_BLOCK_HOST_ORDER

-void HASH_BLOCK_HOST_ORDER (SHA_CTX *c, const void *d, int num)
+void HASH_BLOCK_HOST_ORDER (SHA_CTX *c, const void *d, size_t num)

        {
        const SHA_LONG *W=d;
        register unsigned MD32_REG_T A,B,C,D,E,T;
        {
        const SHA_LONG *W=d;
        register unsigned MD32_REG_T A,B,C,D,E,T;


@@ -551,7 +551,7 @@ void HASH_BLOCK_HOST_ORDER (SHA_CTX *c, const void *d, int num)
 #endif
 
 #ifndef DONT_IMPLEMENT_BLOCK_DATA_ORDER
 #endif
 
 #ifndef DONT_IMPLEMENT_BLOCK_DATA_ORDER

-void HASH_BLOCK_DATA_ORDER (SHA_CTX *c, const void *p, int num)
+void HASH_BLOCK_DATA_ORDER (SHA_CTX *c, const void *p, size_t num)

        {
        const unsigned char *data=p;
        register unsigned MD32_REG_T A,B,C,D,E,T,l;
        {
        const unsigned char *data=p;
        register unsigned MD32_REG_T A,B,C,D,E,T,l;

diff --git a/crypto/sha/sha_one.c b/crypto/sha/sha_one.c
index e61c63f3e99d46f86b0c0a00d981fd0c5324feee..371ffddac6c88d6a1033e4a3a889380f887c69bb 100644 (file)
--- a/crypto/sha/sha_one.c
+++ b/crypto/sha/sha_one.c
@@ -62,7 +62,7 @@
 #include <openssl/crypto.h>
 
 #ifndef OPENSSL_NO_SHA0
 #include <openssl/crypto.h>
 
 #ifndef OPENSSL_NO_SHA0

-unsigned char *SHA(const unsigned char *d, unsigned long n, unsigned char *md)
+unsigned char *SHA(const unsigned char *d, size_t n, unsigned char *md)

        {
        SHA_CTX c;
        static unsigned char m[SHA_DIGEST_LENGTH];
        {
        SHA_CTX c;
        static unsigned char m[SHA_DIGEST_LENGTH];