#include <openssl/crypto.h>
#include "cryptlib.h"
#include <openssl/buffer.h>
-#include <openssl/err.h>
-#include <openssl/crypto.h>
#include <openssl/bio.h>
+#include <openssl/err.h>
static LHASH *error_hash=NULL;
{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_DSA,0,0) ,"dsa 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"},
static void build_SYS_str_reasons()
{
- /* Malloc cannot be used here, use static storage instead */
+ /* OPENSSL_malloc cannot be used here, use static storage instead */
static char strerror_tab[NUM_SYS_STR_REASONS][LEN_SYS_STR_REASON];
int i;
if (((p)->err_data[i] != NULL) && \
(p)->err_data_flags[i] & ERR_TXT_MALLOCED) \
{ \
- Free((p)->err_data[i]); \
+ OPENSSL_free((p)->err_data[i]); \
(p)->err_data[i]=NULL; \
} \
(p)->err_data_flags[i]=0;
{
err_clear_data(s,i);
}
- Free(s);
+ OPENSSL_free(s);
}
void ERR_load_ERR_strings(void)
static char buf[256];
if (ret == NULL) ret=buf;
- ERR_error_string_n(e, buf, 256);
+ ERR_error_string_n(e, ret, 256);
return(ret);
}
return(error_hash);
}
+/* not thread-safe */
LHASH *ERR_get_err_state_table(void)
{
return(thread_hash);
l=ERR_GET_LIB(e);
- CRYPTO_r_lock(CRYPTO_LOCK_ERR_HASH);
+ CRYPTO_w_lock(CRYPTO_LOCK_ERR_HASH);
if (error_hash != NULL)
{
p=(ERR_STRING_DATA *)lh_retrieve(error_hash,&d);
}
- CRYPTO_r_unlock(CRYPTO_LOCK_ERR_HASH);
+ CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH);
return((p == NULL)?NULL:p->string);
}
l=ERR_GET_LIB(e);
f=ERR_GET_FUNC(e);
- CRYPTO_r_lock(CRYPTO_LOCK_ERR_HASH);
+ CRYPTO_w_lock(CRYPTO_LOCK_ERR_HASH);
if (error_hash != NULL)
{
p=(ERR_STRING_DATA *)lh_retrieve(error_hash,&d);
}
- CRYPTO_r_unlock(CRYPTO_LOCK_ERR_HASH);
+ CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH);
return((p == NULL)?NULL:p->string);
}
l=ERR_GET_LIB(e);
r=ERR_GET_REASON(e);
- CRYPTO_r_lock(CRYPTO_LOCK_ERR_HASH);
+ CRYPTO_w_lock(CRYPTO_LOCK_ERR_HASH);
if (error_hash != NULL)
{
}
}
- CRYPTO_r_unlock(CRYPTO_LOCK_ERR_HASH);
+ CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH);
return((p == NULL)?NULL:p->string);
}
void ERR_remove_state(unsigned long pid)
{
- ERR_STATE *p,tmp;
+ ERR_STATE *p = NULL,tmp;
if (thread_hash == NULL)
return;
pid=(unsigned long)CRYPTO_thread_id();
tmp.pid=pid;
CRYPTO_w_lock(CRYPTO_LOCK_ERR);
- p=(ERR_STATE *)lh_delete(thread_hash,&tmp);
+ if (thread_hash)
+ {
+ p=(ERR_STATE *)lh_delete(thread_hash,&tmp);
+ if (lh_num_items(thread_hash) == 0)
+ {
+ /* make sure we don't leak memory */
+ lh_free(thread_hash);
+ thread_hash = NULL;
+ }
+ }
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;
+ ERR_STATE *ret=NULL,tmp,*tmpp=NULL;
+ int thread_state_exists;
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
+ CRYPTO_w_lock(CRYPTO_LOCK_ERR);
+ if (thread_hash != NULL)
{
tmp.pid=pid;
ret=(ERR_STATE *)lh_retrieve(thread_hash,&tmp);
- CRYPTO_r_unlock(CRYPTO_LOCK_ERR);
}
+ CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
/* ret == the error state, if NULL, make a new one */
if (ret == NULL)
{
- ret=(ERR_STATE *)Malloc(sizeof(ERR_STATE));
+ ret=(ERR_STATE *)OPENSSL_malloc(sizeof(ERR_STATE));
if (ret == NULL) return(&fallback);
ret->pid=pid;
ret->top=0;
ret->err_data[i]=NULL;
ret->err_data_flags[i]=0;
}
+
CRYPTO_w_lock(CRYPTO_LOCK_ERR);
- tmpp=(ERR_STATE *)lh_insert(thread_hash,ret);
+
+ /* no entry yet in thread_hash for current thread -
+ * thus, it may have changed since we last looked at it */
+ if (thread_hash == NULL)
+ thread_hash = lh_new(pid_hash, pid_cmp);
+ if (thread_hash == NULL)
+ thread_state_exists = 0; /* allocation error */
+ else
+ {
+ tmpp=(ERR_STATE *)lh_insert(thread_hash,ret);
+ thread_state_exists = 1;
+ }
+
CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
+
+ if (!thread_state_exists)
+ {
+ ERR_STATE_free(ret); /* could not insert it */
+ return(&fallback);
+ }
+
if (tmpp != NULL) /* old entry - should not happen */
{
ERR_STATE_free(tmpp);
char *str,*p,*a;
s=64;
- str=Malloc(s+1);
+ str=OPENSSL_malloc(s+1);
if (str == NULL) return;
str[0]='\0';
if (n > s)
{
s=n+20;
- p=Realloc(str,s+1);
+ p=OPENSSL_realloc(str,s+1);
if (p == NULL)
{
- Free(str);
+ OPENSSL_free(str);
return;
}
else