[thirdparty/openssl.git] / crypto / err / err.c

/* crypto/err/err.c */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 * 
 * This library is free for commercial and non-commercial use as long as
 * the following conditions are aheared to.  The following conditions
 * apply to all code found in this distribution, be it the RC4, RSA,
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
 * included with this distribution is covered by the same copyright terms
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
 * 
 * Copyright remains Eric Young's, and as such any Copyright notices in
 * the code are not to be removed.
 * If this package is used in a product, Eric Young should be given attribution
 * as the author of the parts of the library used.
 * This can be in the form of a textual message at program startup or
 * in documentation (online or textual) provided with the package.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *    "This product includes cryptographic software written by
 *     Eric Young (eay@cryptsoft.com)"
 *    The word 'cryptographic' can be left out if the rouines from the library
 *    being used are not cryptographic related :-).
 * 4. If you include any Windows specific code (or a derivative thereof) from 
 *    the apps directory (application code) you must include an acknowledgement:
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
 * 
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * 
 * The licence and distribution terms for any publically available version or
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
 * copied and put under another distribution licence
 * [including the GNU Public Licence.]
 */

#include <stdio.h>
#include "lhash.h"
#include "crypto.h"
#include "cryptlib.h"
#include "buffer.h"
#include "err.h"
#include "crypto.h"


static LHASH *error_hash=NULL;
static LHASH *thread_hash=NULL;

#ifndef NOPROTO
static unsigned long err_hash(ERR_STRING_DATA *a);
static int err_cmp(ERR_STRING_DATA *a, ERR_STRING_DATA *b);
static unsigned long pid_hash(ERR_STATE *pid);
static int pid_cmp(ERR_STATE *a,ERR_STATE *pid);
static unsigned long get_error_values(int inc,const char **file,int *line,
				      const char **data,int *flags);
static void ERR_STATE_free(ERR_STATE *s);
#else
static unsigned long err_hash();
static int err_cmp();
static unsigned long pid_hash();
static int pid_cmp();
static unsigned long get_error_values();
static void ERR_STATE_free();
ERR_STATE *s;
#endif

#ifndef NO_ERR
static ERR_STRING_DATA ERR_str_libraries[]=
	{
{ERR_PACK(ERR_LIB_NONE,0,0)		,"unknown library"},
{ERR_PACK(ERR_LIB_SYS,0,0)		,"system library"},
{ERR_PACK(ERR_LIB_BN,0,0)		,"bignum routines"},
{ERR_PACK(ERR_LIB_RSA,0,0)		,"rsa routines"},
{ERR_PACK(ERR_LIB_DH,0,0)		,"Diffie-Hellman routines"},
{ERR_PACK(ERR_LIB_EVP,0,0)		,"digital envelope routines"},
{ERR_PACK(ERR_LIB_BUF,0,0)		,"memory buffer routines"},
{ERR_PACK(ERR_LIB_BIO,0,0)		,"BIO routines"},
{ERR_PACK(ERR_LIB_OBJ,0,0)		,"object identifier routines"},
{ERR_PACK(ERR_LIB_PEM,0,0)		,"PEM routines"},
{ERR_PACK(ERR_LIB_ASN1,0,0)		,"asn1 encoding routines"},
{ERR_PACK(ERR_LIB_X509,0,0)		,"x509 certificate routines"},
{ERR_PACK(ERR_LIB_CONF,0,0)		,"configuation file routines"},
{ERR_PACK(ERR_LIB_METH,0,0)		,"X509 lookup 'method' routines"},
{ERR_PACK(ERR_LIB_SSL,0,0)		,"SSL routines"},
{ERR_PACK(ERR_LIB_RSAREF,0,0)		,"RSAref routines"},
{ERR_PACK(ERR_LIB_PROXY,0,0)		,"Proxy routines"},
{ERR_PACK(ERR_LIB_BIO,0,0)		,"BIO routines"},
{ERR_PACK(ERR_LIB_PKCS7,0,0)		,"PKCS7 routines"},
{ERR_PACK(ERR_LIB_X509V3,0,0)		,"X509 V3 routines"},
{ERR_PACK(ERR_LIB_PKCS12,0,0)		,"PKCS12 routines"},
{0,NULL},
	};

static ERR_STRING_DATA ERR_str_functs[]=
	{
	{ERR_PACK(0,SYS_F_FOPEN,0),     	"fopen"},
	{ERR_PACK(0,SYS_F_CONNECT,0),		"connect"},
	{ERR_PACK(0,SYS_F_GETSERVBYNAME,0),	"getservbyname"},
	{ERR_PACK(0,SYS_F_SOCKET,0),		"socket"}, 
	{ERR_PACK(0,SYS_F_IOCTLSOCKET,0),	"ioctlsocket"},
	{ERR_PACK(0,SYS_F_BIND,0),		"bind"},
	{ERR_PACK(0,SYS_F_LISTEN,0),		"listen"},
	{ERR_PACK(0,SYS_F_ACCEPT,0),		"accept"},
#ifdef WINDOWS
	{ERR_PACK(0,SYS_F_WSASTARTUP,0),	"WSAstartup"},
#endif
	{0,NULL},
	};

