(_gcry_module_release): Don't act if module is NULL.
[libgcrypt.git] / src / global.c
1 /* global.c  -  global control functions
2  * Copyright (C) 1998,1999,2000,2001,2002,2003 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, 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 #include <limits.h>
29 #include <errno.h>
30
31 #include "g10lib.h"
32 #include "cipher.h"
33 #include "stdmem.h" /* our own memory allocator */
34 #include "secmem.h" /* our own secmem allocator */
35 #include "ath.h"
36
37 /****************
38  * flag bits: 0 : general cipher debug
39  *            1 : general MPI debug
40  */
41 static unsigned int debug_flags;
42
43 static gcry_handler_alloc_t alloc_func;
44 static gcry_handler_alloc_t alloc_secure_func;
45 static gcry_handler_secure_check_t is_secure_func;
46 static gcry_handler_realloc_t realloc_func;
47 static gcry_handler_free_t free_func;
48 static gcry_handler_no_mem_t outofcore_handler;
49
50 static void *outofcore_handler_value = NULL;
51 static int no_secure_memory = 0;
52 static int any_init_done;
53
54 /* This is our handmade constructor.  It gets called by any function
55    likely to be called at startup.  The suggested way for an
56    application to make sure that this has been called is by using
57    gcry_check_version. */
58 static void
59 global_init (void)
60 {
61   gcry_err_code_t err = GPG_ERR_NO_ERROR;
62
63   if (any_init_done)
64     return;
65   any_init_done = 1;
66   ath_init ();
67
68   if (! err)
69     _gcry_cipher_init ();
70   if (! err)
71     _gcry_md_init ();
72   if (! err)
73     _gcry_pk_init ();
74
75   if (err)
76     /* FIXME?  */
77     BUG ();
78 }
79
80
81 static const char*
82 parse_version_number( const char *s, int *number )
83 {
84     int val = 0;
85
86     if( *s == '0' && isdigit(s[1]) )
87         return NULL; /* leading zeros are not allowed */
88     for ( ; isdigit(*s); s++ ) {
89         val *= 10;
90         val += *s - '0';
91     }
92     *number = val;
93     return val < 0? NULL : s;
94 }
95
96
97 static const char *
98 parse_version_string( const char *s, int *major, int *minor, int *micro )
99 {
100     s = parse_version_number( s, major );
101     if( !s || *s != '.' )
102         return NULL;
103     s++;
104     s = parse_version_number( s, minor );
105     if( !s || *s != '.' )
106         return NULL;
107     s++;
108     s = parse_version_number( s, micro );
109     if( !s )
110         return NULL;
111     return s; /* patchlevel */
112 }
113
114 /****************
115  * Check that the the version of the library is at minimum the requested one
116  * and return the version string; return NULL if the condition is not
117  * satisfied.  If a NULL is passed to this function, no check is done,
118  * but the version string is simply returned.
119  */
120 const char *
121 gcry_check_version( const char *req_version )
122 {
123     const char *ver = VERSION;
124     int my_major, my_minor, my_micro;
125     int rq_major, rq_minor, rq_micro;
126     const char *my_plvl, *rq_plvl;
127
128     global_init ();
129     if ( !req_version )
130         return ver;
131
132     my_plvl = parse_version_string( ver, &my_major, &my_minor, &my_micro );
133     if ( !my_plvl )
134         return NULL;  /* very strange our own version is bogus */
135     rq_plvl = parse_version_string( req_version, &rq_major, &rq_minor,
136                                                                 &rq_micro );
137     if ( !rq_plvl )
138         return NULL;  /* req version string is invalid */
139
140     if ( my_major > rq_major
141         || (my_major == rq_major && my_minor > rq_minor)
142         || (my_major == rq_major && my_minor == rq_minor
143                                  && my_micro > rq_micro)
144         || (my_major == rq_major && my_minor == rq_minor
145                                  && my_micro == rq_micro
146                                  && strcmp( my_plvl, rq_plvl ) >= 0) ) {
147         return ver;
148     }
149     return NULL;
150 }
151
152 gcry_error_t
153 gcry_control (enum gcry_ctl_cmds cmd, ...)
154 {
155   gcry_err_code_t err = GPG_ERR_NO_ERROR;
156   static int init_finished = 0;
157   va_list arg_ptr;
158   
159   va_start (arg_ptr, cmd);
160   switch (cmd)
161     {
162 #if 0
163     case GCRYCTL_NO_MEM_IS_FATAL:
164       break;
165     case GCRYCTL_SET_FATAL_FNC:
166       break;
167 #endif
168
169     case GCRYCTL_ENABLE_M_GUARD:
170       _gcry_private_enable_m_guard ();
171       break;
172
173     case GCRYCTL_ENABLE_QUICK_RANDOM:
174       _gcry_quick_random_gen (1);
175       break;
176
177     case GCRYCTL_DUMP_RANDOM_STATS:
178       _gcry_random_dump_stats ();
179       break;
180
181     case GCRYCTL_DUMP_MEMORY_STATS:
182       /*m_print_stats("[fixme: prefix]");*/
183       break;
184
185     case GCRYCTL_DUMP_SECMEM_STATS:
186       _gcry_secmem_dump_stats ();
187       break;
188
189     case GCRYCTL_DROP_PRIVS:
190       global_init ();
191       _gcry_secmem_init (0);
192       break;
193
194     case GCRYCTL_DISABLE_SECMEM:
195       global_init ();
196       no_secure_memory = 1;
197       break;    
198
199     case GCRYCTL_INIT_SECMEM:
200       global_init ();
201       _gcry_secmem_init (va_arg (arg_ptr, unsigned int));
202       break;
203
204     case GCRYCTL_TERM_SECMEM:
205       global_init ();
206       _gcry_secmem_term ();
207       break;
208
209     case GCRYCTL_DISABLE_SECMEM_WARN:
210       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
211                                | GCRY_SECMEM_FLAG_NO_WARNING));
212       break;
213
214     case GCRYCTL_SUSPEND_SECMEM_WARN:
215       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
216                                | GCRY_SECMEM_FLAG_SUSPEND_WARNING));
217       break;
218
219     case GCRYCTL_RESUME_SECMEM_WARN:
220       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
221                                & ~GCRY_SECMEM_FLAG_SUSPEND_WARNING));
222       break;
223
224     case GCRYCTL_USE_SECURE_RNDPOOL:
225       global_init ();
226       _gcry_secure_random_alloc (); /* put random number into secure memory */
227       break;
228
229     case GCRYCTL_SET_RANDOM_SEED_FILE:
230       _gcry_set_random_seed_file (va_arg (arg_ptr, const char *));
231       break;
232
233     case GCRYCTL_UPDATE_RANDOM_SEED_FILE:
234       _gcry_update_random_seed_file ();
235       break;
236
237     case GCRYCTL_SET_VERBOSITY:
238       _gcry_set_log_verbosity (va_arg (arg_ptr, int));
239       break;
240
241     case GCRYCTL_SET_DEBUG_FLAGS:
242       debug_flags |= va_arg (arg_ptr, unsigned int);
243       break;
244
245     case GCRYCTL_CLEAR_DEBUG_FLAGS:
246       debug_flags &= ~va_arg (arg_ptr, unsigned int);
247       break;
248
249     case GCRYCTL_DISABLE_INTERNAL_LOCKING:
250       global_init ();
251       /* We waste some bytes by doing it this way.  OTOH this function
252          is not anymore required becuase it is done automagically. */
253       ath_deinit ();
254       break;
255
256     case GCRYCTL_ANY_INITIALIZATION_P:
257       if (any_init_done)
258         err = GPG_ERR_GENERAL;
259       break;
260
261     case GCRYCTL_INITIALIZATION_FINISHED_P:
262       if (init_finished)
263         err = GPG_ERR_GENERAL;
264       break;
265
266     case GCRYCTL_INITIALIZATION_FINISHED:
267       /* This is a hook which should be used by an application after
268          all initialization has been done and right before any threads
269          are started.  It is not really needed but the only way to be
270          really sure that all initialization for thread-safety has
271          been done. */
272         if (! init_finished)
273           {
274             global_init ();
275             _gcry_random_initialize ();
276             init_finished = 1;
277           }
278         break;
279
280     default:
281       err = GPG_ERR_INV_OP;
282     }
283
284   va_end(arg_ptr);
285   return gcry_error (err);
286 }
287
288 /* Return a pointer to a string containing a description of the error
289    code in the error value ERR.  */
290 const char *
291 gcry_strerror (gcry_error_t err)
292 {
293   return gpg_strerror (err);
294 }
295
296 /* Return a pointer to a string containing a description of the error
297    source in the error value ERR.  */
298 const char *
299 gcry_strsource (gcry_error_t err)
300 {
301   return gpg_strsource (err);
302 }
303
304 /* Retrieve the error code for the system error ERR.  This returns
305    GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped (report
306    this).  */
307 gcry_err_code_t
308 gcry_err_code_from_errno (int err)
309 {
310   return gpg_err_code_from_errno (err);
311 }
312
313
314 /* Retrieve the system error for the error code CODE.  This returns 0
315    if CODE is not a system error code.  */
316 int
317 gcry_err_code_to_errno (gcry_err_code_t code)
318 {
319   return gpg_err_code_from_errno (code);
320 }
321
322   
323 /* Return an error value with the error source SOURCE and the system
324    error ERR.  */
325 gcry_error_t
326 gcry_err_make_from_errno (gpg_err_source_t source, int err)
327 {
328   return gpg_err_make_from_errno (source, err);
329 }
330
331
332 /* Return an error value with the system error ERR.  */
333 gcry_err_code_t
334 gcry_error_from_errno (int err)
335 {
336   return gcry_error (gpg_err_code_from_errno (err));
337 }
338
339 /****************
340  * NOTE: All 5 functions should be set.  */
341 void
342 gcry_set_allocation_handler (gcry_handler_alloc_t new_alloc_func,
343                              gcry_handler_alloc_t new_alloc_secure_func,
344                              gcry_handler_secure_check_t new_is_secure_func,
345                              gcry_handler_realloc_t new_realloc_func,
346                              gcry_handler_free_t new_free_func)
347 {
348   global_init ();
349
350   alloc_func = new_alloc_func;
351   alloc_secure_func = new_alloc_secure_func;
352   is_secure_func = new_is_secure_func;
353   realloc_func = new_realloc_func;
354   free_func = new_free_func;
355 }
356
357
358
359 /****************
360  * Set an optional handler which is called in case the xmalloc functions
361  * ran out of memory.  This handler may do one of these things:
362  *   o free some memory and return true, so that the xmalloc function
363  *     tries again.
364  *   o Do whatever it like and return false, so that the xmalloc functions
365  *     use the default fatal error handler.
366  *   o Terminate the program and don't return.
367  *
368  * The handler function is called with 3 arguments:  The opaque value set with
369  * this function, the requested memory size, and a flag with these bits
370  * currently defined:
371  *      bit 0 set = secure memory has been requested.
372  */
373 void
374 gcry_set_outofcore_handler( int (*f)( void*, size_t, unsigned int ),
375                                                         void *value )
376 {
377     global_init ();
378
379     outofcore_handler = f;
380     outofcore_handler_value = value;
381 }
382
383
384
385 void *
386 gcry_malloc( size_t n )
387 {
388     if( alloc_func )
389         return alloc_func( n ) ;
390     return _gcry_private_malloc( n );
391 }
392
393 void *
394 gcry_malloc_secure( size_t n )
395 {
396   if (no_secure_memory)
397     return gcry_malloc (n);
398   if (alloc_secure_func)
399     return alloc_secure_func (n) ;
400   return _gcry_private_malloc_secure (n);
401 }
402
403 int
404 gcry_is_secure( const void *a )
405 {
406   if (no_secure_memory)
407     return 0;
408   if (is_secure_func)
409     return is_secure_func (a) ;
410   return _gcry_private_is_secure (a);
411 }
412
413 void
414 _gcry_check_heap( const void *a )
415 {
416     /* FIXME: implement this*/
417 #if 0
418     if( some_handler )
419         some_handler(a)
420     else
421         _gcry_private_check_heap(a)
422 #endif
423 }
424
425 void *
426 gcry_realloc( void *a, size_t n )
427 {
428     /* FIXME: Make sure that the realloced memory is cleared out */
429
430     if( realloc_func )
431         return realloc_func( a, n ) ;
432     return _gcry_private_realloc( a, n );
433 }
434
435 void
436 gcry_free( void *p )
437 {
438     if( !p )
439         return;
440
441     if( free_func )
442         free_func( p );
443     else
444         _gcry_private_free( p );
445 }
446
447 void *
448 gcry_calloc (size_t n, size_t m)
449 {
450   size_t bytes;
451   void *p;
452
453   bytes = n * m; /* size_t is unsigned so the behavior on overflow is defined. */
454   if (m && bytes / m != n) 
455     {
456       errno = ENOMEM;
457       return NULL;
458     }
459
460   p = gcry_malloc (bytes);
461   if (p)
462     memset (p, 0, bytes);
463   return p;
464 }
465
466 void *
467 gcry_calloc_secure (size_t n, size_t m)
468 {
469   size_t bytes;
470   void *p;
471
472   bytes = n * m; /* size_t is unsigned so the behavior on overflow is defined. */
473   if (m && bytes / m != n) 
474     {
475       errno = ENOMEM;
476       return NULL;
477     }
478   
479   p = gcry_malloc_secure (bytes);
480   if (p)
481     memset (p, 0, bytes);
482   return p;
483 }
484
485
486 char *
487 gcry_strdup( const char *string )
488 {
489     void *p = gcry_malloc( strlen(string)+1 );
490     strcpy( p, string );
491     return p;
492 }
493
494
495 void *
496 gcry_xmalloc( size_t n )
497 {
498     void *p;
499
500     while ( !(p = gcry_malloc( n )) ) {
501         if( !outofcore_handler
502             || !outofcore_handler( outofcore_handler_value, n, 0 ) ) {
503             _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
504         }
505     }
506     return p;
507 }
508
509 void *
510 gcry_xrealloc( void *a, size_t n )
511 {
512     void *p;
513
514     while ( !(p = gcry_realloc( a, n )) ) {
515         if( !outofcore_handler
516             || !outofcore_handler( outofcore_handler_value, n, 2 ) ) {
517             _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
518         }
519     }
520     return p;
521 }
522
523 void *
524 gcry_xmalloc_secure( size_t n )
525 {
526     void *p;
527
528     while ( !(p = gcry_malloc_secure( n )) ) {
529         if( !outofcore_handler
530             || !outofcore_handler( outofcore_handler_value, n, 1 ) ) {
531             _gcry_fatal_error(gpg_err_code_from_errno (errno),
532                              _("out of core in secure memory"));
533         }
534     }
535     return p;
536 }
537
538 void *
539 gcry_xcalloc( size_t n, size_t m )
540 {
541     void *p = gcry_xmalloc( n*m );
542     memset( p, 0, n*m );
543     return p;
544 }
545
546 void *
547 gcry_xcalloc_secure( size_t n, size_t m )
548 {
549     void *p = gcry_xmalloc_secure( n* m );
550     memset( p, 0, n*m );
551     return p;
552 }
553
554 char *
555 gcry_xstrdup( const char *string )
556 {
557     void *p = gcry_xmalloc( strlen(string)+1 );
558     strcpy( p, string );
559     return p;
560 }
561
562
563 int
564 _gcry_get_debug_flag( unsigned int mask )
565 {
566     return debug_flags & mask;
567 }
568
569
570 \f
571 /* It is often useful to get some feedback of long running operations.
572    This function may be used to register a handler for this. 
573    The callback function CB is used as:
574
575    void cb (void *opaque, const char *what, int printchar,
576            int current, int total);
577
578    Where WHAT is a string identifying the the type of the progress
579    output, PRINTCHAR the character usually printed, CURRENT the amount
580    of progress currently done and TOTAL the expected amount of
581    progress.  A value of 0 for TOTAL indicates that there is no
582    estimation available.
583
584    Defined values for WHAT:
585
586    "need_entropy"  X    0  number-of-bytes-required
587             When running low on entropy
588    "primegen"      '\n'  0 0
589            Prime generated
590                    '!'
591            Need to refresh the prime pool
592                    '<','>'
593            Number of bits adjusted
594                    '^'
595            Looking for a generator
596                    '.'
597            Fermat tests on 10 candidates failed
598                   ':'
599            Restart with a new random value
600                   '+'
601            Rabin Miller test passed          
602    "pk_elg"        '+','-','.','\n'   0  0
603             Only used in debugging mode.
604    "pk_dsa"       
605             Only used in debugging mode.
606 */
607 void
608 gcry_set_progress_handler (void (*cb)(void *,const char*,int, int, int),
609                            void *cb_data)
610 {
611 #if USE_DSA
612   _gcry_register_pk_dsa_progress (cb, cb_data);
613 #endif
614 #if USE_ELGAMAL
615   _gcry_register_pk_elg_progress (cb, cb_data);
616 #endif
617   _gcry_register_primegen_progress (cb, cb_data);
618   _gcry_register_random_progress (cb, cb_data);
619 }