Add support for dynamically created and destroyed mutexes. This will

[openssl.git] / crypto / cryptlib.c

diff --git a/crypto/cryptlib.c b/crypto/cryptlib.c
index 9a7e80b7f8b66ec560b0c3da9d7d97ea745a6cb6..bc692720c5762e2b506b295e28221591cef2d92a 100644 (file)
--- a/crypto/cryptlib.c
+++ b/crypto/cryptlib.c
@@ -59,15 +59,18 @@
 #include <stdio.h>
 #include <string.h>
 #include "cryptlib.h"
 #include <stdio.h>
 #include <string.h>
 #include "cryptlib.h"

-#include "crypto.h"
-#include "date.h"
+#include <openssl/crypto.h>
+#include <openssl/safestack.h>

 
 #if defined(WIN32) || defined(WIN16)
 static double SSLeay_MSVC5_hack=0.0; /* and for VC1.5 */
 #endif
 
 
 #if defined(WIN32) || defined(WIN16)
 static double SSLeay_MSVC5_hack=0.0; /* and for VC1.5 */
 #endif
 

+DECLARE_STACK_OF(CRYPTO_dynlock);
+IMPLEMENT_STACK_OF(CRYPTO_dynlock);
+

 /* real #defines in crypto.h, keep these upto date */
 /* real #defines in crypto.h, keep these upto date */

-static char* lock_names[CRYPTO_NUM_LOCKS] =
+static const char* lock_names[CRYPTO_NUM_LOCKS] =

        {
        "<<ERROR>>",
        "err",
        {
        "<<ERROR>>",
        "err",


@@ -84,30 +87,48 @@ static char* lock_names[CRYPTO_NUM_LOCKS] =
        "ssl_ctx",
        "ssl_cert",
        "ssl_session",
        "ssl_ctx",
        "ssl_cert",
        "ssl_session",

+       "ssl_sess_cert",

        "ssl",
        "rand",
        "debug_malloc",
        "BIO",
        "ssl",
        "rand",
        "debug_malloc",
        "BIO",

-       "bio_gethostbyname",
+       "gethostbyname",
+       "getservbyname",
+       "readdir",

        "RSA_blinding",
        "RSA_blinding",

+       "dh",
+       "debug_malloc2",
+       "dso",
+#if CRYPTO_NUM_LOCKS != 27
+# error "Inconsistency between crypto.h and cryptlib.c"
+#endif

        };
 
        };
 

+/* This is for applications to allocate new type names in the non-dynamic
+   array of lock names.  These are numbered with positive numbers.  */

 static STACK *app_locks=NULL;
 
 static STACK *app_locks=NULL;
 

-#ifndef NOPROTO
+/* For applications that want a more dynamic way of handling threads, the
+   following stack is used.  These are externally numbered with negative
+   numbers.  */
+static STACK_OF(CRYPTO_dynlock) *dyn_locks=NULL;
+
+

 static void (MS_FAR *locking_callback)(int mode,int type,
 static void (MS_FAR *locking_callback)(int mode,int type,

-       char *file,int line)=NULL;
+       const char *file,int line)=NULL;

 static int (MS_FAR *add_lock_callback)(int *pointer,int amount,
 static int (MS_FAR *add_lock_callback)(int *pointer,int amount,

-       int type,char *file,int line)=NULL;
+       int type,const char *file,int line)=NULL;

 static unsigned long (MS_FAR *id_callback)(void)=NULL;
 static unsigned long (MS_FAR *id_callback)(void)=NULL;

-#else
-static void (MS_FAR *locking_callback)()=NULL;
-static int (MS_FAR *add_lock_callback)()=NULL;
-static unsigned long (MS_FAR *id_callback)()=NULL;
-#endif
+static CRYPTO_dynlock *(MS_FAR *dynlock_create_callback)(const char *file,
+       int line)=NULL;
+static void (MS_FAR *dynlock_locking_callback)(int mode, CRYPTO_dynlock *l,
+       const char *file,int line)=NULL;
+static void (MS_FAR *dynlock_destroy_callback)(CRYPTO_dynlock *l,
+       const char *file,int line)=NULL;
+static int (MS_FAR *add_dynlock_callback)(int *pointer,int amount,
+       CRYPTO_dynlock *l,const char *file,int line)=NULL;

 
 

-int CRYPTO_get_new_lockid(name)
-char *name;
+int CRYPTO_get_new_lockid(char *name)

        {
        char *str;
        int i;
        {
        char *str;
        int i;


@@ -120,54 +141,146 @@ char *name;
        SSLeay_MSVC5_hack=(double)name[0]*(double)name[1];
 #endif
 
        SSLeay_MSVC5_hack=(double)name[0]*(double)name[1];
 #endif
 

-       if (app_locks == NULL)
-               if ((app_locks=sk_new_null()) == NULL)
-                       CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_LOCKID,ERR_R_MALLOC_FAILURE);
-                       return(0);
+       if ((app_locks == NULL) && ((app_locks=sk_new_null()) == NULL))
+               {
+               CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_LOCKID,ERR_R_MALLOC_FAILURE);
+               return(0);
+               }

        if ((str=BUF_strdup(name)) == NULL)
        if ((str=BUF_strdup(name)) == NULL)

