[thirdparty/openssl.git] / crypto / initthread.c

/*
 * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <openssl/crypto.h>
#include <openssl/core_numbers.h>
#include "internal/cryptlib_int.h"
#include "internal/providercommon.h"
#include "internal/thread_once.h"

#ifdef FIPS_MODE
/*
 * Thread aware code may want to be told about thread stop events. We register
 * to hear about those thread stop events when we see a new thread has started.
 * We call the ossl_init_thread_start function to do that. In the FIPS provider
 * we have our own copy of ossl_init_thread_start, which cascades notifications
 * about threads stopping from libcrypto to all the code in the FIPS provider
 * that needs to know about it.
 *
 * The FIPS provider tells libcrypto about which threads it is interested in
 * by calling "c_thread_start" which is a function pointer created during
 * provider initialisation (i.e. OSSL_init_provider).
 */
extern OSSL_core_thread_start_fn *c_thread_start;
#endif

typedef struct thread_event_handler_st THREAD_EVENT_HANDLER;
struct thread_event_handler_st {
    const void *index;
    void *arg;
    OSSL_thread_stop_handler_fn handfn;
    THREAD_EVENT_HANDLER *next;
};

#ifndef FIPS_MODE
DEFINE_SPECIAL_STACK_OF(THREAD_EVENT_HANDLER_PTR, THREAD_EVENT_HANDLER *)

typedef struct global_tevent_register_st GLOBAL_TEVENT_REGISTER;
struct global_tevent_register_st {
    STACK_OF(THREAD_EVENT_HANDLER_PTR) *skhands;
    CRYPTO_RWLOCK *lock;
};

static GLOBAL_TEVENT_REGISTER *glob_tevent_reg = NULL;

static CRYPTO_ONCE tevent_register_runonce = CRYPTO_ONCE_STATIC_INIT;

DEFINE_RUN_ONCE_STATIC(create_global_tevent_register)
{
    glob_tevent_reg = OPENSSL_zalloc(sizeof(*glob_tevent_reg));
    if (glob_tevent_reg == NULL)
        return 0;

    glob_tevent_reg->skhands = sk_THREAD_EVENT_HANDLER_PTR_new_null();
    glob_tevent_reg->lock = CRYPTO_THREAD_lock_new();
    if (glob_tevent_reg->skhands == NULL || glob_tevent_reg->lock == NULL) {
        sk_THREAD_EVENT_HANDLER_PTR_free(glob_tevent_reg->skhands);
        CRYPTO_THREAD_lock_free(glob_tevent_reg->lock);
        OPENSSL_free(glob_tevent_reg);
        glob_tevent_reg = NULL;
        return 0;
    }

    return 1;
}

static GLOBAL_TEVENT_REGISTER *get_global_tevent_register(void)
{
    if (!RUN_ONCE(&tevent_register_runonce, create_global_tevent_register))
        return NULL;
    return glob_tevent_reg;
}
#endif

#ifndef FIPS_MODE
static int  init_thread_push_handlers(THREAD_EVENT_HANDLER **hands);
static void init_thread_remove_handlers(THREAD_EVENT_HANDLER **handsin);
static void init_thread_destructor(void *hands);
static int  init_thread_deregister(void *arg, int all);
#endif
static void init_thread_stop(void *arg, THREAD_EVENT_HANDLER **hands);

static THREAD_EVENT_HANDLER **
init_get_thread_local(CRYPTO_THREAD_LOCAL *local, int alloc, int keep)
{
    THREAD_EVENT_HANDLER **hands = CRYPTO_THREAD_get_local(local);

    if (alloc) {
        if (hands == NULL) {

            if ((hands = OPENSSL_zalloc(sizeof(*hands))) == NULL)
                return NULL;

            if (!CRYPTO_THREAD_set_local(local, hands)) {
                OPENSSL_free(hands);
                return NULL;
            }

#ifndef FIPS_MODE
            if (!init_thread_push_handlers(hands)) {
                CRYPTO_THREAD_set_local(local, NULL);
                OPENSSL_free(hands);
                return NULL;
            }
#endif
        }
    } else if (!keep) {
        CRYPTO_THREAD_set_local(local, NULL);
    }

    return hands;
}

