- 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.

crypto/crypto.h

@@ -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,\
+	malloc, realloc, free)
-	(char *(*)())realloc,\
+#endif
-	(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)
 
 #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)());
+/* CRYPTO_set_mem_functions includes CRYPTO_set_locked_mem_functions --
-void CRYPTO_set_mem_debug_functions(void (*m)(),void (*r)(),void (*f)(),void (*so)(),int (*go)());
+ * call the latter last if you need different functions */
-void CRYPTO_set_mem_debug_options(int bits);
+int CRYPTO_set_mem_functions(void *(*m)(size_t),void *(*r)(void *,size_t), void (*f)(void *));
-void CRYPTO_get_mem_functions(char *(**m)(),char *(**r)(), void (**f)());
+int CRYPTO_set_locked_mem_functions(void *(*m)(size_t), void (*free_func)(void *));
-void CRYPTO_get_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)());
-int CRYPTO_get_mem_debug_options();
+void CRYPTO_get_mem_functions(void *(**m)(size_t),void *(**r)(void *, size_t), void (**f)(void *));
-void CRYPTO_set_locked_mem_functions(char *(*m)(), void (*free_func)());
+void CRYPTO_get_locked_mem_functions(void *(**m)(size_t), void (**f)(void *));
-void CRYPTO_get_locked_mem_functions(char *(**m)(), void (**f)());
+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);
+void CRYPTO_dbg_set_options(long bits);
-int CRYPTO_dbg_get_options();
+long CRYPTO_dbg_get_options();
 
 #ifndef NO_FP_API
 void CRYPTO_mem_leaks_fp(FILE *);

crypto/mem.c

@@ -62,62 +62,94 @@
 #include "cryptlib.h"
 
 
-static char *(*malloc_locked_func)()=(char *(*)())malloc;
+static int allow_customize = 1;      /* we provide flexible functions for */
-static void (*free_locked_func)()=(void (*)())free;
+static int allow_customize_debug = 1;/* exchanging memory-related functions at
-static char *(*malloc_func)()=	(char *(*)())malloc;
+                                      * run-time, but this must be done
-static char *(*realloc_func)()=	(char *(*)())realloc;
+                                      * before any blocks are actually
-static void (*free_func)()=	(void (*)())free;
+                                      * 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
+  /* 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 int (*get_debug_options_func)()= (int (*)())CRYPTO_dbg_get_options;
+  static long (*get_debug_options_func)()= (long (*)())CRYPTO_dbg_get_options;
 #else
-static void (*malloc_debug_func)()= (void (*)())NULL;
+  /* applications can use CRYPTO_malloc_debug_init() to select above case
-static void (*realloc_debug_func)()= (void (*)())NULL;
+   * at run-time */
-static void (*free_debug_func)()= (void (*)())NULL;
+  static void (*malloc_debug_func)()= NULL;
-static void (*set_debug_options_func)()= (void (*)())NULL;
+  static void (*realloc_debug_func)()= NULL;
-static int (*get_debug_options_func)()= (int (*)())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))
+	if (!allow_customize)
-		return;
+		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)())
+void CRYPTO_get_mem_functions(void *(**m)(size_t), void *(**r)(void *, size_t),
-	{
+	void (**f)(void *))
-	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)())
 	{
 	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;
 	}

crypto/mem_dbg.c

@@ -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;
 
+static long options =             /* extra information to be recorded */
+#if defined(CRYPTO_MDEBUG_TIME) || defined(CRYPTO_MDEBUG_ALL)
+	V_CRYPTO_MDEBUG_TIME |
+#endif
+#if defined(CRYPTO_MDEBUG_THREAD) || defined(CRYPTO_MDEBUG_ALL)
+	V_CRYPTO_MDEBUG_THREAD |
+#endif
+	0;
 
-#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
-#endif
-#ifdef CRYPTO_MDEBUG_THREAD
-#define DEF_V_CRYPTO_MDEBUG_THREAD V_CRYPTO_MDEBUG_THREAD
-#else
-#define DEF_V_CRYPTO_MDEBUG_THREAD 0
-#endif
-
-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
+				 * somebody else holds CRYPTO_LOCK_MALLOC2 (and cannot release
-				 * because we block entry to this function).
+				 * 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;