Implement new multi-threading API (71a04cfc) · Commits · CYBER - Cyber Security / TS 103 523 MSP / TLMSP / TLMSP OpenSSL

crypto/Makefile.in

+2 −0

Original line number	Diff line number	Diff line
		@@ -34,9 +34,11 @@ LIB= $(TOP)/libcrypto.a
		SHARED_LIB= libcrypto$(SHLIB_EXT)
		LIBSRC= cryptlib.c mem.c mem_clr.c mem_dbg.c cversion.c ex_data.c cpt_err.c \
		ebcdic.c uid.c o_time.c o_str.c o_dir.c thr_id.c lock.c \
		threads_pthread.c threads_win.c threads_none.c \
		o_init.c o_fips.c mem_sec.c init.c
		LIBOBJ= cryptlib.o mem.o mem_dbg.o cversion.o ex_data.o cpt_err.o \
		ebcdic.o uid.o o_time.o o_str.o o_dir.o thr_id.o lock.o \
		threads_pthread.o threads_win.o threads_none.o \
		o_init.o o_fips.o mem_sec.o init.o $(CPUID_OBJ)

		SRC= $(LIBSRC)

crypto/build.info

+1 −0

Original line number	Diff line number	Diff line
		@@ -3,6 +3,7 @@ LIBS=../libcrypto
		SOURCE[../libcrypto]=\
		cryptlib.c mem.c mem_dbg.c cversion.c ex_data.c cpt_err.c \
		ebcdic.c uid.c o_time.c o_str.c o_dir.c thr_id.c lock.c \
		threads_pthread.c threads_win.c threads_none.c \
		o_init.c o_fips.c mem_sec.c init.c {- $target{cpuid_asm_src} -}
		EXTRA= ../ms/uplink-x86.pl ../ms/uplink.c ../ms/applink.c \
		x86cpuid.pl x86_64cpuid.pl ia64cpuid.S \

crypto/threads_none.c

0 → 100644

+165 −0

Original line number	Diff line number	Diff line
		/* ====================================================================
		* Copyright (c) 2016 The OpenSSL Project. All rights reserved.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions
		* are met:
		*
		* 1. Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		*
		* 2. Redistributions in binary form must reproduce the above copyright
		* notice, this list of conditions and the following disclaimer in
		* the documentation and/or other materials provided with the
		* distribution.
		*
		* 3. All advertising materials mentioning features or use of this
		* software must display the following acknowledgment:
		* "This product includes software developed by the OpenSSL Project
		* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
		*
		* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
		* endorse or promote products derived from this software without
		* prior written permission. For written permission, please contact
		* openssl-core@openssl.org.
		*
		* 5. Products derived from this software may not be called "OpenSSL"
		* nor may "OpenSSL" appear in their names without prior written
		* permission of the OpenSSL Project.
		*
		* 6. Redistributions of any form whatsoever must retain the following
		* acknowledgment:
		* "This product includes software developed by the OpenSSL Project
		* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
		*
		* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
		* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
		* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
		* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
		* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
		* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
		* OF THE POSSIBILITY OF SUCH DAMAGE.
		* ====================================================================
		*/

		#include <openssl/crypto.h>
		#include "internal/threads.h"

		#if !defined(OPENSSL_THREADS) \|\| defined(CRYPTO_TDEBUG)

		CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void)
		{
		CRYPTO_RWLOCK *lock = OPENSSL_zalloc(sizeof(unsigned int));
		if (lock == NULL)
		return NULL;

		(unsigned int )lock = 1;

		return lock;
		}

		int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock)
		{
		OPENSSL_assert((unsigned int )lock == 1);
		return 1;
		}

		int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock)
		{
		OPENSSL_assert((unsigned int )lock == 1);
		return 1;
		}

		int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock)
		{
		OPENSSL_assert((unsigned int )lock == 1);
		return 1;
		}

		void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock) {
		if (lock == NULL)
		return;

		(unsigned int )lock = 0;
		OPENSSL_free(lock);

		return;
		}

		int CRYPTO_THREAD_run_once(CRYPTO_ONCE once, void (init)(void))
		{
		if (*once != 0)
		return 1;

		init();
		*once = 1;

		return 1;
		}

		#define OPENSSL_CRYPTO_THREAD_LOCAL_KEY_MAX 256

		static void *thread_local_storage[OPENSSL_CRYPTO_THREAD_LOCAL_KEY_MAX];

		int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL key, void (cleanup)(void *))
		{
		static unsigned int thread_local_key = 0;

		if (thread_local_key >= OPENSSL_CRYPTO_THREAD_LOCAL_KEY_MAX)
		return 0;

		*key = thread_local_key++;

		thread_local_storage[*key] = NULL;

		return 1;
		}

		void CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL key)
		{
		if (*key >= OPENSSL_CRYPTO_THREAD_LOCAL_KEY_MAX)
		return NULL;

		return thread_local_storage[*key];
		}

		int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL key, void val)
		{
		if (*key >= OPENSSL_CRYPTO_THREAD_LOCAL_KEY_MAX)
		return 0;

		thread_local_storage[*key] = val;

		return 1;
		}

		int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key)
		{
		*key = OPENSSL_CRYPTO_THREAD_LOCAL_KEY_MAX + 1;
		return 1;
		}

		CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void)
		{
		return 0;
		}

		int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b)
		{
		return (a == b);
		}

		int CRYPTO_atomic_add(int val, int amount, int ret, CRYPTO_RWLOCK *lock)
		{
		*val += amount;
		ret = val;

		return 1;
		}

		#endif