static ERR_STRING_DATA ERR_str_reasons[]=
	{
{ERR_R_FATAL                             ,"fatal"},
{ERR_R_SYS_LIB				,"system lib"},
{ERR_R_BN_LIB				,"BN lib"},
{ERR_R_RSA_LIB				,"RSA lib"},
{ERR_R_DH_LIB				,"DH lib"},
{ERR_R_EVP_LIB				,"EVP lib"},
{ERR_R_BUF_LIB				,"BUF lib"},
{ERR_R_BIO_LIB				,"BIO lib"},
{ERR_R_OBJ_LIB				,"OBJ lib"},
{ERR_R_PEM_LIB				,"PEM lib"},
{ERR_R_X509_LIB				,"X509 lib"},
{ERR_R_METH_LIB				,"METH lib"},
{ERR_R_ASN1_LIB				,"ASN1 lib"},
{ERR_R_CONF_LIB				,"CONF lib"},
{ERR_R_SSL_LIB				,"SSL lib"},
{ERR_R_PROXY_LIB			,"PROXY lib"},
{ERR_R_BIO_LIB				,"BIO lib"},
{ERR_R_PKCS7_LIB			,"PKCS7 lib"},
{ERR_R_PKCS12_LIB			,"PKCS12 lib"},
{ERR_R_MALLOC_FAILURE			,"Malloc failure"},
{ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED	,"called a fuction you should not call"},
{ERR_R_PASSED_NULL_PARAMETER		,"passed a null parameter"},
{ERR_R_NESTED_ASN1_ERROR		,"nested asn1 error"},
{ERR_R_BAD_ASN1_OBJECT_HEADER		,"bad asn1 object header"},
{ERR_R_BAD_GET_ASN1_OBJECT_CALL		,"bad get asn1 object call"},
{ERR_R_EXPECTING_AN_ASN1_SEQUENCE	,"expecting an asn1 sequence"},
{ERR_R_ASN1_LENGTH_MISMATCH		,"asn1 length mismatch"},
{ERR_R_MISSING_ASN1_EOS			,"missing asn1 eos"},

{0,NULL},
	};
#endif

#define err_clear_data(p,i) \
	if (((p)->err_data[i] != NULL) && \
		(p)->err_data_flags[i] & ERR_TXT_MALLOCED) \
		{  \
		Free((p)->err_data[i]); \
		(p)->err_data[i]=NULL; \
		} \
	(p)->err_data_flags[i]=0;

static void ERR_STATE_free(ERR_STATE *s)
	{
	int i;

	if(s == NULL)
	    return;

	for (i=0; i<ERR_NUM_ERRORS; i++)
		{
		err_clear_data(s,i);
		}
	Free(s);
	}

void ERR_load_ERR_strings(void)
	{
	static int init=1;

	if (init)
		{
		CRYPTO_w_lock(CRYPTO_LOCK_ERR);
		if (init == 0)
			{
			CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
			return;
			}
		init=0;
		CRYPTO_w_unlock(CRYPTO_LOCK_ERR);

#ifndef NO_ERR
		ERR_load_strings(0,ERR_str_libraries);
		ERR_load_strings(0,ERR_str_reasons);
		ERR_load_strings(ERR_LIB_SYS,ERR_str_functs);
#endif
		}
	}

void ERR_load_strings(int lib, ERR_STRING_DATA *str)
	{
	if (error_hash == NULL)
		{
		CRYPTO_w_lock(CRYPTO_LOCK_ERR_HASH);
		error_hash=lh_new(err_hash,err_cmp);
		if (error_hash == NULL)
			{
			CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH);
			return;
			}
		CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH);

		ERR_load_ERR_strings();
		}

	CRYPTO_w_lock(CRYPTO_LOCK_ERR_HASH);
	while (str->error)
		{
		str->error|=ERR_PACK(lib,0,0);
		lh_insert(error_hash,(char *)str);
		str++;
		}
	CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH);
	}

void ERR_free_strings(void)
	{
	CRYPTO_w_lock(CRYPTO_LOCK_ERR);

	if (error_hash != NULL)
		{
		lh_free(error_hash);
		error_hash=NULL;
		}

	CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
	}

/********************************************************/

void ERR_put_error(int lib, int func, int reason, const char *file,
	     int line)
	{
	ERR_STATE *es;

	es=ERR_get_state();

	es->top=(es->top+1)%ERR_NUM_ERRORS;
	if (es->top == es->bottom)
		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
	es->err_file[es->top]=file;
	es->err_line[es->top]=line;
	err_clear_data(es,es->top);
	}

void ERR_clear_error(void)
	{
	ERR_STATE *es;

	es=ERR_get_state();

#if 0
	/* hmm... is this needed */
	for (i=0; i<ERR_NUM_ERRORS; i++)
		{
		es->err_buffer[i]=0;
		es->err_file[i]=NULL;
		es->err_line[i]= -1;
		err_clear_data(es,i);
		}
#endif
	es->top=es->bottom=0;
	}


unsigned long ERR_get_error(void)
	{ return(get_error_values(1,NULL,NULL,NULL,NULL)); }

unsigned long ERR_get_error_line(const char **file,
	     int *line)
	{ return(get_error_values(1,file,line,NULL,NULL)); }

unsigned long ERR_get_error_line_data(const char **file, int *line,
	     const char **data, int *flags)
	{ return(get_error_values(1,file,line,
	     data,flags)); }

unsigned long ERR_peek_error(void)
	{ return(get_error_values(0,NULL,NULL,NULL,NULL)); }

unsigned long ERR_peek_error_line(const char **file,
	     int *line)
	{ return(get_error_values(0,file,line,NULL,NULL)); }

unsigned long ERR_peek_error_line_data(const char **file, int *line,
	     const char **data, int *flags)
	{ return(get_error_values(0,file,line,
	     data,flags)); }

static unsigned long get_error_values(int inc, const char **file, int *line,
	     const char **data, int *flags)
	{	
	int i=0;
	ERR_STATE *es;
	unsigned long ret;

	es=ERR_get_state();

	if (es->bottom == es->top) return(0);
	i=(es->bottom+1)%ERR_NUM_ERRORS;

	ret=es->err_buffer[i];
	if (inc)
		{
		es->bottom=i;
		es->err_buffer[i]=0;
		}

	if ((file != NULL) && (line != NULL))
		{
		if (es->err_file[i] == NULL)
			{
			*file="NA";
			if (line != NULL) *line=0;
			}
		else
			{
			*file=es->err_file[i];
			if (line != NULL) *line=es->err_line[i];
			}
		}

	if (data != NULL)
		{
		if (es->err_data[i] == NULL)
			{
			*data="";
			if (flags != NULL) *flags=0;
			}
		else
			{
			*data=es->err_data[i];
			if (flags != NULL) *flags=es->err_data_flags[i];
			}
		}
	return(ret);
	}

