Fix the spelling of "implement".
[openssl.git] / 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                     "evp_cleanup_int()\n");
472     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
473                     "obj_cleanup_int()\n");
474 #endif
475     /*
476      * Note that cleanup order is important:
477      * - rand_cleanup_int could call an ENGINE's RAND cleanup function so
478      * must be called before engine_cleanup_int()
479      * - ENGINEs use CRYPTO_EX_DATA and therefore, must be cleaned up
480      * before the ex data handlers are wiped in CRYPTO_cleanup_all_ex_data().
481      * - conf_modules_free_int() can end up in ENGINE code so must be called
482      * before engine_cleanup_int()
483      * - ENGINEs and additional EVP algorithms might use added OIDs names so
484      * obj_cleanup_int() must be called last
485      */
486     rand_cleanup_int();
487     conf_modules_free_int();
488 #ifndef OPENSSL_NO_ENGINE
489     engine_cleanup_int();
490 #endif
491     crypto_cleanup_all_ex_data_int();
492 #ifndef OPENSSL_NO_SOCK
493     bio_sock_cleanup_int();
494 #endif
495     evp_cleanup_int();
496     obj_cleanup_int();
497     base_inited = 0;
498 }
499
500 /*
501  * If this function is called with a non NULL settings value then it must be
502  * called prior to any threads making calls to any OpenSSL functions,
503  * i.e. passing a non-null settings value is assumed to be single-threaded.
504  */
505 int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings)
506 {
507     static int stoperrset = 0;
508
509     if (stopped) {
510         if (!stoperrset) {
511             /*
512              * We only ever set this once to avoid getting into an infinite
513              * loop where the error system keeps trying to init and fails so
514              * sets an error etc
515              */
516             stoperrset = 1;
517             CRYPTOerr(CRYPTO_F_OPENSSL_INIT_CRYPTO, ERR_R_INIT_FAIL);
518         }
519         return 0;
520     }
521
522     if (!CRYPTO_THREAD_run_once(&base, ossl_init_base))
523         return 0;
524
525     if ((opts & OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS)
526             && !CRYPTO_THREAD_run_once(&load_crypto_strings,
527                                        ossl_init_no_load_crypto_strings))
528         return 0;
529
530     if ((opts & OPENSSL_INIT_LOAD_CRYPTO_STRINGS)
531             && !CRYPTO_THREAD_run_once(&load_crypto_strings,
532                                        ossl_init_load_crypto_strings))
533         return 0;
534
535     if ((opts & OPENSSL_INIT_NO_ADD_ALL_CIPHERS)
536             && !CRYPTO_THREAD_run_once(&add_all_ciphers, ossl_init_no_add_algs))
537         return 0;
538
539     if ((opts & OPENSSL_INIT_ADD_ALL_CIPHERS)
540             && !CRYPTO_THREAD_run_once(&add_all_ciphers,
541                                        ossl_init_add_all_ciphers))
542         return 0;
543
544     if ((opts & OPENSSL_INIT_NO_ADD_ALL_DIGESTS)
545             && !CRYPTO_THREAD_run_once(&add_all_digests, ossl_init_no_add_algs))
546         return 0;
547
548     if ((opts & OPENSSL_INIT_ADD_ALL_DIGESTS)
549             && !CRYPTO_THREAD_run_once(&add_all_digests,
550                                        ossl_init_add_all_digests))
551         return 0;
552
553     if ((opts & OPENSSL_INIT_NO_LOAD_CONFIG)
554             && !CRYPTO_THREAD_run_once(&config, ossl_init_no_config))
555         return 0;
556
557     if (opts & OPENSSL_INIT_LOAD_CONFIG) {
558         int ret;
559         CRYPTO_THREAD_write_lock(init_lock);
560         config_filename = (settings == NULL) ? NULL : settings->config_name;
561         ret = CRYPTO_THREAD_run_once(&config, ossl_init_config);
562         CRYPTO_THREAD_unlock(init_lock);
563         if (!ret)
564             return 0;
565     }
566
567     if ((opts & OPENSSL_INIT_ASYNC)
568             && !CRYPTO_THREAD_run_once(&async, ossl_init_async))
569         return 0;
570
571 #ifndef OPENSSL_NO_ENGINE
572     if ((opts & OPENSSL_INIT_ENGINE_OPENSSL)
573             && !CRYPTO_THREAD_run_once(&engine_openssl,
574                                        ossl_init_engine_openssl))
575         return 0;
576 # if !defined(OPENSSL_NO_HW) && \
577     (defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV))
578     if ((opts & OPENSSL_INIT_ENGINE_CRYPTODEV)
579             && !CRYPTO_THREAD_run_once(&engine_cryptodev,
580                                        ossl_init_engine_cryptodev))
581         return 0;
582 # endif
583 # ifndef OPENSSL_NO_RDRAND
584     if ((opts & OPENSSL_INIT_ENGINE_RDRAND)
585             && !CRYPTO_THREAD_run_once(&engine_rdrand, ossl_init_engine_rdrand))
586         return 0;
587 # endif
588     if ((opts & OPENSSL_INIT_ENGINE_DYNAMIC)
589             && !CRYPTO_THREAD_run_once(&engine_dynamic,
590                                        ossl_init_engine_dynamic))
591         return 0;
592 # ifndef OPENSSL_NO_STATIC_ENGINE
593 #  if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_PADLOCK)
594     if ((opts & OPENSSL_INIT_ENGINE_PADLOCK)
595             && !CRYPTO_THREAD_run_once(&engine_padlock,
596                                        ossl_init_engine_padlock))
597         return 0;
598 #  endif
599 #  if defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_NO_CAPIENG)
600     if ((opts & OPENSSL_INIT_ENGINE_CAPI)
601             && !CRYPTO_THREAD_run_once(&engine_capi, ossl_init_engine_capi))
602         return 0;
603 #  endif
604     if ((opts & OPENSSL_INIT_ENGINE_DASYNC)
605             && !CRYPTO_THREAD_run_once(&engine_dasync, ossl_init_engine_dasync))
606         return 0;
607 #  if !defined(OPENSSL_NO_AFALGENG)
608     if ((opts & OPENSSL_INIT_ENGINE_AFALG)
609             && !CRYPTO_THREAD_run_once(&engine_afalg, ossl_init_engine_afalg))
610         return 0;
611 #  endif
612 # endif
613     if (opts & (OPENSSL_INIT_ENGINE_ALL_BUILTIN
614                 | OPENSSL_INIT_ENGINE_DASYNC | OPENSSL_INIT_ENGINE_OPENSSL
615                 | OPENSSL_INIT_ENGINE_AFALG)) {
616         ENGINE_register_all_complete();
617     }
618 #endif
619
620 #ifndef OPENSSL_NO_COMP
621     if ((opts & OPENSSL_INIT_ZLIB)
622             && !CRYPTO_THREAD_run_once(&zlib, ossl_init_zlib))
623         return 0;
624 #endif
625
626     return 1;
627 }
628
629 int OPENSSL_atexit(void (*handler)(void))
630 {
631     OPENSSL_INIT_STOP *newhand;
632
633     newhand = OPENSSL_malloc(sizeof(*newhand));
634     if (newhand == NULL)
635         return 0;
636
637     newhand->handler = handler;
638     newhand->next = stop_handlers;
639     stop_handlers = newhand;
640
641     return 1;
642 }