crypto/init.c

   1 /*
   2  * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include "e_os.h"
  11 #include "internal/cryptlib_int.h"
  12 #include <openssl/err.h>
  13 #include "internal/rand_int.h"
  14 #include "internal/bio.h"
  15 #include <openssl/evp.h>
  16 #include "internal/evp_int.h"
  17 #include "internal/conf.h"
  18 #include "internal/async.h"
  19 #include "internal/engine.h"
  20 #include "internal/comp.h"
  21 #include "internal/err.h"
  22 #include "internal/err_int.h"
  23 #include "internal/objects.h"
  24 #include <stdlib.h>
  25 #include <assert.h>
  26 #include "internal/thread_once.h"
  27 #include "internal/dso_conf.h"
  28 #include "internal/dso.h"
  29 #include "internal/store.h"
  30
  31 static int stopped = 0;
  32
  33 static void ossl_init_thread_stop(struct thread_local_inits_st *locals);
  34
  35 static CRYPTO_THREAD_LOCAL threadstopkey;
  36
  37 static void ossl_init_thread_stop_wrap(void *local)
  38 {
  39     ossl_init_thread_stop((struct thread_local_inits_st *)local);
  40 }
  41
  42 static struct thread_local_inits_st *ossl_init_get_thread_local(int alloc)
  43 {
  44     struct thread_local_inits_st *local =
  45         CRYPTO_THREAD_get_local(&threadstopkey);
  46
  47     if (local == NULL && alloc) {
  48         local = OPENSSL_zalloc(sizeof(*local));
  49         if (local != NULL && !CRYPTO_THREAD_set_local(&threadstopkey, local)) {
  50             OPENSSL_free(local);
  51             return NULL;
  52         }
  53     }
  54     if (!alloc) {
  55         CRYPTO_THREAD_set_local(&threadstopkey, NULL);
  56     }
  57
  58     return local;
  59 }
  60
  61 typedef struct ossl_init_stop_st OPENSSL_INIT_STOP;
  62 struct ossl_init_stop_st {
  63     void (*handler)(void);
  64     OPENSSL_INIT_STOP *next;
  65 };
  66
  67 static OPENSSL_INIT_STOP *stop_handlers = NULL;
  68 static CRYPTO_RWLOCK *init_lock = NULL;
  69
  70 static CRYPTO_ONCE base = CRYPTO_ONCE_STATIC_INIT;
  71 static int base_inited = 0;
  72 DEFINE_RUN_ONCE_STATIC(ossl_init_base)
  73 {
  74 #ifdef OPENSSL_INIT_DEBUG
  75     fprintf(stderr, "OPENSSL_INIT: ossl_init_base: Setting up stop handlers\n");
  76 #endif
  77 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
  78     ossl_malloc_setup_failures();
  79 #endif
  80     /*
  81      * We use a dummy thread local key here. We use the destructor to detect
  82      * when the thread is going to stop (where that feature is available)
  83      */
  84     if (!CRYPTO_THREAD_init_local(&threadstopkey, ossl_init_thread_stop_wrap))
  85         return 0;
  86     if ((init_lock = CRYPTO_THREAD_lock_new()) == NULL)
  87         goto err;
  88 #ifndef OPENSSL_SYS_UEFI
  89     if (atexit(OPENSSL_cleanup) != 0)
  90         goto err;
  91 #endif
  92     OPENSSL_cpuid_setup();
  93
  94     base_inited = 1;
  95     return 1;
  96
  97 err:
  98 #ifdef OPENSSL_INIT_DEBUG
  99     fprintf(stderr, "OPENSSL_INIT: ossl_init_base not ok!\n");
 100 #endif
 101     CRYPTO_THREAD_lock_free(init_lock);
 102     init_lock = NULL;
 103
 104     CRYPTO_THREAD_cleanup_local(&threadstopkey);
 105     return 0;
 106 }
 107
 108 static CRYPTO_ONCE load_crypto_nodelete = CRYPTO_ONCE_STATIC_INIT;
 109 DEFINE_RUN_ONCE_STATIC(ossl_init_load_crypto_nodelete)
 110 {
 111 #ifdef OPENSSL_INIT_DEBUG
 112     fprintf(stderr, "OPENSSL_INIT: ossl_init_load_crypto_nodelete()\n");
 113 #endif
 114 #if !defined(OPENSSL_NO_DSO) && !defined(OPENSSL_USE_NODELETE)
 115 # ifdef DSO_WIN32
 116     {
 117         HMODULE handle = NULL;
 118         BOOL ret;
 119
 120         /* We don't use the DSO route for WIN32 because there is a better way */
 121         ret = GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
 122                                 | GET_MODULE_HANDLE_EX_FLAG_PIN,
 123                                 (void *)&base_inited, &handle);
 124
 125 #  ifdef OPENSSL_INIT_DEBUG
 126         fprintf(stderr, "OPENSSL_INIT: obtained DSO reference? %s\n",
 127                 (ret == TRUE ? "No!" : "Yes."));
 128 #  endif
 129         return (ret == TRUE) ? 1 : 0;
 130     }
 131 # else
 132     /*
 133      * Deliberately leak a reference to ourselves. This will force the library
 134      * to remain loaded until the atexit() handler is run at process exit.
 135      */
 136     {
 137         DSO *dso;
 138         void *err;
 139
 140         if (!err_shelve_state(&err))
 141             return 0;
 142
 143         dso = DSO_dsobyaddr(&base_inited, DSO_FLAG_NO_UNLOAD_ON_FREE);
 144 #  ifdef OPENSSL_INIT_DEBUG
 145         fprintf(stderr, "OPENSSL_INIT: obtained DSO reference? %s\n",
 146                 (dso == NULL ? "No!" : "Yes."));
 147         /*
 148          * In case of No!, it is uncertain our exit()-handlers can still be
 149          * called. After dlclose() the whole library might have been unloaded
 150          * already.
 151          */
 152 #  endif
 153         DSO_free(dso);
 154         err_unshelve_state(err);
 155     }
 156 # endif
 157 #endif
 158
 159     return 1;
 160 }
 161
 162 static CRYPTO_ONCE load_crypto_strings = CRYPTO_ONCE_STATIC_INIT;
 163 static int load_crypto_strings_inited = 0;
 164 DEFINE_RUN_ONCE_STATIC(ossl_init_no_load_crypto_strings)
 165 {
 166     /* Do nothing in this case */
 167     return 1;
 168 }
 169
 170 DEFINE_RUN_ONCE_STATIC(ossl_init_load_crypto_strings)
 171 {
 172     int ret = 1;
 173     /*
 174      * OPENSSL_NO_AUTOERRINIT is provided here to prevent at compile time
 175      * pulling in all the error strings during static linking
 176      */
 177 #if !defined(OPENSSL_NO_ERR) && !defined(OPENSSL_NO_AUTOERRINIT)
 178 # ifdef OPENSSL_INIT_DEBUG
 179     fprintf(stderr, "OPENSSL_INIT: ossl_init_load_crypto_strings: "
 180                     "err_load_crypto_strings_int()\n");
 181 # endif
 182     ret = err_load_crypto_strings_int();
 183     load_crypto_strings_inited = 1;
 184 #endif
 185     return ret;
 186 }
 187
 188 static CRYPTO_ONCE add_all_ciphers = CRYPTO_ONCE_STATIC_INIT;
 189 DEFINE_RUN_ONCE_STATIC(ossl_init_add_all_ciphers)
 190 {
 191     /*
 192      * OPENSSL_NO_AUTOALGINIT is provided here to prevent at compile time
 193      * pulling in all the ciphers during static linking
 194      */
 195 #ifndef OPENSSL_NO_AUTOALGINIT
 196 # ifdef OPENSSL_INIT_DEBUG
 197     fprintf(stderr, "OPENSSL_INIT: ossl_init_add_all_ciphers: "
 198                     "openssl_add_all_ciphers_int()\n");
 199 # endif
 200     openssl_add_all_ciphers_int();
 201 #endif
 202     return 1;
 203 }
 204
 205 static CRYPTO_ONCE add_all_digests = CRYPTO_ONCE_STATIC_INIT;
 206 DEFINE_RUN_ONCE_STATIC(ossl_init_add_all_digests)
 207 {
 208     /*
 209      * OPENSSL_NO_AUTOALGINIT is provided here to prevent at compile time
 210      * pulling in all the ciphers during static linking
 211      */
 212 #ifndef OPENSSL_NO_AUTOALGINIT
 213 # ifdef OPENSSL_INIT_DEBUG
 214     fprintf(stderr, "OPENSSL_INIT: ossl_init_add_all_digests: "
 215                     "openssl_add_all_digests()\n");
 216 # endif
 217     openssl_add_all_digests_int();
 218 #endif
 219     return 1;
 220 }
 221
 222 DEFINE_RUN_ONCE_STATIC(ossl_init_no_add_algs)
 223 {
 224     /* Do nothing */
 225     return 1;
 226 }
 227
 228 static CRYPTO_ONCE config = CRYPTO_ONCE_STATIC_INIT;
 229 static int config_inited = 0;
 230 static const char *appname;
 231 DEFINE_RUN_ONCE_STATIC(ossl_init_config)
 232 {
 233 #ifdef OPENSSL_INIT_DEBUG
 234     fprintf(stderr,
 235             "OPENSSL_INIT: ossl_init_config: openssl_config(%s)\n",
 236             appname == NULL ? "NULL" : appname);
 237 #endif
 238     openssl_config_int(appname);
 239     config_inited = 1;
 240     return 1;
 241 }
 242 DEFINE_RUN_ONCE_STATIC(ossl_init_no_config)
 243 {
 244 #ifdef OPENSSL_INIT_DEBUG
 245     fprintf(stderr,
 246             "OPENSSL_INIT: ossl_init_config: openssl_no_config_int()\n");
 247 #endif
 248     openssl_no_config_int();
 249     config_inited = 1;
 250     return 1;
 251 }
 252
 253 static CRYPTO_ONCE async = CRYPTO_ONCE_STATIC_INIT;
 254 static int async_inited = 0;
 255 DEFINE_RUN_ONCE_STATIC(ossl_init_async)
 256 {
 257 #ifdef OPENSSL_INIT_DEBUG
 258     fprintf(stderr, "OPENSSL_INIT: ossl_init_async: async_init()\n");
 259 #endif
 260     if (!async_init())
 261         return 0;
 262     async_inited = 1;
 263     return 1;
 264 }
 265
 266 #ifndef OPENSSL_NO_ENGINE
 267 static CRYPTO_ONCE engine_openssl = CRYPTO_ONCE_STATIC_INIT;
 268 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_openssl)
 269 {
 270 # ifdef OPENSSL_INIT_DEBUG
 271     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_openssl: "
 272                     "engine_load_openssl_int()\n");
 273 # endif
 274     engine_load_openssl_int();
 275     return 1;
 276 }
 277 # ifndef OPENSSL_NO_DEVCRYPTOENG
 278 static CRYPTO_ONCE engine_devcrypto = CRYPTO_ONCE_STATIC_INIT;
 279 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_devcrypto)
 280 {
 281 #  ifdef OPENSSL_INIT_DEBUG
 282     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_devcrypto: "
 283                     "engine_load_devcrypto_int()\n");
 284 #  endif
 285     engine_load_devcrypto_int();
 286     return 1;
 287 }
 288 # endif
 289
 290 # ifndef OPENSSL_NO_RDRAND
 291 static CRYPTO_ONCE engine_rdrand = CRYPTO_ONCE_STATIC_INIT;
 292 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_rdrand)
 293 {
 294 #  ifdef OPENSSL_INIT_DEBUG
 295     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_rdrand: "
 296                     "engine_load_rdrand_int()\n");
 297 #  endif
 298     engine_load_rdrand_int();
 299     return 1;
 300 }
 301 # endif
 302 static CRYPTO_ONCE engine_dynamic = CRYPTO_ONCE_STATIC_INIT;
 303 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_dynamic)
 304 {
 305 # ifdef OPENSSL_INIT_DEBUG
 306     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_dynamic: "
 307                     "engine_load_dynamic_int()\n");
 308 # endif
 309     engine_load_dynamic_int();
 310     return 1;
 311 }
 312 # ifndef OPENSSL_NO_STATIC_ENGINE
 313 #  if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_PADLOCK)
 314 static CRYPTO_ONCE engine_padlock = CRYPTO_ONCE_STATIC_INIT;
 315 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_padlock)
 316 {
 317 #   ifdef OPENSSL_INIT_DEBUG
 318     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_padlock: "
 319                     "engine_load_padlock_int()\n");
 320 #   endif
 321     engine_load_padlock_int();
 322     return 1;
 323 }
 324 #  endif
 325 #  if defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_NO_CAPIENG)
 326 static CRYPTO_ONCE engine_capi = CRYPTO_ONCE_STATIC_INIT;
 327 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_capi)
 328 {
 329 #   ifdef OPENSSL_INIT_DEBUG
 330     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_capi: "
 331                     "engine_load_capi_int()\n");
 332 #   endif
 333     engine_load_capi_int();
 334     return 1;
 335 }
 336 #  endif
 337 #  if !defined(OPENSSL_NO_AFALGENG)
 338 static CRYPTO_ONCE engine_afalg = CRYPTO_ONCE_STATIC_INIT;
 339 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_afalg)
 340 {
 341 #   ifdef OPENSSL_INIT_DEBUG
 342     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_afalg: "
 343                     "engine_load_afalg_int()\n");
 344 #   endif
 345     engine_load_afalg_int();
 346     return 1;
 347 }
 348 #  endif
 349 # endif
 350 #endif
 351
 352 #ifndef OPENSSL_NO_COMP
 353 static CRYPTO_ONCE zlib = CRYPTO_ONCE_STATIC_INIT;
 354
 355 static int zlib_inited = 0;
 356 DEFINE_RUN_ONCE_STATIC(ossl_init_zlib)
 357 {
 358     /* Do nothing - we need to know about this for the later cleanup */
 359     zlib_inited = 1;
 360     return 1;
 361 }
 362 #endif
 363
 364 static void ossl_init_thread_stop(struct thread_local_inits_st *locals)
 365 {
 366     /* Can't do much about this */
 367     if (locals == NULL)
 368         return;
 369
 370     if (locals->async) {
 371 #ifdef OPENSSL_INIT_DEBUG
 372         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_stop: "
 373                         "async_delete_thread_state()\n");
 374 #endif
 375         async_delete_thread_state();
 376     }
 377
 378     if (locals->err_state) {
 379 #ifdef OPENSSL_INIT_DEBUG
 380         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_stop: "
 381                         "err_delete_thread_state()\n");
 382 #endif
 383         err_delete_thread_state();
 384     }
 385
 386     if (locals->rand) {
 387 #ifdef OPENSSL_INIT_DEBUG
 388         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_stop: "
 389                         "drbg_delete_thread_state()\n");
 390 #endif
 391         drbg_delete_thread_state();
 392     }
 393
 394     OPENSSL_free(locals);
 395 }
 396
 397 void OPENSSL_thread_stop(void)
 398 {
 399     ossl_init_thread_stop(
 400         (struct thread_local_inits_st *)ossl_init_get_thread_local(0));
 401 }
 402
 403 int ossl_init_thread_start(uint64_t opts)
 404 {
 405     struct thread_local_inits_st *locals;
 406
 407     if (!OPENSSL_init_crypto(0, NULL))
 408         return 0;
 409
 410     locals = ossl_init_get_thread_local(1);
 411
 412     if (locals == NULL)
 413         return 0;
 414
 415     if (opts & OPENSSL_INIT_THREAD_ASYNC) {
 416 #ifdef OPENSSL_INIT_DEBUG
 417         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_start: "
 418                         "marking thread for async\n");
 419 #endif
 420         locals->async = 1;
 421     }
 422
 423     if (opts & OPENSSL_INIT_THREAD_ERR_STATE) {
 424 #ifdef OPENSSL_INIT_DEBUG
 425         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_start: "
 426                         "marking thread for err_state\n");
 427 #endif
 428         locals->err_state = 1;
 429     }
 430
 431     if (opts & OPENSSL_INIT_THREAD_RAND) {
 432 #ifdef OPENSSL_INIT_DEBUG
 433         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_start: "
 434                         "marking thread for rand\n");
 435 #endif
 436         locals->rand = 1;
 437     }
 438
 439     return 1;
 440 }
 441
 442 void OPENSSL_cleanup(void)
 443 {
 444     OPENSSL_INIT_STOP *currhandler, *lasthandler;
 445
 446     /* If we've not been inited then no need to deinit */
 447     if (!base_inited)
 448         return;
 449
 450     /* Might be explicitly called and also by atexit */
 451     if (stopped)
 452         return;
 453     stopped = 1;
 454
 455     /*
 456      * Thread stop may not get automatically called by the thread library for
 457      * the very last thread in some situations, so call it directly.
 458      */
 459     ossl_init_thread_stop(ossl_init_get_thread_local(0));
 460
 461     currhandler = stop_handlers;
 462     while (currhandler != NULL) {
 463         currhandler->handler();
 464         lasthandler = currhandler;
 465         currhandler = currhandler->next;
 466         OPENSSL_free(lasthandler);
 467     }
 468     stop_handlers = NULL;
 469
 470     CRYPTO_THREAD_lock_free(init_lock);
 471     init_lock = NULL;
 472
 473     /*
 474      * We assume we are single-threaded for this function, i.e. no race
 475      * conditions for the various "*_inited" vars below.
 476      */
 477
 478 #ifndef OPENSSL_NO_COMP
 479     if (zlib_inited) {
 480 #ifdef OPENSSL_INIT_DEBUG
 481         fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 482                         "comp_zlib_cleanup_int()\n");
 483 #endif
 484         comp_zlib_cleanup_int();
 485     }
 486 #endif
 487
 488     if (async_inited) {
 489 # ifdef OPENSSL_INIT_DEBUG
 490         fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 491                         "async_deinit()\n");
 492 # endif
 493         async_deinit();
 494     }
 495
 496     if (load_crypto_strings_inited) {
 497 #ifdef OPENSSL_INIT_DEBUG
 498         fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 499                         "err_free_strings_int()\n");
 500 #endif
 501         err_free_strings_int();
 502     }
 503
 504     CRYPTO_THREAD_cleanup_local(&threadstopkey);
 505
 506 #ifdef OPENSSL_INIT_DEBUG
 507     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 508                     "rand_cleanup_int()\n");
 509     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 510                     "conf_modules_free_int()\n");
 511 #ifndef OPENSSL_NO_ENGINE
 512     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 513                     "engine_cleanup_int()\n");
 514 #endif
 515     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 516                     "crypto_cleanup_all_ex_data_int()\n");
 517     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 518                     "bio_sock_cleanup_int()\n");
 519     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 520                     "bio_cleanup()\n");
 521     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 522                     "evp_cleanup_int()\n");
 523     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 524                     "obj_cleanup_int()\n");
 525     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 526                     "err_cleanup()\n");
 527 #endif
 528     /*
 529      * Note that cleanup order is important:
 530      * - rand_cleanup_int could call an ENGINE's RAND cleanup function so
 531      * must be called before engine_cleanup_int()
 532      * - ENGINEs use CRYPTO_EX_DATA and therefore, must be cleaned up
 533      * before the ex data handlers are wiped in CRYPTO_cleanup_all_ex_data().
 534      * - conf_modules_free_int() can end up in ENGINE code so must be called
 535      * before engine_cleanup_int()
 536      * - ENGINEs and additional EVP algorithms might use added OIDs names so
 537      * obj_cleanup_int() must be called last
 538      */
 539     rand_cleanup_int();
 540     rand_drbg_cleanup_int();
 541     conf_modules_free_int();
 542 #ifndef OPENSSL_NO_ENGINE
 543     engine_cleanup_int();
 544 #endif
 545     ossl_store_cleanup_int();
 546     crypto_cleanup_all_ex_data_int();
 547     bio_cleanup();
 548     evp_cleanup_int();
 549     obj_cleanup_int();
 550     err_cleanup();
 551
 552     CRYPTO_secure_malloc_done();
 553
 554     base_inited = 0;
 555 }
 556
 557 /*
 558  * If this function is called with a non NULL settings value then it must be
 559  * called prior to any threads making calls to any OpenSSL functions,
 560  * i.e. passing a non-null settings value is assumed to be single-threaded.
 561  */
 562 int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings)
 563 {
 564     if (stopped) {
 565         if (!(opts & OPENSSL_INIT_BASE_ONLY))
 566             CRYPTOerr(CRYPTO_F_OPENSSL_INIT_CRYPTO, ERR_R_INIT_FAIL);
 567         return 0;
 568     }
 569
 570     if (!RUN_ONCE(&base, ossl_init_base))
 571         return 0;
 572
 573     if (!(opts & OPENSSL_INIT_BASE_ONLY)
 574             && !RUN_ONCE(&load_crypto_nodelete,
 575                          ossl_init_load_crypto_nodelete))
 576         return 0;
 577
 578     if ((opts & OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS)
 579             && !RUN_ONCE(&load_crypto_strings,
 580                          ossl_init_no_load_crypto_strings))
 581         return 0;
 582
 583     if ((opts & OPENSSL_INIT_LOAD_CRYPTO_STRINGS)
 584             && !RUN_ONCE(&load_crypto_strings, ossl_init_load_crypto_strings))
 585         return 0;
 586
 587     if ((opts & OPENSSL_INIT_NO_ADD_ALL_CIPHERS)
 588             && !RUN_ONCE(&add_all_ciphers, ossl_init_no_add_algs))
 589         return 0;
 590
 591     if ((opts & OPENSSL_INIT_ADD_ALL_CIPHERS)
 592             && !RUN_ONCE(&add_all_ciphers, ossl_init_add_all_ciphers))
 593         return 0;
 594
 595     if ((opts & OPENSSL_INIT_NO_ADD_ALL_DIGESTS)
 596             && !RUN_ONCE(&add_all_digests, ossl_init_no_add_algs))
 597         return 0;
 598
 599     if ((opts & OPENSSL_INIT_ADD_ALL_DIGESTS)
 600             && !RUN_ONCE(&add_all_digests, ossl_init_add_all_digests))
 601         return 0;
 602
 603     if ((opts & OPENSSL_INIT_ATFORK)
 604             && !openssl_init_fork_handlers())
 605         return 0;
 606
 607     if ((opts & OPENSSL_INIT_NO_LOAD_CONFIG)
 608             && !RUN_ONCE(&config, ossl_init_no_config))
 609         return 0;
 610
 611     if (opts & OPENSSL_INIT_LOAD_CONFIG) {
 612         int ret;
 613         CRYPTO_THREAD_write_lock(init_lock);
 614         appname = (settings == NULL) ? NULL : settings->appname;
 615         ret = RUN_ONCE(&config, ossl_init_config);
 616         CRYPTO_THREAD_unlock(init_lock);
 617         if (!ret)
 618             return 0;
 619     }
 620
 621     if ((opts & OPENSSL_INIT_ASYNC)
 622             && !RUN_ONCE(&async, ossl_init_async))
 623         return 0;
 624
 625 #ifndef OPENSSL_NO_ENGINE
 626     if ((opts & OPENSSL_INIT_ENGINE_OPENSSL)
 627             && !RUN_ONCE(&engine_openssl, ossl_init_engine_openssl))
 628         return 0;
 629 # if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_DEVCRYPTOENG)
 630     if ((opts & OPENSSL_INIT_ENGINE_CRYPTODEV)
 631             && !RUN_ONCE(&engine_devcrypto, ossl_init_engine_devcrypto))
 632         return 0;
 633 # endif
 634 # ifndef OPENSSL_NO_RDRAND
 635     if ((opts & OPENSSL_INIT_ENGINE_RDRAND)
 636             && !RUN_ONCE(&engine_rdrand, ossl_init_engine_rdrand))
 637         return 0;
 638 # endif
 639     if ((opts & OPENSSL_INIT_ENGINE_DYNAMIC)
 640             && !RUN_ONCE(&engine_dynamic, ossl_init_engine_dynamic))
 641         return 0;
 642 # ifndef OPENSSL_NO_STATIC_ENGINE
 643 #  if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_PADLOCK)
 644     if ((opts & OPENSSL_INIT_ENGINE_PADLOCK)
 645             && !RUN_ONCE(&engine_padlock, ossl_init_engine_padlock))
 646         return 0;
 647 #  endif
 648 #  if defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_NO_CAPIENG)
 649     if ((opts & OPENSSL_INIT_ENGINE_CAPI)
 650             && !RUN_ONCE(&engine_capi, ossl_init_engine_capi))
 651         return 0;
 652 #  endif
 653 #  if !defined(OPENSSL_NO_AFALGENG)
 654     if ((opts & OPENSSL_INIT_ENGINE_AFALG)
 655             && !RUN_ONCE(&engine_afalg, ossl_init_engine_afalg))
 656         return 0;
 657 #  endif
 658 # endif
 659     if (opts & (OPENSSL_INIT_ENGINE_ALL_BUILTIN
 660                 | OPENSSL_INIT_ENGINE_OPENSSL
 661                 | OPENSSL_INIT_ENGINE_AFALG)) {
 662         ENGINE_register_all_complete();
 663     }
 664 #endif
 665
 666 #ifndef OPENSSL_NO_COMP
 667     if ((opts & OPENSSL_INIT_ZLIB)
 668             && !RUN_ONCE(&zlib, ossl_init_zlib))
 669         return 0;
 670 #endif
 671
 672     return 1;
 673 }
 674
 675 int OPENSSL_atexit(void (*handler)(void))
 676 {
 677     OPENSSL_INIT_STOP *newhand;
 678
 679 #if !defined(OPENSSL_NO_DSO) && !defined(OPENSSL_USE_NODELETE)
 680     {
 681         union {
 682             void *sym;
 683             void (*func)(void);
 684         } handlersym;
 685
 686         handlersym.func = handler;
 687 # ifdef DSO_WIN32
 688         {
 689             HMODULE handle = NULL;
 690             BOOL ret;
 691
 692             /*
 693              * We don't use the DSO route for WIN32 because there is a better
 694              * way
 695              */
 696             ret = GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
 697                                     | GET_MODULE_HANDLE_EX_FLAG_PIN,
 698                                     handlersym.sym, &handle);
 699
 700             if (!ret)
 701                 return 0;
 702         }
 703 # else
 704         /*
 705          * Deliberately leak a reference to the handler. This will force the
 706          * library/code containing the handler to remain loaded until we run the
 707          * atexit handler. If -znodelete has been used then this is
 708          * unnecessary.
 709          */
 710         {
 711             DSO *dso = NULL;
 712
 713             ERR_set_mark();
 714             dso = DSO_dsobyaddr(handlersym.sym, DSO_FLAG_NO_UNLOAD_ON_FREE);
 715 #  ifdef OPENSSL_INIT_DEBUG
 716             fprintf(stderr,
 717                     "OPENSSL_INIT: OPENSSL_atexit: obtained DSO reference? %s\n",
 718                     (dso == NULL ? "No!" : "Yes."));
 719             /* See same code above in ossl_init_base() for an explanation. */
 720 #  endif
 721             DSO_free(dso);
 722             ERR_pop_to_mark();
 723         }
 724 # endif
 725     }
 726 #endif
 727
 728     if ((newhand = OPENSSL_malloc(sizeof(*newhand))) == NULL) {
 729         CRYPTOerr(CRYPTO_F_OPENSSL_ATEXIT, ERR_R_MALLOC_FAILURE);
 730         return 0;
 731     }
 732
 733     newhand->handler = handler;
 734     newhand->next = stop_handlers;
 735     stop_handlers = newhand;
 736
 737     return 1;
 738 }
 739
 740 #ifdef OPENSSL_SYS_UNIX
 741 /*
 742  * The following three functions are for OpenSSL developers.  This is
 743  * where we set/reset state across fork (called via pthread_atfork when
 744  * it exists, or manually by the application when it doesn't).
 745  *
 746  * WARNING!  If you put code in either OPENSSL_fork_parent or
 747  * OPENSSL_fork_child, you MUST MAKE SURE that they are async-signal-
 748  * safe.  See this link, for example:
 749  *      http://man7.org/linux/man-pages/man7/signal-safety.7.html
 750  */
 751
 752 void OPENSSL_fork_prepare(void)
 753 {
 754 }
 755
 756 void OPENSSL_fork_parent(void)
 757 {
 758 }
 759
 760 void OPENSSL_fork_child(void)
 761 {
 762     rand_fork();
 763 }
 764 #endif