Changed xmalloc style calls to proper malloc calls with error returns at
[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_DUMP_RANDOM_STATS:
223       _gcry_random_dump_stats ();
224       break;
225
226     case GCRYCTL_DUMP_MEMORY_STATS:
227       /*m_print_stats("[fixme: prefix]");*/
228       break;
229
230     case GCRYCTL_DUMP_SECMEM_STATS:
231       _gcry_secmem_dump_stats ();
232       break;
233
234     case GCRYCTL_DROP_PRIVS:
235       global_init ();
236       _gcry_secmem_init (0);
237       break;
238
239     case GCRYCTL_DISABLE_SECMEM:
240       global_init ();
241       no_secure_memory = 1;
242       break;    
243
244     case GCRYCTL_INIT_SECMEM:
245       global_init ();
246       _gcry_secmem_init (va_arg (arg_ptr, unsigned int));
247       break;
248
249     case GCRYCTL_TERM_SECMEM:
250       global_init ();
251       _gcry_secmem_term ();
252       break;
253
254     case GCRYCTL_DISABLE_SECMEM_WARN:
255       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
256                                | GCRY_SECMEM_FLAG_NO_WARNING));
257       break;
258
259     case GCRYCTL_SUSPEND_SECMEM_WARN:
260       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
261                                | GCRY_SECMEM_FLAG_SUSPEND_WARNING));
262       break;
263
264     case GCRYCTL_RESUME_SECMEM_WARN:
265       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
266                                & ~GCRY_SECMEM_FLAG_SUSPEND_WARNING));
267       break;
268
269     case GCRYCTL_USE_SECURE_RNDPOOL:
270       global_init ();
271       _gcry_secure_random_alloc (); /* put random number into secure memory */
272       break;
273
274     case GCRYCTL_SET_RANDOM_SEED_FILE:
275       _gcry_set_random_seed_file (va_arg (arg_ptr, const char *));
276       break;
277
278     case GCRYCTL_UPDATE_RANDOM_SEED_FILE:
279       _gcry_update_random_seed_file ();
280       break;
281
282     case GCRYCTL_SET_VERBOSITY:
283       _gcry_set_log_verbosity (va_arg (arg_ptr, int));
284       break;
285
286     case GCRYCTL_SET_DEBUG_FLAGS:
287       debug_flags |= va_arg (arg_ptr, unsigned int);
288       break;
289
290     case GCRYCTL_CLEAR_DEBUG_FLAGS:
291       debug_flags &= ~va_arg (arg_ptr, unsigned int);
292       break;
293
294     case GCRYCTL_DISABLE_INTERNAL_LOCKING:
295       global_init ();
296       break;
297
298     case GCRYCTL_ANY_INITIALIZATION_P:
299       if (any_init_done)
300         err = GPG_ERR_GENERAL;
301       break;
302
303     case GCRYCTL_INITIALIZATION_FINISHED_P:
304       if (init_finished)
305         err = GPG_ERR_GENERAL;
306       break;
307
308     case GCRYCTL_INITIALIZATION_FINISHED:
309       /* This is a hook which should be used by an application after
310          all initialization has been done and right before any threads
311          are started.  It is not really needed but the only way to be
312          really sure that all initialization for thread-safety has
313          been done. */
314         if (! init_finished)
315           {
316             global_init ();
317             /* Do only a basic random initialization, i.e. init the
318                mutexes. */
319             _gcry_random_initialize (0);
320             init_finished = 1;
321           }
322         break;
323
324     case GCRYCTL_SET_THREAD_CBS:
325       err = ath_install (va_arg (arg_ptr, void *), any_init_done);
326       if (! err)
327         global_init ();
328       break;
329
330     case GCRYCTL_FAST_POLL:
331       /* We need to do make sure that the random pool is really
332          initialized so that the poll fucntion is not a NOP. */
333       _gcry_random_initialize (1);
334       _gcry_fast_random_poll (); 
335       break;
336
337     case GCRYCTL_SET_RANDOM_DAEMON_SOCKET:
338       _gcry_set_random_daemon_socket (va_arg (arg_ptr, const char *));
339       break;
340
341     case GCRYCTL_USE_RANDOM_DAEMON:
342       /* We need to do make sure that the random pool is really
343          initialized so that the poll fucntion is not a NOP. */
344       _gcry_random_initialize (1);
345       _gcry_use_random_daemon (!! va_arg (arg_ptr, int));
346       break;
347
348     default:
349       err = GPG_ERR_INV_OP;
350     }
351
352   va_end(arg_ptr);
353   return gcry_error (err);
354 }
355
356 /* Return a pointer to a string containing a description of the error
357    code in the error value ERR.  */
358 const char *
359 gcry_strerror (gcry_error_t err)
360 {
361   return gpg_strerror (err);
362 }
363
364 /* Return a pointer to a string containing a description of the error
365    source in the error value ERR.  */
366 const char *
367 gcry_strsource (gcry_error_t err)
368 {
369   return gpg_strsource (err);
370 }
371
372 /* Retrieve the error code for the system error ERR.  This returns
373    GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped (report
374    this).  */
375 gcry_err_code_t
376 gcry_err_code_from_errno (int err)
377 {
378   return gpg_err_code_from_errno (err);
379 }
380
381
382 /* Retrieve the system error for the error code CODE.  This returns 0
383    if CODE is not a system error code.  */
384 int
385 gcry_err_code_to_errno (gcry_err_code_t code)
386 {
387   return gpg_err_code_from_errno (code);
388 }
389
390   
391 /* Return an error value with the error source SOURCE and the system
392    error ERR.  */
393 gcry_error_t
394 gcry_err_make_from_errno (gpg_err_source_t source, int err)
395 {
396   return gpg_err_make_from_errno (source, err);
397 }
398
399
400 /* Return an error value with the system error ERR.  */
401 gcry_err_code_t
402 gcry_error_from_errno (int err)
403 {
404   return gcry_error (gpg_err_code_from_errno (err));
405 }
406
407 /****************
408  * NOTE: All 5 functions should be set.  */
409 void
410 gcry_set_allocation_handler (gcry_handler_alloc_t new_alloc_func,
411                              gcry_handler_alloc_t new_alloc_secure_func,
412                              gcry_handler_secure_check_t new_is_secure_func,
413                              gcry_handler_realloc_t new_realloc_func,
414                              gcry_handler_free_t new_free_func)
415 {
416   global_init ();
417
418   alloc_func = new_alloc_func;
419   alloc_secure_func = new_alloc_secure_func;
420   is_secure_func = new_is_secure_func;
421   realloc_func = new_realloc_func;
422   free_func = new_free_func;
423 }
424
425
426
427 /****************
428  * Set an optional handler which is called in case the xmalloc functions
429  * ran out of memory.  This handler may do one of these things:
430  *   o free some memory and return true, so that the xmalloc function
431  *     tries again.
432  *   o Do whatever it like and return false, so that the xmalloc functions
433  *     use the default fatal error handler.
434  *   o Terminate the program and don't return.
435  *
436  * The handler function is called with 3 arguments:  The opaque value set with
437  * this function, the requested memory size, and a flag with these bits
438  * currently defined:
439  *      bit 0 set = secure memory has been requested.
440  */
441 void
442 gcry_set_outofcore_handler( int (*f)( void*, size_t, unsigned int ),
443                                                         void *value )
444 {
445     global_init ();
446
447     outofcore_handler = f;
448     outofcore_handler_value = value;
449 }
450
451 gcry_err_code_t
452 _gcry_malloc (size_t n, unsigned int flags, void **mem)
453 {
454   gcry_err_code_t err = 0;
455   void *m;
456
457   if ((flags & GCRY_ALLOC_FLAG_SECURE) && !no_secure_memory)
458     {
459       if (alloc_secure_func)
460         m = (*alloc_secure_func) (n);
461       else
462         m = _gcry_private_malloc_secure (n);
463     }
464   else
465     {
466       if (alloc_func)
467         m = (*alloc_func) (n);
468       else
469         m = _gcry_private_malloc (n);
470     }
471
472   if (!m)
473     {
474       /* Make sure that ERRNO has been set in case a user supplied
475          memory handler didn't it correctly. */
476       if (!errno)
477         errno = ENOMEM;
478       err = gpg_err_code_from_errno (errno);
479     }
480   else
481     *mem = m;
482
483   return err;
484 }
485   
486 void *
487 gcry_malloc (size_t n)
488 {
489   void *mem = NULL;
490
491   _gcry_malloc (n, 0, &mem);
492
493   return mem;
494 }
495
496 void *
497 gcry_malloc_secure (size_t n)
498 {
499   void *mem = NULL;
500
501   _gcry_malloc (n, GCRY_ALLOC_FLAG_SECURE, &mem);
502
503   return mem;
504 }
505
506 int
507 gcry_is_secure (const void *a)
508 {
509   if (no_secure_memory)
510     return 0;
511   if (is_secure_func)
512     return is_secure_func (a) ;
513   return _gcry_private_is_secure (a);
514 }
515
516 void
517 _gcry_check_heap( const void *a )
518 {
519     /* FIXME: implement this*/
520 #if 0
521     if( some_handler )
522         some_handler(a)
523     else
524         _gcry_private_check_heap(a)
525 #endif
526 }
527
528 void *
529 gcry_realloc (void *a, size_t n)
530 {
531   void *p;
532
533   if (realloc_func)
534     p = realloc_func (a, n);
535   else
536     p =  _gcry_private_realloc (a, n);
537   if (!p && !errno)
538     errno = ENOMEM;
539   return p;
540 }
541
542 void
543 gcry_free( void *p )
544 {
545   if( !p )
546     return;
547
548   if (free_func)
549     free_func (p);
550   else
551     _gcry_private_free (p);
552 }
553
554 void *
555 gcry_calloc (size_t n, size_t m)
556 {
557   size_t bytes;
558   void *p;
559
560   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
561                     defined. */
562   if (m && bytes / m != n) 
563     {
564       errno = ENOMEM;
565       return NULL;
566     }
567
568   p = gcry_malloc (bytes);
569   if (p)
570     memset (p, 0, bytes);
571   return p;
572 }
573
574 void *
575 gcry_calloc_secure (size_t n, size_t m)
576 {
577   size_t bytes;
578   void *p;
579
580   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
581                     defined. */
582   if (m && bytes / m != n) 
583     {
584       errno = ENOMEM;
585       return NULL;
586     }
587   
588   p = gcry_malloc_secure (bytes);
589   if (p)
590     memset (p, 0, bytes);
591   return p;
592 }
593
594
595 /* Create and return a copy of the null-terminated string STRING.  If
596    it is contained in secure memory, the copy will be contained in
597    secure memory as well.  In an out-of-memory condition, NULL is
598    returned.  */
599 char *
600 gcry_strdup (const char *string)
601 {
602   char *string_cp = NULL;
603   size_t string_n = 0;
604
605   string_n = strlen (string);
606
607   if (gcry_is_secure (string))
608     string_cp = gcry_malloc_secure (string_n + 1);
609   else
610     string_cp = gcry_malloc (string_n + 1);
611   
612   if (string_cp)
613     strcpy (string_cp, string);
614
615   return string_cp;
616 }
617
618
619 void *
620 gcry_xmalloc( size_t n )
621 {
622     void *p;
623
624     while ( !(p = gcry_malloc( n )) ) {
625         if( !outofcore_handler
626             || !outofcore_handler( outofcore_handler_value, n, 0 ) ) {
627             _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
628         }
629     }
630     return p;
631 }
632
633 void *
634 gcry_xrealloc( void *a, size_t n )
635 {
636     void *p;
637
638     while ( !(p = gcry_realloc( a, n )) ) {
639         if( !outofcore_handler
640             || !outofcore_handler( outofcore_handler_value, n, 2 ) ) {
641             _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
642         }
643     }
644     return p;
645 }
646
647 void *
648 gcry_xmalloc_secure( size_t n )
649 {
650     void *p;
651
652     while ( !(p = gcry_malloc_secure( n )) ) {
653         if( !outofcore_handler
654             || !outofcore_handler( outofcore_handler_value, n, 1 ) ) {
655             _gcry_fatal_error(gpg_err_code_from_errno (errno),
656                              _("out of core in secure memory"));
657         }
658     }
659     return p;
660 }
661
662
663 void *
664 gcry_xcalloc( size_t n, size_t m )
665 {
666   size_t nbytes;
667   void *p;
668
669   nbytes = n * m; 
670   if (m && nbytes / m != n) 
671     {
672       errno = ENOMEM;
673       _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
674     }
675
676   p = gcry_xmalloc ( nbytes );
677   memset ( p, 0, nbytes );
678   return p;
679 }
680
681 void *
682 gcry_xcalloc_secure( size_t n, size_t m )
683 {
684   size_t nbytes;
685   void *p;
686
687   nbytes = n * m; 
688   if (m && nbytes / m != n) 
689     {
690       errno = ENOMEM;
691       _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
692     }
693
694   p = gcry_xmalloc_secure ( nbytes );
695   memset ( p, 0, nbytes );
696   return p;
697 }
698
699 char *
700 gcry_xstrdup (const char *string)
701 {
702   char *p;
703
704   while ( !(p = gcry_strdup (string)) ) 
705     {
706       size_t n = strlen (string);
707       int is_sec = !!gcry_is_secure (string);
708
709       if (!outofcore_handler
710           || !outofcore_handler (outofcore_handler_value, n, is_sec) ) 
711         {
712           _gcry_fatal_error (gpg_err_code_from_errno (errno),
713                              is_sec? _("out of core in secure memory"):NULL);
714         }
715     }
716
717   return p;
718 }
719
720
721 int
722 _gcry_get_debug_flag( unsigned int mask )
723 {
724     return debug_flags & mask;
725 }
726
727
728 \f
729 /* It is often useful to get some feedback of long running operations.
730    This function may be used to register a handler for this. 
731    The callback function CB is used as:
732
733    void cb (void *opaque, const char *what, int printchar,
734            int current, int total);
735
736    Where WHAT is a string identifying the the type of the progress
737    output, PRINTCHAR the character usually printed, CURRENT the amount
738    of progress currently done and TOTAL the expected amount of
739    progress.  A value of 0 for TOTAL indicates that there is no
740    estimation available.
741
742    Defined values for WHAT:
743
744    "need_entropy"  X    0  number-of-bytes-required
745             When running low on entropy
746    "primegen"      '\n'  0 0
747            Prime generated
748                    '!'
749            Need to refresh the prime pool
750                    '<','>'
751            Number of bits adjusted
752                    '^'
753            Looking for a generator
754                    '.'
755            Fermat tests on 10 candidates failed
756                   ':'
757            Restart with a new random value
758                   '+'
759            Rabin Miller test passed          
760    "pk_elg"        '+','-','.','\n'   0  0
761             Only used in debugging mode.
762    "pk_dsa"       
763             Only used in debugging mode.
764 */
765 void
766 gcry_set_progress_handler (void (*cb)(void *,const char*,int, int, int),
767                            void *cb_data)
768 {
769 #if USE_DSA
770   _gcry_register_pk_dsa_progress (cb, cb_data);
771 #endif
772 #if USE_ELGAMAL
773   _gcry_register_pk_elg_progress (cb, cb_data);
774 #endif
775   _gcry_register_primegen_progress (cb, cb_data);
776   _gcry_register_random_progress (cb, cb_data);
777 }