fix submitted by Andy Schneider <andy.schneider@bjss.co.uk>

[openssl.git] / crypto / cryptlib.c

diff --git a/crypto/cryptlib.c b/crypto/cryptlib.c
index f5e44311f48deaf725e2910aa6dcefdd057508c9..2f62fd77c64973e2fdde2feeb583117b8f35d6a7 100644 (file)
--- a/crypto/cryptlib.c
+++ b/crypto/cryptlib.c
@@ -62,19 +62,19 @@
 #include <openssl/crypto.h>
 #include <openssl/safestack.h>
 
-#if defined(WIN32) || defined(WIN16)
+#if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN16)
 static double SSLeay_MSVC5_hack=0.0; /* and for VC1.5 */
 #endif
 
-DECLARE_STACK_OF(CRYPTO_dynlock);
-IMPLEMENT_STACK_OF(CRYPTO_dynlock);
+DECLARE_STACK_OF(CRYPTO_dynlock)
+IMPLEMENT_STACK_OF(CRYPTO_dynlock)
 
 /* real #defines in crypto.h, keep these upto date */
 static const char* lock_names[CRYPTO_NUM_LOCKS] =
        {
        "<<ERROR>>",
        "err",
-       "err_hash",
+       "ex_data",
        "x509",
        "x509_info",
        "x509_pkey",
@@ -90,6 +90,7 @@ static const char* lock_names[CRYPTO_NUM_LOCKS] =
        "ssl_sess_cert",
        "ssl",
        "rand",
+       "rand2",
        "debug_malloc",
        "BIO",
        "gethostbyname",
@@ -100,7 +101,9 @@ static const char* lock_names[CRYPTO_NUM_LOCKS] =
        "debug_malloc2",
        "dso",
        "dynlock",
-#if CRYPTO_NUM_LOCKS != 28
+       "engine",
+       "ui",
+#if CRYPTO_NUM_LOCKS != 31
 # error "Inconsistency between crypto.h and cryptlib.c"
 #endif
        };
@@ -122,7 +125,7 @@ static int (MS_FAR *add_lock_callback)(int *pointer,int amount,
 static unsigned long (MS_FAR *id_callback)(void)=NULL;
 static struct CRYPTO_dynlock_value *(MS_FAR *dynlock_create_callback)
        (const char *file,int line)=NULL;
-static void (MS_FAR *dynlock_locking_callback)(int mode,
+static void (MS_FAR *dynlock_lock_callback)(int mode,
        struct CRYPTO_dynlock_value *l, const char *file,int line)=NULL;
 static void (MS_FAR *dynlock_destroy_callback)(struct CRYPTO_dynlock_value *l,
        const char *file,int line)=NULL;
@@ -132,11 +135,11 @@ int CRYPTO_get_new_lockid(char *name)
        char *str;
        int i;
 
+#if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN16)
        /* A hack to make Visual C++ 5.0 work correctly when linking as
         * a DLL using /MT. Without this, the application cannot use
         * and floating point printf's.
         * It also seems to be needed for Visual C 1.5 (win16) */
-#if defined(WIN32) || defined(WIN16)
        SSLeay_MSVC5_hack=(double)name[0]*(double)name[1];
 #endif
 
@@ -175,7 +178,7 @@ int CRYPTO_get_new_dynlockid(void)
                }
        CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
        if ((dyn_locks == NULL)
-               && ((dyn_locks=sk_new_null()) == NULL))
+               && ((dyn_locks=sk_CRYPTO_dynlock_new_null()) == NULL))
                {
                CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
                CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,ERR_R_MALLOC_FAILURE);
@@ -199,7 +202,11 @@ int CRYPTO_get_new_dynlockid(void)
                }
 
        CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
-       i=sk_CRYPTO_dynlock_push(dyn_locks,pointer);
+       /* First, try to find an existing empty slot */
+       i=sk_CRYPTO_dynlock_find(dyn_locks,NULL);
+       /* If there was none, push, thereby creating a new one */
+       if (i == -1)
+               i=sk_CRYPTO_dynlock_push(dyn_locks,pointer);
        CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
 
        if (!i)
@@ -223,7 +230,10 @@ void CRYPTO_destroy_dynlockid(int i)
        CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
 
        if (dyn_locks == NULL || i >= sk_CRYPTO_dynlock_num(dyn_locks))
