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