crypto/init.c

   1 /*
   2  * Written by Matt Caswell for the OpenSSL project.
   3  */
   4 /* ====================================================================
   5  * Copyright (c) 2016 The OpenSSL Project.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  *
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in
  16  *    the documentation and/or other materials provided with the
  17  *    distribution.
  18  *
  19  * 3. All advertising materials mentioning features or use of this
  20  *    software must display the following acknowledgment:
  21  *    "This product includes software developed by the OpenSSL Project
  22  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  23  *
  24  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  25  *    endorse or promote products derived from this software without
  26  *    prior written permission. For written permission, please contact
  27  *    openssl-core@openssl.org.
  28  *
  29  * 5. Products derived from this software may not be called "OpenSSL"
  30  *    nor may "OpenSSL" appear in their names without prior written
  31  *    permission of the OpenSSL Project.
  32  *
  33  * 6. Redistributions of any form whatsoever must retain the following
  34  *    acknowledgment:
  35  *    "This product includes software developed by the OpenSSL Project
  36  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  37  *
  38  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  39  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  40  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  41  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  42  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  43  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  44  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  45  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  46  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  47  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  48  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  49  * OF THE POSSIBILITY OF SUCH DAMAGE.
  50  * ====================================================================
  51  *
  52  * This product includes cryptographic software written by Eric Young
  53  * (eay@cryptsoft.com).  This product includes software written by Tim
  54  * Hudson (tjh@cryptsoft.com).
  55  *
  56  */
  57
  58 #include <internal/threads.h>
  59 #include <internal/cryptlib_int.h>
  60 #include <openssl/err.h>
  61 #include <internal/rand.h>
  62 #include <internal/bio.h>
  63 #include <openssl/evp.h>
  64 #include <internal/evp_int.h>
  65 #include <internal/conf.h>
  66 #include <internal/async.h>
  67 #include <internal/engine.h>
  68 #include <internal/comp.h>
  69 #include <internal/err.h>
  70 #include <internal/err_int.h>
  71 #include <internal/objects.h>
  72 #include <stdlib.h>
  73 #include <assert.h>
  74
  75 static int stopped = 0;
  76
  77 static void ossl_init_thread_stop(struct thread_local_inits_st *locals);
  78
  79 static CRYPTO_THREAD_LOCAL threadstopkey;
  80
  81 static void ossl_init_thread_stop_wrap(void *local)
  82 {
  83     ossl_init_thread_stop((struct thread_local_inits_st *)local);
  84 }
  85
  86 static struct thread_local_inits_st *ossl_init_get_thread_local(int alloc)
  87 {
  88     struct thread_local_inits_st *local =
  89         CRYPTO_THREAD_get_local(&threadstopkey);
  90
  91     if (local == NULL && alloc) {
  92         local = OPENSSL_zalloc(sizeof *local);
  93         CRYPTO_THREAD_set_local(&threadstopkey, local);
  94     }
  95     if (!alloc) {
  96         CRYPTO_THREAD_set_local(&threadstopkey, NULL);
  97     }
  98
  99     return local;
 100 }
 101
 102 typedef struct ossl_init_stop_st OPENSSL_INIT_STOP;
 103 struct ossl_init_stop_st {
 104     void (*handler)(void);
 105     OPENSSL_INIT_STOP *next;
 106 };
 107
 108 static OPENSSL_INIT_STOP *stop_handlers = NULL;
 109 static CRYPTO_RWLOCK *init_lock = NULL;
 110
 111 static CRYPTO_ONCE base = CRYPTO_ONCE_STATIC_INIT;
 112 static int base_inited = 0;
 113 static void ossl_init_base(void)
 114 {
 115 #ifdef OPENSSL_INIT_DEBUG
 116     fprintf(stderr, "OPENSSL_INIT: ossl_init_base: Setting up stop handlers\n");
 117 #endif
 118     /*
 119      * We use a dummy thread local key here. We use the destructor to detect
 120      * when the thread is going to stop (where that feature is available)
 121      */
 122     CRYPTO_THREAD_init_local(&threadstopkey, ossl_init_thread_stop_wrap);
 123 #ifndef OPENSSL_SYS_UEFI
 124     atexit(OPENSSL_cleanup);
 125 #endif
 126     init_lock = CRYPTO_THREAD_lock_new();
 127     OPENSSL_cpuid_setup();
 128     base_inited = 1;
 129 }
 130
 131 static CRYPTO_ONCE load_crypto_strings = CRYPTO_ONCE_STATIC_INIT;
 132 static int load_crypto_strings_inited = 0;
 133 static void ossl_init_no_load_crypto_strings(void)
 134 {
 135     /* Do nothing in this case */
 136     return;
 137 }
 138
 139 static void ossl_init_load_crypto_strings(void)
 140 {
 141     /*
 142      * OPENSSL_NO_AUTOERRINIT is provided here to prevent at compile time
 143      * pulling in all the error strings during static linking
 144      */
 145 #if !defined(OPENSSL_NO_ERR) && !defined(OPENSSL_NO_AUTOERRINIT)
 146 # ifdef OPENSSL_INIT_DEBUG
 147     fprintf(stderr, "OPENSSL_INIT: ossl_init_load_crypto_strings: "
 148                     "err_load_crypto_strings_int()\n");
 149 # endif
 150     err_load_crypto_strings_int();
 151 #endif
 152     load_crypto_strings_inited = 1;
 153 }
 154
 155 static CRYPTO_ONCE add_all_ciphers = CRYPTO_ONCE_STATIC_INIT;
 156 static void ossl_init_add_all_ciphers(void)
 157 {
 158     /*
 159      * OPENSSL_NO_AUTOALGINIT is provided here to prevent at compile time
 160      * pulling in all the ciphers during static linking
 161      */
 162 #ifndef OPENSSL_NO_AUTOALGINIT
 163 # ifdef OPENSSL_INIT_DEBUG
 164     fprintf(stderr, "OPENSSL_INIT: ossl_init_add_all_ciphers: "
 165                     "openssl_add_all_ciphers_int()\n");
 166 # endif
 167     openssl_add_all_ciphers_int();
 168 # ifndef OPENSSL_NO_ENGINE
 169 #  if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV)
 170     ENGINE_setup_bsd_cryptodev();
 171 #  endif
 172 # endif
 173 #endif
 174 }
 175
 176 static CRYPTO_ONCE add_all_digests = CRYPTO_ONCE_STATIC_INIT;
 177 static void ossl_init_add_all_digests(void)
 178 {
 179     /*
 180      * OPENSSL_NO_AUTOALGINIT is provided here to prevent at compile time
 181      * pulling in all the ciphers during static linking
 182      */
 183 #ifndef OPENSSL_NO_AUTOALGINIT
 184 # ifdef OPENSSL_INIT_DEBUG
 185     fprintf(stderr, "OPENSSL_INIT: ossl_init_add_all_digests: "
 186                     "openssl_add_all_digests()\n");
 187 # endif
 188     openssl_add_all_digests_int();
 189 # ifndef OPENSSL_NO_ENGINE
 190 #  if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV)
 191     ENGINE_setup_bsd_cryptodev();
 192 #  endif
 193 # endif
 194 #endif
 195 }
 196
 197 static void ossl_init_no_add_algs(void)
 198 {
 199     /* Do nothing */
 200     return;
 201 }
 202
 203 static CRYPTO_ONCE config = CRYPTO_ONCE_STATIC_INIT;
 204 static int config_inited = 0;
 205 static const char *config_filename;
 206 static void ossl_init_config(void)
 207 {
 208 #ifdef OPENSSL_INIT_DEBUG
 209     fprintf(stderr,
 210             "OPENSSL_INIT: ossl_init_config: openssl_config(%s)\n",
 211             config_filename==NULL?"NULL":config_filename);
 212 #endif
 213     openssl_config_int(config_filename);
 214     config_inited = 1;
 215 }
 216 static void ossl_init_no_config(void)
 217 {
 218 #ifdef OPENSSL_INIT_DEBUG
 219     fprintf(stderr,
 220             "OPENSSL_INIT: ossl_init_config: openssl_no_config_int()\n");
 221 #endif
 222     openssl_no_config_int();
 223     config_inited = 1;
 224 }
 225
 226 static CRYPTO_ONCE async = CRYPTO_ONCE_STATIC_INIT;
 227 static int async_inited = 0;
 228 static void ossl_init_async(void)
 229 {
 230 #ifdef OPENSSL_INIT_DEBUG
 231     fprintf(stderr, "OPENSSL_INIT: ossl_init_async: async_init()\n");
 232 #endif
 233     async_init();
 234     async_inited = 1;
 235 }
 236
 237 #ifndef OPENSSL_NO_ENGINE
 238 static CRYPTO_ONCE engine_openssl = CRYPTO_ONCE_STATIC_INIT;
 239 static void ossl_init_engine_openssl(void)
 240 {
 241 # ifdef OPENSSL_INIT_DEBUG
 242     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_openssl: "
 243                     "engine_load_openssl_int()\n");
 244 # endif
 245     engine_load_openssl_int();
 246 }
 247 # if !defined(OPENSSL_NO_HW) && \
 248     (defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV))
 249 static CRYPTO_ONCE engine_cryptodev = CRYPTO_ONCE_STATIC_INIT;
 250 static void ossl_init_engine_cryptodev(void)
 251 {
 252 #  ifdef OPENSSL_INIT_DEBUG
 253     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_cryptodev: "
 254                     "engine_load_cryptodev_int()\n");
 255 #  endif
 256     engine_load_cryptodev_int();
 257 }
 258 # endif
 259
 260 # ifndef OPENSSL_NO_RDRAND
 261 static CRYPTO_ONCE engine_rdrand = CRYPTO_ONCE_STATIC_INIT;
 262 static void ossl_init_engine_rdrand(void)
 263 {
 264 #  ifdef OPENSSL_INIT_DEBUG
 265     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_rdrand: "
 266                     "engine_load_rdrand_int()\n");
 267 #  endif
 268     engine_load_rdrand_int();
 269 }
 270 # endif
 271 static CRYPTO_ONCE engine_dynamic = CRYPTO_ONCE_STATIC_INIT;
 272 static void ossl_init_engine_dynamic(void)
 273 {
 274 # ifdef OPENSSL_INIT_DEBUG
 275     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_dynamic: "
 276                     "engine_load_dynamic_int()\n");
 277 # endif
 278     engine_load_dynamic_int();
 279 }
 280 # ifndef OPENSSL_NO_STATIC_ENGINE
 281 #  if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_PADLOCK)
 282 static CRYPTO_ONCE engine_padlock = CRYPTO_ONCE_STATIC_INIT;
 283 static void ossl_init_engine_padlock(void)
 284 {
 285 #   ifdef OPENSSL_INIT_DEBUG
 286     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_padlock: "
 287                     "engine_load_padlock_int()\n");
 288 #   endif
 289     engine_load_padlock_int();
 290 }
 291 #  endif
 292 #  if defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_NO_CAPIENG)
 293 static CRYPTO_ONCE engine_capi = CRYPTO_ONCE_STATIC_INIT;
 294 static void ossl_init_engine_capi(void)
 295 {
 296 #   ifdef OPENSSL_INIT_DEBUG
 297     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_capi: "
 298                     "engine_load_capi_int()\n");
 299 #   endif
 300     engine_load_capi_int();
 301 }
 302 #  endif
 303 static CRYPTO_ONCE engine_dasync = CRYPTO_ONCE_STATIC_INIT;
 304 static void ossl_init_engine_dasync(void)
 305 {
 306 # ifdef OPENSSL_INIT_DEBUG
 307     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_dasync: "
 308                     "engine_load_dasync_int()\n");
 309 # endif
 310     engine_load_dasync_int();
 311 }
 312 #  if !defined(OPENSSL_NO_AFALGENG)
 313 static CRYPTO_ONCE engine_afalg = CRYPTO_ONCE_STATIC_INIT;
 314 static void ossl_init_engine_afalg(void)
 315 {
 316 #   ifdef OPENSSL_INIT_DEBUG
 317     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_afalg: "
 318                     "engine_load_afalg_int()\n");
 319 #   endif
 320     engine_load_afalg_int();
 321 }
 322 #  endif
 323 # endif
 324 #endif
 325
 326 #ifndef OPENSSL_NO_COMP
 327 static CRYPTO_ONCE zlib = CRYPTO_ONCE_STATIC_INIT;
 328
 329 static int zlib_inited = 0;
 330 static void ossl_init_zlib(void)
 331 {
 332     /* Do nothing - we need to know about this for the later cleanup */
 333     zlib_inited = 1;
 334 }
 335 #endif
 336
 337 static void ossl_init_thread_stop(struct thread_local_inits_st *locals)
 338 {
 339     /* Can't do much about this */
 340     if (locals == NULL)
 341         return;
 342
 343     if (locals->async) {
 344 #ifdef OPENSSL_INIT_DEBUG
 345         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_stop: "
 346                         "ASYNC_cleanup_thread()\n");
 347 #endif
 348         ASYNC_cleanup_thread();
 349     }
 350
 351     if (locals->err_state) {
 352 #ifdef OPENSSL_INIT_DEBUG
 353         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_stop: "
 354                         "ERR_remove_thread_state()\n");
 355 #endif
 356         ERR_remove_thread_state();
 357     }
 358
 359     OPENSSL_free(locals);
 360 }
 361
 362 void OPENSSL_thread_stop(void)
 363 {
 364     ossl_init_thread_stop(
 365         (struct thread_local_inits_st *)ossl_init_get_thread_local(0));
 366 }
 367
 368 int ossl_init_thread_start(uint64_t opts)
 369 {
 370     struct thread_local_inits_st *locals = ossl_init_get_thread_local(1);
 371
 372     if (locals == NULL)
 373         return 0;
 374
 375     if (opts & OPENSSL_INIT_THREAD_ASYNC) {
 376 #ifdef OPENSSL_INIT_DEBUG
 377         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_start: "
 378                         "marking thread for async\n");
 379 #endif
 380         locals->async = 1;
 381     }
 382
 383     if (opts & OPENSSL_INIT_THREAD_ERR_STATE) {
 384 #ifdef OPENSSL_INIT_DEBUG
 385         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_start: "
 386                         "marking thread for err_state\n");
 387 #endif
 388         locals->err_state = 1;
 389     }
 390
 391     return 1;
 392 }
 393
 394 void OPENSSL_cleanup(void)
 395 {
 396     OPENSSL_INIT_STOP *currhandler, *lasthandler;
 397
 398     /* If we've not been inited then no need to deinit */
 399     if (!base_inited)
 400         return;
 401
 402     /* Might be explicitly called and also by atexit */
 403     if (stopped)
 404         return;
 405     stopped = 1;
 406
 407     /*
 408      * Thread stop may not get automatically called by the thread library for
 409      * the very last thread in some situations, so call it directly.
 410      */
 411     ossl_init_thread_stop(ossl_init_get_thread_local(0));
 412
 413     currhandler = stop_handlers;
 414     while (currhandler != NULL) {
 415         currhandler->handler();
 416         lasthandler = currhandler;
 417         currhandler = currhandler->next;
 418         OPENSSL_free(lasthandler);
 419     }
 420     stop_handlers = NULL;
 421
 422     CRYPTO_THREAD_lock_free(init_lock);
 423
 424     /*
 425      * We assume we are single-threaded for this function, i.e. no race
 426      * conditions for the various "*_inited" vars below.
 427      */
 428
 429 #ifndef OPENSSL_NO_COMP
 430     if (zlib_inited) {
 431 #ifdef OPENSSL_INIT_DEBUG
 432         fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 433                         "comp_zlib_cleanup_int()\n");
 434 #endif
 435         comp_zlib_cleanup_int();
 436     }
 437 #endif
 438
 439     if (async_inited) {
 440 # ifdef OPENSSL_INIT_DEBUG
 441         fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 442                         "async_deinit()\n");
 443 # endif
 444         async_deinit();
 445     }
 446
 447     if (load_crypto_strings_inited) {
 448 #ifdef OPENSSL_INIT_DEBUG
 449         fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 450                         "err_free_strings_int()\n");
 451 #endif
 452         err_free_strings_int();
 453     }
 454
 455     CRYPTO_THREAD_cleanup_local(&threadstopkey);
 456
 457 #ifdef OPENSSL_INIT_DEBUG
 458     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 459                     "rand_cleanup_int()\n");
 460     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 461                     "conf_modules_free_int()\n");
 462 #ifndef OPENSSL_NO_ENGINE
 463     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 464                     "engine_cleanup_int()\n");
 465 #endif
 466     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 467                     "crypto_cleanup_all_ex_data_int()\n");
 468     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 469                     "bio_sock_cleanup_int()\n");
 470     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 471                     "bio_cleanup()\n");
 472     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 473                     "evp_cleanup_int()\n");
 474     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 475                     "obj_cleanup_int()\n");
 476     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 477                     "err_cleanup()\n");
 478 #endif
 479     /*
 480      * Note that cleanup order is important:
 481      * - rand_cleanup_int could call an ENGINE's RAND cleanup function so
 482      * must be called before engine_cleanup_int()
 483      * - ENGINEs use CRYPTO_EX_DATA and therefore, must be cleaned up
 484      * before the ex data handlers are wiped in CRYPTO_cleanup_all_ex_data().
 485      * - conf_modules_free_int() can end up in ENGINE code so must be called
 486      * before engine_cleanup_int()
 487      * - ENGINEs and additional EVP algorithms might use added OIDs names so
 488      * obj_cleanup_int() must be called last
 489      */
 490     rand_cleanup_int();
 491     conf_modules_free_int();
 492 #ifndef OPENSSL_NO_ENGINE
 493     engine_cleanup_int();
 494 #endif
 495     crypto_cleanup_all_ex_data_int();
 496     bio_cleanup();
 497     evp_cleanup_int();
 498     obj_cleanup_int();
 499     err_cleanup();
 500
 501     base_inited = 0;
 502 }
 503
 504 /*
 505  * If this function is called with a non NULL settings value then it must be
 506  * called prior to any threads making calls to any OpenSSL functions,
 507  * i.e. passing a non-null settings value is assumed to be single-threaded.
 508  */
 509 int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings)
 510 {
 511     static int stoperrset = 0;
 512
 513     if (stopped) {
 514         if (!stoperrset) {
 515             /*
 516              * We only ever set this once to avoid getting into an infinite
 517              * loop where the error system keeps trying to init and fails so
 518              * sets an error etc
 519              */
 520             stoperrset = 1;
 521             CRYPTOerr(CRYPTO_F_OPENSSL_INIT_CRYPTO, ERR_R_INIT_FAIL);
 522         }
 523         return 0;
 524     }
 525
 526     if (!CRYPTO_THREAD_run_once(&base, ossl_init_base))
 527         return 0;
 528
 529     if ((opts & OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS)
 530             && !CRYPTO_THREAD_run_once(&load_crypto_strings,
 531                                        ossl_init_no_load_crypto_strings))
 532         return 0;
 533
 534     if ((opts & OPENSSL_INIT_LOAD_CRYPTO_STRINGS)
 535             && !CRYPTO_THREAD_run_once(&load_crypto_strings,
 536                                        ossl_init_load_crypto_strings))
 537         return 0;
 538
 539     if ((opts & OPENSSL_INIT_NO_ADD_ALL_CIPHERS)
 540             && !CRYPTO_THREAD_run_once(&add_all_ciphers, ossl_init_no_add_algs))
 541         return 0;
 542
 543     if ((opts & OPENSSL_INIT_ADD_ALL_CIPHERS)
 544             && !CRYPTO_THREAD_run_once(&add_all_ciphers,
 545                                        ossl_init_add_all_ciphers))
 546         return 0;
 547
 548     if ((opts & OPENSSL_INIT_NO_ADD_ALL_DIGESTS)
 549             && !CRYPTO_THREAD_run_once(&add_all_digests, ossl_init_no_add_algs))
 550         return 0;
 551
 552     if ((opts & OPENSSL_INIT_ADD_ALL_DIGESTS)
 553             && !CRYPTO_THREAD_run_once(&add_all_digests,
 554                                        ossl_init_add_all_digests))
 555         return 0;
 556
 557     if ((opts & OPENSSL_INIT_NO_LOAD_CONFIG)
 558             && !CRYPTO_THREAD_run_once(&config, ossl_init_no_config))
 559         return 0;
 560
 561     if (opts & OPENSSL_INIT_LOAD_CONFIG) {
 562         int ret;
 563         CRYPTO_THREAD_write_lock(init_lock);
 564         config_filename = (settings == NULL) ? NULL : settings->config_name;
 565         ret = CRYPTO_THREAD_run_once(&config, ossl_init_config);
 566         CRYPTO_THREAD_unlock(init_lock);
 567         if (!ret)
 568             return 0;
 569     }
 570
 571     if ((opts & OPENSSL_INIT_ASYNC)
 572             && !CRYPTO_THREAD_run_once(&async, ossl_init_async))
 573         return 0;
 574
 575 #ifndef OPENSSL_NO_ENGINE
 576     if ((opts & OPENSSL_INIT_ENGINE_OPENSSL)
 577             && !CRYPTO_THREAD_run_once(&engine_openssl,
 578                                        ossl_init_engine_openssl))
 579         return 0;
 580 # if !defined(OPENSSL_NO_HW) && \
 581     (defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV))
 582     if ((opts & OPENSSL_INIT_ENGINE_CRYPTODEV)
 583             && !CRYPTO_THREAD_run_once(&engine_cryptodev,
 584                                        ossl_init_engine_cryptodev))
 585         return 0;
 586 # endif
 587 # ifndef OPENSSL_NO_RDRAND
 588     if ((opts & OPENSSL_INIT_ENGINE_RDRAND)
 589             && !CRYPTO_THREAD_run_once(&engine_rdrand, ossl_init_engine_rdrand))
 590         return 0;
 591 # endif
 592     if ((opts & OPENSSL_INIT_ENGINE_DYNAMIC)
 593             && !CRYPTO_THREAD_run_once(&engine_dynamic,
 594                                        ossl_init_engine_dynamic))
 595         return 0;
 596 # ifndef OPENSSL_NO_STATIC_ENGINE
 597 #  if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_PADLOCK)
 598     if ((opts & OPENSSL_INIT_ENGINE_PADLOCK)
 599             && !CRYPTO_THREAD_run_once(&engine_padlock,
 600                                        ossl_init_engine_padlock))
 601         return 0;
 602 #  endif
 603 #  if defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_NO_CAPIENG)
 604     if ((opts & OPENSSL_INIT_ENGINE_CAPI)
 605             && !CRYPTO_THREAD_run_once(&engine_capi, ossl_init_engine_capi))
 606         return 0;
 607 #  endif
 608     if ((opts & OPENSSL_INIT_ENGINE_DASYNC)
 609             && !CRYPTO_THREAD_run_once(&engine_dasync, ossl_init_engine_dasync))
 610         return 0;
 611 #  if !defined(OPENSSL_NO_AFALGENG)
 612     if ((opts & OPENSSL_INIT_ENGINE_AFALG)
 613             && !CRYPTO_THREAD_run_once(&engine_afalg, ossl_init_engine_afalg))
 614         return 0;
 615 #  endif
 616 # endif
 617     if (opts & (OPENSSL_INIT_ENGINE_ALL_BUILTIN
 618                 | OPENSSL_INIT_ENGINE_DASYNC | OPENSSL_INIT_ENGINE_OPENSSL
 619                 | OPENSSL_INIT_ENGINE_AFALG)) {
 620         ENGINE_register_all_complete();
 621     }
 622 #endif
 623
 624 #ifndef OPENSSL_NO_COMP
 625     if ((opts & OPENSSL_INIT_ZLIB)
 626             && !CRYPTO_THREAD_run_once(&zlib, ossl_init_zlib))
 627         return 0;
 628 #endif
 629
 630     return 1;
 631 }
 632
 633 int OPENSSL_atexit(void (*handler)(void))
 634 {
 635     OPENSSL_INIT_STOP *newhand;
 636
 637     newhand = OPENSSL_malloc(sizeof(*newhand));
 638     if (newhand == NULL)
 639         return 0;
 640
 641     newhand->handler = handler;
 642     newhand->next = stop_handlers;
 643     stop_handlers = newhand;
 644
 645     return 1;
 646 }