+               {
+               CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
                return;
+               }
        pointer = sk_CRYPTO_dynlock_value(dyn_locks, i);
        if (pointer != NULL)
                {
@@ -236,7 +246,7 @@ void CRYPTO_destroy_dynlockid(int i)
                        }
                else
 #endif
-                       if (--(pointer->references) <= 0)
+                       if (pointer->references <= 0)
                                {
                                sk_CRYPTO_dynlock_set(dyn_locks, i, NULL);
                                }
@@ -272,16 +282,47 @@ struct CRYPTO_dynlock_value *CRYPTO_get_dynlock_value(int i)
        return NULL;
        }
 
-void (*CRYPTO_get_locking_callback(void))(int mode,int type,const char *file,
-               int line)
+struct CRYPTO_dynlock_value *(*CRYPTO_get_dynlock_create_callback(void))
+       (const char *file,int line)
        {
-       return(locking_callback);
+       return(dynlock_create_callback);
        }
 
 void (*CRYPTO_get_dynlock_lock_callback(void))(int mode,
        struct CRYPTO_dynlock_value *l, const char *file,int line)
        {
-       return(dynlock_locking_callback);
+       return(dynlock_lock_callback);
+       }
+
+void (*CRYPTO_get_dynlock_destroy_callback(void))
+       (struct CRYPTO_dynlock_value *l, const char *file,int line)
+       {
+       return(dynlock_destroy_callback);
+       }
+
+void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *(*func)
+       (const char *file, int line))
+       {
+       dynlock_create_callback=func;
+       }
+
+void CRYPTO_set_dynlock_lock_callback(void (*func)(int mode,
+       struct CRYPTO_dynlock_value *l, const char *file, int line))
+       {
+       dynlock_lock_callback=func;
+       }
+
+void CRYPTO_set_dynlock_destroy_callback(void (*func)
+       (struct CRYPTO_dynlock_value *l, const char *file, int line))
+       {
+       dynlock_destroy_callback=func;
+       }
+
+
+void (*CRYPTO_get_locking_callback(void))(int mode,int type,const char *file,
+               int line)
+       {
+       return(locking_callback);
        }
 
 int (*CRYPTO_get_add_lock_callback(void))(int *num,int mount,int type,
@@ -296,12 +337,6 @@ void CRYPTO_set_locking_callback(void (*func)(int mode,int type,
        locking_callback=func;
        }
 
-void CRYPTO_set_dynlock_locking_callback(void (*func)(int mode,
-       struct CRYPTO_dynlock_value *l, const char *file, int line))
-       {
-       dynlock_locking_callback=func;
-       }
-
 void CRYPTO_set_add_lock_callback(int (*func)(int *num,int mount,int type,
                                              const char *file,int line))
        {
@@ -324,9 +359,9 @@ unsigned long CRYPTO_thread_id(void)
 
        if (id_callback == NULL)
                {
-#ifdef WIN16
+#ifdef OPENSSL_SYS_WIN16
                ret=(unsigned long)GetCurrentTask();
-#elif defined(WIN32)
+#elif defined(OPENSSL_SYS_WIN32)
                ret=(unsigned long)GetCurrentThreadId();
 #elif defined(GETPID_IS_MEANINGLESS)
                ret=1L;
@@ -366,16 +401,15 @@ void CRYPTO_lock(int mode, int type, const char *file, int line)
 #endif
        if (type < 0)
                {
-               int i = -type - 1;
                struct CRYPTO_dynlock_value *pointer
-                       = CRYPTO_get_dynlock_value(i);
+                       = CRYPTO_get_dynlock_value(type);
 
-               if (pointer)
+               if (pointer && dynlock_lock_callback)
                        {
-                       dynlock_locking_callback(mode, pointer, file, line);
+                       dynlock_lock_callback(mode, pointer, file, line);
                        }
 
-               CRYPTO_destroy_dynlockid(i);
+               CRYPTO_destroy_dynlockid(type);
                }
        else
                if (locking_callback != NULL)
@@ -401,7 +435,6 @@ int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
                        CRYPTO_get_lock_name(type),
                        file,line);
 #endif
-               *pointer=ret;
                }
        else
                {
@@ -434,7 +467,7 @@ const char *CRYPTO_get_lock_name(int type)
        }
 
 #ifdef _DLL
-#ifdef WIN32
+#ifdef OPENSSL_SYS_WIN32
 
 /* All we really need to do is remove the 'error' state when a thread
  * detaches */