#ifndef FIPS_MODE
/*
 * Since per-thread-specific-data destructors are not universally
 * available, i.e. not on Windows, only below CRYPTO_THREAD_LOCAL key
 * is assumed to have destructor associated. And then an effort is made
 * to call this single destructor on non-pthread platform[s].
 *
 * Initial value is "impossible". It is used as guard value to shortcut
 * destructor for threads terminating before libcrypto is initialized or
 * after it's de-initialized. Access to the key doesn't have to be
 * serialized for the said threads, because they didn't use libcrypto
 * and it doesn't matter if they pick "impossible" or dereference real
 * key value and pull NULL past initialization in the first thread that
 * intends to use libcrypto.
 */
static union {
    long sane;
    CRYPTO_THREAD_LOCAL value;
} destructor_key = { -1 };

/*
 * The thread event handler list is a thread specific linked list
 * of callback functions which are invoked in list order by the
 * current thread in case of certain events. (Currently, there is
 * only one type of event, the 'thread stop' event.)
 *
 * We also keep a global reference to that linked list, so that we
 * can deregister handlers if necessary before all the threads are
 * stopped.
 */
static int init_thread_push_handlers(THREAD_EVENT_HANDLER **hands)
{
    int ret;
    GLOBAL_TEVENT_REGISTER *gtr;

    gtr = get_global_tevent_register();
    if (gtr == NULL)
        return 0;

    CRYPTO_THREAD_write_lock(gtr->lock);
    ret = (sk_THREAD_EVENT_HANDLER_PTR_push(gtr->skhands, hands) != 0);
    CRYPTO_THREAD_unlock(gtr->lock);

    return ret;
}

static void init_thread_remove_handlers(THREAD_EVENT_HANDLER **handsin)
{
    GLOBAL_TEVENT_REGISTER *gtr;
    int i;

    gtr = get_global_tevent_register();
    if (gtr == NULL)
        return;
    CRYPTO_THREAD_write_lock(gtr->lock);
    for (i = 0; i < sk_THREAD_EVENT_HANDLER_PTR_num(gtr->skhands); i++) {
        THREAD_EVENT_HANDLER **hands
            = sk_THREAD_EVENT_HANDLER_PTR_value(gtr->skhands, i);

        if (hands == handsin) {
            hands = sk_THREAD_EVENT_HANDLER_PTR_delete(gtr->skhands, i);
            CRYPTO_THREAD_unlock(gtr->lock);
            return;
        }
    }
    CRYPTO_THREAD_unlock(gtr->lock);
    return;
}

static void init_thread_destructor(void *hands)
{
    init_thread_stop(NULL, (THREAD_EVENT_HANDLER **)hands);
    init_thread_remove_handlers(hands);
    OPENSSL_free(hands);
}

int ossl_init_thread(void)
{
    if (!CRYPTO_THREAD_init_local(&destructor_key.value,
                                  init_thread_destructor))
        return 0;

    return 1;
}

void ossl_cleanup_thread(void)
{
    init_thread_deregister(NULL, 1);
    CRYPTO_THREAD_cleanup_local(&destructor_key.value);
    destructor_key.sane = -1;
}

void OPENSSL_thread_stop_ex(OPENSSL_CTX *ctx)
{
    ctx = openssl_ctx_get_concrete(ctx);
    /*
     * TODO(3.0). It would be nice if we could figure out a way to do this on
     * all threads that have used the OPENSSL_CTX when the OPENSSL_CTX is freed.
     * This is currently not possible due to the use of thread local variables.
     */
    ossl_ctx_thread_stop(ctx);
}

void OPENSSL_thread_stop(void)
{
    if (destructor_key.sane != -1) {
        THREAD_EVENT_HANDLER **hands
            = init_get_thread_local(&destructor_key.value, 0, 0);
        init_thread_stop(NULL, hands);

        init_thread_remove_handlers(hands);
        OPENSSL_free(hands);
    }
}

