Commit 0cd08cce authored by Bodo Möller's avatar Bodo Möller
Browse files

- 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.
parent 03c48fa0

crypto/crypto.h

+37 −31
Original line number Diff line number Diff line
@@ -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,32 +200,40 @@ 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)

	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) \
@@ -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 *);

crypto/mem.c

+73 −37
Original line number Diff line number Diff line
@@ -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

  /* 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;

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;
@@ -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

+44 −37
Original line number Diff line number Diff line
@@ -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;

static unsigned long order = 0; /* number of memory requests */

static LHASH *mh=NULL; /* hash-table of memory requests (address as key) */



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

#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)

	{
@@ -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;