Work around Travis "virtual memory exhausted" error
[openssl.git] / 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         CRYPTO_THREAD_set_local(&threadstopkey, local);
47     }
48     if (!alloc) {
49         CRYPTO_THREAD_set_local(&threadstopkey, NULL);
50     }
51
52     return local;
53 }
54
55 typedef struct ossl_init_stop_st OPENSSL_INIT_STOP;
56 struct ossl_init_stop_st {
57     void (*handler)(void);
58     OPENSSL_INIT_STOP *next;
59 };
60
61 static OPENSSL_INIT_STOP *stop_handlers = NULL;
62 static CRYPTO_RWLOCK *init_lock = NULL;
63
64 static CRYPTO_ONCE base = CRYPTO_ONCE_STATIC_INIT;
65 static int base_inited = 0;
66 DEFINE_RUN_ONCE_STATIC(ossl_init_base)
67 {
68 #ifdef OPENSSL_INIT_DEBUG
69     fprintf(stderr, "OPENSSL_INIT: ossl_init_base: Setting up stop handlers\n");
70 #endif
71 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
72     ossl_malloc_setup_failures();
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(__DragonFly__) || 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 = ossl_init_get_thread_local(1);
363
364     if (locals == NULL)
365         return 0;
366
367     if (opts & OPENSSL_INIT_THREAD_ASYNC) {
368 #ifdef OPENSSL_INIT_DEBUG
369         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_start: "
370                         "marking thread for async\n");
371 #endif
372         locals->async = 1;
373     }
374
375     if (opts & OPENSSL_INIT_THREAD_ERR_STATE) {
376 #ifdef OPENSSL_INIT_DEBUG
377         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_start: "
378                         "marking thread for err_state\n");
379 #endif
380         locals->err_state = 1;
381     }
382
383     return 1;
384 }
385
386 void OPENSSL_cleanup(void)
387 {
388     OPENSSL_INIT_STOP *currhandler, *lasthandler;
389
390     /* If we've not been inited then no need to deinit */
391     if (!base_inited)
392         return;
393
394     /* Might be explicitly called and also by atexit */
395     if (stopped)
396         return;
397     stopped = 1;
398
399     /*
400      * Thread stop may not get automatically called by the thread library for
401      * the very last thread in some situations, so call it directly.
402      */
403     ossl_init_thread_stop(ossl_init_get_thread_local(0));
404
405     currhandler = stop_handlers;
406     while (currhandler != NULL) {
407         currhandler->handler();
408         lasthandler = currhandler;
409         currhandler = currhandler->next;
410         OPENSSL_free(lasthandler);
411     }
412     stop_handlers = NULL;
413
414     CRYPTO_THREAD_lock_free(init_lock);
415
416     /*
417      * We assume we are single-threaded for this function, i.e. no race
418      * conditions for the various "*_inited" vars below.
419      */
420
421 #ifndef OPENSSL_NO_COMP
422     if (zlib_inited) {
423 #ifdef OPENSSL_INIT_DEBUG
424         fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
425                         "comp_zlib_cleanup_int()\n");
426 #endif
427         comp_zlib_cleanup_int();
428     }
429 #endif
430
431     if (async_inited) {
432 # ifdef OPENSSL_INIT_DEBUG
433         fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
434                         "async_deinit()\n");
435 # endif
436         async_deinit();
437     }
438
439     if (load_crypto_strings_inited) {
440 #ifdef OPENSSL_INIT_DEBUG
441         fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
442                         "err_free_strings_int()\n");
443 #endif
444         err_free_strings_int();
445     }
446
447     CRYPTO_THREAD_cleanup_local(&threadstopkey);
448
449 #ifdef OPENSSL_INIT_DEBUG
450     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
451                     "rand_cleanup_int()\n");
452     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
453                     "conf_modules_free_int()\n");
454 #ifndef OPENSSL_NO_ENGINE
455     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
456                     "engine_cleanup_int()\n");
457 #endif
458     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
459                     "crypto_cleanup_all_ex_data_int()\n");
460     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
461                     "bio_sock_cleanup_int()\n");
462     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
463                     "bio_cleanup()\n");
464     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
465                     "evp_cleanup_int()\n");
466     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
467                     "obj_cleanup_int()\n");
468     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
469                     "err_cleanup()\n");
470 #endif
471     /*
472      * Note that cleanup order is important:
473      * - rand_cleanup_int could call an ENGINE's RAND cleanup function so
474      * must be called before engine_cleanup_int()
475      * - ENGINEs use CRYPTO_EX_DATA and therefore, must be cleaned up
476      * before the ex data handlers are wiped in CRYPTO_cleanup_all_ex_data().
477      * - conf_modules_free_int() can end up in ENGINE code so must be called
478      * before engine_cleanup_int()
479      * - ENGINEs and additional EVP algorithms might use added OIDs names so
480      * obj_cleanup_int() must be called last
481      */
482     rand_cleanup_int();
483     conf_modules_free_int();
484 #ifndef OPENSSL_NO_ENGINE
485     engine_cleanup_int();
486 #endif
487     crypto_cleanup_all_ex_data_int();
488     bio_cleanup();
489     evp_cleanup_int();
490     obj_cleanup_int();
491     err_cleanup();
492
493     base_inited = 0;
494 }
495
496 /*
497  * If this function is called with a non NULL settings value then it must be
498  * called prior to any threads making calls to any OpenSSL functions,
499  * i.e. passing a non-null settings value is assumed to be single-threaded.
500  */
501 int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings)
502 {
503     static int stoperrset = 0;
504
505     if (stopped) {
506         if (!stoperrset) {
507             /*
508              * We only ever set this once to avoid getting into an infinite
509              * loop where the error system keeps trying to init and fails so
510              * sets an error etc
511              */
512             stoperrset = 1;
513             CRYPTOerr(CRYPTO_F_OPENSSL_INIT_CRYPTO, ERR_R_INIT_FAIL);
514         }
515         return 0;
516     }
517
518     if (!base_inited && !RUN_ONCE(&base, ossl_init_base))
519         return 0;
520
521     if ((opts & OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS)
522             && !RUN_ONCE(&load_crypto_strings,
523                          ossl_init_no_load_crypto_strings))
524         return 0;
525
526     if ((opts & OPENSSL_INIT_LOAD_CRYPTO_STRINGS)
527             && !RUN_ONCE(&load_crypto_strings, ossl_init_load_crypto_strings))
528         return 0;
529
530     if ((opts & OPENSSL_INIT_NO_ADD_ALL_CIPHERS)
531             && !RUN_ONCE(&add_all_ciphers, ossl_init_no_add_algs))
532         return 0;
533
534     if ((opts & OPENSSL_INIT_ADD_ALL_CIPHERS)
535             && !RUN_ONCE(&add_all_ciphers, ossl_init_add_all_ciphers))
536         return 0;
537
538     if ((opts & OPENSSL_INIT_NO_ADD_ALL_DIGESTS)
539             && !RUN_ONCE(&add_all_digests, ossl_init_no_add_algs))
540         return 0;
541
542     if ((opts & OPENSSL_INIT_ADD_ALL_DIGESTS)
543             && !RUN_ONCE(&add_all_digests, ossl_init_add_all_digests))
544         return 0;
545
546     if ((opts & OPENSSL_INIT_NO_LOAD_CONFIG)
547             && !RUN_ONCE(&config, ossl_init_no_config))
548         return 0;
549
550     if (opts & OPENSSL_INIT_LOAD_CONFIG) {
551         int ret;
552         CRYPTO_THREAD_write_lock(init_lock);
553         appname = (settings == NULL) ? NULL : settings->appname;
554         ret = RUN_ONCE(&config, ossl_init_config);
555         CRYPTO_THREAD_unlock(init_lock);
556         if (!ret)
557             return 0;
558     }
559
560     if ((opts & OPENSSL_INIT_ASYNC)
561             && !RUN_ONCE(&async, ossl_init_async))
562         return 0;
563
564 #ifndef OPENSSL_NO_ENGINE
565     if ((opts & OPENSSL_INIT_ENGINE_OPENSSL)
566             && !RUN_ONCE(&engine_openssl, ossl_init_engine_openssl))
567         return 0;
568 # if !defined(OPENSSL_NO_HW) && \
569     (defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) || defined(HAVE_CRYPTODEV))
570     if ((opts & OPENSSL_INIT_ENGINE_CRYPTODEV)
571             && !RUN_ONCE(&engine_cryptodev, ossl_init_engine_cryptodev))
572         return 0;
573 # endif
574 # ifndef OPENSSL_NO_RDRAND
575     if ((opts & OPENSSL_INIT_ENGINE_RDRAND)
576             && !RUN_ONCE(&engine_rdrand, ossl_init_engine_rdrand))
577         return 0;
578 # endif
579     if ((opts & OPENSSL_INIT_ENGINE_DYNAMIC)
580             && !RUN_ONCE(&engine_dynamic, ossl_init_engine_dynamic))
581         return 0;
582 # ifndef OPENSSL_NO_STATIC_ENGINE
583 #  if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_PADLOCK)
584     if ((opts & OPENSSL_INIT_ENGINE_PADLOCK)
585             && !RUN_ONCE(&engine_padlock, ossl_init_engine_padlock))
586         return 0;
587 #  endif
588 #  if defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_NO_CAPIENG)
589     if ((opts & OPENSSL_INIT_ENGINE_CAPI)
590             && !RUN_ONCE(&engine_capi, ossl_init_engine_capi))
591         return 0;
592 #  endif
593 #  if !defined(OPENSSL_NO_AFALGENG)
594     if ((opts & OPENSSL_INIT_ENGINE_AFALG)
595             && !RUN_ONCE(&engine_afalg, ossl_init_engine_afalg))
596         return 0;
597 #  endif
598 # endif
599     if (opts & (OPENSSL_INIT_ENGINE_ALL_BUILTIN
600                 | OPENSSL_INIT_ENGINE_OPENSSL
601                 | OPENSSL_INIT_ENGINE_AFALG)) {
602         ENGINE_register_all_complete();
603     }
604 #endif
605
606 #ifndef OPENSSL_NO_COMP
607     if ((opts & OPENSSL_INIT_ZLIB)
608             && !RUN_ONCE(&zlib, ossl_init_zlib))
609         return 0;
610 #endif
611
612     return 1;
613 }
614
615 int OPENSSL_atexit(void (*handler)(void))
616 {
617     OPENSSL_INIT_STOP *newhand;
618
619 #if !defined(OPENSSL_NO_DSO) && !defined(OPENSSL_USE_NODELETE)
620     {
621         union {
622             void *sym;
623             void (*func)(void);
624         } handlersym;
625
626         handlersym.func = handler;
627 # ifdef DSO_WIN32
628         {
629             HMODULE handle = NULL;
630             BOOL ret;
631
632             /*
633              * We don't use the DSO route for WIN32 because there is a better
634              * way
635              */
636             ret = GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
637                                     | GET_MODULE_HANDLE_EX_FLAG_PIN,
638                                     handlersym.sym, &handle);
639
640             if (!ret)
641                 return 0;
642         }
643 # else
644         /*
645          * Deliberately leak a reference to the handler. This will force the
646          * library/code containing the handler to remain loaded until we run the
647          * atexit handler. If -znodelete has been used then this is
648          * unneccessary.
649          */
650         {
651             DSO *dso = NULL;
652
653             ERR_set_mark();
654             dso = DSO_dsobyaddr(handlersym.sym, DSO_FLAG_NO_UNLOAD_ON_FREE);
655             DSO_free(dso);
656             ERR_pop_to_mark();
657         }
658 # endif
659     }
660 #endif
661
662     newhand = OPENSSL_malloc(sizeof(*newhand));
663     if (newhand == NULL)
664         return 0;
665
666     newhand->handler = handler;
667     newhand->next = stop_handlers;
668     stop_handlers = newhand;
669
670     return 1;
671 }