Add support for Salsa20.
[libgcrypt.git] / src / ath.c
1 /* ath.c - A Thread-safeness library.
2  *  Copyright (C) 2002, 2003, 2004, 2011 Free Software Foundation, Inc.
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser general Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23
24 #include <assert.h>
25 #include <stdlib.h>
26 #include <unistd.h>
27 #include <errno.h>
28 #if USE_POSIX_THREADS_WEAK
29 # include <pthread.h>
30 #endif
31
32 #include "ath.h"
33
34
35 \f
36 /* On an ELF system it is easy to use pthreads using weak references.
37    Take care not to test the address of a weak referenced function we
38    actually use; some GCC versions have a bug were &foo != NULL is
39    always evaluated to true in PIC mode.  USING_PTHREAD_AS_DEFAULT is
40    used by ath_install to detect the default usage of pthread.  */
41 #if USE_POSIX_THREADS_WEAK
42 # pragma weak pthread_cancel
43 # pragma weak pthread_mutex_init
44 # pragma weak pthread_mutex_lock
45 # pragma weak pthread_mutex_unlock
46 # pragma weak pthread_mutex_destroy
47 #endif
48
49 /* For the dummy interface.  The MUTEX_NOTINIT value is used to check
50    that a mutex has been initialized.  */
51 #define MUTEX_NOTINIT   ((ath_mutex_t) 0)
52 #define MUTEX_UNLOCKED  ((ath_mutex_t) 1)
53 #define MUTEX_LOCKED    ((ath_mutex_t) 2)
54 #define MUTEX_DESTROYED ((ath_mutex_t) 3)
55
56
57 /* Return the thread type from the option field. */
58 #define GET_OPTION(a)    ((a) & 0xff)
59
60
61 \f
62 enum ath_thread_model {
63   ath_model_undefined = 0,
64   ath_model_none,          /* No thread support.  */
65   ath_model_pthreads_weak, /* POSIX threads using weak symbols.  */
66   ath_model_pthreads,      /* POSIX threads directly linked.  */
67   ath_model_w32            /* Microsoft Windows threads.  */
68 };
69
70
71 /* The thread model in use.  */
72 static enum ath_thread_model thread_model;
73
74
75 /* Initialize the ath subsystem.  This is called as part of the
76    Libgcrypt initialization.  It's purpose is to initialize the
77    locking system.  It returns 0 on sucess or an ERRNO value on error.
78    In the latter case it is not defined whether ERRNO was changed.
79
80    Note: This should be called as early as possible because it is not
81    always possible to detect the thread model to use while already
82    running multi threaded.  */
83 int
84 ath_init (void)
85 {
86   int err = 0;
87
88   if (thread_model)
89     return 0; /* Already initialized - no error.  */
90
91   if (0)
92     ;
93 #if USE_POSIX_THREADS_WEAK
94   else if (pthread_cancel)
95     {
96       thread_model = ath_model_pthreads_weak;
97     }
98 #endif
99   else
100     {
101       /* Assume a single threaded application.  */
102       thread_model = ath_model_none;
103     }
104
105   return err;
106 }
107
108
109 /* Return the used thread model as string for display purposes an if
110    R_MODEL is not null store its internal number at R_MODEL.  */
111 const char *
112 ath_get_model (int *r_model)
113 {
114   if (r_model)
115     *r_model = thread_model;
116   switch (thread_model)
117     {
118     case ath_model_undefined:     return "undefined";
119     case ath_model_none:          return "none";
120     case ath_model_pthreads_weak: return "pthread(weak)";
121     case ath_model_pthreads:      return "pthread";
122     case ath_model_w32:           return "w32";
123     default:                      return "?";
124     }
125 }
126
127
128 /* This function was used in old Libgcrypt versions (via
129    GCRYCTL_SET_THREAD_CBS) to register the thread callback functions.
130    It is not anymore required.  However to allow existing code to
131    continue to work, we keep this function and check that no user
132    defined callbacks are used and that the requested thread system
133    matches the one Libgcrypt is using.  */
134 gpg_err_code_t
135 ath_install (struct ath_ops *ath_ops)
136 {
137   unsigned int thread_option;
138
139   /* Check if the requested thread option is compatible to the
140      thread option we are already committed to.  */
141   thread_option = ath_ops? GET_OPTION (ath_ops->option) : 0;
142
143   /* Return an error if the requested thread model does not match the
144      configured one.  */
145   if (0)
146     ;
147 #if USE_POSIX_THREADS_WEAK
148   else if (thread_model == ath_model_pthreads_weak)
149     {
150       if (thread_option == ATH_THREAD_OPTION_PTHREAD)
151         return 0; /* Okay - compatible.  */
152     }
153 #endif /*USE_POSIX_THREADS_WEAK*/
154   else if (thread_option == ATH_THREAD_OPTION_DEFAULT)
155     return 0; /* No thread support requested.  */
156
157   return GPG_ERR_NOT_SUPPORTED;
158 }
159
160
161 /* Initialize a new mutex.  This function returns 0 on success or an
162    system error code (i.e. an ERRNO value).  ERRNO may or may not be
163    changed on error.  */
164 int
165 ath_mutex_init (ath_mutex_t *lock)
166 {
167   int err;
168
169   switch (thread_model)
170     {
171     case ath_model_none:
172       *lock = MUTEX_UNLOCKED;
173       err = 0;
174       break;
175
176 #if USE_POSIX_THREADS_WEAK
177     case ath_model_pthreads_weak:
178       {
179         pthread_mutex_t *plck;
180
181         plck = malloc (sizeof *plck);
182         if (!plck)
183           err = errno? errno : ENOMEM;
184         else
185           {
186             err = pthread_mutex_init (plck, NULL);
187             if (err)
188               free (plck);
189             else
190               *lock = (void*)plck;
191           }
192       }
193       break;
194 #endif /*USE_POSIX_THREADS_WEAK*/
195
196     default:
197       err = EINVAL;
198       break;
199     }
200
201   return err;
202 }
203
204
205 /* Destroy a mutex.  This function is a NOP if LOCK is NULL.  If the
206    mutex is still locked it can't be destroyed and the function
207    returns EBUSY.  ERRNO may or may not be changed on error.  */
208 int
209 ath_mutex_destroy (ath_mutex_t *lock)
210 {
211   int err;
212
213   if (!*lock)
214     return 0;
215
216   switch (thread_model)
217     {
218     case ath_model_none:
219       if (*lock != MUTEX_UNLOCKED)
220         err = EBUSY;
221       else
222         {
223           *lock = MUTEX_DESTROYED;
224           err = 0;
225         }
226       break;
227
228 #if USE_POSIX_THREADS_WEAK
229     case ath_model_pthreads_weak:
230       {
231         pthread_mutex_t *plck = (pthread_mutex_t*) (*lock);
232
233         err = pthread_mutex_destroy (plck);
234         if (!err)
235           {
236             free (plck);
237             lock = NULL;
238           }
239       }
240       break;
241 #endif /*USE_POSIX_THREADS_WEAK*/
242
243     default:
244       err = EINVAL;
245       break;
246     }
247
248   return err;
249 }
250
251
252 /* Lock the mutex LOCK.  On success the function returns 0; on error
253    an error code.  ERRNO may or may not be changed on error.  */
254 int
255 ath_mutex_lock (ath_mutex_t *lock)
256 {
257   int err;
258
259   switch (thread_model)
260     {
261     case ath_model_none:
262       if (*lock == MUTEX_NOTINIT)
263         err = EINVAL;
264       else if (*lock == MUTEX_UNLOCKED)
265         {
266           *lock = MUTEX_LOCKED;
267           err = 0;
268         }
269       else
270         err = EDEADLK;
271       break;
272
273 #if USE_POSIX_THREADS_WEAK
274     case ath_model_pthreads_weak:
275       err = pthread_mutex_lock ((pthread_mutex_t*)(*lock));
276       break;
277 #endif /*USE_POSIX_THREADS_WEAK*/
278
279     default:
280       err = EINVAL;
281       break;
282     }
283
284   return err;
285 }
286
287 /* Unlock the mutex LOCK.  On success the function returns 0; on error
288    an error code.  ERRNO may or may not be changed on error.  */
289 int
290 ath_mutex_unlock (ath_mutex_t *lock)
291 {
292   int err;
293
294   switch (thread_model)
295     {
296     case ath_model_none:
297       if (*lock == MUTEX_NOTINIT)
298         err = EINVAL;
299       else if (*lock == MUTEX_LOCKED)
300         {
301           *lock = MUTEX_UNLOCKED;
302           err = 0;
303         }
304       else
305         err = EPERM;
306       break;
307
308 #if USE_POSIX_THREADS_WEAK
309     case ath_model_pthreads_weak:
310       err = pthread_mutex_unlock ((pthread_mutex_t*)(*lock));
311       break;
312 #endif /*USE_POSIX_THREADS_WEAK*/
313
314     default:
315       err = EINVAL;
316       break;
317     }
318
319   return err;
320 }