/src/openssl/crypto/initthread.c

Source (jump to first uncovered line)
/*
 * 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 "crypto/cryptlib.h"
#include "prov/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, *tmp;

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

    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);
    }
}

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 (gtr == NULL)
        return 0;
    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

Coverage Report

Created: 2024-08-27 12:12

Line	Count	Source (jump to first uncovered line)
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>
11		#include <openssl/core_numbers.h>
12		#include "crypto/cryptlib.h"
13		#include "prov/providercommon.h"
14		#include "internal/thread_once.h"
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.
24		*
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
31
32		typedef struct thread_event_handler_st THREAD_EVENT_HANDLER;
33		struct thread_event_handler_st {
34		const void *index;
35		void *arg;
36		OSSL_thread_stop_handler_fn handfn;
37		THREAD_EVENT_HANDLER *next;
38		};
39
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	1.92k	{
55	1.92k	glob_tevent_reg = OPENSSL_zalloc(sizeof(*glob_tevent_reg));
56	1.92k	if (glob_tevent_reg == NULL)
57	0	return 0;
58
59	1.92k	glob_tevent_reg->skhands = sk_THREAD_EVENT_HANDLER_PTR_new_null();
60	1.92k	glob_tevent_reg->lock = CRYPTO_THREAD_lock_new();
61	1.92k	if (glob_tevent_reg->skhands == NULL \|\| glob_tevent_reg->lock == NULL) {
62	0	sk_THREAD_EVENT_HANDLER_PTR_free(glob_tevent_reg->skhands);
63	0	CRYPTO_THREAD_lock_free(glob_tevent_reg->lock);
64	0	OPENSSL_free(glob_tevent_reg);
65	0	glob_tevent_reg = NULL;
66	0	return 0;
67	0	}
68
69	1.92k	return 1;
70	1.92k	}
71
72		static GLOBAL_TEVENT_REGISTER *get_global_tevent_register(void)
73	5.08k	{
74	5.08k	if (!RUN_ONCE(&tevent_register_runonce, create_global_tevent_register))
75	0	return NULL;
76	5.08k	return glob_tevent_reg;
77	5.08k	}
78		#endif
79
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
86		static void init_thread_stop(void arg, THREAD_EVENT_HANDLER *hands);
87
88		static THREAD_EVENT_HANDLER **
89		init_get_thread_local(CRYPTO_THREAD_LOCAL *local, int alloc, int keep)
90	5.08k	{
91	5.08k	THREAD_EVENT_HANDLER **hands = CRYPTO_THREAD_get_local(local);
92
93	5.08k	if (alloc) {
94	1.92k	if (hands == NULL) {
95
96	1.92k	if ((hands = OPENSSL_zalloc(sizeof(*hands))) == NULL)
97	0	return NULL;
98
99	1.92k	if (!CRYPTO_THREAD_set_local(local, hands)) {
100	0	OPENSSL_free(hands);
101	0	return NULL;
102	0	}
103
104	1.92k	#ifndef FIPS_MODE
105	1.92k	if (!init_thread_push_handlers(hands)) {
106	0	CRYPTO_THREAD_set_local(local, NULL);
107	0	OPENSSL_free(hands);
108	0	return NULL;
109	0	}
110	1.92k	#endif
111	1.92k	}
112	3.16k	} else if (!keep) {
113	1.58k	CRYPTO_THREAD_set_local(local, NULL);
114	1.58k	}
115
116	5.08k	return hands;
117	5.08k	}
118
119		#ifndef FIPS_MODE
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
130		* and it doesn't matter if they pick "impossible" or dereference real
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
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	1.92k	{
151	1.92k	int ret;
152	1.92k	GLOBAL_TEVENT_REGISTER *gtr;
153
154	1.92k	gtr = get_global_tevent_register();
155	1.92k	if (gtr == NULL)
156	0	return 0;
157
158	1.92k	CRYPTO_THREAD_write_lock(gtr->lock);
159	1.92k	ret = (sk_THREAD_EVENT_HANDLER_PTR_push(gtr->skhands, hands) != 0);
160	1.92k	CRYPTO_THREAD_unlock(gtr->lock);
161
162	1.92k	return ret;
163	1.92k	}
164
165		static void init_thread_remove_handlers(THREAD_EVENT_HANDLER **handsin)
166	1.58k	{
167	1.58k	GLOBAL_TEVENT_REGISTER *gtr;
168	1.58k	int i;
169
170	1.58k	gtr = get_global_tevent_register();
171	1.58k	if (gtr == NULL)
172	0	return;
173	1.58k	CRYPTO_THREAD_write_lock(gtr->lock);
174	1.58k	for (i = 0; i < sk_THREAD_EVENT_HANDLER_PTR_num(gtr->skhands); i++) {
175	1.58k	THREAD_EVENT_HANDLER **hands
176	1.58k	= sk_THREAD_EVENT_HANDLER_PTR_value(gtr->skhands, i);
177
178	1.58k	if (hands == handsin) {
179	1.58k	hands = sk_THREAD_EVENT_HANDLER_PTR_delete(gtr->skhands, i);
180	1.58k	CRYPTO_THREAD_unlock(gtr->lock);
181	1.58k	return;
182	1.58k	}
183	1.58k	}
184	0	CRYPTO_THREAD_unlock(gtr->lock);
185	0	return;
186	1.58k	}
187
188		static void init_thread_destructor(void *hands)
189	0	{
190	0	init_thread_stop(NULL, (THREAD_EVENT_HANDLER **)hands);
191	0	init_thread_remove_handlers(hands);
192	0	OPENSSL_free(hands);
193	0	}
194
195		int ossl_init_thread(void)
196	1.92k	{
197	1.92k	if (!CRYPTO_THREAD_init_local(&destructor_key.value,
198	1.92k	init_thread_destructor))
199	0	return 0;
200
201	1.92k	return 1;
202	1.92k	}
203
204		void ossl_cleanup_thread(void)
205	1.58k	{
206	1.58k	init_thread_deregister(NULL, 1);
207	1.58k	CRYPTO_THREAD_cleanup_local(&destructor_key.value);
208	1.58k	destructor_key.sane = -1;
209	1.58k	}
210
211		void OPENSSL_thread_stop_ex(OPENSSL_CTX *ctx)
212	0	{
213	0	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	0	ossl_ctx_thread_stop(ctx);
220	0	}
221
222		void OPENSSL_thread_stop(void)
223	1.58k	{
224	1.58k	if (destructor_key.sane != -1) {
225	1.58k	THREAD_EVENT_HANDLER **hands
226	1.58k	= init_get_thread_local(&destructor_key.value, 0, 0);
227	1.58k	init_thread_stop(NULL, hands);
228
229	1.58k	init_thread_remove_handlers(hands);
230	1.58k	OPENSSL_free(hands);
231	1.58k	}
232	1.58k	}
233
234		void ossl_ctx_thread_stop(void *arg)
235	1.58k	{
236	1.58k	if (destructor_key.sane != -1) {
237	1.58k	THREAD_EVENT_HANDLER **hands
238	1.58k	= init_get_thread_local(&destructor_key.value, 0, 1);
239	1.58k	init_thread_stop(arg, hands);
240	1.58k	}
241	1.58k	}
242
243		#else
244
245		static void thread_event_ossl_ctx_new(OPENSSL_CTX libctx)
246		{
247		THREAD_EVENT_HANDLER **hands = NULL;
248		CRYPTO_THREAD_LOCAL tlocal = OPENSSL_zalloc(sizeof(tlocal));
249
250		if (tlocal == NULL)
251		return NULL;
252
253		if (!CRYPTO_THREAD_init_local(tlocal, NULL)) {
254		goto err;
255		}
256
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
271		static void thread_event_ossl_ctx_free(void *tlocal)
272		{
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
281		void ossl_ctx_thread_stop(void *arg)
282		{
283		THREAD_EVENT_HANDLER **hands;
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);
288
289		if (local == NULL)
290		return;
291		hands = init_get_thread_local(local, 0, 0);
292		init_thread_stop(arg, hands);
293		OPENSSL_free(hands);
294		}
295		#endif /* FIPS_MODE */
296
297
298		static void init_thread_stop(void arg, THREAD_EVENT_HANDLER *hands)
299	3.16k	{
300	3.16k	THREAD_EVENT_HANDLER curr, prev = NULL, *tmp;
301
302		/* Can't do much about this */
303	3.16k	if (hands == NULL)
304	1.58k	return;
305
306	1.58k	curr = *hands;
307	3.16k	while (curr != NULL) {
308	1.58k	if (arg != NULL && curr->arg != arg) {
309	0	prev = curr;
310	0	curr = curr->next;
311	0	continue;
312	0	}
313	1.58k	curr->handfn(curr->arg);
314	1.58k	if (prev == NULL)
315	1.58k	*hands = curr->next;
316	0	else
317	0	prev->next = curr->next;
318
319	1.58k	tmp = curr;
320	1.58k	curr = curr->next;
321
322	1.58k	OPENSSL_free(tmp);
323	1.58k	}
324	1.58k	}
325
326		int ossl_init_thread_start(const void index, void arg,
327		OSSL_thread_stop_handler_fn handfn)
328	1.92k	{
329	1.92k	THREAD_EVENT_HANDLER **hands;
330	1.92k	THREAD_EVENT_HANDLER *hand;
331		#ifdef FIPS_MODE
332		OPENSSL_CTX *ctx = arg;
333
334		/*
335		* In FIPS mode the list of THREAD_EVENT_HANDLERs is unique per combination
336		* of OPENSSL_CTX and thread. This is because in FIPS mode each OPENSSL_CTX
337		* gets informed about thread stop events individually.
338		*/
339		CRYPTO_THREAD_LOCAL *local
340		= openssl_ctx_get_data(ctx, OPENSSL_CTX_THREAD_EVENT_HANDLER_INDEX,
341		&thread_event_ossl_ctx_method);
342		#else
343		/*
344		* Outside of FIPS mode the list of THREAD_EVENT_HANDLERs is unique per
345		* thread, but may hold multiple OPENSSL_CTXs. We only get told about
346		* thread stop events globally, so we have to ensure all affected
347		* OPENSSL_CTXs are informed.
348		*/
349	1.92k	CRYPTO_THREAD_LOCAL *local = &destructor_key.value;
350	1.92k	#endif
351
352	1.92k	hands = init_get_thread_local(local, 1, 0);
353	1.92k	if (hands == NULL)
354	0	return 0;
355
356		#ifdef FIPS_MODE
357		if (*hands == NULL) {
358		/*
359		* We've not yet registered any handlers for this thread. We need to get
360		* libcrypto to tell us about later thread stop events. c_thread_start
361		* is a callback to libcrypto defined in fipsprov.c
362		*/
363		if (!c_thread_start(FIPS_get_provider(ctx), ossl_ctx_thread_stop))
364		return 0;
365		}
366		#endif
367
368	1.92k	hand = OPENSSL_malloc(sizeof(*hand));
369	1.92k	if (hand == NULL)
370	0	return 0;
371
372	1.92k	hand->handfn = handfn;
373	1.92k	hand->arg = arg;
374	1.92k	hand->index = index;
375	1.92k	hand->next = *hands;
376	1.92k	*hands = hand;
377
378	1.92k	return 1;
379	1.92k	}
380
381		#ifndef FIPS_MODE
382		static int init_thread_deregister(void *index, int all)
383	1.58k	{
384	1.58k	GLOBAL_TEVENT_REGISTER *gtr;
385	1.58k	int i;
386
387	1.58k	gtr = get_global_tevent_register();
388	1.58k	if (gtr == NULL)
389	0	return 0;
390	1.58k	if (!all)
391	0	CRYPTO_THREAD_write_lock(gtr->lock);
392	1.58k	for (i = 0; i < sk_THREAD_EVENT_HANDLER_PTR_num(gtr->skhands); i++) {
393	0	THREAD_EVENT_HANDLER **hands
394	0	= sk_THREAD_EVENT_HANDLER_PTR_value(gtr->skhands, i);
395	0	THREAD_EVENT_HANDLER curr = hands, prev = NULL, tmp;
396
397	0	if (hands == NULL) {
398	0	if (!all)
399	0	CRYPTO_THREAD_unlock(gtr->lock);
400	0	return 0;
401	0	}
402	0	while (curr != NULL) {
403	0	if (all \|\| curr->index == index) {
404	0	if (prev != NULL)
405	0	prev->next = curr->next;
406	0	else
407	0	*hands = curr->next;
408	0	tmp = curr;
409	0	curr = curr->next;
410	0	OPENSSL_free(tmp);
411	0	continue;
412	0	}
413	0	prev = curr;
414	0	curr = curr->next;
415	0	}
416	0	if (all)
417	0	OPENSSL_free(hands);
418	0	}
419	1.58k	if (all) {
420	1.58k	CRYPTO_THREAD_lock_free(gtr->lock);
421	1.58k	sk_THREAD_EVENT_HANDLER_PTR_free(gtr->skhands);
422	1.58k	OPENSSL_free(gtr);
423	1.58k	} else {
424	0	CRYPTO_THREAD_unlock(gtr->lock);
425	0	}
426	1.58k	return 1;
427	1.58k	}
428
429		int ossl_init_thread_deregister(void *index)
430	0	{
431	0	return init_thread_deregister(index, 0);
432	0	}
433		#endif