2003-09-29 Moritz Schulte <mo@g10code.com>
[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       break;
252
253     case GCRYCTL_ANY_INITIALIZATION_P:
254       if (any_init_done)
255         err = GPG_ERR_GENERAL;
256       break;
257
258     case GCRYCTL_INITIALIZATION_FINISHED_P:
259       if (init_finished)
260         err = GPG_ERR_GENERAL;
261       break;
262
263     case GCRYCTL_INITIALIZATION_FINISHED:
264       /* This is a hook which should be used by an application after
265          all initialization has been done and right before any threads
266          are started.  It is not really needed but the only way to be
267          really sure that all initialization for thread-safety has
268          been done. */
269         if (! init_finished)
270           {
271             global_init ();
272             _gcry_random_initialize ();
273             init_finished = 1;
274           }
275         break;
276
277     default:
278       err = GPG_ERR_INV_OP;
279     }
280
281   va_end(arg_ptr);
282   return gcry_error (err);
283 }
284
285 /* Return a pointer to a string containing a description of the error
286    code in the error value ERR.  */
287 const char *
288 gcry_strerror (gcry_error_t err)
289 {
290   return gpg_strerror (err);
291 }
292
293 /* Return a pointer to a string containing a description of the error
294    source in the error value ERR.  */
295 const char *
296 gcry_strsource (gcry_error_t err)
297 {
298   return gpg_strsource (err);
299 }
300
301 /* Retrieve the error code for the system error ERR.  This returns
302    GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped (report
303    this).  */
304 gcry_err_code_t
305 gcry_err_code_from_errno (int err)
306 {
307   return gpg_err_code_from_errno (err);
308 }
309
310
311 /* Retrieve the system error for the error code CODE.  This returns 0
312    if CODE is not a system error code.  */
313 int
314 gcry_err_code_to_errno (gcry_err_code_t code)
315 {
316   return gpg_err_code_from_errno (code);
317 }
318
319   
320 /* Return an error value with the error source SOURCE and the system
321    error ERR.  */
322 gcry_error_t
323 gcry_err_make_from_errno (gpg_err_source_t source, int err)
324 {
325   return gpg_err_make_from_errno (source, err);
326 }
327
328
329 /* Return an error value with the system error ERR.  */
330 gcry_err_code_t
331 gcry_error_from_errno (int err)
332 {
333   return gcry_error (gpg_err_code_from_errno (err));
334 }
335
336 /****************
337  * NOTE: All 5 functions should be set.  */
338 void
339 gcry_set_allocation_handler (gcry_handler_alloc_t new_alloc_func,
340                              gcry_handler_alloc_t new_alloc_secure_func,
341                              gcry_handler_secure_check_t new_is_secure_func,
342                              gcry_handler_realloc_t new_realloc_func,
343                              gcry_handler_free_t new_free_func)
344 {
345   global_init ();
346
347   alloc_func = new_alloc_func;
348   alloc_secure_func = new_alloc_secure_func;
349   is_secure_func = new_is_secure_func;
350   realloc_func = new_realloc_func;
351   free_func = new_free_func;
352 }
353
354
355
356 /****************
357  * Set an optional handler which is called in case the xmalloc functions
358  * ran out of memory.  This handler may do one of these things:
359  *   o free some memory and return true, so that the xmalloc function
360  *     tries again.
361  *   o Do whatever it like and return false, so that the xmalloc functions
362  *     use the default fatal error handler.
363  *   o Terminate the program and don't return.
364  *
365  * The handler function is called with 3 arguments:  The opaque value set with
366  * this function, the requested memory size, and a flag with these bits
367  * currently defined:
368  *      bit 0 set = secure memory has been requested.
369  */
370 void
371 gcry_set_outofcore_handler( int (*f)( void*, size_t, unsigned int ),
372                                                         void *value )
373 {
374     global_init ();
375
376     outofcore_handler = f;
377     outofcore_handler_value = value;
378 }
379
380 gcry_err_code_t
381 _gcry_malloc (size_t n, unsigned int flags, void **mem)
382 {
383   gcry_err_code_t err = GPG_ERR_NO_ERROR;
384   void *m = NULL;
385
386   if (flags & GCRY_ALLOC_FLAG_SECURE)
387     {
388       if (alloc_secure_func)
389         m = (*alloc_secure_func) (n);
390       else
391         m = _gcry_private_malloc_secure (n);
392     }
393   else
394     {
395       if (alloc_func)
396         m = (*alloc_func) (n);
397       else
398         m = _gcry_private_malloc (n);
399     }
400
401   if (! m)
402     err = gpg_err_code_from_errno (ENOMEM);
403   else
404     *mem = m;
405
406   return err;
407 }
408   
409 void *
410 gcry_malloc (size_t n)
411 {
412   void *mem = NULL;
413
414   _gcry_malloc (n, 0, &mem);
415
416   return mem;
417 }
418
419 void *
420 gcry_malloc_secure (size_t n)
421 {
422   void *mem = NULL;
423
424   _gcry_malloc (n, GCRY_ALLOC_FLAG_SECURE, &mem);
425
426   return mem;
427 }
428
429 int
430 gcry_is_secure (const void *a)
431 {
432   if (no_secure_memory)
433     return 0;
434   if (is_secure_func)
435     return is_secure_func (a) ;
436   return _gcry_private_is_secure (a);
437 }
438
439 void
440 _gcry_check_heap( const void *a )
441 {
442     /* FIXME: implement this*/
443 #if 0
444     if( some_handler )
445         some_handler(a)
446     else
447         _gcry_private_check_heap(a)
448 #endif
449 }
450
451 void *
452 gcry_realloc (void *a, size_t n)
453 {
454   if (realloc_func)
455     return realloc_func (a, n);
456   return _gcry_private_realloc (a, n);
457 }
458
459 void
460 gcry_free( void *p )
461 {
462     if( !p )
463         return;
464
465     if( free_func )
466         free_func( p );
467     else
468         _gcry_private_free( p );
469 }
470
471 void *
472 gcry_calloc (size_t n, size_t m)
473 {
474   size_t bytes;
475   void *p;
476
477   bytes = n * m; /* size_t is unsigned so the behavior on overflow is defined. */
478   if (m && bytes / m != n) 
479     {
480       errno = ENOMEM;
481       return NULL;
482     }
483
484   p = gcry_malloc (bytes);
485   if (p)
486     memset (p, 0, bytes);
487   return p;
488 }
489
490 void *
491 gcry_calloc_secure (size_t n, size_t m)
492 {
493   size_t bytes;
494   void *p;
495
496   bytes = n * m; /* size_t is unsigned so the behavior on overflow is defined. */
497   if (m && bytes / m != n) 
498     {
499       errno = ENOMEM;
500       return NULL;
501     }
502   
503   p = gcry_malloc_secure (bytes);
504   if (p)
505     memset (p, 0, bytes);
506   return p;
507 }
508
509
510 char *
511 gcry_strdup( const char *string )
512 {
513     void *p = gcry_malloc( strlen(string)+1 );
514     strcpy( p, string );
515     return p;
516 }
517
518
519 void *
520 gcry_xmalloc( size_t n )
521 {
522     void *p;
523
524     while ( !(p = gcry_malloc( n )) ) {
525         if( !outofcore_handler
526             || !outofcore_handler( outofcore_handler_value, n, 0 ) ) {
527             _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
528         }
529     }
530     return p;
531 }
532
533 void *
534 gcry_xrealloc( void *a, size_t n )
535 {
536     void *p;
537
538     while ( !(p = gcry_realloc( a, n )) ) {
539         if( !outofcore_handler
540             || !outofcore_handler( outofcore_handler_value, n, 2 ) ) {
541             _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
542         }
543     }
544     return p;
545 }
546
547 void *
548 gcry_xmalloc_secure( size_t n )
549 {
550     void *p;
551
552     while ( !(p = gcry_malloc_secure( n )) ) {
553         if( !outofcore_handler
554             || !outofcore_handler( outofcore_handler_value, n, 1 ) ) {
555             _gcry_fatal_error(gpg_err_code_from_errno (errno),
556                              _("out of core in secure memory"));
557         }
558     }
559     return p;
560 }
561
562 void *
563 gcry_xcalloc( size_t n, size_t m )
564 {
565     void *p = gcry_xmalloc( n*m );
566     memset( p, 0, n*m );
567     return p;
568 }
569
570 void *
571 gcry_xcalloc_secure( size_t n, size_t m )
572 {
573     void *p = gcry_xmalloc_secure( n* m );
574     memset( p, 0, n*m );
575     return p;
576 }
577
578 char *
579 gcry_xstrdup( const char *string )
580 {
581     void *p = gcry_xmalloc( strlen(string)+1 );
582     strcpy( p, string );
583     return p;
584 }
585
586
587 int
588 _gcry_get_debug_flag( unsigned int mask )
589 {
590     return debug_flags & mask;
591 }
592
593
594 \f
595 /* It is often useful to get some feedback of long running operations.
596    This function may be used to register a handler for this. 
597    The callback function CB is used as:
598
599    void cb (void *opaque, const char *what, int printchar,
600            int current, int total);
601
602    Where WHAT is a string identifying the the type of the progress
603    output, PRINTCHAR the character usually printed, CURRENT the amount
604    of progress currently done and TOTAL the expected amount of
605    progress.  A value of 0 for TOTAL indicates that there is no
606    estimation available.
607
608    Defined values for WHAT:
609
610    "need_entropy"  X    0  number-of-bytes-required
611             When running low on entropy
612    "primegen"      '\n'  0 0
613            Prime generated
614                    '!'
615            Need to refresh the prime pool
616                    '<','>'
617            Number of bits adjusted
618                    '^'
619            Looking for a generator
620                    '.'
621            Fermat tests on 10 candidates failed
622                   ':'
623            Restart with a new random value
624                   '+'
625            Rabin Miller test passed          
626    "pk_elg"        '+','-','.','\n'   0  0
627             Only used in debugging mode.
628    "pk_dsa"       
629             Only used in debugging mode.
630 */
631 void
632 gcry_set_progress_handler (void (*cb)(void *,const char*,int, int, int),
633                            void *cb_data)
634 {
635 #if USE_DSA
636   _gcry_register_pk_dsa_progress (cb, cb_data);
637 #endif
638 #if USE_ELGAMAL
639   _gcry_register_pk_elg_progress (cb, cb_data);
640 #endif
641   _gcry_register_primegen_progress (cb, cb_data);
642   _gcry_register_random_progress (cb, cb_data);
643 }