summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/threads/th-lock.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/libcrypto/threads/th-lock.c')
-rw-r--r--src/lib/libcrypto/threads/th-lock.c399
1 files changed, 399 insertions, 0 deletions
diff --git a/src/lib/libcrypto/threads/th-lock.c b/src/lib/libcrypto/threads/th-lock.c
new file mode 100644
index 0000000000..039022446d
--- /dev/null
+++ b/src/lib/libcrypto/threads/th-lock.c
@@ -0,0 +1,399 @@
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
86int CRYPTO_thread_setup(void);
87void CRYPTO_thread_cleanup(void);
88
89static void irix_locking_callback(int mode,int type,char *file,int line);
90static void solaris_locking_callback(int mode,int type,char *file,int line);
91static void win32_locking_callback(int mode,int type,char *file,int line);
92static void pthreads_locking_callback(int mode,int type,char *file,int line);
93
94static unsigned long irix_thread_id(void );
95static unsigned long solaris_thread_id(void );
96static unsigned long pthreads_thread_id(void );
97
98#else
99int CRYPOTO_thread_setup();
100void CRYPTO_cleanup();
101
102static void irix_locking_callback();
103static void solaris_locking_callback();
104static void win32_locking_callback();
105static void pthreads_locking_callback();
106
107static unsigned long irix_thread_id();
108static unsigned long solaris_thread_id();
109static 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
123static HANDLE lock_cs[CRYPTO_NUM_LOCKS];
124
125int 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
139static 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
148void win32_locking_callback(mode,type,file,line)
149int mode;
150int type;
151char *file;
152int 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
170static mutex_t lock_cs[CRYPTO_NUM_LOCKS];
171#ifdef USE_MUTEX
172static long lock_count[CRYPTO_NUM_LOCKS];
173#else
174static rwlock_t lock_cs[CRYPTO_NUM_LOCKS];
175#endif
176
177void 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
195void 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
210void solaris_locking_callback(mode,type,file,line)
211int mode;
212int type;
213char *file;
214int 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
251unsigned 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
263static usptr_t *arena;
264static usema_t *lock_cs[CRYPTO_NUM_LOCKS];
265
266void 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
290void 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
305void irix_locking_callback(mode,type,file,line)
306int mode;
307int type;
308char *file;
309int 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
321unsigned 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
333static pthread_mutex_t lock_cs[CRYPTO_NUM_LOCKS];
334static long lock_count[CRYPTO_NUM_LOCKS];
335
336void 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
350void 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
361void pthreads_locking_callback(mode,type,file,line)
362int mode;
363int type;
364char *file;
365int 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
390unsigned 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
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-11-02 11:23:50 +0000