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