| /* Copyright (c) 2015, Google Inc. |
| * |
| * Permission to use, copy, modify, and/or distribute this software for any |
| * purpose with or without fee is hereby granted, provided that the above |
| * copyright notice and this permission notice appear in all copies. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY |
| * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
| * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
| * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ |
| |
| #include "internal.h" |
| |
| #if !defined(OPENSSL_WINDOWS) |
| |
| #include <pthread.h> |
| #include <string.h> |
| |
| #include <openssl/mem.h> |
| |
| |
| void CRYPTO_once(CRYPTO_once_t *once, void (*init)(void)) { |
| pthread_once(once, init); |
| } |
| |
| static pthread_mutex_t g_destructors_lock = PTHREAD_MUTEX_INITIALIZER; |
| static thread_local_destructor_t g_destructors[NUM_OPENSSL_THREAD_LOCALS]; |
| |
| static void thread_local_destructor(void *arg) { |
| if (arg == NULL) { |
| return; |
| } |
| |
| thread_local_destructor_t destructors[NUM_OPENSSL_THREAD_LOCALS]; |
| if (pthread_mutex_lock(&g_destructors_lock) != 0) { |
| return; |
| } |
| memcpy(destructors, g_destructors, sizeof(destructors)); |
| pthread_mutex_unlock(&g_destructors_lock); |
| |
| unsigned i; |
| void **pointers = arg; |
| for (i = 0; i < NUM_OPENSSL_THREAD_LOCALS; i++) { |
| if (destructors[i] != NULL) { |
| destructors[i](pointers[i]); |
| } |
| } |
| |
| OPENSSL_free(pointers); |
| } |
| |
| static pthread_once_t g_thread_local_init_once = PTHREAD_ONCE_INIT; |
| static pthread_key_t g_thread_local_key; |
| static int g_thread_local_failed = 0; |
| |
| static void thread_local_init(void) { |
| g_thread_local_failed = |
| pthread_key_create(&g_thread_local_key, thread_local_destructor) != 0; |
| } |
| |
| void *CRYPTO_get_thread_local(thread_local_data_t index) { |
| CRYPTO_once(&g_thread_local_init_once, thread_local_init); |
| if (g_thread_local_failed) { |
| return NULL; |
| } |
| |
| void **pointers = pthread_getspecific(g_thread_local_key); |
| if (pointers == NULL) { |
| return NULL; |
| } |
| return pointers[index]; |
| } |
| |
| int CRYPTO_set_thread_local(thread_local_data_t index, void *value, |
| thread_local_destructor_t destructor) { |
| CRYPTO_once(&g_thread_local_init_once, thread_local_init); |
| if (g_thread_local_failed) { |
| destructor(value); |
| return 0; |
| } |
| |
| void **pointers = pthread_getspecific(g_thread_local_key); |
| if (pointers == NULL) { |
| pointers = OPENSSL_malloc(sizeof(void *) * NUM_OPENSSL_THREAD_LOCALS); |
| if (pointers == NULL) { |
| destructor(value); |
| return 0; |
| } |
| memset(pointers, 0, sizeof(void *) * NUM_OPENSSL_THREAD_LOCALS); |
| if (pthread_setspecific(g_thread_local_key, pointers) != 0) { |
| OPENSSL_free(pointers); |
| destructor(value); |
| return 0; |
| } |
| } |
| |
| if (pthread_mutex_lock(&g_destructors_lock) != 0) { |
| destructor(value); |
| return 0; |
| } |
| g_destructors[index] = destructor; |
| pthread_mutex_unlock(&g_destructors_lock); |
| |
| pointers[index] = value; |
| return 1; |
| } |
| |
| #endif /* !OPENSSL_WINDOWS */ |