Doc for the added internal RSA functions
[openssl.git] / crypto / threads_win.c
1 /*
2  * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #if defined(_WIN32)
11 # include <windows.h>
12 #endif
13
14 #include <openssl/crypto.h>
15
16 #if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG) && defined(OPENSSL_SYS_WINDOWS)
17
18 CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void)
19 {
20     CRYPTO_RWLOCK *lock;
21
22     if ((lock = OPENSSL_zalloc(sizeof(CRITICAL_SECTION))) == NULL) {
23         /* Don't set error, to avoid recursion blowup. */
24         return NULL;
25     }
26
27 # if !defined(_WIN32_WCE)
28     /* 0x400 is the spin count value suggested in the documentation */
29     if (!InitializeCriticalSectionAndSpinCount(lock, 0x400)) {
30         OPENSSL_free(lock);
31         return NULL;
32     }
33 # else
34     InitializeCriticalSection(lock);
35 # endif
36
37     return lock;
38 }
39
40 int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock)
41 {
42     EnterCriticalSection(lock);
43     return 1;
44 }
45
46 int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock)
47 {
48     EnterCriticalSection(lock);
49     return 1;
50 }
51
52 int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock)
53 {
54     LeaveCriticalSection(lock);
55     return 1;
56 }
57
58 void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock)
59 {
60     if (lock == NULL)
61         return;
62
63     DeleteCriticalSection(lock);
64     OPENSSL_free(lock);
65
66     return;
67 }
68
69 #  define ONCE_UNINITED     0
70 #  define ONCE_ININIT       1
71 #  define ONCE_DONE         2
72
73 /*
74  * We don't use InitOnceExecuteOnce because that isn't available in WinXP which
75  * we still have to support.
76  */
77 int CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void))
78 {
79     LONG volatile *lock = (LONG *)once;
80     LONG result;
81
82     if (*lock == ONCE_DONE)
83         return 1;
84
85     do {
86         result = InterlockedCompareExchange(lock, ONCE_ININIT, ONCE_UNINITED);
87         if (result == ONCE_UNINITED) {
88             init();
89             *lock = ONCE_DONE;
90             return 1;
91         }
92     } while (result == ONCE_ININIT);
93
94     return (*lock == ONCE_DONE);
95 }
96
97 int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL *key, void (*cleanup)(void *))
98 {
99     *key = TlsAlloc();
100     if (*key == TLS_OUT_OF_INDEXES)
101         return 0;
102
103     return 1;
104 }
105
106 void *CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL *key)
107 {
108     DWORD last_error;
109     void *ret;
110
111     /*
112      * TlsGetValue clears the last error even on success, so that callers may
113      * distinguish it successfully returning NULL or failing. It is documented
114      * to never fail if the argument is a valid index from TlsAlloc, so we do
115      * not need to handle this.
116      *
117      * However, this error-mangling behavior interferes with the caller's use of
118      * GetLastError. In particular SSL_get_error queries the error queue to
119      * determine whether the caller should look at the OS's errors. To avoid
120      * destroying state, save and restore the Windows error.
121      *
122      * https://msdn.microsoft.com/en-us/library/windows/desktop/ms686812(v=vs.85).aspx
123      */
124     last_error = GetLastError();
125     ret = TlsGetValue(*key);
126     SetLastError(last_error);
127     return ret;
128 }
129
130 int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL *key, void *val)
131 {
132     if (TlsSetValue(*key, val) == 0)
133         return 0;
134
135     return 1;
136 }
137
138 int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key)
139 {
140     if (TlsFree(*key) == 0)
141         return 0;
142
143     return 1;
144 }
145
146 CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void)
147 {
148     return GetCurrentThreadId();
149 }
150
151 int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b)
152 {
153     return (a == b);
154 }
155
156 int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock)
157 {
158     *ret = InterlockedExchangeAdd(val, amount) + amount;
159     return 1;
160 }
161
162 int openssl_init_fork_handlers(void)
163 {
164     return 0;
165 }
166
167 int openssl_get_fork_id(void)
168 {
169     return 0;
170 }
171 #endif