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