summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--CHANGES65
-rw-r--r--apps/apps.h4
-rw-r--r--crypto/bn/bn.h7
-rw-r--r--crypto/bn/bn_blind.c17
-rw-r--r--crypto/bn/exptest.c2
-rw-r--r--crypto/cryptlib.c97
-rw-r--r--crypto/crypto.h31
-rw-r--r--crypto/dsa/dsatest.c2
-rw-r--r--crypto/ec/ectest.c2
-rw-r--r--crypto/ecdh/ecdhtest.c2
-rw-r--r--crypto/ecdsa/ecdsatest.c2
-rw-r--r--crypto/engine/enginetest.c2
-rw-r--r--crypto/err/err.c40
-rw-r--r--crypto/err/err.h7
-rw-r--r--crypto/err/err_prn.c4
-rw-r--r--crypto/evp/evp_test.c2
-rw-r--r--crypto/mem_dbg.c92
-rw-r--r--crypto/rand/md_rand.c17
-rw-r--r--crypto/rsa/rsa_eay.c4
-rw-r--r--crypto/rsa/rsa_lib.c3
-rw-r--r--crypto/rsa/rsa_test.c2
-rw-r--r--doc/crypto/BN_BLINDING_new.pod31
-rw-r--r--doc/crypto/bn.pod6
-rw-r--r--doc/crypto/threads.pod8
-rw-r--r--ssl/ssltest.c2
25 files changed, 161 insertions, 290 deletions
diff --git a/CHANGES b/CHANGES
index 074538ccf6..0d47c6044e 100644
--- a/CHANGES
+++ b/CHANGES
@@ -20,63 +20,6 @@
STACK, TXT_DB, bsearch, qsort.
[Ben Laurie]
- *) Not all of this is true any longer.
- Will have to be updated to reflect all subsequent changes to cryptlib.c.
- --bodo
-
-
- To support arbitrarily-typed thread IDs, deprecate the existing
- type-specific APIs for a general purpose CRYPTO_THREADID
- interface. Applications can choose the thread ID
- callback type it wishes to register, as before;
-
- void CRYPTO_set_id_callback(unsigned long (*func)(void));
- void CRYPTO_set_idptr_callback(void *(*func)(void));
-
- but retrieval, copies, and comparisons of thread IDs are via
- type-independent interfaces;
-
- void CRYPTO_THREADID_set(CRYPTO_THREADID *id);
- void CRYPTO_THREADID_cmp(const CRYPTO_THREADID *id1,
- const CRYPTO_THREADID *id2);
- void CRYPTO_THREADID_cpy(CRYPTO_THREADID *dst,
- const CRYPTO_THREADID *src);
-
- Also, for code that needs a thread ID "value" for use in
- hash-tables or logging, a "hash" is available by;
-
- unsigned long CRYPTO_THREADID_hash(const CRYPTO_THREADID *id);
-
- This hash value is likely to be the thread ID anyway, but
- otherwise it will be unique if possible or as collision-free as
- possible if uniqueness can't be guaranteed on the target
- architecture.
-
- The following functions are deprecated;
- unsigned long (*CRYPTO_get_id_callback(void))(void);
- unsigned long CRYPTO_thread_id(void);
-
- As a consequence of the above, there are similar deprecations of
- BN_BLINDING functions in favour of CRYPTO_THREADID-based
- alternatives;
-
- #ifndef OPENSSL_NO_DEPRECATED
- unsigned long BN_BLINDING_get_thread_id(const BN_BLINDING *);
- void BN_BLINDING_set_thread_id(BN_BLINDING *, unsigned long);
- #endif
- void BN_BLINDING_set_thread(BN_BLINDING *);
- int BN_BLINDING_cmp_thread(const BN_BLINDING *, const
- CRYPTO_THREADID *);
-
- Also, the ERR_remove_state(int pid) API has been deprecated;
-
- #ifndef OPENSSL_NO_DEPRECATED
- void ERR_remove_state(unsigned long pid)
- #endif
- void ERR_remove_thread_state(CRYPTO_THREADID *tid);
-
- [Geoff Thorpe]
-
*) Initial support for Cryptographic Message Syntax (aka CMS) based
on RFC3850, RFC3851 and RFC3852. New cms directory and cms utility,
support for data, signedData, compressedData, digestedData and
@@ -383,14 +326,6 @@
callback is &errno.
[Bodo Moeller]
- -- NOTE -- this change has been reverted and replaced with a
- type-independent wrapper (ie. applications do not have to check
- two type-specific thread ID representations as implied in this
- change note). However, the "idptr" callback form described here
- can still be registered. Please see the more recent CHANGES note
- regarding CRYPTO_THREADID. [Geoff Thorpe]
- -- NOTE --
-
*) Change the array representation of binary polynomials: the list
of degrees of non-zero coefficients is now terminated with -1.
Previously it was terminated with 0, which was also part of the
diff --git a/apps/apps.h b/apps/apps.h
index bcf597f3ef..93d874976b 100644
--- a/apps/apps.h
+++ b/apps/apps.h
@@ -181,7 +181,7 @@ extern BIO *bio_err;
# define apps_shutdown() \
do { CONF_modules_unload(1); destroy_ui_method(); \
OBJ_cleanup(); EVP_cleanup(); ENGINE_cleanup(); \
- CRYPTO_cleanup_all_ex_data(); ERR_remove_thread_state(NULL); \
+ CRYPTO_cleanup_all_ex_data(); ERR_remove_state(0); \
ERR_free_strings(); COMP_zlib_cleanup();} while(0)
# else
# define apps_startup() \
@@ -191,7 +191,7 @@ extern BIO *bio_err;
# define apps_shutdown() \
do { CONF_modules_unload(1); destroy_ui_method(); \
OBJ_cleanup(); EVP_cleanup(); \
- CRYPTO_cleanup_all_ex_data(); ERR_remove_thread_state(NULL); \
+ CRYPTO_cleanup_all_ex_data(); ERR_remove_state(0); \
ERR_free_strings(); } while(0)
# endif
#endif
diff --git a/crypto/bn/bn.h b/crypto/bn/bn.h
index 65202ae9f2..de2cfcf93c 100644
--- a/crypto/bn/bn.h
+++ b/crypto/bn/bn.h
@@ -129,7 +129,6 @@
#ifndef OPENSSL_NO_FP_API
#include <stdio.h> /* FILE */
#endif
-#include <openssl/crypto.h>
#include <openssl/ossl_typ.h>
#ifdef __cplusplus
@@ -565,12 +564,10 @@ int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *);
int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b, BN_CTX *);
-#ifndef OPENSSL_NO_DEPRECATED
unsigned long BN_BLINDING_get_thread_id(const BN_BLINDING *);
void BN_BLINDING_set_thread_id(BN_BLINDING *, unsigned long);
-#endif
-void BN_BLINDING_set_thread(BN_BLINDING *);
-int BN_BLINDING_cmp_thread(const BN_BLINDING *, const CRYPTO_THREADID *);
+void *BN_BLINDING_get_thread_idptr(const BN_BLINDING *);
+void BN_BLINDING_set_thread_idptr(BN_BLINDING *, void *);
unsigned long BN_BLINDING_get_flags(const BN_BLINDING *);
void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long);
BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
diff --git a/crypto/bn/bn_blind.c b/crypto/bn/bn_blind.c
index fa48470a57..e9b6173e24 100644
--- a/crypto/bn/bn_blind.c
+++ b/crypto/bn/bn_blind.c
@@ -121,13 +121,10 @@ struct bn_blinding_st
BIGNUM *Ai;
BIGNUM *e;
BIGNUM *mod; /* just a reference */
-/* FIXME: should really try to remove these, but the deprecated APIs that are
- * using them would need to be fudged somehow. */
-#ifndef OPENSSL_NO_DEPRECATED
unsigned long thread_id; /* added in OpenSSL 0.9.6j and 0.9.7b;
* used only by crypto/rsa/rsa_eay.c, rsa_lib.c */
-#endif
- CRYPTO_THREADID tid;
+ void *thread_idptr; /* added in OpenSSL 0.9.9;
+ * used only by crypto/rsa/rsa_eay.c, rsa_lib.c */
unsigned int counter;
unsigned long flags;
BN_MONT_CTX *m_ctx;
@@ -268,7 +265,6 @@ int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b, BN_CTX *ct
return(ret);
}
-#ifndef OPENSSL_NO_DEPRECATED
unsigned long BN_BLINDING_get_thread_id(const BN_BLINDING *b)
{
return b->thread_id;
@@ -278,16 +274,15 @@ void BN_BLINDING_set_thread_id(BN_BLINDING *b, unsigned long n)
{
b->thread_id = n;
}
-#endif
-void BN_BLINDING_set_thread(BN_BLINDING *b)
+void *BN_BLINDING_get_thread_idptr(const BN_BLINDING *b)
{
- CRYPTO_THREADID_set(&b->tid);
+ return b->thread_idptr;
}
-int BN_BLINDING_cmp_thread(const BN_BLINDING *b, const CRYPTO_THREADID *tid)
+void BN_BLINDING_set_thread_idptr(BN_BLINDING *b, void *p)
{
- return CRYPTO_THREADID_cmp(&b->tid, tid);
+ b->thread_idptr = p;
}
unsigned long BN_BLINDING_get_flags(const BN_BLINDING *b)
diff --git a/crypto/bn/exptest.c b/crypto/bn/exptest.c
index 074a8e882a..89ebcc8711 100644
--- a/crypto/bn/exptest.c
+++ b/crypto/bn/exptest.c
@@ -187,7 +187,7 @@ int main(int argc, char *argv[])
BN_free(b);
BN_free(m);
BN_CTX_free(ctx);
- ERR_remove_thread_state(NULL);
+ ERR_remove_state(0);
CRYPTO_mem_leaks(out);
BIO_free(out);
printf(" done\n");
diff --git a/crypto/cryptlib.c b/crypto/cryptlib.c
index b8c2ee80f6..b89bd7a6fa 100644
--- a/crypto/cryptlib.c
+++ b/crypto/cryptlib.c
@@ -414,60 +414,14 @@ void CRYPTO_set_add_lock_callback(int (*func)(int *num,int mount,int type,
add_lock_callback=func;
}
-/* Thread IDs. So ... if we build without OPENSSL_NO_DEPRECATED, then we leave
- * the existing implementations and just layer CRYPTO_THREADID_[get|cmp]
- * harmlessly on top. Otherwise, we only use 'id_callback' or 'idptr_callback'
- * if they're non-NULL, ie. we ignore CRYPTO_thread_id()'s fallbacks and we
- * move CRYPTO_thread_idptr()'s "&errno" fallback trick into
- * CRYPTO_THREADID_set(). */
-
-void CRYPTO_set_id_callback(unsigned long (*func)(void))
- {
- id_callback=func;
- }
-
-void CRYPTO_set_idptr_callback(void *(*func)(void))
- {
- idptr_callback=func;
- }
-
-void CRYPTO_THREADID_set(CRYPTO_THREADID *id)
- {
- if (id_callback)
- id->ulong = id_callback();
- else
- id->ulong = 0;
-
- if (idptr_callback)
- id->ptr = idptr_callback();
- else
- id->ptr = &errno;
- }
-
-int CRYPTO_THREADID_cmp(const CRYPTO_THREADID *id1, const CRYPTO_THREADID *id2)
- {
- if (id1->ulong != id2->ulong)
- return ((id1->ulong < id2->ulong) ? -1 : 1);
- if (id1->ptr != id2->ptr)
- return ((id1->ptr < id2->ptr) ? -1 : 1);
- return 0;
- }
-
-unsigned long CRYPTO_THREADID_hash(const CRYPTO_THREADID *id)
- {
- /* will need further processing to arrive at a good hash (mem_dbg.c uses this) */
- return id->ulong + (unsigned long)id->ptr;
- }
-
-void CRYPTO_THREADID_cpy(CRYPTO_THREADID *dst, const CRYPTO_THREADID *src)
+unsigned long (*CRYPTO_get_id_callback(void))(void)
{
- memcpy(dst, src, sizeof(*src));
+ return(id_callback);
}
-#ifndef OPENSSL_NO_DEPRECATED
-unsigned long (*CRYPTO_get_id_callback(void))(void)
+void CRYPTO_set_id_callback(unsigned long (*func)(void))
{
- return(id_callback);
+ id_callback=func;
}
unsigned long CRYPTO_thread_id(void)
@@ -492,14 +446,34 @@ unsigned long CRYPTO_thread_id(void)
ret=id_callback();
return(ret);
}
-#endif
+
+void *(*CRYPTO_get_idptr_callback(void))(void)
+ {
+ return(idptr_callback);
+ }
+
+void CRYPTO_set_idptr_callback(void *(*func)(void))
+ {
+ idptr_callback=func;
+ }
+
+void *CRYPTO_thread_idptr(void)
+ {
+ void *ret=NULL;
+
+ if (idptr_callback == NULL)
+ ret = &errno;
+ else
+ ret = idptr_callback();
+
+ return ret;
+ }
void CRYPTO_lock(int mode, int type, const char *file, int line)
{
#ifdef LOCK_DEBUG
{
char *rw_text,*operation_text;
- CRYPTO_THREADID tid;
if (mode & CRYPTO_LOCK)
operation_text="lock ";
@@ -515,9 +489,8 @@ void CRYPTO_lock(int mode, int type, const char *file, int line)
else
rw_text="ERROR";
- CRYPTO_THREADID_set(&tid);
- fprintf(stderr,"lock:%08lx:(%s)%s %-18s %s:%d\n",
- CRYPTO_THREADID_hash(&tid), rw_text, operation_text,
+ fprintf(stderr,"lock:%08lx/%08p:(%s)%s %-18s %s:%d\n",
+ CRYPTO_thread_id(), CRYPTO_thread_idptr(), rw_text, operation_text,
CRYPTO_get_lock_name(type), file, line);
}
#endif
@@ -544,10 +517,6 @@ int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
int line)
{
int ret = 0;
-#ifdef LOCK_DEBUG
- CRYPTO_THREADID tid;
- CRYPTO_THREADID_set(&tid);
-#endif
if (add_lock_callback != NULL)
{
@@ -557,8 +526,9 @@ int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
ret=add_lock_callback(pointer,amount,type,file,line);
#ifdef LOCK_DEBUG
- fprintf(stderr,"ladd:%08lx:%2d+%2d->%2d %-18s %s:%d\n",
- CRYPTO_THREADID_hash(&tid), before,amount,ret,
+ fprintf(stderr,"ladd:%08lx/%0xp:%2d+%2d->%2d %-18s %s:%d\n",
+ CRYPTO_thread_id(), CRYPTO_thread_idptr(),
+ before,amount,ret,
CRYPTO_get_lock_name(type),
file,line);
#endif
@@ -569,8 +539,9 @@ int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
ret= *pointer+amount;
#ifdef LOCK_DEBUG
- fprintf(stderr,"ladd:%08lx:%2d+%2d->%2d %-18s %s:%d\n",
- CRYPTO_THREADID_hash(&tid), *pointer,amount,ret,
+ fprintf(stderr,"ladd:%08lx/%0xp:%2d+%2d->%2d %-18s %s:%d\n",
+ CRYPTO_thread_id(), CRYPTO_thread_idptr(),
+ *pointer,amount,ret,
CRYPTO_get_lock_name(type),
file,line);
#endif
diff --git a/crypto/crypto.h b/crypto/crypto.h
index 4fa540527e..8bc927b429 100644
--- a/crypto/crypto.h
+++ b/crypto/crypto.h
@@ -301,17 +301,6 @@ typedef struct crypto_ex_data_func_st
DECLARE_STACK_OF(CRYPTO_EX_DATA_FUNCS)
-/* This structure is exposed to allow it to be used without dynamic allocation,
- * however it exists to encapsulate the different ways of representing "thread
- * ID"s (given that applications provide the thread implementation via
- * callbacks). So treat this type as opaque if you don't want your code to fall
- * apart when someone decides to extend this in some way. */
-typedef struct crypto_threadid
- {
- unsigned long ulong;
- void *ptr;
- } CRYPTO_THREADID;
-
/* Per class, we have a STACK of CRYPTO_EX_DATA_FUNCS for each CRYPTO_EX_DATA
* entry.
*/
@@ -432,26 +421,12 @@ void CRYPTO_set_add_lock_callback(int (*func)(int *num,int mount,int type,
const char *file, int line));
int (*CRYPTO_get_add_lock_callback(void))(int *num,int mount,int type,
const char *file,int line);
-/* Implement "thread ID" via callback, choose the prototype that matches your
- * thread implementation. */
void CRYPTO_set_id_callback(unsigned long (*func)(void));
-void CRYPTO_set_idptr_callback(void *(*func)(void));
-/* Records the thread ID of the currently executing thread */
-void CRYPTO_THREADID_set(CRYPTO_THREADID *id);
-/* Compares two thread IDs. If the underlying notion of thread ID is linear,
- * this returns -1, 0, or +1 to imply strict-ordering (as other ***_cmp()
- * functions do). Otherwise, zero means equal, non-zero means not equal. */
-int CRYPTO_THREADID_cmp(const CRYPTO_THREADID *id1, const CRYPTO_THREADID *id2);
-/* When you need "a number", eg. for hashing, use this. */
-unsigned long CRYPTO_THREADID_hash(const CRYPTO_THREADID *id);
-/* Copy a threadid */
-void CRYPTO_THREADID_cpy(CRYPTO_THREADID *dst, const CRYPTO_THREADID *src);
-#ifndef OPENSSL_NO_DEPRECATED
-/* Deprecated interfaces - these presume you know exactly what's going on under
- * the covers. Better to migrate to the CRYPTO_THREADID_***() form. */
unsigned long (*CRYPTO_get_id_callback(void))(void);
unsigned long CRYPTO_thread_id(void);
-#endif
+void CRYPTO_set_idptr_callback(void *(*func)(void));
+void *(*CRYPTO_get_idptr_callback(void))(void);
+void *CRYPTO_thread_idptr(void);
const char *CRYPTO_get_lock_name(int type);
int CRYPTO_add_lock(int *pointer,int amount,int type, const char *file,
diff --git a/crypto/dsa/dsatest.c b/crypto/dsa/dsatest.c
index edffd24e6b..5a699ca5d3 100644
--- a/crypto/dsa/dsatest.c
+++ b/crypto/dsa/dsatest.c
@@ -222,7 +222,7 @@ end:
ERR_print_errors(bio_err);
if (dsa != NULL) DSA_free(dsa);
CRYPTO_cleanup_all_ex_data();
- ERR_remove_thread_state(NULL);
+ ERR_remove_state(0);
ERR_free_strings();
CRYPTO_mem_leaks(bio_err);
if (bio_err != NULL)
diff --git a/crypto/ec/ectest.c b/crypto/ec/ectest.c
index 7509cb9c7c..b74d6435be 100644
--- a/crypto/ec/ectest.c
+++ b/crypto/ec/ectest.c
@@ -1326,7 +1326,7 @@ int main(int argc, char *argv[])
#endif
CRYPTO_cleanup_all_ex_data();
ERR_free_strings();
- ERR_remove_thread_state(NULL);
+ ERR_remove_state(0);
CRYPTO_mem_leaks_fp(stderr);
return 0;
diff --git a/crypto/ecdh/ecdhtest.c b/crypto/ecdh/ecdhtest.c
index 212a87efa4..1575006b51 100644
--- a/crypto/ecdh/ecdhtest.c
+++ b/crypto/ecdh/ecdhtest.c
@@ -343,7 +343,7 @@ err:
if (ctx) BN_CTX_free(ctx);
BIO_free(out);
CRYPTO_cleanup_all_ex_data();
- ERR_remove_thread_state(NULL);
+ ERR_remove_state(0);
CRYPTO_mem_leaks_fp(stderr);
EXIT(ret);
return(ret);
diff --git a/crypto/ecdsa/ecdsatest.c b/crypto/ecdsa/ecdsatest.c
index aa4e1481a8..b07e31252b 100644
--- a/crypto/ecdsa/ecdsatest.c
+++ b/crypto/ecdsa/ecdsatest.c
@@ -490,7 +490,7 @@ err:
if (ret)
ERR_print_errors(out);
CRYPTO_cleanup_all_ex_data();
- ERR_remove_thread_state(NULL);
+ ERR_remove_state(0);
ERR_free_strings();
CRYPTO_mem_leaks(out);
if (out != NULL)
diff --git a/crypto/engine/enginetest.c b/crypto/engine/enginetest.c
index 3c1d2b4fbe..cf82f490db 100644
--- a/crypto/engine/enginetest.c
+++ b/crypto/engine/enginetest.c
@@ -276,7 +276,7 @@ end:
ENGINE_cleanup();
CRYPTO_cleanup_all_ex_data();
ERR_free_strings();
- ERR_remove_thread_state(NULL);
+ ERR_remove_state(0);
CRYPTO_mem_leaks_fp(stderr);
return to_return;
}
diff --git a/crypto/err/err.c b/crypto/err/err.c
index b96e675618..f615cb4766 100644
--- a/crypto/err/err.c
+++ b/crypto/err/err.c
@@ -429,13 +429,13 @@ static ERR_STRING_DATA *int_err_del_item(ERR_STRING_DATA *d)
static unsigned long err_state_hash(const ERR_STATE *a)
{
- return CRYPTO_THREADID_hash(&a->tid);
+ return (a->pid + (unsigned long)a->pidptr) * 13;
}
static IMPLEMENT_LHASH_HASH_FN(err_state, ERR_STATE)
static int err_state_cmp(const ERR_STATE *a, const ERR_STATE *b)
{
- return CRYPTO_THREADID_cmp(&a->tid, &b->tid);
+ return (a->pid != b->pid) || (a->pidptr != b->pidptr);
}
static IMPLEMENT_LHASH_COMP_FN(err_state, ERR_STATE)
@@ -980,37 +980,40 @@ const char *ERR_reason_error_string(unsigned long e)
return((p == NULL)?NULL:p->string);
}
-void ERR_remove_thread_state(CRYPTO_THREADID *tid)
+void ERR_remove_state(unsigned long pid)
{
ERR_STATE tmp;
+ void *pidptr;
- if (tid)
- CRYPTO_THREADID_cpy(&tmp.tid, tid);
- else
- CRYPTO_THREADID_set(&tmp.tid);
err_fns_check();
+ if (pid != 0)
+ pidptr = &errno;
+ else
+ {
+ pid = CRYPTO_thread_id();
+ pidptr = CRYPTO_thread_idptr();
+ }
+
+ tmp.pid=pid;
+ tmp.pidptr=pidptr;
/* thread_del_item automatically destroys the LHASH if the number of
* items reaches zero. */
ERRFN(thread_del_item)(&tmp);
}
-#ifndef OPENSSL_NO_DEPRECATED
-void ERR_remove_state(unsigned long pid)
- {
- ERR_remove_thread_state(NULL);
- }
-#endif
-
ERR_STATE *ERR_get_state(void)
{
static ERR_STATE fallback;
- CRYPTO_THREADID tid;
ERR_STATE *ret,tmp,*tmpp=NULL;
int i;
+ unsigned long pid;
+ void *pidptr;
err_fns_check();
- CRYPTO_THREADID_set(&tid);
- CRYPTO_THREADID_cpy(&tmp.tid, &tid);
+ pid = CRYPTO_thread_id();
+ pidptr = CRYPTO_thread_idptr();
+ tmp.pid = pid;
+ tmp.pidptr = pidptr;
ret=ERRFN(thread_get_item)(&tmp);
/* ret == the error state, if NULL, make a new one */
@@ -1018,7 +1021,8 @@ ERR_STATE *ERR_get_state(void)
{
ret=(ERR_STATE *)OPENSSL_malloc(sizeof(ERR_STATE));
if (ret == NULL) return(&fallback);
- CRYPTO_THREADID_cpy(&ret->tid, &tid);
+ ret->pid=pid;
+ ret->pidptr=pidptr;
ret->top=0;
ret->bottom=0;
for (i=0; i<ERR_NUM_ERRORS; i++)
diff --git a/crypto/err/err.h b/crypto/err/err.h
index 99340c8294..942f820a02 100644
--- a/crypto/err/err.h
+++ b/crypto/err/err.h
@@ -147,10 +147,8 @@ extern "C" {
#define ERR_NUM_ERRORS 16
typedef struct err_state_st
{
-#ifndef OPENSSL_NO_DEPRECATED
unsigned long pid;
-#endif
- CRYPTO_THREADID tid;
+ void *pidptr; /* new in OpenSSL 0.9.9 */
int err_flags[ERR_NUM_ERRORS];
unsigned long err_buffer[ERR_NUM_ERRORS];
char *err_data[ERR_NUM_ERRORS];
@@ -353,10 +351,7 @@ void ERR_load_ERR_strings(void);
void ERR_load_crypto_strings(void);
void ERR_free_strings(void);
-void ERR_remove_thread_state(CRYPTO_THREADID *tid);
-#ifndef OPENSSL_NO_DEPRECATED
void ERR_remove_state(unsigned long pid); /* if zero we look it up */
-#endif
ERR_STATE *ERR_get_state(void);
#ifndef OPENSSL_NO_LHASH
diff --git a/crypto/err/err_prn.c b/crypto/err/err_prn.c
index 6515d10c07..2224a901e5 100644
--- a/crypto/err/err_prn.c
+++ b/crypto/err/err_prn.c
@@ -72,10 +72,8 @@ void ERR_print_errors_cb(int (*cb)(const char *str, size_t len, void *u),
const char *file,*data;
int line,flags;
unsigned long es;
- CRYPTO_THREADID tid;
- CRYPTO_THREADID_set(&tid);
- es = CRYPTO_THREADID_hash(&tid);
+ es=CRYPTO_thread_id();
while ((l=ERR_get_error_line_data(&file,&line,&data,&flags)) != 0)
{
ERR_error_string_n(l, buf, sizeof buf);
diff --git a/crypto/evp/evp_test.c b/crypto/evp/evp_test.c
index b8c9235d3e..bb6f02c2e9 100644
--- a/crypto/evp/evp_test.c
+++ b/crypto/evp/evp_test.c
@@ -441,7 +441,7 @@ int main(int argc,char **argv)
#endif
EVP_cleanup();
CRYPTO_cleanup_all_ex_data();
- ERR_remove_thread_state(NULL);
+ ERR_remove_state(0);
ERR_free_strings();
CRYPTO_mem_leaks_fp(stderr);
diff --git a/crypto/mem_dbg.c b/crypto/mem_dbg.c
index 939cee1aee..72859f8992 100644
--- a/crypto/mem_dbg.c
+++ b/crypto/mem_dbg.c
@@ -150,7 +150,8 @@ typedef struct app_mem_info_st
* CRYPTO_remove_all_info() to pop all entries.
*/
{
- CRYPTO_THREADID threadid;
+ unsigned long thread_id;
+ void *thread_idptr;
const char *file;
int line;
const char *info;
@@ -175,7 +176,8 @@ typedef struct mem_st
int num;
const char *file;
int line;
- CRYPTO_THREADID threadid;
+ unsigned long thread_id;
+ void *thread_idptr;
unsigned long order;
time_t time;
APP_INFO *app_info;
@@ -196,9 +198,12 @@ static unsigned int num_disable = 0; /* num_disable > 0
* mh_mode == CRYPTO_MEM_CHECK_ON (w/o ..._ENABLE)
*/
-/* Valid iff num_disable > 0. CRYPTO_LOCK_MALLOC2 is locked exactly in this
- * case (by the thread named in disabling_threadid). */
-static CRYPTO_THREADID disabling_threadid;
+/* The following two variables, disabling_thread_id and disabling_thread_idptr,
+ * are valid iff num_disable > 0. CRYPTO_LOCK_MALLOC2 is locked exactly in
+ * this case (by the thread named in disabling_thread_id / disabling_thread_idptr).
+ */
+static unsigned long disabling_thread_id = 0;
+static void *disabling_thread_idptr = NULL;
static void app_info_free(APP_INFO *inf)
{
@@ -235,10 +240,9 @@ int CRYPTO_mem_ctrl(int mode)
case CRYPTO_MEM_CHECK_DISABLE: /* aka MemCheck_off() */
if (mh_mode & CRYPTO_MEM_CHECK_ON)
{
- CRYPTO_THREADID tid;
- CRYPTO_THREADID_set(&tid);
- if (!num_disable || CRYPTO_THREADID_cmp(&tid,
- &disabling_threadid))
+ if (!num_disable
+ || (disabling_thread_id != CRYPTO_thread_id())
+ || (disabling_thread_idptr != CRYPTO_thread_idptr())) /* otherwise we already have the MALLOC2 lock */
{
/* Long-time lock CRYPTO_LOCK_MALLOC2 must not be claimed while
* we're holding CRYPTO_LOCK_MALLOC, or we'll deadlock if
@@ -256,7 +260,8 @@ int CRYPTO_mem_ctrl(int mode)
CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
mh_mode &= ~CRYPTO_MEM_CHECK_ENABLE;
- CRYPTO_THREADID_set(&disabling_threadid);
+ disabling_thread_id=CRYPTO_thread_id();
+ disabling_thread_idptr=CRYPTO_thread_idptr();
}
num_disable++;
}
@@ -289,12 +294,11 @@ int CRYPTO_is_mem_check_on(void)
if (mh_mode & CRYPTO_MEM_CHECK_ON)
{
- CRYPTO_THREADID tid;
- CRYPTO_THREADID_set(&tid);
CRYPTO_r_lock(CRYPTO_LOCK_MALLOC);
- ret = (mh_mode & CRYPTO_MEM_CHECK_ENABLE) ||
- CRYPTO_THREADID_cmp(&tid, &disabling_threadid);
+ ret = (mh_mode & CRYPTO_MEM_CHECK_ENABLE)
+ || (disabling_thread_id != CRYPTO_thread_id())
+ || (disabling_thread_idptr != CRYPTO_thread_idptr());
CRYPTO_r_unlock(CRYPTO_LOCK_MALLOC);
}
@@ -340,15 +344,20 @@ static IMPLEMENT_LHASH_HASH_FN(mem, MEM)
/* static int app_info_cmp(APP_INFO *a, APP_INFO *b) */
static int app_info_cmp(const void *a_void, const void *b_void)
{
- return CRYPTO_THREADID_cmp(&((const APP_INFO *)a_void)->threadid,
- &((const APP_INFO *)b_void)->threadid);
+ return (((const APP_INFO *)a_void)->thread_id != ((const APP_INFO *)b_void)->thread_id)
+ || (((const APP_INFO *)a_void)->thread_idptr != ((const APP_INFO *)b_void)->thread_idptr);
}
static IMPLEMENT_LHASH_COMP_FN(app_info, APP_INFO)
static unsigned long app_info_hash(const APP_INFO *a)
{
+ unsigned long id1, id2;
unsigned long ret;
- ret = CRYPTO_THREADID_hash(&a->threadid);
+
+ id1=(unsigned long)a->thread_id;
+ id2=(unsigned long)a->thread_idptr;
+ ret = id1 + id2;
+
ret=ret*17851+(ret>>14)*7+(ret>>4)*251;
return(ret);
}
@@ -361,7 +370,8 @@ static APP_INFO *pop_info(void)
if (amih != NULL)
{
- CRYPTO_THREADID_set(&tmp.threadid);
+ tmp.thread_id=CRYPTO_thread_id();
+ tmp.thread_idptr=CRYPTO_thread_idptr();
if ((ret=lh_APP_INFO_delete(amih,&tmp)) != NULL)
{
APP_INFO *next=ret->next;
@@ -372,11 +382,10 @@ static APP_INFO *pop_info(void)
lh_APP_INFO_insert(amih,next);
}
#ifdef LEVITTE_DEBUG_MEM
- if (CRYPTO_THREADID_cmp(&ret->threadid, &tmp.threadid))
+ if (ret->thread_id != tmp.thread_id || ret->thread_idptr != tmp.thread_idptr)
{
- fprintf(stderr, "pop_info(): deleted info has other thread ID (%lu) than the current thread (%lu)!!!!\n",
- CRYPTO_THREADID_hash(&ret->threadid),
- CRYPTO_THREADID_hash(&tmp.threadid));
+ fprintf(stderr, "pop_info(): deleted info has other thread ID (%lu/%p) than the current thread (%lu/%p)!!!!\n",
+ ret->thread_id, ret->thread_idptr, tmp.thread_id, tmp.thread_idptr);
abort();
}
#endif
@@ -416,7 +425,8 @@ int CRYPTO_push_info_(const char *info, const char *file, int line)
}
}
- CRYPTO_THREADID_set(&ami->threadid);
+ ami->thread_id=CRYPTO_thread_id();
+ ami->thread_idptr=CRYPTO_thread_idptr();
ami->file=file;
ami->line=line;
ami->info=info;
@@ -426,11 +436,10 @@ int CRYPTO_push_info_(const char *info, const char *file, int line)
if ((amim=lh_APP_INFO_insert(amih,ami)) != NULL)
{
#ifdef LEVITTE_DEBUG_MEM
- if (CRYPTO_THREADID_cmp(&ami->threadid, &amim->threadid))
+ if (ami->thread_id != amim->thread_id || ami->thread_idptr != amim->thread_idptr)
{
- fprintf(stderr, "CRYPTO_push_info(): previous info has other thread ID (%lu) than the current thread (%lu)!!!!\n",
- CRYPTO_THREADID_hash(&amim->threadid),
- CRYPTO_THREADID_hash(&ami->threadid));
+ fprintf(stderr, "CRYPTO_push_info(): previous info has other thread ID (%lu/%p) than the current thread (%lu/%p)!!!!\n",
+ amim->thread_id, amim->thread_idptr, ami->thread_id, ami->thread_idptr);
abort();
}
#endif
@@ -515,7 +524,16 @@ void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line,
m->file=file;
m->line=line;
m->num=num;
- CRYPTO_THREADID_set(&m->threadid);
+ if (options & V_CRYPTO_MDEBUG_THREAD)
+ {
+ m->thread_id=CRYPTO_thread_id();
+ m->thread_idptr=CRYPTO_thread_idptr();
+ }
+ else
+ {
+ m->thread_id=0;
+ m->thread_idptr=NULL;
+ }
if (order == break_order_num)
{
@@ -534,7 +552,8 @@ void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line,
else
m->time=0;
- CRYPTO_THREADID_set(&m->threadid);
+ tmp.thread_id=CRYPTO_thread_id();
+ tmp.thread_idptr=CRYPTO_thread_idptr();
m->app_info=NULL;
if (amih != NULL
&& (amim=lh_APP_INFO_retrieve(amih,&tmp)) != NULL)
@@ -663,7 +682,8 @@ static void print_leak_doall_arg(const MEM *m, MEM_LEAK *l)
APP_INFO *amip;
int ami_cnt;
struct tm *lcl = NULL;
- CRYPTO_THREADID tid;
+ unsigned long ti;
+ void *tip;
#define BUF_REMAIN (sizeof buf - (size_t)(bufp - buf))
@@ -685,8 +705,7 @@ static void print_leak_doall_arg(const MEM *m, MEM_LEAK *l)
if (options & V_CRYPTO_MDEBUG_THREAD)
{
- BIO_snprintf(bufp, BUF_REMAIN, "thread=%lu, ",
- CRYPTO_THREADID_hash(&m->threadid));
+ BIO_snprintf(bufp, BUF_REMAIN, "thread=%lu/%p, ", m->thread_id, m->thread_idptr);
bufp += strlen(bufp);
}
@@ -703,7 +722,8 @@ static void print_leak_doall_arg(const MEM *m, MEM_LEAK *l)
ami_cnt=0;
if (!amip)
return;
- CRYPTO_THREADID_set(&tid);
+ ti=amip->thread_id;
+ tip=amip->thread_idptr;
do
{
@@ -713,8 +733,8 @@ static void print_leak_doall_arg(const MEM *m, MEM_LEAK *l)
ami_cnt++;
memset(buf,'>',ami_cnt);
BIO_snprintf(buf + ami_cnt, sizeof buf - ami_cnt,
- " thread=%lu, file=%s, line=%d, info=\"",
- CRYPTO_THREADID_hash(&amip->threadid), amip->file, amip->line);
+ " thread=%lu/%p, file=%s, line=%d, info=\"",
+ amip->thread_id, amip->thread_idptr, amip->file, amip->line);
buf_len=strlen(buf);
info_len=strlen(amip->info);
if (128 - buf_len - 3 < info_len)
@@ -734,7 +754,7 @@ static void print_leak_doall_arg(const MEM *m, MEM_LEAK *l)
amip = amip->next;
}
- while(amip && !CRYPTO_THREADID_cmp(&amip->threadid, &tid));
+ while(amip && amip->thread_id == ti && amip->thread_idptr == tip);
#ifdef LEVITTE_DEBUG_MEM
if (amip)
diff --git a/crypto/rand/md_rand.c b/crypto/rand/md_rand.c
index 59535b9e70..cfc78774f7 100644
--- a/crypto/rand/md_rand.c
+++ b/crypto/rand/md_rand.c
@@ -145,7 +145,8 @@ static unsigned int crypto_lock_rand = 0; /* may be