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