Totally get rid of CRYPTO_LOCK_ERR_HASH.

In err.c, flags int_error_hash_set and int_thread_hash_set
appear superfluous since we can just as well initialize
int_error_hash and int_thread_hash to NULL.

Change some of the err.c formatting to conform with the rest of
OpenSSL.

diff --git a/crypto/cryptlib.c b/crypto/cryptlib.c
index 6a2e546fba99300f02ed570b81750067cfd498fb..4eb584c90a5855c7ca643e73889fb079b3dddb86 100644 (file)
--- a/crypto/cryptlib.c
+++ b/crypto/cryptlib.c
@@ -74,7 +74,7 @@ static const char* lock_names[CRYPTO_NUM_LOCKS] =
        {
        "<<ERROR>>",
        "err",
-       "err_hash",
+       "ex_data",
        "x509",
        "x509_info",
        "x509_pkey",
@@ -103,8 +103,7 @@ static const char* lock_names[CRYPTO_NUM_LOCKS] =
        "dynlock",
        "engine",
        "ui",
-       "ex_data",
-#if CRYPTO_NUM_LOCKS != 32
+#if CRYPTO_NUM_LOCKS != 31
 # error "Inconsistency between crypto.h and cryptlib.c"
 #endif
        };

diff --git a/crypto/crypto.h b/crypto/crypto.h
index 4cf9fd040ba1cfc7d3af7e29c8b2838eedc20c82..9a642ab9626fc02c3f5b0ed1979a82c3594657f7 100644 (file)
--- a/crypto/crypto.h
+++ b/crypto/crypto.h
@@ -97,7 +97,7 @@ extern "C" {
  */
 
 #define        CRYPTO_LOCK_ERR                 1
-#define        CRYPTO_LOCK_ERR_HASH            2
+#define        CRYPTO_LOCK_EX_DATA             2
 #define        CRYPTO_LOCK_X509                3
 #define        CRYPTO_LOCK_X509_INFO           4
 #define        CRYPTO_LOCK_X509_PKEY           5
@@ -126,8 +126,7 @@ extern "C" {
 #define        CRYPTO_LOCK_DYNLOCK             28
 #define        CRYPTO_LOCK_ENGINE              29
 #define        CRYPTO_LOCK_UI                  30
-#define        CRYPTO_LOCK_EX_DATA             31
-#define        CRYPTO_NUM_LOCKS                32
+#define        CRYPTO_NUM_LOCKS                31
 
 #define CRYPTO_LOCK            1
 #define CRYPTO_UNLOCK          2

diff --git a/crypto/err/err.c b/crypto/err/err.c
index 75a69c3e406a16de5d6da6d5febdc665428e7d9d..6d7f9b9c22e6e079318db75cad9baca7ddf1e64c 100644 (file)
--- a/crypto/err/err.c
+++ b/crypto/err/err.c
@@ -267,11 +267,9 @@ 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;
-static int int_error_hash_set = 0;
-static LHASH *int_thread_hash;
-static int int_thread_hash_set = 0;
-static int int_err_library_number=ERR_LIB_USER;
+static LHASH *int_error_hash = NULL;
+static LHASH *int_thread_hash = NULL;
+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. */
@@ -295,17 +293,18 @@ const ERR_FNS *ERR_get_implementation(void)
 
 int ERR_set_implementation(const ERR_FNS *fns)
        {
-       int toret = 0;
+       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)
+       if (!err_fns)
                {
                err_fns = fns;
-               toret = 1;
+               ret = 1;
                }
        CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
-       return toret;
+       return ret;
        }
 
 /* These are the callbacks provided to "lh_new()" when creating the LHASH tables
@@ -326,27 +325,25 @@ static unsigned long get_error_values(int inc,const char **file,int *line,
 
 static LHASH *int_err_get(void)
        {
-       LHASH *toret = NULL;
+       LHASH *ret = NULL;
+
        CRYPTO_w_lock(CRYPTO_LOCK_ERR);
-       if(!int_error_hash_set)
+       if (!int_error_hash)
                int_error_hash = lh_new(err_hash, err_cmp);
-       if(int_error_hash)
-               {
-               int_error_hash_set = 1;
-               toret = int_error_hash;
-               }
+       if (int_error_hash)
+               ret = int_error_hash;
        CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
-       return(toret);
+
+       return ret;
        }
 
 static void int_err_del(void)
        {
        CRYPTO_w_lock(CRYPTO_LOCK_ERR);
-       if(int_error_hash_set)
+       if (int_error_hash)
                {
                lh_free(int_error_hash);
                int_error_hash = NULL;
-               int_error_hash_set = 0;
                }
        CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
        }
@@ -355,13 +352,16 @@ static ERR_STRING_DATA *int_err_get_item(const ERR_STRING_DATA *d)
        {
        ERR_STRING_DATA *p;
        LHASH *hash;
+
        err_fns_check();
        hash = ERRFN(err_get)();
-       if(!hash)
+       if (!hash)
                return NULL;
+
        CRYPTO_r_lock(CRYPTO_LOCK_ERR);
        p = (ERR_STRING_DATA *)lh_retrieve(hash, d);
        CRYPTO_r_unlock(CRYPTO_LOCK_ERR);
+
        return p;
        }
 
@@ -369,13 +369,16 @@ static ERR_STRING_DATA *int_err_set_item(ERR_STRING_DATA *d)
        {
        ERR_STRING_DATA *p;
        LHASH *hash;
+
        err_fns_check();
        hash = ERRFN(err_get)();
-       if(!hash)
+       if (!hash)
                return NULL;
+
        CRYPTO_w_lock(CRYPTO_LOCK_ERR);
        p = (ERR_STRING_DATA *)lh_insert(hash, d);
        CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
+
        return p;
        }
 
@@ -383,42 +386,46 @@ static ERR_STRING_DATA *int_err_del_item(ERR_STRING_DATA *d)
        {
        ERR_STRING_DATA *p;
        LHASH *hash;
+
        err_fns_check();
        hash = ERRFN(err_get)();
-       if(!hash)
+       if (!hash)
                return NULL;
+
        CRYPTO_w_lock(CRYPTO_LOCK_ERR);
        p = (ERR_STRING_DATA *)lh_delete(hash, d);
        CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
+
        return p;
        }
 
 static LHASH *int_thread_get(void)
        {
-       LHASH *toret = NULL;
+       LHASH *ret = NULL;
+
        CRYPTO_w_lock(CRYPTO_LOCK_ERR);
-       if(!int_thread_hash_set)
+       if (!int_thread_hash)
                int_thread_hash = lh_new(pid_hash, pid_cmp);
-       if(int_thread_hash)
-               {
-               int_thread_hash_set = 1;
-               toret = int_thread_hash;
-               }
+       if (int_thread_hash)
+               ret = int_thread_hash;
        CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
-       return(toret);
+       return ret;
        }
 
 static ERR_STATE *int_thread_get_item(const ERR_STATE *d)
        {
        ERR_STATE *p;
        LHASH *hash;
+
        err_fns_check();
        hash = ERRFN(thread_get)();
-       if(!hash)
+       if (!hash)
                return NULL;
+
        CRYPTO_r_lock(CRYPTO_LOCK_ERR);
        p = (ERR_STATE *)lh_retrieve(hash, d);
        CRYPTO_r_unlock(CRYPTO_LOCK_ERR);
+
        return p;
        }
 
@@ -426,13 +433,16 @@ static ERR_STATE *int_thread_set_item(ERR_STATE *d)
        {
        ERR_STATE *p;
        LHASH *hash;
+
        err_fns_check();
        hash = ERRFN(thread_get)();
-       if(!hash)
+       if (!hash)
                return NULL;
+
        CRYPTO_w_lock(CRYPTO_LOCK_ERR);
        p = (ERR_STATE *)lh_insert(hash, d);
        CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
+
        return p;
        }
 
@@ -440,31 +450,35 @@ static void int_thread_del_item(const ERR_STATE *d)
        {
        ERR_STATE *p;
        LHASH *hash;
+
        err_fns_check();
        hash = ERRFN(thread_get)();
-       if(!hash)
+       if (!hash)
                return;
+
        CRYPTO_w_lock(CRYPTO_LOCK_ERR);
        p = (ERR_STATE *)lh_delete(hash, d);
        /* make sure we don't leak memory */
-       if(int_thread_hash_set && (lh_num_items(int_thread_hash) == 0))
+       if (int_thread_hash && (lh_num_items(int_thread_hash) == 0))
                {
                lh_free(int_thread_hash);
                int_thread_hash = NULL;
-               int_thread_hash_set = 0;
                }
        CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
-       if(p)
+
+       if (p)
                ERR_STATE_free(p);
        }
 
 static int int_err_get_next_lib(void)
        {
-       int toret;
+       int ret;
+
        CRYPTO_w_lock(CRYPTO_LOCK_ERR);
-       toret = int_err_library_number++;
+       ret = int_err_library_number++;
        CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
-       return toret;
+
+       return ret;
        }
 
 
