From: Bodo Möller Date: Sat, 18 Dec 1999 05:22:50 +0000 (+0000) Subject: - Don't assume that int and size_t have the same representation X-Git-Tag: OpenSSL_0_9_5beta1~366 X-Git-Url: https://git.librecmc.org/?a=commitdiff_plain;h=0cd08cce17f665fe57b650d0d2f983f41c84b273;p=oweals%2Fopenssl.git - 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. --- diff --git a/crypto/crypto.h b/crypto/crypto.h index 19e8d10cbf..acb530768d 100644 --- a/crypto/crypto.h +++ b/crypto/crypto.h @@ -63,6 +63,8 @@ extern "C" { #endif +#include + #ifndef NO_FP_API #include #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 *); diff --git a/crypto/mem.c b/crypto/mem.c index f06236e1e2..a9529ee274 100644 --- a/crypto/mem.c +++ b/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; + } + +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; } diff --git a/crypto/mem_dbg.c b/crypto/mem_dbg.c index 4bddbe07b2..c16fa7a2b8 100644 --- a/crypto/mem_dbg.c +++ b/crypto/mem_dbg.c @@ -65,7 +65,12 @@ #include #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 -#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;