Branch data Line data Source code
1 : : /* crypto/cryptlib.c */
2 : : /* ====================================================================
3 : : * Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved.
4 : : *
5 : : * Redistribution and use in source and binary forms, with or without
6 : : * modification, are permitted provided that the following conditions
7 : : * are met:
8 : : *
9 : : * 1. Redistributions of source code must retain the above copyright
10 : : * notice, this list of conditions and the following disclaimer.
11 : : *
12 : : * 2. Redistributions in binary form must reproduce the above copyright
13 : : * notice, this list of conditions and the following disclaimer in
14 : : * the documentation and/or other materials provided with the
15 : : * distribution.
16 : : *
17 : : * 3. All advertising materials mentioning features or use of this
18 : : * software must display the following acknowledgment:
19 : : * "This product includes software developed by the OpenSSL Project
20 : : * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
21 : : *
22 : : * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
23 : : * endorse or promote products derived from this software without
24 : : * prior written permission. For written permission, please contact
25 : : * openssl-core@openssl.org.
26 : : *
27 : : * 5. Products derived from this software may not be called "OpenSSL"
28 : : * nor may "OpenSSL" appear in their names without prior written
29 : : * permission of the OpenSSL Project.
30 : : *
31 : : * 6. Redistributions of any form whatsoever must retain the following
32 : : * acknowledgment:
33 : : * "This product includes software developed by the OpenSSL Project
34 : : * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
35 : : *
36 : : * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
37 : : * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
38 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
39 : : * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
40 : : * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
41 : : * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
42 : : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
43 : : * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
44 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
45 : : * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
46 : : * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
47 : : * OF THE POSSIBILITY OF SUCH DAMAGE.
48 : : * ====================================================================
49 : : *
50 : : * This product includes cryptographic software written by Eric Young
51 : : * (eay@cryptsoft.com). This product includes software written by Tim
52 : : * Hudson (tjh@cryptsoft.com).
53 : : *
54 : : */
55 : : /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
56 : : * All rights reserved.
57 : : *
58 : : * This package is an SSL implementation written
59 : : * by Eric Young (eay@cryptsoft.com).
60 : : * The implementation was written so as to conform with Netscapes SSL.
61 : : *
62 : : * This library is free for commercial and non-commercial use as long as
63 : : * the following conditions are aheared to. The following conditions
64 : : * apply to all code found in this distribution, be it the RC4, RSA,
65 : : * lhash, DES, etc., code; not just the SSL code. The SSL documentation
66 : : * included with this distribution is covered by the same copyright terms
67 : : * except that the holder is Tim Hudson (tjh@cryptsoft.com).
68 : : *
69 : : * Copyright remains Eric Young's, and as such any Copyright notices in
70 : : * the code are not to be removed.
71 : : * If this package is used in a product, Eric Young should be given attribution
72 : : * as the author of the parts of the library used.
73 : : * This can be in the form of a textual message at program startup or
74 : : * in documentation (online or textual) provided with the package.
75 : : *
76 : : * Redistribution and use in source and binary forms, with or without
77 : : * modification, are permitted provided that the following conditions
78 : : * are met:
79 : : * 1. Redistributions of source code must retain the copyright
80 : : * notice, this list of conditions and the following disclaimer.
81 : : * 2. Redistributions in binary form must reproduce the above copyright
82 : : * notice, this list of conditions and the following disclaimer in the
83 : : * documentation and/or other materials provided with the distribution.
84 : : * 3. All advertising materials mentioning features or use of this software
85 : : * must display the following acknowledgement:
86 : : * "This product includes cryptographic software written by
87 : : * Eric Young (eay@cryptsoft.com)"
88 : : * The word 'cryptographic' can be left out if the rouines from the library
89 : : * being used are not cryptographic related :-).
90 : : * 4. If you include any Windows specific code (or a derivative thereof) from
91 : : * the apps directory (application code) you must include an acknowledgement:
92 : : * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
93 : : *
94 : : * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
95 : : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
96 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
97 : : * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
98 : : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
99 : : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
100 : : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
101 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
102 : : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
103 : : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
104 : : * SUCH DAMAGE.
105 : : *
106 : : * The licence and distribution terms for any publically available version or
107 : : * derivative of this code cannot be changed. i.e. this code cannot simply be
108 : : * copied and put under another distribution licence
109 : : * [including the GNU Public Licence.]
110 : : */
111 : : /* ====================================================================
112 : : * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
113 : : * ECDH support in OpenSSL originally developed by
114 : : * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
115 : : */
116 : :
117 : : #include "cryptlib.h"
118 : : #include <openssl/safestack.h>
119 : : #ifdef OPENSSL_FIPS
120 : : #include <openssl/fips.h>
121 : : #endif
122 : :
123 : : #if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN16)
124 : : static double SSLeay_MSVC5_hack=0.0; /* and for VC1.5 */
125 : : #endif
126 : :
127 : : DECLARE_STACK_OF(CRYPTO_dynlock)
128 : :
129 : : /* real #defines in crypto.h, keep these upto date */
130 : : static const char* const lock_names[CRYPTO_NUM_LOCKS] =
131 : : {
132 : : "<<ERROR>>",
133 : : "err",
134 : : "ex_data",
135 : : "x509",
136 : : "x509_info",
137 : : "x509_pkey",
138 : : "x509_crl",
139 : : "x509_req",
140 : : "dsa",
141 : : "rsa",
142 : : "evp_pkey",
143 : : "x509_store",
144 : : "ssl_ctx",
145 : : "ssl_cert",
146 : : "ssl_session",
147 : : "ssl_sess_cert",
148 : : "ssl",
149 : : "ssl_method",
150 : : "rand",
151 : : "rand2",
152 : : "debug_malloc",
153 : : "BIO",
154 : : "gethostbyname",
155 : : "getservbyname",
156 : : "readdir",
157 : : "RSA_blinding",
158 : : "dh",
159 : : "debug_malloc2",
160 : : "dso",
161 : : "dynlock",
162 : : "engine",
163 : : "ui",
164 : : "ecdsa",
165 : : "ec",
166 : : "ecdh",
167 : : "bn",
168 : : "ec_pre_comp",
169 : : "store",
170 : : "comp",
171 : : "fips",
172 : : "fips2",
173 : : #if CRYPTO_NUM_LOCKS != 41
174 : : # error "Inconsistency between crypto.h and cryptlib.c"
175 : : #endif
176 : : };
177 : :
178 : : /* This is for applications to allocate new type names in the non-dynamic
179 : : array of lock names. These are numbered with positive numbers. */
180 : : static STACK_OF(OPENSSL_STRING) *app_locks=NULL;
181 : :
182 : : /* For applications that want a more dynamic way of handling threads, the
183 : : following stack is used. These are externally numbered with negative
184 : : numbers. */
185 : : static STACK_OF(CRYPTO_dynlock) *dyn_locks=NULL;
186 : :
187 : :
188 : : static void (MS_FAR *locking_callback)(int mode,int type,
189 : : const char *file,int line)=0;
190 : : static int (MS_FAR *add_lock_callback)(int *pointer,int amount,
191 : : int type,const char *file,int line)=0;
192 : : static struct CRYPTO_dynlock_value *(MS_FAR *dynlock_create_callback)
193 : : (const char *file,int line)=0;
194 : : static void (MS_FAR *dynlock_lock_callback)(int mode,
195 : : struct CRYPTO_dynlock_value *l, const char *file,int line)=0;
196 : : static void (MS_FAR *dynlock_destroy_callback)(struct CRYPTO_dynlock_value *l,
197 : : const char *file,int line)=0;
198 : :
199 : 0 : int CRYPTO_get_new_lockid(char *name)
200 : : {
201 : : char *str;
202 : : int i;
203 : :
204 : : #if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN16)
205 : : /* A hack to make Visual C++ 5.0 work correctly when linking as
206 : : * a DLL using /MT. Without this, the application cannot use
207 : : * any floating point printf's.
208 : : * It also seems to be needed for Visual C 1.5 (win16) */
209 : : SSLeay_MSVC5_hack=(double)name[0]*(double)name[1];
210 : : #endif
211 : :
212 [ # # ][ # # ]: 0 : if ((app_locks == NULL) && ((app_locks=sk_OPENSSL_STRING_new_null()) == NULL))
213 : : {
214 : 0 : CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_LOCKID,ERR_R_MALLOC_FAILURE);
215 : 0 : return(0);
216 : : }
217 [ # # ]: 0 : if ((str=BUF_strdup(name)) == NULL)
218 : : {
219 : 0 : CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_LOCKID,ERR_R_MALLOC_FAILURE);
220 : 0 : return(0);
221 : : }
222 : 0 : i=sk_OPENSSL_STRING_push(app_locks,str);
223 [ # # ]: 0 : if (!i)
224 : 0 : OPENSSL_free(str);
225 : : else
226 : 0 : i+=CRYPTO_NUM_LOCKS; /* gap of one :-) */
227 : 0 : return(i);
228 : : }
229 : :
230 : 0 : int CRYPTO_num_locks(void)
231 : : {
232 : 0 : return CRYPTO_NUM_LOCKS;
233 : : }
234 : :
235 : 0 : int CRYPTO_get_new_dynlockid(void)
236 : : {
237 : 0 : int i = 0;
238 : 0 : CRYPTO_dynlock *pointer = NULL;
239 : :
240 [ # # ]: 0 : if (dynlock_create_callback == NULL)
241 : : {
242 : 0 : CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,CRYPTO_R_NO_DYNLOCK_CREATE_CALLBACK);
243 : 0 : return(0);
244 : : }
245 : 0 : CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
246 [ # # ]: 0 : if ((dyn_locks == NULL)
247 [ # # ]: 0 : && ((dyn_locks=sk_CRYPTO_dynlock_new_null()) == NULL))
248 : : {
249 : 0 : CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
250 : 0 : CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,ERR_R_MALLOC_FAILURE);
251 : 0 : return(0);
252 : : }
253 : 0 : CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
254 : :
255 : 0 : pointer = (CRYPTO_dynlock *)OPENSSL_malloc(sizeof(CRYPTO_dynlock));
256 [ # # ]: 0 : if (pointer == NULL)
257 : : {
258 : 0 : CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,ERR_R_MALLOC_FAILURE);
259 : 0 : return(0);
260 : : }
261 : 0 : pointer->references = 1;
262 : 0 : pointer->data = dynlock_create_callback(__FILE__,__LINE__);
263 [ # # ]: 0 : if (pointer->data == NULL)
264 : : {
265 : 0 : OPENSSL_free(pointer);
266 : 0 : CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,ERR_R_MALLOC_FAILURE);
267 : 0 : return(0);
268 : : }
269 : :
270 : 0 : CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
271 : : /* First, try to find an existing empty slot */
272 : 0 : i=sk_CRYPTO_dynlock_find(dyn_locks,NULL);
273 : : /* If there was none, push, thereby creating a new one */
274 [ # # ]: 0 : if (i == -1)
275 : : /* Since sk_push() returns the number of items on the
276 : : stack, not the location of the pushed item, we need
277 : : to transform the returned number into a position,
278 : : by decreasing it. */
279 : 0 : i=sk_CRYPTO_dynlock_push(dyn_locks,pointer) - 1;
280 : : else
281 : : /* If we found a place with a NULL pointer, put our pointer
282 : : in it. */
283 : 0 : (void)sk_CRYPTO_dynlock_set(dyn_locks,i,pointer);
284 : 0 : CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
285 : :
286 [ # # ]: 0 : if (i == -1)
287 : : {
288 : 0 : dynlock_destroy_callback(pointer->data,__FILE__,__LINE__);
289 : 0 : OPENSSL_free(pointer);
290 : : }
291 : : else
292 : 0 : i += 1; /* to avoid 0 */
293 : 0 : return -i;
294 : : }
295 : :
296 : 0 : void CRYPTO_destroy_dynlockid(int i)
297 : : {
298 : 0 : CRYPTO_dynlock *pointer = NULL;
299 [ # # ]: 0 : if (i)
300 : 0 : i = -i-1;
301 [ # # ]: 0 : if (dynlock_destroy_callback == NULL)
302 : : return;
303 : :
304 : 0 : CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
305 : :
306 [ # # ][ # # ]: 0 : if (dyn_locks == NULL || i >= sk_CRYPTO_dynlock_num(dyn_locks))
307 : : {
308 : 0 : CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
309 : 0 : return;
310 : : }
311 : 0 : pointer = sk_CRYPTO_dynlock_value(dyn_locks, i);
312 [ # # ]: 0 : if (pointer != NULL)
313 : : {
314 : 0 : --pointer->references;
315 : : #ifdef REF_CHECK
316 : : if (pointer->references < 0)
317 : : {
318 : : fprintf(stderr,"CRYPTO_destroy_dynlockid, bad reference count\n");
319 : : abort();
320 : : }
321 : : else
322 : : #endif
323 [ # # ]: 0 : if (pointer->references <= 0)
324 : : {
325 : 0 : (void)sk_CRYPTO_dynlock_set(dyn_locks, i, NULL);
326 : : }
327 : : else
328 : : pointer = NULL;
329 : : }
330 : 0 : CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
331 : :
332 [ # # ]: 0 : if (pointer)
333 : : {
334 : 0 : dynlock_destroy_callback(pointer->data,__FILE__,__LINE__);
335 : 0 : OPENSSL_free(pointer);
336 : : }
337 : : }
338 : :
339 : 0 : struct CRYPTO_dynlock_value *CRYPTO_get_dynlock_value(int i)
340 : : {
341 : 0 : CRYPTO_dynlock *pointer = NULL;
342 [ # # ]: 0 : if (i)
343 : 0 : i = -i-1;
344 : :
345 : 0 : CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
346 : :
347 [ # # ][ # # ]: 0 : if (dyn_locks != NULL && i < sk_CRYPTO_dynlock_num(dyn_locks))
348 : 0 : pointer = sk_CRYPTO_dynlock_value(dyn_locks, i);
349 [ # # ]: 0 : if (pointer)
350 : 0 : pointer->references++;
351 : :
352 : 0 : CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
353 : :
354 [ # # ]: 0 : if (pointer)
355 : 0 : return pointer->data;
356 : : return NULL;
357 : : }
358 : :
359 : 0 : struct CRYPTO_dynlock_value *(*CRYPTO_get_dynlock_create_callback(void))
360 : : (const char *file,int line)
361 : : {
362 : 0 : return(dynlock_create_callback);
363 : : }
364 : :
365 : 0 : void (*CRYPTO_get_dynlock_lock_callback(void))(int mode,
366 : : struct CRYPTO_dynlock_value *l, const char *file,int line)
367 : : {
368 : 0 : return(dynlock_lock_callback);
369 : : }
370 : :
371 : 0 : void (*CRYPTO_get_dynlock_destroy_callback(void))
372 : : (struct CRYPTO_dynlock_value *l, const char *file,int line)
373 : : {
374 : 0 : return(dynlock_destroy_callback);
375 : : }
376 : :
377 : 0 : void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *(*func)
378 : : (const char *file, int line))
379 : : {
380 : 0 : dynlock_create_callback=func;
381 : 0 : }
382 : :
383 : 0 : void CRYPTO_set_dynlock_lock_callback(void (*func)(int mode,
384 : : struct CRYPTO_dynlock_value *l, const char *file, int line))
385 : : {
386 : : #ifdef OPENSSL_FIPS
387 : : FIPS_set_locking_callbacks(CRYPTO_lock, CRYPTO_add_lock);
388 : : #endif
389 : 0 : dynlock_lock_callback=func;
390 : 0 : }
391 : :
392 : 0 : void CRYPTO_set_dynlock_destroy_callback(void (*func)
393 : : (struct CRYPTO_dynlock_value *l, const char *file, int line))
394 : : {
395 : 0 : dynlock_destroy_callback=func;
396 : 0 : }
397 : :
398 : :
399 : 0 : void (*CRYPTO_get_locking_callback(void))(int mode,int type,const char *file,
400 : : int line)
401 : : {
402 : 0 : return(locking_callback);
403 : : }
404 : :
405 : 0 : int (*CRYPTO_get_add_lock_callback(void))(int *num,int mount,int type,
406 : : const char *file,int line)
407 : : {
408 : 0 : return(add_lock_callback);
409 : : }
410 : :
411 : 1619 : void CRYPTO_set_locking_callback(void (*func)(int mode,int type,
412 : : const char *file,int line))
413 : : {
414 : : #ifdef OPENSSL_FIPS
415 : : FIPS_set_locking_callbacks(CRYPTO_lock, CRYPTO_add_lock);
416 : : #endif
417 : 1619 : locking_callback=func;
418 : 1619 : }
419 : :
420 : 0 : void CRYPTO_set_add_lock_callback(int (*func)(int *num,int mount,int type,
421 : : const char *file,int line))
422 : : {
423 : 0 : add_lock_callback=func;
424 : 0 : }
425 : :
426 : 387971214 : void CRYPTO_lock(int mode, int type, const char *file, int line)
427 : : {
428 : : #ifdef LOCK_DEBUG
429 : : {
430 : : CRYPTO_THREADID id;
431 : : char *rw_text,*operation_text;
432 : :
433 : : if (mode & CRYPTO_LOCK)
434 : : operation_text="lock ";
435 : : else if (mode & CRYPTO_UNLOCK)
436 : : operation_text="unlock";
437 : : else
438 : : operation_text="ERROR ";
439 : :
440 : : if (mode & CRYPTO_READ)
441 : : rw_text="r";
442 : : else if (mode & CRYPTO_WRITE)
443 : : rw_text="w";
444 : : else
445 : : rw_text="ERROR";
446 : :
447 : : CRYPTO_THREADID_current(&id);
448 : : fprintf(stderr,"lock:%08lx:(%s)%s %-18s %s:%d\n",
449 : : CRYPTO_THREADID_hash(&id), rw_text, operation_text,
450 : : CRYPTO_get_lock_name(type), file, line);
451 : : }
452 : : #endif
453 [ - + ]: 387971214 : if (type < 0)
454 : : {
455 [ # # ]: 0 : if (dynlock_lock_callback != NULL)
456 : : {
457 : 0 : struct CRYPTO_dynlock_value *pointer
458 : : = CRYPTO_get_dynlock_value(type);
459 : :
460 [ # # ]: 0 : OPENSSL_assert(pointer != NULL);
461 : :
462 : 0 : dynlock_lock_callback(mode, pointer, file, line);
463 : :
464 : 0 : CRYPTO_destroy_dynlockid(type);
465 : : }
466 : : }
467 : : else
468 [ + + ]: 387971214 : if (locking_callback != NULL)
469 : 356165784 : locking_callback(mode,type,file,line);
470 : 387971214 : }
471 : :
472 : 1027968 : int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
473 : : int line)
474 : : {
475 : 1027968 : int ret = 0;
476 : :
477 [ - + ]: 1027968 : if (add_lock_callback != NULL)
478 : : {
479 : : #ifdef LOCK_DEBUG
480 : : int before= *pointer;
481 : : #endif
482 : :
483 : 0 : ret=add_lock_callback(pointer,amount,type,file,line);
484 : : #ifdef LOCK_DEBUG
485 : : {
486 : : CRYPTO_THREADID id;
487 : : CRYPTO_THREADID_current(&id);
488 : : fprintf(stderr,"ladd:%08lx:%2d+%2d->%2d %-18s %s:%d\n",
489 : : CRYPTO_THREADID_hash(&id), before,amount,ret,
490 : : CRYPTO_get_lock_name(type),
491 : : file,line);
492 : : }
493 : : #endif
494 : : }
495 : : else
496 : : {
497 : 1027968 : CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,file,line);
498 : :
499 : 1027968 : ret= *pointer+amount;
500 : : #ifdef LOCK_DEBUG
501 : : {
502 : : CRYPTO_THREADID id;
503 : : CRYPTO_THREADID_current(&id);
504 : : fprintf(stderr,"ladd:%08lx:%2d+%2d->%2d %-18s %s:%d\n",
505 : : CRYPTO_THREADID_hash(&id),
506 : : *pointer,amount,ret,
507 : : CRYPTO_get_lock_name(type),
508 : : file,line);
509 : : }
510 : : #endif
511 : 1027968 : *pointer=ret;
512 : 1027968 : CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,file,line);
513 : : }
514 : 1027968 : return(ret);
515 : : }
516 : :
517 : 0 : const char *CRYPTO_get_lock_name(int type)
518 : : {
519 [ # # ]: 0 : if (type < 0)
520 : : return("dynamic");
521 [ # # ]: 0 : else if (type < CRYPTO_NUM_LOCKS)
522 : 0 : return(lock_names[type]);
523 [ # # ]: 0 : else if (type-CRYPTO_NUM_LOCKS > sk_OPENSSL_STRING_num(app_locks))
524 : : return("ERROR");
525 : : else
526 : 0 : return(sk_OPENSSL_STRING_value(app_locks,type-CRYPTO_NUM_LOCKS));
527 : : }
|