/* BAD for multi-threaded, uses a local buffer if ret == NULL */
char *ERR_error_string(unsigned long e, char *ret)
	{
	static char buf[256];
	const char *ls,*fs,*rs;
	unsigned long l,f,r;
	int i;

	l=ERR_GET_LIB(e);
	f=ERR_GET_FUNC(e);
	r=ERR_GET_REASON(e);

	ls=ERR_lib_error_string(e);
	fs=ERR_func_error_string(e);
	rs=ERR_reason_error_string(e);

	if (ret == NULL) ret=buf;

	sprintf(&(ret[0]),"error:%08lX:",e);
	i=strlen(ret);
	if (ls == NULL)
		sprintf(&(ret[i]),":lib(%lu) ",l);
	else	sprintf(&(ret[i]),"%s",ls);
	i=strlen(ret);
	if (fs == NULL)
		sprintf(&(ret[i]),":func(%lu) ",f);
	else	sprintf(&(ret[i]),":%s",fs);
	i=strlen(ret);
	if (rs == NULL)
		sprintf(&(ret[i]),":reason(%lu)",r);
	else	sprintf(&(ret[i]),":%s",rs);

	return(ret);
	}

LHASH *ERR_get_string_table(void)
	{
	return(error_hash);
	}

LHASH *ERR_get_err_state_table(void)
	{
	return(thread_hash);
	}

const char *ERR_lib_error_string(unsigned long e)
	{
	ERR_STRING_DATA d,*p=NULL;
	unsigned long l;

	l=ERR_GET_LIB(e);

	CRYPTO_r_lock(CRYPTO_LOCK_ERR_HASH);

	if (error_hash != NULL)
		{
		d.error=ERR_PACK(l,0,0);
		p=(ERR_STRING_DATA *)lh_retrieve(error_hash,(char *)&d);
		}

	CRYPTO_r_unlock(CRYPTO_LOCK_ERR_HASH);

	return((p == NULL)?NULL:p->string);
	}

const char *ERR_func_error_string(unsigned long e)
	{
	ERR_STRING_DATA d,*p=NULL;
	unsigned long l,f;

	l=ERR_GET_LIB(e);
	f=ERR_GET_FUNC(e);

	CRYPTO_r_lock(CRYPTO_LOCK_ERR_HASH);

	if (error_hash != NULL)
		{
		d.error=ERR_PACK(l,f,0);
		p=(ERR_STRING_DATA *)lh_retrieve(error_hash,(char *)&d);
		}

	CRYPTO_r_unlock(CRYPTO_LOCK_ERR_HASH);

	return((p == NULL)?NULL:p->string);
	}

const char *ERR_reason_error_string(unsigned long e)
	{
	ERR_STRING_DATA d,*p=NULL;
	unsigned long l,r;

	l=ERR_GET_LIB(e);
	r=ERR_GET_REASON(e);

	CRYPTO_r_lock(CRYPTO_LOCK_ERR_HASH);

	if (error_hash != NULL)
		{
		d.error=ERR_PACK(l,0,r);
		p=(ERR_STRING_DATA *)lh_retrieve(error_hash,(char *)&d);
		if (p == NULL)
			{
			d.error=ERR_PACK(0,0,r);
			p=(ERR_STRING_DATA *)lh_retrieve(error_hash,
				(char *)&d);
			}
		}

	CRYPTO_r_unlock(CRYPTO_LOCK_ERR_HASH);

	return((p == NULL)?NULL:p->string);
	}

static unsigned long err_hash(ERR_STRING_DATA *a)
	{
	unsigned long ret,l;

	l=a->error;
	ret=l^ERR_GET_LIB(l)^ERR_GET_FUNC(l);
	return(ret^ret%19*13);
	}

static int err_cmp(ERR_STRING_DATA *a, ERR_STRING_DATA *b)
	{
	return((int)(a->error-b->error));
	}

static unsigned long pid_hash(ERR_STATE *a)
	{
	return(a->pid*13);
	}

static int pid_cmp(ERR_STATE *a, ERR_STATE *b)
	{
	return((int)((long)a->pid - (long)b->pid));
	}

void ERR_remove_state(unsigned long pid)
	{
	ERR_STATE *p,tmp;

	if (thread_hash == NULL)
		return;
	if (pid == 0)
		pid=(unsigned long)CRYPTO_thread_id();
	tmp.pid=pid;
	CRYPTO_w_lock(CRYPTO_LOCK_ERR);
	p=(ERR_STATE *)lh_delete(thread_hash,(char *)&tmp);
	CRYPTO_w_unlock(CRYPTO_LOCK_ERR);

	if (p != NULL) ERR_STATE_free(p);
	}

