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