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
  27 static int stopped = 0;
  28
  29 static void ossl_init_thread_stop(struct thread_local_inits_st *locals);
  30
  31 static CRYPTO_THREAD_LOCAL threadstopkey;
  32
  33 static void ossl_init_thread_stop_wrap(void *local)
  34 {
  35     ossl_init_thread_stop((struct thread_local_inits_st *)local);
  36 }
  37
  38 static struct thread_local_inits_st *ossl_init_get_thread_local(int alloc)
  39 {
  40     struct thread_local_inits_st *local =
  41         CRYPTO_THREAD_get_local(&threadstopkey);
  42
  43     if (local == NULL && alloc) {
  44         local = OPENSSL_zalloc(sizeof *local);
  45         CRYPTO_THREAD_set_local(&threadstopkey, local);
  46     }
  47     if (!alloc) {
  48         CRYPTO_THREAD_set_local(&threadstopkey, NULL);
  49     }
  50
  51     return local;
  52 }
  53
  54 typedef struct ossl_init_stop_st OPENSSL_INIT_STOP;
  55 struct ossl_init_stop_st {
  56     void (*handler)(void);
  57     OPENSSL_INIT_STOP *next;
  58 };
  59
  60 static OPENSSL_INIT_STOP *stop_handlers = NULL;
  61 static CRYPTO_RWLOCK *init_lock = NULL;
  62
  63 static CRYPTO_ONCE base = CRYPTO_ONCE_STATIC_INIT;
  64 static int base_inited = 0;
  65 DEFINE_RUN_ONCE_STATIC(ossl_init_base)
  66 {
  67 #ifdef OPENSSL_INIT_DEBUG
  68     fprintf(stderr, "OPENSSL_INIT: ossl_init_base: Setting up stop handlers\n");
  69 #endif
  70     /*
  71      * We use a dummy thread local key here. We use the destructor to detect
  72      * when the thread is going to stop (where that feature is available)
  73      */
  74     CRYPTO_THREAD_init_local(&threadstopkey, ossl_init_thread_stop_wrap);
  75 #ifndef OPENSSL_SYS_UEFI
  76     atexit(OPENSSL_cleanup);
  77 #endif
  78     if ((init_lock = CRYPTO_THREAD_lock_new()) == NULL)
  79         return 0;
  80     OPENSSL_cpuid_setup();
  81     base_inited = 1;
  82     return 1;
  83 }
  84
  85 static CRYPTO_ONCE load_crypto_strings = CRYPTO_ONCE_STATIC_INIT;
  86 static int load_crypto_strings_inited = 0;
  87 DEFINE_RUN_ONCE_STATIC(ossl_init_no_load_crypto_strings)
  88 {
  89     /* Do nothing in this case */
  90     return 1;
  91 }
  92
  93 DEFINE_RUN_ONCE_STATIC(ossl_init_load_crypto_strings)
  94 {
  95     int ret = 1;
  96     /*
  97      * OPENSSL_NO_AUTOERRINIT is provided here to prevent at compile time
  98      * pulling in all the error strings during static linking
  99      */
 100 #if !defined(OPENSSL_NO_ERR) && !defined(OPENSSL_NO_AUTOERRINIT)
 101 # ifdef OPENSSL_INIT_DEBUG
 102     fprintf(stderr, "OPENSSL_INIT: ossl_init_load_crypto_strings: "
 103                     "err_load_crypto_strings_int()\n");
 104 # endif
 105     ret = err_load_crypto_strings_int();
 106     load_crypto_strings_inited = 1;
 107 #endif
 108     return ret;
 109 }
 110
 111 static CRYPTO_ONCE add_all_ciphers = CRYPTO_ONCE_STATIC_INIT;
 112 DEFINE_RUN_ONCE_STATIC(ossl_init_add_all_ciphers)
 113 {
 114     /*
 115      * OPENSSL_NO_AUTOALGINIT is provided here to prevent at compile time
 116      * pulling in all the ciphers during static linking
 117      */
 118 #ifndef OPENSSL_NO_AUTOALGINIT
 119 # ifdef OPENSSL_INIT_DEBUG
 120     fprintf(stderr, "OPENSSL_INIT: ossl_init_add_all_ciphers: "
 121                     "openssl_add_all_ciphers_int()\n");
 122 # endif
 123     openssl_add_all_ciphers_int();
 124 #endif
 125     return 1;
 126 }
 127
 128 static CRYPTO_ONCE add_all_digests = CRYPTO_ONCE_STATIC_INIT;
 129 DEFINE_RUN_ONCE_STATIC(ossl_init_add_all_digests)
 130 {
 131     /*
 132      * OPENSSL_NO_AUTOALGINIT is provided here to prevent at compile time
 133      * pulling in all the ciphers during static linking
 134      */
 135 #ifndef OPENSSL_NO_AUTOALGINIT
 136 # ifdef OPENSSL_INIT_DEBUG
 137     fprintf(stderr, "OPENSSL_INIT: ossl_init_add_all_digests: "
 138                     "openssl_add_all_digests()\n");
 139 # endif
 140     openssl_add_all_digests_int();
 141 #endif
 142     return 1;
 143 }
 144
 145 DEFINE_RUN_ONCE_STATIC(ossl_init_no_add_algs)
 146 {
 147     /* Do nothing */
 148     return 1;
 149 }
 150
 151 static CRYPTO_ONCE config = CRYPTO_ONCE_STATIC_INIT;
 152 static int config_inited = 0;
 153 static const char *appname;
 154 DEFINE_RUN_ONCE_STATIC(ossl_init_config)
 155 {
 156 #ifdef OPENSSL_INIT_DEBUG
 157     fprintf(stderr,
 158             "OPENSSL_INIT: ossl_init_config: openssl_config(%s)\n",
 159             appname == NULL ? "NULL" : appname);
 160 #endif
 161     openssl_config_int(appname);
 162     config_inited = 1;
 163     return 1;
 164 }
 165 DEFINE_RUN_ONCE_STATIC(ossl_init_no_config)
 166 {
 167 #ifdef OPENSSL_INIT_DEBUG
 168     fprintf(stderr,
 169             "OPENSSL_INIT: ossl_init_config: openssl_no_config_int()\n");
 170 #endif
 171     openssl_no_config_int();
 172     config_inited = 1;
 173     return 1;
 174 }
 175
 176 static CRYPTO_ONCE async = CRYPTO_ONCE_STATIC_INIT;
 177 static int async_inited = 0;
 178 DEFINE_RUN_ONCE_STATIC(ossl_init_async)
 179 {
 180 #ifdef OPENSSL_INIT_DEBUG
 181     fprintf(stderr, "OPENSSL_INIT: ossl_init_async: async_init()\n");
 182 #endif
 183     if (!async_init())
 184         return 0;
 185     async_inited = 1;
 186     return 1;
 187 }
 188
 189 #ifndef OPENSSL_NO_ENGINE
 190 static CRYPTO_ONCE engine_openssl = CRYPTO_ONCE_STATIC_INIT;
 191 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_openssl)
 192 {
 193 # ifdef OPENSSL_INIT_DEBUG
 194     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_openssl: "
 195                     "engine_load_openssl_int()\n");
 196 # endif
 197     engine_load_openssl_int();
 198     return 1;
 199 }
 200 # if !defined(OPENSSL_NO_HW) && \
 201     (defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) || defined(HAVE_CRYPTODEV))
 202 static CRYPTO_ONCE engine_cryptodev = CRYPTO_ONCE_STATIC_INIT;
 203 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_cryptodev)
 204 {
 205 #  ifdef OPENSSL_INIT_DEBUG
 206     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_cryptodev: "
 207                     "engine_load_cryptodev_int()\n");
 208 #  endif
 209     engine_load_cryptodev_int();
 210     return 1;
 211 }
 212 # endif
 213
 214 # ifndef OPENSSL_NO_RDRAND
 215 static CRYPTO_ONCE engine_rdrand = CRYPTO_ONCE_STATIC_INIT;
 216 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_rdrand)
 217 {
 218 #  ifdef OPENSSL_INIT_DEBUG
 219     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_rdrand: "
 220                     "engine_load_rdrand_int()\n");
 221 #  endif
 222     engine_load_rdrand_int();
 223     return 1;
 224 }
 225 # endif
 226 static CRYPTO_ONCE engine_dynamic = CRYPTO_ONCE_STATIC_INIT;
 227 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_dynamic)
 228 {
 229 # ifdef OPENSSL_INIT_DEBUG
 230     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_dynamic: "
 231                     "engine_load_dynamic_int()\n");
 232 # endif
 233     engine_load_dynamic_int();
 234     return 1;
 235 }
 236 # ifndef OPENSSL_NO_STATIC_ENGINE
 237 #  if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_PADLOCK)
 238 static CRYPTO_ONCE engine_padlock = CRYPTO_ONCE_STATIC_INIT;
 239 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_padlock)
 240 {
 241 #   ifdef OPENSSL_INIT_DEBUG
 242     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_padlock: "
 243                     "engine_load_padlock_int()\n");
 244 #   endif
 245     engine_load_padlock_int();
 246     return 1;
 247 }
 248 #  endif
 249 #  if defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_NO_CAPIENG)
 250 static CRYPTO_ONCE engine_capi = CRYPTO_ONCE_STATIC_INIT;
 251 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_capi)
 252 {
 253 #   ifdef OPENSSL_INIT_DEBUG
 254     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_capi: "
 255                     "engine_load_capi_int()\n");
 256 #   endif
 257     engine_load_capi_int();
 258     return 1;
 259 }
 260 #  endif
 261 #  if !defined(OPENSSL_NO_AFALGENG)
 262 static CRYPTO_ONCE engine_afalg = CRYPTO_ONCE_STATIC_INIT;
 263 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_afalg)
 264 {
 265 #   ifdef OPENSSL_INIT_DEBUG
 266     fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_afalg: "
 267                     "engine_load_afalg_int()\n");
 268 #   endif
 269     engine_load_afalg_int();
 270     return 1;
 271 }
 272 #  endif
 273 # endif
 274 #endif
 275
 276 #ifndef OPENSSL_NO_COMP
 277 static CRYPTO_ONCE zlib = CRYPTO_ONCE_STATIC_INIT;
 278
 279 static int zlib_inited = 0;
 280 DEFINE_RUN_ONCE_STATIC(ossl_init_zlib)
 281 {
 282     /* Do nothing - we need to know about this for the later cleanup */
 283     zlib_inited = 1;
 284     return 1;
 285 }
 286 #endif
 287
 288 static void ossl_init_thread_stop(struct thread_local_inits_st *locals)
 289 {
 290     /* Can't do much about this */
 291     if (locals == NULL)
 292         return;
 293
 294     if (locals->async) {
 295 #ifdef OPENSSL_INIT_DEBUG
 296         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_stop: "
 297                         "ASYNC_cleanup_thread()\n");
 298 #endif
 299         ASYNC_cleanup_thread();
 300     }
 301
 302     if (locals->err_state) {
 303 #ifdef OPENSSL_INIT_DEBUG
 304         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_stop: "
 305                         "err_delete_thread_state()\n");
 306 #endif
 307         err_delete_thread_state();
 308     }
 309
 310     OPENSSL_free(locals);
 311 }
 312
 313 void OPENSSL_thread_stop(void)
 314 {
 315     ossl_init_thread_stop(
 316         (struct thread_local_inits_st *)ossl_init_get_thread_local(0));
 317 }
 318
 319 int ossl_init_thread_start(uint64_t opts)
 320 {
 321     struct thread_local_inits_st *locals = ossl_init_get_thread_local(1);
 322
 323     if (locals == NULL)
 324         return 0;
 325
 326     if (opts & OPENSSL_INIT_THREAD_ASYNC) {
 327 #ifdef OPENSSL_INIT_DEBUG
 328         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_start: "
 329                         "marking thread for async\n");
 330 #endif
 331         locals->async = 1;
 332     }
 333
 334     if (opts & OPENSSL_INIT_THREAD_ERR_STATE) {
 335 #ifdef OPENSSL_INIT_DEBUG
 336         fprintf(stderr, "OPENSSL_INIT: ossl_init_thread_start: "
 337                         "marking thread for err_state\n");
 338 #endif
 339         locals->err_state = 1;
 340     }
 341
 342     return 1;
 343 }
 344
 345 void OPENSSL_cleanup(void)
 346 {
 347     OPENSSL_INIT_STOP *currhandler, *lasthandler;
 348
 349     /* If we've not been inited then no need to deinit */
 350     if (!base_inited)
 351         return;
 352
 353     /* Might be explicitly called and also by atexit */
 354     if (stopped)
 355         return;
 356     stopped = 1;
 357
 358     /*
 359      * Thread stop may not get automatically called by the thread library for
 360      * the very last thread in some situations, so call it directly.
 361      */
 362     ossl_init_thread_stop(ossl_init_get_thread_local(0));
 363
 364     currhandler = stop_handlers;
 365     while (currhandler != NULL) {
 366         currhandler->handler();
 367         lasthandler = currhandler;
 368         currhandler = currhandler->next;
 369         OPENSSL_free(lasthandler);
 370     }
 371     stop_handlers = NULL;
 372
 373     CRYPTO_THREAD_lock_free(init_lock);
 374
 375     /*
 376      * We assume we are single-threaded for this function, i.e. no race
 377      * conditions for the various "*_inited" vars below.
 378      */
 379
 380 #ifndef OPENSSL_NO_COMP
 381     if (zlib_inited) {
 382 #ifdef OPENSSL_INIT_DEBUG
 383         fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 384                         "comp_zlib_cleanup_int()\n");
 385 #endif
 386         comp_zlib_cleanup_int();
 387     }
 388 #endif
 389
 390     if (async_inited) {
 391 # ifdef OPENSSL_INIT_DEBUG
 392         fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 393                         "async_deinit()\n");
 394 # endif
 395         async_deinit();
 396     }
 397
 398     if (load_crypto_strings_inited) {
 399 #ifdef OPENSSL_INIT_DEBUG
 400         fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 401                         "err_free_strings_int()\n");
 402 #endif
 403         err_free_strings_int();
 404     }
 405
 406     CRYPTO_THREAD_cleanup_local(&threadstopkey);
 407
 408 #ifdef OPENSSL_INIT_DEBUG
 409     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 410                     "rand_cleanup_int()\n");
 411     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 412                     "conf_modules_free_int()\n");
 413 #ifndef OPENSSL_NO_ENGINE
 414     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 415                     "engine_cleanup_int()\n");
 416 #endif
 417     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 418                     "crypto_cleanup_all_ex_data_int()\n");
 419     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 420                     "bio_sock_cleanup_int()\n");
 421     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 422                     "bio_cleanup()\n");
 423     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 424                     "evp_cleanup_int()\n");
 425     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 426                     "obj_cleanup_int()\n");
 427     fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
 428                     "err_cleanup()\n");
 429 #endif
 430     /*
 431      * Note that cleanup order is important:
 432      * - rand_cleanup_int could call an ENGINE's RAND cleanup function so
 433      * must be called before engine_cleanup_int()
 434      * - ENGINEs use CRYPTO_EX_DATA and therefore, must be cleaned up
 435      * before the ex data handlers are wiped in CRYPTO_cleanup_all_ex_data().
 436      * - conf_modules_free_int() can end up in ENGINE code so must be called
 437      * before engine_cleanup_int()
 438      * - ENGINEs and additional EVP algorithms might use added OIDs names so
 439      * obj_cleanup_int() must be called last
 440      */
 441     rand_cleanup_int();
 442     conf_modules_free_int();
 443 #ifndef OPENSSL_NO_ENGINE
 444     engine_cleanup_int();
 445 #endif
 446     crypto_cleanup_all_ex_data_int();
 447     bio_cleanup();
 448     evp_cleanup_int();
 449     obj_cleanup_int();
 450     err_cleanup();
 451
 452     base_inited = 0;
 453 }
 454
 455 /*
 456  * If this function is called with a non NULL settings value then it must be
 457  * called prior to any threads making calls to any OpenSSL functions,
 458  * i.e. passing a non-null settings value is assumed to be single-threaded.
 459  */
 460 int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings)
 461 {
 462     static int stoperrset = 0;
 463
 464     if (stopped) {
 465         if (!stoperrset) {
 466             /*
 467              * We only ever set this once to avoid getting into an infinite
 468              * loop where the error system keeps trying to init and fails so
 469              * sets an error etc
 470              */
 471             stoperrset = 1;
 472             CRYPTOerr(CRYPTO_F_OPENSSL_INIT_CRYPTO, ERR_R_INIT_FAIL);
 473         }
 474         return 0;
 475     }
 476
 477     if (!RUN_ONCE(&base, ossl_init_base))
 478         return 0;
 479
 480     if ((opts & OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS)
 481             && !RUN_ONCE(&load_crypto_strings,
 482                          ossl_init_no_load_crypto_strings))
 483         return 0;
 484
 485     if ((opts & OPENSSL_INIT_LOAD_CRYPTO_STRINGS)
 486             && !RUN_ONCE(&load_crypto_strings, ossl_init_load_crypto_strings))
 487         return 0;
 488
 489     if ((opts & OPENSSL_INIT_NO_ADD_ALL_CIPHERS)
 490             && !RUN_ONCE(&add_all_ciphers, ossl_init_no_add_algs))
 491         return 0;
 492
 493     if ((opts & OPENSSL_INIT_ADD_ALL_CIPHERS)
 494             && !RUN_ONCE(&add_all_ciphers, ossl_init_add_all_ciphers))
 495         return 0;
 496
 497     if ((opts & OPENSSL_INIT_NO_ADD_ALL_DIGESTS)
 498             && !RUN_ONCE(&add_all_digests, ossl_init_no_add_algs))
 499         return 0;
 500
 501     if ((opts & OPENSSL_INIT_ADD_ALL_DIGESTS)
 502             && !RUN_ONCE(&add_all_digests, ossl_init_add_all_digests))
 503         return 0;
 504
 505     if ((opts & OPENSSL_INIT_NO_LOAD_CONFIG)
 506             && !RUN_ONCE(&config, ossl_init_no_config))
 507         return 0;
 508
 509     if (opts & OPENSSL_INIT_LOAD_CONFIG) {
 510         int ret;
 511         CRYPTO_THREAD_write_lock(init_lock);
 512         appname = (settings == NULL) ? NULL : settings->appname;
 513         ret = RUN_ONCE(&config, ossl_init_config);
 514         CRYPTO_THREAD_unlock(init_lock);
 515         if (!ret)
 516             return 0;
 517     }
 518
 519     if ((opts & OPENSSL_INIT_ASYNC)
 520             && !RUN_ONCE(&async, ossl_init_async))
 521         return 0;
 522
 523 #ifndef OPENSSL_NO_ENGINE
 524     if ((opts & OPENSSL_INIT_ENGINE_OPENSSL)
 525             && !RUN_ONCE(&engine_openssl, ossl_init_engine_openssl))
 526         return 0;
 527 # if !defined(OPENSSL_NO_HW) && \
 528     (defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) || defined(HAVE_CRYPTODEV))
 529     if ((opts & OPENSSL_INIT_ENGINE_CRYPTODEV)
 530             && !RUN_ONCE(&engine_cryptodev, ossl_init_engine_cryptodev))
 531         return 0;
 532 # endif
 533 # ifndef OPENSSL_NO_RDRAND
 534     if ((opts & OPENSSL_INIT_ENGINE_RDRAND)
 535             && !RUN_ONCE(&engine_rdrand, ossl_init_engine_rdrand))
 536         return 0;
 537 # endif
 538     if ((opts & OPENSSL_INIT_ENGINE_DYNAMIC)
 539             && !RUN_ONCE(&engine_dynamic, ossl_init_engine_dynamic))
 540         return 0;
 541 # ifndef OPENSSL_NO_STATIC_ENGINE
 542 #  if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_PADLOCK)
 543     if ((opts & OPENSSL_INIT_ENGINE_PADLOCK)
 544             && !RUN_ONCE(&engine_padlock, ossl_init_engine_padlock))
 545         return 0;
 546 #  endif
 547 #  if defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_NO_CAPIENG)
 548     if ((opts & OPENSSL_INIT_ENGINE_CAPI)
 549             && !RUN_ONCE(&engine_capi, ossl_init_engine_capi))
 550         return 0;
 551 #  endif
 552 #  if !defined(OPENSSL_NO_AFALGENG)
 553     if ((opts & OPENSSL_INIT_ENGINE_AFALG)
 554             && !RUN_ONCE(&engine_afalg, ossl_init_engine_afalg))
 555         return 0;
 556 #  endif
 557 # endif
 558     if (opts & (OPENSSL_INIT_ENGINE_ALL_BUILTIN
 559                 | OPENSSL_INIT_ENGINE_OPENSSL
 560                 | OPENSSL_INIT_ENGINE_AFALG)) {
 561         ENGINE_register_all_complete();
 562     }
 563 #endif
 564
 565 #ifndef OPENSSL_NO_COMP
 566     if ((opts & OPENSSL_INIT_ZLIB)
 567             && !RUN_ONCE(&zlib, ossl_init_zlib))
 568         return 0;
 569 #endif
 570
 571     return 1;
 572 }
 573
 574 int OPENSSL_atexit(void (*handler)(void))
 575 {
 576     OPENSSL_INIT_STOP *newhand;
 577
 578     newhand = OPENSSL_malloc(sizeof(*newhand));
 579     if (newhand == NULL)
 580         return 0;
 581
 582     newhand->handler = handler;
 583     newhand->next = stop_handlers;
 584     stop_handlers = newhand;
 585
 586     return 1;
 587 }