crypto/init.c

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