ERR_STATE *ERR_get_state(void)
	{
	static ERR_STATE fallback;
	ERR_STATE *ret=NULL,tmp,*tmpp;
	int i;
	unsigned long pid;

	pid=(unsigned long)CRYPTO_thread_id();

	CRYPTO_r_lock(CRYPTO_LOCK_ERR);
	if (thread_hash == NULL)
		{
		CRYPTO_r_unlock(CRYPTO_LOCK_ERR);
		CRYPTO_w_lock(CRYPTO_LOCK_ERR);
		if (thread_hash == NULL)
			{
			MemCheck_off();
			thread_hash=lh_new(pid_hash,pid_cmp);
			MemCheck_on();
			CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
			if (thread_hash == NULL) return(&fallback);
			}
		else
			CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
		}
	else
		{
		tmp.pid=pid;
		ret=(ERR_STATE *)lh_retrieve(thread_hash,(char *)&tmp);
		CRYPTO_r_unlock(CRYPTO_LOCK_ERR);
		}

	/* ret == the error state, if NULL, make a new one */
	if (ret == NULL)
		{
		ret=(ERR_STATE *)Malloc(sizeof(ERR_STATE));
		if (ret == NULL) return(&fallback);
		ret->pid=pid;
		ret->top=0;
		ret->bottom=0;
		for (i=0; i<ERR_NUM_ERRORS; i++)
			{
			ret->err_data[i]=NULL;
			ret->err_data_flags[i]=0;
			}
		CRYPTO_w_lock(CRYPTO_LOCK_ERR);
		tmpp=(ERR_STATE *)lh_insert(thread_hash,(char *)ret);
		CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
		if (tmpp != NULL) /* old entry - should not happen */
			{
			ERR_STATE_free(tmpp);
			}
		}
	return(ret);
	}

int ERR_get_next_error_library(void)
	{
	static int value=ERR_LIB_USER;

	return(value++);
	}

void ERR_set_error_data(char *data, int flags)
	{
	ERR_STATE *es;
	int i;

	es=ERR_get_state();

	i=es->top;
	if (i == 0)
		i=ERR_NUM_ERRORS-1;

	es->err_data[i]=data;
	es->err_data_flags[es->top]=flags;
	}

void ERR_add_error_data( VAR_PLIST(int , num))
VAR_ALIST
        {
        VAR_BDEFN(args, int, num);
	int i,n,s;
	char *str,*p,*a;

	s=64;
	str=Malloc(s+1);
	if (str == NULL) return;
	str[0]='\0';

	VAR_INIT(args,int,num);
	n=0;
	for (i=0; i<num; i++)
		{
		VAR_ARG(args,char *,a);
		/* ignore NULLs, thanks to Bob Beck <beck@obtuse.com> */
		if (a != NULL)
			{
			n+=strlen(a);
			if (n > s)
				{
				s=n+20;
				p=Realloc(str,s+1);
				if (p == NULL)
					{
					Free(str);
					return;
					}
				else
					str=p;
				}
			strcat(str,a);
			}
		}
	ERR_set_error_data(str,ERR_TXT_MALLOCED|ERR_TXT_STRING);

	VAR_END( args );
	}
Commit	Line	Data
d02b48c6	1	/* crypto/err/err.c */
58964a49	2	/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
d02b48c6 RE	3	* All rights reserved.
	4	*
	5	* This package is an SSL implementation written
	6	* by Eric Young (eay@cryptsoft.com).
	7	* The implementation was written so as to conform with Netscapes SSL.
	8	*
	9	* This library is free for commercial and non-commercial use as long as
	10	* the following conditions are aheared to. The following conditions
	11	* apply to all code found in this distribution, be it the RC4, RSA,
	12	* lhash, DES, etc., code; not just the SSL code. The SSL documentation
	13	* included with this distribution is covered by the same copyright terms
	14	* except that the holder is Tim Hudson (tjh@cryptsoft.com).
	15	*
	16	* Copyright remains Eric Young's, and as such any Copyright notices in
	17	* the code are not to be removed.
	18	* If this package is used in a product, Eric Young should be given attribution
	19	* as the author of the parts of the library used.
	20	* This can be in the form of a textual message at program startup or
	21	* in documentation (online or textual) provided with the package.
	22	*
	23	* Redistribution and use in source and binary forms, with or without
	24	* modification, are permitted provided that the following conditions
	25	* are met:
	26	* 1. Redistributions of source code must retain the copyright
	27	* notice, this list of conditions and the following disclaimer.
	28	* 2. Redistributions in binary form must reproduce the above copyright
	29	* notice, this list of conditions and the following disclaimer in the
	30	* documentation and/or other materials provided with the distribution.
	31	* 3. All advertising materials mentioning features or use of this software
	32	* must display the following acknowledgement:
	33	* "This product includes cryptographic software written by
	34	* Eric Young (eay@cryptsoft.com)"
	35	* The word 'cryptographic' can be left out if the rouines from the library
	36	* being used are not cryptographic related :-).
	37	* 4. If you include any Windows specific code (or a derivative thereof) from
	38	* the apps directory (application code) you must include an acknowledgement:
	39	* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
	40	*
	41	* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
	42	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	43	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	44	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
	45	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	46	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	47	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	48	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	49	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	50	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	51	* SUCH DAMAGE.
	52	*
	53	* The licence and distribution terms for any publically available version or
	54	* derivative of this code cannot be changed. i.e. this code cannot simply be
	55	* copied and put under another distribution licence
	56	* [including the GNU Public Licence.]
	57	*/
	58
	59	#include <stdio.h>
	60	#include "lhash.h"
	61	#include "crypto.h"
	62	#include "cryptlib.h"
	63	#include "buffer.h"
	64	#include "err.h"
	65	#include "crypto.h"
	66
67
68	static LHASH *error_hash=NULL;
69	static LHASH *thread_hash=NULL;
70
71	#ifndef NOPROTO
72	static unsigned long err_hash(ERR_STRING_DATA *a);
73	static int err_cmp(ERR_STRING_DATA a, ERR_STRING_DATA b);
74	static unsigned long pid_hash(ERR_STATE *pid);
75	static int pid_cmp(ERR_STATE a,ERR_STATE pid);
e778802f BL	76	static unsigned long get_error_values(int inc,const char *file,int line,
e778802f BL	77	const char *data,int flags);
58964a49	78	static void ERR_STATE_free(ERR_STATE *s);
d02b48c6 RE	79	#else
	80	static unsigned long err_hash();
	81	static int err_cmp();
	82	static unsigned long pid_hash();
	83	static int pid_cmp();