void ossl_ctx_thread_stop(void *arg)
{
    if (destructor_key.sane != -1) {
        THREAD_EVENT_HANDLER **hands
            = init_get_thread_local(&destructor_key.value, 0, 1);
        init_thread_stop(arg, hands);
    }
}

#else

static void *thread_event_ossl_ctx_new(OPENSSL_CTX *libctx)
{
    THREAD_EVENT_HANDLER **hands = NULL;
    CRYPTO_THREAD_LOCAL *tlocal = OPENSSL_zalloc(sizeof(*tlocal));

    if (tlocal == NULL)
        return NULL;

    if (!CRYPTO_THREAD_init_local(tlocal,  NULL)) {
        goto err;
    }

    hands = OPENSSL_zalloc(sizeof(*hands));
    if (hands == NULL)
        goto err;

    if (!CRYPTO_THREAD_set_local(tlocal, hands))
        goto err;

    return tlocal;
 err:
    OPENSSL_free(hands);
    OPENSSL_free(tlocal);
    return NULL;
}

static void thread_event_ossl_ctx_free(void *tlocal)
{
    OPENSSL_free(tlocal);
}

static const OPENSSL_CTX_METHOD thread_event_ossl_ctx_method = {
    thread_event_ossl_ctx_new,
    thread_event_ossl_ctx_free,
};

void ossl_ctx_thread_stop(void *arg)
{
    THREAD_EVENT_HANDLER **hands;
    OPENSSL_CTX *ctx = arg;
    CRYPTO_THREAD_LOCAL *local
        = openssl_ctx_get_data(ctx, OPENSSL_CTX_THREAD_EVENT_HANDLER_INDEX,
                               &thread_event_ossl_ctx_method);

    if (local == NULL)
        return;
    hands = init_get_thread_local(local, 0, 0);
    init_thread_stop(arg, hands);
    OPENSSL_free(hands);
}
#endif /* FIPS_MODE */


static void init_thread_stop(void *arg, THREAD_EVENT_HANDLER **hands)
{
    THREAD_EVENT_HANDLER *curr, *prev = NULL;

    /* Can't do much about this */
    if (hands == NULL)
        return;

    curr = *hands;
    while (curr != NULL) {
        if (arg != NULL && curr->arg != arg) {
            curr = curr->next;
            continue;
        }
        curr->handfn(curr->arg);
        prev = curr;
        curr = curr->next;
        if (prev == *hands)
            *hands = curr;
        OPENSSL_free(prev);
    }
}

int ossl_init_thread_start(const void *index, void *arg,
                           OSSL_thread_stop_handler_fn handfn)
{
    THREAD_EVENT_HANDLER **hands;
    THREAD_EVENT_HANDLER *hand;
#ifdef FIPS_MODE
    OPENSSL_CTX *ctx = arg;

    /*
     * In FIPS mode the list of THREAD_EVENT_HANDLERs is unique per combination
     * of OPENSSL_CTX and thread. This is because in FIPS mode each OPENSSL_CTX
     * gets informed about thread stop events individually.
     */
    CRYPTO_THREAD_LOCAL *local
        = openssl_ctx_get_data(ctx, OPENSSL_CTX_THREAD_EVENT_HANDLER_INDEX,
                               &thread_event_ossl_ctx_method);
#else
    /*
     * Outside of FIPS mode the list of THREAD_EVENT_HANDLERs is unique per
     * thread, but may hold multiple OPENSSL_CTXs. We only get told about
     * thread stop events globally, so we have to ensure all affected
     * OPENSSL_CTXs are informed.
     */
    CRYPTO_THREAD_LOCAL *local = &destructor_key.value;
#endif

    hands = init_get_thread_local(local, 1, 0);
    if (hands == NULL)
        return 0;

#ifdef FIPS_MODE
    if (*hands == NULL) {
        /*
         * We've not yet registered any handlers for this thread. We need to get
         * libcrypto to tell us about later thread stop events. c_thread_start
         * is a callback to libcrypto defined in fipsprov.c
         */
        if (!c_thread_start(FIPS_get_provider(ctx), ossl_ctx_thread_stop))
            return 0;
    }
#endif

    hand = OPENSSL_malloc(sizeof(*hand));
    if (hand == NULL)
        return 0;

    hand->handfn = handfn;
    hand->arg = arg;
    hand->index = index;
    hand->next = *hands;
    *hands = hand;

    return 1;
}

