diff options
Diffstat (limited to 'src/include/openssl/thread.h')
| -rw-r--r-- | src/include/openssl/thread.h | 273 |
1 files changed, 273 insertions, 0 deletions
diff --git a/src/include/openssl/thread.h b/src/include/openssl/thread.h new file mode 100644 index 0000000..ea65405 --- /dev/null +++ b/src/include/openssl/thread.h @@ -0,0 +1,273 @@ +/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) + * All rights reserved. + * + * This package is an SSL implementation written + * by Eric Young (eay@cryptsoft.com). + * The implementation was written so as to conform with Netscapes SSL. + * + * This library is free for commercial and non-commercial use as long as + * the following conditions are aheared to. The following conditions + * apply to all code found in this distribution, be it the RC4, RSA, + * lhash, DES, etc., code; not just the SSL code. The SSL documentation + * included with this distribution is covered by the same copyright terms + * except that the holder is Tim Hudson (tjh@cryptsoft.com). + * + * Copyright remains Eric Young's, and as such any Copyright notices in + * the code are not to be removed. + * If this package is used in a product, Eric Young should be given attribution + * as the author of the parts of the library used. + * This can be in the form of a textual message at program startup or + * in documentation (online or textual) provided with the package. + * + * 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 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 acknowledgement: + * "This product includes cryptographic software written by + * Eric Young (eay@cryptsoft.com)" + * The word 'cryptographic' can be left out if the rouines from the library + * being used are not cryptographic related :-). + * 4. If you include any Windows specific code (or a derivative thereof) from + * the apps directory (application code) you must include an acknowledgement: + * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" + * + * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND + * ANY EXPRESS 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 AUTHOR OR 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. + * + * The licence and distribution terms for any publically available version or + * derivative of this code cannot be changed. i.e. this code cannot simply be + * copied and put under another distribution licence + * [including the GNU Public Licence.] */ + +#ifndef OPENSSL_HEADER_THREAD_H +#define OPENSSL_HEADER_THREAD_H + +#include <openssl/base.h> + +#if defined(__cplusplus) +extern "C" { +#endif + + +/* Functions to support multithreading. + * + * OpenSSL can safely be used in multi-threaded applications provided that at + * least two callback functions are set with |CRYPTO_set_locking_callback| and + * |CRYPTO_THREADID_set_callback|. + * + * The locking callback performs mutual exclusion. Rather than using a single + * lock for all, shared data-structures, OpenSSL requires that the locking + * callback support a fixed (at run-time) number of different locks, given by + * |CRYPTO_num_locks|. + * + * The thread ID callback is called to record the currently executing thread's + * identifier in a |CRYPTO_THREADID| structure. If this callback is not + * provided then the address of |errno| is used as the thread identifier. This + * is sufficient only if the system has a thread-local |errno| value. */ + + +/* CRYPTO_num_locks returns the number of static locks that the callback + * function passed to |CRYPTO_set_locking_callback| must be able to handle. */ +OPENSSL_EXPORT int CRYPTO_num_locks(void); + +/* CRYPTO_set_locking_callback sets a callback function that implements locking + * on behalf of OpenSSL. The callback is called whenever OpenSSL needs to lock + * or unlock a lock, and locks are specified as a number between zero and + * |CRYPTO_num_locks()-1|. + * + * The mode argument to the callback is a bitwise-OR of either CRYPTO_LOCK or + * CRYPTO_UNLOCK, to denote the action, and CRYPTO_READ or CRYPTO_WRITE, to + * indicate the type of lock. The |file| and |line| arguments give the location + * in the OpenSSL source where the locking action originated. */ +OPENSSL_EXPORT void CRYPTO_set_locking_callback( + void (*func)(int mode, int lock_num, const char *file, int line)); + +/* CRYPTO_set_add_lock_callback sets an optional callback which is used when + * OpenSSL needs to add a fixed amount to an integer. For example, this is used + * when maintaining reference counts. Normally the reference counts are + * maintained by performing the addition under a lock but, if this callback + * has been set, the application is free to implement the operation using + * faster methods (i.e. atomic operations). + * + * The callback is given a pointer to the integer to be altered (|num|), the + * amount to add to the integer (|amount|, which may be negative), the number + * of the lock which would have been taken to protect the operation and the + * position in the OpenSSL code where the operation originated. */ +OPENSSL_EXPORT void CRYPTO_set_add_lock_callback(int (*func)( + int *num, int amount, int lock_num, const char *file, int line)); + +/* CRYPTO_get_lock_name returns the name of the lock given by |lock_num|. This + * can be used in a locking callback for debugging purposes. */ +OPENSSL_EXPORT const char *CRYPTO_get_lock_name(int lock_num); + + +/* CRYPTO_THREADID identifies a thread in a multithreaded program. This + * structure should not be used directly. Rather applications should use + * |CRYPTO_THREADID_set_numeric| and |CRYPTO_THREADID_set_pointer|. */ +typedef struct crypto_threadid_st { + void *ptr; + unsigned long val; +} CRYPTO_THREADID; + +/* CRYPTO_THREADID_set_callback sets a callback function that stores an + * identifier of the currently executing thread into |threadid|. The + * CRYPTO_THREADID structure should not be accessed directly. Rather one of + * |CRYPTO_THREADID_set_numeric| or |CRYPTO_THREADID_set_pointer| should be + * used depending on whether thread IDs are numbers or pointers on the host + * system. */ +OPENSSL_EXPORT int CRYPTO_THREADID_set_callback( + void (*threadid_func)(CRYPTO_THREADID *threadid)); + +OPENSSL_EXPORT void CRYPTO_THREADID_set_numeric(CRYPTO_THREADID *id, + unsigned long val); +OPENSSL_EXPORT void CRYPTO_THREADID_set_pointer(CRYPTO_THREADID *id, void *ptr); + + +/* Private functions: */ + +/* CRYPTO_get_locking_callback returns the callback, if any, that was most + * recently set using |CRYPTO_set_locking_callback|. */ +void (*CRYPTO_get_locking_callback(void))(int mode, int lock_num, + const char *file, int line); + +/* CRYPTO_get_add_lock_callback returns the callback, if any, that was most + * recently set using |CRYPTO_set_add_lock_callback|. */ +int (*CRYPTO_get_add_lock_callback(void))(int *num, int amount, int lock_num, + const char *file, int line); + +/* CRYPTO_lock locks or unlocks the lock specified by |lock_num| (one of + * |CRYPTO_LOCK_*|). Don't call this directly, rather use one of the + * CRYPTO_[rw]_(un)lock macros. */ +OPENSSL_EXPORT void CRYPTO_lock(int mode, int lock_num, const char *file, + int line); + +/* CRYPTO_add_lock adds |amount| to |*pointer|, protected by the lock specified + * by |lock_num|. It returns the new value of |*pointer|. Don't call this + * function directly, rather use the |CRYPTO_add_lock| macro. + * + * TODO(fork): rename to CRYPTO_add_locked. */ +OPENSSL_EXPORT int CRYPTO_add_lock(int *pointer, int amount, int lock_num, + const char *file, int line); + + +/* CRYPTO_THREADID_current stores the current thread identifier in |id|. */ +OPENSSL_EXPORT void CRYPTO_THREADID_current(CRYPTO_THREADID *id); + +/* CRYPTO_THREADID_cmp returns < 0, 0 or > 0 if |a| is less than, equal to or + * greater than |b|, respectively. */ +int CRYPTO_THREADID_cmp(const CRYPTO_THREADID *a, const CRYPTO_THREADID *b); + +/* CRYPTO_THREADID_cpy sets |*dest| equal to |*src|. */ +void CRYPTO_THREADID_cpy(CRYPTO_THREADID *dest, const CRYPTO_THREADID *src); + +/* CRYPTO_THREADID_hash returns a hash of the numeric value of |id|. */ +uint32_t CRYPTO_THREADID_hash(const CRYPTO_THREADID *id); + +/* These are the locks used by OpenSSL. These values should match up with the + * table in thread.c. */ +#define CRYPTO_LOCK_ERR 1 +#define CRYPTO_LOCK_EX_DATA 2 +#define CRYPTO_LOCK_X509 3 +#define CRYPTO_LOCK_X509_INFO 4 +#define CRYPTO_LOCK_X509_PKEY 5 +#define CRYPTO_LOCK_X509_CRL 6 +#define CRYPTO_LOCK_X509_REQ 7 +#define CRYPTO_LOCK_DSA 8 +#define CRYPTO_LOCK_RSA 9 +#define CRYPTO_LOCK_EVP_PKEY 10 +#define CRYPTO_LOCK_X509_STORE 11 +#define CRYPTO_LOCK_SSL_CTX 12 +#define CRYPTO_LOCK_SSL_CERT 13 +#define CRYPTO_LOCK_SSL_SESSION 14 +#define CRYPTO_LOCK_SSL_SESS_CERT 15 +#define CRYPTO_LOCK_SSL 16 +#define CRYPTO_LOCK_SSL_METHOD 17 +#define CRYPTO_LOCK_RAND 18 +#define CRYPTO_LOCK_RAND2 19 +#define CRYPTO_LOCK_MALLOC 20 +#define CRYPTO_LOCK_BIO 21 +#define CRYPTO_LOCK_GETHOSTBYNAME 22 +#define CRYPTO_LOCK_GETSERVBYNAME 23 +#define CRYPTO_LOCK_READDIR 24 +#define CRYPTO_LOCK_RSA_BLINDING 25 +#define CRYPTO_LOCK_DH 26 +#define CRYPTO_LOCK_MALLOC2 27 +#define CRYPTO_LOCK_DSO 28 +#define CRYPTO_LOCK_DYNLOCK 29 +#define CRYPTO_LOCK_ENGINE 30 +#define CRYPTO_LOCK_UI 31 +#define CRYPTO_LOCK_ECDSA 32 +#define CRYPTO_LOCK_EC 33 +#define CRYPTO_LOCK_ECDH 34 +#define CRYPTO_LOCK_BN 35 +#define CRYPTO_LOCK_EC_PRE_COMP 36 +#define CRYPTO_LOCK_STORE 37 +#define CRYPTO_LOCK_COMP 38 +#define CRYPTO_LOCK_FIPS 39 +#define CRYPTO_LOCK_FIPS2 40 +#define CRYPTO_LOCK_OBJ 40 +#define CRYPTO_NUM_LOCKS 42 + +#define CRYPTO_LOCK 1 +#define CRYPTO_UNLOCK 2 +#define CRYPTO_READ 4 +#define CRYPTO_WRITE 8 + +#define CRYPTO_w_lock(lock_num) \ + CRYPTO_lock(CRYPTO_LOCK | CRYPTO_WRITE, lock_num, __FILE__, __LINE__) +#define CRYPTO_w_unlock(lock_num) \ + CRYPTO_lock(CRYPTO_UNLOCK | CRYPTO_WRITE, lock_num, __FILE__, __LINE__) +#define CRYPTO_r_lock(lock_num) \ + CRYPTO_lock(CRYPTO_LOCK | CRYPTO_READ, lock_num, __FILE__, __LINE__) +#define CRYPTO_r_unlock(lock_num) \ + CRYPTO_lock(CRYPTO_UNLOCK | CRYPTO_READ, lock_num, __FILE__, __LINE__) +#define CRYPTO_add(addr, amount, lock_num) \ + CRYPTO_add_lock(addr, amount, lock_num, __FILE__, __LINE__) + + +/* Private functions. + * + * Some old code calls these functions and so no-op implementations are + * provided. + * + * TODO(fork): cleanup callers and remove. */ + +OPENSSL_EXPORT void CRYPTO_set_id_callback(unsigned long (*func)(void)); + +typedef struct { + int references; + struct CRYPTO_dynlock_value *data; +} CRYPTO_dynlock; + +OPENSSL_EXPORT void CRYPTO_set_dynlock_create_callback( + struct CRYPTO_dynlock_value *(*dyn_create_function)(const char *file, + int line)); + +OPENSSL_EXPORT void CRYPTO_set_dynlock_lock_callback(void (*dyn_lock_function)( + int mode, struct CRYPTO_dynlock_value *l, const char *file, int line)); + +OPENSSL_EXPORT void CRYPTO_set_dynlock_destroy_callback( + void (*dyn_destroy_function)(struct CRYPTO_dynlock_value *l, + const char *file, int line)); + + +#if defined(__cplusplus) +} /* extern C */ +#endif + +#endif /* OPENSSL_HEADER_THREAD_H */ |