/src/openssl/crypto/initthread.c

Source (jump to first uncovered line)
/*
 * Copyright 2019-2023 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_dispatch.h>
#include "crypto/cryptlib.h"
#include "prov/providercommon.h"
#include "internal/thread_once.h"
#include "crypto/context.h"

#ifdef FIPS_MODULE
#include "prov/provider_ctx.h"

/*
 * 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_provider_init).
 */
extern OSSL_FUNC_core_thread_start_fn *c_thread_start;
#endif

typedef struct thread_event_handler_st THREAD_EVENT_HANDLER;
struct thread_event_handler_st {
#ifndef FIPS_MODULE
    const void *index;
#endif
    void *arg;
    OSSL_thread_stop_handler_fn handfn;
    THREAD_EVENT_HANDLER *next;
};

#ifndef FIPS_MODULE
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_MODULE
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_MODULE
            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_MODULE
/*
 * 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;

    if (!CRYPTO_THREAD_write_lock(gtr->lock))
        return 0;
    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;
    if (!CRYPTO_THREAD_write_lock(gtr->lock))
        return;
    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) {
            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(OSSL_LIB_CTX *ctx)
{
    ctx = ossl_lib_ctx_get_concrete(ctx);
    /*
     * It would be nice if we could figure out a way to do this on all threads
     * that have used the OSSL_LIB_CTX when the context 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(OSSL_LIB_CTX *ctx)
{
    if (destructor_key.sane != -1) {
        THREAD_EVENT_HANDLER **hands
            = init_get_thread_local(&destructor_key.value, 0, 1);
        init_thread_stop(ctx, hands);
    }
}

#else

static void ossl_arg_thread_stop(void *arg);

/* Register the current thread so that we are informed if it gets stopped */
int ossl_thread_register_fips(OSSL_LIB_CTX *libctx)
{
    return c_thread_start(FIPS_get_core_handle(libctx), ossl_arg_thread_stop,
                          libctx);
}

void *ossl_thread_event_ctx_new(OSSL_LIB_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;

    /*
     * We should ideally call ossl_thread_register_fips() here. This function
     * is called during the startup of the FIPS provider and we need to ensure
     * that the main thread is registered to receive thread callbacks in order
     * to free |hands| that we allocated above. However we are too early in
     * the FIPS provider initialisation that FIPS_get_core_handle() doesn't work
     * yet. So we defer this to the main provider OSSL_provider_init_int()
     * function.
     */

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

void ossl_thread_event_ctx_free(void *tlocal)
{
    OPENSSL_free(tlocal);
}

static void ossl_arg_thread_stop(void *arg)
{
    ossl_ctx_thread_stop((OSSL_LIB_CTX *)arg);
}

void ossl_ctx_thread_stop(OSSL_LIB_CTX *ctx)
{
    THREAD_EVENT_HANDLER **hands;
    CRYPTO_THREAD_LOCAL *local
        = ossl_lib_ctx_get_data(ctx, OSSL_LIB_CTX_THREAD_EVENT_HANDLER_INDEX);

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


static void init_thread_stop(void *arg, THREAD_EVENT_HANDLER **hands)
{
    THREAD_EVENT_HANDLER *curr, *prev = NULL, *tmp;
#ifndef FIPS_MODULE
    GLOBAL_TEVENT_REGISTER *gtr;
#endif

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

#ifndef FIPS_MODULE
    gtr = get_global_tevent_register();
    if (gtr == NULL)
        return;

    if (!CRYPTO_THREAD_write_lock(gtr->lock))
        return;
#endif

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

        tmp = curr;
        curr = curr->next;

        OPENSSL_free(tmp);
    }
#ifndef FIPS_MODULE
    CRYPTO_THREAD_unlock(gtr->lock);
#endif
}

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_MODULE
    OSSL_LIB_CTX *ctx = arg;

    /*
     * In FIPS mode the list of THREAD_EVENT_HANDLERs is unique per combination
     * of OSSL_LIB_CTX and thread. This is because in FIPS mode each
     * OSSL_LIB_CTX gets informed about thread stop events individually.
     */
    CRYPTO_THREAD_LOCAL *local
        = ossl_lib_ctx_get_data(ctx, OSSL_LIB_CTX_THREAD_EVENT_HANDLER_INDEX);
#else
    /*
     * Outside of FIPS mode the list of THREAD_EVENT_HANDLERs is unique per
     * thread, but may hold multiple OSSL_LIB_CTXs. We only get told about
     * thread stop events globally, so we have to ensure all affected
     * OSSL_LIB_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_MODULE
    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 (!ossl_thread_register_fips(ctx))
            return 0;
    }
#endif

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

    hand->handfn = handfn;
    hand->arg = arg;
#ifndef FIPS_MODULE
    hand->index = index;
#endif
    hand->next = *hands;
    *hands = hand;

    return 1;
}

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

    gtr = get_global_tevent_register();
    if (gtr == NULL)
        return 0;
    if (!all) {
        if (!CRYPTO_THREAD_write_lock(gtr->lock))
            return 0;
    } else {
        glob_tevent_reg = NULL;
    }
    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 = NULL, *prev = NULL, *tmp;

        if (hands == NULL) {
            if (!all)
                CRYPTO_THREAD_unlock(gtr->lock);
            return 0;
        }
        curr = *hands;
        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

Coverage Report

Created: 2024-07-27 06:39

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