#ifndef FIPS_MODE
static int init_thread_deregister(void *index, int all)
{
    GLOBAL_TEVENT_REGISTER *gtr;
    int i;

    gtr = get_global_tevent_register();
    if (!all)
        CRYPTO_THREAD_write_lock(gtr->lock);
    for (i = 0; i < sk_THREAD_EVENT_HANDLER_PTR_num(gtr->skhands); i++) {
        THREAD_EVENT_HANDLER **hands
            = sk_THREAD_EVENT_HANDLER_PTR_value(gtr->skhands, i);
        THREAD_EVENT_HANDLER *curr = *hands, *prev = NULL, *tmp;

        if (hands == NULL) {
            if (!all)
                CRYPTO_THREAD_unlock(gtr->lock);
            return 0;
        }
        while (curr != NULL) {
            if (all || curr->index == index) {
                if (prev != NULL)
                    prev->next = curr->next;
                else
                    *hands = curr->next;
                tmp = curr;
                curr = curr->next;
                OPENSSL_free(tmp);
                continue;
            }
            prev = curr;
            curr = curr->next;
        }
        if (all)
            OPENSSL_free(hands);
    }
    if (all) {
        CRYPTO_THREAD_lock_free(gtr->lock);
        sk_THREAD_EVENT_HANDLER_PTR_free(gtr->skhands);
        OPENSSL_free(gtr);
    } else {
        CRYPTO_THREAD_unlock(gtr->lock);
    }
    return 1;
}

int ossl_init_thread_deregister(void *index)
{
    return init_thread_deregister(index, 0);
}
#endif
Commit	Line	Data
72592b86 MC	1	/*
	2	* Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
	3	*
	4	* Licensed under the Apache License 2.0 (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 <openssl/crypto.h>
da747958	11	#include <openssl/core_numbers.h>
72592b86	12	#include "internal/cryptlib_int.h"
da747958	13	#include "internal/providercommon.h"
6913f5fe	14	#include "internal/thread_once.h"
da747958 MC	15
	16	#ifdef FIPS_MODE
	17	/*
	18	* Thread aware code may want to be told about thread stop events. We register
	19	* to hear about those thread stop events when we see a new thread has started.
	20	* We call the ossl_init_thread_start function to do that. In the FIPS provider
	21	* we have our own copy of ossl_init_thread_start, which cascades notifications
	22	* about threads stopping from libcrypto to all the code in the FIPS provider
	23	* that needs to know about it.
4bd8b240	24	*
da747958 MC	25	* The FIPS provider tells libcrypto about which threads it is interested in
	26	* by calling "c_thread_start" which is a function pointer created during
	27	* provider initialisation (i.e. OSSL_init_provider).
	28	*/
	29	extern OSSL_core_thread_start_fn *c_thread_start;
	30	#endif
72592b86 MC	31
	32	typedef struct thread_event_handler_st THREAD_EVENT_HANDLER;
	33	struct thread_event_handler_st {
6913f5fe	34	const void *index;
da747958 MC	35	void *arg;
da747958 MC	36	OSSL_thread_stop_handler_fn handfn;
72592b86 MC	37	THREAD_EVENT_HANDLER *next;
	38	};
	39
