Add support for setting the EGD socket.
[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_enable_quick_random_gen ();
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_RNDEGD_SOCKET:
347 #if USE_RNDEGD
348       err = _gcry_rndegd_set_socket_name (va_arg (arg_ptr, const char *));
349 #else
350       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
351 #endif
352       break;
353
354     case GCRYCTL_SET_RANDOM_DAEMON_SOCKET:
355       _gcry_set_random_daemon_socket (va_arg (arg_ptr, const char *));
356       break;
357
358     case GCRYCTL_USE_RANDOM_DAEMON:
359       /* We need to do make sure that the random pool is really
360          initialized so that the poll function is not a NOP. */
361       _gcry_random_initialize (1);
362       _gcry_use_random_daemon (!! va_arg (arg_ptr, int));
363       break;
364
365       /* This command dumps information pertaining to the
366          configuration of libgcrypt to the logging stream.  It may be
367          used before the intialization has been finished but not
368          before a gcry_version_check. */
369     case GCRYCTL_DUMP_CONFIG:
370       log_info ("version:%s:\n", VERSION);
371       log_info ("mpi-asm:%s:\n", _gcry_mpi_get_hw_config ());
372       log_info ("rnd-mod:"
373 #if USE_RNDEGD
374                 "egd:"
375 #endif
376 #if USE_RNDLINUX
377                 "linux:"
378 #endif
379 #if USE_RNDUNIX
380                 "unix:"
381 #endif
382 #if USE_RNDW32
383                 "w32:"
384 #endif
385                 "\n");
386       break;
387
388     default:
389       err = GPG_ERR_INV_OP;
390     }
391
392   va_end(arg_ptr);
393   return gcry_error (err);
394 }
395
396 /* Return a pointer to a string containing a description of the error
397    code in the error value ERR.  */
398 const char *
399 gcry_strerror (gcry_error_t err)
400 {
401   return gpg_strerror (err);
402 }
403
404 /* Return a pointer to a string containing a description of the error
405    source in the error value ERR.  */
406 const char *
407 gcry_strsource (gcry_error_t err)
408 {
409   return gpg_strsource (err);
410 }
411
412 /* Retrieve the error code for the system error ERR.  This returns
413    GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped (report
414    this).  */
415 gcry_err_code_t
416 gcry_err_code_from_errno (int err)
417 {
418   return gpg_err_code_from_errno (err);
419 }
420
421
422 /* Retrieve the system error for the error code CODE.  This returns 0
423    if CODE is not a system error code.  */
424 int
425 gcry_err_code_to_errno (gcry_err_code_t code)
426 {
427   return gpg_err_code_from_errno (code);
428 }
429
430   
431 /* Return an error value with the error source SOURCE and the system
432    error ERR.  */
433 gcry_error_t
434 gcry_err_make_from_errno (gpg_err_source_t source, int err)
435 {
436   return gpg_err_make_from_errno (source, err);
437 }
438
439
440 /* Return an error value with the system error ERR.  */
441 gcry_err_code_t
442 gcry_error_from_errno (int err)
443 {
444   return gcry_error (gpg_err_code_from_errno (err));
445 }
446
447 /****************
448  * NOTE: All 5 functions should be set.  */
449 void
450 gcry_set_allocation_handler (gcry_handler_alloc_t new_alloc_func,
451                              gcry_handler_alloc_t new_alloc_secure_func,
452                              gcry_handler_secure_check_t new_is_secure_func,
453                              gcry_handler_realloc_t new_realloc_func,
454                              gcry_handler_free_t new_free_func)
455 {
456   global_init ();
457
458   alloc_func = new_alloc_func;
459   alloc_secure_func = new_alloc_secure_func;
460   is_secure_func = new_is_secure_func;
461   realloc_func = new_realloc_func;
462   free_func = new_free_func;
463 }
464
465
466
467 /****************
468  * Set an optional handler which is called in case the xmalloc functions
469  * ran out of memory.  This handler may do one of these things:
470  *   o free some memory and return true, so that the xmalloc function
471  *     tries again.
472  *   o Do whatever it like and return false, so that the xmalloc functions
473  *     use the default fatal error handler.
474  *   o Terminate the program and don't return.
475  *
476  * The handler function is called with 3 arguments:  The opaque value set with
477  * this function, the requested memory size, and a flag with these bits
478  * currently defined:
479  *      bit 0 set = secure memory has been requested.
480  */
481 void
482 gcry_set_outofcore_handler( int (*f)( void*, size_t, unsigned int ),
483                                                         void *value )
484 {
485     global_init ();
486
487     outofcore_handler = f;
488     outofcore_handler_value = value;
489 }
490
491 gcry_err_code_t
492 _gcry_malloc (size_t n, unsigned int flags, void **mem)
493 {
494   gcry_err_code_t err = 0;
495   void *m;
496
497   if ((flags & GCRY_ALLOC_FLAG_SECURE) && !no_secure_memory)
498     {
499       if (alloc_secure_func)
500         m = (*alloc_secure_func) (n);
501       else
502         m = _gcry_private_malloc_secure (n);
503     }
504   else
505     {
506       if (alloc_func)
507         m = (*alloc_func) (n);
508       else
509         m = _gcry_private_malloc (n);
510     }
511
512   if (!m)
513     {
514       /* Make sure that ERRNO has been set in case a user supplied
515          memory handler didn't it correctly. */
516       if (!errno)
517         errno = ENOMEM;
518       err = gpg_err_code_from_errno (errno);
519     }
520   else
521     *mem = m;
522
523   return err;
524 }
525   
526 void *
527 gcry_malloc (size_t n)
528 {
529   void *mem = NULL;
530
531   _gcry_malloc (n, 0, &mem);
532
533   return mem;
534 }
535
536 void *
537 gcry_malloc_secure (size_t n)
538 {
539   void *mem = NULL;
540
541   _gcry_malloc (n, GCRY_ALLOC_FLAG_SECURE, &mem);
542
543   return mem;
544 }
545
546 int
547 gcry_is_secure (const void *a)
548 {
549   if (no_secure_memory)
550     return 0;
551   if (is_secure_func)
552     return is_secure_func (a) ;
553   return _gcry_private_is_secure (a);
554 }
555
556 void
557 _gcry_check_heap( const void *a )
558 {
559   (void)a;
560   
561     /* FIXME: implement this*/
562 #if 0
563     if( some_handler )
564         some_handler(a)
565     else
566         _gcry_private_check_heap(a)
567 #endif
568 }
569
570 void *
571 gcry_realloc (void *a, size_t n)
572 {
573   void *p;
574
575   if (realloc_func)
576     p = realloc_func (a, n);
577   else
578     p =  _gcry_private_realloc (a, n);
579   if (!p && !errno)
580     errno = ENOMEM;
581   return p;
582 }
583
584 void
585 gcry_free( void *p )
586 {
587   if( !p )
588     return;
589
590   if (free_func)
591     free_func (p);
592   else
593     _gcry_private_free (p);
594 }
595
596 void *
597 gcry_calloc (size_t n, size_t m)
598 {
599   size_t bytes;
600   void *p;
601
602   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
603                     defined. */
604   if (m && bytes / m != n) 
605     {
606       errno = ENOMEM;
607       return NULL;
608     }
609
610   p = gcry_malloc (bytes);
611   if (p)
612     memset (p, 0, bytes);
613   return p;
614 }
615
616 void *
617 gcry_calloc_secure (size_t n, size_t m)
618 {
619   size_t bytes;
620   void *p;
621
622   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
623                     defined. */
624   if (m && bytes / m != n) 
625     {
626       errno = ENOMEM;
627       return NULL;
628     }
629   
630   p = gcry_malloc_secure (bytes);
631   if (p)
632     memset (p, 0, bytes);
633   return p;
634 }
635
636
637 /* Create and return a copy of the null-terminated string STRING.  If
638    it is contained in secure memory, the copy will be contained in
639    secure memory as well.  In an out-of-memory condition, NULL is
640    returned.  */
641 char *
642 gcry_strdup (const char *string)
643 {
644   char *string_cp = NULL;
645   size_t string_n = 0;
646
647   string_n = strlen (string);
648
649   if (gcry_is_secure (string))
650     string_cp = gcry_malloc_secure (string_n + 1);
651   else
652     string_cp = gcry_malloc (string_n + 1);
653   
654   if (string_cp)
655     strcpy (string_cp, string);
656
657   return string_cp;
658 }
659
660
661 void *
662 gcry_xmalloc( size_t n )
663 {
664     void *p;
665
666     while ( !(p = gcry_malloc( n )) ) {
667         if( !outofcore_handler
668             || !outofcore_handler( outofcore_handler_value, n, 0 ) ) {
669             _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
670         }
671     }
672     return p;
673 }
674
675 void *
676 gcry_xrealloc( void *a, size_t n )
677 {
678     void *p;
679
680     while ( !(p = gcry_realloc( a, n )) ) {
681         if( !outofcore_handler
682             || !outofcore_handler( outofcore_handler_value, n,
683                                    gcry_is_secure(a)? 3:2 ) ) {
684             _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
685         }
686     }
687     return p;
688 }
689
690 void *
691 gcry_xmalloc_secure( size_t n )
692 {
693     void *p;
694
695     while ( !(p = gcry_malloc_secure( n )) ) {
696         if( !outofcore_handler
697             || !outofcore_handler( outofcore_handler_value, n, 1 ) ) {
698             _gcry_fatal_error(gpg_err_code_from_errno (errno),
699                              _("out of core in secure memory"));
700         }
701     }
702     return p;
703 }
704
705
706 void *
707 gcry_xcalloc( size_t n, size_t m )
708 {
709   size_t nbytes;
710   void *p;
711
712   nbytes = n * m; 
713   if (m && nbytes / m != n) 
714     {
715       errno = ENOMEM;
716       _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
717     }
718
719   p = gcry_xmalloc ( nbytes );
720   memset ( p, 0, nbytes );
721   return p;
722 }
723
724 void *
725 gcry_xcalloc_secure( size_t n, size_t m )
726 {
727   size_t nbytes;
728   void *p;
729
730   nbytes = n * m; 
731   if (m && nbytes / m != n) 
732     {
733       errno = ENOMEM;
734       _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
735     }
736
737   p = gcry_xmalloc_secure ( nbytes );
738   memset ( p, 0, nbytes );
739   return p;
740 }
741
742 char *
743 gcry_xstrdup (const char *string)
744 {
745   char *p;
746
747   while ( !(p = gcry_strdup (string)) ) 
748     {
749       size_t n = strlen (string);
750       int is_sec = !!gcry_is_secure (string);
751
752       if (!outofcore_handler
753           || !outofcore_handler (outofcore_handler_value, n, is_sec) ) 
754         {
755           _gcry_fatal_error (gpg_err_code_from_errno (errno),
756                              is_sec? _("out of core in secure memory"):NULL);
757         }
758     }
759
760   return p;
761 }
762
763
764 int
765 _gcry_get_debug_flag( unsigned int mask )
766 {
767     return debug_flags & mask;
768 }
769
770
771 \f
772 /* It is often useful to get some feedback of long running operations.
773    This function may be used to register a handler for this. 
774    The callback function CB is used as:
775
776    void cb (void *opaque, const char *what, int printchar,
777            int current, int total);
778
779    Where WHAT is a string identifying the the type of the progress
780    output, PRINTCHAR the character usually printed, CURRENT the amount
781    of progress currently done and TOTAL the expected amount of
782    progress.  A value of 0 for TOTAL indicates that there is no
783    estimation available.
784
785    Defined values for WHAT:
786
787    "need_entropy"  X    0  number-of-bytes-required
788             When running low on entropy
789    "primegen"      '\n'  0 0
790            Prime generated
791                    '!'
792            Need to refresh the prime pool
793                    '<','>'
794            Number of bits adjusted
795                    '^'
796            Looking for a generator
797                    '.'
798            Fermat tests on 10 candidates failed
799                   ':'
800            Restart with a new random value
801                   '+'
802            Rabin Miller test passed          
803    "pk_elg"        '+','-','.','\n'   0  0
804             Only used in debugging mode.
805    "pk_dsa"       
806             Only used in debugging mode.
807 */
808 void
809 gcry_set_progress_handler (void (*cb)(void *,const char*,int, int, int),
810                            void *cb_data)
811 {
812 #if USE_DSA
813   _gcry_register_pk_dsa_progress (cb, cb_data);
814 #endif
815 #if USE_ELGAMAL
816   _gcry_register_pk_elg_progress (cb, cb_data);
817 #endif
818   _gcry_register_primegen_progress (cb, cb_data);
819   _gcry_register_random_progress (cb, cb_data);
820 }