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