Page MenuHome GnuPG
Files F31766884

global.c
No OneTemporary
Actions

global.c
View Options

/* global.c - global control functions
* Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
*
* This file is part of Libgcrypt.
*
* Libgcrypt is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser general Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* Libgcrypt is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*/
#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <ctype.h>
#include <assert.h>
#include <limits.h>
#include <errno.h>
#include "g10lib.h"
#include "cipher.h"
#include "stdmem.h" /* our own memory allocator */
#include "secmem.h" /* our own secmem allocator */
#include "ath.h"
/****************
* flag bits: 0 : general cipher debug
* 1 : general MPI debug
*/
static unsigned int debug_flags;
static int last_ec; /* fixme: make thread safe */
static void *(*alloc_func)(size_t n) = NULL;
static void *(*alloc_secure_func)(size_t n) = NULL;
static int (*is_secure_func)(const void*) = NULL;
static void *(*realloc_func)(void *p, size_t n) = NULL;
static void (*free_func)(void*) = NULL;
static int (*outofcore_handler)( void*, size_t, unsigned int ) = NULL;
static void *outofcore_handler_value = NULL;
static int no_secure_memory = 0;
static int any_init_done;
/* This is out handmade constructore. It gets called by any function
likely to be called at startup. The suggested way for an
application to make sure that this has been called is by using
gcry_check_version. */
static void
global_init (void)
{
if (!any_init_done)
return;
any_init_done = 1;
ath_init ();
}
static const char*
parse_version_number( const char *s, int *number )
{
int val = 0;
if( *s == '0' && isdigit(s[1]) )
return NULL; /* leading zeros are not allowed */
for ( ; isdigit(*s); s++ ) {
val *= 10;
val += *s - '0';
}
*number = val;
return val < 0? NULL : s;
}
static const char *
parse_version_string( const char *s, int *major, int *minor, int *micro )
{
s = parse_version_number( s, major );
if( !s || *s != '.' )
return NULL;
s++;
s = parse_version_number( s, minor );
if( !s || *s != '.' )
return NULL;
s++;
s = parse_version_number( s, micro );
if( !s )
return NULL;
return s; /* patchlevel */
}
/****************
* Check that the the version of the library is at minimum the requested one
* and return the version string; return NULL if the condition is not
* satisfied. If a NULL is passed to this function, no check is done,
* but the version string is simply returned.
*/
const char *
gcry_check_version( const char *req_version )
{
const char *ver = VERSION;
int my_major, my_minor, my_micro;
int rq_major, rq_minor, rq_micro;
const char *my_plvl, *rq_plvl;
global_init ();
if ( !req_version )
return ver;
my_plvl = parse_version_string( ver, &my_major, &my_minor, &my_micro );
if ( !my_plvl )
return NULL; /* very strange our own version is bogus */
rq_plvl = parse_version_string( req_version, &rq_major, &rq_minor,
&rq_micro );
if ( !rq_plvl )
return NULL; /* req version string is invalid */
if ( my_major > rq_major
|| (my_major == rq_major && my_minor > rq_minor)
|| (my_major == rq_major && my_minor == rq_minor
&& my_micro > rq_micro)
|| (my_major == rq_major && my_minor == rq_minor
&& my_micro == rq_micro
&& strcmp( my_plvl, rq_plvl ) >= 0) ) {
return ver;
}
return NULL;
}
int
gcry_control( enum gcry_ctl_cmds cmd, ... )
{
static int init_finished = 0;
va_list arg_ptr ;
va_start( arg_ptr, cmd ) ;
switch( cmd ) {
#if 0
case GCRYCTL_NO_MEM_IS_FATAL:
break;
case GCRYCTL_SET_FATAL_FNC:
break;
#endif
case GCRYCTL_ENABLE_M_GUARD:
_gcry_private_enable_m_guard();
break;
case GCRYCTL_DUMP_RANDOM_STATS:
_gcry_random_dump_stats();
break;
case GCRYCTL_DUMP_MEMORY_STATS:
/*m_print_stats("[fixme: prefix]");*/
break;
case GCRYCTL_DUMP_SECMEM_STATS:
_gcry_secmem_dump_stats();
break;
case GCRYCTL_DROP_PRIVS:
global_init ();
_gcry_secmem_init( 0 );
break;
case GCRYCTL_DISABLE_SECMEM:
global_init ();
no_secure_memory = 1;
break;
case GCRYCTL_INIT_SECMEM:
global_init ();
_gcry_secmem_init( va_arg( arg_ptr, unsigned int ) );
break;
case GCRYCTL_TERM_SECMEM:
global_init ();
_gcry_secmem_term();
break;
case GCRYCTL_DISABLE_SECMEM_WARN:
_gcry_secmem_set_flags( (_gcry_secmem_get_flags() | 1) );
break;
case GCRYCTL_SUSPEND_SECMEM_WARN:
_gcry_secmem_set_flags( (_gcry_secmem_get_flags() | 2) );
break;
case GCRYCTL_RESUME_SECMEM_WARN:
_gcry_secmem_set_flags( (_gcry_secmem_get_flags() & ~2) );
break;
case GCRYCTL_USE_SECURE_RNDPOOL:
global_init ();
_gcry_secure_random_alloc(); /* put random number into secure memory */
break;
case GCRYCTL_SET_VERBOSITY:
_gcry_set_log_verbosity( va_arg( arg_ptr, int ) );
break;
case GCRYCTL_SET_DEBUG_FLAGS:
debug_flags |= va_arg( arg_ptr, unsigned int );
break;
case GCRYCTL_CLEAR_DEBUG_FLAGS:
debug_flags &= ~va_arg( arg_ptr, unsigned int );
break;
case GCRYCTL_DISABLE_INTERNAL_LOCKING:
global_init ();
/* We wase some bytes by doing it this way. OTOH this
function is not anymore required becuase it is done
automagically. */
ath_deinit ();
break;
case GCRYCTL_ANY_INITIALIZATION_P:
va_end(arg_ptr);
return any_init_done? -1 : 0;
case GCRYCTL_INITIALIZATION_FINISHED_P:
va_end(arg_ptr);
return init_finished? -1 : 0;
case GCRYCTL_INITIALIZATION_FINISHED:
/* This is a hook which should be used by an application after
all initialization has been done and right before any
threads are started. It is not really needed but the only
way to be really sure that all initialization for
thread-safety has been done. */
if (!init_finished) {
global_init ();
_gcry_random_initialize ();
init_finished = 1;
}
break;
default:
va_end(arg_ptr);
return GCRYERR_INV_OP;
}
va_end(arg_ptr);
return 0;
}
int
gcry_errno()
{
return last_ec;
}
const char*
gcry_strerror( int ec )
{
const char *s;
static char buf[20];
if( ec == -1 )
ec = gcry_errno();
#define X(n,a) case GCRYERR_##n : s = a; break;
switch( ec ) {
X(SUCCESS, N_("no error"))
X(GENERAL, N_("general error"))
X(INV_PK_ALGO, N_("invalid public key algorithm"))
X(INV_MD_ALGO, N_("invalid hash algorithm"))
X(BAD_PUBLIC_KEY ,N_("bad public key"))
X(BAD_SECRET_KEY ,N_("bad secret key"))
X(BAD_SIGNATURE , N_("bad signature"))
X(INV_CIPHER_ALGO,N_("invalid cipher algorithm"))
X(BAD_MPI, N_("bad big integer"))
X(WRONG_PK_ALGO, N_("unusable public key algorithm"))
X(WEAK_KEY, N_("weak encryption key"))
X(INV_KEYLEN, N_("invalid key length"))
X(INV_ARG, N_("invalid argument"))
X(SELFTEST, N_("selftest failed"))
X(INV_OP, N_("invalid operation code or ctl command"))
X(NO_MEM, N_("out of core"))
X(INTERNAL, N_("internal error"))
X(EOF, N_("EOF"))
X(INV_OBJ, N_("an object is not valid"))
X(TOO_SHORT, N_("provided buffer too short"))
X(TOO_LARGE, N_("object is too large"))
X(NO_OBJ, N_("no object"))
X(NOT_IMPL, N_("not implemented"))
X(CONFLICT, N_("conflict"))
X(INV_CIPHER_MODE,N_("invalid cipher mode"))
X(SEXP_INV_LEN_SPEC ,N_("invalid length specification"))
X(SEXP_STRING_TOO_LONG,N_("string too long"))
X(SEXP_UNMATCHED_PAREN,N_("unmatched parenthesis"))
X(SEXP_NOT_CANONICAL ,N_("not a canonical S-expression"))
X(SEXP_BAD_CHARACTER ,N_("bad character"))
X(SEXP_BAD_QUOTATION ,N_("invalid hex/octal value or bad quotation"))
X(SEXP_ZERO_PREFIX ,N_("a length may not begin with zero"))
X(SEXP_NESTED_DH ,N_("nested display hints"))
X(SEXP_UNMATCHED_DH ,N_("unmatched display hint close"))
X(SEXP_UNEXPECTED_PUNC,N_("unexpected reserved punctuation"))
X(SEXP_BAD_HEX_CHAR, N_("invalid hex character"))
X(SEXP_ODD_HEX_NUMBERS,N_("odd number of hex characters"))
X(SEXP_BAD_OCT_CHAR, N_("invalid octal character"))
default:
sprintf( buf, "ec=%d", ec );
s = buf;
}
#undef X
return s;
}
int
_gcry_set_lasterr( int ec )
{
if( ec )
last_ec = ec == -1 ? GCRYERR_EOF : ec;
return ec;
}
/****************
* NOTE: All 5 functions should be set. */
void
gcry_set_allocation_handler( void *(*new_alloc_func)(size_t n),
void *(*new_alloc_secure_func)(size_t n),
int (*new_is_secure_func)(const void*),
void *(*new_realloc_func)(void *p, size_t n),
void (*new_free_func)(void*) )
{
global_init ();
alloc_func = new_alloc_func;
alloc_secure_func = new_alloc_secure_func;
is_secure_func = new_is_secure_func;
realloc_func = new_realloc_func;
free_func = new_free_func;
}
/****************
* Set an optional handler which is called in case the xmalloc functions
* ran out of memory. This handler may do one of these things:
* o free some memory and return true, so that the xmalloc function
* tries again.
* o Do whatever it like and return false, so that the xmalloc functions
* use the default fatal error handler.
* o Terminate the program and don't return.
*
* The handler function is called with 3 arguments: The opaque value set with
* this function, the requested memory size, and a flag with these bits
* currently defined:
* bit 0 set = secure memory has been requested.
*/
void
gcry_set_outofcore_handler( int (*f)( void*, size_t, unsigned int ),
void *value )
{
global_init ();
outofcore_handler = f;
outofcore_handler_value = value;
}
void *
gcry_malloc( size_t n )
{
if( alloc_func )
return alloc_func( n ) ;
return _gcry_private_malloc( n );
}
void *
gcry_malloc_secure( size_t n )
{
if (no_secure_memory)
return gcry_malloc (n);
if (alloc_secure_func)
return alloc_secure_func (n) ;
return _gcry_private_malloc_secure (n);
}
int
gcry_is_secure( const void *a )
{
if (no_secure_memory)
return 0;
if (is_secure_func)
return is_secure_func (a) ;
return _gcry_private_is_secure (a);
}
void
_gcry_check_heap( const void *a )
{
/* FIXME: implement this*/
#if 0
if( some_handler )
some_handler(a)
else
_gcry_private_check_heap(a)
#endif
}
void *
gcry_realloc( void *a, size_t n )
{
/* FIXME: Make sure that the realloced memory is cleared out */
if( realloc_func )
return realloc_func( a, n ) ;
return _gcry_private_realloc( a, n );
}
void
gcry_free( void *p )
{
if( !p )
return;
if( free_func )
free_func( p );
else
_gcry_private_free( p );
}
void *
gcry_calloc (size_t n, size_t m)
{
size_t bytes;
void *p;
bytes = n * m; /* size_t is unsigned so the behavior on overflow is defined. */
if (m && bytes / m != n)
{
errno = ENOMEM;
return NULL;
}
p = gcry_malloc (bytes);
if (p)
memset (p, 0, bytes);
return p;
}
void *
gcry_calloc_secure (size_t n, size_t m)
{
size_t bytes;
void *p;
bytes = n * m; /* size_t is unsigned so the behavior on overflow is defined. */
if (m && bytes / m != n)
{
errno = ENOMEM;
return NULL;
}
p = gcry_malloc_secure (bytes);
if (p)
memset (p, 0, bytes);
return p;
}
char *
gcry_strdup( const char *string )
{
void *p = gcry_malloc( strlen(string)+1 );
strcpy( p, string );
return p;
}
void *
gcry_xmalloc( size_t n )
{
void *p;
while ( !(p = gcry_malloc( n )) ) {
if( !outofcore_handler
|| !outofcore_handler( outofcore_handler_value, n, 0 ) ) {
_gcry_fatal_error(GCRYERR_NO_MEM, NULL );
}
}
return p;
}
void *
gcry_xrealloc( void *a, size_t n )
{
void *p;
while ( !(p = gcry_realloc( a, n )) ) {
if( !outofcore_handler
|| !outofcore_handler( outofcore_handler_value, n, 2 ) ) {
_gcry_fatal_error(GCRYERR_NO_MEM, NULL );
}
}
return p;
}
void *
gcry_xmalloc_secure( size_t n )
{
void *p;
while ( !(p = gcry_malloc_secure( n )) ) {
if( !outofcore_handler
|| !outofcore_handler( outofcore_handler_value, n, 1 ) ) {
_gcry_fatal_error(GCRYERR_NO_MEM,
_("out of core in secure memory"));
}
}
return p;
}
void *
gcry_xcalloc( size_t n, size_t m )
{
void *p = gcry_xmalloc( n*m );
memset( p, 0, n*m );
return p;
}
void *
gcry_xcalloc_secure( size_t n, size_t m )
{
void *p = gcry_xmalloc_secure( n* m );
memset( p, 0, n*m );
return p;
}
char *
gcry_xstrdup( const char *string )
{
void *p = gcry_xmalloc( strlen(string)+1 );
strcpy( p, string );
return p;
}
int
_gcry_get_debug_flag( unsigned int mask )
{
return debug_flags & mask;
}
/* It is often useful to get some feedback of long running operations.
This function may be used to register a handler for this.
The callback function CB is used as:
void cb (void *opaque, const char *what, int printchar,
int current, int total);
Where WHAT is a string identifying the the type of the progress
output, PRINTCHAR the character usually printed, CURRENT the amount
of progress currently done and TOTAL the expected amount of
progress. A value of 0 for TOTAL indicates that there is no
estimation available.
*/
void
gcry_set_progress_handler (void (*cb)(void *,const char*,int, int, int),
void *cb_data)
{
_gcry_register_pk_dsa_progress (cb, cb_data);
_gcry_register_pk_elg_progress (cb, cb_data);
_gcry_register_primegen_progress (cb, cb_data);
}

File Metadata

Mime Type
text/x-c
Expires
Thu, Nov 6, 3:22 PM (2 h, 45 m)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
da/50/a5dc2170aa837f0657702e136760

Event Timeline