6913f5fe MC	40	#ifndef FIPS_MODE
	41	DEFINE_SPECIAL_STACK_OF(THREAD_EVENT_HANDLER_PTR, THREAD_EVENT_HANDLER *)
	42
	43	typedef struct global_tevent_register_st GLOBAL_TEVENT_REGISTER;
	44	struct global_tevent_register_st {
	45	STACK_OF(THREAD_EVENT_HANDLER_PTR) *skhands;
	46	CRYPTO_RWLOCK *lock;
	47	};
	48
	49	static GLOBAL_TEVENT_REGISTER *glob_tevent_reg = NULL;
	50
	51	static CRYPTO_ONCE tevent_register_runonce = CRYPTO_ONCE_STATIC_INIT;
	52
	53	DEFINE_RUN_ONCE_STATIC(create_global_tevent_register)
	54	{
	55	glob_tevent_reg = OPENSSL_zalloc(sizeof(*glob_tevent_reg));
	56	if (glob_tevent_reg == NULL)
	57	return 0;
	58
	59	glob_tevent_reg->skhands = sk_THREAD_EVENT_HANDLER_PTR_new_null();
	60	glob_tevent_reg->lock = CRYPTO_THREAD_lock_new();
	61	if (glob_tevent_reg->skhands == NULL \|\| glob_tevent_reg->lock == NULL) {
	62	sk_THREAD_EVENT_HANDLER_PTR_free(glob_tevent_reg->skhands);
	63	CRYPTO_THREAD_lock_free(glob_tevent_reg->lock);
	64	OPENSSL_free(glob_tevent_reg);
	65	glob_tevent_reg = NULL;
	66	return 0;
	67	}
	68
	69	return 1;
	70	}
	71
	72	static GLOBAL_TEVENT_REGISTER *get_global_tevent_register(void)
	73	{
	74	if (!RUN_ONCE(&tevent_register_runonce, create_global_tevent_register))
	75	return NULL;
	76	return glob_tevent_reg;
	77	}
	78	#endif
	79
3b438ef9 DMSP	80	#ifndef FIPS_MODE
	81	static int init_thread_push_handlers(THREAD_EVENT_HANDLER **hands);
	82	static void init_thread_remove_handlers(THREAD_EVENT_HANDLER **handsin);
	83	static void init_thread_destructor(void *hands);
	84	static int init_thread_deregister(void *arg, int all);
	85	#endif
2be8c56a	86	static void init_thread_stop(void arg, THREAD_EVENT_HANDLER *hands);
da747958 MC	87
da747958 MC	88	static THREAD_EVENT_HANDLER **
2be8c56a	89	init_get_thread_local(CRYPTO_THREAD_LOCAL *local, int alloc, int keep)
da747958 MC	90	{
	91	THREAD_EVENT_HANDLER **hands = CRYPTO_THREAD_get_local(local);
	92
	93	if (alloc) {
6913f5fe	94	if (hands == NULL) {
6913f5fe	95
3b438ef9	96	if ((hands = OPENSSL_zalloc(sizeof(*hands))) == NULL)
6913f5fe	97	return NULL;
6913f5fe	98
3b438ef9	99	if (!CRYPTO_THREAD_set_local(local, hands)) {
6913f5fe MC	100	OPENSSL_free(hands);
	101	return NULL;
	102	}
3b438ef9 DMSP	103
	104	#ifndef FIPS_MODE
	105	if (!init_thread_push_handlers(hands)) {
	106	CRYPTO_THREAD_set_local(local, NULL);
6913f5fe	107	OPENSSL_free(hands);
6913f5fe MC	108	return NULL;
6913f5fe MC	109	}
6913f5fe	110	#endif
da747958 MC	111	}
	112	} else if (!keep) {
	113	CRYPTO_THREAD_set_local(local, NULL);
	114	}
	115
	116	return hands;
	117	}
e41faf57 MC	118
e41faf57 MC	119	#ifndef FIPS_MODE
72592b86 MC	120	/*
	121	* Since per-thread-specific-data destructors are not universally
	122	* available, i.e. not on Windows, only below CRYPTO_THREAD_LOCAL key
	123	* is assumed to have destructor associated. And then an effort is made
	124	* to call this single destructor on non-pthread platform[s].
	125	*
	126	* Initial value is "impossible". It is used as guard value to shortcut
	127	* destructor for threads terminating before libcrypto is initialized or
	128	* after it's de-initialized. Access to the key doesn't have to be
	129	* serialized for the said threads, because they didn't use libcrypto
c2969ff6	130	* and it doesn't matter if they pick "impossible" or dereference real
72592b86 MC	131	* key value and pull NULL past initialization in the first thread that
	132	* intends to use libcrypto.
	133	*/
	134	static union {
	135	long sane;
	136	CRYPTO_THREAD_LOCAL value;
	137	} destructor_key = { -1 };
	138
