35609238c82a8065dce104c57803c84fabe41e97
[libgcrypt.git] / src / global.c
1 /* global.c  -  global control functions
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
3  *               2004, 2005  Free Software Foundation, Inc.
4  *
5  * This file is part of Libgcrypt.
6  *
7  * Libgcrypt is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser general Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * Libgcrypt is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <stdarg.h>
27 #include <ctype.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
67   err = ath_init ();
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     case GCRYCTL_ENABLE_M_GUARD:
163       _gcry_private_enable_m_guard ();
164       break;
165
166     case GCRYCTL_ENABLE_QUICK_RANDOM:
167       _gcry_quick_random_gen (1);
168       break;
169
170     case GCRYCTL_DUMP_RANDOM_STATS:
171       _gcry_random_dump_stats ();
172       break;
173
174     case GCRYCTL_DUMP_MEMORY_STATS:
175       /*m_print_stats("[fixme: prefix]");*/
176       break;
177
178     case GCRYCTL_DUMP_SECMEM_STATS:
179       _gcry_secmem_dump_stats ();
180       break;
181
182     case GCRYCTL_DROP_PRIVS:
183       global_init ();
184       _gcry_secmem_init (0);
185       break;
186
187     case GCRYCTL_DISABLE_SECMEM:
188       global_init ();
189       no_secure_memory = 1;
190       break;    
191
192     case GCRYCTL_INIT_SECMEM:
193       global_init ();
194       _gcry_secmem_init (va_arg (arg_ptr, unsigned int));
195       break;
196
197     case GCRYCTL_TERM_SECMEM:
198       global_init ();
199       _gcry_secmem_term ();
200       break;
201
202     case GCRYCTL_DISABLE_SECMEM_WARN:
203       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
204                                | GCRY_SECMEM_FLAG_NO_WARNING));
205       break;
206
207     case GCRYCTL_SUSPEND_SECMEM_WARN:
208       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
209                                | GCRY_SECMEM_FLAG_SUSPEND_WARNING));
210       break;
211
212     case GCRYCTL_RESUME_SECMEM_WARN:
213       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
214                                & ~GCRY_SECMEM_FLAG_SUSPEND_WARNING));
215       break;
216
217     case GCRYCTL_USE_SECURE_RNDPOOL:
218       global_init ();
219       _gcry_secure_random_alloc (); /* put random number into secure memory */
220       break;
221
222     case GCRYCTL_SET_RANDOM_SEED_FILE:
223       _gcry_set_random_seed_file (va_arg (arg_ptr, const char *));
224       break;
225
226     case GCRYCTL_UPDATE_RANDOM_SEED_FILE:
227       _gcry_update_random_seed_file ();
228       break;
229
230     case GCRYCTL_SET_VERBOSITY:
231       _gcry_set_log_verbosity (va_arg (arg_ptr, int));
232       break;
233
234     case GCRYCTL_SET_DEBUG_FLAGS:
235       debug_flags |= va_arg (arg_ptr, unsigned int);
236       break;
237
238     case GCRYCTL_CLEAR_DEBUG_FLAGS:
239       debug_flags &= ~va_arg (arg_ptr, unsigned int);
240       break;
241
242     case GCRYCTL_DISABLE_INTERNAL_LOCKING:
243       global_init ();
244       break;
245
246     case GCRYCTL_ANY_INITIALIZATION_P:
247       if (any_init_done)
248         err = GPG_ERR_GENERAL;
249       break;
250
251     case GCRYCTL_INITIALIZATION_FINISHED_P:
252       if (init_finished)
253         err = GPG_ERR_GENERAL;
254       break;
255
256     case GCRYCTL_INITIALIZATION_FINISHED:
257       /* This is a hook which should be used by an application after
258          all initialization has been done and right before any threads
259          are started.  It is not really needed but the only way to be
260          really sure that all initialization for thread-safety has
261          been done. */
262         if (! init_finished)
263           {
264             global_init ();
265             /* Do only a basic ranom initialization, i.e. inti the
266                mutexes. */
267             _gcry_random_initialize (0);
268             init_finished = 1;
269           }
270         break;
271
272     case GCRYCTL_SET_THREAD_CBS:
273       err = ath_install (va_arg (arg_ptr, void *), any_init_done);
274       break;
275
276     case GCRYCTL_FAST_POLL:
277       /* We need to do make sure that the random pool is really
278          initialized so that the poll fucntion is not a NOP. */
279       _gcry_random_initialize (1);
280       _gcry_fast_random_poll (); 
281       break;
282
283     default:
284       err = GPG_ERR_INV_OP;
285     }
286
287   va_end(arg_ptr);
288   return gcry_error (err);
289 }
290
291 /* Return a pointer to a string containing a description of the error
292    code in the error value ERR.  */
293 const char *
294 gcry_strerror (gcry_error_t err)
295 {
296   return gpg_strerror (err);
297 }
298
299 /* Return a pointer to a string containing a description of the error
300    source in the error value ERR.  */
301 const char *
302 gcry_strsource (gcry_error_t err)
303 {
304   return gpg_strsource (err);
305 }
306
307 /* Retrieve the error code for the system error ERR.  This returns
308    GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped (report
309    this).  */
310 gcry_err_code_t
311 gcry_err_code_from_errno (int err)
312 {
313   return gpg_err_code_from_errno (err);
314 }
315
316
317 /* Retrieve the system error for the error code CODE.  This returns 0
318    if CODE is not a system error code.  */
319 int
320 gcry_err_code_to_errno (gcry_err_code_t code)
321 {
322   return gpg_err_code_from_errno (code);
323 }
324
325   
326 /* Return an error value with the error source SOURCE and the system
327    error ERR.  */
328 gcry_error_t
329 gcry_err_make_from_errno (gpg_err_source_t source, int err)
330 {
331   return gpg_err_make_from_errno (source, err);
332 }
333
334
335 /* Return an error value with the system error ERR.  */
336 gcry_err_code_t
337 gcry_error_from_errno (int err)
338 {
339   return gcry_error (gpg_err_code_from_errno (err));
340 }
341
342 /****************
343  * NOTE: All 5 functions should be set.  */
344 void
345 gcry_set_allocation_handler (gcry_handler_alloc_t new_alloc_func,
346                              gcry_handler_alloc_t new_alloc_secure_func,
347                              gcry_handler_secure_check_t new_is_secure_func,
348                              gcry_handler_realloc_t new_realloc_func,
349                              gcry_handler_free_t new_free_func)
350 {
351   global_init ();
352
353   alloc_func = new_alloc_func;
354   alloc_secure_func = new_alloc_secure_func;
355   is_secure_func = new_is_secure_func;
356   realloc_func = new_realloc_func;
357   free_func = new_free_func;
358 }
359
360
361
362 /****************
363  * Set an optional handler which is called in case the xmalloc functions
364  * ran out of memory.  This handler may do one of these things:
365  *   o free some memory and return true, so that the xmalloc function
366  *     tries again.
367  *   o Do whatever it like and return false, so that the xmalloc functions
368  *     use the default fatal error handler.
369  *   o Terminate the program and don't return.
370  *
371  * The handler function is called with 3 arguments:  The opaque value set with
372  * this function, the requested memory size, and a flag with these bits
373  * currently defined:
374  *      bit 0 set = secure memory has been requested.
375  */
376 void
377 gcry_set_outofcore_handler( int (*f)( void*, size_t, unsigned int ),
378                                                         void *value )
379 {
380     global_init ();
381
382     outofcore_handler = f;
383     outofcore_handler_value = value;
384 }
385
386 gcry_err_code_t
387 _gcry_malloc (size_t n, unsigned int flags, void **mem)
388 {
389   gcry_err_code_t err = 0;
390   void *m;
391
392   if ((flags & GCRY_ALLOC_FLAG_SECURE) && !no_secure_memory)
393     {
394       if (alloc_secure_func)
395         m = (*alloc_secure_func) (n);
396       else
397         m = _gcry_private_malloc_secure (n);
398     }
399   else
400     {
401       if (alloc_func)
402         m = (*alloc_func) (n);
403       else
404         m = _gcry_private_malloc (n);
405     }
406
407   if (!m)
408     {
409       /* Make sure that ERRNO has been set in case a user supplied
410          memory handler didn't it correctly. */
411       if (!errno)
412         errno = ENOMEM;
413       err = gpg_err_code_from_errno (errno);
414     }
415   else
416     *mem = m;
417
418   return err;
419 }
420   
421 void *
422 gcry_malloc (size_t n)
423 {
424   void *mem = NULL;
425
426   _gcry_malloc (n, 0, &mem);
427
428   return mem;
429 }
430
431 void *
432 gcry_malloc_secure (size_t n)
433 {
434   void *mem = NULL;
435
436   _gcry_malloc (n, GCRY_ALLOC_FLAG_SECURE, &mem);
437
438   return mem;
439 }
440
441 int
442 gcry_is_secure (const void *a)
443 {
444   if (no_secure_memory)
445     return 0;
446   if (is_secure_func)
447     return is_secure_func (a) ;
448   return _gcry_private_is_secure (a);
449 }
450
451 void
452 _gcry_check_heap( const void *a )
453 {
454     /* FIXME: implement this*/
455 #if 0
456     if( some_handler )
457         some_handler(a)
458     else
459         _gcry_private_check_heap(a)
460 #endif
461 }
462
463 void *
464 gcry_realloc (void *a, size_t n)
465 {
466   void *p;
467
468   if (realloc_func)
469     p = realloc_func (a, n);
470   else
471     p =  _gcry_private_realloc (a, n);
472   if (!p && !errno)
473     errno = ENOMEM;
474   return p;
475 }
476
477 void
478 gcry_free( void *p )
479 {
480   if( !p )
481     return;
482
483   if (free_func)
484     free_func (p);
485   else
486     _gcry_private_free (p);
487 }
488
489 void *
490 gcry_calloc (size_t n, size_t m)
491 {
492   size_t bytes;
493   void *p;
494
495   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
496                     defined. */
497   if (m && bytes / m != n) 
498     {
499       errno = ENOMEM;
500       return NULL;
501     }
502
503   p = gcry_malloc (bytes);
504   if (p)
505     memset (p, 0, bytes);
506   return p;
507 }
508
509 void *
510 gcry_calloc_secure (size_t n, size_t m)
511 {
512   size_t bytes;
513   void *p;
514
515   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
516                     defined. */
517   if (m && bytes / m != n) 
518     {
519       errno = ENOMEM;
520       return NULL;
521     }
522   
523   p = gcry_malloc_secure (bytes);
524   if (p)
525     memset (p, 0, bytes);
526   return p;
527 }
528
529
530 /* Create and return a copy of the null-terminated string STRING.  If
531    it is contained in secure memory, the copy will be contained in
532    secure memory as well.  In an out-of-memory condition, NULL is
533    returned.  */
534 char *
535 gcry_strdup (const char *string)
536 {
537   char *string_cp = NULL;
538   size_t string_n = 0;
539
540   string_n = strlen (string);
541
542   if (gcry_is_secure (string))
543     string_cp = gcry_malloc_secure (string_n + 1);
544   else
545     string_cp = gcry_malloc (string_n + 1);
546   
547   if (string_cp)
548     strcpy (string_cp, string);
549
550   return string_cp;
551 }
552
553
554 void *
555 gcry_xmalloc( size_t n )
556 {
557     void *p;
558
559     while ( !(p = gcry_malloc( n )) ) {
560         if( !outofcore_handler
561             || !outofcore_handler( outofcore_handler_value, n, 0 ) ) {
562             _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
563         }
564     }
565     return p;
566 }
567
568 void *
569 gcry_xrealloc( void *a, size_t n )
570 {
571     void *p;
572
573     while ( !(p = gcry_realloc( a, n )) ) {
574         if( !outofcore_handler
575             || !outofcore_handler( outofcore_handler_value, n, 2 ) ) {
576             _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
577         }
578     }
579     return p;
580 }
581
582 void *
583 gcry_xmalloc_secure( size_t n )
584 {
585     void *p;
586
587     while ( !(p = gcry_malloc_secure( n )) ) {
588         if( !outofcore_handler
589             || !outofcore_handler( outofcore_handler_value, n, 1 ) ) {
590             _gcry_fatal_error(gpg_err_code_from_errno (errno),
591                              _("out of core in secure memory"));
592         }
593     }
594     return p;
595 }
596
597 void *
598 gcry_xcalloc( size_t n, size_t m )
599 {
600     void *p = gcry_xmalloc( n*m );
601     memset( p, 0, n*m );
602     return p;
603 }
604
605 void *
606 gcry_xcalloc_secure( size_t n, size_t m )
607 {
608     void *p = gcry_xmalloc_secure( n* m );
609     memset( p, 0, n*m );
610     return p;
611 }
612
613 char *
614 gcry_xstrdup (const char *string)
615 {
616   char *p;
617
618   while ( !(p = gcry_strdup (string)) ) 
619     {
620       size_t n = strlen (string);
621       int is_sec = !!gcry_is_secure (string);
622
623       if (!outofcore_handler
624           || !outofcore_handler (outofcore_handler_value, n, is_sec) ) 
625         {
626           _gcry_fatal_error (gpg_err_code_from_errno (errno),
627                              is_sec? _("out of core in secure memory"):NULL);
628         }
629     }
630
631   strcpy( p, string );
632   return p;
633 }
634
635
636 int
637 _gcry_get_debug_flag( unsigned int mask )
638 {
639     return debug_flags & mask;
640 }
641
642
643 \f
644 /* It is often useful to get some feedback of long running operations.
645    This function may be used to register a handler for this. 
646    The callback function CB is used as:
647
648    void cb (void *opaque, const char *what, int printchar,
649            int current, int total);
650
651    Where WHAT is a string identifying the the type of the progress
652    output, PRINTCHAR the character usually printed, CURRENT the amount
653    of progress currently done and TOTAL the expected amount of
654    progress.  A value of 0 for TOTAL indicates that there is no
655    estimation available.
656
657    Defined values for WHAT:
658
659    "need_entropy"  X    0  number-of-bytes-required
660             When running low on entropy
661    "primegen"      '\n'  0 0
662            Prime generated
663                    '!'
664            Need to refresh the prime pool
665                    '<','>'
666            Number of bits adjusted
667                    '^'
668            Looking for a generator
669                    '.'
670            Fermat tests on 10 candidates failed
671                   ':'
672            Restart with a new random value
673                   '+'
674            Rabin Miller test passed          
675    "pk_elg"        '+','-','.','\n'   0  0
676             Only used in debugging mode.
677    "pk_dsa"       
678             Only used in debugging mode.
679 */
680 void
681 gcry_set_progress_handler (void (*cb)(void *,const char*,int, int, int),
682                            void *cb_data)
683 {
684 #if USE_DSA
685   _gcry_register_pk_dsa_progress (cb, cb_data);
686 #endif
687 #if USE_ELGAMAL
688   _gcry_register_pk_elg_progress (cb, cb_data);
689 #endif
690   _gcry_register_primegen_progress (cb, cb_data);
691   _gcry_register_random_progress (cb, cb_data);
692 }