+               {
+               CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_LOCKID,ERR_R_MALLOC_FAILURE);

                return(0);
                return(0);

+               }

        i=sk_push(app_locks,str);
        if (!i)
        i=sk_push(app_locks,str);
        if (!i)

-               Free(str);
+               OPENSSL_free(str);

        else
                i+=CRYPTO_NUM_LOCKS; /* gap of one :-) */
        return(i);
        }
 
        else
                i+=CRYPTO_NUM_LOCKS; /* gap of one :-) */
        return(i);
        }
 

-void (*CRYPTO_get_locking_callback(P_V))(P_I_I_P_I)
+int CRYPTO_num_locks(void)
+       {
+       return CRYPTO_NUM_LOCKS;
+       }
+
+int CRYPTO_get_new_dynlockid(void)
+       {
+       int i = 0;
+       CRYPTO_dynlock *pointer = NULL;
+
+       if (dynlock_create_callback == NULL)
+               {
+               CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,CRYPTO_R_NO_DYNLOCK_CREATE_CALLBACK);
+               return(0);
+               }
+       if ((dyn_locks == NULL)
+               && ((dyn_locks=sk_new_null()) == NULL))
+               {
+               CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,ERR_R_MALLOC_FAILURE);
+               return(0);
+               }
+
+       pointer = dynlock_create_callback(__FILE__,__LINE__);
+       if (pointer == NULL)
+               {
+               CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,ERR_R_MALLOC_FAILURE);
+               return(0);
+               }
+       i=sk_CRYPTO_dynlock_push(dyn_locks,pointer);
+       if (!i)
+               dynlock_destroy_callback(pointer,__FILE__,__LINE__);
+       else
+               i += 1; /* to avoid 0 */
+       return -i;
+       }
+
+void CRYPTO_destroy_dynlockid(int i)
+       {
+       if (i)
+               i = -i-1;
+       if (dyn_locks == NULL || i >= sk_CRYPTO_dynlock_num(dyn_locks))
+               return;
+       if (dynlock_destroy_callback == NULL)
+               return;
+       dynlock_destroy_callback(sk_CRYPTO_dynlock_value(dyn_locks, i),
+               __FILE__,__LINE__);
+       sk_CRYPTO_dynlock_set(dyn_locks, i, NULL);
+       }
+
+CRYPTO_dynlock *CRYPTO_get_dynlock_value(int i)
+       {
+       if (i)
+               i = -i-1;
+       if (dyn_locks == NULL || i >= sk_CRYPTO_dynlock_num(dyn_locks))
+               return NULL;
+       return sk_CRYPTO_dynlock_value(dyn_locks, i);
+       }
+
+void (*CRYPTO_get_locking_callback(void))(int mode,int type,const char *file,
+               int line)

        {
        return(locking_callback);
        }
 
        {
        return(locking_callback);
        }
 

-int (*CRYPTO_get_add_lock_callback(P_V))(P_IP_I_I_P_I)
+void (*CRYPTO_get_dynlock_lock_callback(void))(int mode,CRYPTO_dynlock *l,
+                                              const char *file,int line)
+       {
+       return(dynlock_locking_callback);
+       }
+
+int (*CRYPTO_get_add_lock_callback(void))(int *num,int mount,int type,
+                                         const char *file,int line)

        {
        return(add_lock_callback);
        }
 
        {
        return(add_lock_callback);
        }
 

-void CRYPTO_set_locking_callback(func)
-void (*func)(P_I_I_P_I);
+int (*CRYPTO_get_add_dynlock_callback(void))(int *num,int mount,
+                                            CRYPTO_dynlock *l,
+                                            const char *file,int line)
+       {
+       return(add_dynlock_callback);
+       }
+
+void CRYPTO_set_locking_callback(void (*func)(int mode,int type,
+                                             const char *file,int line))

        {
        locking_callback=func;
        }
 
        {
        locking_callback=func;
        }
 

-void CRYPTO_set_add_lock_callback(func)
-int (*func)(P_IP_I_I_P_I);
+void CRYPTO_set_dynlock_locking_callback(void (*func)(int mode,
+                                                     CRYPTO_dynlock *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))

        {
        add_lock_callback=func;
        }
 
        {
        add_lock_callback=func;
        }
 

-unsigned long (*CRYPTO_get_id_callback(P_V))(P_V)
+void CRYPTO_set_add_dynlock_lock_callback(int (*func)(int *num,int mount,
+                                                     CRYPTO_dynlock *l,
+                                                     const char *file,
+                                                     int line))
+       {
+       add_dynlock_callback=func;
+       }
+
+unsigned long (*CRYPTO_get_id_callback(void))(void)

        {
        return(id_callback);
        }
 
        {
        return(id_callback);
        }
 

