Replace ath based mutexes by gpgrt based locks.
[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, 2011,
4  *               2012  Free Software Foundation, Inc.
5  * Copyright (C) 2013, 2014 g10 Code GmbH
6  *
7  * This file is part of Libgcrypt.
8  *
9  * Libgcrypt is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU Lesser general Public License as
11  * published by the Free Software Foundation; either version 2.1 of
12  * the License, or (at your option) any later version.
13  *
14  * Libgcrypt is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
21  */
22
23 #include <config.h>
24
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <stdarg.h>
29 #include <ctype.h>
30 #include <limits.h>
31 #include <errno.h>
32 #include <unistd.h>
33 #ifdef HAVE_SYSLOG
34 # include <syslog.h>
35 #endif /*HAVE_SYSLOG*/
36
37 #include "g10lib.h"
38 #include "cipher.h"
39 #include "stdmem.h" /* our own memory allocator */
40 #include "secmem.h" /* our own secmem allocator */
41
42
43 \f
44
45 /****************
46  * flag bits: 0 : general cipher debug
47  *            1 : general MPI debug
48  */
49 static unsigned int debug_flags;
50
51 /* gcry_control (GCRYCTL_SET_FIPS_MODE), sets this flag so that the
52    initialization code switched fips mode on.  */
53 static int force_fips_mode;
54
55 /* Controlled by global_init().  */
56 static int any_init_done;
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   /* Tell the random module that we have seen an init call.  */
87   _gcry_set_preferred_rng_type (0);
88
89   /* See whether the system is in FIPS mode.  This needs to come as
90      early as possible but after 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   /* Initialize the modules - this is mainly allocating some memory and
98      creating mutexes.  */
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   err = _gcry_primegen_init ();
109   if (err)
110     goto fail;
111   err = _gcry_secmem_module_init ();
112   if (err)
113     goto fail;
114   err = _gcry_mpi_init ();
115   if (err)
116     goto fail;
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;
220
221     if (req_version && req_version[0] == 1 && req_version[1] == 1)
222         return _gcry_compat_identification ();
223
224     /* Initialize library.  */
225     global_init ();
226
227     if ( !req_version )
228         /* Caller wants our version number.  */
229         return ver;
230
231     /* Parse own version number.  */
232     my_plvl = parse_version_string( ver, &my_major, &my_minor, &my_micro );
233     if ( !my_plvl )
234         /* very strange our own version is bogus.  Shouldn't we use
235            assert() here and bail out in case this happens?  -mo.  */
236         return NULL;
237
238     /* Parse requested version number.  */
239     if (!parse_version_string (req_version, &rq_major, &rq_minor, &rq_micro))
240       return NULL;  /* req version string is invalid, this can happen.  */
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                                                         && my_micro > rq_micro)
246         || (my_major == rq_major && my_minor == rq_minor
247                                  && my_micro == rq_micro))
248       {
249         return ver;
250       }
251
252     return NULL;
253 }
254
255
256 static void
257 print_config ( int (*fnc)(FILE *fp, const char *format, ...), FILE *fp)
258 {
259   unsigned int hwfeatures, afeature;
260   int i;
261   const char *s;
262
263   fnc (fp, "version:%s:\n", VERSION);
264   fnc (fp, "ciphers:%s:\n", LIBGCRYPT_CIPHERS);
265   fnc (fp, "pubkeys:%s:\n", LIBGCRYPT_PUBKEY_CIPHERS);
266   fnc (fp, "digests:%s:\n", LIBGCRYPT_DIGESTS);
267   fnc (fp, "rnd-mod:"
268 #if USE_RNDEGD
269                 "egd:"
270 #endif
271 #if USE_RNDLINUX
272                 "linux:"
273 #endif
274 #if USE_RNDUNIX
275                 "unix:"
276 #endif
277 #if USE_RNDW32
278                 "w32:"
279 #endif
280        "\n");
281   fnc (fp, "cpu-arch:"
282 #if defined(HAVE_CPU_ARCH_X86)
283        "x86"
284 #elif defined(HAVE_CPU_ARCH_ALPHA)
285        "alpha"
286 #elif defined(HAVE_CPU_ARCH_SPARC)
287        "sparc"
288 #elif defined(HAVE_CPU_ARCH_MIPS)
289        "mips"
290 #elif defined(HAVE_CPU_ARCH_M68K)
291        "m68k"
292 #elif defined(HAVE_CPU_ARCH_PPC)
293        "ppc"
294 #elif defined(HAVE_CPU_ARCH_ARM)
295        "arm"
296 #endif
297        ":\n");
298   fnc (fp, "mpi-asm:%s:\n", _gcry_mpi_get_hw_config ());
299   hwfeatures = _gcry_get_hw_features ();
300   fnc (fp, "hwflist:");
301   for (i=0; (s = _gcry_enum_hw_features (i, &afeature)); i++)
302     if ((hwfeatures & afeature))
303       fnc (fp, "%s:", s);
304   fnc (fp, "\n");
305   /* We use y/n instead of 1/0 for the simple reason that Emacsen's
306      compile error parser would accidently flag that line when printed
307      during "make check" as an error.  */
308   fnc (fp, "fips-mode:%c:%c:\n",
309        fips_mode ()? 'y':'n',
310        _gcry_enforced_fips_mode ()? 'y':'n' );
311   /* The currently used RNG type.  */
312   {
313     i = _gcry_get_rng_type (0);
314     switch (i)
315       {
316       case GCRY_RNG_TYPE_STANDARD: s = "standard"; break;
317       case GCRY_RNG_TYPE_FIPS:     s = "fips"; break;
318       case GCRY_RNG_TYPE_SYSTEM:   s = "system"; break;
319       default: BUG ();
320       }
321     fnc (fp, "rng-type:%s:%d:\n", s, i);
322   }
323
324 }
325
326
327 \f
328
329 /* Command dispatcher function, acting as general control
330    function.  */
331 gcry_err_code_t
332 _gcry_vcontrol (enum gcry_ctl_cmds cmd, va_list arg_ptr)
333 {
334   static int init_finished = 0;
335   gcry_err_code_t rc = 0;
336
337   switch (cmd)
338     {
339     case GCRYCTL_ENABLE_M_GUARD:
340       _gcry_private_enable_m_guard ();
341       break;
342
343     case GCRYCTL_ENABLE_QUICK_RANDOM:
344       _gcry_set_preferred_rng_type (0);
345       _gcry_enable_quick_random_gen ();
346       break;
347
348     case GCRYCTL_FAKED_RANDOM_P:
349       /* Return an error if the RNG is faked one (e.g. enabled by
350          ENABLE_QUICK_RANDOM. */
351       if (_gcry_random_is_faked ())
352         rc = GPG_ERR_GENERAL;  /* Use as TRUE value.  */
353       break;
354
355     case GCRYCTL_DUMP_RANDOM_STATS:
356       _gcry_random_dump_stats ();
357       break;
358
359     case GCRYCTL_DUMP_MEMORY_STATS:
360       /*m_print_stats("[fixme: prefix]");*/
361       break;
362
363     case GCRYCTL_DUMP_SECMEM_STATS:
364       _gcry_secmem_dump_stats ();
365       break;
366
367     case GCRYCTL_DROP_PRIVS:
368       global_init ();
369       _gcry_secmem_init (0);
370       break;
371
372     case GCRYCTL_DISABLE_SECMEM:
373       global_init ();
374       no_secure_memory = 1;
375       break;
376
377     case GCRYCTL_INIT_SECMEM:
378       global_init ();
379       _gcry_secmem_init (va_arg (arg_ptr, unsigned int));
380       if ((_gcry_secmem_get_flags () & GCRY_SECMEM_FLAG_NOT_LOCKED))
381         rc = GPG_ERR_GENERAL;
382       break;
383
384     case GCRYCTL_TERM_SECMEM:
385       global_init ();
386       _gcry_secmem_term ();
387       break;
388
389     case GCRYCTL_DISABLE_SECMEM_WARN:
390       _gcry_set_preferred_rng_type (0);
391       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
392                                | GCRY_SECMEM_FLAG_NO_WARNING));
393       break;
394
395     case GCRYCTL_SUSPEND_SECMEM_WARN:
396       _gcry_set_preferred_rng_type (0);
397       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
398                                | GCRY_SECMEM_FLAG_SUSPEND_WARNING));
399       break;
400
401     case GCRYCTL_RESUME_SECMEM_WARN:
402       _gcry_set_preferred_rng_type (0);
403       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
404                                & ~GCRY_SECMEM_FLAG_SUSPEND_WARNING));
405       break;
406
407     case GCRYCTL_USE_SECURE_RNDPOOL:
408       global_init ();
409       _gcry_secure_random_alloc (); /* Put random number into secure memory. */
410       break;
411
412     case GCRYCTL_SET_RANDOM_SEED_FILE:
413       _gcry_set_preferred_rng_type (0);
414       _gcry_set_random_seed_file (va_arg (arg_ptr, const char *));
415       break;
416
417     case GCRYCTL_UPDATE_RANDOM_SEED_FILE:
418       _gcry_set_preferred_rng_type (0);
419       if ( fips_is_operational () )
420         _gcry_update_random_seed_file ();
421       break;
422
423     case GCRYCTL_SET_VERBOSITY:
424       _gcry_set_preferred_rng_type (0);
425       _gcry_set_log_verbosity (va_arg (arg_ptr, int));
426       break;
427
428     case GCRYCTL_SET_DEBUG_FLAGS:
429       debug_flags |= va_arg (arg_ptr, unsigned int);
430       break;
431
432     case GCRYCTL_CLEAR_DEBUG_FLAGS:
433       debug_flags &= ~va_arg (arg_ptr, unsigned int);
434       break;
435
436     case GCRYCTL_DISABLE_INTERNAL_LOCKING:
437       /* Not used anymore.  */
438       global_init ();
439       break;
440
441     case GCRYCTL_ANY_INITIALIZATION_P:
442       if (any_init_done)
443         rc = GPG_ERR_GENERAL;
444       break;
445
446     case GCRYCTL_INITIALIZATION_FINISHED_P:
447       if (init_finished)
448         rc = GPG_ERR_GENERAL; /* Yes.  */
449       break;
450
451     case GCRYCTL_INITIALIZATION_FINISHED:
452       /* This is a hook which should be used by an application after
453          all initialization has been done and right before any threads
454          are started.  It is not really needed but the only way to be
455          really sure that all initialization for thread-safety has
456          been done. */
457       if (! init_finished)
458         {
459           global_init ();
460           /* Do only a basic random initialization, i.e. init the
461              mutexes. */
462           _gcry_random_initialize (0);
463           init_finished = 1;
464           /* Force us into operational state if in FIPS mode.  */
465           (void)fips_is_operational ();
466         }
467       break;
468
469     case GCRYCTL_SET_THREAD_CBS:
470       /* This is now a dummy call.  We used to install our own thread
471          library here. */
472       _gcry_set_preferred_rng_type (0);
473       global_init ();
474       break;
475
476     case GCRYCTL_FAST_POLL:
477       _gcry_set_preferred_rng_type (0);
478       /* We need to do make sure that the random pool is really
479          initialized so that the poll function is not a NOP. */
480       _gcry_random_initialize (1);
481
482       if ( fips_is_operational () )
483         _gcry_fast_random_poll ();
484       break;
485
486     case GCRYCTL_SET_RNDEGD_SOCKET:
487 #if USE_RNDEGD
488       _gcry_set_preferred_rng_type (0);
489       rc = _gcry_rndegd_set_socket_name (va_arg (arg_ptr, const char *));
490 #else
491       rc = gpg_error (GPG_ERR_NOT_SUPPORTED);
492 #endif
493       break;
494
495     case GCRYCTL_SET_RANDOM_DAEMON_SOCKET:
496       _gcry_set_preferred_rng_type (0);
497       _gcry_set_random_daemon_socket (va_arg (arg_ptr, const char *));
498       break;
499
500     case GCRYCTL_USE_RANDOM_DAEMON:
501       /* We need to do make sure that the random pool is really
502          initialized so that the poll function is not a NOP. */
503       _gcry_set_preferred_rng_type (0);
504       _gcry_random_initialize (1);
505       _gcry_use_random_daemon (!! va_arg (arg_ptr, int));
506       break;
507
508     case GCRYCTL_CLOSE_RANDOM_DEVICE:
509       _gcry_random_close_fds ();
510       break;
511
512       /* This command dumps information pertaining to the
513          configuration of libgcrypt to the given stream.  It may be
514          used before the initialization has been finished but not
515          before a gcry_version_check. */
516     case GCRYCTL_PRINT_CONFIG:
517       {
518         FILE *fp = va_arg (arg_ptr, FILE *);
519         _gcry_set_preferred_rng_type (0);
520         print_config (fp?fprintf:_gcry_log_info_with_dummy_fp, fp);
521       }
522       break;
523
524     case GCRYCTL_OPERATIONAL_P:
525       /* Returns true if the library is in an operational state.  This
526          is always true for non-fips mode.  */
527       _gcry_set_preferred_rng_type (0);
528       if (_gcry_fips_test_operational ())
529         rc = GPG_ERR_GENERAL; /* Used as TRUE value */
530       break;
531
532     case GCRYCTL_FIPS_MODE_P:
533       if (fips_mode ()
534           && !_gcry_is_fips_mode_inactive ()
535           && !no_secure_memory)
536         rc = GPG_ERR_GENERAL; /* Used as TRUE value */
537       break;
538
539     case GCRYCTL_FORCE_FIPS_MODE:
540       /* Performing this command puts the library into fips mode.  If
541          the library has already been initialized into fips mode, a
542          selftest is triggered.  It is not possible to put the libraty
543          into fips mode after having passed the initialization. */
544       _gcry_set_preferred_rng_type (0);
545       if (!any_init_done)
546         {
547           /* Not yet intialized at all.  Set a flag so that we are put
548              into fips mode during initialization.  */
549           force_fips_mode = 1;
550         }
551       else
552         {
553           /* Already initialized.  If we are already operational we
554              run a selftest.  If not we use the is_operational call to
555              force us into operational state if possible.  */
556           if (_gcry_fips_test_error_or_operational ())
557             _gcry_fips_run_selftests (1);
558           if (_gcry_fips_is_operational ())
559             rc = GPG_ERR_GENERAL; /* Used as TRUE value */
560       }
561       break;
562
563     case GCRYCTL_SELFTEST:
564       /* Run a selftest.  This works in fips mode as well as in
565          standard mode.  In contrast to the power-up tests, we use an
566          extended version of the selftests. Returns 0 on success or an
567          error code. */
568       global_init ();
569       rc = _gcry_fips_run_selftests (1);
570       break;
571
572 #if _GCRY_GCC_VERSION >= 40600
573 # pragma GCC diagnostic push
574 # pragma GCC diagnostic ignored "-Wswitch"
575 #endif
576     case 58:  /* Init external random test.  */
577       {
578         void **rctx        = va_arg (arg_ptr, void **);
579         unsigned int flags = va_arg (arg_ptr, unsigned int);
580         const void *key    = va_arg (arg_ptr, const void *);
581         size_t keylen      = va_arg (arg_ptr, size_t);
582         const void *seed   = va_arg (arg_ptr, const void *);
583         size_t seedlen     = va_arg (arg_ptr, size_t);
584         const void *dt     = va_arg (arg_ptr, const void *);
585         size_t dtlen       = va_arg (arg_ptr, size_t);
586         if (!fips_is_operational ())
587           rc = fips_not_operational ();
588         else
589           rc = _gcry_random_init_external_test (rctx, flags, key, keylen,
590                                                 seed, seedlen, dt, dtlen);
591       }
592       break;
593     case 59:  /* Run external random test.  */
594       {
595         void *ctx     = va_arg (arg_ptr, void *);
596         void *buffer  = va_arg (arg_ptr, void *);
597         size_t buflen = va_arg (arg_ptr, size_t);
598         if (!fips_is_operational ())
599           rc = fips_not_operational ();
600         else
601           rc = _gcry_random_run_external_test (ctx, buffer, buflen);
602       }
603       break;
604     case 60:  /* Deinit external random test.  */
605       {
606         void *ctx = va_arg (arg_ptr, void *);
607         _gcry_random_deinit_external_test (ctx);
608       }
609       break;
610     case 61:  /* RFU */
611       break;
612     case 62:  /* RFU */
613       break;
614 #if _GCRY_GCC_VERSION >= 40600
615 # pragma GCC diagnostic pop
616 #endif
617
618     case GCRYCTL_DISABLE_HWF:
619       {
620         const char *name = va_arg (arg_ptr, const char *);
621         rc = _gcry_disable_hw_feature (name);
622       }
623       break;
624
625     case GCRYCTL_SET_ENFORCED_FIPS_FLAG:
626       if (!any_init_done)
627         {
628           /* Not yet initialized at all.  Set the enforced fips mode flag */
629           _gcry_set_preferred_rng_type (0);
630           _gcry_set_enforced_fips_mode ();
631         }
632       else
633         rc = GPG_ERR_GENERAL;
634       break;
635
636     case GCRYCTL_SET_PREFERRED_RNG_TYPE:
637       /* This may be called before gcry_check_version.  */
638       {
639         int i = va_arg (arg_ptr, int);
640         /* Note that we may not pass 0 to _gcry_set_preferred_rng_type.  */
641         if (i > 0)
642           _gcry_set_preferred_rng_type (i);
643       }
644       break;
645
646     case GCRYCTL_GET_CURRENT_RNG_TYPE:
647       {
648         int *ip = va_arg (arg_ptr, int*);
649         if (ip)
650           *ip = _gcry_get_rng_type (!any_init_done);
651       }
652       break;
653
654     case GCRYCTL_DISABLE_LOCKED_SECMEM:
655       _gcry_set_preferred_rng_type (0);
656       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
657                                | GCRY_SECMEM_FLAG_NO_MLOCK));
658       break;
659
660     case GCRYCTL_DISABLE_PRIV_DROP:
661       _gcry_set_preferred_rng_type (0);
662       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
663                                | GCRY_SECMEM_FLAG_NO_PRIV_DROP));
664       break;
665
666     default:
667       _gcry_set_preferred_rng_type (0);
668       rc = GPG_ERR_INV_OP;
669     }
670
671   return rc;
672 }
673
674
675
676 /* Set custom allocation handlers.  This is in general not useful
677  * because the libgcrypt allocation functions are guaranteed to
678  * provide proper allocation handlers which zeroize memory if needed.
679  * NOTE: All 5 functions should be set.  */
680 void
681 _gcry_set_allocation_handler (gcry_handler_alloc_t new_alloc_func,
682                               gcry_handler_alloc_t new_alloc_secure_func,
683                               gcry_handler_secure_check_t new_is_secure_func,
684                               gcry_handler_realloc_t new_realloc_func,
685                               gcry_handler_free_t new_free_func)
686 {
687   global_init ();
688
689   if (fips_mode ())
690     {
691       /* We do not want to enforce the fips mode, but merely set a
692          flag so that the application may check whether it is still in
693          fips mode.  */
694       _gcry_inactivate_fips_mode ("custom allocation handler");
695     }
696
697   alloc_func = new_alloc_func;
698   alloc_secure_func = new_alloc_secure_func;
699   is_secure_func = new_is_secure_func;
700   realloc_func = new_realloc_func;
701   free_func = new_free_func;
702 }
703
704
705
706 /****************
707  * Set an optional handler which is called in case the xmalloc functions
708  * ran out of memory.  This handler may do one of these things:
709  *   o free some memory and return true, so that the xmalloc function
710  *     tries again.
711  *   o Do whatever it like and return false, so that the xmalloc functions
712  *     use the default fatal error handler.
713  *   o Terminate the program and don't return.
714  *
715  * The handler function is called with 3 arguments:  The opaque value set with
716  * this function, the requested memory size, and a flag with these bits
717  * currently defined:
718  *      bit 0 set = secure memory has been requested.
719  */
720 void
721 _gcry_set_outofcore_handler (int (*f)(void*, size_t, unsigned int), void *value)
722 {
723   global_init ();
724
725   if (fips_mode () )
726     {
727       log_info ("out of core handler ignored in FIPS mode\n");
728       return;
729     }
730
731   outofcore_handler = f;
732   outofcore_handler_value = value;
733 }
734
735 /* Return the no_secure_memory flag.  */
736 static int
737 get_no_secure_memory (void)
738 {
739   if (!no_secure_memory)
740     return 0;
741   if (_gcry_enforced_fips_mode ())
742     {
743       no_secure_memory = 0;
744       return 0;
745     }
746   return no_secure_memory;
747 }
748
749
750 static gcry_err_code_t
751 do_malloc (size_t n, unsigned int flags, void **mem)
752 {
753   gcry_err_code_t err = 0;
754   void *m;
755
756   if ((flags & GCRY_ALLOC_FLAG_SECURE) && !get_no_secure_memory ())
757     {
758       if (alloc_secure_func)
759         m = (*alloc_secure_func) (n);
760       else
761         m = _gcry_private_malloc_secure (n);
762     }
763   else
764     {
765       if (alloc_func)
766         m = (*alloc_func) (n);
767       else
768         m = _gcry_private_malloc (n);
769     }
770
771   if (!m)
772     {
773       /* Make sure that ERRNO has been set in case a user supplied
774          memory handler didn't it correctly. */
775       if (!errno)
776         gpg_err_set_errno (ENOMEM);
777       err = gpg_err_code_from_errno (errno);
778     }
779   else
780     *mem = m;
781
782   return err;
783 }
784
785 void *
786 _gcry_malloc (size_t n)
787 {
788   void *mem = NULL;
789
790   do_malloc (n, 0, &mem);
791
792   return mem;
793 }
794
795 void *
796 _gcry_malloc_secure (size_t n)
797 {
798   void *mem = NULL;
799
800   do_malloc (n, GCRY_ALLOC_FLAG_SECURE, &mem);
801
802   return mem;
803 }
804
805 int
806 _gcry_is_secure (const void *a)
807 {
808   if (get_no_secure_memory ())
809     return 0;
810   if (is_secure_func)
811     return is_secure_func (a) ;
812   return _gcry_private_is_secure (a);
813 }
814
815 void
816 _gcry_check_heap( const void *a )
817 {
818   (void)a;
819
820     /* FIXME: implement this*/
821 #if 0
822     if( some_handler )
823         some_handler(a)
824     else
825         _gcry_private_check_heap(a)
826 #endif
827 }
828
829 void *
830 _gcry_realloc (void *a, size_t n)
831 {
832   void *p;
833
834   /* To avoid problems with non-standard realloc implementations and
835      our own secmem_realloc, we divert to malloc and free here.  */
836   if (!a)
837     return _gcry_malloc (n);
838   if (!n)
839     {
840       xfree (a);
841       return NULL;
842     }
843
844   if (realloc_func)
845     p = realloc_func (a, n);
846   else
847     p =  _gcry_private_realloc (a, n);
848   if (!p && !errno)
849     gpg_err_set_errno (ENOMEM);
850   return p;
851 }
852
853 void
854 _gcry_free (void *p)
855 {
856   int save_errno;
857
858   if (!p)
859     return;
860
861   /* In case ERRNO is set we better save it so that the free machinery
862      may not accidently change ERRNO.  We restore it only if it was
863      already set to comply with the usual C semantic for ERRNO.  */
864   save_errno = errno;
865   if (free_func)
866     free_func (p);
867   else
868     _gcry_private_free (p);
869
870   if (save_errno)
871     gpg_err_set_errno (save_errno);
872 }
873
874 void *
875 _gcry_calloc (size_t n, size_t m)
876 {
877   size_t bytes;
878   void *p;
879
880   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
881                     defined. */
882   if (m && bytes / m != n)
883     {
884       gpg_err_set_errno (ENOMEM);
885       return NULL;
886     }
887
888   p = _gcry_malloc (bytes);
889   if (p)
890     memset (p, 0, bytes);
891   return p;
892 }
893
894 void *
895 _gcry_calloc_secure (size_t n, size_t m)
896 {
897   size_t bytes;
898   void *p;
899
900   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
901                     defined. */
902   if (m && bytes / m != n)
903     {
904       gpg_err_set_errno (ENOMEM);
905       return NULL;
906     }
907
908   p = _gcry_malloc_secure (bytes);
909   if (p)
910     memset (p, 0, bytes);
911   return p;
912 }
913
914
915 /* Create and return a copy of the null-terminated string STRING.  If
916    it is contained in secure memory, the copy will be contained in
917    secure memory as well.  In an out-of-memory condition, NULL is
918    returned.  */
919 char *
920 _gcry_strdup (const char *string)
921 {
922   char *string_cp = NULL;
923   size_t string_n = 0;
924
925   string_n = strlen (string);
926
927   if (_gcry_is_secure (string))
928     string_cp = _gcry_malloc_secure (string_n + 1);
929   else
930     string_cp = _gcry_malloc (string_n + 1);
931
932   if (string_cp)
933     strcpy (string_cp, string);
934
935   return string_cp;
936 }
937
938
939 void *
940 _gcry_xmalloc( size_t n )
941 {
942   void *p;
943
944   while ( !(p = _gcry_malloc( n )) )
945     {
946       if ( fips_mode ()
947            || !outofcore_handler
948            || !outofcore_handler (outofcore_handler_value, n, 0) )
949         {
950           _gcry_fatal_error (gpg_err_code_from_errno (errno), NULL);
951         }
952     }
953     return p;
954 }
955
956 void *
957 _gcry_xrealloc( void *a, size_t n )
958 {
959   void *p;
960
961   while ( !(p = _gcry_realloc( a, n )) )
962     {
963       if ( fips_mode ()
964            || !outofcore_handler
965            || !outofcore_handler (outofcore_handler_value, n,
966                                   _gcry_is_secure(a)? 3:2))
967         {
968           _gcry_fatal_error (gpg_err_code_from_errno (errno), NULL );
969         }
970     }
971     return p;
972 }
973
974 void *
975 _gcry_xmalloc_secure( size_t n )
976 {
977   void *p;
978
979   while ( !(p = _gcry_malloc_secure( n )) )
980     {
981       if ( fips_mode ()
982            || !outofcore_handler
983            || !outofcore_handler (outofcore_handler_value, n, 1) )
984         {
985           _gcry_fatal_error (gpg_err_code_from_errno (errno),
986                              _("out of core in secure memory"));
987         }
988     }
989   return p;
990 }
991
992
993 void *
994 _gcry_xcalloc( size_t n, size_t m )
995 {
996   size_t nbytes;
997   void *p;
998
999   nbytes = n * m;
1000   if (m && nbytes / m != n)
1001     {
1002       gpg_err_set_errno (ENOMEM);
1003       _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
1004     }
1005
1006   p = _gcry_xmalloc ( nbytes );
1007   memset ( p, 0, nbytes );
1008   return p;
1009 }
1010
1011 void *
1012 _gcry_xcalloc_secure( size_t n, size_t m )
1013 {
1014   size_t nbytes;
1015   void *p;
1016
1017   nbytes = n * m;
1018   if (m && nbytes / m != n)
1019     {
1020       gpg_err_set_errno (ENOMEM);
1021       _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
1022     }
1023
1024   p = _gcry_xmalloc_secure ( nbytes );
1025   memset ( p, 0, nbytes );
1026   return p;
1027 }
1028
1029 char *
1030 _gcry_xstrdup (const char *string)
1031 {
1032   char *p;
1033
1034   while ( !(p = _gcry_strdup (string)) )
1035     {
1036       size_t n = strlen (string);
1037       int is_sec = !!_gcry_is_secure (string);
1038
1039       if (fips_mode ()
1040           || !outofcore_handler
1041           || !outofcore_handler (outofcore_handler_value, n, is_sec) )
1042         {
1043           _gcry_fatal_error (gpg_err_code_from_errno (errno),
1044                              is_sec? _("out of core in secure memory"):NULL);
1045         }
1046     }
1047
1048   return p;
1049 }
1050
1051
1052 int
1053 _gcry_get_debug_flag (unsigned int mask)
1054 {
1055   if ( fips_mode () )
1056     return 0;
1057   return (debug_flags & mask);
1058 }
1059
1060
1061 \f
1062 /* It is often useful to get some feedback of long running operations.
1063    This function may be used to register a handler for this.
1064    The callback function CB is used as:
1065
1066    void cb (void *opaque, const char *what, int printchar,
1067            int current, int total);
1068
1069    Where WHAT is a string identifying the the type of the progress
1070    output, PRINTCHAR the character usually printed, CURRENT the amount
1071    of progress currently done and TOTAL the expected amount of
1072    progress.  A value of 0 for TOTAL indicates that there is no
1073    estimation available.
1074
1075    Defined values for WHAT:
1076
1077    "need_entropy"  X    0  number-of-bytes-required
1078             When running low on entropy
1079    "primegen"      '\n'  0 0
1080            Prime generated
1081                    '!'
1082            Need to refresh the prime pool
1083                    '<','>'
1084            Number of bits adjusted
1085                    '^'
1086            Looking for a generator
1087                    '.'
1088            Fermat tests on 10 candidates failed
1089                   ':'
1090            Restart with a new random value
1091                   '+'
1092            Rabin Miller test passed
1093    "pk_elg"        '+','-','.','\n'   0  0
1094             Only used in debugging mode.
1095    "pk_dsa"
1096             Only used in debugging mode.
1097 */
1098 void
1099 _gcry_set_progress_handler (void (*cb)(void *,const char*,int, int, int),
1100                             void *cb_data)
1101 {
1102 #if USE_DSA
1103   _gcry_register_pk_dsa_progress (cb, cb_data);
1104 #endif
1105 #if USE_ELGAMAL
1106   _gcry_register_pk_elg_progress (cb, cb_data);
1107 #endif
1108   _gcry_register_primegen_progress (cb, cb_data);
1109   _gcry_register_random_progress (cb, cb_data);
1110 }