dfeab068	84	static unsigned long get_error_values();
58964a49 RE	85	static void ERR_STATE_free();
58964a49 RE	86	ERR_STATE *s;
d02b48c6 RE	87	#endif
	88
	89	#ifndef NO_ERR
	90	static ERR_STRING_DATA ERR_str_libraries[]=
	91	{
	92	{ERR_PACK(ERR_LIB_NONE,0,0) ,"unknown library"},
	93	{ERR_PACK(ERR_LIB_SYS,0,0) ,"system library"},
	94	{ERR_PACK(ERR_LIB_BN,0,0) ,"bignum routines"},
	95	{ERR_PACK(ERR_LIB_RSA,0,0) ,"rsa routines"},
	96	{ERR_PACK(ERR_LIB_DH,0,0) ,"Diffie-Hellman routines"},
	97	{ERR_PACK(ERR_LIB_EVP,0,0) ,"digital envelope routines"},
	98	{ERR_PACK(ERR_LIB_BUF,0,0) ,"memory buffer routines"},
	99	{ERR_PACK(ERR_LIB_BIO,0,0) ,"BIO routines"},
	100	{ERR_PACK(ERR_LIB_OBJ,0,0) ,"object identifier routines"},
	101	{ERR_PACK(ERR_LIB_PEM,0,0) ,"PEM routines"},
	102	{ERR_PACK(ERR_LIB_ASN1,0,0) ,"asn1 encoding routines"},
	103	{ERR_PACK(ERR_LIB_X509,0,0) ,"x509 certificate routines"},
	104	{ERR_PACK(ERR_LIB_CONF,0,0) ,"configuation file routines"},
	105	{ERR_PACK(ERR_LIB_METH,0,0) ,"X509 lookup 'method' routines"},
	106	{ERR_PACK(ERR_LIB_SSL,0,0) ,"SSL routines"},
	107	{ERR_PACK(ERR_LIB_RSAREF,0,0) ,"RSAref routines"},
	108	{ERR_PACK(ERR_LIB_PROXY,0,0) ,"Proxy routines"},
	109	{ERR_PACK(ERR_LIB_BIO,0,0) ,"BIO routines"},
	110	{ERR_PACK(ERR_LIB_PKCS7,0,0) ,"PKCS7 routines"},
834eeef9	111	{ERR_PACK(ERR_LIB_X509V3,0,0) ,"X509 V3 routines"},
67d5ac03	112	{ERR_PACK(ERR_LIB_PKCS12,0,0) ,"PKCS12 routines"},
d02b48c6 RE	113	{0,NULL},
	114	};
	115
	116	static ERR_STRING_DATA ERR_str_functs[]=
	117	{
	118	{ERR_PACK(0,SYS_F_FOPEN,0), "fopen"},
	119	{ERR_PACK(0,SYS_F_CONNECT,0), "connect"},
	120	{ERR_PACK(0,SYS_F_GETSERVBYNAME,0), "getservbyname"},
	121	{ERR_PACK(0,SYS_F_SOCKET,0), "socket"},
	122	{ERR_PACK(0,SYS_F_IOCTLSOCKET,0), "ioctlsocket"},
	123	{ERR_PACK(0,SYS_F_BIND,0), "bind"},
	124	{ERR_PACK(0,SYS_F_LISTEN,0), "listen"},
	125	{ERR_PACK(0,SYS_F_ACCEPT,0), "accept"},
	126	#ifdef WINDOWS
	127	{ERR_PACK(0,SYS_F_WSASTARTUP,0), "WSAstartup"},
	128	#endif
	129	{0,NULL},
	130	};
	131
	132	static ERR_STRING_DATA ERR_str_reasons[]=
	133	{
	134	{ERR_R_FATAL ,"fatal"},
	135	{ERR_R_SYS_LIB ,"system lib"},
	136	{ERR_R_BN_LIB ,"BN lib"},
	137	{ERR_R_RSA_LIB ,"RSA lib"},
	138	{ERR_R_DH_LIB ,"DH lib"},
	139	{ERR_R_EVP_LIB ,"EVP lib"},
	140	{ERR_R_BUF_LIB ,"BUF lib"},
	141	{ERR_R_BIO_LIB ,"BIO lib"},
	142	{ERR_R_OBJ_LIB ,"OBJ lib"},
	143	{ERR_R_PEM_LIB ,"PEM lib"},
	144	{ERR_R_X509_LIB ,"X509 lib"},
	145	{ERR_R_METH_LIB ,"METH lib"},
	146	{ERR_R_ASN1_LIB ,"ASN1 lib"},
	147	{ERR_R_CONF_LIB ,"CONF lib"},
	148	{ERR_R_SSL_LIB ,"SSL lib"},
	149	{ERR_R_PROXY_LIB ,"PROXY lib"},
	150	{ERR_R_BIO_LIB ,"BIO lib"},
	151	{ERR_R_PKCS7_LIB ,"PKCS7 lib"},
67d5ac03	152	{ERR_R_PKCS12_LIB ,"PKCS12 lib"},
d02b48c6 RE	153	{ERR_R_MALLOC_FAILURE ,"Malloc failure"},
d02b48c6 RE	154	{ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED ,"called a fuction you should not call"},
dfeab068 RE	155	{ERR_R_PASSED_NULL_PARAMETER ,"passed a null parameter"},
	156	{ERR_R_NESTED_ASN1_ERROR ,"nested asn1 error"},
	157	{ERR_R_BAD_ASN1_OBJECT_HEADER ,"bad asn1 object header"},
	158	{ERR_R_BAD_GET_ASN1_OBJECT_CALL ,"bad get asn1 object call"},
	159	{ERR_R_EXPECTING_AN_ASN1_SEQUENCE ,"expecting an asn1 sequence"},
	160	{ERR_R_ASN1_LENGTH_MISMATCH ,"asn1 length mismatch"},
	161	{ERR_R_MISSING_ASN1_EOS ,"missing asn1 eos"},
	162
d02b48c6 RE	163	{0,NULL},
	164	};
	165	#endif
	166