crypto/threads_pthread.c

0 → 100644

+167 −0

Original line number	Diff line number	Diff line
		/* ====================================================================
		* Copyright (c) 2016 The OpenSSL Project. All rights reserved.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions
		* are met:
		*
		* 1. Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		*
		* 2. Redistributions in binary form must reproduce the above copyright
		* notice, this list of conditions and the following disclaimer in
		* the documentation and/or other materials provided with the
		* distribution.
		*
		* 3. All advertising materials mentioning features or use of this
		* software must display the following acknowledgment:
		* "This product includes software developed by the OpenSSL Project
		* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
		*
		* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
		* endorse or promote products derived from this software without
		* prior written permission. For written permission, please contact
		* openssl-core@openssl.org.
		*
		* 5. Products derived from this software may not be called "OpenSSL"
		* nor may "OpenSSL" appear in their names without prior written
		* permission of the OpenSSL Project.
		*
		* 6. Redistributions of any form whatsoever must retain the following
		* acknowledgment:
		* "This product includes software developed by the OpenSSL Project
		* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
		*
		* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
		* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
		* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
		* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
		* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
		* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
		* OF THE POSSIBILITY OF SUCH DAMAGE.
		* ====================================================================
		*/

		#include <openssl/crypto.h>
		#include "internal/threads.h"

		#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG) && !defined(OPENSSL_SYS_WINDOWS)

		CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void)
		{
		CRYPTO_RWLOCK *lock = OPENSSL_zalloc(sizeof(pthread_rwlock_t));
		if (lock == NULL)
		return NULL;

		if (pthread_rwlock_init(lock, NULL) != 0)
		return NULL;

		return lock;
		}

		int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock)
		{
		if (pthread_rwlock_rdlock(lock) != 0)
		return 0;

		return 1;
		}

		int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock)
		{
		if (pthread_rwlock_wrlock(lock) != 0)
		return 0;

		return 1;
		}

		int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock)
		{
		if (pthread_rwlock_unlock(lock) != 0)
		return 0;

		return 1;
		}

		void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock)
		{
		if (lock == NULL)
		return;

		pthread_rwlock_destroy(lock);
		OPENSSL_free(lock);

		return;
		}

		int CRYPTO_THREAD_run_once(CRYPTO_ONCE once, void (init)(void))
		{
		if (pthread_once(once, init) != 0)
		return 0;

		return 1;
		}

		int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL key, void (cleanup)(void *))
		{
		if (pthread_key_create(key, cleanup) != 0)
		return 0;

		return 1;
		}

		void CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL key)
		{
		return pthread_getspecific(*key);
		}

		int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL key, void val)
		{
		if (pthread_setspecific(*key, val) != 0)
		return 0;

		return 1;
		}

		int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key)
		{
		if (pthread_key_delete(*key) != 0)
		return 0;

		return 1;
		}

		CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void)
		{
		return pthread_self();
		}

		int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b)
		{
		return pthread_equal(a, b);
		}

		int CRYPTO_atomic_add(int val, int amount, int ret, CRYPTO_RWLOCK *lock)
		{
		#ifdef __ATOMIC_RELAXED
		*ret = __atomic_add_fetch(val, amount, __ATOMIC_RELAXED);
		#else
		if (!CRYPTO_THREAD_write_lock(lock))
		return 0;

		*val += amount;
		ret = val;

		if (!CRYPTO_THREAD_unlock(lock))
		return 0;
		#endif

		return 1;
		}

		#endif

