X-Git-Url: https://git.openssl.org/?a=blobdiff_plain;f=crypto%2Ferr%2Ferr.c;h=aff3ae5a24e75656d6e96c5fb12c94011bc35232;hb=ff2344052;hp=50865b8b26c01816fa9bba3685663c3127875f3a;hpb=a00ae6c46e0d7907a7c9f9e85334e968aa5fd338;p=openssl.git diff --git a/crypto/err/err.c b/crypto/err/err.c index 50865b8b26..aff3ae5a24 100644 --- a/crypto/err/err.c +++ b/crypto/err/err.c @@ -1,4 +1,3 @@ -/* crypto/err/err.c */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -112,15 +111,15 @@ #include #include #include -#include "cryptlib.h" +#include +#include +#include #include #include #include #include -#include - -DECLARE_LHASH_OF(ERR_STRING_DATA); -DECLARE_LHASH_OF(ERR_STATE); +#include "internal/err.h" +#include static void err_load_strings(int lib, ERR_STRING_DATA *str); @@ -157,6 +156,9 @@ static ERR_STRING_DATA ERR_str_libraries[] = { {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"}, + {ERR_PACK(ERR_LIB_CT, 0, 0), "CT routines"}, + {ERR_PACK(ERR_LIB_ASYNC, 0, 0), "ASYNC routines"}, + {ERR_PACK(ERR_LIB_KDF, 0, 0), "KDF routines"}, {0, NULL}, }; @@ -174,6 +176,12 @@ static ERR_STRING_DATA ERR_str_functs[] = { # endif {ERR_PACK(0, SYS_F_OPENDIR, 0), "opendir"}, {ERR_PACK(0, SYS_F_FREAD, 0), "fread"}, + {ERR_PACK(0, SYS_F_GETADDRINFO, 0), "getaddrinfo"}, + {ERR_PACK(0, SYS_F_GETNAMEINFO, 0), "getnameinfo"}, + {ERR_PACK(0, SYS_F_SETSOCKOPT, 0), "setsockopt"}, + {ERR_PACK(0, SYS_F_GETSOCKOPT, 0), "getsockopt"}, + {ERR_PACK(0, SYS_F_GETSOCKNAME, 0), "getsockname"}, + {ERR_PACK(0, SYS_F_GETHOSTBYNAME, 0), "gethostbyname"}, {0, NULL}, }; @@ -218,125 +226,33 @@ static ERR_STRING_DATA ERR_str_reasons[] = { {ERR_R_PASSED_NULL_PARAMETER, "passed a null parameter"}, {ERR_R_INTERNAL_ERROR, "internal error"}, {ERR_R_DISABLED, "called a function that was disabled at compile-time"}, + {ERR_R_INIT_FAIL, "init fail"}, {0, NULL}, }; #endif -/* Define the predeclared (but externally opaque) "ERR_FNS" type */ -struct st_ERR_FNS { - /* Works on the "error_hash" string table */ - 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_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 *); - /* Returns the next available error "library" numbers */ - int (*cb_get_next_lib) (void); -}; +static CRYPTO_ONCE err_init = CRYPTO_ONCE_STATIC_INIT; +static CRYPTO_THREAD_LOCAL err_thread_local; + +static CRYPTO_ONCE err_string_init = CRYPTO_ONCE_STATIC_INIT; +static CRYPTO_RWLOCK *err_string_lock; /* Predeclarations of the "err_defaults" functions */ -static LHASH_OF(ERR_STRING_DATA) *int_err_get(int create); -static void int_err_del(void); +static LHASH_OF(ERR_STRING_DATA) *get_hash(int create, int lockit); 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_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 *); -static int int_err_get_next_lib(void); -/* The static ERR_FNS table using these defaults functions */ -static const ERR_FNS err_defaults = { - int_err_get, - int_err_del, - int_err_get_item, - int_err_set_item, - int_err_del_item, - int_thread_get, - int_thread_release, - int_thread_get_item, - int_thread_set_item, - int_thread_del_item, - int_err_get_next_lib -}; - -/* The replacable table of ERR_FNS functions we use at run-time */ -static const ERR_FNS *err_fns = NULL; - -/* Eg. rather than using "err_get()", use "ERRFN(err_get)()". */ -#define ERRFN(a) err_fns->cb_##a /* - * The internal state used by "err_defaults" - as such, the setting, reading, - * creating, and deleting of this data should only be permitted via the - * "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. + * The internal state */ + 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; -/* - * Internal function that checks whether "err_fns" is set and if not, sets it - * to the defaults. - */ -static void err_fns_check(void) -{ - if (err_fns) - return; - - CRYPTO_w_lock(CRYPTO_LOCK_ERR); - if (!err_fns) - err_fns = &err_defaults; - CRYPTO_w_unlock(CRYPTO_LOCK_ERR); -} - -/* API functions to get or set the underlying ERR functions. */ - -const ERR_FNS *ERR_get_implementation(void) -{ - err_fns_check(); - return err_fns; -} - -int ERR_set_implementation(const ERR_FNS *fns) -{ - int ret = 0; - - CRYPTO_w_lock(CRYPTO_LOCK_ERR); - /* - * It's too late if 'err_fns' is non-NULL. BTW: not much point setting an - * error is there?! - */ - if (!err_fns) { - err_fns = fns; - ret = 1; - } - CRYPTO_w_unlock(CRYPTO_LOCK_ERR); - return ret; -} - -/* - * These are the callbacks provided to "lh_new()" when creating the LHASH - * tables internal to the "err_defaults" implementation. - */ - 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 unsigned long err_string_data_hash(const ERR_STRING_DATA *a) { unsigned long ret, l; @@ -346,221 +262,44 @@ static unsigned long err_string_data_hash(const ERR_STRING_DATA *a) 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) { 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) +static LHASH_OF(ERR_STRING_DATA) *get_hash(int create, int lockit) { LHASH_OF(ERR_STRING_DATA) *ret = NULL; - CRYPTO_w_lock(CRYPTO_LOCK_ERR); + if (lockit) + CRYPTO_THREAD_write_lock(err_string_lock); if (!int_error_hash && create) { - CRYPTO_push_info("int_err_get (err.c)"); - int_error_hash = lh_ERR_STRING_DATA_new(); - CRYPTO_pop_info(); + int_error_hash = lh_ERR_STRING_DATA_new(err_string_data_hash, + err_string_data_cmp); } - if (int_error_hash) + if (int_error_hash != NULL) ret = int_error_hash; - CRYPTO_w_unlock(CRYPTO_LOCK_ERR); + if (lockit) + CRYPTO_THREAD_unlock(err_string_lock); return ret; } -static void int_err_del(void) -{ - CRYPTO_w_lock(CRYPTO_LOCK_ERR); - if (int_error_hash) { - lh_ERR_STRING_DATA_free(int_error_hash); - int_error_hash = NULL; - } - CRYPTO_w_unlock(CRYPTO_LOCK_ERR); -} - static ERR_STRING_DATA *int_err_get_item(const ERR_STRING_DATA *d) { - ERR_STRING_DATA *p; - LHASH_OF(ERR_STRING_DATA) *hash; - - err_fns_check(); - hash = ERRFN(err_get) (0); - if (!hash) - return NULL; - - CRYPTO_r_lock(CRYPTO_LOCK_ERR); - p = lh_ERR_STRING_DATA_retrieve(hash, d); - CRYPTO_r_unlock(CRYPTO_LOCK_ERR); - - return p; -} - -static ERR_STRING_DATA *int_err_set_item(ERR_STRING_DATA *d) -{ - ERR_STRING_DATA *p; - LHASH_OF(ERR_STRING_DATA) *hash; - - err_fns_check(); - hash = ERRFN(err_get) (1); - if (!hash) - return NULL; - - CRYPTO_w_lock(CRYPTO_LOCK_ERR); - p = lh_ERR_STRING_DATA_insert(hash, d); - CRYPTO_w_unlock(CRYPTO_LOCK_ERR); - - return p; -} - -static ERR_STRING_DATA *int_err_del_item(ERR_STRING_DATA *d) -{ - ERR_STRING_DATA *p; + ERR_STRING_DATA *p = NULL; LHASH_OF(ERR_STRING_DATA) *hash; - err_fns_check(); - hash = ERRFN(err_get) (0); - if (!hash) - return NULL; - - CRYPTO_w_lock(CRYPTO_LOCK_ERR); - p = lh_ERR_STRING_DATA_delete(hash, d); - CRYPTO_w_unlock(CRYPTO_LOCK_ERR); - - return p; -} - -static unsigned long err_state_hash(const ERR_STATE *a) -{ - 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_ERR_STATE_new(); - CRYPTO_pop_info(); - } - if (int_thread_hash) { - int_thread_hash_references++; - ret = int_thread_hash; - } - CRYPTO_w_unlock(CRYPTO_LOCK_ERR); - return ret; -} - -static void int_thread_release(LHASH_OF(ERR_STATE) **hash) -{ - int i; - - if (hash == NULL || *hash == NULL) - return; - - i = CRYPTO_add(&int_thread_hash_references, -1, CRYPTO_LOCK_ERR); - -#ifdef REF_PRINT - fprintf(stderr, "%4d:%s\n", int_thread_hash_references, "ERR"); -#endif - if (i > 0) - return; -#ifdef REF_CHECK - if (i < 0) { - fprintf(stderr, "int_thread_release, bad reference count\n"); - abort(); /* ok */ - } -#endif - *hash = NULL; -} - -static ERR_STATE *int_thread_get_item(const ERR_STATE *d) -{ - ERR_STATE *p; - LHASH_OF(ERR_STATE) *hash; - - err_fns_check(); - hash = ERRFN(thread_get) (0); - if (!hash) - return NULL; - - CRYPTO_r_lock(CRYPTO_LOCK_ERR); - p = lh_ERR_STATE_retrieve(hash, d); - CRYPTO_r_unlock(CRYPTO_LOCK_ERR); + CRYPTO_THREAD_read_lock(err_string_lock); + hash = get_hash(0, 0); + if (hash) + p = lh_ERR_STRING_DATA_retrieve(hash, d); + CRYPTO_THREAD_unlock(err_string_lock); - ERRFN(thread_release) (&hash); return p; } -static ERR_STATE *int_thread_set_item(ERR_STATE *d) -{ - ERR_STATE *p; - LHASH_OF(ERR_STATE) *hash; - - err_fns_check(); - hash = ERRFN(thread_get) (1); - if (!hash) - return NULL; - - CRYPTO_w_lock(CRYPTO_LOCK_ERR); - p = lh_ERR_STATE_insert(hash, d); - CRYPTO_w_unlock(CRYPTO_LOCK_ERR); - - ERRFN(thread_release) (&hash); - return p; -} - -static void int_thread_del_item(const ERR_STATE *d) -{ - ERR_STATE *p; - LHASH_OF(ERR_STATE) *hash; - - err_fns_check(); - hash = ERRFN(thread_get) (0); - if (!hash) - return; - - CRYPTO_w_lock(CRYPTO_LOCK_ERR); - p = lh_ERR_STATE_delete(hash, d); - /* make sure we don't leak memory */ - if (int_thread_hash_references == 1 - && int_thread_hash && lh_ERR_STATE_num_items(int_thread_hash) == 0) { - lh_ERR_STATE_free(int_thread_hash); - int_thread_hash = NULL; - } - CRYPTO_w_unlock(CRYPTO_LOCK_ERR); - - ERRFN(thread_release) (&hash); - if (p) - ERR_STATE_free(p); -} - -static int int_err_get_next_lib(void) -{ - int ret; - - CRYPTO_w_lock(CRYPTO_LOCK_ERR); - ret = int_err_library_number++; - CRYPTO_w_unlock(CRYPTO_LOCK_ERR); - - return ret; -} - #ifndef OPENSSL_NO_ERR # define NUM_SYS_STR_REASONS 127 # define LEN_SYS_STR_REASON 32 @@ -580,19 +319,12 @@ static void build_SYS_str_reasons(void) { /* OPENSSL_malloc cannot be used here, use static storage instead */ static char strerror_tab[NUM_SYS_STR_REASONS][LEN_SYS_STR_REASON]; - int i; static int init = 1; + int i; - CRYPTO_r_lock(CRYPTO_LOCK_ERR); - if (!init) { - CRYPTO_r_unlock(CRYPTO_LOCK_ERR); - return; - } - - CRYPTO_r_unlock(CRYPTO_LOCK_ERR); - CRYPTO_w_lock(CRYPTO_LOCK_ERR); + CRYPTO_THREAD_write_lock(err_string_lock); if (!init) { - CRYPTO_w_unlock(CRYPTO_LOCK_ERR); + CRYPTO_THREAD_unlock(err_string_lock); return; } @@ -604,8 +336,8 @@ static void build_SYS_str_reasons(void) char (*dest)[LEN_SYS_STR_REASON] = &(strerror_tab[i - 1]); char *src = strerror(i); if (src != NULL) { - strncpy(*dest, src, sizeof *dest); - (*dest)[sizeof *dest - 1] = '\0'; + strncpy(*dest, src, sizeof(*dest)); + (*dest)[sizeof(*dest) - 1] = '\0'; str->string = *dest; } } @@ -620,14 +352,13 @@ static void build_SYS_str_reasons(void) init = 0; - CRYPTO_w_unlock(CRYPTO_LOCK_ERR); + CRYPTO_THREAD_unlock(err_string_lock); } #endif #define err_clear_data(p,i) \ do { \ - if (((p)->err_data[i] != NULL) && \ - (p)->err_data_flags[i] & ERR_TXT_MALLOCED) \ + if ((p)->err_data_flags[i] & ERR_TXT_MALLOCED) \ { \ OPENSSL_free((p)->err_data[i]); \ (p)->err_data[i]=NULL; \ @@ -657,10 +388,22 @@ static void ERR_STATE_free(ERR_STATE *s) OPENSSL_free(s); } +static void do_err_strings_init(void) +{ + err_string_lock = CRYPTO_THREAD_lock_new(); +} + +void err_cleanup(void) +{ + CRYPTO_THREAD_lock_free(err_string_lock); + err_string_lock = NULL; +} + void ERR_load_ERR_strings(void) { - err_fns_check(); #ifndef OPENSSL_NO_ERR + CRYPTO_THREAD_run_once(&err_string_init, do_err_strings_init); + err_load_strings(0, ERR_str_libraries); err_load_strings(0, ERR_str_reasons); err_load_strings(ERR_LIB_SYS, ERR_str_functs); @@ -671,12 +414,18 @@ void ERR_load_ERR_strings(void) static void err_load_strings(int lib, ERR_STRING_DATA *str) { - while (str->error) { - if (lib) - str->error |= ERR_PACK(lib, 0, 0); - ERRFN(err_set_item) (str); - str++; + LHASH_OF(ERR_STRING_DATA) *hash; + + CRYPTO_THREAD_write_lock(err_string_lock); + hash = get_hash(1, 0); + if (hash) { + for (; str->error; str++) { + if (lib) + str->error |= ERR_PACK(lib, 0, 0); + (void)lh_ERR_STRING_DATA_insert(hash, str); + } } + CRYPTO_THREAD_unlock(err_string_lock); } void ERR_load_strings(int lib, ERR_STRING_DATA *str) @@ -687,18 +436,30 @@ void ERR_load_strings(int lib, ERR_STRING_DATA *str) void ERR_unload_strings(int lib, ERR_STRING_DATA *str) { - while (str->error) { - if (lib) - str->error |= ERR_PACK(lib, 0, 0); - ERRFN(err_del_item) (str); - str++; + LHASH_OF(ERR_STRING_DATA) *hash; + + CRYPTO_THREAD_run_once(&err_string_init, do_err_strings_init); + + CRYPTO_THREAD_write_lock(err_string_lock); + hash = get_hash(0, 0); + if (hash) { + for (; str->error; str++) { + if (lib) + str->error |= ERR_PACK(lib, 0, 0); + (void)lh_ERR_STRING_DATA_delete(hash, str); + } } + CRYPTO_THREAD_unlock(err_string_lock); } -void ERR_free_strings(void) +void err_free_strings_int(void) { - err_fns_check(); - ERRFN(err_del) (); + CRYPTO_THREAD_run_once(&err_string_init, do_err_strings_init); + + CRYPTO_THREAD_write_lock(err_string_lock); + lh_ERR_STRING_DATA_free(int_error_hash); + int_error_hash = NULL; + CRYPTO_THREAD_unlock(err_string_lock); } /********************************************************/ @@ -914,7 +675,6 @@ void ERR_error_string_n(unsigned long e, char *buf, size_t len) } } -/* BAD for multi-threading: uses a local buffer if ret == NULL */ /* * ERR_error_string_n should be used instead for ret != NULL as * ERR_error_string cannot know how large the buffer is @@ -932,20 +692,7 @@ char *ERR_error_string(unsigned long e, char *ret) LHASH_OF(ERR_STRING_DATA) *ERR_get_string_table(void) { - err_fns_check(); - return ERRFN(err_get) (0); -} - -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_OF(ERR_STATE) **hash) -{ - err_fns_check(); - ERRFN(thread_release) (hash); + return get_hash(0, 1); } const char *ERR_lib_error_string(unsigned long e) @@ -953,10 +700,11 @@ const char *ERR_lib_error_string(unsigned long e) ERR_STRING_DATA d, *p; unsigned long l; - err_fns_check(); + CRYPTO_THREAD_run_once(&err_string_init, do_err_strings_init); + l = ERR_GET_LIB(e); d.error = ERR_PACK(l, 0, 0); - p = ERRFN(err_get_item) (&d); + p = int_err_get_item(&d); return ((p == NULL) ? NULL : p->string); } @@ -965,11 +713,12 @@ const char *ERR_func_error_string(unsigned long e) ERR_STRING_DATA d, *p; unsigned long l, f; - err_fns_check(); + CRYPTO_THREAD_run_once(&err_string_init, do_err_strings_init); + l = ERR_GET_LIB(e); f = ERR_GET_FUNC(e); d.error = ERR_PACK(l, f, 0); - p = ERRFN(err_get_item) (&d); + p = int_err_get_item(&d); return ((p == NULL) ? NULL : p->string); } @@ -978,85 +727,77 @@ const char *ERR_reason_error_string(unsigned long e) ERR_STRING_DATA d, *p = NULL; unsigned long l, r; - err_fns_check(); + CRYPTO_THREAD_run_once(&err_string_init, do_err_strings_init); + l = ERR_GET_LIB(e); r = ERR_GET_REASON(e); d.error = ERR_PACK(l, 0, r); - p = ERRFN(err_get_item) (&d); + p = int_err_get_item(&d); if (!p) { d.error = ERR_PACK(0, 0, r); - p = ERRFN(err_get_item) (&d); + p = int_err_get_item(&d); } return ((p == NULL) ? NULL : p->string); } -void ERR_remove_thread_state(const CRYPTO_THREADID *id) +void ERR_remove_thread_state(void) { - ERR_STATE tmp; + ERR_STATE *state = ERR_get_state(); + if (state == NULL) + return; - if (id) - CRYPTO_THREADID_cpy(&tmp.tid, id); - else - 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); + CRYPTO_THREAD_set_local(&err_thread_local, NULL); + ERR_STATE_free(state); } -#ifndef OPENSSL_NO_DEPRECATED +#if OPENSSL_API_COMPAT < 0x10000000L void ERR_remove_state(unsigned long pid) { - ERR_remove_thread_state(NULL); + ERR_remove_thread_state(); } #endif +static void err_do_init(void) +{ + CRYPTO_THREAD_init_local(&err_thread_local, NULL); +} + ERR_STATE *ERR_get_state(void) { - static ERR_STATE fallback; - ERR_STATE *ret, tmp, *tmpp = NULL; - int i; - CRYPTO_THREADID tid; - - err_fns_check(); - 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 */ - if (ret == NULL) { - ret = (ERR_STATE *)OPENSSL_malloc(sizeof(ERR_STATE)); - if (ret == NULL) - return (&fallback); - CRYPTO_THREADID_cpy(&ret->tid, &tid); - ret->top = 0; - ret->bottom = 0; - for (i = 0; i < ERR_NUM_ERRORS; i++) { - ret->err_data[i] = NULL; - ret->err_data_flags[i] = 0; - } - tmpp = ERRFN(thread_set_item) (ret); - /* To check if insertion failed, do a get. */ - if (ERRFN(thread_get_item) (ret) != ret) { - ERR_STATE_free(ret); /* could not insert it */ - return (&fallback); + ERR_STATE *state = NULL; + + CRYPTO_THREAD_run_once(&err_init, err_do_init); + + state = CRYPTO_THREAD_get_local(&err_thread_local); + + if (state == NULL) { + state = OPENSSL_zalloc(sizeof(*state)); + if (state == NULL) + return NULL; + + if (!CRYPTO_THREAD_set_local(&err_thread_local, state)) { + ERR_STATE_free(state); + return NULL; } - /* - * If a race occurred in this function and we came second, tmpp is - * the first one that we just replaced. - */ - if (tmpp) - ERR_STATE_free(tmpp); + + /* Ignore failures from these */ + OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL); + ossl_init_thread_start(OPENSSL_INIT_THREAD_ERR_STATE); } - return ret; + + return state; } int ERR_get_next_error_library(void) { - err_fns_check(); - return ERRFN(get_next_lib) (); + int ret; + + CRYPTO_THREAD_run_once(&err_string_init, do_err_strings_init); + + CRYPTO_THREAD_write_lock(err_string_lock); + ret = int_err_library_number++; + CRYPTO_THREAD_unlock(err_string_lock); + return ret; } void ERR_set_error_data(char *data, int flags) @@ -1106,10 +847,10 @@ void ERR_add_error_vdata(int num, va_list args) if (p == NULL) { OPENSSL_free(str); return; - } else - str = p; + } + str = p; } - BUF_strlcat(str, a, (size_t)s + 1); + OPENSSL_strlcat(str, a, (size_t)s + 1); } } ERR_set_error_data(str, ERR_TXT_MALLOCED | ERR_TXT_STRING);