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