(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.
extern "C" {
#endif
+#include <stdlib.h>
+
#ifndef NO_FP_API
#include <stdio.h>
#endif
/* 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;
#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)
+ malloc, realloc, free)
+#endif
+
+#if defined CRYPTO_MDEBUG_ALL || defined CRYPTO_MDEBUG_TIME || defined CRYPTO_MDEBUG_THREAD
+# ifndef CRYPTO_MDEBUG /* avoid duplicate #define */
+# define CRYPTO_MDEBUG
+# 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,\
- (int (*)())CRYPTO_dbg_get_options);\
+ (long (*)())CRYPTO_dbg_get_options);\
} while(0)
-#if defined CRYPTO_MDEBUG_ALL || defined CRYPTO_MDEBUG_TIME || defined CRYPTO_MDEBUG_THREAD
-# ifndef CRYPTO_MDEBUG /* avoid duplicate #define */
-# define CRYPTO_MDEBUG
-# endif
-#endif
+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) \
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!) */
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 *);
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);
* 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 *);
#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;
+ }
+
+int CRYPTO_set_locked_mem_functions(void *(*m)(size_t), void (*f)(void *))
+ {
+ if (!allow_customize)
+ return 0;
+ if ((m == NULL) || (f == NULL))
+ return 0;
+ 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_mem_debug_functions(void (*m)(), void (*r)(), void (*f)(),void (*so)(),long (*go)())
{
- if ((m == NULL) || (r == NULL) || (f == NULL) || (so == NULL) || (go == NULL))
- return;
+ 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;
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);
{
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);
free_debug_func(NULL, 1);
}
-
void *CRYPTO_remalloc(void *a, int num, char *file, int line)
{
if (a != NULL) Free(a);
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;
}
#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
*
* 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;
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
-#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
+static long options = /* extra information to be recorded */
+#if defined(CRYPTO_MDEBUG_TIME) || defined(CRYPTO_MDEBUG_ALL)
+ V_CRYPTO_MDEBUG_TIME |
#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)
{
{
/* 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).
*/
return(ret);
}
-int CRYPTO_mem_check_on(void)
+int CRYPTO_is_mem_check_on(void)
{
int ret = 0;
}
-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;
}
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)
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;
{
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);
{
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);
MemCheck_on();
return;
}
+ CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
if (mh == NULL)
{
if ((mh=lh_new(mem_hash,mem_cmp)) == NULL)
Free(mm);
}
err:
+ CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
MemCheck_on();
}
break;
if (is_MemCheck_on())
{
MemCheck_off();
+ CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
m.addr=addr1;
mp=(MEM *)lh_delete(mh,(char *)&m);
lh_insert(mh,(char *)mp);
}
+ CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
MemCheck_on();
}
break;
projects / openssl.git / commitdiff