-/* crypto/err/err.c */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
-#include "cryptlib.h"
+#include <internal/cryptlib_int.h>
+#include <internal/threads.h>
#include <openssl/lhash.h>
#include <openssl/crypto.h>
#include <openssl/buffer.h>
#include <openssl/bio.h>
#include <openssl/err.h>
-
-DECLARE_LHASH_OF(ERR_STRING_DATA);
-DECLARE_LHASH_OF(ERR_STATE);
+#include <openssl/opensslconf.h>
static void err_load_strings(int lib, ERR_STRING_DATA *str);
{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},
};
# 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},
};
{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;
/* 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;
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_w_lock(CRYPTO_LOCK_ERR);
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_w_unlock(CRYPTO_LOCK_ERR);
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;
+ ERR_STRING_DATA *p = NULL;
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);
+ hash = get_hash(0, 0);
+ if (hash)
+ 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;
- 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);
-
- 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
{
/* 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) {
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;
}
}
#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; \
void ERR_load_ERR_strings(void)
{
- err_fns_check();
#ifndef OPENSSL_NO_ERR
err_load_strings(0, ERR_str_libraries);
err_load_strings(0, ERR_str_reasons);
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_w_lock(CRYPTO_LOCK_ERR);
+ 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_w_unlock(CRYPTO_LOCK_ERR);
}
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_w_lock(CRYPTO_LOCK_ERR);
+ 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_w_unlock(CRYPTO_LOCK_ERR);
}
void ERR_free_strings(void)
{
- err_fns_check();
- ERRFN(err_del) ();
+ CRYPTO_w_lock(CRYPTO_LOCK_ERR);
+ lh_ERR_STRING_DATA_free(int_error_hash);
+ int_error_hash = NULL;
+ CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
}
/********************************************************/
}
}
-/* 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
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)
ERR_STRING_DATA d, *p;
unsigned long l;
- err_fns_check();
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);
}
ERR_STRING_DATA d, *p;
unsigned long l, f;
- err_fns_check();
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);
}
ERR_STRING_DATA d, *p = NULL;
unsigned long l, r;
- err_fns_check();
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_w_lock(CRYPTO_LOCK_ERR);
+ ret = int_err_library_number++;
+ CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
+ return ret;
}
void ERR_set_error_data(char *data, int flags)
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);
projects / openssl.git / blobdiff