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