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