@@ -490,7 +504,7 @@ static void build_SYS_str_reasons()
 
        if (!init) return;
 
-       CRYPTO_w_lock(CRYPTO_LOCK_ERR_HASH);
+       CRYPTO_w_lock(CRYPTO_LOCK_ERR);
 
        for (i = 1; i <= NUM_SYS_STR_REASONS; i++)
                {
@@ -517,7 +531,7 @@ static void build_SYS_str_reasons()
 
        init = 0;
        
-       CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH);
+       CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
        }
 #endif
 
@@ -534,7 +548,7 @@ static void ERR_STATE_free(ERR_STATE *s)
        {
        int i;
 
-       if(s == NULL)
+       if (s == NULL)
            return;
 
        for (i=0; i<ERR_NUM_ERRORS; i++)
@@ -574,7 +588,7 @@ void ERR_load_strings(int lib, ERR_STRING_DATA *str)
 
 void ERR_unload_strings(int lib, ERR_STRING_DATA *str)
        {
-       while(str->error)
+       while (str->error)
                {
                str->error|=ERR_PACK(lib,0,0);
                ERRFN(err_del_item)(str);
@@ -652,8 +666,7 @@ unsigned long ERR_get_error_line(const char **file,
 
 unsigned long ERR_get_error_line_data(const char **file, int *line,
             const char **data, int *flags)
-       { return(get_error_values(1,file,line,
-            data,flags)); }
+       { return(get_error_values(1,file,line,data,flags)); }
 
 unsigned long ERR_peek_error(void)
        { return(get_error_values(0,NULL,NULL,NULL,NULL)); }
@@ -664,8 +677,7 @@ unsigned long ERR_peek_error_line(const char **file,
 
 unsigned long ERR_peek_error_line_data(const char **file, int *line,
             const char **data, int *flags)
-       { return(get_error_values(0,file,line,
-            data,flags)); }
+       { return(get_error_values(0,file,line,data,flags)); }
 
 static unsigned long get_error_values(int inc, const char **file, int *line,
             const char **data, int *flags)
@@ -676,7 +688,7 @@ static unsigned long get_error_values(int inc, const char **file, int *line,
 
        es=ERR_get_state();
 
-       if (es->bottom == es->top) return(0);
+       if (es->bottom == es->top) return 0;
        i=(es->bottom+1)%ERR_NUM_ERRORS;
 
        ret=es->err_buffer[i];
@@ -720,7 +732,7 @@ static unsigned long get_error_values(int inc, const char **file, int *line,
                        if (flags != NULL) *flags=es->err_data_flags[i];
                        }
                }
-       return(ret);
+       return ret;
        }
 
 void ERR_error_string_n(unsigned long e, char *buf, size_t len)
@@ -782,7 +794,7 @@ char *ERR_error_string(unsigned long e, char *ret)
        if (ret == NULL) ret=buf;
        ERR_error_string_n(e, ret, 256);
 
-       return(ret);
+       return ret;
        }
 
 LHASH *ERR_get_string_table(void)
@@ -832,7 +844,7 @@ const char *ERR_reason_error_string(unsigned long e)
        r=ERR_GET_REASON(e);
        d.error=ERR_PACK(l,0,r);
        p=ERRFN(err_get_item)(&d);
-       if(!p)
+       if (!p)
                {
                d.error=ERR_PACK(0,0,r);
                p=ERRFN(err_get_item)(&d);
@@ -873,6 +885,7 @@ static int pid_cmp(const void *a_void, const void *b_void)
 void ERR_remove_state(unsigned long pid)
        {
        ERR_STATE tmp;
+
        err_fns_check();
        if (pid == 0)
                pid=(unsigned long)CRYPTO_thread_id();
@@ -888,6 +901,7 @@ ERR_STATE *ERR_get_state(void)
        ERR_STATE *ret,tmp,*tmpp=NULL;
        int i;
        unsigned long pid;
+
        err_fns_check();
        pid=(unsigned long)CRYPTO_thread_id();
        tmp.pid=pid;
@@ -908,17 +922,17 @@ ERR_STATE *ERR_get_state(void)
                        }
                tmpp = ERRFN(thread_set_item)(ret);
                /* To check if insertion failed, do a get. */
-               if(ERRFN(thread_get_item)(ret) != ret)
+               if (ERRFN(thread_get_item)(ret) != ret)
                        {
                        ERR_STATE_free(ret); /* could not insert it */
                        return(&fallback);
                        }
                /* If a race occured in this function and we came second, tmpp
                 * is the first one that we just replaced. */
-               if(tmpp)
+               if (tmpp)
                        ERR_STATE_free(tmpp);
                }
-       return(ret);
+       return ret;
        }
 
 int ERR_get_next_error_library(void)