Not sure about this one... seems to be needed to make 64 bit release

[openssl.git] / crypto / rand / md_rand.c

diff --git a/crypto/rand/md_rand.c b/crypto/rand/md_rand.c
index f47fc2ba8459e947f68322b269e1e5125f8da71f..cac3e8be61aa1b50868edc21f59ee060b933dcd6 100644 (file)
--- a/crypto/rand/md_rand.c
+++ b/crypto/rand/md_rand.c
@@ -56,7 +56,7 @@
  * [including the GNU Public Licence.]
  */
 /* ====================================================================
- * Copyright (c) 1998-2000 The OpenSSL Project.  All rights reserved.
+ * Copyright (c) 1998-2001 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -126,7 +126,6 @@
 
 #include <openssl/crypto.h>
 #include <openssl/err.h>
-#include <openssl/evp.h>
 
 #ifdef BN_DEBUG
 # define PREDICT
@@ -146,20 +145,20 @@ static unsigned int crypto_lock_rand = 0; /* may be set only when a thread
                                            * holds CRYPTO_LOCK_RAND
                                            * (to prevent double locking) */
 /* access to lockin_thread is synchronized by CRYPTO_LOCK_RAND2 */
-static unsigned long locking_thread = 0; /* valid iff crypto_lock_rand is set */
+static CRYPTO_THREADID locking_threadid; /* valid iff crypto_lock_rand is set */
 
 
 #ifdef PREDICT
 int rand_predictable=0;
 #endif
 
-const char *RAND_version="RAND" OPENSSL_VERSION_PTEXT;
+const char RAND_version[]="RAND" OPENSSL_VERSION_PTEXT;
 
 static void ssleay_rand_cleanup(void);
-static void ssleay_rand_seed(const void *buf, int num);
-static void ssleay_rand_add(const void *buf, int num, double add_entropy);
-static int ssleay_rand_bytes(unsigned char *buf, int num);
-static int ssleay_rand_pseudo_bytes(unsigned char *buf, int num);
+static void ssleay_rand_seed(const void *buf, size_t num);
+static void ssleay_rand_add(const void *buf, size_t num, double add_entropy);
+static int ssleay_rand_bytes(unsigned char *buf, size_t num);
+static int ssleay_rand_pseudo_bytes(unsigned char *buf, size_t num);
 static int ssleay_rand_status(void);
 
 RAND_METHOD rand_ssleay_meth={
@@ -178,19 +177,20 @@ RAND_METHOD *RAND_SSLeay(void)
 
 static void ssleay_rand_cleanup(void)
        {
-       memset(state,0,sizeof(state));
+       OPENSSL_cleanse(state,sizeof(state));
        state_num=0;
        state_index=0;
-       memset(md,0,MD_DIGEST_LENGTH);
+       OPENSSL_cleanse(md,MD_DIGEST_LENGTH);
        md_count[0]=0;
        md_count[1]=0;
        entropy=0;
        initialized=0;
        }
 
-static void ssleay_rand_add(const void *buf, int num, double add)
+static void ssleay_rand_add(const void *buf, size_t num, double add)
        {
-       int i,j,k,st_idx;
+       int i,st_idx;
+       ssize_t j,k;
        long md_c[2];
        unsigned char local_md[MD_DIGEST_LENGTH];
        EVP_MD_CTX m;
@@ -214,8 +214,10 @@ static void ssleay_rand_add(const void *buf, int num, double add)
        /* check if we already have the lock */
        if (crypto_lock_rand)
                {
+               CRYPTO_THREADID cur;
+               CRYPTO_THREADID_current(&cur);
                CRYPTO_r_lock(CRYPTO_LOCK_RAND2);
-               do_not_lock = (locking_thread == CRYPTO_thread_id());
+               do_not_lock = !CRYPTO_THREADID_cmp(&locking_threadid, &cur);
                CRYPTO_r_unlock(CRYPTO_LOCK_RAND2);
                }
        else
@@ -301,7 +303,7 @@ static void ssleay_rand_add(const void *buf, int num, double add)
         * other thread's seeding remains without effect (except for
         * the incremented counter).  By XORing it we keep at least as
         * much entropy as fits into md. */
-       for (k = 0; k < sizeof md; k++)
+       for (k = 0; k < (int)sizeof(md); k++)
                {
                md[k] ^= local_md[k];
                }
@@ -314,15 +316,16 @@ static void ssleay_rand_add(const void *buf, int num, double add)
 #endif
        }
 
-static void ssleay_rand_seed(const void *buf, int num)
+static void ssleay_rand_seed(const void *buf, size_t num)
        {
-       ssleay_rand_add(buf, num, num);
+       ssleay_rand_add(buf, num, (double)num);
        }
 
-static int ssleay_rand_bytes(unsigned char *buf, int num)
+static int ssleay_rand_bytes(unsigned char *buf, size_t num)
        {
        static volatile int stirred_pool = 0;
-       int i,j,k,st_num,st_idx;
+       int i,st_num,st_idx;
+       ssize_t j,k;
        int num_ceil;
        int ok;
        long md_c[2];
@@ -373,7 +376,7 @@ static int ssleay_rand_bytes(unsigned char *buf, int num)
 
        /* prevent ssleay_rand_bytes() from trying to obtain the lock again */
        CRYPTO_w_lock(CRYPTO_LOCK_RAND2);
-       locking_thread = CRYPTO_thread_id();
+       CRYPTO_THREADID_current(&locking_threadid);
        CRYPTO_w_unlock(CRYPTO_LOCK_RAND2);
        crypto_lock_rand = 1;
 
@@ -510,7 +513,7 @@ static int ssleay_rand_bytes(unsigned char *buf, int num)
 
 /* pseudo-random bytes that are guaranteed to be unique but not
    unpredictable */
-static int ssleay_rand_pseudo_bytes(unsigned char *buf, int num) 
+static int ssleay_rand_pseudo_bytes(unsigned char *buf, size_t num) 
        {
        int ret;
        unsigned long err;
@@ -521,22 +524,24 @@ static int ssleay_rand_pseudo_bytes(unsigned char *buf, int num)
                err = ERR_peek_error();
                if (ERR_GET_LIB(err) == ERR_LIB_RAND &&
                    ERR_GET_REASON(err) == RAND_R_PRNG_NOT_SEEDED)
-                       (void)ERR_get_error();
+                       ERR_clear_error();
                }
        return (ret);
        }
 
 static int ssleay_rand_status(void)
        {
+       CRYPTO_THREADID cur;
        int ret;
        int do_not_lock;
 
+       CRYPTO_THREADID_current(&cur);
        /* check if we already have the lock
         * (could happen if a RAND_poll() implementation calls RAND_status()) */
        if (crypto_lock_rand)
                {
                CRYPTO_r_lock(CRYPTO_LOCK_RAND2);
-               do_not_lock = (locking_thread == CRYPTO_thread_id());
+               do_not_lock = !CRYPTO_THREADID_cmp(&locking_threadid, &cur);
                CRYPTO_r_unlock(CRYPTO_LOCK_RAND2);
                }
        else
@@ -548,7 +553,7 @@ static int ssleay_rand_status(void)
                
                /* prevent ssleay_rand_bytes() from trying to obtain the lock again */
                CRYPTO_w_lock(CRYPTO_LOCK_RAND2);
-               locking_thread = CRYPTO_thread_id();
+               CRYPTO_THREADID_cpy(&locking_threadid, &cur);
                CRYPTO_w_unlock(CRYPTO_LOCK_RAND2);
                crypto_lock_rand = 1;
                }