source: EcnlProtoTool/trunk/openssl-1.1.0e/crypto/init.c@ 331

Last change on this file since 331 was 331, checked in by coas-nagasima, 6 years ago

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