Add a new helper tool
[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    intialization code swicthed 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 sucess, 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     { 0, NULL} 
269   };
270   int i;
271
272   fnc (fp, "version:%s:\n", VERSION);
273   fnc (fp, "ciphers:%s:\n", LIBGCRYPT_CIPHERS);
274   fnc (fp, "pubkeys:%s:\n", LIBGCRYPT_PUBKEY_CIPHERS);
275   fnc (fp, "digests:%s:\n", LIBGCRYPT_DIGESTS);
276   fnc (fp, "rnd-mod:"
277 #if USE_RNDEGD
278                 "egd:"
279 #endif
280 #if USE_RNDLINUX
281                 "linux:"
282 #endif
283 #if USE_RNDUNIX
284                 "unix:"
285 #endif
286 #if USE_RNDW32
287                 "w32:"
288 #endif
289        "\n");
290   fnc (fp, "mpi-asm:%s:\n", _gcry_mpi_get_hw_config ());
291   hwf = _gcry_get_hw_features ();
292   fnc (fp, "hwflist:");
293   for (i=0; hwflist[i].desc; i++)
294   if ( (hwf & hwflist[i].flag) )
295     fnc (fp, "%s:", hwflist[i].desc);
296   fnc (fp, "\n");
297   /* We use y/n instead of 1/0 for the simple reason that Emacsen's
298      compile error parser would accidently flag that line when printed
299      during "make check" as an error.  */
300   fnc (fp, "fips-mode:%c:%c:\n", 
301        fips_mode ()? 'y':'n',
302        _gcry_enforced_fips_mode ()? 'y':'n' );
303 }
304
305
306 \f
307
308 /* Command dispatcher function, acting as general control
309    function.  */
310 gcry_error_t
311 _gcry_vcontrol (enum gcry_ctl_cmds cmd, va_list arg_ptr)
312 {
313   static int init_finished = 0;
314   gcry_err_code_t err = 0;
315   
316   switch (cmd)
317     {
318     case GCRYCTL_ENABLE_M_GUARD:
319       _gcry_private_enable_m_guard ();
320       break;
321
322     case GCRYCTL_ENABLE_QUICK_RANDOM:
323       _gcry_enable_quick_random_gen ();
324       break;
325
326     case GCRYCTL_FAKED_RANDOM_P:
327       /* Return an error if the RNG is faked one (e.g. enabled by
328          ENABLE_QUICK_RANDOM. */
329       if (_gcry_random_is_faked ())
330         err = GPG_ERR_GENERAL;  /* Use as TRUE value.  */
331       break;
332
333     case GCRYCTL_DUMP_RANDOM_STATS:
334       _gcry_random_dump_stats ();
335       break;
336
337     case GCRYCTL_DUMP_MEMORY_STATS:
338       /*m_print_stats("[fixme: prefix]");*/
339       break;
340
341     case GCRYCTL_DUMP_SECMEM_STATS:
342       _gcry_secmem_dump_stats ();
343       break;
344
345     case GCRYCTL_DROP_PRIVS:
346       global_init ();
347       _gcry_secmem_init (0);
348       break;
349
350     case GCRYCTL_DISABLE_SECMEM:
351       global_init ();
352       no_secure_memory = 1;
353       break;    
354
355     case GCRYCTL_INIT_SECMEM:
356       global_init ();
357       _gcry_secmem_init (va_arg (arg_ptr, unsigned int));
358       if ((_gcry_secmem_get_flags () & GCRY_SECMEM_FLAG_NOT_LOCKED))
359         err = GPG_ERR_GENERAL;
360       break;
361
362     case GCRYCTL_TERM_SECMEM:
363       global_init ();
364       _gcry_secmem_term ();
365       break;
366
367     case GCRYCTL_DISABLE_SECMEM_WARN:
368       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
369                                | GCRY_SECMEM_FLAG_NO_WARNING));
370       break;
371
372     case GCRYCTL_SUSPEND_SECMEM_WARN:
373       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
374                                | GCRY_SECMEM_FLAG_SUSPEND_WARNING));
375       break;
376
377     case GCRYCTL_RESUME_SECMEM_WARN:
378       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
379                                & ~GCRY_SECMEM_FLAG_SUSPEND_WARNING));
380       break;
381
382     case GCRYCTL_USE_SECURE_RNDPOOL:
383       global_init ();
384       _gcry_secure_random_alloc (); /* Put random number into secure memory. */
385       break;
386
387     case GCRYCTL_SET_RANDOM_SEED_FILE:
388       _gcry_set_random_seed_file (va_arg (arg_ptr, const char *));
389       break;
390
391     case GCRYCTL_UPDATE_RANDOM_SEED_FILE:
392       if ( fips_is_operational () )
393         _gcry_update_random_seed_file ();
394       break;
395
396     case GCRYCTL_SET_VERBOSITY:
397       _gcry_set_log_verbosity (va_arg (arg_ptr, int));
398       break;
399
400     case GCRYCTL_SET_DEBUG_FLAGS:
401       debug_flags |= va_arg (arg_ptr, unsigned int);
402       break;
403
404     case GCRYCTL_CLEAR_DEBUG_FLAGS:
405       debug_flags &= ~va_arg (arg_ptr, unsigned int);
406       break;
407
408     case GCRYCTL_DISABLE_INTERNAL_LOCKING:
409       /* Not used anymore.  */
410       global_init ();
411       break;
412
413     case GCRYCTL_ANY_INITIALIZATION_P:
414       if (any_init_done)
415         err = GPG_ERR_GENERAL;
416       break;
417
418     case GCRYCTL_INITIALIZATION_FINISHED_P:
419       if (init_finished)
420         err = GPG_ERR_GENERAL; /* Yes.  */
421       break;
422
423     case GCRYCTL_INITIALIZATION_FINISHED:
424       /* This is a hook which should be used by an application after
425          all initialization has been done and right before any threads
426          are started.  It is not really needed but the only way to be
427          really sure that all initialization for thread-safety has
428          been done. */
429       if (! init_finished)
430         {
431           global_init ();
432           /* Do only a basic random initialization, i.e. init the
433              mutexes. */
434           _gcry_random_initialize (0);
435           init_finished = 1;
436           /* Force us into operational state if in FIPS mode.  */
437           (void)fips_is_operational ();
438         }
439       break;
440
441     case GCRYCTL_SET_THREAD_CBS:
442       err = ath_install (va_arg (arg_ptr, void *), any_init_done);
443       if (! err)
444         global_init ();
445       break;
446
447     case GCRYCTL_FAST_POLL:
448       /* We need to do make sure that the random pool is really
449          initialized so that the poll function is not a NOP. */
450       _gcry_random_initialize (1);
451
452       if ( fips_is_operational () )
453         _gcry_fast_random_poll (); 
454       break;
455
456     case GCRYCTL_SET_RNDEGD_SOCKET:
457 #if USE_RNDEGD
458       err = _gcry_rndegd_set_socket_name (va_arg (arg_ptr, const char *));
459 #else
460       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
461 #endif
462       break;
463
464     case GCRYCTL_SET_RANDOM_DAEMON_SOCKET:
465       _gcry_set_random_daemon_socket (va_arg (arg_ptr, const char *));
466       break;
467
468     case GCRYCTL_USE_RANDOM_DAEMON:
469       /* We need to do make sure that the random pool is really
470          initialized so that the poll function is not a NOP. */
471       _gcry_random_initialize (1);
472       _gcry_use_random_daemon (!! va_arg (arg_ptr, int));
473       break;
474       
475       /* This command dumps information pertaining to the
476          configuration of libgcrypt to the given stream.  It may be
477          used before the intialization has been finished but not
478          before a gcry_version_check. */
479     case GCRYCTL_PRINT_CONFIG:
480       {
481         FILE *fp = va_arg (arg_ptr, FILE *);
482         print_config (fp?fprintf:_gcry_log_info_with_dummy_fp, fp);
483       }
484       break;
485
486     case GCRYCTL_OPERATIONAL_P:
487       /* Returns true if the library is in an operational state.  This
488          is always true for non-fips mode.  */
489       if (_gcry_fips_test_operational ())
490         err = GPG_ERR_GENERAL; /* Used as TRUE value */
491       break;
492
493     case GCRYCTL_FIPS_MODE_P:
494       if (fips_mode () 
495           && !_gcry_is_fips_mode_inactive () 
496           && !no_secure_memory)
497         err = GPG_ERR_GENERAL; /* Used as TRUE value */
498       break;
499
500     case GCRYCTL_FORCE_FIPS_MODE:
501       /* Performing this command puts the library into fips mode.  If
502          the library has already been initialized into fips mode, a
503          selftest is triggered.  it is not possible to put the libraty
504          into fips mode after having passed the initialization. */
505       if (!any_init_done)
506         {
507           /* Not yet intialized at all.  Set a flag so that we are put
508              into fips mode during initialization.  */
509           force_fips_mode = 1;
510         }
511       else 
512         {
513           /* Already initialized.  If we are already operational we
514              run a selftest.  If not we use the is_operational call to
515              force us into operational state if possible.  */
516           if (_gcry_fips_test_error_or_operational ())
517             _gcry_fips_run_selftests (1);
518           if (_gcry_fips_is_operational ())
519             err = GPG_ERR_GENERAL; /* Used as TRUE value */
520       }
521       break;
522
523     case GCRYCTL_SELFTEST:
524       /* Run a selftest.  This works in fips mode as well as in
525          standard mode.  In contrast to the power-up tests, we use an
526          extended version of the selftests. Returns 0 on success or an
527          error code. */
528       global_init ();
529       err = _gcry_fips_run_selftests (1);
530       break;
531
532     case 58:  /* Init external random test.  */
533       {
534         void **rctx        = va_arg (arg_ptr, void **);
535         unsigned int flags = va_arg (arg_ptr, unsigned int);
536         const void *key    = va_arg (arg_ptr, const void *);
537         size_t keylen      = va_arg (arg_ptr, size_t);
538         const void *seed   = va_arg (arg_ptr, const void *);
539         size_t seedlen     = va_arg (arg_ptr, size_t);
540         const void *dt     = va_arg (arg_ptr, const void *);
541         size_t dtlen       = va_arg (arg_ptr, size_t);
542         if (!fips_is_operational ())
543           err = fips_not_operational ();
544         else
545           err = _gcry_random_init_external_test (rctx, flags, key, keylen,
546                                                  seed, seedlen, dt, dtlen);
547       }
548       break;
549     case 59:  /* Run external random test.  */
550       {
551         void *ctx     = va_arg (arg_ptr, void *);
552         void *buffer  = va_arg (arg_ptr, void *);
553         size_t buflen = va_arg (arg_ptr, size_t);
554         if (!fips_is_operational ())
555           err = fips_not_operational ();
556         else
557           err = _gcry_random_run_external_test (ctx, buffer, buflen);
558       }
559       break;
560     case 60:  /* Deinit external random test.  */
561       {
562         void *ctx = va_arg (arg_ptr, void *);
563         _gcry_random_deinit_external_test (ctx);
564       }
565       break;
566
567
568     default:
569       err = GPG_ERR_INV_OP;
570     }
571
572   return gcry_error (err);
573 }
574
575
576 /* Command dispatcher function, acting as general control
577    function.  */
578 gcry_error_t
579 gcry_control (enum gcry_ctl_cmds cmd, ...)
580 {
581   gcry_error_t err;
582   va_list arg_ptr;
583   
584   va_start (arg_ptr, cmd);
585   err = _gcry_vcontrol (cmd, arg_ptr);
586   va_end(arg_ptr);
587   return err;
588 }
589
590
591
592 /* Return a pointer to a string containing a description of the error
593    code in the error value ERR.  */
594 const char *
595 gcry_strerror (gcry_error_t err)
596 {
597   return gpg_strerror (err);
598 }
599
600 /* Return a pointer to a string containing a description of the error
601    source in the error value ERR.  */
602 const char *
603 gcry_strsource (gcry_error_t err)
604 {
605   return gpg_strsource (err);
606 }
607
608 /* Retrieve the error code for the system error ERR.  This returns
609    GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped (report
610    this).  */
611 gcry_err_code_t
612 gcry_err_code_from_errno (int err)
613 {
614   return gpg_err_code_from_errno (err);
615 }
616
617
618 /* Retrieve the system error for the error code CODE.  This returns 0
619    if CODE is not a system error code.  */
620 int
621 gcry_err_code_to_errno (gcry_err_code_t code)
622 {
623   return gpg_err_code_from_errno (code);
624 }
625
626   
627 /* Return an error value with the error source SOURCE and the system
628    error ERR.  */
629 gcry_error_t
630 gcry_err_make_from_errno (gpg_err_source_t source, int err)
631 {
632   return gpg_err_make_from_errno (source, err);
633 }
634
635
636 /* Return an error value with the system error ERR.  */
637 gcry_err_code_t
638 gcry_error_from_errno (int err)
639 {
640   return gcry_error (gpg_err_code_from_errno (err));
641 }
642
643
644 /* Set custom allocation handlers.  This is in general not useful
645  * because the libgcrypt allocation functions are guaranteed to
646  * provide proper allocation handlers which zeroize memory if needed.
647  * NOTE: All 5 functions should be set.  */
648 void
649 gcry_set_allocation_handler (gcry_handler_alloc_t new_alloc_func,
650                              gcry_handler_alloc_t new_alloc_secure_func,
651                              gcry_handler_secure_check_t new_is_secure_func,
652                              gcry_handler_realloc_t new_realloc_func,
653                              gcry_handler_free_t new_free_func)
654 {
655   global_init ();
656
657   if (fips_mode ())
658     {
659       /* We do not want to enforce the fips mode, but merely set a
660          flag so that the application may check whether it is still in
661          fips mode.  */
662       _gcry_inactivate_fips_mode ("custom allocation handler");
663     }
664
665   alloc_func = new_alloc_func;
666   alloc_secure_func = new_alloc_secure_func;
667   is_secure_func = new_is_secure_func;
668   realloc_func = new_realloc_func;
669   free_func = new_free_func;
670 }
671
672
673
674 /****************
675  * Set an optional handler which is called in case the xmalloc functions
676  * ran out of memory.  This handler may do one of these things:
677  *   o free some memory and return true, so that the xmalloc function
678  *     tries again.
679  *   o Do whatever it like and return false, so that the xmalloc functions
680  *     use the default fatal error handler.
681  *   o Terminate the program and don't return.
682  *
683  * The handler function is called with 3 arguments:  The opaque value set with
684  * this function, the requested memory size, and a flag with these bits
685  * currently defined:
686  *      bit 0 set = secure memory has been requested.
687  */
688 void
689 gcry_set_outofcore_handler( int (*f)( void*, size_t, unsigned int ),
690                                                         void *value )
691 {
692   global_init ();
693
694   if (fips_mode () )
695     {
696       log_info ("out of core handler ignored in FIPS mode\n");
697       return;
698     }
699   
700   outofcore_handler = f;
701   outofcore_handler_value = value;
702 }
703
704 /* Return the no_secure_memory flag.  */
705 static int
706 get_no_secure_memory (void)
707 {
708   if (!no_secure_memory)
709     return 0;
710   if (_gcry_enforced_fips_mode ())
711     {
712       no_secure_memory = 0;
713       return 0;
714     }
715   return no_secure_memory;
716 }
717
718
719 static gcry_err_code_t
720 do_malloc (size_t n, unsigned int flags, void **mem)
721 {
722   gcry_err_code_t err = 0;
723   void *m;
724
725   if ((flags & GCRY_ALLOC_FLAG_SECURE) && !get_no_secure_memory ())
726     {
727       if (alloc_secure_func)
728         m = (*alloc_secure_func) (n);
729       else
730         m = _gcry_private_malloc_secure (n);
731     }
732   else
733     {
734       if (alloc_func)
735         m = (*alloc_func) (n);
736       else
737         m = _gcry_private_malloc (n);
738     }
739
740   if (!m)
741     {
742       /* Make sure that ERRNO has been set in case a user supplied
743          memory handler didn't it correctly. */
744       if (!errno)
745         errno = ENOMEM;
746       err = gpg_err_code_from_errno (errno);
747     }
748   else
749     *mem = m;
750
751   return err;
752 }
753   
754 void *
755 gcry_malloc (size_t n)
756 {
757   void *mem = NULL;
758
759   do_malloc (n, 0, &mem);
760
761   return mem;
762 }
763
764 void *
765 gcry_malloc_secure (size_t n)
766 {
767   void *mem = NULL;
768
769   do_malloc (n, GCRY_ALLOC_FLAG_SECURE, &mem);
770
771   return mem;
772 }
773
774 int
775 gcry_is_secure (const void *a)
776 {
777   if (get_no_secure_memory ())
778     return 0;
779   if (is_secure_func)
780     return is_secure_func (a) ;
781   return _gcry_private_is_secure (a);
782 }
783
784 void
785 _gcry_check_heap( const void *a )
786 {
787   (void)a;
788   
789     /* FIXME: implement this*/
790 #if 0
791     if( some_handler )
792         some_handler(a)
793     else
794         _gcry_private_check_heap(a)
795 #endif
796 }
797
798 void *
799 gcry_realloc (void *a, size_t n)
800 {
801   void *p;
802
803   if (realloc_func)
804     p = realloc_func (a, n);
805   else
806     p =  _gcry_private_realloc (a, n);
807   if (!p && !errno)
808     errno = ENOMEM;
809   return p;
810 }
811
812 void
813 gcry_free (void *p)
814 {
815   int save_errno;
816
817   if (!p)
818     return;
819
820   /* In case ERRNO is set we better save it so that the free machinery
821      may not accidently change ERRNO.  We restore it only if it was
822      already set to comply with the usual C semantic for ERRNO.  */
823   save_errno = errno;
824   if (free_func)
825     free_func (p);
826   else
827     _gcry_private_free (p);
828
829   if (save_errno)
830     errno = save_errno;
831 }
832
833 void *
834 gcry_calloc (size_t n, size_t m)
835 {
836   size_t bytes;
837   void *p;
838
839   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
840                     defined. */
841   if (m && bytes / m != n) 
842     {
843       errno = ENOMEM;
844       return NULL;
845     }
846
847   p = gcry_malloc (bytes);
848   if (p)
849     memset (p, 0, bytes);
850   return p;
851 }
852
853 void *
854 gcry_calloc_secure (size_t n, size_t m)
855 {
856   size_t bytes;
857   void *p;
858
859   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
860                     defined. */
861   if (m && bytes / m != n) 
862     {
863       errno = ENOMEM;
864       return NULL;
865     }
866   
867   p = gcry_malloc_secure (bytes);
868   if (p)
869     memset (p, 0, bytes);
870   return p;
871 }
872
873
874 /* Create and return a copy of the null-terminated string STRING.  If
875    it is contained in secure memory, the copy will be contained in
876    secure memory as well.  In an out-of-memory condition, NULL is
877    returned.  */
878 char *
879 gcry_strdup (const char *string)
880 {
881   char *string_cp = NULL;
882   size_t string_n = 0;
883
884   string_n = strlen (string);
885
886   if (gcry_is_secure (string))
887     string_cp = gcry_malloc_secure (string_n + 1);
888   else
889     string_cp = gcry_malloc (string_n + 1);
890   
891   if (string_cp)
892     strcpy (string_cp, string);
893
894   return string_cp;
895 }
896
897
898 void *
899 gcry_xmalloc( size_t n )
900 {
901   void *p;
902   
903   while ( !(p = gcry_malloc( n )) ) 
904     {
905       if ( fips_mode () 
906            || !outofcore_handler
907            || !outofcore_handler (outofcore_handler_value, n, 0) )
908         {
909           _gcry_fatal_error (gpg_err_code_from_errno (errno), NULL);
910         }
911     }
912     return p;
913 }
914
915 void *
916 gcry_xrealloc( void *a, size_t n )
917 {
918   void *p;
919   
920   while ( !(p = gcry_realloc( a, n )) )
921     {
922       if ( fips_mode ()
923            || !outofcore_handler
924            || !outofcore_handler (outofcore_handler_value, n,
925                                    gcry_is_secure(a)? 3:2 ) )
926         {
927           _gcry_fatal_error (gpg_err_code_from_errno (errno), NULL );
928         }
929     }
930     return p;
931 }
932
933 void *
934 gcry_xmalloc_secure( size_t n )
935 {
936   void *p;
937   
938   while ( !(p = gcry_malloc_secure( n )) ) 
939     {
940       if ( fips_mode ()
941            || !outofcore_handler
942            || !outofcore_handler (outofcore_handler_value, n, 1) )
943         {
944           _gcry_fatal_error (gpg_err_code_from_errno (errno),
945                              _("out of core in secure memory"));
946         }
947     }
948   return p;
949 }
950
951
952 void *
953 gcry_xcalloc( size_t n, size_t m )
954 {
955   size_t nbytes;
956   void *p;
957
958   nbytes = n * m; 
959   if (m && nbytes / m != n) 
960     {
961       errno = ENOMEM;
962       _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
963     }
964
965   p = gcry_xmalloc ( nbytes );
966   memset ( p, 0, nbytes );
967   return p;
968 }
969
970 void *
971 gcry_xcalloc_secure( size_t n, size_t m )
972 {
973   size_t nbytes;
974   void *p;
975
976   nbytes = n * m; 
977   if (m && nbytes / m != n) 
978     {
979       errno = ENOMEM;
980       _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
981     }
982
983   p = gcry_xmalloc_secure ( nbytes );
984   memset ( p, 0, nbytes );
985   return p;
986 }
987
988 char *
989 gcry_xstrdup (const char *string)
990 {
991   char *p;
992   
993   while ( !(p = gcry_strdup (string)) ) 
994     {
995       size_t n = strlen (string);
996       int is_sec = !!gcry_is_secure (string);
997       
998       if (fips_mode ()
999           || !outofcore_handler
1000           || !outofcore_handler (outofcore_handler_value, n, is_sec) ) 
1001         {
1002           _gcry_fatal_error (gpg_err_code_from_errno (errno),
1003                              is_sec? _("out of core in secure memory"):NULL);
1004         }
1005     }
1006
1007   return p;
1008 }
1009
1010
1011 int
1012 _gcry_get_debug_flag (unsigned int mask)
1013 {
1014   if ( fips_mode () )
1015     return 0;
1016   return (debug_flags & mask);
1017 }
1018
1019
1020 \f
1021 /* It is often useful to get some feedback of long running operations.
1022    This function may be used to register a handler for this. 
1023    The callback function CB is used as:
1024
1025    void cb (void *opaque, const char *what, int printchar,
1026            int current, int total);
1027
1028    Where WHAT is a string identifying the the type of the progress
1029    output, PRINTCHAR the character usually printed, CURRENT the amount
1030    of progress currently done and TOTAL the expected amount of
1031    progress.  A value of 0 for TOTAL indicates that there is no
1032    estimation available.
1033
1034    Defined values for WHAT:
1035
1036    "need_entropy"  X    0  number-of-bytes-required
1037             When running low on entropy
1038    "primegen"      '\n'  0 0
1039            Prime generated
1040                    '!'
1041            Need to refresh the prime pool
1042                    '<','>'
1043            Number of bits adjusted
1044                    '^'
1045            Looking for a generator
1046                    '.'
1047            Fermat tests on 10 candidates failed
1048                   ':'
1049            Restart with a new random value
1050                   '+'
1051            Rabin Miller test passed          
1052    "pk_elg"        '+','-','.','\n'   0  0
1053             Only used in debugging mode.
1054    "pk_dsa"       
1055             Only used in debugging mode.
1056 */
1057 void
1058 gcry_set_progress_handler (void (*cb)(void *,const char*,int, int, int),
1059                            void *cb_data)
1060 {
1061 #if USE_DSA
1062   _gcry_register_pk_dsa_progress (cb, cb_data);
1063 #endif
1064 #if USE_ELGAMAL
1065   _gcry_register_pk_elg_progress (cb, cb_data);
1066 #endif
1067   _gcry_register_primegen_progress (cb, cb_data);
1068   _gcry_register_random_progress (cb, cb_data);
1069 }