ecc: Fix _gcry_mpi_ec_p_new to allow secp256k1.
[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   gpg_err_code_t rc;
138   unsigned int thread_option;
139
140   /* Fist call ath_init so that we know our thread model.  */
141   rc = ath_init ();
142   if (rc)
143     return rc;
144
145   /* Check if the requested thread option is compatible to the
146      thread option we are already committed to.  */
147   thread_option = ath_ops? GET_OPTION (ath_ops->option) : 0;
148
149   /* Return an error if the requested thread model does not match the
150      configured one.  */
151   if (0)
152     ;
153 #if USE_POSIX_THREADS_WEAK
154   else if (thread_model == ath_model_pthreads_weak)
155     {
156       if (thread_option == ATH_THREAD_OPTION_PTHREAD)
157         return 0; /* Okay - compatible.  */
158       if (thread_option == ATH_THREAD_OPTION_PTH)
159         return 0; /* Okay - compatible.  */
160     }
161 #endif /*USE_POSIX_THREADS_WEAK*/
162   else if (thread_option == ATH_THREAD_OPTION_PTH)
163     {
164       if (thread_model == ath_model_none)
165         return 0; /* Okay - compatible.  */
166     }
167   else if (thread_option == ATH_THREAD_OPTION_DEFAULT)
168     return 0; /* No thread support requested.  */
169
170   return GPG_ERR_NOT_SUPPORTED;
171 }
172
173
174 /* Initialize a new mutex.  This function returns 0 on success or an
175    system error code (i.e. an ERRNO value).  ERRNO may or may not be
176    changed on error.  */
177 int
178 ath_mutex_init (ath_mutex_t *lock)
179 {
180   int err;
181
182   switch (thread_model)
183     {
184     case ath_model_none:
185       *lock = MUTEX_UNLOCKED;
186       err = 0;
187       break;
188
189 #if USE_POSIX_THREADS_WEAK
190     case ath_model_pthreads_weak:
191       {
192         pthread_mutex_t *plck;
193
194         plck = malloc (sizeof *plck);
195         if (!plck)
196           err = errno? errno : ENOMEM;
197         else
198           {
199             err = pthread_mutex_init (plck, NULL);
200             if (err)
201               free (plck);
202             else
203               *lock = (void*)plck;
204           }
205       }
206       break;
207 #endif /*USE_POSIX_THREADS_WEAK*/
208
209     default:
210       err = EINVAL;
211       break;
212     }
213
214   return err;
215 }
216
217
218 /* Destroy a mutex.  This function is a NOP if LOCK is NULL.  If the
219    mutex is still locked it can't be destroyed and the function
220    returns EBUSY.  ERRNO may or may not be changed on error.  */
221 int
222 ath_mutex_destroy (ath_mutex_t *lock)
223 {
224   int err;
225
226   if (!*lock)
227     return 0;
228
229   switch (thread_model)
230     {
231     case ath_model_none:
232       if (*lock != MUTEX_UNLOCKED)
233         err = EBUSY;
234       else
235         {
236           *lock = MUTEX_DESTROYED;
237           err = 0;
238         }
239       break;
240
241 #if USE_POSIX_THREADS_WEAK
242     case ath_model_pthreads_weak:
243       {
244         pthread_mutex_t *plck = (pthread_mutex_t*) (*lock);
245
246         err = pthread_mutex_destroy (plck);
247         if (!err)
248           {
249             free (plck);
250             lock = NULL;
251           }
252       }
253       break;
254 #endif /*USE_POSIX_THREADS_WEAK*/
255
256     default:
257       err = EINVAL;
258       break;
259     }
260
261   return err;
262 }
263
264
265 /* Lock the mutex LOCK.  On success the function returns 0; on error
266    an error code.  ERRNO may or may not be changed on error.  */
267 int
268 ath_mutex_lock (ath_mutex_t *lock)
269 {
270   int err;
271
272   switch (thread_model)
273     {
274     case ath_model_none:
275       if (*lock == MUTEX_NOTINIT)
276         err = EINVAL;
277       else if (*lock == MUTEX_UNLOCKED)
278         {
279           *lock = MUTEX_LOCKED;
280           err = 0;
281         }
282       else
283         err = EDEADLK;
284       break;
285
286 #if USE_POSIX_THREADS_WEAK
287     case ath_model_pthreads_weak:
288       err = pthread_mutex_lock ((pthread_mutex_t*)(*lock));
289       break;
290 #endif /*USE_POSIX_THREADS_WEAK*/
291
292     default:
293       err = EINVAL;
294       break;
295     }
296
297   return err;
298 }
299
300 /* Unlock the mutex LOCK.  On success the function returns 0; on error
301    an error code.  ERRNO may or may not be changed on error.  */
302 int
303 ath_mutex_unlock (ath_mutex_t *lock)
304 {
305   int err;
306
307   switch (thread_model)
308     {
309     case ath_model_none:
310       if (*lock == MUTEX_NOTINIT)
311         err = EINVAL;
312       else if (*lock == MUTEX_LOCKED)
313         {
314           *lock = MUTEX_UNLOCKED;
315           err = 0;
316         }
317       else
318         err = EPERM;
319       break;
320
321 #if USE_POSIX_THREADS_WEAK
322     case ath_model_pthreads_weak:
323       err = pthread_mutex_unlock ((pthread_mutex_t*)(*lock));
324       break;
325 #endif /*USE_POSIX_THREADS_WEAK*/
326
327     default:
328       err = EINVAL;
329       break;
330     }
331
332   return err;
333 }