crypto/dyn_lck.c

   1 /* crypto/cryptlib.c */
   2 /* ====================================================================
   3  * Copyright (c) 1998-2003 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
 120 #if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN16)
 121 static double SSLeay_MSVC5_hack=0.0; /* and for VC1.5 */
 122 #endif
 123
 124 DECLARE_STACK_OF(CRYPTO_dynlock)
 125 IMPLEMENT_STACK_OF(CRYPTO_dynlock)
 126
 127 /* real #defines in crypto.h, keep these upto date */
 128 static const char* const lock_names[CRYPTO_NUM_LOCKS] =
 129         {
 130         "<<ERROR>>",
 131         "err",
 132         "ex_data",
 133         "x509",
 134         "x509_info",
 135         "x509_pkey",
 136         "x509_crl",
 137         "x509_req",
 138         "dsa",
 139         "rsa",
 140         "evp_pkey",
 141         "x509_store",
 142         "ssl_ctx",
 143         "ssl_cert",
 144         "ssl_session",
 145         "ssl_sess_cert",
 146         "ssl",
 147         "ssl_method",
 148         "rand",
 149         "rand2",
 150         "debug_malloc",
 151         "BIO",
 152         "gethostbyname",
 153         "getservbyname",
 154         "readdir",
 155         "RSA_blinding",
 156         "dh",
 157         "debug_malloc2",
 158         "dso",
 159         "dynlock",
 160         "engine",
 161         "ui",
 162         "ecdsa",
 163         "ec",
 164         "ecdh",
 165         "bn",
 166         "ec_pre_comp",
 167         "store",
 168         "comp",
 169         "fips",
 170         "fips2",
 171 #if CRYPTO_NUM_LOCKS != 41
 172 # error "Inconsistency between crypto.h and cryptlib.c"
 173 #endif
 174         };
 175
 176 /* This is for applications to allocate new type names in the non-dynamic
 177    array of lock names.  These are numbered with positive numbers.  */
 178 static STACK *app_locks=NULL;
 179
 180 /* For applications that want a more dynamic way of handling threads, the
 181    following stack is used.  These are externally numbered with negative
 182    numbers.  */
 183 static STACK_OF(CRYPTO_dynlock) *dyn_locks=NULL;
 184
 185
 186 static struct CRYPTO_dynlock_value *(MS_FAR *dynlock_create_callback)
 187         (const char *file,int line)=NULL;
 188 static void (MS_FAR *dynlock_lock_callback)(int mode,
 189         struct CRYPTO_dynlock_value *l, const char *file,int line)=NULL;
 190 static void (MS_FAR *dynlock_destroy_callback)(struct CRYPTO_dynlock_value *l,
 191         const char *file,int line)=NULL;
 192
 193 int CRYPTO_get_new_lockid(char *name)
 194         {
 195         char *str;
 196         int i;
 197
 198 #if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN16)
 199         /* A hack to make Visual C++ 5.0 work correctly when linking as
 200          * a DLL using /MT. Without this, the application cannot use
 201          * and floating point printf's.
 202          * It also seems to be needed for Visual C 1.5 (win16) */
 203         SSLeay_MSVC5_hack=(double)name[0]*(double)name[1];
 204 #endif
 205
 206         if ((app_locks == NULL) && ((app_locks=sk_new_null()) == NULL))
 207                 {
 208                 CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_LOCKID,ERR_R_MALLOC_FAILURE);
 209                 return(0);
 210                 }
 211         if ((str=BUF_strdup(name)) == NULL)
 212                 {
 213                 CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_LOCKID,ERR_R_MALLOC_FAILURE);
 214                 return(0);
 215                 }
 216         i=sk_push(app_locks,str);
 217         if (!i)
 218                 OPENSSL_free(str);
 219         else
 220                 i+=CRYPTO_NUM_LOCKS; /* gap of one :-) */
 221         return(i);
 222         }
 223
 224 int CRYPTO_get_new_dynlockid(void)
 225         {
 226         int i = 0;
 227         CRYPTO_dynlock *pointer = NULL;
 228
 229         if (dynlock_create_callback == NULL)
 230                 {
 231                 CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,CRYPTO_R_NO_DYNLOCK_CREATE_CALLBACK);
 232                 return(0);
 233                 }
 234         CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
 235         if ((dyn_locks == NULL)
 236                 && ((dyn_locks=sk_CRYPTO_dynlock_new_null()) == NULL))
 237                 {
 238                 CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
 239                 CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,ERR_R_MALLOC_FAILURE);
 240                 return(0);
 241                 }
 242         CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
 243
 244         pointer = (CRYPTO_dynlock *)OPENSSL_malloc(sizeof(CRYPTO_dynlock));
 245         if (pointer == NULL)
 246                 {
 247                 CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,ERR_R_MALLOC_FAILURE);
 248                 return(0);
 249                 }
 250         pointer->references = 1;
 251         pointer->data = dynlock_create_callback(__FILE__,__LINE__);
 252         if (pointer->data == NULL)
 253                 {
 254                 OPENSSL_free(pointer);
 255                 CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,ERR_R_MALLOC_FAILURE);
 256                 return(0);
 257                 }
 258
 259         CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
 260         /* First, try to find an existing empty slot */
 261         i=sk_CRYPTO_dynlock_find(dyn_locks,NULL);
 262         /* If there was none, push, thereby creating a new one */
 263         if (i == -1)
 264                 /* Since sk_push() returns the number of items on the
 265                    stack, not the location of the pushed item, we need
 266                    to transform the returned number into a position,
 267                    by decreasing it.  */
 268                 i=sk_CRYPTO_dynlock_push(dyn_locks,pointer) - 1;
 269         else
 270                 /* If we found a place with a NULL pointer, put our pointer
 271                    in it.  */
 272                 sk_CRYPTO_dynlock_set(dyn_locks,i,pointer);
 273         CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
 274
 275         if (i == -1)
 276                 {
 277                 dynlock_destroy_callback(pointer->data,__FILE__,__LINE__);
 278                 OPENSSL_free(pointer);
 279                 }
 280         else
 281                 i += 1; /* to avoid 0 */
 282         return -i;
 283         }
 284
 285 void CRYPTO_destroy_dynlockid(int i)
 286         {
 287         CRYPTO_dynlock *pointer = NULL;
 288         if (i)
 289                 i = -i-1;
 290         if (dynlock_destroy_callback == NULL)
 291                 return;
 292
 293         CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
 294
 295         if (dyn_locks == NULL || i >= sk_CRYPTO_dynlock_num(dyn_locks))
 296                 {
 297                 CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
 298                 return;
 299                 }
 300         pointer = sk_CRYPTO_dynlock_value(dyn_locks, i);
 301         if (pointer != NULL)
 302                 {
 303                 --pointer->references;
 304 #ifdef REF_CHECK
 305                 if (pointer->references < 0)
 306                         {
 307                         fprintf(stderr,"CRYPTO_destroy_dynlockid, bad reference count\n");
 308                         abort();
 309                         }
 310                 else
 311 #endif
 312                         if (pointer->references <= 0)
 313                                 {
 314                                 sk_CRYPTO_dynlock_set(dyn_locks, i, NULL);
 315                                 }
 316                         else
 317                                 pointer = NULL;
 318                 }
 319         CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
 320
 321         if (pointer)
 322                 {
 323                 dynlock_destroy_callback(pointer->data,__FILE__,__LINE__);
 324                 OPENSSL_free(pointer);
 325                 }
 326         }
 327
 328 struct CRYPTO_dynlock_value *CRYPTO_get_dynlock_value(int i)
 329         {
 330         CRYPTO_dynlock *pointer = NULL;
 331         if (i)
 332                 i = -i-1;
 333
 334         CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
 335
 336         if (dyn_locks != NULL && i < sk_CRYPTO_dynlock_num(dyn_locks))
 337                 pointer = sk_CRYPTO_dynlock_value(dyn_locks, i);
 338         if (pointer)
 339                 pointer->references++;
 340
 341         CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
 342
 343         if (pointer)
 344                 return pointer->data;
 345         return NULL;
 346         }
 347
 348 struct CRYPTO_dynlock_value *(*CRYPTO_get_dynlock_create_callback(void))
 349         (const char *file,int line)
 350         {
 351         return(dynlock_create_callback);
 352         }
 353
 354 void (*CRYPTO_get_dynlock_lock_callback(void))(int mode,
 355         struct CRYPTO_dynlock_value *l, const char *file,int line)
 356         {
 357         return(dynlock_lock_callback);
 358         }
 359
 360 void (*CRYPTO_get_dynlock_destroy_callback(void))
 361         (struct CRYPTO_dynlock_value *l, const char *file,int line)
 362         {
 363         return(dynlock_destroy_callback);
 364         }
 365
 366 void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *(*func)
 367         (const char *file, int line))
 368         {
 369         dynlock_create_callback=func;
 370         }
 371
 372 static void do_dynlock(int mode, int type, const char *file, int line)
 373         {
 374         if (dynlock_lock_callback != NULL)
 375                 {
 376                 struct CRYPTO_dynlock_value *pointer
 377                                 = CRYPTO_get_dynlock_value(type);
 378
 379                 OPENSSL_assert(pointer != NULL);
 380
 381                 dynlock_lock_callback(mode, pointer, file, line);
 382
 383                 CRYPTO_destroy_dynlockid(type);
 384                 }
 385         }
 386
 387 void CRYPTO_set_dynlock_lock_callback(void (*func)(int mode,
 388         struct CRYPTO_dynlock_value *l, const char *file, int line))
 389         {
 390         /* Set callback so CRYPTO_lock() can now handle dynamic locks.
 391          * This is OK because at this point and application shouldn't be using
 392          * OpenSSL from multiple threads because it is setting up the locking
 393          * callbacks.
 394          */
 395         static int done = 0;
 396         if (!done)
 397                 {
 398                 int_CRYPTO_set_do_dynlock_callback(do_dynlock);
 399                 done = 1;
 400                 }
 401
 402         dynlock_lock_callback=func;
 403         }
 404
 405 void CRYPTO_set_dynlock_destroy_callback(void (*func)
 406         (struct CRYPTO_dynlock_value *l, const char *file, int line))
 407         {
 408         dynlock_destroy_callback=func;
 409         }
 410
 411 const char *CRYPTO_get_lock_name(int type)
 412         {
 413         if (type < 0)
 414                 return("dynamic");
 415         else if (type < CRYPTO_NUM_LOCKS)
 416                 return(lock_names[type]);
 417         else if (type-CRYPTO_NUM_LOCKS > sk_num(app_locks))
 418                 return("ERROR");
 419         else
 420                 return(sk_value(app_locks,type-CRYPTO_NUM_LOCKS));
 421         }
 422