b4c78b61ac55d59a815d13278f7c8844d43db942
[libgcrypt.git] / src / global.c
1 /* global.c  -  global control functions
2  *      Copyright (C) 1998, 1999, 2000, 2001 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 General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (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 General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <stdarg.h>
26 #include <ctype.h>
27 #include <assert.h>
28
29 #include "g10lib.h"
30 #include "../cipher/random.h"
31 #include "stdmem.h" /* our own memory allocator */
32 #include "secmem.h" /* our own secmem allocator */
33
34
35 /****************
36  * flag bits: 0 : general cipher debug
37  *            1 : general MPI debug
38  */
39 static unsigned int debug_flags;
40 static int last_ec; /* fixme: make thread safe */
41
42 static void *(*alloc_func)(size_t n) = NULL;
43 static void *(*alloc_secure_func)(size_t n) = NULL;
44 static int   (*is_secure_func)(const void*) = NULL;
45 static void *(*realloc_func)(void *p, size_t n) = NULL;
46 static void (*free_func)(void*) = NULL;
47 static int (*outofcore_handler)( void*, size_t, unsigned int ) = NULL;
48 static void *outofcore_handler_value = NULL;
49 static int no_internal_locking = 0;
50 static int no_secure_memory = 0;
51
52 static const char*
53 parse_version_number( const char *s, int *number )
54 {
55     int val = 0;
56
57     if( *s == '0' && isdigit(s[1]) )
58         return NULL; /* leading zeros are not allowed */
59     for ( ; isdigit(*s); s++ ) {
60         val *= 10;
61         val += *s - '0';
62     }
63     *number = val;
64     return val < 0? NULL : s;
65 }
66
67
68 static const char *
69 parse_version_string( const char *s, int *major, int *minor, int *micro )
70 {
71     s = parse_version_number( s, major );
72     if( !s || *s != '.' )
73         return NULL;
74     s++;
75     s = parse_version_number( s, minor );
76     if( !s || *s != '.' )
77         return NULL;
78     s++;
79     s = parse_version_number( s, micro );
80     if( !s )
81         return NULL;
82     return s; /* patchlevel */
83 }
84
85 /****************
86  * Check that the the version of the library is at minimum the requested one
87  * and return the version string; return NULL if the condition is not
88  * satisfied.  If a NULL is passed to this function, no check is done,
89  * but the version string is simply returned.
90  */
91 const char *
92 gcry_check_version( const char *req_version )
93 {
94     const char *ver = VERSION;
95     int my_major, my_minor, my_micro;
96     int rq_major, rq_minor, rq_micro;
97     const char *my_plvl, *rq_plvl;
98
99     if ( !req_version )
100         return ver;
101
102     my_plvl = parse_version_string( ver, &my_major, &my_minor, &my_micro );
103     if ( !my_plvl )
104         return NULL;  /* very strange our own version is bogus */
105     rq_plvl = parse_version_string( req_version, &rq_major, &rq_minor,
106                                                                 &rq_micro );
107     if ( !rq_plvl )
108         return NULL;  /* req version string is invalid */
109
110     if ( my_major > rq_major
111         || (my_major == rq_major && my_minor > rq_minor)
112         || (my_major == rq_major && my_minor == rq_minor
113                                  && my_micro > rq_micro)
114         || (my_major == rq_major && my_minor == rq_minor
115                                  && my_micro == rq_micro
116                                  && strcmp( my_plvl, rq_plvl ) >= 0) ) {
117         return ver;
118     }
119     return NULL;
120 }
121
122
123 int
124 gcry_control( enum gcry_ctl_cmds cmd, ... )
125 {
126     va_list arg_ptr ;
127
128     va_start( arg_ptr, cmd ) ;
129     switch( cmd ) {
130      #if 0
131       case GCRYCTL_NO_MEM_IS_FATAL:
132         break;
133       case GCRYCTL_SET_FATAL_FNC:
134         break;
135      #endif
136
137       case GCRYCTL_ENABLE_M_GUARD:
138         _gcry_private_enable_m_guard();
139         break;
140
141       case GCRYCTL_DUMP_RANDOM_STATS:
142         _gcry_random_dump_stats();
143         break;
144
145       case GCRYCTL_DUMP_MEMORY_STATS:
146         /*m_print_stats("[fixme: prefix]");*/
147         break;
148
149       case GCRYCTL_DUMP_SECMEM_STATS:
150         _gcry_secmem_dump_stats();
151         break;
152
153       case GCRYCTL_DROP_PRIVS:
154         _gcry_secmem_init( 0 );
155         break;
156
157       case GCRYCTL_DISABLE_SECMEM:
158         no_secure_memory = 1;
159         break;    
160
161       case GCRYCTL_INIT_SECMEM:
162         _gcry_secmem_init( va_arg( arg_ptr, unsigned int ) );
163         break;
164
165       case GCRYCTL_TERM_SECMEM:
166         _gcry_secmem_term();
167         break;
168
169       case GCRYCTL_DISABLE_SECMEM_WARN:
170         _gcry_secmem_set_flags( (_gcry_secmem_get_flags() | 1) );
171         break;
172
173       case GCRYCTL_SUSPEND_SECMEM_WARN:
174         _gcry_secmem_set_flags( (_gcry_secmem_get_flags() | 2) );
175         break;
176
177       case GCRYCTL_RESUME_SECMEM_WARN:
178         _gcry_secmem_set_flags( (_gcry_secmem_get_flags() & ~2) );
179         break;
180
181       case GCRYCTL_USE_SECURE_RNDPOOL:
182         _gcry_secure_random_alloc(); /* put random number into secure memory */
183         break;
184
185       case GCRYCTL_SET_VERBOSITY:
186         _gcry_set_log_verbosity( va_arg( arg_ptr, int ) );
187         break;
188
189       case GCRYCTL_SET_DEBUG_FLAGS:
190         debug_flags |= va_arg( arg_ptr, unsigned int );
191         break;
192
193       case GCRYCTL_CLEAR_DEBUG_FLAGS:
194         debug_flags &= ~va_arg( arg_ptr, unsigned int );
195         break;
196
197       case GCRYCTL_DISABLE_INTERNAL_LOCKING:
198         no_internal_locking = 1;
199         break;
200
201       case GCRYCTL_INITIALIZATION_FINISHED:
202         /* This is a hook which should be used by an application after
203            all intialization has been done and right before any
204            threads are started.  It is not really needed but the only
205            way to be really sure that all initialization for
206            thread-safety has been done. */
207         /* fixme: we should initialize the various mutexs here */
208         break;
209
210       default:
211         va_end(arg_ptr);
212         return GCRYERR_INV_OP;
213     }
214     va_end(arg_ptr);
215     return 0;
216 }
217
218 int
219 gcry_errno()
220 {
221     return last_ec;
222 }
223
224 const char*
225 gcry_strerror( int ec )
226 {
227     const char *s;
228     static char buf[20];
229
230     if( ec == -1 )
231         ec = gcry_errno();
232   #define X(n,a) case GCRYERR_##n : s = a; break;
233     switch( ec ) {
234       X(SUCCESS,        N_("no error"))
235       X(GENERAL,        N_("general error"))
236
237       X(INV_PK_ALGO,    N_("invalid public key algorithm"))
238       X(INV_MD_ALGO,    N_("invalid hash algorithm"))
239       X(BAD_PUBLIC_KEY ,N_("bad public key"))
240       X(BAD_SECRET_KEY ,N_("bad secret key"))
241       X(BAD_SIGNATURE , N_("bad signature"))
242
243       X(INV_CIPHER_ALGO,N_("invalid cipher algorithm"))
244       X(BAD_MPI,        N_("bad big integer"))
245       X(WRONG_PK_ALGO,  N_("unusable public key algorithm"))
246       X(WEAK_KEY,       N_("weak encryption key"))
247       X(INV_KEYLEN,     N_("invalid key length"))
248       X(INV_ARG,        N_("invalid argument"))
249       X(SELFTEST,       N_("selftest failed"))
250
251       X(INV_OP,         N_("invalid operation code or ctl command"))
252       X(NO_MEM,         N_("out of core"))
253       X(INTERNAL,       N_("internal error"))
254       X(EOF,            N_("EOF"))
255       X(INV_OBJ,        N_("an object is not valid"))
256       X(TOO_SHORT,      N_("provided buffer too short"))
257       X(TOO_LARGE,      N_("object is too large"))
258       X(NO_OBJ,         N_("no object"))
259       X(NOT_IMPL,       N_("not implemented"))
260       X(CONFLICT,       N_("conflict"))
261       X(INV_CIPHER_MODE,N_("invalid cipher mode"))
262
263
264       default:
265         sprintf( buf, "ec=%d", ec );
266         s = buf;
267     }
268   #undef X
269     return s;
270 }
271
272
273 int
274 _gcry_set_lasterr( int ec )
275 {
276     if( ec )
277         last_ec = ec == -1 ? GCRYERR_EOF : ec;
278     return ec;
279 }
280
281
282
283 /****************
284  * NOTE: All 5 functions should be set.  */
285 void
286 gcry_set_allocation_handler( void *(*new_alloc_func)(size_t n),
287                              void *(*new_alloc_secure_func)(size_t n),
288                              int (*new_is_secure_func)(const void*),
289                              void *(*new_realloc_func)(void *p, size_t n),
290                              void (*new_free_func)(void*) )
291 {
292     alloc_func        = new_alloc_func;
293     alloc_secure_func = new_alloc_secure_func;
294     is_secure_func    = new_is_secure_func;
295     realloc_func      = new_realloc_func;
296     free_func         = new_free_func;
297 }
298
299
300
301 /****************
302  * Set an optional handler which is called in case the xmalloc functions
303  * ran out of memory.  This handler may do one of these things:
304  *   o free some memory and return true, so that the xmalloc function
305  *     tries again.
306  *   o Do whatever it like and return false, so that the xmalloc functions
307  *     use the default fatal error handler.
308  *   o Terminate the program and don't return.
309  *
310  * The handler function is called with 3 arguments:  The opaque value set with
311  * this function, the requested memory size, and a flag with these bits
312  * currently defined:
313  *      bit 0 set = secure memory has been requested.
314  */
315 void
316 gcry_set_outofcore_handler( int (*f)( void*, size_t, unsigned int ),
317                                                         void *value )
318 {
319     outofcore_handler = f;
320     outofcore_handler_value = value;
321 }
322
323
324
325 void *
326 gcry_malloc( size_t n )
327 {
328     if( alloc_func )
329         return alloc_func( n ) ;
330     return _gcry_private_malloc( n );
331 }
332
333 void *
334 gcry_malloc_secure( size_t n )
335 {
336   if (no_secure_memory)
337     return gcry_malloc (n);
338   if (alloc_secure_func)
339     return alloc_secure_func (n) ;
340   return _gcry_private_malloc_secure (n);
341 }
342
343 int
344 gcry_is_secure( const void *a )
345 {
346   if (no_secure_memory)
347     return 0;
348   if (is_secure_func)
349     return is_secure_func (a) ;
350   return _gcry_private_is_secure (a);
351 }
352
353 void
354 _gcry_check_heap( const void *a )
355 {
356     /* FIXME: implement this*/
357   #if 0
358     if( some_handler )
359         some_handler(a)
360     else
361         _gcry_private_check_heap(a)
362   #endif
363 }
364
365 void *
366 gcry_realloc( void *a, size_t n )
367 {
368     /* FIXME: Make sure that the realloced memory is cleared out */
369
370     if( realloc_func )
371         return realloc_func( a, n ) ;
372     return _gcry_private_realloc( a, n );
373 }
374
375 void
376 gcry_free( void *p )
377 {
378     if( !p )
379         return;
380
381     if( free_func )
382         free_func( p );
383     else
384         _gcry_private_free( p );
385 }
386
387 void *
388 gcry_calloc( size_t n, size_t m )
389 {
390     void *p = gcry_malloc( n*m );
391     if( p )
392         memset( p, 0, n*m );
393     return p;
394 }
395
396 void *
397 gcry_calloc_secure( size_t n, size_t m )
398 {
399     void *p = gcry_malloc_secure( n*m );
400     if( p )
401         memset( p, 0, n*m );
402     return p;
403 }
404
405
406 char *
407 gcry_strdup( const char *string )
408 {
409     void *p = gcry_malloc( strlen(string)+1 );
410     strcpy( p, string );
411     return p;
412 }
413
414
415 void *
416 gcry_xmalloc( size_t n )
417 {
418     void *p;
419
420     while ( !(p = gcry_malloc( n )) ) {
421         if( !outofcore_handler
422             || !outofcore_handler( outofcore_handler_value, n, 0 ) ) {
423             _gcry_fatal_error(GCRYERR_NO_MEM, NULL );
424         }
425     }
426     return p;
427 }
428
429 void *
430 gcry_xrealloc( void *a, size_t n )
431 {
432     void *p;
433
434     while ( !(p = gcry_realloc( a, n )) ) {
435         if( !outofcore_handler
436             || !outofcore_handler( outofcore_handler_value, n, 2 ) ) {
437             _gcry_fatal_error(GCRYERR_NO_MEM, NULL );
438         }
439     }
440     return p;
441 }
442
443 void *
444 gcry_xmalloc_secure( size_t n )
445 {
446     void *p;
447
448     while ( !(p = gcry_malloc_secure( n )) ) {
449         if( !outofcore_handler
450             || !outofcore_handler( outofcore_handler_value, n, 1 ) ) {
451             _gcry_fatal_error(GCRYERR_NO_MEM,
452                              _("out of core in secure memory"));
453         }
454     }
455     return p;
456 }
457
458 void *
459 gcry_xcalloc( size_t n, size_t m )
460 {
461     void *p = gcry_xmalloc( n*m );
462     memset( p, 0, n*m );
463     return p;
464 }
465
466 void *
467 gcry_xcalloc_secure( size_t n, size_t m )
468 {
469     void *p = gcry_xmalloc_secure( n* m );
470     memset( p, 0, n*m );
471     return p;
472 }
473
474 char *
475 gcry_xstrdup( const char *string )
476 {
477     void *p = gcry_xmalloc( strlen(string)+1 );
478     strcpy( p, string );
479     return p;
480 }
481
482
483 int
484 _gcry_get_debug_flag( unsigned int mask )
485 {
486     return debug_flags & mask;
487 }
488
489 int 
490 _gcry_no_internal_locking (void)
491 {
492   return no_internal_locking;
493 }
494