X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=crypto%2Ferr%2Ferr.c;h=3492950b59be3e05bc1d5c82594b22265f0b2a16;hb=cd91fd7c32428c0deb503f19b8061e0980476876;hp=6812a9afed2c671dd3628f0e86d8e73c9103cd2b;hpb=48fc582f66a58e3da6f095ba1b4498c17581e05a;p=oweals%2Fopenssl.git diff --git a/crypto/err/err.c b/crypto/err/err.c index 6812a9afed..3492950b59 100644 --- a/crypto/err/err.c +++ b/crypto/err/err.c @@ -109,6 +109,8 @@ * */ +#define OPENSSL_NO_FIPS_ERR + #include #include #include @@ -119,6 +121,9 @@ #include #include +DECLARE_LHASH_OF(ERR_STRING_DATA); +DECLARE_LHASH_OF(ERR_STATE); + static void err_load_strings(int lib, ERR_STRING_DATA *str); static void ERR_STATE_free(ERR_STATE *s); @@ -140,6 +145,8 @@ static ERR_STRING_DATA ERR_str_libraries[]= {ERR_PACK(ERR_LIB_CONF,0,0) ,"configuration file routines"}, {ERR_PACK(ERR_LIB_CRYPTO,0,0) ,"common libcrypto routines"}, {ERR_PACK(ERR_LIB_EC,0,0) ,"elliptic curve routines"}, +{ERR_PACK(ERR_LIB_ECDSA,0,0) ,"ECDSA routines"}, +{ERR_PACK(ERR_LIB_ECDH,0,0) ,"ECDH routines"}, {ERR_PACK(ERR_LIB_SSL,0,0) ,"SSL routines"}, {ERR_PACK(ERR_LIB_BIO,0,0) ,"BIO routines"}, {ERR_PACK(ERR_LIB_PKCS7,0,0) ,"PKCS7 routines"}, @@ -150,6 +157,9 @@ static ERR_STRING_DATA ERR_str_libraries[]= {ERR_PACK(ERR_LIB_TS,0,0) ,"time stamp routines"}, {ERR_PACK(ERR_LIB_ENGINE,0,0) ,"engine routines"}, {ERR_PACK(ERR_LIB_OCSP,0,0) ,"OCSP routines"}, +{ERR_PACK(ERR_LIB_FIPS,0,0) ,"FIPS routines"}, +{ERR_PACK(ERR_LIB_CMS,0,0) ,"CMS routines"}, +{ERR_PACK(ERR_LIB_HMAC,0,0) ,"HMAC routines"}, {0,NULL}, }; @@ -197,6 +207,7 @@ static ERR_STRING_DATA ERR_str_reasons[]= {ERR_R_ENGINE_LIB ,"ENGINE lib"}, {ERR_R_OCSP_LIB ,"OCSP lib"}, {ERR_R_TS_LIB ,"TS lib"}, +{ERR_R_ECDSA_LIB ,"ECDSA lib"}, {ERR_R_NESTED_ASN1_ERROR ,"nested asn1 error"}, {ERR_R_BAD_ASN1_OBJECT_HEADER ,"bad asn1 object header"}, @@ -221,14 +232,14 @@ static ERR_STRING_DATA ERR_str_reasons[]= struct st_ERR_FNS { /* Works on the "error_hash" string table */ - LHASH *(*cb_err_get)(int create); + LHASH_OF(ERR_STRING_DATA) *(*cb_err_get)(int create); void (*cb_err_del)(void); ERR_STRING_DATA *(*cb_err_get_item)(const ERR_STRING_DATA *); ERR_STRING_DATA *(*cb_err_set_item)(ERR_STRING_DATA *); ERR_STRING_DATA *(*cb_err_del_item)(ERR_STRING_DATA *); /* Works on the "thread_hash" error-state table */ - LHASH *(*cb_thread_get)(int create); - void (*cb_thread_release)(LHASH **hash); + LHASH_OF(ERR_STATE) *(*cb_thread_get)(int create); + void (*cb_thread_release)(LHASH_OF(ERR_STATE) **hash); ERR_STATE *(*cb_thread_get_item)(const ERR_STATE *); ERR_STATE *(*cb_thread_set_item)(ERR_STATE *); void (*cb_thread_del_item)(const ERR_STATE *); @@ -237,13 +248,13 @@ struct st_ERR_FNS }; /* Predeclarations of the "err_defaults" functions */ -static LHASH *int_err_get(int create); +static LHASH_OF(ERR_STRING_DATA) *int_err_get(int create); static void int_err_del(void); static ERR_STRING_DATA *int_err_get_item(const ERR_STRING_DATA *); static ERR_STRING_DATA *int_err_set_item(ERR_STRING_DATA *); static ERR_STRING_DATA *int_err_del_item(ERR_STRING_DATA *); -static LHASH *int_thread_get(int create); -static void int_thread_release(LHASH **hash); +static LHASH_OF(ERR_STATE) *int_thread_get(int create); +static void int_thread_release(LHASH_OF(ERR_STATE) **hash); static ERR_STATE *int_thread_get_item(const ERR_STATE *); static ERR_STATE *int_thread_set_item(ERR_STATE *); static void int_thread_del_item(const ERR_STATE *); @@ -275,8 +286,8 @@ static const ERR_FNS *err_fns = NULL; * "err_defaults" functions. This way, a linked module can completely defer all * ERR state operation (together with requisite locking) to the implementations * and state in the loading application. */ -static LHASH *int_error_hash = NULL; -static LHASH *int_thread_hash = NULL; +static LHASH_OF(ERR_STRING_DATA) *int_error_hash = NULL; +static LHASH_OF(ERR_STATE) *int_thread_hash = NULL; static int int_thread_hash_references = 0; static int int_err_library_number= ERR_LIB_USER; @@ -319,28 +330,37 @@ int ERR_set_implementation(const ERR_FNS *fns) /* These are the callbacks provided to "lh_new()" when creating the LHASH tables * internal to the "err_defaults" implementation. */ -/* static unsigned long err_hash(ERR_STRING_DATA *a); */ -static unsigned long err_hash(const void *a_void); -/* static int err_cmp(ERR_STRING_DATA *a, ERR_STRING_DATA *b); */ -static int err_cmp(const void *a_void, const void *b_void); -/* static unsigned long pid_hash(ERR_STATE *pid); */ -static unsigned long pid_hash(const void *pid_void); -/* static int pid_cmp(ERR_STATE *a,ERR_STATE *pid); */ -static int pid_cmp(const void *a_void,const void *pid_void); static unsigned long get_error_values(int inc,int top,const char **file,int *line, const char **data,int *flags); /* The internal functions used in the "err_defaults" implementation */ -static LHASH *int_err_get(int create) +static unsigned long err_string_data_hash(const ERR_STRING_DATA *a) + { + unsigned long ret,l; + + l=a->error; + ret=l^ERR_GET_LIB(l)^ERR_GET_FUNC(l); + return(ret^ret%19*13); + } +static IMPLEMENT_LHASH_HASH_FN(err_string_data, ERR_STRING_DATA) + +static int err_string_data_cmp(const ERR_STRING_DATA *a, + const ERR_STRING_DATA *b) { - LHASH *ret = NULL; + return (int)(a->error - b->error); + } +static IMPLEMENT_LHASH_COMP_FN(err_string_data, ERR_STRING_DATA) + +static LHASH_OF(ERR_STRING_DATA) *int_err_get(int create) + { + LHASH_OF(ERR_STRING_DATA) *ret = NULL; CRYPTO_w_lock(CRYPTO_LOCK_ERR); if (!int_error_hash && create) { CRYPTO_push_info("int_err_get (err.c)"); - int_error_hash = lh_new(err_hash, err_cmp); + int_error_hash = lh_ERR_STRING_DATA_new(); CRYPTO_pop_info(); } if (int_error_hash) @@ -355,7 +375,7 @@ static void int_err_del(void) CRYPTO_w_lock(CRYPTO_LOCK_ERR); if (int_error_hash) { - lh_free(int_error_hash); + lh_ERR_STRING_DATA_free(int_error_hash); int_error_hash = NULL; } CRYPTO_w_unlock(CRYPTO_LOCK_ERR); @@ -364,7 +384,7 @@ static void int_err_del(void) static ERR_STRING_DATA *int_err_get_item(const ERR_STRING_DATA *d) { ERR_STRING_DATA *p; - LHASH *hash; + LHASH_OF(ERR_STRING_DATA) *hash; err_fns_check(); hash = ERRFN(err_get)(0); @@ -372,7 +392,7 @@ static ERR_STRING_DATA *int_err_get_item(const ERR_STRING_DATA *d) return NULL; CRYPTO_r_lock(CRYPTO_LOCK_ERR); - p = (ERR_STRING_DATA *)lh_retrieve(hash, d); + p = lh_ERR_STRING_DATA_retrieve(hash, d); CRYPTO_r_unlock(CRYPTO_LOCK_ERR); return p; @@ -381,7 +401,7 @@ static ERR_STRING_DATA *int_err_get_item(const ERR_STRING_DATA *d) static ERR_STRING_DATA *int_err_set_item(ERR_STRING_DATA *d) { ERR_STRING_DATA *p; - LHASH *hash; + LHASH_OF(ERR_STRING_DATA) *hash; err_fns_check(); hash = ERRFN(err_get)(1); @@ -389,7 +409,7 @@ static ERR_STRING_DATA *int_err_set_item(ERR_STRING_DATA *d) return NULL; CRYPTO_w_lock(CRYPTO_LOCK_ERR); - p = (ERR_STRING_DATA *)lh_insert(hash, d); + p = lh_ERR_STRING_DATA_insert(hash, d); CRYPTO_w_unlock(CRYPTO_LOCK_ERR); return p; @@ -398,7 +418,7 @@ static ERR_STRING_DATA *int_err_set_item(ERR_STRING_DATA *d) static ERR_STRING_DATA *int_err_del_item(ERR_STRING_DATA *d) { ERR_STRING_DATA *p; - LHASH *hash; + LHASH_OF(ERR_STRING_DATA) *hash; err_fns_check(); hash = ERRFN(err_get)(0); @@ -406,21 +426,33 @@ static ERR_STRING_DATA *int_err_del_item(ERR_STRING_DATA *d) return NULL; CRYPTO_w_lock(CRYPTO_LOCK_ERR); - p = (ERR_STRING_DATA *)lh_delete(hash, d); + p = lh_ERR_STRING_DATA_delete(hash, d); CRYPTO_w_unlock(CRYPTO_LOCK_ERR); return p; } -static LHASH *int_thread_get(int create) +static unsigned long err_state_hash(const ERR_STATE *a) { - LHASH *ret = NULL; + return CRYPTO_THREADID_hash(&a->tid) * 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); + } +static IMPLEMENT_LHASH_COMP_FN(err_state, ERR_STATE) + +static LHASH_OF(ERR_STATE) *int_thread_get(int create) + { + LHASH_OF(ERR_STATE) *ret = NULL; CRYPTO_w_lock(CRYPTO_LOCK_ERR); if (!int_thread_hash && create) { CRYPTO_push_info("int_thread_get (err.c)"); - int_thread_hash = lh_new(pid_hash, pid_cmp); + int_thread_hash = lh_ERR_STATE_new(); CRYPTO_pop_info(); } if (int_thread_hash) @@ -432,7 +464,7 @@ static LHASH *int_thread_get(int create) return ret; } -static void int_thread_release(LHASH **hash) +static void int_thread_release(LHASH_OF(ERR_STATE) **hash) { int i; @@ -458,7 +490,7 @@ static void int_thread_release(LHASH **hash) static ERR_STATE *int_thread_get_item(const ERR_STATE *d) { ERR_STATE *p; - LHASH *hash; + LHASH_OF(ERR_STATE) *hash; err_fns_check(); hash = ERRFN(thread_get)(0); @@ -466,7 +498,7 @@ static ERR_STATE *int_thread_get_item(const ERR_STATE *d) return NULL; CRYPTO_r_lock(CRYPTO_LOCK_ERR); - p = (ERR_STATE *)lh_retrieve(hash, d); + p = lh_ERR_STATE_retrieve(hash, d); CRYPTO_r_unlock(CRYPTO_LOCK_ERR); ERRFN(thread_release)(&hash); @@ -476,7 +508,7 @@ static ERR_STATE *int_thread_get_item(const ERR_STATE *d) static ERR_STATE *int_thread_set_item(ERR_STATE *d) { ERR_STATE *p; - LHASH *hash; + LHASH_OF(ERR_STATE) *hash; err_fns_check(); hash = ERRFN(thread_get)(1); @@ -484,7 +516,7 @@ static ERR_STATE *int_thread_set_item(ERR_STATE *d) return NULL; CRYPTO_w_lock(CRYPTO_LOCK_ERR); - p = (ERR_STATE *)lh_insert(hash, d); + p = lh_ERR_STATE_insert(hash, d); CRYPTO_w_unlock(CRYPTO_LOCK_ERR); ERRFN(thread_release)(&hash); @@ -494,7 +526,7 @@ static ERR_STATE *int_thread_set_item(ERR_STATE *d) static void int_thread_del_item(const ERR_STATE *d) { ERR_STATE *p; - LHASH *hash; + LHASH_OF(ERR_STATE) *hash; err_fns_check(); hash = ERRFN(thread_get)(0); @@ -502,12 +534,12 @@ static void int_thread_del_item(const ERR_STATE *d) return; CRYPTO_w_lock(CRYPTO_LOCK_ERR); - p = (ERR_STATE *)lh_delete(hash, d); + p = lh_ERR_STATE_delete(hash, d); /* make sure we don't leak memory */ if (int_thread_hash_references == 1 - && int_thread_hash && (lh_num_items(int_thread_hash) == 0)) + && int_thread_hash && lh_ERR_STATE_num_items(int_thread_hash) == 0) { - lh_free(int_thread_hash); + lh_ERR_STATE_free(int_thread_hash); int_thread_hash = NULL; } CRYPTO_w_unlock(CRYPTO_LOCK_ERR); @@ -892,19 +924,19 @@ char *ERR_error_string(unsigned long e, char *ret) return ret; } -LHASH *ERR_get_string_table(void) +LHASH_OF(ERR_STRING_DATA) *ERR_get_string_table(void) { err_fns_check(); return ERRFN(err_get)(0); } -LHASH *ERR_get_err_state_table(void) +LHASH_OF(ERR_STATE) *ERR_get_err_state_table(void) { err_fns_check(); return ERRFN(thread_get)(0); } -void ERR_release_err_state_table(LHASH **hash) +void ERR_release_err_state_table(LHASH_OF(ERR_STATE) **hash) { err_fns_check(); ERRFN(thread_release)(hash); @@ -953,70 +985,37 @@ const char *ERR_reason_error_string(unsigned long e) return((p == NULL)?NULL:p->string); } -/* static unsigned long err_hash(ERR_STRING_DATA *a) */ -static unsigned long err_hash(const void *a_void) - { - unsigned long ret,l; - - l=((const ERR_STRING_DATA *)a_void)->error; - ret=l^ERR_GET_LIB(l)^ERR_GET_FUNC(l); - return(ret^ret%19*13); - } - -/* static int err_cmp(ERR_STRING_DATA *a, ERR_STRING_DATA *b) */ -static int err_cmp(const void *a_void, const void *b_void) - { - return((int)(((const ERR_STRING_DATA *)a_void)->error - - ((const ERR_STRING_DATA *)b_void)->error)); - } - -/* 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); - } - -/* 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); - } - -void ERR_remove_state(unsigned long pid) +void ERR_remove_thread_state(const CRYPTO_THREADID *id) { ERR_STATE tmp; - void *pidptr; - err_fns_check(); - if (pid != 0) - pidptr = &errno; + if (id) + CRYPTO_THREADID_cpy(&tmp.tid, id); else - { - pid = CRYPTO_thread_id(); - pidptr = CRYPTO_thread_idptr(); - } - - tmp.pid=pid; - tmp.pidptr=pidptr; + CRYPTO_THREADID_current(&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; ERR_STATE *ret,tmp,*tmpp=NULL; int i; - unsigned long pid; - void *pidptr; + CRYPTO_THREADID tid; err_fns_check(); - pid = CRYPTO_thread_id(); - pidptr = CRYPTO_thread_idptr(); - tmp.pid = pid; - tmp.pidptr = pidptr; + CRYPTO_THREADID_current(&tid); + CRYPTO_THREADID_cpy(&tmp.tid, &tid); ret=ERRFN(thread_get_item)(&tmp); /* ret == the error state, if NULL, make a new one */ @@ -1024,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