Replace assert calls by a new gcry_assert at most places.
[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       _gcry_update_random_seed_file ();
353       break;
354
355     case GCRYCTL_SET_VERBOSITY:
356       _gcry_set_log_verbosity (va_arg (arg_ptr, int));
357       break;
358
359     case GCRYCTL_SET_DEBUG_FLAGS:
360       debug_flags |= va_arg (arg_ptr, unsigned int);
361       break;
362
363     case GCRYCTL_CLEAR_DEBUG_FLAGS:
364       debug_flags &= ~va_arg (arg_ptr, unsigned int);
365       break;
366
367     case GCRYCTL_DISABLE_INTERNAL_LOCKING:
368       /* Not used anymore.  */
369       global_init ();
370       break;
371
372     case GCRYCTL_ANY_INITIALIZATION_P:
373       if (any_init_done)
374         err = GPG_ERR_GENERAL;
375       break;
376
377     case GCRYCTL_INITIALIZATION_FINISHED_P:
378       if (init_finished)
379         err = GPG_ERR_GENERAL; /* Yes.  */
380       break;
381
382     case GCRYCTL_INITIALIZATION_FINISHED:
383       /* This is a hook which should be used by an application after
384          all initialization has been done and right before any threads
385          are started.  It is not really needed but the only way to be
386          really sure that all initialization for thread-safety has
387          been done. */
388       if (! init_finished)
389         {
390           global_init ();
391           /* Do only a basic random initialization, i.e. init the
392              mutexes. */
393           _gcry_random_initialize (0);
394           init_finished = 1;
395         }
396       break;
397
398     case GCRYCTL_SET_THREAD_CBS:
399       err = ath_install (va_arg (arg_ptr, void *), any_init_done);
400       if (! err)
401         global_init ();
402       break;
403
404     case GCRYCTL_FAST_POLL:
405       /* We need to do make sure that the random pool is really
406          initialized so that the poll function is not a NOP. */
407       _gcry_random_initialize (1);
408       _gcry_fast_random_poll (); 
409       break;
410
411     case GCRYCTL_SET_RNDEGD_SOCKET:
412 #if USE_RNDEGD
413       err = _gcry_rndegd_set_socket_name (va_arg (arg_ptr, const char *));
414 #else
415       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
416 #endif
417       break;
418
419     case GCRYCTL_SET_RANDOM_DAEMON_SOCKET:
420       _gcry_set_random_daemon_socket (va_arg (arg_ptr, const char *));
421       break;
422
423     case GCRYCTL_USE_RANDOM_DAEMON:
424       /* We need to do make sure that the random pool is really
425          initialized so that the poll function is not a NOP. */
426       _gcry_random_initialize (1);
427       _gcry_use_random_daemon (!! va_arg (arg_ptr, int));
428       break;
429       
430       /* This command dumps information pertaining to the
431          configuration of libgcrypt to the given stream.  It may be
432          used before the intialization has been finished but not
433          before a gcry_version_check. */
434     case GCRYCTL_PRINT_CONFIG:
435       {
436         FILE *fp = va_arg (arg_ptr, FILE *);
437         print_config (fp?fprintf:_gcry_log_info_with_dummy_fp, fp);
438       }
439       break;
440
441     case GCRYCTL_OPERATIONAL_P:
442       /* Returns true if the library is in an operational state.  This
443          is always true for non-fips mode.  */
444       if (_gcry_fips_test_operational ())
445         err = GPG_ERR_GENERAL; /* Used as TRUE value */
446       break;
447
448     case GCRYCTL_FIPS_MODE_P:
449       if (fips_mode ())
450         err = GPG_ERR_GENERAL; /* Used as TRUE value */
451       break;
452
453     case GCRYCTL_FORCE_FIPS_MODE:
454       /* Performing this command puts the library into fips mode.  If
455          the library has already been initialized or is already in
456          fips mode, a selftest is triggered.  */
457       if (!any_init_done)
458         {
459           /* Not yet intialized at all.  Set a flag so that we are put
460              into fips mode during initialization.  */
461           force_fips_mode = 1;
462         }
463       else 
464         {
465           /* Already initialized.  If we are already operational we
466              run a selftest.  If not we use the is_operational call to
467              force us into operational state if possible.  */
468           if (_gcry_fips_test_operational ())
469             _gcry_fips_run_selftests ();
470           if (_gcry_fips_is_operational ())
471             err = GPG_ERR_GENERAL; /* Used as TRUE value */
472       }
473       break;
474
475     default:
476       err = GPG_ERR_INV_OP;
477     }
478
479   return gcry_error (err);
480 }
481
482
483 /* Command dispatcher function, acting as general control
484    function.  */
485 gcry_error_t
486 gcry_control (enum gcry_ctl_cmds cmd, ...)
487 {
488   gcry_error_t err;
489   va_list arg_ptr;
490   
491   va_start (arg_ptr, cmd);
492   err = _gcry_vcontrol (cmd, arg_ptr);
493   va_end(arg_ptr);
494   return err;
495 }
496
497
498
499 /* Return a pointer to a string containing a description of the error
500    code in the error value ERR.  */
501 const char *
502 gcry_strerror (gcry_error_t err)
503 {
504   return gpg_strerror (err);
505 }
506
507 /* Return a pointer to a string containing a description of the error
508    source in the error value ERR.  */
509 const char *
510 gcry_strsource (gcry_error_t err)
511 {
512   return gpg_strsource (err);
513 }
514
515 /* Retrieve the error code for the system error ERR.  This returns
516    GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped (report
517    this).  */
518 gcry_err_code_t
519 gcry_err_code_from_errno (int err)
520 {
521   return gpg_err_code_from_errno (err);
522 }
523
524
525 /* Retrieve the system error for the error code CODE.  This returns 0
526    if CODE is not a system error code.  */
527 int
528 gcry_err_code_to_errno (gcry_err_code_t code)
529 {
530   return gpg_err_code_from_errno (code);
531 }
532
533   
534 /* Return an error value with the error source SOURCE and the system
535    error ERR.  */
536 gcry_error_t
537 gcry_err_make_from_errno (gpg_err_source_t source, int err)
538 {
539   return gpg_err_make_from_errno (source, err);
540 }
541
542
543 /* Return an error value with the system error ERR.  */
544 gcry_err_code_t
545 gcry_error_from_errno (int err)
546 {
547   return gcry_error (gpg_err_code_from_errno (err));
548 }
549
550 /****************
551  * NOTE: All 5 functions should be set.  */
552 void
553 gcry_set_allocation_handler (gcry_handler_alloc_t new_alloc_func,
554                              gcry_handler_alloc_t new_alloc_secure_func,
555                              gcry_handler_secure_check_t new_is_secure_func,
556                              gcry_handler_realloc_t new_realloc_func,
557                              gcry_handler_free_t new_free_func)
558 {
559   global_init ();
560
561   if (fips_mode () )
562     {
563       fips_signal_error ("custom allocation handler used");
564       return;
565     }
566
567   alloc_func = new_alloc_func;
568   alloc_secure_func = new_alloc_secure_func;
569   is_secure_func = new_is_secure_func;
570   realloc_func = new_realloc_func;
571   free_func = new_free_func;
572 }
573
574
575
576 /****************
577  * Set an optional handler which is called in case the xmalloc functions
578  * ran out of memory.  This handler may do one of these things:
579  *   o free some memory and return true, so that the xmalloc function
580  *     tries again.
581  *   o Do whatever it like and return false, so that the xmalloc functions
582  *     use the default fatal error handler.
583  *   o Terminate the program and don't return.
584  *
585  * The handler function is called with 3 arguments:  The opaque value set with
586  * this function, the requested memory size, and a flag with these bits
587  * currently defined:
588  *      bit 0 set = secure memory has been requested.
589  */
590 void
591 gcry_set_outofcore_handler( int (*f)( void*, size_t, unsigned int ),
592                                                         void *value )
593 {
594   global_init ();
595
596   if (fips_mode () )
597     {
598       fips_signal_error ("out of core handler used");
599       return;
600     }
601   
602   outofcore_handler = f;
603   outofcore_handler_value = value;
604 }
605
606 static gcry_err_code_t
607 do_malloc (size_t n, unsigned int flags, void **mem)
608 {
609   gcry_err_code_t err = 0;
610   void *m;
611
612   if ((flags & GCRY_ALLOC_FLAG_SECURE) && !no_secure_memory)
613     {
614       if (alloc_secure_func)
615         m = (*alloc_secure_func) (n);
616       else
617         m = _gcry_private_malloc_secure (n);
618     }
619   else
620     {
621       if (alloc_func)
622         m = (*alloc_func) (n);
623       else
624         m = _gcry_private_malloc (n);
625     }
626
627   if (!m)
628     {
629       /* Make sure that ERRNO has been set in case a user supplied
630          memory handler didn't it correctly. */
631       if (!errno)
632         errno = ENOMEM;
633       err = gpg_err_code_from_errno (errno);
634     }
635   else
636     *mem = m;
637
638   return err;
639 }
640   
641 void *
642 gcry_malloc (size_t n)
643 {
644   void *mem = NULL;
645
646   do_malloc (n, 0, &mem);
647
648   return mem;
649 }
650
651 void *
652 gcry_malloc_secure (size_t n)
653 {
654   void *mem = NULL;
655
656   do_malloc (n, GCRY_ALLOC_FLAG_SECURE, &mem);
657
658   return mem;
659 }
660
661 int
662 gcry_is_secure (const void *a)
663 {
664   if (no_secure_memory)
665     return 0;
666   if (is_secure_func)
667     return is_secure_func (a) ;
668   return _gcry_private_is_secure (a);
669 }
670
671 void
672 _gcry_check_heap( const void *a )
673 {
674   (void)a;
675   
676     /* FIXME: implement this*/
677 #if 0
678     if( some_handler )
679         some_handler(a)
680     else
681         _gcry_private_check_heap(a)
682 #endif
683 }
684
685 void *
686 gcry_realloc (void *a, size_t n)
687 {
688   void *p;
689
690   if (realloc_func)
691     p = realloc_func (a, n);
692   else
693     p =  _gcry_private_realloc (a, n);
694   if (!p && !errno)
695     errno = ENOMEM;
696   return p;
697 }
698
699 void
700 gcry_free( void *p )
701 {
702   if( !p )
703     return;
704
705   if (free_func)
706     free_func (p);
707   else
708     _gcry_private_free (p);
709 }
710
711 void *
712 gcry_calloc (size_t n, size_t m)
713 {
714   size_t bytes;
715   void *p;
716
717   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
718                     defined. */
719   if (m && bytes / m != n) 
720     {
721       errno = ENOMEM;
722       return NULL;
723     }
724
725   p = gcry_malloc (bytes);
726   if (p)
727     memset (p, 0, bytes);
728   return p;
729 }
730
731 void *
732 gcry_calloc_secure (size_t n, size_t m)
733 {
734   size_t bytes;
735   void *p;
736
737   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
738                     defined. */
739   if (m && bytes / m != n) 
740     {
741       errno = ENOMEM;
742       return NULL;
743     }
744   
745   p = gcry_malloc_secure (bytes);
746   if (p)
747     memset (p, 0, bytes);
748   return p;
749 }
750
751
752 /* Create and return a copy of the null-terminated string STRING.  If
753    it is contained in secure memory, the copy will be contained in
754    secure memory as well.  In an out-of-memory condition, NULL is
755    returned.  */
756 char *
757 gcry_strdup (const char *string)
758 {
759   char *string_cp = NULL;
760   size_t string_n = 0;
761
762   string_n = strlen (string);
763
764   if (gcry_is_secure (string))
765     string_cp = gcry_malloc_secure (string_n + 1);
766   else
767     string_cp = gcry_malloc (string_n + 1);
768   
769   if (string_cp)
770     strcpy (string_cp, string);
771
772   return string_cp;
773 }
774
775
776 void *
777 gcry_xmalloc( size_t n )
778 {
779     void *p;
780
781     while ( !(p = gcry_malloc( n )) ) {
782         if( !outofcore_handler
783             || !outofcore_handler( outofcore_handler_value, n, 0 ) ) {
784             _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
785         }
786     }
787     return p;
788 }
789
790 void *
791 gcry_xrealloc( void *a, size_t n )
792 {
793     void *p;
794
795     while ( !(p = gcry_realloc( a, n )) ) {
796         if( !outofcore_handler
797             || !outofcore_handler( outofcore_handler_value, n,
798                                    gcry_is_secure(a)? 3:2 ) ) {
799             _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
800         }
801     }
802     return p;
803 }
804
805 void *
806 gcry_xmalloc_secure( size_t n )
807 {
808     void *p;
809
810     while ( !(p = gcry_malloc_secure( n )) ) {
811         if( !outofcore_handler
812             || !outofcore_handler( outofcore_handler_value, n, 1 ) ) {
813             _gcry_fatal_error(gpg_err_code_from_errno (errno),
814                              _("out of core in secure memory"));
815         }
816     }
817     return p;
818 }
819
820
821 void *
822 gcry_xcalloc( size_t n, size_t m )
823 {
824   size_t nbytes;
825   void *p;
826
827   nbytes = n * m; 
828   if (m && nbytes / m != n) 
829     {
830       errno = ENOMEM;
831       _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
832     }
833
834   p = gcry_xmalloc ( nbytes );
835   memset ( p, 0, nbytes );
836   return p;
837 }
838
839 void *
840 gcry_xcalloc_secure( size_t n, size_t m )
841 {
842   size_t nbytes;
843   void *p;
844
845   nbytes = n * m; 
846   if (m && nbytes / m != n) 
847     {
848       errno = ENOMEM;
849       _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
850     }
851
852   p = gcry_xmalloc_secure ( nbytes );
853   memset ( p, 0, nbytes );
854   return p;
855 }
856
857 char *
858 gcry_xstrdup (const char *string)
859 {
860   char *p;
861
862   while ( !(p = gcry_strdup (string)) ) 
863     {
864       size_t n = strlen (string);
865       int is_sec = !!gcry_is_secure (string);
866
867       if (!outofcore_handler
868           || !outofcore_handler (outofcore_handler_value, n, is_sec) ) 
869         {
870           _gcry_fatal_error (gpg_err_code_from_errno (errno),
871                              is_sec? _("out of core in secure memory"):NULL);
872         }
873     }
874
875   return p;
876 }
877
878
879 int
880 _gcry_get_debug_flag (unsigned int mask)
881 {
882   if ( fips_mode () )
883     return 0;
884   return (debug_flags & mask);
885 }
886
887
888 \f
889 /* It is often useful to get some feedback of long running operations.
890    This function may be used to register a handler for this. 
891    The callback function CB is used as:
892
893    void cb (void *opaque, const char *what, int printchar,
894            int current, int total);
895
896    Where WHAT is a string identifying the the type of the progress
897    output, PRINTCHAR the character usually printed, CURRENT the amount
898    of progress currently done and TOTAL the expected amount of
899    progress.  A value of 0 for TOTAL indicates that there is no
900    estimation available.
901
902    Defined values for WHAT:
903
904    "need_entropy"  X    0  number-of-bytes-required
905             When running low on entropy
906    "primegen"      '\n'  0 0
907            Prime generated
908                    '!'
909            Need to refresh the prime pool
910                    '<','>'
911            Number of bits adjusted
912                    '^'
913            Looking for a generator
914                    '.'
915            Fermat tests on 10 candidates failed
916                   ':'
917            Restart with a new random value
918                   '+'
919            Rabin Miller test passed          
920    "pk_elg"        '+','-','.','\n'   0  0
921             Only used in debugging mode.
922    "pk_dsa"       
923             Only used in debugging mode.
924 */
925 void
926 gcry_set_progress_handler (void (*cb)(void *,const char*,int, int, int),
927                            void *cb_data)
928 {
929 #if USE_DSA
930   _gcry_register_pk_dsa_progress (cb, cb_data);
931 #endif
932 #if USE_ELGAMAL
933   _gcry_register_pk_elg_progress (cb, cb_data);
934 #endif
935   _gcry_register_primegen_progress (cb, cb_data);
936   _gcry_register_random_progress (cb, cb_data);
937 }