diff options
-rw-r--r-- | CHANGES | 60 | ||||
-rw-r--r-- | apps/apps.h | 4 | ||||
-rw-r--r-- | crypto/bn/bn.h | 7 | ||||
-rw-r--r-- | crypto/bn/bn_blind.c | 17 | ||||
-rw-r--r-- | crypto/bn/exptest.c | 2 | ||||
-rw-r--r-- | crypto/cryptlib.c | 96 | ||||
-rw-r--r-- | crypto/crypto.h | 32 | ||||
-rw-r--r-- | crypto/dsa/dsatest.c | 2 | ||||
-rw-r--r-- | crypto/ec/ectest.c | 2 | ||||
-rw-r--r-- | crypto/ecdh/ecdhtest.c | 2 | ||||
-rw-r--r-- | crypto/ecdsa/ecdsatest.c | 2 | ||||
-rw-r--r-- | crypto/engine/enginetest.c | 2 | ||||
-rw-r--r-- | crypto/err/err.c | 42 | ||||
-rw-r--r-- | crypto/err/err.h | 7 | ||||
-rw-r--r-- | crypto/err/err_prn.c | 4 | ||||
-rw-r--r-- | crypto/evp/evp_test.c | 2 | ||||
-rw-r--r-- | crypto/mem_dbg.c | 96 | ||||
-rw-r--r-- | crypto/rand/md_rand.c | 17 | ||||
-rw-r--r-- | crypto/rsa/rsa_eay.c | 4 | ||||
-rw-r--r-- | crypto/rsa/rsa_lib.c | 3 | ||||
-rw-r--r-- | crypto/rsa/rsa_test.c | 2 | ||||
-rw-r--r-- | doc/crypto/BN_BLINDING_new.pod | 31 | ||||
-rw-r--r-- | doc/crypto/bn.pod | 6 | ||||
-rw-r--r-- | doc/crypto/threads.pod | 8 | ||||
-rw-r--r-- | ssl/ssltest.c | 2 |
25 files changed, 288 insertions, 164 deletions
@@ -4,6 +4,58 @@ Changes between 0.9.8g and 0.9.9 [xx XXX xxxx] + *) 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 @@ -311,6 +363,14 @@ 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 6786cbd2e0..d446d17a0b 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_state(0); \ + CRYPTO_cleanup_all_ex_data(); ERR_remove_thread_state(NULL); \ 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_state(0); \ + CRYPTO_cleanup_all_ex_data(); ERR_remove_thread_state(NULL); \ ERR_free_strings(); } while(0) # endif #endif diff --git a/crypto/bn/bn.h b/crypto/bn/bn.h index 83f87ffea6..56d9f5f16e 100644 --- a/crypto/bn/bn.h +++ b/crypto/bn/bn.h @@ -129,6 +129,7 @@ #ifndef OPENSSL_NO_FP_API #include <stdio.h> /* FILE */ #endif +#include <openssl/crypto.h> #include <openssl/ossl_typ.h> #ifdef __cplusplus @@ -563,10 +564,12 @@ 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); -void *BN_BLINDING_get_thread_idptr(const BN_BLINDING *); -void BN_BLINDING_set_thread_idptr(BN_BLINDING *, void *); +#endif +void BN_BLINDING_set_thread(BN_BLINDING *); +int BN_BLINDING_cmp_thread(const BN_BLINDING *, const CRYPTO_THREADID *); 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 e9b6173e24..fa48470a57 100644 --- a/crypto/bn/bn_blind.c +++ b/crypto/bn/bn_blind.c @@ -121,10 +121,13 @@ 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 */ - void *thread_idptr; /* added in OpenSSL 0.9.9; - * used only by crypto/rsa/rsa_eay.c, rsa_lib.c */ +#endif + CRYPTO_THREADID tid; unsigned int counter; unsigned long flags; BN_MONT_CTX *m_ctx; @@ -265,6 +268,7 @@ 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; @@ -274,15 +278,16 @@ void BN_BLINDING_set_thread_id(BN_BLINDING *b, unsigned long n) { b->thread_id = n; } +#endif -void *BN_BLINDING_get_thread_idptr(const BN_BLINDING *b) +void BN_BLINDING_set_thread(BN_BLINDING *b) { - return b->thread_idptr; + CRYPTO_THREADID_set(&b->tid); } -void BN_BLINDING_set_thread_idptr(BN_BLINDING *b, void *p) +int BN_BLINDING_cmp_thread(const BN_BLINDING *b, const CRYPTO_THREADID *tid) { - b->thread_idptr = p; + return CRYPTO_THREADID_cmp(&b->tid, tid); } unsigned long BN_BLINDING_get_flags(const BN_BLINDING *b) diff --git a/crypto/bn/exptest.c b/crypto/bn/exptest.c index 89ebcc8711..074a8e882a 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_state(0); + ERR_remove_thread_state(NULL); CRYPTO_mem_leaks(out); BIO_free(out); printf(" done\n"); diff --git a/crypto/cryptlib.c b/crypto/cryptlib.c index 33c70afa33..73bdfd8ce9 100644 --- a/crypto/cryptlib.c +++ b/crypto/cryptlib.c @@ -415,16 +415,61 @@ void CRYPTO_set_add_lock_callback(int (*func)(int *num,int mount,int type, add_lock_callback=func; } -unsigned long (*CRYPTO_get_id_callback(void))(void) - { - return(id_callback); - } +/* 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) + { + memset(id, 0, sizeof(*id)); + if (idptr_callback) + id->ptr = idptr_callback(); + else if (id_callback) + id->ulong = id_callback(); + else + id->ptr = &errno; + } + +int CRYPTO_THREADID_cmp(const CRYPTO_THREADID *id1, const CRYPTO_THREADID *id2) + { + if (id1->ptr != id2->ptr) + return ((id1->ptr < id2->ptr) ? -1 : 1); + if (id1->ulong != id2->ulong) + return ((id1->ulong < id2->ulong ) ? -1 : 1); + return 0; + } + +unsigned long CRYPTO_THREADID_hash(const CRYPTO_THREADID *id) + { + if (idptr_callback || !id_callback) + return (unsigned long)id->ptr; + return id->ulong; + } + +void CRYPTO_THREADID_cpy(CRYPTO_THREADID *dst, const CRYPTO_THREADID *src) + { + memcpy(dst, src, sizeof(*src)); + } + +#ifndef OPENSSL_NO_DEPRECATED +unsigned long (*CRYPTO_get_id_callback(void))(void) + { + return(id_callback); + } + unsigned long CRYPTO_thread_id(void) { unsigned long ret=0; @@ -447,34 +492,14 @@ unsigned long CRYPTO_thread_id(void) ret=id_callback(); return(ret); } - -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; - } +#endif 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 "; @@ -490,8 +515,9 @@ void CRYPTO_lock(int mode, int type, const char *file, int line) else rw_text="ERROR"; - fprintf(stderr,"lock:%08lx/%08p:(%s)%s %-18s %s:%d\n", - CRYPTO_thread_id(), CRYPTO_thread_idptr(), rw_text, operation_text, + CRYPTO_THREADID_set(&tid); + fprintf(stderr,"lock:%08lx:(%s)%s %-18s %s:%d\n", + CRYPTO_THREADID_hash(&tid), rw_text, operation_text, CRYPTO_get_lock_name(type), file, line); } #endif @@ -518,6 +544,10 @@ 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) { @@ -527,9 +557,8 @@ 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/%0xp:%2d+%2d->%2d %-18s %s:%d\n", - CRYPTO_thread_id(), CRYPTO_thread_idptr(), - before,amount,ret, + fprintf(stderr,"ladd:%08lx:%2d+%2d->%2d %-18s %s:%d\n", + CRYPTO_THREADID_hash(&tid), before,amount,ret, CRYPTO_get_lock_name(type), file,line); #endif @@ -540,9 +569,8 @@ int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file, ret= *pointer+amount; #ifdef LOCK_DEBUG - fprintf(stderr,"ladd:%08lx/%0xp:%2d+%2d->%2d %-18s %s:%d\n", - CRYPTO_thread_id(), CRYPTO_thread_idptr(), - *pointer,amount,ret, + fprintf(stderr,"ladd:%08lx:%2d+%2d->%2d %-18s %s:%d\n", + CRYPTO_THREADID_hash(&tid), *pointer,amount,ret, CRYPTO_get_lock_name(type), file,line); #endif diff --git a/crypto/crypto.h b/crypto/crypto.h index ffe92993ec..bb9b89c6a5 100644 --- a/crypto/crypto.h +++ b/crypto/crypto.h @@ -300,6 +300,17 @@ 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 + { + void *ptr; + unsigned long ulong; + } CRYPTO_THREADID; + /* Per class, we have a STACK of CRYPTO_EX_DATA_FUNCS for each CRYPTO_EX_DATA * entry. */ @@ -420,12 +431,27 @@ 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); -void CRYPTO_set_idptr_callback(void *(*func)(void)); -void *(*CRYPTO_get_idptr_callback(void))(void); -void *CRYPTO_thread_idptr(void); +#endif + const char *CRYPTO_get_lock_name(int type); int CRYPTO_add_lock(int *pointer,int amount,int type, const char *file, int line); diff --git a/crypto/dsa/dsatest.c b/crypto/dsa/dsatest.c index 5a699ca5d3..edffd24e6b 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_state(0); + ERR_remove_thread_state(NULL); 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 b74d6435be..7509cb9c7c 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_state(0); + ERR_remove_thread_state(NULL); CRYPTO_mem_leaks_fp(stderr); return 0; diff --git a/crypto/ecdh/ecdhtest.c b/crypto/ecdh/ecdhtest.c index 1575006b51..212a87efa4 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_state(0); + ERR_remove_thread_state(NULL); CRYPTO_mem_leaks_fp(stderr); EXIT(ret); return(ret); diff --git a/crypto/ecdsa/ecdsatest.c b/crypto/ecdsa/ecdsatest.c index b07e31252b..aa4e1481a8 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_state(0); + ERR_remove_thread_state(NULL); ERR_free_strings(); CRYPTO_mem_leaks(out); if (out != NULL) diff --git a/crypto/engine/enginetest.c b/crypto/engine/enginetest.c index cf82f490db..3c1d2b4fbe 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_state(0); + ERR_remove_thread_state(NULL); CRYPTO_mem_leaks_fp(stderr); return to_return; } diff --git a/crypto/err/err.c b/crypto/err/err.c index 09b9812b7e..8adcd9f96d 100644 --- a/crypto/err/err.c +++ b/crypto/err/err.c @@ -975,50 +975,47 @@ static int err_cmp(const void *a_void, const void *b_void) /* static unsigned long pid_hash(ERR_STATE *a) */ static unsigned long pid_hash(const void *a_void) { - return((((const ERR_STATE *)a_void)->pid + (unsigned long)((const ERR_STATE *)a_void)->pidptr)*13); + return CRYPTO_THREADID_hash(&((const ERR_STATE *)a_void)->tid); } /* static int pid_cmp(ERR_STATE *a, ERR_STATE *b) */ static int pid_cmp(const void *a_void, const void *b_void) { - return (((const ERR_STATE *)a_void)->pid != ((const ERR_STATE *)b_void)->pid) - || (((const ERR_STATE *)a_void)->pidptr != ((const ERR_STATE *)b_void)->pidptr); + return CRYPTO_THREADID_cmp(&((const ERR_STATE *)a_void)->tid, + &((const ERR_STATE *)b_void)->tid); } -void ERR_remove_state(unsigned long pid) +void ERR_remove_thread_state(CRYPTO_THREADID *tid) { ERR_STATE tmp; - void *pidptr; - err_fns_check(); - if (pid != 0) - pidptr = &errno; + if (tid) + CRYPTO_THREADID_cpy(&tmp.tid, tid); else - { - pid = CRYPTO_thread_id(); - pidptr = CRYPTO_thread_idptr(); - } - - tmp.pid=pid; - tmp.pidptr=pidptr; + CRYPTO_THREADID_set(&tmp.tid); + err_fns_check(); /* 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(); - pid = CRYPTO_thread_id(); - pidptr = CRYPTO_thread_idptr(); - tmp.pid = pid; - tmp.pidptr = pidptr; + CRYPTO_THREADID_set(&tid); + CRYPTO_THREADID_cpy(&tmp.tid, &tid); ret=ERRFN(thread_get_item)(&tmp); /* ret == the error state, if NULL, make a new one */ @@ -1026,8 +1023,7 @@ ERR_STATE *ERR_get_state(void) { ret=(ERR_STATE *)OPENSSL_malloc(sizeof(ERR_STATE)); if (ret == NULL) return(&fallback); - ret->pid=pid; - ret->pidptr=pidptr; + CRYPTO_THREADID_cpy(&ret->tid, &tid); 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 9a6aecfce6..c56f5aadb2 100644 --- a/crypto/err/err.h +++ b/crypto/err/err.h @@ -147,8 +147,10 @@ extern "C" { #define ERR_NUM_ERRORS 16 typedef struct err_state_st { +#ifndef OPENSSL_NO_DEPRECATED unsigned long pid; - void *pidptr; /* new in OpenSSL 0.9.9 */ +#endif + CRYPTO_THREADID tid; int err_flags[ERR_NUM_ERRORS]; unsigned long err_buffer[ERR_NUM_ERRORS]; char *err_data[ERR_NUM_ERRORS]; @@ -349,7 +351,10 @@ 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 2224a901e5..6515d10c07 100644 --- a/crypto/err/err_prn.c +++ b/crypto/err/err_prn.c @@ -72,8 +72,10 @@ 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; - es=CRYPTO_thread_id(); + CRYPTO_THREADID_set(&tid); + es = CRYPTO_THREADID_hash(&tid); 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 bb6f02c2e9..b8c9235d3e 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_state(0); + ERR_remove_thread_state(NULL); ERR_free_strings(); CRYPTO_mem_leaks_fp(stderr); diff --git a/crypto/mem_dbg.c b/crypto/mem_dbg.c index 5e55d22277..1d94d3c5a2 100644 --- a/crypto/mem_dbg.c +++ b/crypto/mem_dbg.c @@ -146,9 +146,8 @@ typedef struct app_mem_info_st * CRYPTO_pop_info() to pop an entry, * CRYPTO_remove_all_info() to pop all entries. */ - { - unsigned long thread_id; - void *thread_idptr; + { + CRYPTO_THREADID threadid; const char *file; int line; const char *info; @@ -170,8 +169,7 @@ typedef struct mem_st int num; const char *file; int line; - unsigned long thread_id; - void *thread_idptr; + CRYPTO_THREADID threadid; unsigned long order; time_t time; APP_INFO *app_info; @@ -192,12 +190,9 @@ static unsigned int num_disable = 0; /* num_disable > 0 * mh_mode == CRYPTO_MEM_CHECK_ON (w/o ..._ENABLE) */ -/* 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; +/* 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; static void app_info_free(APP_INFO *inf) { @@ -234,9 +229,10 @@ int CRYPTO_mem_ctrl(int mode) case CRYPTO_MEM_CHECK_DISABLE: /* aka MemCheck_off() */ if (mh_mode & CRYPTO_MEM_CHECK_ON) { - if (!num_disable - || (disabling_thread_id != CRYPTO_thread_id()) - || (disabling_thread_idptr != CRYPTO_thread_idptr())) /* otherwise we already have the MALLOC2 lock */ + CRYPTO_THREADID tid; + CRYPTO_THREADID_set(&tid); + if (!num_disable || CRYPTO_THREADID_cmp(&tid, + &disabling_threadid)) { /* Long-time lock CRYPTO_LOCK_MALLOC2 must not be claimed while * we're holding CRYPTO_LOCK_MALLOC, or we'll deadlock if @@ -254,8 +250,7 @@ int CRYPTO_mem_ctrl(int mode) CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2); CRYPTO_w_lock(CRYPTO_LOCK_MALLOC); mh_mode &= ~CRYPTO_MEM_CHECK_ENABLE; - disabling_thread_id=CRYPTO_thread_id(); - disabling_thread_idptr=CRYPTO_thread_idptr(); + CRYPTO_THREADID_set(&disabling_threadid); } num_disable++; } @@ -288,11 +283,12 @@ 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) - || (disabling_thread_id != CRYPTO_thread_id()) - || (disabling_thread_idptr != CRYPTO_thread_idptr()); + ret = (mh_mode & CRYPTO_MEM_CHECK_ENABLE) || + CRYPTO_THREADID_cmp(&tid, &disabling_threadid); CRYPTO_r_unlock(CRYPTO_LOCK_MALLOC); } @@ -339,20 +335,15 @@ static unsigned long mem_hash(const void *a_void) /* 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 (((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); + return CRYPTO_THREADID_cmp(&((const APP_INFO *)a_void)->threadid, + &((const APP_INFO *)b_void)->threadid); } /* static unsigned long app_info_hash(APP_INFO *a) */ static unsigned long app_info_hash(const void *a_void) { - unsigned long id1, id2; unsigned long ret; - - id1=(unsigned long)((const APP_INFO *)a_void)->thread_id; - id2=(unsigned long)((const APP_INFO *)a_void)->thread_idptr; - ret = id1 + id2; - + ret = CRYPTO_THREADID_hash(&((const APP_INFO *)a_void)->threadid); ret=ret*17851+(ret>>14)*7+(ret>>4)*251; return(ret); } @@ -364,8 +355,7 @@ static APP_INFO *pop_info(void) if (amih != NULL) { - tmp.thread_id=CRYPTO_thread_id(); - tmp.thread_idptr=CRYPTO_thread_idptr(); + CRYPTO_THREADID_set(&tmp.threadid); if ((ret=(APP_INFO *)lh_delete(amih,&tmp)) != NULL) { APP_INFO *next=ret->next; @@ -376,10 +366,11 @@ static APP_INFO *pop_info(void) lh_insert(amih,(char *)next); } #ifdef LEVITTE_DEBUG_MEM - if (ret->thread_id != tmp.thread_id || ret->thread_idptr != tmp.thread_idptr) + if (CRYPTO_THREADID_cmp(&ret->threadid, &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); + 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)); abort(); } #endif @@ -419,8 +410,7 @@ int CRYPTO_push_info_(const char *info, const char *file, int line) } } - ami->thread_id=CRYPTO_thread_id(); - ami->thread_idptr=CRYPTO_thread_idptr(); + CRYPTO_THREADID_set(&ami->threadid); ami->file=file; ami->line=line; ami->info=info; @@ -430,10 +420,11 @@ int CRYPTO_push_info_(const char *info, const char *file, int line) if ((amim=(APP_INFO *)lh_insert(amih,(char *)ami)) != NULL) { #ifdef LEVITTE_DEBUG_MEM - if (ami->thread_id != amim->thread_id || ami->thread_idptr != amim->thread_idptr) + if (CRYPTO_THREADID_cmp(&ami->threadid, &amim->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); + 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)); abort(); } #endif @@ -518,16 +509,7 @@ void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line, m->file=file; m->line=line; m->num=num; - 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; - } + CRYPTO_THREADID_set(&m->threadid); if (order == break_order_num) { @@ -546,8 +528,7 @@ void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line, else m->time=0; - tmp.thread_id=CRYPTO_thread_id(); - tmp.thread_idptr=CRYPTO_thread_idptr(); + CRYPTO_THREADID_set(&m->threadid); m->app_info=NULL; if (amih != NULL && (amim=(APP_INFO *)lh_retrieve(amih,(char *)&tmp)) != NULL) @@ -676,8 +657,7 @@ static void print_leak(const MEM *m, MEM_LEAK *l) APP_INFO *amip; int ami_cnt; struct tm *lcl = NULL; - unsigned long ti; - void *tip; + CRYPTO_THREADID tid; #define BUF_REMAIN (sizeof buf - (size_t)(bufp - buf)) @@ -699,7 +679,8 @@ static void print_leak(const MEM *m, MEM_LEAK *l) if (options & V_CRYPTO_MDEBUG_THREAD) { - BIO_snprintf(bufp, BUF_REMAIN, "thread=%lu/%p, ", m->thread_id, m->thread_idptr); + BIO_snprintf(bufp, BUF_REMAIN, "thread=%lu, ", + CRYPTO_THREADID_hash(&m->threadid)); bufp += strlen(bufp); } @@ -716,8 +697,7 @@ static void print_leak(const MEM *m, MEM_LEAK *l) ami_cnt=0; if (!amip) return; - ti=amip->thread_id; - tip=amip->thread_idptr; + CRYPTO_THREADID_set(&tid); do { @@ -727,8 +707,8 @@ static void print_leak(const MEM *m, MEM_LEAK *l) ami_cnt++; memset(buf,'>',ami_cnt); BIO_snprintf(buf + ami_cnt, sizeof buf - ami_cnt, - " thread=%lu/%p, file=%s, line=%d, info=\"", - amip- |