58964a49 RE	167	#define err_clear_data(p,i) \
	168	if (((p)->err_data[i] != NULL) && \
	169	(p)->err_data_flags[i] & ERR_TXT_MALLOCED) \
	170	{ \
	171	Free((p)->err_data[i]); \
	172	(p)->err_data[i]=NULL; \
	173	} \
	174	(p)->err_data_flags[i]=0;
	175
6b691a5c	176	static void ERR_STATE_free(ERR_STATE *s)
58964a49 RE	177	{
	178	int i;
	179
e03ddfae BL	180	if(s == NULL)
	181	return;
	182
58964a49 RE	183	for (i=0; i<ERR_NUM_ERRORS; i++)
	184	{
	185	err_clear_data(s,i);
	186	}
	187	Free(s);
	188	}
	189
6b691a5c	190	void ERR_load_ERR_strings(void)
d02b48c6 RE	191	{
	192	static int init=1;
	193
	194	if (init)
	195	{
	196	CRYPTO_w_lock(CRYPTO_LOCK_ERR);
	197	if (init == 0)
	198	{
	199	CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
	200	return;
	201	}
	202	init=0;
	203	CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
	204
	205	#ifndef NO_ERR
	206	ERR_load_strings(0,ERR_str_libraries);
	207	ERR_load_strings(0,ERR_str_reasons);
	208	ERR_load_strings(ERR_LIB_SYS,ERR_str_functs);
	209	#endif
	210	}
	211	}
	212
6b691a5c	213	void ERR_load_strings(int lib, ERR_STRING_DATA *str)
d02b48c6 RE	214	{
	215	if (error_hash == NULL)
	216	{
	217	CRYPTO_w_lock(CRYPTO_LOCK_ERR_HASH);
	218	error_hash=lh_new(err_hash,err_cmp);
	219	if (error_hash == NULL)
	220	{
	221	CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH);
	222	return;
	223	}
	224	CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH);
	225
	226	ERR_load_ERR_strings();
	227	}
	228
	229	CRYPTO_w_lock(CRYPTO_LOCK_ERR_HASH);
	230	while (str->error)
	231	{
	232	str->error\|=ERR_PACK(lib,0,0);
	233	lh_insert(error_hash,(char *)str);
	234	str++;
	235	}
	236	CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH);
	237	}
	238
6b691a5c	239	void ERR_free_strings(void)
d02b48c6 RE	240	{
	241	CRYPTO_w_lock(CRYPTO_LOCK_ERR);
	242
	243	if (error_hash != NULL)
	244	{
	245	lh_free(error_hash);
	246	error_hash=NULL;
	247	}
	248
	249	CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
	250	}
	251
58964a49 RE	252	/********************************************************/
58964a49 RE	253
6b691a5c UM	254	void ERR_put_error(int lib, int func, int reason, const char *file,
6b691a5c UM	255	int line)
d02b48c6 RE	256	{
	257	ERR_STATE *es;
	258
	259	es=ERR_get_state();
	260
	261	es->top=(es->top+1)%ERR_NUM_ERRORS;
	262	if (es->top == es->bottom)
	263	es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
	264	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
	265	es->err_file[es->top]=file;
	266	es->err_line[es->top]=line;
58964a49	267	err_clear_data(es,es->top);
d02b48c6 RE	268	}
d02b48c6 RE	269
6b691a5c	270	void ERR_clear_error(void)
d02b48c6	271	{
d02b48c6 RE	272	ERR_STATE *es;
	273
	274	es=ERR_get_state();
	275
58964a49 RE	276	#if 0
58964a49 RE	277	/* hmm... is this needed */
d02b48c6 RE	278	for (i=0; i<ERR_NUM_ERRORS; i++)
	279	{
	280	es->err_buffer[i]=0;
	281	es->err_file[i]=NULL;
	282	es->err_line[i]= -1;
58964a49	283	err_clear_data(es,i);
d02b48c6	284	}
58964a49	285	#endif
d02b48c6 RE	286	es->top=es->bottom=0;
	287	}
	288
d02b48c6	289
6b691a5c	290	unsigned long ERR_get_error(void)
58964a49	291	{ return(get_error_values(1,NULL,NULL,NULL,NULL)); }
d02b48c6	292
6b691a5c UM	293	unsigned long ERR_get_error_line(const char **file,
6b691a5c UM	294	int *line)
58964a49	295	{ return(get_error_values(1,file,line,NULL,NULL)); }
d02b48c6	296
6b691a5c UM	297	unsigned long ERR_get_error_line_data(const char *file, int line,
	298	const char *data, int flags)
	299	{ return(get_error_values(1,file,line,
	300	data,flags)); }
d02b48c6	301
6b691a5c	302	unsigned long ERR_peek_error(void)
58964a49	303	{ return(get_error_values(0,NULL,NULL,NULL,NULL)); }
d02b48c6	304
6b691a5c UM	305	unsigned long ERR_peek_error_line(const char **file,
6b691a5c UM	306	int *line)
58964a49	307	{ return(get_error_values(0,file,line,NULL,NULL)); }
d02b48c6	308
6b691a5c UM	309	unsigned long ERR_peek_error_line_data(const char *file, int line,
	310	const char *data, int flags)
	311	{ return(get_error_values(0,file,line,
	312	data,flags)); }
	313
	314	static unsigned long get_error_values(int inc, const char *file, int line,
	315	const char *data, int flags)
