doc/crypto/threads.pod

   1 =pod
   2
   3 =head1 NAME
   4
   5 CRYPTO_THREADID_set_callback, CRYPTO_THREADID_get_callback,
   6 CRYPTO_THREADID_current, CRYPTO_THREADID_cmp, CRYPTO_THREADID_cpy,
   7 CRYPTO_THREADID_hash, CRYPTO_set_locking_callback, CRYPTO_num_locks,
   8 CRYPTO_set_dynlock_create_callback, CRYPTO_set_dynlock_lock_callback,
   9 CRYPTO_set_dynlock_destroy_callback, CRYPTO_get_new_dynlockid,
  10 CRYPTO_destroy_dynlockid, CRYPTO_lock - OpenSSL thread support
  11
  12 =head1 SYNOPSIS
  13
  14  #include <openssl/crypto.h>
  15
  16  /* Don't use this structure directly. */
  17  typedef struct crypto_threadid_st
  18          {
  19          void *ptr;
  20          unsigned long val;
  21          } CRYPTO_THREADID;
  22  /* Only use CRYPTO_THREADID_set_[numeric|pointer]() within callbacks */
  23  void CRYPTO_THREADID_set_numeric(CRYPTO_THREADID *id, unsigned long val);
  24  void CRYPTO_THREADID_set_pointer(CRYPTO_THREADID *id, void *ptr);
  25  int CRYPTO_THREADID_set_callback(void (*threadid_func)(CRYPTO_THREADID *));
  26  void (*CRYPTO_THREADID_get_callback(void))(CRYPTO_THREADID *);
  27  void CRYPTO_THREADID_current(CRYPTO_THREADID *id);
  28  int CRYPTO_THREADID_cmp(const CRYPTO_THREADID *a,
  29                          const CRYPTO_THREADID *b);
  30  void CRYPTO_THREADID_cpy(CRYPTO_THREADID *dest,
  31                           const CRYPTO_THREADID *src);
  32  unsigned long CRYPTO_THREADID_hash(const CRYPTO_THREADID *id);
  33
  34  int CRYPTO_num_locks(void);
  35
  36  /* struct CRYPTO_dynlock_value needs to be defined by the user */
  37  struct CRYPTO_dynlock_value;
  38
  39  void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *
  40         (*dyn_create_function)(char *file, int line));
  41  void CRYPTO_set_dynlock_lock_callback(void (*dyn_lock_function)
  42         (int mode, struct CRYPTO_dynlock_value *l,
  43         const char *file, int line));
  44  void CRYPTO_set_dynlock_destroy_callback(void (*dyn_destroy_function)
  45         (struct CRYPTO_dynlock_value *l, const char *file, int line));
  46
  47  int CRYPTO_get_new_dynlockid(void);
  48
  49  void CRYPTO_destroy_dynlockid(int i);
  50
  51  void CRYPTO_lock(int mode, int n, const char *file, int line);
  52
  53  #define CRYPTO_w_lock(type)    \
  54         CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,__FILE__,__LINE__)
  55  #define CRYPTO_w_unlock(type)  \
  56         CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,__FILE__,__LINE__)
  57  #define CRYPTO_r_lock(type)    \
  58         CRYPTO_lock(CRYPTO_LOCK|CRYPTO_READ,type,__FILE__,__LINE__)
  59  #define CRYPTO_r_unlock(type)  \
  60         CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_READ,type,__FILE__,__LINE__)
  61  #define CRYPTO_add(addr,amount,type)   \
  62         CRYPTO_add_lock(addr,amount,type,__FILE__,__LINE__)
  63
  64 =head1 DESCRIPTION
  65
  66 OpenSSL can generally be used safely in multi-threaded applications provided
  67 that at least two callback functions are set, the locking_function and
  68 threadid_func.
  69 Note that OpenSSL is not completely thread-safe, and unfortunately not all
  70 global resources have the necessary locks.
  71 Further, the thread-safety does not extend to things like multiple threads
  72 using the same B<SSL> object at the same time.
  73
  74 locking_function(int mode, int n, const char *file, int line) is
  75 needed to perform locking on shared data structures.
  76 (Note that OpenSSL uses a number of global data structures that
  77 will be implicitly shared whenever multiple threads use OpenSSL.)
  78 Multi-threaded applications will crash at random if it is not set.
  79
  80 locking_function() must be able to handle up to CRYPTO_num_locks()
  81 different mutex locks. It sets the B<n>-th lock if B<mode> &
  82 B<CRYPTO_LOCK>, and releases it otherwise.
  83
  84 B<file> and B<line> are the file number of the function setting the
  85 lock. They can be useful for debugging.
  86
  87 threadid_func(CRYPTO_THREADID *id) is needed to record the currently-executing
  88 thread's identifier into B<id>. The implementation of this callback should not
  89 fill in B<id> directly, but should use CRYPTO_THREADID_set_numeric() if thread
  90 IDs are numeric, or CRYPTO_THREADID_set_pointer() if they are pointer-based.
  91 If the application does not register such a callback using
  92 CRYPTO_THREADID_set_callback(), then a default implementation is used - on
  93 Windows and BeOS this uses the system's default thread identifying APIs, and on
  94 all other platforms it uses the address of B<errno>. The latter is satisfactory
  95 for thread-safety if and only if the platform has a thread-local error number
  96 facility.
  97
  98 Once threadid_func() is registered, or if the built-in default implementation is
  99 to be used;
 100
 101 =over 4
 102
 103 =item *
 104 CRYPTO_THREADID_current() records the currently-executing thread ID into the
 105 given B<id> object.
 106
 107 =item *
 108 CRYPTO_THREADID_cmp() compares two thread IDs (returning zero for equality, ie.
 109 the same semantics as memcmp()).
 110
 111 =item *
 112 CRYPTO_THREADID_cpy() duplicates a thread ID value,
 113
 114 =item *
 115 CRYPTO_THREADID_hash() returns a numeric value usable as a hash-table key. This
 116 is usually the exact numeric or pointer-based thread ID used internally, however
 117 this also handles the unusual case where pointers are larger than 'long'
 118 variables and the platform's thread IDs are pointer-based - in this case, mixing
 119 is done to attempt to produce a unique numeric value even though it is not as
 120 wide as the platform's true thread IDs.
 121
 122 =back
 123
 124 Additionally, OpenSSL supports dynamic locks, and sometimes, some parts
 125 of OpenSSL need it for better performance.  To enable this, the following
 126 is required:
 127
 128 =over 4
 129
 130 =item *
 131 Three additional callback function, dyn_create_function, dyn_lock_function
 132 and dyn_destroy_function.
 133
 134 =item *
 135 A structure defined with the data that each lock needs to handle.
 136
 137 =back
 138
 139 struct CRYPTO_dynlock_value has to be defined to contain whatever structure
 140 is needed to handle locks.
 141
 142 dyn_create_function(const char *file, int line) is needed to create a
 143 lock.  Multi-threaded applications might crash at random if it is not set.
 144
 145 dyn_lock_function(int mode, CRYPTO_dynlock *l, const char *file, int line)
 146 is needed to perform locking off dynamic lock numbered n. Multi-threaded
 147 applications might crash at random if it is not set.
 148
 149 dyn_destroy_function(CRYPTO_dynlock *l, const char *file, int line) is
 150 needed to destroy the lock l. Multi-threaded applications might crash at
 151 random if it is not set.
 152
 153 CRYPTO_get_new_dynlockid() is used to create locks.  It will call
 154 dyn_create_function for the actual creation.
 155
 156 CRYPTO_destroy_dynlockid() is used to destroy locks.  It will call
 157 dyn_destroy_function for the actual destruction.
 158
 159 CRYPTO_lock() is used to lock and unlock the locks.  mode is a bitfield
 160 describing what should be done with the lock.  n is the number of the
 161 lock as returned from CRYPTO_get_new_dynlockid().  mode can be combined
 162 from the following values.  These values are pairwise exclusive, with
 163 undefined behaviour if misused (for example, CRYPTO_READ and CRYPTO_WRITE
 164 should not be used together):
 165
 166         CRYPTO_LOCK     0x01
 167         CRYPTO_UNLOCK   0x02
 168         CRYPTO_READ     0x04
 169         CRYPTO_WRITE    0x08
 170
 171 =head1 RETURN VALUES
 172
 173 CRYPTO_num_locks() returns the required number of locks.
 174
 175 CRYPTO_get_new_dynlockid() returns the index to the newly created lock.
 176
 177 The other functions return no values.
 178
 179 =head1 NOTES
 180
 181 You can find out if OpenSSL was configured with thread support:
 182
 183  #define OPENSSL_THREAD_DEFINES
 184  #include <openssl/opensslconf.h>
 185  #if defined(OPENSSL_THREADS)
 186    // thread support enabled
 187  #else
 188    // no thread support
 189  #endif
 190
 191 Also, dynamic locks are currently not used internally by OpenSSL, but
 192 may do so in the future.
 193
 194 =head1 EXAMPLES
 195
 196 B<crypto/threads/mttest.c> shows examples of the callback functions on
 197 Solaris, Irix and Win32.
 198
 199 =head1 HISTORY
 200
 201 CRYPTO_set_locking_callback() is
 202 available in all versions of SSLeay and OpenSSL.
 203 CRYPTO_num_locks() was added in OpenSSL 0.9.4.
 204 All functions dealing with dynamic locks were added in OpenSSL 0.9.5b-dev.
 205 B<CRYPTO_THREADID> and associated functions were introduced in OpenSSL 1.0.0
 206 to replace (actually, deprecate) the previous CRYPTO_set_id_callback(),
 207 CRYPTO_get_id_callback(), and CRYPTO_thread_id() functions which assumed
 208 thread IDs to always be represented by 'unsigned long'.
 209
 210 =head1 SEE ALSO
 211
 212 L<crypto(3)|crypto(3)>
 213
 214 =cut