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