58964a49 RE	316	{
58964a49 RE	317	int i=0;
d02b48c6	318	ERR_STATE *es;
58964a49	319	unsigned long ret;
d02b48c6 RE	320
	321	es=ERR_get_state();
	322
58964a49	323	if (es->bottom == es->top) return(0);
d02b48c6	324	i=(es->bottom+1)%ERR_NUM_ERRORS;
58964a49 RE	325
	326	ret=es->err_buffer[i];
	327	if (inc)
d02b48c6	328	{
58964a49 RE	329	es->bottom=i;
58964a49 RE	330	es->err_buffer[i]=0;
d02b48c6	331	}
58964a49 RE	332
58964a49 RE	333	if ((file != NULL) && (line != NULL))
d02b48c6	334	{
58964a49 RE	335	if (es->err_file[i] == NULL)
	336	{
	337	*file="NA";
	338	if (line != NULL) *line=0;
	339	}
	340	else
	341	{
	342	*file=es->err_file[i];
	343	if (line != NULL) *line=es->err_line[i];
	344	}
d02b48c6	345	}
d02b48c6	346
58964a49 RE	347	if (data != NULL)
	348	{
	349	if (es->err_data[i] == NULL)
	350	{
	351	*data="";
	352	if (flags != NULL) *flags=0;
	353	}
	354	else
	355	{
	356	*data=es->err_data[i];
	357	if (flags != NULL) *flags=es->err_data_flags[i];
	358	}
	359	}
d02b48c6 RE	360	return(ret);
	361	}
	362
	363	/* BAD for multi-threaded, uses a local buffer if ret == NULL */
6b691a5c	364	char ERR_error_string(unsigned long e, char ret)
d02b48c6 RE	365	{
d02b48c6 RE	366	static char buf[256];
e778802f	367	const char ls,fs,*rs;
d02b48c6 RE	368	unsigned long l,f,r;
	369	int i;
	370
	371	l=ERR_GET_LIB(e);
	372	f=ERR_GET_FUNC(e);
	373	r=ERR_GET_REASON(e);
	374
	375	ls=ERR_lib_error_string(e);
	376	fs=ERR_func_error_string(e);
	377	rs=ERR_reason_error_string(e);
	378
	379	if (ret == NULL) ret=buf;
	380
	381	sprintf(&(ret[0]),"error:%08lX:",e);
	382	i=strlen(ret);
	383	if (ls == NULL)
	384	sprintf(&(ret[i]),":lib(%lu) ",l);
	385	else sprintf(&(ret[i]),"%s",ls);
	386	i=strlen(ret);
	387	if (fs == NULL)
	388	sprintf(&(ret[i]),":func(%lu) ",f);
	389	else sprintf(&(ret[i]),":%s",fs);
	390	i=strlen(ret);
	391	if (rs == NULL)
	392	sprintf(&(ret[i]),":reason(%lu)",r);
	393	else sprintf(&(ret[i]),":%s",rs);
	394
	395	return(ret);
	396	}
	397
6b691a5c	398	LHASH *ERR_get_string_table(void)
d02b48c6 RE	399	{
	400	return(error_hash);
	401	}
	402
6b691a5c	403	LHASH *ERR_get_err_state_table(void)
d02b48c6 RE	404	{
	405	return(thread_hash);
	406	}
	407
6b691a5c	408	const char *ERR_lib_error_string(unsigned long e)
d02b48c6 RE	409	{
	410	ERR_STRING_DATA d,*p=NULL;
	411	unsigned long l;
	412
	413	l=ERR_GET_LIB(e);
	414
	415	CRYPTO_r_lock(CRYPTO_LOCK_ERR_HASH);
	416
	417	if (error_hash != NULL)
	418	{
	419	d.error=ERR_PACK(l,0,0);
	420	p=(ERR_STRING_DATA )lh_retrieve(error_hash,(char )&d);
	421	}
	422
	423	CRYPTO_r_unlock(CRYPTO_LOCK_ERR_HASH);
	424
	425	return((p == NULL)?NULL:p->string);
	426	}
	427
6b691a5c	428	const char *ERR_func_error_string(unsigned long e)
d02b48c6 RE	429	{
	430	ERR_STRING_DATA d,*p=NULL;
	431	unsigned long l,f;
	432
	433	l=ERR_GET_LIB(e);
	434	f=ERR_GET_FUNC(e);
	435
	436	CRYPTO_r_lock(CRYPTO_LOCK_ERR_HASH);
	437
	438	if (error_hash != NULL)
	439	{
	440	d.error=ERR_PACK(l,f,0);
	441	p=(ERR_STRING_DATA )lh_retrieve(error_hash,(char )&d);
	442	}
	443
	444	CRYPTO_r_unlock(CRYPTO_LOCK_ERR_HASH);
	445
	446	return((p == NULL)?NULL:p->string);
	447	}
	448
6b691a5c	449	const char *ERR_reason_error_string(unsigned long e)
d02b48c6 RE	450	{
	451	ERR_STRING_DATA d,*p=NULL;
	452	unsigned long l,r;
	453
	454	l=ERR_GET_LIB(e);
	455	r=ERR_GET_REASON(e);
	456
	457	CRYPTO_r_lock(CRYPTO_LOCK_ERR_HASH);
	458
	459	if (error_hash != NULL)
	460	{
	461	d.error=ERR_PACK(l,0,r);
	462	p=(ERR_STRING_DATA )lh_retrieve(error_hash,(char )&d);
	463	if (p == NULL)
	464	{
	465	d.error=ERR_PACK(0,0,r);
	466	p=(ERR_STRING_DATA *)lh_retrieve(error_hash,
	467	(char *)&d);
	468	}
	469	}
	470
	471	CRYPTO_r_unlock(CRYPTO_LOCK_ERR_HASH);
	472
	473	return((p == NULL)?NULL:p->string);
	474	}
	475
