- Don't assume that int and size_t have the same representation
authorBodo Möller <bodo@openssl.org>
Sat, 18 Dec 1999 05:22:50 +0000 (05:22 +0000)
committerBodo Möller <bodo@openssl.org>
Sat, 18 Dec 1999 05:22:50 +0000 (05:22 +0000)
  (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
crypto/mem.c
crypto/mem_dbg.c

index 19e8d10..acb5307 100644 (file)
@@ -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 *);
index f06236e..a9529ee 100644 (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;
@@ -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;
        }
index 4bddbe0..c16fa7a 100644 (file)
 #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;
@@ -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;