4c921e1bbc
Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
271 lines
11 KiB
C
271 lines
11 KiB
C
/* 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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
int CRYPTO_THREADID_set_callback(
|
|
void (*threadid_func)(CRYPTO_THREADID *threadid));
|
|
|
|
void CRYPTO_THREADID_set_numeric(CRYPTO_THREADID *id, unsigned long val);
|
|
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. */
|
|
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. */
|
|
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|. */
|
|
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. */
|
|
|
|
void CRYPTO_set_id_callback(unsigned long (*func)(void));
|
|
|
|
typedef struct {
|
|
int references;
|
|
struct CRYPTO_dynlock_value *data;
|
|
} CRYPTO_dynlock;
|
|
|
|
void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *(
|
|
*dyn_create_function)(const char *file, int line));
|
|
|
|
void CRYPTO_set_dynlock_lock_callback(void (*dyn_lock_function)(
|
|
int mode, struct CRYPTO_dynlock_value *l, const char *file, int line));
|
|
|
|
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 */
|