6b691a5c	476	static unsigned long err_hash(ERR_STRING_DATA *a)
d02b48c6 RE	477	{
	478	unsigned long ret,l;
	479
	480	l=a->error;
	481	ret=l^ERR_GET_LIB(l)^ERR_GET_FUNC(l);
	482	return(ret^ret%19*13);
	483	}
	484
6b691a5c	485	static int err_cmp(ERR_STRING_DATA a, ERR_STRING_DATA b)
d02b48c6 RE	486	{
	487	return((int)(a->error-b->error));
	488	}
	489
6b691a5c	490	static unsigned long pid_hash(ERR_STATE *a)
d02b48c6 RE	491	{
	492	return(a->pid*13);
	493	}
	494
6b691a5c	495	static int pid_cmp(ERR_STATE a, ERR_STATE b)
d02b48c6 RE	496	{
	497	return((int)((long)a->pid - (long)b->pid));
	498	}
	499
6b691a5c	500	void ERR_remove_state(unsigned long pid)
d02b48c6 RE	501	{
	502	ERR_STATE *p,tmp;
	503
	504	if (thread_hash == NULL)
	505	return;
	506	if (pid == 0)
	507	pid=(unsigned long)CRYPTO_thread_id();
	508	tmp.pid=pid;
	509	CRYPTO_w_lock(CRYPTO_LOCK_ERR);
	510	p=(ERR_STATE )lh_delete(thread_hash,(char )&tmp);
d02b48c6	511	CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
58964a49 RE	512
58964a49 RE	513	if (p != NULL) ERR_STATE_free(p);
d02b48c6 RE	514	}
d02b48c6 RE	515
6b691a5c	516	ERR_STATE *ERR_get_state(void)
d02b48c6 RE	517	{
	518	static ERR_STATE fallback;
	519	ERR_STATE ret=NULL,tmp,tmpp;
58964a49	520	int i;
d02b48c6 RE	521	unsigned long pid;
	522
	523	pid=(unsigned long)CRYPTO_thread_id();
	524
	525	CRYPTO_r_lock(CRYPTO_LOCK_ERR);
	526	if (thread_hash == NULL)
	527	{
	528	CRYPTO_r_unlock(CRYPTO_LOCK_ERR);
	529	CRYPTO_w_lock(CRYPTO_LOCK_ERR);
	530	if (thread_hash == NULL)
	531	{
dfeab068	532	MemCheck_off();
d02b48c6	533	thread_hash=lh_new(pid_hash,pid_cmp);
dfeab068	534	MemCheck_on();
d02b48c6 RE	535	CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
	536	if (thread_hash == NULL) return(&fallback);
	537	}
	538	else
	539	CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
	540	}
	541	else
	542	{
	543	tmp.pid=pid;
	544	ret=(ERR_STATE )lh_retrieve(thread_hash,(char )&tmp);
	545	CRYPTO_r_unlock(CRYPTO_LOCK_ERR);
	546	}
	547
	548	/* ret == the error state, if NULL, make a new one */
	549	if (ret == NULL)
	550	{
	551	ret=(ERR_STATE *)Malloc(sizeof(ERR_STATE));
	552	if (ret == NULL) return(&fallback);
	553	ret->pid=pid;
	554	ret->top=0;
	555	ret->bottom=0;
58964a49 RE	556	for (i=0; i<ERR_NUM_ERRORS; i++)
	557	{
	558	ret->err_data[i]=NULL;
	559	ret->err_data_flags[i]=0;
	560	}
d02b48c6 RE	561	CRYPTO_w_lock(CRYPTO_LOCK_ERR);
	562	tmpp=(ERR_STATE )lh_insert(thread_hash,(char )ret);
	563	CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
	564	if (tmpp != NULL) /* old entry - should not happen */
58964a49 RE	565	{
	566	ERR_STATE_free(tmpp);
	567	}
d02b48c6 RE	568	}
	569	return(ret);
	570	}
	571
6b691a5c	572	int ERR_get_next_error_library(void)
58964a49 RE	573	{
	574	static int value=ERR_LIB_USER;
	575
	576	return(value++);
	577	}
	578
6b691a5c	579	void ERR_set_error_data(char *data, int flags)
58964a49 RE	580	{
	581	ERR_STATE *es;
	582	int i;
	583
	584	es=ERR_get_state();
	585
	586	i=es->top;
	587	if (i == 0)
	588	i=ERR_NUM_ERRORS-1;
	589
	590	es->err_data[i]=data;
	591	es->err_data_flags[es->top]=flags;
	592	}
	593
	594	void ERR_add_error_data( VAR_PLIST(int , num))
	595	VAR_ALIST
	596	{
	597	VAR_BDEFN(args, int, num);
	598	int i,n,s;
	599	char str,p,*a;
	600
	601	s=64;
	602	str=Malloc(s+1);
	603	if (str == NULL) return;
	604	str[0]='\0';
	605
	606	VAR_INIT(args,int,num);
	607	n=0;
	608	for (i=0; i<num; i++)
	609	{
	610	VAR_ARG(args,char *,a);
dfeab068 RE	611	/* ignore NULLs, thanks to Bob Beck <beck@obtuse.com> */
dfeab068 RE	612	if (a != NULL)
58964a49	613	{
dfeab068 RE	614	n+=strlen(a);
dfeab068 RE	615	if (n > s)
58964a49	616	{
dfeab068 RE	617	s=n+20;
	618	p=Realloc(str,s+1);
	619	if (p == NULL)
	620	{
	621	Free(str);
	622	return;
	623	}
	624	else
	625	str=p;
58964a49	626	}
dfeab068	627	strcat(str,a);
58964a49	628	}
58964a49 RE	629	}
	630	ERR_set_error_data(str,ERR_TXT_MALLOCED\|ERR_TXT_STRING);
	631
	632	VAR_END( args );
	633	}
	634