crypto/threads_win.c

0 → 100644

+190 −0

Original line number	Diff line number	Diff line
		/* ====================================================================
		* Copyright (c) 2016 The OpenSSL Project. All rights reserved.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions
		* are met:
		*
		* 1. Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		*
		* 2. Redistributions in binary form must reproduce the above copyright
		* notice, this list of conditions and the following disclaimer in
		* the documentation and/or other materials provided with the
		* distribution.
		*
		* 3. All advertising materials mentioning features or use of this
		* software must display the following acknowledgment:
		* "This product includes software developed by the OpenSSL Project
		* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
		*
		* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
		* endorse or promote products derived from this software without
		* prior written permission. For written permission, please contact
		* openssl-core@openssl.org.
		*
		* 5. Products derived from this software may not be called "OpenSSL"
		* nor may "OpenSSL" appear in their names without prior written
		* permission of the OpenSSL Project.
		*
		* 6. Redistributions of any form whatsoever must retain the following
		* acknowledgment:
		* "This product includes software developed by the OpenSSL Project
		* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
		*
		* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
		* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
		* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
		* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
		* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
		* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
		* OF THE POSSIBILITY OF SUCH DAMAGE.
		* ====================================================================
		*/

		#include <openssl/crypto.h>
		#include "internal/threads.h"

		#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG) && defined(OPENSSL_SYS_WINDOWS)

		CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void)
		{
		CRYPTO_RWLOCK *lock = OPENSSL_zalloc(sizeof(CRITICAL_SECTION));
		if (lock == NULL)
		return NULL;

		/* 0x400 is the spin count value suggested in the documentation */
		if (!InitializeCriticalSectionAndSpinCount(lock, 0x400))
		return NULL;

		return lock;
		}

		int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock)
		{
		EnterCriticalSection(lock);
		return 1;
		}

		int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock)
		{
		EnterCriticalSection(lock);
		return 1;
		}

		int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock)
		{
		LeaveCriticalSection(lock);
		return 1;
		}

		void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock)
		{
		if (lock == NULL)
		return;

		DeleteCriticalSection(lock);
		OPENSSL_free(lock);

		return;
		}

		# if _WIN32_WINNT < 0x0600

		# define ONCE_UNINITED 0
		# define ONCE_ININIT 1
		# define ONCE_DONE 2

		int CRYPTO_THREAD_run_once(CRYPTO_ONCE once, void (init)(void))
		{
		LONG volatile lock = (LONG )once;
		LONG result;

		if (*lock == ONCE_DONE)
		return 1;

		do {
		result = InterlockedCompareExchange(lock, ONCE_ININIT, ONCE_UNINITED);
		if (result == ONCE_UNINITED) {
		init();
		*lock = ONCE_DONE;
		return 1;
		}
		} while (result == ONCE_ININIT);

		return (*lock == ONCE_DONE);
		}

		# else

		BOOL CALLBACK once_cb(PINIT_ONCE once, PVOID p, PVOID *pp)
		{
		void (*init)(void) = p;

		init();

		return TRUE;
		}

		void CRYPTO_THREAD_run_once(CRYPTO_ONCE once, void (init)(void))
		{
		if (InitOnceExecuteOnce(once, once_cb, init, NULL))
		return 0;

		return 1;
		}

		# endif

		int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL key, void (cleanup)(void *))
		{
		*key = TlsAlloc();
		if (*key == TLS_OUT_OF_INDEXES)
		return 0;

		return 1;
		}

		void CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL key)
		{
		return TlsGetValue(*key);
		}

		int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL key, void val)
		{
		if (TlsSetValue(*key, val) == 0)
		return 0;

		return 1;
		}

		int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key)
		{
		if (TlsFree(*key) == 0)
		return 0;

		return 1;
		}

		CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void)
		{
		return GetCurrentThreadId();
		}

		int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b)
		{
		return (a == b);
		}

		int CRYPTO_atomic_add(int val, int amount, int ret, CRYPTO_RWLOCK *lock)
		{
		*ret = InterlockedExchangeAdd(val, amount) + amount;
		return 1;
		}

		#endif