More extension code. Incomplete support for subject and issuer alt
[openssl.git] / crypto / threads / th-lock.c
1 /* crypto/threads/th-lock.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 <stdlib.h>
61 #include <string.h>
62 #include <errno.h>
63 #ifdef LINUX
64 #include <typedefs.h>
65 #endif
66 #ifdef WIN32
67 #include <windows.h>
68 #endif
69 #ifdef SOLARIS
70 #include <synch.h>
71 #include <thread.h>
72 #endif
73 #ifdef IRIX
74 #include <ulocks.h>
75 #include <sys/prctl.h>
76 #endif
77 #include "lhash.h"
78 #include "crypto.h"
79 #include "buffer.h"
80 #include "e_os.h"
81 #include "x509.h"
82 #include "ssl.h"
83 #include "err.h"
84
85 #ifndef NOPROTO
86 int CRYPTO_thread_setup(void);
87 void CRYPTO_thread_cleanup(void);
88
89 static void irix_locking_callback(int mode,int type,char *file,int line);
90 static void solaris_locking_callback(int mode,int type,char *file,int line);
91 static void win32_locking_callback(int mode,int type,char *file,int line);
92 static void pthreads_locking_callback(int mode,int type,char *file,int line);
93
94 static unsigned long irix_thread_id(void );
95 static unsigned long solaris_thread_id(void );
96 static unsigned long pthreads_thread_id(void );
97
98 #else
99 int CRYPOTO_thread_setup();
100 void CRYPTO_cleanup();
101
102 static void irix_locking_callback();
103 static void solaris_locking_callback();
104 static void win32_locking_callback();
105 static void pthreads_locking_callback();
106
107 static unsigned long irix_thread_id();
108 static unsigned long solaris_thread_id();
109 static unsigned long pthreads_thread_id();
110
111 #endif
112
113 /* usage:
114  * CRYPTO_thread_setup();
115  * applicaion code
116  * CRYPTO_thread_cleanup();
117  */
118
119 #define THREAD_STACK_SIZE (16*1024)
120
121 #ifdef WIN32
122
123 static HANDLE lock_cs[CRYPTO_NUM_LOCKS];
124
125 int CRYPTO_thread_setup()
126         {
127         int i;
128
129         for (i=0; i<CRYPTO_NUM_LOCKS; i++)
130                 {
131                 lock_cs[i]=CreateMutex(NULL,FALSE,NULL);
132                 }
133
134         CRYPTO_set_locking_callback((void (*)(int,int,char *,int))win32_locking_callback);
135         /* id callback defined */
136         return(1);
137         }
138
139 static void CRYPTO_thread_cleanup()
140         {
141         int i;
142
143         CRYPTO_set_locking_callback(NULL);
144         for (i=0; i<CRYPTO_NUM_LOCKS; i++)
145                 CloseHandle(lock_cs[i]);
146         }
147
148 void win32_locking_callback(mode,type,file,line)
149 int mode;
150 int type;
151 char *file;
152 int line;
153         {
154         if (mode & CRYPTO_LOCK)
155                 {
156                 WaitForSingleObject(lock_cs[type],INFINITE);
157                 }
158         else
159                 {
160                 ReleaseMutex(lock_cs[type]);
161                 }
162         }
163
164 #endif /* WIN32 */
165
166 #ifdef SOLARIS
167
168 #define USE_MUTEX
169
170 static mutex_t lock_cs[CRYPTO_NUM_LOCKS];
171 #ifdef USE_MUTEX
172 static long lock_count[CRYPTO_NUM_LOCKS];
173 #else
174 static rwlock_t lock_cs[CRYPTO_NUM_LOCKS];
175 #endif
176
177 void CRYPTO_thread_setup()
178         {
179         int i;
180
181         for (i=0; i<CRYPTO_NUM_LOCKS; i++)
182                 {
183                 lock_count[i]=0;
184 #ifdef USE_MUTEX
185                 mutex_init(&(lock_cs[i]),USYNC_THREAD,NULL);
186 #else
187                 rwlock_init(&(lock_cs[i]),USYNC_THREAD,NULL);
188 #endif
189                 }
190
191         CRYPTO_set_id_callback((unsigned long (*)())solaris_thread_id);
192         CRYPTO_set_locking_callback((void (*)())solaris_locking_callback);
193         }
194
195 void CRYPTO_thread_cleanup()
196         {
197         int i;
198
199         CRYPTO_set_locking_callback(NULL);
200         for (i=0; i<CRYPTO_NUM_LOCKS; i++)
201                 {
202 #ifdef USE_MUTEX
203                 mutex_destroy(&(lock_cs[i]));
204 #else
205                 rwlock_destroy(&(lock_cs[i]));
206 #endif
207                 }
208         }
209
210 void solaris_locking_callback(mode,type,file,line)
211 int mode;
212 int type;
213 char *file;
214 int line;
215         {
216 #if 0
217         fprintf(stderr,"thread=%4d mode=%s lock=%s %s:%d\n",
218                 CRYPTO_thread_id(),
219                 (mode&CRYPTO_LOCK)?"l":"u",
220                 (type&CRYPTO_READ)?"r":"w",file,line);
221 #endif
222
223 #if 0
224         if (CRYPTO_LOCK_SSL_CERT == type)
225                 fprintf(stderr,"(t,m,f,l) %ld %d %s %d\n",
226                         CRYPTO_thread_id(),
227                         mode,file,line);
228 #endif
229         if (mode & CRYPTO_LOCK)
230                 {
231 #ifdef USE_MUTEX
232                 mutex_lock(&(lock_cs[type]));
233 #else
234                 if (mode & CRYPTO_READ)
235                         rw_rdlock(&(lock_cs[type]));
236                 else
237                         rw_wrlock(&(lock_cs[type]));
238 #endif
239                 lock_count[type]++;
240                 }
241         else
242                 {
243 #ifdef USE_MUTEX
244                 mutex_unlock(&(lock_cs[type]));
245 #else
246                 rw_unlock(&(lock_cs[type]));
247 #endif
248                 }
249         }
250
251 unsigned long solaris_thread_id()
252         {
253         unsigned long ret;
254
255         ret=(unsigned long)thr_self();
256         return(ret);
257         }
258 #endif /* SOLARIS */
259
260 #ifdef IRIX
261 /* I don't think this works..... */
262
263 static usptr_t *arena;
264 static usema_t *lock_cs[CRYPTO_NUM_LOCKS];
265
266 void CRYPTO_thread_setup()
267         {
268         int i;
269         char filename[20];
270
271         strcpy(filename,"/tmp/mttest.XXXXXX");
272         mktemp(filename);
273
274         usconfig(CONF_STHREADIOOFF);
275         usconfig(CONF_STHREADMALLOCOFF);
276         usconfig(CONF_INITUSERS,100);
277         usconfig(CONF_LOCKTYPE,US_DEBUGPLUS);
278         arena=usinit(filename);
279         unlink(filename);
280
281         for (i=0; i<CRYPTO_NUM_LOCKS; i++)
282                 {
283                 lock_cs[i]=usnewsema(arena,1);
284                 }
285
286         CRYPTO_set_id_callback((unsigned long (*)())irix_thread_id);
287         CRYPTO_set_locking_callback((void (*)())irix_locking_callback);
288         }
289
290 void CRYPTO_thread_cleanup()
291         {
292         int i;
293
294         CRYPTO_set_locking_callback(NULL);
295         for (i=0; i<CRYPTO_NUM_LOCKS; i++)
296                 {
297                 char buf[10];
298
299                 sprintf(buf,"%2d:",i);
300                 usdumpsema(lock_cs[i],stdout,buf);
301                 usfreesema(lock_cs[i],arena);
302                 }
303         }
304
305 void irix_locking_callback(mode,type,file,line)
306 int mode;
307 int type;
308 char *file;
309 int line;
310         {
311         if (mode & CRYPTO_LOCK)
312                 {
313                 uspsema(lock_cs[type]);
314                 }
315         else
316                 {
317                 usvsema(lock_cs[type]);
318                 }
319         }
320
321 unsigned long irix_thread_id()
322         {
323         unsigned long ret;
324
325         ret=(unsigned long)getpid();
326         return(ret);
327         }
328 #endif /* IRIX */
329
330 /* Linux and a few others */
331 #ifdef PTHREADS
332
333 static pthread_mutex_t lock_cs[CRYPTO_NUM_LOCKS];
334 static long lock_count[CRYPTO_NUM_LOCKS];
335
336 void CRYPTO_thread_setup()
337         {
338         int i;
339
340         for (i=0; i<CRYPTO_NUM_LOCKS; i++)
341                 {
342                 lock_count[i]=0;
343                 pthread_mutex_init(&(lock_cs[i]),NULL);
344                 }
345
346         CRYPTO_set_id_callback((unsigned long (*)())pthreads_thread_id);
347         CRYPTO_set_locking_callback((void (*)())pthreads_locking_callback);
348         }
349
350 void thread_cleanup()
351         {
352         int i;
353
354         CRYPTO_set_locking_callback(NULL);
355         for (i=0; i<CRYPTO_NUM_LOCKS; i++)
356                 {
357                 pthread_mutex_destroy(&(lock_cs[i]));
358                 }
359         }
360
361 void pthreads_locking_callback(mode,type,file,line)
362 int mode;
363 int type;
364 char *file;
365 int line;
366       {
367 #if 0
368         fprintf(stderr,"thread=%4d mode=%s lock=%s %s:%d\n",
369                 CRYPTO_thread_id(),
370                 (mode&CRYPTO_LOCK)?"l":"u",
371                 (type&CRYPTO_READ)?"r":"w",file,line);
372 #endif
373 #if 0
374         if (CRYPTO_LOCK_SSL_CERT == type)
375                 fprintf(stderr,"(t,m,f,l) %ld %d %s %d\n",
376                 CRYPTO_thread_id(),
377                 mode,file,line);
378 #endif
379         if (mode & CRYPTO_LOCK)
380                 {
381                 pthread_mutex_lock(&(lock_cs[type]));
382                 lock_count[type]++;
383                 }
384         else
385                 {
386                 pthread_mutex_unlock(&(lock_cs[type]));
387                 }
388         }
389
390 unsigned long pthreads_thread_id()
391         {
392         unsigned long ret;
393
394         ret=(unsigned long)pthread_self();
395         return(ret);
396         }
397
398 #endif /* PTHREADS */
399