3b438ef9 DMSP	139	/*
	140	* The thread event handler list is a thread specific linked list
	141	* of callback functions which are invoked in list order by the
	142	* current thread in case of certain events. (Currently, there is
	143	* only one type of event, the 'thread stop' event.)
	144	*
	145	* We also keep a global reference to that linked list, so that we
	146	* can deregister handlers if necessary before all the threads are
	147	* stopped.
	148	*/
	149	static int init_thread_push_handlers(THREAD_EVENT_HANDLER **hands)
	150	{
	151	int ret;
	152	GLOBAL_TEVENT_REGISTER *gtr;
	153
	154	gtr = get_global_tevent_register();
	155	if (gtr == NULL)
	156	return 0;
	157
	158	CRYPTO_THREAD_write_lock(gtr->lock);
	159	ret = (sk_THREAD_EVENT_HANDLER_PTR_push(gtr->skhands, hands) != 0);
	160	CRYPTO_THREAD_unlock(gtr->lock);
	161
	162	return ret;
	163	}
	164
6913f5fe MC	165	static void init_thread_remove_handlers(THREAD_EVENT_HANDLER **handsin)
	166	{
	167	GLOBAL_TEVENT_REGISTER *gtr;
	168	int i;
	169
	170	gtr = get_global_tevent_register();
	171	if (gtr == NULL)
	172	return;
	173	CRYPTO_THREAD_write_lock(gtr->lock);
	174	for (i = 0; i < sk_THREAD_EVENT_HANDLER_PTR_num(gtr->skhands); i++) {
	175	THREAD_EVENT_HANDLER **hands
	176	= sk_THREAD_EVENT_HANDLER_PTR_value(gtr->skhands, i);
	177
	178	if (hands == handsin) {
	179	hands = sk_THREAD_EVENT_HANDLER_PTR_delete(gtr->skhands, i);
	180	CRYPTO_THREAD_unlock(gtr->lock);
	181	return;
	182	}
	183	}
	184	CRYPTO_THREAD_unlock(gtr->lock);
	185	return;
	186	}
	187
2be8c56a	188	static void init_thread_destructor(void *hands)
72592b86	189	{
2be8c56a	190	init_thread_stop(NULL, (THREAD_EVENT_HANDLER **)hands);
6913f5fe	191	init_thread_remove_handlers(hands);
da747958	192	OPENSSL_free(hands);
72592b86 MC	193	}
72592b86 MC	194
2be8c56a	195	int ossl_init_thread(void)
72592b86	196	{
72592b86	197	if (!CRYPTO_THREAD_init_local(&destructor_key.value,
2be8c56a	198	init_thread_destructor))
72592b86 MC	199	return 0;
	200
	201	return 1;
	202	}
	203
2be8c56a	204	void ossl_cleanup_thread(void)
72592b86	205	{
6913f5fe	206	init_thread_deregister(NULL, 1);
72592b86 MC	207	CRYPTO_THREAD_cleanup_local(&destructor_key.value);
	208	destructor_key.sane = -1;
	209	}
	210
52b18ce1 MC	211	void OPENSSL_thread_stop_ex(OPENSSL_CTX *ctx)
	212	{
	213	ctx = openssl_ctx_get_concrete(ctx);
	214	/*
	215	* TODO(3.0). It would be nice if we could figure out a way to do this on
	216	* all threads that have used the OPENSSL_CTX when the OPENSSL_CTX is freed.
	217	* This is currently not possible due to the use of thread local variables.
	218	*/
	219	ossl_ctx_thread_stop(ctx);
	220	}
	221
