import openssl-0.9.7-beta1

1 files changed, 167 insertions, 96 deletions

diff --git a/src/lib/libcrypto/mem_dbg.c b/src/lib/libcrypto/mem_dbg.c
index 14770c0733..1c4e04f51f 100644
--- a/src/lib/libcrypto/mem_dbg.c
+++ b/src/lib/libcrypto/mem_dbg.c
@@ -81,7 +81,8 @@ static int mh_mode=CRYPTO_MEM_CHECK_OFF;
  */
 
 static unsigned long order = 0; /* number of memory requests */
-static LHASH *mh=NULL; /* hash-table of memory requests (address as key) */
+static LHASH *mh=NULL; /* hash-table of memory requests (address as key);
+                        * access requires MALLOC2 lock */
 
 
 typedef struct app_mem_info_st
@@ -103,12 +104,13 @@ typedef struct app_mem_info_st
 
 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) */
+                          * (with `thread' as key);
+                          * access requires MALLOC2 lock */
 
 typedef struct mem_st
 /* memory-block description */
         {
-        char *addr;
+        void *addr;
         int num;
         const char *file;
         int line;
@@ -128,7 +130,15 @@ static long options =             /* extra information to be recorded */
         0;
 
 
-static unsigned long disabling_thread = 0;
+static unsigned int num_disable = 0; /* num_disable > 0
+                                      *     iff
+                                      * mh_mode == CRYPTO_MEM_CHECK_ON (w/o ..._ENABLE)
+                                      */
+static unsigned long disabling_thread = 0; /* Valid iff num_disable > 0.
+                                            * CRYPTO_LOCK_MALLOC2 is locked
+                                            * exactly in this case (by the
+                                            * thread named in disabling_thread).
+                                            */
 
 int CRYPTO_mem_ctrl(int mode)
         {
@@ -137,22 +147,23 @@ int CRYPTO_mem_ctrl(int mode)
         CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
         switch (mode)
                 {
-        /* for applications: */
+        /* for applications (not to be called while multiple threads
+         * use the library): */
         case CRYPTO_MEM_CHECK_ON: /* aka MemCheck_start() */
                 mh_mode = CRYPTO_MEM_CHECK_ON|CRYPTO_MEM_CHECK_ENABLE;
-                disabling_thread = 0;
+                num_disable = 0;
                 break;
         case CRYPTO_MEM_CHECK_OFF: /* aka MemCheck_stop() */
                 mh_mode = 0;
-                disabling_thread = 0;
+                num_disable = 0; /* should be true *before* MemCheck_stop is used,
+                                    or there'll be a lot of confusion */
                 break;
 
         /* switch off temporarily (for library-internal use): */
         case CRYPTO_MEM_CHECK_DISABLE: /* aka MemCheck_off() */
                 if (mh_mode & CRYPTO_MEM_CHECK_ON)
                         {
-                        mh_mode&= ~CRYPTO_MEM_CHECK_ENABLE;
-                        if (disabling_thread != CRYPTO_thread_id()) /* otherwise we already have the MALLOC2 lock */
+                        if (!num_disable || (disabling_thread != CRYPTO_thread_id())) /* otherwise we already have the MALLOC2 lock */
                                 {
                                 /* Long-time lock CRYPTO_LOCK_MALLOC2 must not be claimed while
                                  * we're holding CRYPTO_LOCK_MALLOC, or we'll deadlock if
@@ -169,18 +180,23 @@ int CRYPTO_mem_ctrl(int mode)
                                  * OpenSSL threads. */
                                 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
                                 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
+                                mh_mode &= ~CRYPTO_MEM_CHECK_ENABLE;
                                 disabling_thread=CRYPTO_thread_id();
                                 }
+                        num_disable++;
                         }
                 break;
         case CRYPTO_MEM_CHECK_ENABLE: /* aka MemCheck_on() */
                 if (mh_mode & CRYPTO_MEM_CHECK_ON)
                         {
-                        mh_mode|=CRYPTO_MEM_CHECK_ENABLE;
-                        if (disabling_thread != 0)
+                        if (num_disable) /* always true, or something is going wrong */
                                 {
-                                disabling_thread=0;
-                                CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);
+                                num_disable--;
+                                if (num_disable == 0)
+                                        {
+                                        mh_mode|=CRYPTO_MEM_CHECK_ENABLE;
+                                        CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);
+                                        }
                                 }
                         }
                 break;
@@ -198,12 +214,12 @@ int CRYPTO_is_mem_check_on(void)
 
         if (mh_mode & CRYPTO_MEM_CHECK_ON)
                 {
-                CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
+                CRYPTO_r_lock(CRYPTO_LOCK_MALLOC);
 
                 ret = (mh_mode & CRYPTO_MEM_CHECK_ENABLE)
-                        && disabling_thread != CRYPTO_thread_id();
+                        || (disabling_thread != CRYPTO_thread_id());
 
-                CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
+                CRYPTO_r_unlock(CRYPTO_LOCK_MALLOC);
                 }
         return(ret);
         }       
@@ -219,37 +235,43 @@ long CRYPTO_dbg_get_options(void)
         return options;
         }
 
-static int mem_cmp(MEM *a, MEM *b)
+/* static int mem_cmp(MEM *a, MEM *b) */
+static int mem_cmp(const void *a_void, const void *b_void)
         {
-        return(a->addr - b->addr);
+        return((const char *)((const MEM *)a_void)->addr
+                - (const char *)((const MEM *)b_void)->addr);
         }
 
-static unsigned long mem_hash(MEM *a)
+/* static unsigned long mem_hash(MEM *a) */
+static unsigned long mem_hash(const void *a_void)
         {
         unsigned long ret;
 
-        ret=(unsigned long)a->addr;
+        ret=(unsigned long)((const MEM *)a_void)->addr;
 
         ret=ret*17851+(ret>>14)*7+(ret>>4)*251;
         return(ret);
         }
 
-static int app_info_cmp(APP_INFO *a, APP_INFO *b)
+/* static int app_info_cmp(APP_INFO *a, APP_INFO *b) */
+static int app_info_cmp(const void *a_void, const void *b_void)
         {
-        return(a->thread != b->thread);
+        return(((const APP_INFO *)a_void)->thread
+                != ((const APP_INFO *)b_void)->thread);
         }
 
-static unsigned long app_info_hash(APP_INFO *a)
+/* static unsigned long app_info_hash(APP_INFO *a) */
+static unsigned long app_info_hash(const void *a_void)
         {
         unsigned long ret;
 
-        ret=(unsigned long)a->thread;
+        ret=(unsigned long)((const APP_INFO *)a_void)->thread;
 
         ret=ret*17851+(ret>>14)*7+(ret>>4)*251;
         return(ret);
         }
 
-static APP_INFO *pop_info()
+static APP_INFO *pop_info(void)
         {
         APP_INFO tmp;
         APP_INFO *ret = NULL;
@@ -266,7 +288,7 @@ static APP_INFO *pop_info()
                                 next->references++;
                                 lh_insert(amih,(char *)next);
                                 }
-#ifdef LEVITTE_DEBUG
+#ifdef LEVITTE_DEBUG_MEM
                         if (ret->thread != tmp.thread)
                                 {
                                 fprintf(stderr, "pop_info(): deleted info has other thread ID (%lu) than the current thread (%lu)!!!!\n",
@@ -279,7 +301,7 @@ static APP_INFO *pop_info()
                                 ret->next = NULL;
                                 if (next != NULL)
                                         next->references--;
-                                Free(ret);
+                                OPENSSL_free(ret);
                                 }
                         }
                 }
@@ -293,18 +315,18 @@ int CRYPTO_push_info_(const char *info, const char *file, int line)
 
         if (is_MemCheck_on())
                 {
-                MemCheck_off(); /* obtains CRYPTO_LOCK_MALLOC2 */
+                MemCheck_off(); /* obtain MALLOC2 lock */
 
-                if ((ami = (APP_INFO *)Malloc(sizeof(APP_INFO))) == NULL)
+                if ((ami = (APP_INFO *)OPENSSL_malloc(sizeof(APP_INFO))) == NULL)
                         {
                         ret=0;
                         goto err;
                         }
                 if (amih == NULL)
                         {
-                        if ((amih=lh_new(app_info_hash,app_info_cmp)) == NULL)
+                        if ((amih=lh_new(app_info_hash, app_info_cmp)) == NULL)
                                 {
-                                Free(ami);
+                                OPENSSL_free(ami);
                                 ret=0;
                                 goto err;
                                 }
@@ -319,7 +341,7 @@ int CRYPTO_push_info_(const char *info, const char *file, int line)
 
                 if ((amim=(APP_INFO *)lh_insert(amih,(char *)ami)) != NULL)
                         {
-#ifdef LEVITTE_DEBUG
+#ifdef LEVITTE_DEBUG_MEM
                         if (ami->thread != amim->thread)
                                 {
                                 fprintf(stderr, "CRYPTO_push_info(): previous info has other thread ID (%lu) than the current thread (%lu)!!!!\n",
@@ -330,7 +352,7 @@ int CRYPTO_push_info_(const char *info, const char *file, int line)
                         ami->next=amim;
                         }
  err:
-                MemCheck_on(); /* releases CRYPTO_LOCK_MALLOC2 */
+                MemCheck_on(); /* release MALLOC2 lock */
                 }
 
         return(ret);
@@ -342,11 +364,11 @@ int CRYPTO_pop_info(void)
 
         if (is_MemCheck_on()) /* _must_ be true, or something went severely wrong */
                 {
-                MemCheck_off(); /* obtains CRYPTO_LOCK_MALLOC2 */
+                MemCheck_off(); /* obtain MALLOC2 lock */
 
                 ret=(pop_info() != NULL);
 
-                MemCheck_on(); /* releases CRYPTO_LOCK_MALLOC2 */
+                MemCheck_on(); /* release MALLOC2 lock */
                 }
         return(ret);
         }
@@ -357,12 +379,12 @@ int CRYPTO_remove_all_info(void)
 
         if (is_MemCheck_on()) /* _must_ be true */
                 {
-                MemCheck_off(); /* obtains CRYPTO_LOCK_MALLOC2 */
+                MemCheck_off(); /* obtain MALLOC2 lock */
 
                 while(pop_info() != NULL)
                         ret++;
 
-                MemCheck_on(); /* releases CRYPTO_LOCK_MALLOC2 */
+                MemCheck_on(); /* release MALLOC2 lock */
                 }
         return(ret);
         }
@@ -385,19 +407,20 @@ void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line,
 
                 if (is_MemCheck_on())
                         {
-                        MemCheck_off(); /* obtains CRYPTO_LOCK_MALLOC2 */
-                        if ((m=(MEM *)Malloc(sizeof(MEM))) == NULL)
+                        MemCheck_off(); /* make sure we hold MALLOC2 lock */
+                        if ((m=(MEM *)OPENSSL_malloc(sizeof(MEM))) == NULL)
                                 {
-                                Free(addr);
-                                MemCheck_on(); /* releases CRYPTO_LOCK_MALLOC2 */
+                                OPENSSL_free(addr);
+                                MemCheck_on(); /* release MALLOC2 lock
+                                                * if num_disabled drops to 0 */
                                 return;
                                 }
                         if (mh == NULL)
                                 {
-                                if ((mh=lh_new(mem_hash,mem_cmp)) == NULL)
+                                if ((mh=lh_new(mem_hash, mem_cmp)) == NULL)
                                         {
-                                        Free(addr);
-                                        Free(m);
+                                        OPENSSL_free(addr);
+                                        OPENSSL_free(m);
                                         addr=NULL;
                                         goto err;
                                         }
@@ -418,8 +441,8 @@ void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line,
                                 m->order=order;
                                 }
                         m->order=order++;
-#ifdef LEVITTE_DEBUG
-                        fprintf(stderr, "LEVITTE_DEBUG: [%5d] %c 0x%p (%d)\n",
+#ifdef LEVITTE_DEBUG_MEM
+                        fprintf(stderr, "LEVITTE_DEBUG_MEM: [%5d] %c 0x%p (%d)\n",
                                 m->order,
                                 (before_p & 128) ? '*' : '+',
                                 m->addr, m->num);
@@ -445,10 +468,11 @@ void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line,
                                         {
                                         mm->app_info->references--;
                                         }
-                                Free(mm);
+                                OPENSSL_free(mm);
                                 }
                 err:
-                        MemCheck_on(); /* releases CRYPTO_LOCK_MALLOC2 */
+                        MemCheck_on(); /* release MALLOC2 lock
+                                        * if num_disabled drops to 0 */
                         }
                 break;
                 }
@@ -467,24 +491,25 @@ void CRYPTO_dbg_free(void *addr, int before_p)
 
                 if (is_MemCheck_on() && (mh != NULL))
                         {
-                        MemCheck_off();
+                        MemCheck_off(); /* make sure we hold MALLOC2 lock */
 
                         m.addr=addr;
                         mp=(MEM *)lh_delete(mh,(char *)&m);
                         if (mp != NULL)
                                 {
-#ifdef LEVITTE_DEBUG
-                        fprintf(stderr, "LEVITTE_DEBUG: [%5d] - 0x%p (%d)\n",
+#ifdef LEVITTE_DEBUG_MEM
+                        fprintf(stderr, "LEVITTE_DEBUG_MEM: [%5d] - 0x%p (%d)\n",
                                 mp->order, mp->addr, mp->num);
 #endif
                                 if (mp->app_info != NULL)
                                         {
                                         mp->app_info->references--;
                                         }
-                                Free(mp);
+                                OPENSSL_free(mp);
                                 }
 
-                        MemCheck_on(); /* releases CRYPTO_LOCK_MALLOC2 */
+                        MemCheck_on(); /* release MALLOC2 lock
+                                        * if num_disabled drops to 0 */
                         }
                 break;
         case 1:
@@ -497,8 +522,8 @@ void CRYPTO_dbg_realloc(void *addr1, void *addr2, int num,
         {
         MEM m,*mp;
 
-#ifdef LEVITTE_DEBUG
-        fprintf(stderr, "LEVITTE_DEBUG: --> CRYPTO_dbg_malloc(addr1 = %p, addr2 = %p, num = %d, file = \"%s\", line = %d, before_p = %d)\n",
+#ifdef LEVITTE_DEBUG_MEM
+        fprintf(stderr, "LEVITTE_DEBUG_MEM: --> CRYPTO_dbg_malloc(addr1 = %p, addr2 = %p, num = %d, file = \"%s\", line = %d, before_p = %d)\n",
                 addr1, addr2, num, file, line, before_p);
 #endif
 
@@ -518,14 +543,14 @@ void CRYPTO_dbg_realloc(void *addr1, void *addr2, int num,
 
                 if (is_MemCheck_on())
                         {
-                        MemCheck_off(); /* obtains CRYPTO_LOCK_MALLOC2 */
+                        MemCheck_off(); /* make sure we hold MALLOC2 lock */
 
                         m.addr=addr1;
                         mp=(MEM *)lh_delete(mh,(char *)&m);
                         if (mp != NULL)
                                 {
-#ifdef LEVITTE_DEBUG
-                                fprintf(stderr, "LEVITTE_DEBUG: [%5d] * 0x%p (%d) -> 0x%p (%d)\n",
+#ifdef LEVITTE_DEBUG_MEM
+                                fprintf(stderr, "LEVITTE_DEBUG_MEM: [%5d] * 0x%p (%d) -> 0x%p (%d)\n",
                                         mp->order,
                                         mp->addr, mp->num,
                                         addr2, num);
@@ -535,7 +560,8 @@ void CRYPTO_dbg_realloc(void *addr1, void *addr2, int num,
                                 lh_insert(mh,(char *)mp);
                                 }
 
-                        MemCheck_on(); /* releases CRYPTO_LOCK_MALLOC2 */
+                        MemCheck_on(); /* release MALLOC2 lock
+                                        * if num_disabled drops to 0 */
                         }
                 break;
                 }
@@ -550,7 +576,7 @@ typedef struct mem_leak_st
         long bytes;
         } MEM_LEAK;
 
-static void print_leak(MEM *m, MEM_LEAK *l)
+static void print_leak(const MEM *m, MEM_LEAK *l)
         {
         char buf[1024];
         char *bufp = buf;
@@ -626,7 +652,7 @@ static void print_leak(MEM *m, MEM_LEAK *l)
                 }
         while(amip && amip->thread == ti);
                 
-#ifdef LEVITTE_DEBUG
+#ifdef LEVITTE_DEBUG_MEM
         if (amip)
                 {
                 fprintf(stderr, "Thread switch detected in backtrace!!!!\n");
@@ -635,69 +661,114 @@ static void print_leak(MEM *m, MEM_LEAK *l)
 #endif
         }
 
+static IMPLEMENT_LHASH_DOALL_ARG_FN(print_leak, const MEM *, MEM_LEAK *)
+
 void CRYPTO_mem_leaks(BIO *b)
         {
         MEM_LEAK ml;
         char buf[80];
 
-        if (mh == NULL) return;
+        if (mh == NULL && amih == NULL)
+                return;
+
+        MemCheck_off(); /* obtain MALLOC2 lock */
+
         ml.bio=b;
         ml.bytes=0;
         ml.chunks=0;
-        CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
-        lh_doall_arg(mh,(void (*)())print_leak,(char *)&ml);
-        CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);
+        if (mh != NULL)
+                lh_doall_arg(mh, LHASH_DOALL_ARG_FN(print_leak),
+                                (char *)&ml);
         if (ml.chunks != 0)
                 {
                 sprintf(buf,"%ld bytes leaked in %d chunks\n",
                         ml.bytes,ml.chunks);
                 BIO_puts(b,buf);
                 }
+        else
+                {
+                /* Make sure that, if we found no leaks, memory-leak debugging itself
+                 * does not introduce memory leaks (which might irritate
+                 * external debugging tools).
+                 * (When someone enables leak checking, but does not call
+                 * this function, we declare it to be their fault.)
+                 *
+                 * XXX    This should be in CRYPTO_mem_leaks_cb,
+                 * and CRYPTO_mem_leaks should be implemented by
+                 * using CRYPTO_mem_leaks_cb.
+                 * (Also their should be a variant of lh_doall_arg
+                 * that takes a function pointer instead of a void *;
+                 * this would obviate the ugly and illegal
+                 * void_fn_to_char kludge in CRYPTO_mem_leaks_cb.
+                 * Otherwise the code police will come and get us.)
+                 */
+                int old_mh_mode;
 
-#if 0
-        lh_stats_bio(mh,b);
-        lh_node_stats_bio(mh,b);
-        lh_node_usage_stats_bio(mh,b);
-#endif
-        }
-
-union void_fn_to_char_u
-        {
-        char *char_p;
-        void (*fn_p)();
-        };
-
-static void cb_leak(MEM *m, char *cb)
-        {
-        union void_fn_to_char_u mem_callback;
+                CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
 
-        mem_callback.char_p=cb;
-        mem_callback.fn_p(m->order,m->file,m->line,m->num,m->addr);
-        }
+                /* avoid deadlock when lh_free() uses CRYPTO_dbg_free(),
+                 * which uses CRYPTO_is_mem_check_on */
+                old_mh_mode = mh_mode;
+                mh_mode = CRYPTO_MEM_CHECK_OFF;
 
-void CRYPTO_mem_leaks_cb(void (*cb)())
-        {
-        union void_fn_to_char_u mem_cb;
+                if (mh != NULL)
+                        {
+                        lh_free(mh);
+                        mh = NULL;
+                        }
+                if (amih != NULL)
+                        {
+                        if (lh_num_items(amih) == 0) 
+                                {
+                                lh_free(amih);
+                                amih = NULL;
+                                }
+                        }
 
-        if (mh == NULL) return;
-        CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
-        mem_cb.fn_p=cb;
-        lh_doall_arg(mh,(void (*)())cb_leak,mem_cb.char_p);
-        mem_cb.char_p=NULL;
-        CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);
+                mh_mode = old_mh_mode;
+                CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
+                }
+        MemCheck_on(); /* release MALLOC2 lock */
         }
 
-#ifndef NO_FP_API
+#ifndef OPENSSL_NO_FP_API
 void CRYPTO_mem_leaks_fp(FILE *fp)
         {
         BIO *b;
 
         if (mh == NULL) return;
-        if ((b=BIO_new(BIO_s_file())) == NULL)
-                return;
+        /* Need to turn off memory checking when allocated BIOs ... especially
+         * as we're creating them at a time when we're trying to check we've not
+         * left anything un-free()'d!! */
+        MemCheck_off();
+        b = BIO_new(BIO_s_file());
+        MemCheck_on();
+        if(!b) return;
         BIO_set_fp(b,fp,BIO_NOCLOSE);
         CRYPTO_mem_leaks(b);
         BIO_free(b);
         }
 #endif
 
+
+
+/* FIXME: We really don't allow much to the callback.  For example, it has
+   no chance of reaching the info stack for the item it processes.  Should
+   it really be this way?  -- Richard Levitte */
+/* NB: The prototypes have been typedef'd to CRYPTO_MEM_LEAK_CB inside crypto.h
+ * If this code is restructured, remove the callback type if it is no longer
+ * needed. -- Geoff Thorpe */
+static void cb_leak(const MEM *m, CRYPTO_MEM_LEAK_CB **cb)
+        {
+        (**cb)(m->order,m->file,m->line,m->num,m->addr);
+        }
+
+static IMPLEMENT_LHASH_DOALL_ARG_FN(cb_leak, const MEM *, CRYPTO_MEM_LEAK_CB **)
+
+void CRYPTO_mem_leaks_cb(CRYPTO_MEM_LEAK_CB *cb)
+        {
+        if (mh == NULL) return;
+        CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
+        lh_doall_arg(mh, LHASH_DOALL_ARG_FN(cb_leak), &cb);
+        CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);
+        }