-void CRYPTO_set_id_callback(func)
-unsigned long (*func)(P_V);
+void CRYPTO_set_id_callback(unsigned long (*func)(void))

        {
        id_callback=func;
        }
 
        {
        id_callback=func;
        }
 

-unsigned long CRYPTO_thread_id()
+unsigned long CRYPTO_thread_id(void)

        {
        unsigned long ret=0;
 
        {
        unsigned long ret=0;
 


@@ -177,7 +290,7 @@ unsigned long CRYPTO_thread_id()
                ret=(unsigned long)GetCurrentTask();
 #elif defined(WIN32)
                ret=(unsigned long)GetCurrentThreadId();
                ret=(unsigned long)GetCurrentTask();
 #elif defined(WIN32)
                ret=(unsigned long)GetCurrentThreadId();

-#elif defined(MSDOS)
+#elif defined(GETPID_IS_MEANINGLESS)

                ret=1L;
 #else
                ret=(unsigned long)getpid();
                ret=1L;
 #else
                ret=(unsigned long)getpid();


@@ -188,11 +301,7 @@ unsigned long CRYPTO_thread_id()
        return(ret);
        }
 
        return(ret);
        }
 

-void CRYPTO_lock(mode,type,file,line)
-int mode;
-int type;
-char *file;
-int line;
+void CRYPTO_lock(int mode, int type, const char *file, int line)

        {
 #ifdef LOCK_DEBUG
                {
        {
 #ifdef LOCK_DEBUG
                {


@@ -217,18 +326,23 @@ int line;
                        CRYPTO_get_lock_name(type), file, line);
                }
 #endif
                        CRYPTO_get_lock_name(type), file, line);
                }
 #endif

-       if (locking_callback != NULL)
-               locking_callback(mode,type,file,line);
+       if (type < 0)
+               {
+               int i = -type-1;
+               if (i < sk_CRYPTO_dynlock_num(dyn_locks))
+                       dynlock_locking_callback(mode,
+                               sk_CRYPTO_dynlock_value(dyn_locks,i),
+                               file,line);
+               }
+       else
+               if (locking_callback != NULL)
+                       locking_callback(mode,type,file,line);

        }
 
        }
 

-int CRYPTO_add_lock(pointer,amount,type,file,line)
-int *pointer;
-int amount;
-int type;
-char *file;
-int line;
+int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
+            int line)

        {
        {

-       int ret;
+       int ret = 0;

 
        if (add_lock_callback != NULL)
                {
 
        if (add_lock_callback != NULL)
                {


@@ -236,7 +350,21 @@ int line;
                int before= *pointer;
 #endif
 
                int before= *pointer;
 #endif
 

-               ret=add_lock_callback(pointer,amount,type,file,line);
+               if (type < 0)
+                       {
+                       int i = -type-1;
+                       if (i >= sk_CRYPTO_dynlock_num(dyn_locks))
+                               /* FIXME: This is superbly dangerous if there
+                                  are threads competing on this value, but
+                                  hey, if the user used an invalid lock... */
+                               ret=(*pointer + amount);
+                       else
+                               ret=add_dynlock_callback(pointer,amount,
+                                       sk_CRYPTO_dynlock_value(dyn_locks,i),
+                                       file,line);
+                       }
+               else
+                       ret=add_lock_callback(pointer,amount,type,file,line);

 #ifdef LOCK_DEBUG
                fprintf(stderr,"ladd:%08lx:%2d+%2d->%2d %-18s %s:%d\n",
                        CRYPTO_thread_id(),
 #ifdef LOCK_DEBUG
                fprintf(stderr,"ladd:%08lx:%2d+%2d->%2d %-18s %s:%d\n",
                        CRYPTO_thread_id(),


@@ -264,11 +392,10 @@ int line;
        return(ret);
        }
 
        return(ret);
        }
 

-char *CRYPTO_get_lock_name(type)
-int type;
+const char *CRYPTO_get_lock_name(int type)

        {
        if (type < 0)
        {
        if (type < 0)

-               return("ERROR");
+               return("dynamic");

        else if (type < CRYPTO_NUM_LOCKS)
                return(lock_names[type]);
        else if (type-CRYPTO_NUM_LOCKS >= sk_num(app_locks))
        else if (type < CRYPTO_NUM_LOCKS)
                return(lock_names[type]);
        else if (type-CRYPTO_NUM_LOCKS >= sk_num(app_locks))


@@ -283,10 +410,8 @@ int type;
 /* All we really need to do is remove the 'error' state when a thread
  * detaches */
 
 /* All we really need to do is remove the 'error' state when a thread
  * detaches */
 

-BOOL WINAPI DLLEntryPoint(hinstDLL,fdwReason,lpvReserved)
-HINSTANCE hinstDLL;
-DWORD fdwReason;
-LPVOID lpvReserved;
+BOOL WINAPI DLLEntryPoint(HINSTANCE hinstDLL, DWORD fdwReason,
+            LPVOID lpvReserved)

        {
        switch(fdwReason)
                {
        {
        switch(fdwReason)
                {