da747958	222	void OPENSSL_thread_stop(void)
72592b86	223	{
da747958 MC	224	if (destructor_key.sane != -1) {
da747958 MC	225	THREAD_EVENT_HANDLER **hands
2be8c56a MC	226	= init_get_thread_local(&destructor_key.value, 0, 0);
2be8c56a MC	227	init_thread_stop(NULL, hands);
6913f5fe MC	228
6913f5fe MC	229	init_thread_remove_handlers(hands);
da747958	230	OPENSSL_free(hands);
72592b86	231	}
72592b86 MC	232	}
72592b86 MC	233
da747958	234	void ossl_ctx_thread_stop(void *arg)
e41faf57	235	{
da747958 MC	236	if (destructor_key.sane != -1) {
da747958 MC	237	THREAD_EVENT_HANDLER **hands
2be8c56a MC	238	= init_get_thread_local(&destructor_key.value, 0, 1);
2be8c56a MC	239	init_thread_stop(arg, hands);
da747958	240	}
e41faf57	241	}
da747958	242
e41faf57	243	#else
da747958	244
e41faf57 MC	245	static void thread_event_ossl_ctx_new(OPENSSL_CTX libctx)
	246	{
	247	THREAD_EVENT_HANDLER **hands = NULL;
da747958	248	CRYPTO_THREAD_LOCAL tlocal = OPENSSL_zalloc(sizeof(tlocal));
e41faf57 MC	249
	250	if (tlocal == NULL)
	251	return NULL;
	252
da747958 MC	253	if (!CRYPTO_THREAD_init_local(tlocal, NULL)) {
	254	goto err;
	255	}
	256
e41faf57 MC	257	hands = OPENSSL_zalloc(sizeof(*hands));
	258	if (hands == NULL)
	259	goto err;
	260
	261	if (!CRYPTO_THREAD_set_local(tlocal, hands))
	262	goto err;
	263
	264	return tlocal;
	265	err:
	266	OPENSSL_free(hands);
	267	OPENSSL_free(tlocal);
	268	return NULL;
	269	}
	270
da747958	271	static void thread_event_ossl_ctx_free(void *tlocal)
e41faf57	272	{
e41faf57 MC	273	OPENSSL_free(tlocal);
	274	}
	275
	276	static const OPENSSL_CTX_METHOD thread_event_ossl_ctx_method = {
	277	thread_event_ossl_ctx_new,
	278	thread_event_ossl_ctx_free,
	279	};
	280
da747958	281	void ossl_ctx_thread_stop(void *arg)
e41faf57 MC	282	{
e41faf57 MC	283	THREAD_EVENT_HANDLER **hands;
da747958 MC	284	OPENSSL_CTX *ctx = arg;
	285	CRYPTO_THREAD_LOCAL *local
	286	= openssl_ctx_get_data(ctx, OPENSSL_CTX_THREAD_EVENT_HANDLER_INDEX,
	287	&thread_event_ossl_ctx_method);
e41faf57	288
da747958 MC	289	if (local == NULL)
da747958 MC	290	return;
2be8c56a MC	291	hands = init_get_thread_local(local, 0, 0);
2be8c56a MC	292	init_thread_stop(arg, hands);
da747958	293	OPENSSL_free(hands);
e41faf57 MC	294	}
	295	#endif /* FIPS_MODE */
	296
