=head1 NAME
-CRYPTO_set_locking_callback, CRYPTO_set_id_callback - OpenSSL thread support
+CRYPTO_THREAD_lock_new, CRYPTO_THREAD_read_lock, CRYPTO_THREAD_write_lock,
+CRYPTO_THREAD_unlock, CRYPTO_THREAD_lock_free, CRYPTO_atomic_add - OpenSSL thread support
=head1 SYNOPSIS
#include <openssl/crypto.h>
- void CRYPTO_set_locking_callback(void (*locking_function)(int mode,
- int n, const char *file, int line));
+ CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void);
+ int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock);
+ int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock);
+ int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock);
+ void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock);
- void CRYPTO_set_id_callback(unsigned long (*id_function)(void));
-
- int CRYPTO_num_locks(void);
+ int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock);
=head1 DESCRIPTION
-OpenSSL can safely be used in multi-threaded applications provided
-that two callback functions are set.
+OpenSSL can be safely used in multi-threaded applications provided that
+support for the underlying OS threading API is built-in. Currently, OpenSSL
+supports the pthread and Windows APIs. OpenSSL can also be built without
+any multi-threading support, for example on platforms that don't provide
+any threading support or that provide a threading API that is not yet
+supported by OpenSSL.
+
+The following multi-threading function are provided:
+
+=over 4
+
+=item *
+CRYPTO_THREAD_lock_new() allocates, initializes and returns a new read/write
+lock.
+
+=item *
+CRYPTO_THREAD_read_lock() locks the provided B<lock> for reading.
+
+=item *
+CRYPTO_THREAD_write_lock() locks the provided B<lock> for writing.
-locking_function(int mode, int type, const char *file, int line) is
-needed to perform locking on shared data stuctures. Multi-threaded
-applications will crash at random if it is not set.
+=item *
+CRYPTO_THREAD_unlock() unlocks the previously locked B<lock>.
-locking_function() must be able to handle up to CRYPTO_num_locks()
-different mutex locks. It sets the B<n>th lock if B<mode> &
-B<CRYPTO_LOCK>, and releases it otherwise.
+=item *
+CRYPTO_THREAD_lock_frees() frees the provided B<lock>.
-B<file> and B<line> are the file number of the function setting the
-lock. They can be useful for debugging.
+=item *
+CRYPTO_atomic_add() atomically adds B<amount> to B<val> and returns the
+result of the operation in B<ret>. B<lock> will be locked, unless atomic
+operations are supported on the specific platform. Because of this, if a
+variable is modified by CRYPTO_atomic_add() then CRYPTO_atomic_add() must
+be the only way that the variable is modified.
-id_function(void) is a function that returns a thread ID. It is not
-needed on Windows nor on platforms where getpid() returns a different
-ID for each thread.
+=back
=head1 RETURN VALUES
-CRYPTO_num_locks() returns the required number of locks.
-The other functions return no values.
+CRYPTO_THREAD_lock_new() returns the allocated lock, or NULL on error.
-=head1 NOTE
+CRYPTO_THREAD_lock_frees() returns no value.
+
+The other functions return 1 on success or 0 on error.
+
+=head1 NOTES
You can find out if OpenSSL was configured with thread support:
#define OPENSSL_THREAD_DEFINES
#include <openssl/opensslconf.h>
- #if defined(THREADS)
+ #if defined(OPENSSL_THREADS)
// thread support enabled
#else
// no thread support
#endif
-=head1 EXAMPLES
-
-B<crypto/threads/mttest.c> shows examples of the callback functions on
-Solaris, Irix and Win32.
-
-=head1 HISTORY
-
-CRYPTO_set_locking_callback() and CRYPTO_set_id_callback() are
-available in all versions of SSLeay and OpenSSL.
-CRYPTO_num_locks() was added in OpenSSL 0.9.4.
-
=head1 SEE ALSO
-L<crypto(3)|crypto(3)>
+L<crypto(3)>
=cut
projects / openssl.git / blobdiff