Add support for dynamically created and destroyed mutexes. This will
[openssl.git] / crypto / cryptlib.c
1 /* crypto/cryptlib.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  * 
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  * 
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  * 
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from 
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  * 
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  * 
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58
59 #include <stdio.h>
60 #include <string.h>
61 #include "cryptlib.h"
62 #include <openssl/crypto.h>
63 #include <openssl/safestack.h>
64
65 #if defined(WIN32) || defined(WIN16)
66 static double SSLeay_MSVC5_hack=0.0; /* and for VC1.5 */
67 #endif
68
69 DECLARE_STACK_OF(CRYPTO_dynlock);
70 IMPLEMENT_STACK_OF(CRYPTO_dynlock);
71
72 /* real #defines in crypto.h, keep these upto date */
73 static const char* lock_names[CRYPTO_NUM_LOCKS] =
74         {
75         "<<ERROR>>",
76         "err",
77         "err_hash",
78         "x509",
79         "x509_info",
80         "x509_pkey",
81         "x509_crl",
82         "x509_req",
83         "dsa",
84         "rsa",
85         "evp_pkey",
86         "x509_store",
87         "ssl_ctx",
88         "ssl_cert",
89         "ssl_session",
90         "ssl_sess_cert",
91         "ssl",
92         "rand",
93         "debug_malloc",
94         "BIO",
95         "gethostbyname",
96         "getservbyname",
97         "readdir",
98         "RSA_blinding",
99         "dh",
100         "debug_malloc2",
101         "dso",
102 #if CRYPTO_NUM_LOCKS != 27
103 # error "Inconsistency between crypto.h and cryptlib.c"
104 #endif
105         };
106
107 /* This is for applications to allocate new type names in the non-dynamic
108    array of lock names.  These are numbered with positive numbers.  */
109 static STACK *app_locks=NULL;
110
111 /* For applications that want a more dynamic way of handling threads, the
112    following stack is used.  These are externally numbered with negative
113    numbers.  */
114 static STACK_OF(CRYPTO_dynlock) *dyn_locks=NULL;
115
116
117 static void (MS_FAR *locking_callback)(int mode,int type,
118         const char *file,int line)=NULL;
119 static int (MS_FAR *add_lock_callback)(int *pointer,int amount,
120         int type,const char *file,int line)=NULL;
121 static unsigned long (MS_FAR *id_callback)(void)=NULL;
122 static CRYPTO_dynlock *(MS_FAR *dynlock_create_callback)(const char *file,
123         int line)=NULL;
124 static void (MS_FAR *dynlock_locking_callback)(int mode, CRYPTO_dynlock *l,
125         const char *file,int line)=NULL;
126 static void (MS_FAR *dynlock_destroy_callback)(CRYPTO_dynlock *l,
127         const char *file,int line)=NULL;
128 static int (MS_FAR *add_dynlock_callback)(int *pointer,int amount,
129         CRYPTO_dynlock *l,const char *file,int line)=NULL;
130
131 int CRYPTO_get_new_lockid(char *name)
132         {
133         char *str;
134         int i;
135
136         /* A hack to make Visual C++ 5.0 work correctly when linking as
137          * a DLL using /MT. Without this, the application cannot use
138          * and floating point printf's.
139          * It also seems to be needed for Visual C 1.5 (win16) */
140 #if defined(WIN32) || defined(WIN16)
141         SSLeay_MSVC5_hack=(double)name[0]*(double)name[1];
142 #endif
143
144         if ((app_locks == NULL) && ((app_locks=sk_new_null()) == NULL))
145                 {
146                 CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_LOCKID,ERR_R_MALLOC_FAILURE);
147                 return(0);
148                 }
149         if ((str=BUF_strdup(name)) == NULL)
150                 {
151                 CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_LOCKID,ERR_R_MALLOC_FAILURE);
152                 return(0);
153                 }
154         i=sk_push(app_locks,str);
155         if (!i)
156                 OPENSSL_free(str);
157         else
158                 i+=CRYPTO_NUM_LOCKS; /* gap of one :-) */
159         return(i);
160         }
161
162 int CRYPTO_num_locks(void)
163         {
164         return CRYPTO_NUM_LOCKS;
165         }
166
167 int CRYPTO_get_new_dynlockid(void)
168         {
169         int i = 0;
170         CRYPTO_dynlock *pointer = NULL;
171
172         if (dynlock_create_callback == NULL)
173                 {
174                 CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,CRYPTO_R_NO_DYNLOCK_CREATE_CALLBACK);
175                 return(0);
176                 }
177         if ((dyn_locks == NULL)
178                 && ((dyn_locks=sk_new_null()) == NULL))
179                 {
180                 CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,ERR_R_MALLOC_FAILURE);
181                 return(0);
182                 }
183
184         pointer = dynlock_create_callback(__FILE__,__LINE__);
185         if (pointer == NULL)
186                 {
187                 CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,ERR_R_MALLOC_FAILURE);
188                 return(0);
189                 }
190         i=sk_CRYPTO_dynlock_push(dyn_locks,pointer);
191         if (!i)
192                 dynlock_destroy_callback(pointer,__FILE__,__LINE__);
193         else
194                 i += 1; /* to avoid 0 */
195         return -i;
196         }
197
198 void CRYPTO_destroy_dynlockid(int i)
199         {
200         if (i)
201                 i = -i-1;
202         if (dyn_locks == NULL || i >= sk_CRYPTO_dynlock_num(dyn_locks))
203                 return;
204         if (dynlock_destroy_callback == NULL)
205                 return;
206         dynlock_destroy_callback(sk_CRYPTO_dynlock_value(dyn_locks, i),
207                 __FILE__,__LINE__);
208         sk_CRYPTO_dynlock_set(dyn_locks, i, NULL);
209         }
210
211 CRYPTO_dynlock *CRYPTO_get_dynlock_value(int i)
212         {
213         if (i)
214                 i = -i-1;
215         if (dyn_locks == NULL || i >= sk_CRYPTO_dynlock_num(dyn_locks))
216                 return NULL;
217         return sk_CRYPTO_dynlock_value(dyn_locks, i);
218         }
219
220 void (*CRYPTO_get_locking_callback(void))(int mode,int type,const char *file,
221                 int line)
222         {
223         return(locking_callback);
224         }
225
226 void (*CRYPTO_get_dynlock_lock_callback(void))(int mode,CRYPTO_dynlock *l,
227                                                const char *file,int line)
228         {
229         return(dynlock_locking_callback);
230         }
231
232 int (*CRYPTO_get_add_lock_callback(void))(int *num,int mount,int type,
233                                           const char *file,int line)
234         {
235         return(add_lock_callback);
236         }
237
238 int (*CRYPTO_get_add_dynlock_callback(void))(int *num,int mount,
239                                              CRYPTO_dynlock *l,
240                                              const char *file,int line)
241         {
242         return(add_dynlock_callback);
243         }
244
245 void CRYPTO_set_locking_callback(void (*func)(int mode,int type,
246                                               const char *file,int line))
247         {
248         locking_callback=func;
249         }
250
251 void CRYPTO_set_dynlock_locking_callback(void (*func)(int mode,
252                                                       CRYPTO_dynlock *l,
253                                                       const char *file,
254                                                       int line))
255         {
256         dynlock_locking_callback=func;
257         }
258
259 void CRYPTO_set_add_lock_callback(int (*func)(int *num,int mount,int type,
260                                               const char *file,int line))
261         {
262         add_lock_callback=func;
263         }
264
265 void CRYPTO_set_add_dynlock_lock_callback(int (*func)(int *num,int mount,
266                                                       CRYPTO_dynlock *l,
267                                                       const char *file,
268                                                       int line))
269         {
270         add_dynlock_callback=func;
271         }
272
273 unsigned long (*CRYPTO_get_id_callback(void))(void)
274         {
275         return(id_callback);
276         }
277
278 void CRYPTO_set_id_callback(unsigned long (*func)(void))
279         {
280         id_callback=func;
281         }
282
283 unsigned long CRYPTO_thread_id(void)
284         {
285         unsigned long ret=0;
286
287         if (id_callback == NULL)
288                 {
289 #ifdef WIN16
290                 ret=(unsigned long)GetCurrentTask();
291 #elif defined(WIN32)
292                 ret=(unsigned long)GetCurrentThreadId();
293 #elif defined(GETPID_IS_MEANINGLESS)
294                 ret=1L;
295 #else
296                 ret=(unsigned long)getpid();
297 #endif
298                 }
299         else
300                 ret=id_callback();
301         return(ret);
302         }
303
304 void CRYPTO_lock(int mode, int type, const char *file, int line)
305         {
306 #ifdef LOCK_DEBUG
307                 {
308                 char *rw_text,*operation_text;
309
310                 if (mode & CRYPTO_LOCK)
311                         operation_text="lock  ";
312                 else if (mode & CRYPTO_UNLOCK)
313                         operation_text="unlock";
314                 else
315                         operation_text="ERROR ";
316
317                 if (mode & CRYPTO_READ)
318                         rw_text="r";
319                 else if (mode & CRYPTO_WRITE)
320                         rw_text="w";
321                 else
322                         rw_text="ERROR";
323
324                 fprintf(stderr,"lock:%08lx:(%s)%s %-18s %s:%d\n",
325                         CRYPTO_thread_id(), rw_text, operation_text,
326                         CRYPTO_get_lock_name(type), file, line);
327                 }
328 #endif
329         if (type < 0)
330                 {
331                 int i = -type-1;
332                 if (i < sk_CRYPTO_dynlock_num(dyn_locks))
333                         dynlock_locking_callback(mode,
334                                 sk_CRYPTO_dynlock_value(dyn_locks,i),
335                                 file,line);
336                 }
337         else
338                 if (locking_callback != NULL)
339                         locking_callback(mode,type,file,line);
340         }
341
342 int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
343              int line)
344         {
345         int ret = 0;
346
347         if (add_lock_callback != NULL)
348                 {
349 #ifdef LOCK_DEBUG
350                 int before= *pointer;
351 #endif
352
353                 if (type < 0)
354                         {
355                         int i = -type-1;
356                         if (i >= sk_CRYPTO_dynlock_num(dyn_locks))
357                                 /* FIXME: This is superbly dangerous if there
358                                    are threads competing on this value, but
359                                    hey, if the user used an invalid lock... */
360                                 ret=(*pointer + amount);
361                         else
362                                 ret=add_dynlock_callback(pointer,amount,
363                                         sk_CRYPTO_dynlock_value(dyn_locks,i),
364                                         file,line);
365                         }
366                 else
367                         ret=add_lock_callback(pointer,amount,type,file,line);
368 #ifdef LOCK_DEBUG
369                 fprintf(stderr,"ladd:%08lx:%2d+%2d->%2d %-18s %s:%d\n",
370                         CRYPTO_thread_id(),
371                         before,amount,ret,
372                         CRYPTO_get_lock_name(type),
373                         file,line);
374 #endif
375                 *pointer=ret;
376                 }
377         else
378                 {
379                 CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,file,line);
380
381                 ret= *pointer+amount;
382 #ifdef LOCK_DEBUG
383                 fprintf(stderr,"ladd:%08lx:%2d+%2d->%2d %-18s %s:%d\n",
384                         CRYPTO_thread_id(),
385                         *pointer,amount,ret,
386                         CRYPTO_get_lock_name(type),
387                         file,line);
388 #endif
389                 *pointer=ret;
390                 CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,file,line);
391                 }
392         return(ret);
393         }
394
395 const char *CRYPTO_get_lock_name(int type)
396         {
397         if (type < 0)
398                 return("dynamic");
399         else if (type < CRYPTO_NUM_LOCKS)
400                 return(lock_names[type]);
401         else if (type-CRYPTO_NUM_LOCKS >= sk_num(app_locks))
402                 return("ERROR");
403         else
404                 return(sk_value(app_locks,type-CRYPTO_NUM_LOCKS));
405         }
406
407 #ifdef _DLL
408 #ifdef WIN32
409
410 /* All we really need to do is remove the 'error' state when a thread
411  * detaches */
412
413 BOOL WINAPI DLLEntryPoint(HINSTANCE hinstDLL, DWORD fdwReason,
414              LPVOID lpvReserved)
415         {
416         switch(fdwReason)
417                 {
418         case DLL_PROCESS_ATTACH:
419                 break;
420         case DLL_THREAD_ATTACH:
421                 break;
422         case DLL_THREAD_DETACH:
423                 ERR_remove_state(0);
424                 break;
425         case DLL_PROCESS_DETACH:
426                 break;
427                 }
428         return(TRUE);
429         }
430 #endif
431
432 #endif