da747958	297
2be8c56a	298	static void init_thread_stop(void arg, THREAD_EVENT_HANDLER *hands)
72592b86 MC	299	{
	300	THREAD_EVENT_HANDLER curr, prev = NULL;
	301
	302	/* Can't do much about this */
	303	if (hands == NULL)
	304	return;
	305
	306	curr = *hands;
	307	while (curr != NULL) {
da747958 MC	308	if (arg != NULL && curr->arg != arg) {
	309	curr = curr->next;
	310	continue;
	311	}
	312	curr->handfn(curr->arg);
72592b86 MC	313	prev = curr;
72592b86 MC	314	curr = curr->next;
da747958 MC	315	if (prev == *hands)
da747958 MC	316	*hands = curr;
72592b86 MC	317	OPENSSL_free(prev);
72592b86 MC	318	}
72592b86 MC	319	}
72592b86 MC	320
6913f5fe MC	321	int ossl_init_thread_start(const void index, void arg,
6913f5fe MC	322	OSSL_thread_stop_handler_fn handfn)
72592b86 MC	323	{
	324	THREAD_EVENT_HANDLER **hands;
	325	THREAD_EVENT_HANDLER *hand;
e41faf57	326	#ifdef FIPS_MODE
da747958 MC	327	OPENSSL_CTX *ctx = arg;
da747958 MC	328
e41faf57 MC	329	/*
	330	* In FIPS mode the list of THREAD_EVENT_HANDLERs is unique per combination
	331	* of OPENSSL_CTX and thread. This is because in FIPS mode each OPENSSL_CTX
	332	* gets informed about thread stop events individually.
	333	*/
da747958 MC	334	CRYPTO_THREAD_LOCAL *local
	335	= openssl_ctx_get_data(ctx, OPENSSL_CTX_THREAD_EVENT_HANDLER_INDEX,
	336	&thread_event_ossl_ctx_method);
e41faf57 MC	337	#else
	338	/*
	339	* Outside of FIPS mode the list of THREAD_EVENT_HANDLERs is unique per
	340	* thread, but may hold multiple OPENSSL_CTXs. We only get told about
	341	* thread stop events globally, so we have to ensure all affected
	342	* OPENSSL_CTXs are informed.
	343	*/
da747958	344	CRYPTO_THREAD_LOCAL *local = &destructor_key.value;
e41faf57	345	#endif
72592b86	346
2be8c56a	347	hands = init_get_thread_local(local, 1, 0);
72592b86 MC	348	if (hands == NULL)
	349	return 0;
	350
da747958 MC	351	#ifdef FIPS_MODE
	352	if (*hands == NULL) {
	353	/*
	354	* We've not yet registered any handlers for this thread. We need to get
	355	* libcrypto to tell us about later thread stop events. c_thread_start
	356	* is a callback to libcrypto defined in fipsprov.c
	357	*/
	358	if (!c_thread_start(FIPS_get_provider(ctx), ossl_ctx_thread_stop))
	359	return 0;
	360	}
	361	#endif
	362
72592b86 MC	363	hand = OPENSSL_malloc(sizeof(*hand));
	364	if (hand == NULL)
	365	return 0;
	366
	367	hand->handfn = handfn;
da747958	368	hand->arg = arg;
6913f5fe	369	hand->index = index;
72592b86 MC	370	hand->next = *hands;
	371	*hands = hand;
	372
	373	return 1;
	374	}
6913f5fe MC	375
	376	#ifndef FIPS_MODE
	377	static int init_thread_deregister(void *index, int all)
	378	{
	379	GLOBAL_TEVENT_REGISTER *gtr;
	380	int i;
	381
	382	gtr = get_global_tevent_register();
	383	if (!all)
	384	CRYPTO_THREAD_write_lock(gtr->lock);
	385	for (i = 0; i < sk_THREAD_EVENT_HANDLER_PTR_num(gtr->skhands); i++) {
	386	THREAD_EVENT_HANDLER **hands
	387	= sk_THREAD_EVENT_HANDLER_PTR_value(gtr->skhands, i);
	388	THREAD_EVENT_HANDLER curr = hands, prev = NULL, tmp;
	389
	390	if (hands == NULL) {
	391	if (!all)
	392	CRYPTO_THREAD_unlock(gtr->lock);
	393	return 0;
	394	}
	395	while (curr != NULL) {
	396	if (all \|\| curr->index == index) {
	397	if (prev != NULL)
	398	prev->next = curr->next;
	399	else
	400	*hands = curr->next;
	401	tmp = curr;
	402	curr = curr->next;
	403	OPENSSL_free(tmp);
	404	continue;
	405	}
	406	prev = curr;
	407	curr = curr->next;
	408	}
	409	if (all)
	410	OPENSSL_free(hands);
	411	}
	412	if (all) {
	413	CRYPTO_THREAD_lock_free(gtr->lock);
	414	sk_THREAD_EVENT_HANDLER_PTR_free(gtr->skhands);
	415	OPENSSL_free(gtr);
	416	} else {
	417	CRYPTO_THREAD_unlock(gtr->lock);
	418	}
	419	return 1;
	420	}
	421
	422	int ossl_init_thread_deregister(void *index)
	423	{
	424	return init_thread_deregister(index, 0);
	425	}
	426	#endif