- Don't assume that int and size_t have the same representation
(and that malloc can be called with an int argument). - Use proper prototypes (with argument list) for various function pointers, avoid casts (however there are still many such cases left in these files). - Avoid collissions in app_info_cmp if sizeof int != sizeof long. - Use CRYPTO_LOCK_MALLOC in mem_dbg.c.
This commit is contained in:
Bodo Möller
parent
03c48fa07b
commit
0cd08cce17
@ -63,6 +63,8 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#ifndef NO_FP_API
|
||||
#include <stdio.h>
|
||||
#endif
|
||||
@ -157,18 +159,11 @@ extern "C" {
|
||||
/* Adds thread number to the memory checking information */
|
||||
#define V_CRYPTO_MDEBUG_THREAD 0x2 /* a bit */
|
||||
|
||||
/*
|
||||
typedef struct crypto_mem_st
|
||||
{
|
||||
char *(*malloc_func)();
|
||||
char *(*realloc_func)();
|
||||
void (*free_func)();
|
||||
} CRYPTO_MEM_FUNC;
|
||||
*/
|
||||
|
||||
/* predec of the BIO type */
|
||||
typedef struct bio_st BIO_dummy;
|
||||
|
||||
|
||||
typedef struct crypto_ex_data_st
|
||||
{
|
||||
STACK *sk;
|
||||
@ -205,20 +200,11 @@ typedef struct crypto_ex_data_func_st
|
||||
#define CRYPTO_EX_INDEX_X509_STORE_CTX 5
|
||||
|
||||
|
||||
#if 0 /* unnecessary, it's the default and cannot be changed back later anyway */
|
||||
/* This is the default callbacks, but we can have others as well */
|
||||
#define CRYPTO_malloc_init() CRYPTO_set_mem_functions(\
|
||||
(char *(*)())malloc,\
|
||||
(char *(*)())realloc,\
|
||||
(void (*)())free)
|
||||
|
||||
#define CRYPTO_malloc_debug_init() do {\
|
||||
CRYPTO_set_mem_debug_functions(\
|
||||
(void (*)())CRYPTO_dbg_malloc,\
|
||||
(void (*)())CRYPTO_dbg_realloc,\
|
||||
(void (*)())CRYPTO_dbg_free,\
|
||||
(void (*)())CRYPTO_dbg_set_options,\
|
||||
(int (*)())CRYPTO_dbg_get_options);\
|
||||
} while(0)
|
||||
malloc, realloc, free)
|
||||
#endif
|
||||
|
||||
#if defined CRYPTO_MDEBUG_ALL || defined CRYPTO_MDEBUG_TIME || defined CRYPTO_MDEBUG_THREAD
|
||||
# ifndef CRYPTO_MDEBUG /* avoid duplicate #define */
|
||||
@ -226,11 +212,28 @@ typedef struct crypto_ex_data_func_st
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Set standard debugging functions (not done by default
|
||||
* unless CRYPTO_MDEBUG ist defined) */
|
||||
#define CRYPTO_malloc_debug_init() do {\
|
||||
CRYPTO_set_mem_debug_functions(\
|
||||
(void (*)())CRYPTO_dbg_malloc,\
|
||||
(void (*)())CRYPTO_dbg_realloc,\
|
||||
(void (*)())CRYPTO_dbg_free,\
|
||||
(void (*)())CRYPTO_dbg_set_options,\
|
||||
(long (*)())CRYPTO_dbg_get_options);\
|
||||
} while(0)
|
||||
|
||||
int CRYPTO_mem_ctrl(int mode);
|
||||
int CRYPTO_is_mem_check_on(void);
|
||||
|
||||
/* for applications */
|
||||
#define MemCheck_start() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON)
|
||||
#define MemCheck_stop() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_OFF)
|
||||
|
||||
/* for library-internal use */
|
||||
#define MemCheck_on() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE)
|
||||
#define MemCheck_off() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE)
|
||||
#define is_MemCheck_on() CRYPTO_mem_check_on()
|
||||
#define is_MemCheck_on() CRYPTO_is_mem_check_on()
|
||||
|
||||
#define Malloc(num) CRYPTO_malloc((int)num,__FILE__,__LINE__)
|
||||
#define Realloc(addr,num) \
|
||||
@ -261,8 +264,6 @@ int CRYPTO_dup_ex_data(STACK *meth,CRYPTO_EX_DATA *from,CRYPTO_EX_DATA *to);
|
||||
void CRYPTO_free_ex_data(STACK *meth,char *obj,CRYPTO_EX_DATA *ad);
|
||||
void CRYPTO_new_ex_data(STACK *meth, char *obj, CRYPTO_EX_DATA *ad);
|
||||
|
||||
int CRYPTO_mem_ctrl(int mode);
|
||||
int CRYPTO_mem_check_on(void);
|
||||
int CRYPTO_get_new_lockid(char *name);
|
||||
|
||||
int CRYPTO_num_locks(void); /* return CRYPTO_NUM_LOCKS (shared libs!) */
|
||||
@ -282,14 +283,14 @@ const char *CRYPTO_get_lock_name(int type);
|
||||
int CRYPTO_add_lock(int *pointer,int amount,int type, const char *file,
|
||||
int line);
|
||||
|
||||
void CRYPTO_set_mem_functions(char *(*m)(),char *(*r)(), void (*f)());
|
||||
void CRYPTO_set_mem_debug_functions(void (*m)(),void (*r)(),void (*f)(),void (*so)(),int (*go)());
|
||||
void CRYPTO_set_mem_debug_options(int bits);
|
||||
void CRYPTO_get_mem_functions(char *(**m)(),char *(**r)(), void (**f)());
|
||||
void CRYPTO_get_mem_debug_functions(void (**m)(),void (**r)(),void (**f)(),void (**so)(),int (**go)());
|
||||
int CRYPTO_get_mem_debug_options();
|
||||
void CRYPTO_set_locked_mem_functions(char *(*m)(), void (*free_func)());
|
||||
void CRYPTO_get_locked_mem_functions(char *(**m)(), void (**f)());
|
||||
/* CRYPTO_set_mem_functions includes CRYPTO_set_locked_mem_functions --
|
||||
* call the latter last if you need different functions */
|
||||
int CRYPTO_set_mem_functions(void *(*m)(size_t),void *(*r)(void *,size_t), void (*f)(void *));
|
||||
int CRYPTO_set_locked_mem_functions(void *(*m)(size_t), void (*free_func)(void *));
|
||||
int CRYPTO_set_mem_debug_functions(void (*m)(),void (*r)(),void (*f)(),void (*so)(),long (*go)());
|
||||
void CRYPTO_get_mem_functions(void *(**m)(size_t),void *(**r)(void *, size_t), void (**f)(void *));
|
||||
void CRYPTO_get_locked_mem_functions(void *(**m)(size_t), void (**f)(void *));
|
||||
void CRYPTO_get_mem_debug_functions(void (**m)(),void (**r)(),void (**f)(),void (**so)(),long (**go)());
|
||||
|
||||
void *CRYPTO_malloc_locked(int num, char *file, int line);
|
||||
void CRYPTO_free_locked(void *);
|
||||
@ -298,7 +299,12 @@ void CRYPTO_free(void *);
|
||||
void *CRYPTO_realloc(void *addr,int num, char *file, int line);
|
||||
void *CRYPTO_remalloc(void *addr,int num, char *file, int line);
|
||||
|
||||
int CRYPTO_add_info(const char *file, int line, const char *info);
|
||||
void CRYPTO_set_mem_debug_options(long bits);
|
||||
long CRYPTO_get_mem_debug_options();
|
||||
|
||||
#define CRYPTO_add_info(info) \
|
||||
CRYPTO_add_info_(info, __FILE__, __LINE__);
|
||||
int CRYPTO_add_info_(const char *file, int line, const char *info);
|
||||
int CRYPTO_remove_info(void);
|
||||
int CRYPTO_remove_all_info(void);
|
||||
|
||||
@ -319,8 +325,8 @@ void CRYPTO_dbg_free(void *addr,int before_p);
|
||||
* 2: Set the "Show Thread Number" option.
|
||||
* 3: 1 + 2
|
||||
*/
|
||||
void CRYPTO_dbg_set_options(int num);
|
||||
int CRYPTO_dbg_get_options();
|
||||
void CRYPTO_dbg_set_options(long bits);
|
||||
long CRYPTO_dbg_get_options();
|
||||
|
||||
#ifndef NO_FP_API
|
||||
void CRYPTO_mem_leaks_fp(FILE *);
|
||||
|
||||
110
crypto/mem.c
110
crypto/mem.c
@ -62,62 +62,94 @@
|
||||
#include "cryptlib.h"
|
||||
|
||||
|
||||
static char *(*malloc_locked_func)()=(char *(*)())malloc;
|
||||
static void (*free_locked_func)()=(void (*)())free;
|
||||
static char *(*malloc_func)()= (char *(*)())malloc;
|
||||
static char *(*realloc_func)()= (char *(*)())realloc;
|
||||
static void (*free_func)()= (void (*)())free;
|
||||
static int allow_customize = 1; /* we provide flexible functions for */
|
||||
static int allow_customize_debug = 1;/* exchanging memory-related functions at
|
||||
* run-time, but this must be done
|
||||
* before any blocks are actually
|
||||
* allocated; or we'll run into huge
|
||||
* problems when malloc/free pairs
|
||||
* don't match etc. */
|
||||
|
||||
/* may be changed as long as `allow_customize' is set */
|
||||
static void *(*malloc_locked_func)(size_t) = malloc;
|
||||
static void (*free_locked_func)(void *) = free;
|
||||
static void *(*malloc_func)(size_t) = malloc;
|
||||
static void *(*realloc_func)(void *, size_t)= realloc;
|
||||
static void (*free_func)(void *) = free;
|
||||
|
||||
/* may be changed as long as `allow_customize_debug' is set */
|
||||
/* XXX use correct function pointer types */
|
||||
#ifdef CRYPTO_MDEBUG
|
||||
static void (*malloc_debug_func)()= (void (*)())CRYPTO_dbg_malloc;
|
||||
static void (*realloc_debug_func)()= (void (*)())CRYPTO_dbg_realloc;
|
||||
static void (*free_debug_func)()= (void (*)())CRYPTO_dbg_free;
|
||||
static void (*set_debug_options_func)()= (void (*)())CRYPTO_dbg_set_options;
|
||||
static int (*get_debug_options_func)()= (int (*)())CRYPTO_dbg_get_options;
|
||||
/* use default functions from mem_dbg.c */
|
||||
static void (*malloc_debug_func)()= (void (*)())CRYPTO_dbg_malloc;
|
||||
static void (*realloc_debug_func)()= (void (*)())CRYPTO_dbg_realloc;
|
||||
static void (*free_debug_func)()= (void (*)())CRYPTO_dbg_free;
|
||||
static void (*set_debug_options_func)()= (void (*)())CRYPTO_dbg_set_options;
|
||||
static long (*get_debug_options_func)()= (long (*)())CRYPTO_dbg_get_options;
|
||||
#else
|
||||
static void (*malloc_debug_func)()= (void (*)())NULL;
|
||||
static void (*realloc_debug_func)()= (void (*)())NULL;
|
||||
static void (*free_debug_func)()= (void (*)())NULL;
|
||||
static void (*set_debug_options_func)()= (void (*)())NULL;
|
||||
static int (*get_debug_options_func)()= (int (*)())NULL;
|
||||
/* applications can use CRYPTO_malloc_debug_init() to select above case
|
||||
* at run-time */
|
||||
static void (*malloc_debug_func)()= NULL;
|
||||
static void (*realloc_debug_func)()= NULL;
|
||||
static void (*free_debug_func)()= NULL;
|
||||
static void (*set_debug_options_func)()= NULL;
|
||||
static int (*get_debug_options_func)()= NULL;
|
||||
#endif
|
||||
|
||||
void CRYPTO_set_mem_functions(char *(*m)(), char *(*r)(), void (*f)())
|
||||
|
||||
int CRYPTO_set_mem_functions(void *(*m)(size_t), void *(*r)(void *, size_t),
|
||||
void (*f)(void *))
|
||||
{
|
||||
if ((m == NULL) || (r == NULL) || (f == NULL)) return;
|
||||
if (!allow_customize)
|
||||
return 0;
|
||||
if ((m == NULL) || (r == NULL) || (f == NULL))
|
||||
return 0;
|
||||
malloc_func=m;
|
||||
realloc_func=r;
|
||||
free_func=f;
|
||||
malloc_locked_func=m;
|
||||
free_locked_func=f;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CRYPTO_set_mem_debug_functions(void (*m)(), void (*r)(), void (*f)(),void (*so)(),int (*go)())
|
||||
int CRYPTO_set_locked_mem_functions(void *(*m)(size_t), void (*f)(void *))
|
||||
{
|
||||
if ((m == NULL) || (r == NULL) || (f == NULL) || (so == NULL) || (go == NULL))
|
||||
return;
|
||||
if (!allow_customize)
|
||||
return 0;
|
||||
if ((m == NULL) || (f == NULL))
|
||||
return 0;
|
||||
malloc_locked_func=m;
|
||||
free_locked_func=f;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CRYPTO_set_mem_debug_functions(void (*m)(), void (*r)(), void (*f)(),void (*so)(),long (*go)())
|
||||
{
|
||||
if (!allow_customize_debug)
|
||||
return 0;
|
||||
malloc_debug_func=m;
|
||||
realloc_debug_func=r;
|
||||
free_debug_func=f;
|
||||
set_debug_options_func=so;
|
||||
get_debug_options_func=go;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CRYPTO_set_locked_mem_functions(char *(*m)(), void (*f)())
|
||||
{
|
||||
if ((m == NULL) || (f == NULL)) return;
|
||||
malloc_locked_func=m;
|
||||
free_locked_func=f;
|
||||
}
|
||||
|
||||
void CRYPTO_get_mem_functions(char *(**m)(), char *(**r)(), void (**f)())
|
||||
void CRYPTO_get_mem_functions(void *(**m)(size_t), void *(**r)(void *, size_t),
|
||||
void (**f)(void *))
|
||||
{
|
||||
if (m != NULL) *m=malloc_func;
|
||||
if (r != NULL) *r=realloc_func;
|
||||
if (f != NULL) *f=free_func;
|
||||
}
|
||||
|
||||
void CRYPTO_get_mem_debug_functions(void (**m)(), void (**r)(), void (**f)(),void (**so)(),int (**go)())
|
||||
void CRYPTO_get_locked_mem_functions(void *(**m)(size_t), void (**f)(void *))
|
||||
{
|
||||
if (m != NULL) *m=malloc_locked_func;
|
||||
if (f != NULL) *f=free_locked_func;
|
||||
}
|
||||
|
||||
void CRYPTO_get_mem_debug_functions(void (**m)(), void (**r)(), void (**f)(),void (**so)(),long (**go)())
|
||||
{
|
||||
if (m != NULL) *m=malloc_debug_func;
|
||||
if (r != NULL) *r=realloc_debug_func;
|
||||
@ -126,18 +158,17 @@ void CRYPTO_get_mem_debug_functions(void (**m)(), void (**r)(), void (**f)(),voi
|
||||
if (go != NULL) *go=get_debug_options_func;
|
||||
}
|
||||
|
||||
void CRYPTO_get_locked_mem_functions(char *(**m)(), void (**f)())
|
||||
{
|
||||
if (m != NULL) *m=malloc_locked_func;
|
||||
if (f != NULL) *f=free_locked_func;
|
||||
}
|
||||
|
||||
void *CRYPTO_malloc_locked(int num, char *file, int line)
|
||||
{
|
||||
char *ret = NULL;
|
||||
|
||||
allow_customize = 0;
|
||||
if (malloc_debug_func != NULL)
|
||||
{
|
||||
allow_customize_debug = 0;
|
||||
malloc_debug_func(NULL, num, file, line, 0);
|
||||
}
|
||||
ret = malloc_locked_func(num);
|
||||
#ifdef LEVITTE_DEBUG
|
||||
fprintf(stderr, "LEVITTE_DEBUG: > 0x%p (%d)\n", ret, num);
|
||||
@ -164,8 +195,12 @@ void *CRYPTO_malloc(int num, char *file, int line)
|
||||
{
|
||||
char *ret = NULL;
|
||||
|
||||
allow_customize = 0;
|
||||
if (malloc_debug_func != NULL)
|
||||
{
|
||||
allow_customize_debug = 0;
|
||||
malloc_debug_func(NULL, num, file, line, 0);
|
||||
}
|
||||
ret = malloc_func(num);
|
||||
#ifdef LEVITTE_DEBUG
|
||||
fprintf(stderr, "LEVITTE_DEBUG: > 0x%p (%d)\n", ret, num);
|
||||
@ -204,7 +239,6 @@ void CRYPTO_free(void *str)
|
||||
free_debug_func(NULL, 1);
|
||||
}
|
||||
|
||||
|
||||
void *CRYPTO_remalloc(void *a, int num, char *file, int line)
|
||||
{
|
||||
if (a != NULL) Free(a);
|
||||
@ -212,14 +246,16 @@ void *CRYPTO_remalloc(void *a, int num, char *file, int line)
|
||||
return(a);
|
||||
}
|
||||
|
||||
void CRYPTO_set_mem_debug_options(int bits)
|
||||
|
||||
void CRYPTO_set_mem_debug_options(long bits)
|
||||
{
|
||||
if (set_debug_options_func != NULL)
|
||||
set_debug_options_func(bits);
|
||||
}
|
||||
|
||||
int CRYPTO_get_mem_debug_options()
|
||||
long CRYPTO_get_mem_debug_options()
|
||||
{
|
||||
if (get_debug_options_func != NULL)
|
||||
return get_debug_options_func();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -65,7 +65,12 @@
|
||||
#include <openssl/lhash.h>
|
||||
#include "cryptlib.h"
|
||||
|
||||
/* State CRYPTO_MEM_CHECK_ON exists only temporarily when the library
|
||||
static int mh_mode=CRYPTO_MEM_CHECK_OFF;
|
||||
/* The state changes to CRYPTO_MEM_CHECK_ON | CRYPTO_MEM_CHECK_ENABLE
|
||||
* when the application asks for it (usually after library initialisation
|
||||
* for which no book-keeping is desired).
|
||||
*
|
||||
* State CRYPTO_MEM_CHECK_ON exists only temporarily when the library
|
||||
* thinks that certain allocations should not be checked (e.g. the data
|
||||
* structures used for memory checking). It is not suitable as an initial
|
||||
* state: the library will unexpectedly enable memory checking when it
|
||||
@ -74,27 +79,34 @@
|
||||
*
|
||||
* State CRYPTO_MEM_CHECK_ENABLE without ..._ON makes no sense whatsoever.
|
||||
*/
|
||||
static int mh_mode=CRYPTO_MEM_CHECK_OFF;
|
||||
static unsigned long disabling_thread = 0;
|
||||
|
||||
static unsigned long order = 0; /* number of memory requests */
|
||||
static LHASH *mh=NULL; /* hash-table of memory requests (address as key) */
|
||||
|
||||
static unsigned long order=0;
|
||||
|
||||
static LHASH *amih=NULL;
|
||||
|
||||
typedef struct app_mem_info_st
|
||||
/* For application-defined information (static C-string `info')
|
||||
* to be displayed in memory leak list.
|
||||
* Each thread has its own stack. For applications, there is
|
||||
* CRYPTO_add_info("...") to push an entry,
|
||||
* CRYPTO_remove_info() to pop an entry,
|
||||
* CRYPTO_remove_all_info() to pop all entries.
|
||||
*/
|
||||
{
|
||||
unsigned long thread;
|
||||
const char *file;
|
||||
int line;
|
||||
const char *info;
|
||||
struct app_mem_info_st *next;
|
||||
struct app_mem_info_st *next; /* tail of thread's stack */
|
||||
int references;
|
||||
} APP_INFO;
|
||||
|
||||
static LHASH *mh=NULL;
|
||||
static LHASH *amih=NULL; /* hash-table with those app_mem_info_st's
|
||||
* that are at the top of their thread's stack
|
||||
* (with `thread' as key) */
|
||||
|
||||
typedef struct mem_st
|
||||
/* memory-block description */
|
||||
{
|
||||
char *addr;
|
||||
int num;
|
||||
@ -106,30 +118,17 @@ typedef struct mem_st
|
||||
APP_INFO *app_info;
|
||||
} MEM;
|
||||
|
||||
|
||||
#ifdef CRYPTO_MDEBUG_ALL
|
||||
# ifndef CRYPTO_MDEBUG_TIME
|
||||
# define CRYPTO_MDEBUG_TIME
|
||||
# endif
|
||||
# ifndef CRYPTO_MDEBUG_THREAD
|
||||
# define CRYPTO_MDEBUG_THREAD
|
||||
# endif
|
||||
static long options = /* extra information to be recorded */
|
||||
#if defined(CRYPTO_MDEBUG_TIME) || defined(CRYPTO_MDEBUG_ALL)
|
||||
V_CRYPTO_MDEBUG_TIME |
|
||||
#endif
|
||||
|
||||
/* Get defaults that will depend on some macros defined elsewhere */
|
||||
#ifdef CRYPTO_MDEBUG_TIME
|
||||
#define DEF_V_CRYPTO_MDEBUG_TIME V_CRYPTO_MDEBUG_TIME
|
||||
#else
|
||||
#define DEF_V_CRYPTO_MDEBUG_TIME 0
|
||||
#endif
|
||||
#ifdef CRYPTO_MDEBUG_THREAD
|
||||
#define DEF_V_CRYPTO_MDEBUG_THREAD V_CRYPTO_MDEBUG_THREAD
|
||||
#else
|
||||
#define DEF_V_CRYPTO_MDEBUG_THREAD 0
|
||||
#if defined(CRYPTO_MDEBUG_THREAD) || defined(CRYPTO_MDEBUG_ALL)
|
||||
V_CRYPTO_MDEBUG_THREAD |
|
||||
#endif
|
||||
0;
|
||||
|
||||
static int options = DEF_V_CRYPTO_MDEBUG_TIME | DEF_V_CRYPTO_MDEBUG_THREAD;
|
||||
|
||||
static unsigned long disabling_thread = 0;
|
||||
|
||||
int CRYPTO_mem_ctrl(int mode)
|
||||
{
|
||||
@ -157,8 +156,8 @@ int CRYPTO_mem_ctrl(int mode)
|
||||
{
|
||||
/* Long-time lock CRYPTO_LOCK_MALLOC2 must not be claimed while
|
||||
* we're holding CRYPTO_LOCK_MALLOC, or we'll deadlock if
|
||||
* somebody else holds CRYPTO_LOCK_MALLOC2 (and cannot release it
|
||||
* because we block entry to this function).
|
||||
* somebody else holds CRYPTO_LOCK_MALLOC2 (and cannot release
|
||||
* it because we block entry to this function).
|
||||
* Give them a chance, first, and then claim the locks in
|
||||
* appropriate order (long-time lock first).
|
||||
*/
|
||||
@ -193,7 +192,7 @@ int CRYPTO_mem_ctrl(int mode)
|
||||
return(ret);
|
||||
}
|
||||
|
||||
int CRYPTO_mem_check_on(void)
|
||||
int CRYPTO_is_mem_check_on(void)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
@ -210,12 +209,12 @@ int CRYPTO_mem_check_on(void)
|
||||
}
|
||||
|
||||
|
||||
void CRYPTO_dbg_set_options(int bits)
|
||||
void CRYPTO_dbg_set_options(long bits)
|
||||
{
|
||||
options = bits;
|
||||
}
|
||||
|
||||
int CRYPTO_dbg_get_options()
|
||||
long CRYPTO_dbg_get_options()
|
||||
{
|
||||
return options;
|
||||
}
|
||||
@ -237,7 +236,7 @@ static unsigned long mem_hash(MEM *a)
|
||||
|
||||
static int app_info_cmp(APP_INFO *a, APP_INFO *b)
|
||||
{
|
||||
return(a->thread - b->thread);
|
||||
return(a->thread != b->thread);
|
||||
}
|
||||
|
||||
static unsigned long app_info_hash(APP_INFO *a)
|
||||
@ -287,7 +286,7 @@ static APP_INFO *remove_info()
|
||||
return(ret);
|
||||
}
|
||||
|
||||
int CRYPTO_add_info(const char *file, int line, const char *info)
|
||||
int CRYPTO_add_info_(const char *file, int line, const char *info)
|
||||
{
|
||||
APP_INFO *ami, *amim;
|
||||
int ret=0;
|
||||
@ -341,12 +340,14 @@ int CRYPTO_remove_info(void)
|
||||
{
|
||||
int ret=0;
|
||||
|
||||
if (is_MemCheck_on())
|
||||
if (is_MemCheck_on()) /* _must_ be true, or something went severly wrong */
|
||||
{
|
||||
MemCheck_off();
|
||||
CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
|
||||
|
||||
ret=(remove_info() != NULL);
|
||||
|
||||
CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
|
||||
MemCheck_on();
|
||||
}
|
||||
return(ret);
|
||||
@ -356,13 +357,15 @@ int CRYPTO_remove_all_info(void)
|
||||
{
|
||||
int ret=0;
|
||||
|
||||
if (is_MemCheck_on())
|
||||
if (is_MemCheck_on()) /* _must_ be true */
|
||||
{
|
||||
MemCheck_off();
|
||||
CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
|
||||
|
||||
while(remove_info() != NULL)
|
||||
ret++;
|
||||
|
||||
CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
|
||||
MemCheck_on();
|
||||
}
|
||||
return(ret);
|
||||
@ -393,6 +396,7 @@ void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line,
|
||||
MemCheck_on();
|
||||
return;
|
||||
}
|
||||
CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
|
||||
if (mh == NULL)
|
||||
{
|
||||
if ((mh=lh_new(mem_hash,mem_cmp)) == NULL)
|
||||
@ -449,6 +453,7 @@ void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line,
|
||||
Free(mm);
|
||||
}
|
||||
err:
|
||||
CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
|
||||
MemCheck_on();
|
||||
}
|
||||
break;
|
||||
@ -520,6 +525,7 @@ void CRYPTO_dbg_realloc(void *addr1, void *addr2, int num,
|
||||
if (is_MemCheck_on())
|
||||
{
|
||||
MemCheck_off();
|
||||
CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
|
||||
|
||||
m.addr=addr1;
|
||||
mp=(MEM *)lh_delete(mh,(char *)&m);
|
||||
@ -536,6 +542,7 @@ void CRYPTO_dbg_realloc(void *addr1, void *addr2, int num,
|
||||
lh_insert(mh,(char *)mp);
|
||||
}
|
||||
|
||||
CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
|
||||
MemCheck_on();
|
||||
}
|
||||
break;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user