First pass at applying KNF to the OpenSSL code, which almost makes it

readable. This pass is whitespace only and can readily be verified using
tr and md5.

1 files changed, 312 insertions, 331 deletions

diff --git a/src/lib/libcrypto/mem_dbg.c b/src/lib/libcrypto/mem_dbg.c
index ac793397f1..9324ec4c7d 100644
--- a/src/lib/libcrypto/mem_dbg.c
+++ b/src/lib/libcrypto/mem_dbg.c
@@ -118,7 +118,7 @@
 #include <openssl/bio.h>
 #include <openssl/lhash.h>
 
-static int mh_mode=CRYPTO_MEM_CHECK_OFF;
+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).
@@ -136,10 +136,9 @@ static int mh_mode=CRYPTO_MEM_CHECK_OFF;
 static unsigned long order = 0; /* number of memory requests */
 
 DECLARE_LHASH_OF(MEM);
-static LHASH_OF(MEM) *mh=NULL; /* hash-table of memory requests
-                                * (address as key); access requires
-                                * MALLOC2 lock */
-
+static LHASH_OF(MEM) *mh = NULL; /* hash - table of memory requests
+                                  * (address as key); access requires
+                                  * MALLOC2 lock */
 
 typedef struct app_mem_info_st
 /* For application-defined information (static C-string `info')
@@ -149,28 +148,28 @@ typedef struct app_mem_info_st
  *   CRYPTO_pop_info()           to pop an entry,
  *   CRYPTO_remove_all_info()    to pop all entries.
  */
-        {
+{
         CRYPTO_THREADID threadid;
         const char *file;
         int line;
         const char *info;
         struct app_mem_info_st *next; /* tail of thread's stack */
         int references;
-        } APP_INFO;
+} APP_INFO;
 
 static void app_info_free(APP_INFO *);
 
 DECLARE_LHASH_OF(APP_INFO);
-static LHASH_OF(APP_INFO) *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);
-                                       * access requires MALLOC2
-                                       * lock */
+static LHASH_OF(APP_INFO) *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);
+                                         * access requires MALLOC2
+                                         * lock */
 
 typedef struct mem_st
 /* memory-block description */
-        {
+{
         void *addr;
         int num;
         const char *file;
@@ -179,47 +178,46 @@ typedef struct mem_st
         unsigned long order;
         time_t time;
         APP_INFO *app_info;
-        } MEM;
+} MEM;
 
 static long options =             /* extra information to be recorded */
 #if defined(CRYPTO_MDEBUG_TIME) || defined(CRYPTO_MDEBUG_ALL)
-        V_CRYPTO_MDEBUG_TIME |
+V_CRYPTO_MDEBUG_TIME |
 #endif
 #if defined(CRYPTO_MDEBUG_THREAD) || defined(CRYPTO_MDEBUG_ALL)
-        V_CRYPTO_MDEBUG_THREAD |
+V_CRYPTO_MDEBUG_THREAD |
 #endif
-        0;
+0;
 
 
 static unsigned int num_disable = 0; /* num_disable > 0
-                                      *     iff
-                                      * mh_mode == CRYPTO_MEM_CHECK_ON (w/o ..._ENABLE)
-                                      */
+                                      *     iff
+                                      * mh_mode == CRYPTO_MEM_CHECK_ON (w/o ..._ENABLE)
+                                      */
 
 /* Valid iff num_disable > 0.  CRYPTO_LOCK_MALLOC2 is locked exactly in this
  * case (by the thread named in disabling_thread).
  */
 static CRYPTO_THREADID disabling_threadid;
 
-static void app_info_free(APP_INFO *inf)
-        {
-        if (--(inf->references) <= 0)
-                {
-                if (inf->next != NULL)
-                        {
+static void
+app_info_free(APP_INFO *inf)
+{
+        if (--(inf->references) <= 0) {
+                if (inf->next != NULL) {
                         app_info_free(inf->next);
-                        }
-                OPENSSL_free(inf);
                 }
+                OPENSSL_free(inf);
         }
+}
 
-int CRYPTO_mem_ctrl(int mode)
-        {
-        int ret=mh_mode;
+int
+CRYPTO_mem_ctrl(int mode)
+{
+        int ret = mh_mode;
 
         CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
-        switch (mode)
-                {
+        switch (mode) {
         /* for applications (not to be called while multiple threads
          * use the library): */
         case CRYPTO_MEM_CHECK_ON: /* aka MemCheck_start() */
@@ -232,14 +230,13 @@ int CRYPTO_mem_ctrl(int mode)
                                     or there'll be a lot of confusion */
                 break;
 
-        /* switch off temporarily (for library-internal use): */
+                /* switch off temporarily (for library-internal use): */
         case CRYPTO_MEM_CHECK_DISABLE: /* aka MemCheck_off() */
-                if (mh_mode & CRYPTO_MEM_CHECK_ON)
-                        {
+                if (mh_mode & CRYPTO_MEM_CHECK_ON) {
                         CRYPTO_THREADID cur;
                         CRYPTO_THREADID_current(&cur);
                         if (!num_disable || CRYPTO_THREADID_cmp(&disabling_threadid, &cur)) /* 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
                                  * somebody else holds CRYPTO_LOCK_MALLOC2 (and cannot release
@@ -257,412 +254,402 @@ int CRYPTO_mem_ctrl(int mode)
                                 CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
                                 mh_mode &= ~CRYPTO_MEM_CHECK_ENABLE;
                                 CRYPTO_THREADID_cpy(&disabling_threadid, &cur);
-                                }
-                        num_disable++;
                         }
+                        num_disable++;
+                }
                 break;
         case CRYPTO_MEM_CHECK_ENABLE: /* aka MemCheck_on() */
-                if (mh_mode & CRYPTO_MEM_CHECK_ON)
-                        {
+                if (mh_mode & CRYPTO_MEM_CHECK_ON) {
                         if (num_disable) /* always true, or something is going wrong */
-                                {
+                        {
                                 num_disable--;
-                                if (num_disable == 0)
-                                        {
+                                if (num_disable == 0) {
                                         mh_mode|=CRYPTO_MEM_CHECK_ENABLE;
                                         CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);
-                                        }
                                 }
                         }
+                }
                 break;
 
         default:
                 break;
-                }
-        CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
-        return(ret);
         }
+        CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
+        return (ret);
+}
 
-int CRYPTO_is_mem_check_on(void)
-        {
+int
+CRYPTO_is_mem_check_on(void)
+{
         int ret = 0;
 
-        if (mh_mode & CRYPTO_MEM_CHECK_ON)
-                {
+        if (mh_mode & CRYPTO_MEM_CHECK_ON) {
                 CRYPTO_THREADID cur;
                 CRYPTO_THREADID_current(&cur);
                 CRYPTO_r_lock(CRYPTO_LOCK_MALLOC);
 
-                ret = (mh_mode & CRYPTO_MEM_CHECK_ENABLE)
-                        || CRYPTO_THREADID_cmp(&disabling_threadid, &cur);
+                ret = (mh_mode & CRYPTO_MEM_CHECK_ENABLE) ||
+                    CRYPTO_THREADID_cmp(&disabling_threadid, &cur);
 
                 CRYPTO_r_unlock(CRYPTO_LOCK_MALLOC);
-                }
-        return(ret);
-        }       
+        }
+        return (ret);
+}
 
 
-void CRYPTO_dbg_set_options(long bits)
-        {
+void
+CRYPTO_dbg_set_options(long bits)
+{
         options = bits;
-        }
+}
 
-long CRYPTO_dbg_get_options(void)
-        {
+long
+CRYPTO_dbg_get_options(void)
+{
         return options;
-        }
+}
 
-static int mem_cmp(const MEM *a, const MEM *b)
-        {
+static int
+mem_cmp(const MEM *a, const MEM *b)
+{
 #ifdef _WIN64
-        const char *ap=(const char *)a->addr,
-                   *bp=(const char *)b->addr;
-        if (ap==bp)     return 0;
-        else if (ap>bp) return 1;
-        else            return -1;
+        const char *ap = (const char *)a->addr,
+        *bp = (const char *)b->addr;
+        if (ap == bp)
+                return 0;
+        else if (ap > bp)       return 1;
+                else            return -1;
 #else
         return (const char *)a->addr - (const char *)b->addr;
 #endif
-        }
+}
+
 static IMPLEMENT_LHASH_COMP_FN(mem, MEM)
 
-static unsigned long mem_hash(const MEM *a)
-        {
+static unsigned long
+mem_hash(const MEM *a)
+{
         unsigned long ret;
 
-        ret=(unsigned long)a->addr;
+        ret = (unsigned long)a->addr;
 
-        ret=ret*17851+(ret>>14)*7+(ret>>4)*251;
-        return(ret);
-        }
-static IMPLEMENT_LHASH_HASH_FN(mem, MEM)
+        ret = ret * 17851 + (ret >> 14) * 7 + (ret >> 4) * 251;
+        return (ret);
+}
+
+static
+IMPLEMENT_LHASH_HASH_FN(mem, MEM)
 
 /* static int app_info_cmp(APP_INFO *a, APP_INFO *b) */
-static int app_info_cmp(const void *a_void, const void *b_void)
-        {
+static int
+app_info_cmp(const void *a_void, const void *b_void)
+{
         return CRYPTO_THREADID_cmp(&((const APP_INFO *)a_void)->threadid,
-                                &((const APP_INFO *)b_void)->threadid);
-        }
+            &((const APP_INFO *)b_void)->threadid);
+}
+
 static IMPLEMENT_LHASH_COMP_FN(app_info, APP_INFO)
 
-static unsigned long app_info_hash(const APP_INFO *a)
-        {
+static unsigned long
+app_info_hash(const APP_INFO *a)
+{
         unsigned long ret;
 
         ret = CRYPTO_THREADID_hash(&a->threadid);
         /* This is left in as a "who am I to question legacy?" measure */
-        ret=ret*17851+(ret>>14)*7+(ret>>4)*251;
-        return(ret);
-        }
+        ret = ret * 17851 + (ret >> 14) * 7 + (ret >> 4) * 251;
+        return (ret);
+}
+
 static IMPLEMENT_LHASH_HASH_FN(app_info, APP_INFO)
 
-static APP_INFO *pop_info(void)
-        {
+static APP_INFO
+*pop_info(void)
+{
         APP_INFO tmp;
         APP_INFO *ret = NULL;
 
-        if (amih != NULL)
-                {
+        if (amih != NULL) {
                 CRYPTO_THREADID_current(&tmp.threadid);
-                if ((ret=lh_APP_INFO_delete(amih,&tmp)) != NULL)
-                        {
-                        APP_INFO *next=ret->next;
+                if ((ret = lh_APP_INFO_delete(amih, &tmp)) != NULL) {
+                        APP_INFO *next = ret->next;
 
-                        if (next != NULL)
-                                {
+                        if (next != NULL) {
                                 next->references++;
-                                (void)lh_APP_INFO_insert(amih,next);
-                                }
+                                (void)lh_APP_INFO_insert(amih, next);
+                        }
 #ifdef LEVITTE_DEBUG_MEM
-                        if (CRYPTO_THREADID_cmp(&ret->threadid, &tmp.threadid))
-                                {
+                        if (CRYPTO_THREADID_cmp(&ret->threadid, &tmp.threadid)) {
                                 fprintf(stderr, "pop_info(): deleted info has other thread ID (%lu) than the current thread (%lu)!!!!\n",
-                                        CRYPTO_THREADID_hash(&ret->threadid),
-                                        CRYPTO_THREADID_hash(&tmp.threadid));
+                                CRYPTO_THREADID_hash(&ret->threadid),
+                                CRYPTO_THREADID_hash(&tmp.threadid));
                                 abort();
-                                }
+                        }
 #endif
-                        if (--(ret->references) <= 0)
-                                {
+                        if (--(ret->references) <= 0) {
                                 ret->next = NULL;
                                 if (next != NULL)
                                         next->references--;
                                 OPENSSL_free(ret);
-                                }
                         }
                 }
-        return(ret);
         }
+        return (ret);
+}
 
-int CRYPTO_push_info_(const char *info, const char *file, int line)
-        {
+int
+CRYPTO_push_info_(const char *info, const char *file, int line)
+{
         APP_INFO *ami, *amim;
-        int ret=0;
+        int ret = 0;
 
-        if (is_MemCheck_on())
-                {
+        if (is_MemCheck_on()) {
                 MemCheck_off(); /* obtain MALLOC2 lock */
 
-                if ((ami = (APP_INFO *)OPENSSL_malloc(sizeof(APP_INFO))) == NULL)
-                        {
-                        ret=0;
+                if ((ami = (APP_INFO *)OPENSSL_malloc(sizeof(APP_INFO))) == NULL) {
+                        ret = 0;
                         goto err;
-                        }
-                if (amih == NULL)
-                        {
-                        if ((amih=lh_APP_INFO_new()) == NULL)
-                                {
+                }
+                if (amih == NULL) {
+                        if ((amih = lh_APP_INFO_new()) == NULL) {
                                 OPENSSL_free(ami);
-                                ret=0;
+                                ret = 0;
                                 goto err;
-                                }
                         }
+                }
 
                 CRYPTO_THREADID_current(&ami->threadid);
-                ami->file=file;
-                ami->line=line;
-                ami->info=info;
-                ami->references=1;
-                ami->next=NULL;
+                ami->file = file;
+                ami->line = line;
+                ami->info = info;
+                ami->references = 1;
+                ami->next = NULL;
 
-                if ((amim=lh_APP_INFO_insert(amih,ami)) != NULL)
-                        {
+                if ((amim = lh_APP_INFO_insert(amih, ami)) != NULL) {
 #ifdef LEVITTE_DEBUG_MEM
-                        if (CRYPTO_THREADID_cmp(&ami->threadid, &amim->threadid))
-                                {
+                        if (CRYPTO_THREADID_cmp(&ami->threadid, &amim->threadid)) {
                                 fprintf(stderr, "CRYPTO_push_info(): previous info has other thread ID (%lu) than the current thread (%lu)!!!!\n",
-                                        CRYPTO_THREADID_hash(&amim->threadid),
-                                        CRYPTO_THREADID_hash(&ami->threadid));
+                                CRYPTO_THREADID_hash(&amim->threadid),
+                                CRYPTO_THREADID_hash(&ami->threadid));
                                 abort();
-                                }
-#endif
-                        ami->next=amim;
                         }
- err:
-                MemCheck_on(); /* release MALLOC2 lock */
+#endif
+                        ami->next = amim;
                 }
-
-        return(ret);
+                err:
+                MemCheck_on(); /* release MALLOC2 lock */
         }
 
-int CRYPTO_pop_info(void)
-        {
-        int ret=0;
+        return (ret);
+}
+
+int
+CRYPTO_pop_info(void)
+{
+        int ret = 0;
 
         if (is_MemCheck_on()) /* _must_ be true, or something went severely wrong */
-                {
+        {
                 MemCheck_off(); /* obtain MALLOC2 lock */
 
-                ret=(pop_info() != NULL);
+                ret = (pop_info() != NULL);
 
                 MemCheck_on(); /* release MALLOC2 lock */
-                }
-        return(ret);
         }
+        return (ret);
+}
 
-int CRYPTO_remove_all_info(void)
-        {
-        int ret=0;
+int
+CRYPTO_remove_all_info(void)
+{
+        int ret = 0;
 
         if (is_MemCheck_on()) /* _must_ be true */
-                {
+        {
                 MemCheck_off(); /* obtain MALLOC2 lock */
 
-                while(pop_info() != NULL)
-                        ret++;
+                while (pop_info() != NULL)
+                ret++;
 
                 MemCheck_on(); /* release MALLOC2 lock */
-                }
-        return(ret);
         }
+        return (ret);
+}
 
 
-static unsigned long break_order_num=0;
-void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line,
-        int before_p)
-        {
-        MEM *m,*mm;
-        APP_INFO tmp,*amim;
+static unsigned long break_order_num = 0;
+void
+CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line,
+    int before_p)
+{
+        MEM *m, *mm;
+        APP_INFO tmp, *amim;
 
-        switch(before_p & 127)
-                {
+        switch (before_p & 127) {
         case 0:
                 break;
         case 1:
                 if (addr == NULL)
                         break;
 
-                if (is_MemCheck_on())
-                        {
+                if (is_MemCheck_on()) {
                         MemCheck_off(); /* make sure we hold MALLOC2 lock */
-                        if ((m=(MEM *)OPENSSL_malloc(sizeof(MEM))) == NULL)
-                                {
+                        if ((m = (MEM *)OPENSSL_malloc(sizeof(MEM))) == NULL) {
                                 OPENSSL_free(addr);
                                 MemCheck_on(); /* release MALLOC2 lock
                                                 * if num_disabled drops to 0 */
                                 return;
-                                }
-                        if (mh == NULL)
-                                {
-                                if ((mh=lh_MEM_new()) == NULL)
-                                        {
+                        }
+                        if (mh == NULL) {
+                                if ((mh = lh_MEM_new()) == NULL) {
                                         OPENSSL_free(addr);
                                         OPENSSL_free(m);
-                                        addr=NULL;
+                                        addr = NULL;
                                         goto err;
-                                        }
                                 }
+                        }
 
-                        m->addr=addr;
-                        m->file=file;
-                        m->line=line;
-                        m->num=num;
+                        m->addr = addr;
+                        m->file = file;
+                        m->line = line;
+                        m->num = num;
                         if (options & V_CRYPTO_MDEBUG_THREAD)
                                 CRYPTO_THREADID_current(&m->threadid);
                         else
                                 memset(&m->threadid, 0, sizeof(m->threadid));
 
-                        if (order == break_order_num)
-                                {
+                        if (order == break_order_num) {
                                 /* BREAK HERE */
-                                m->order=order;
-                                }
-                        m->order=order++;
+                                m->order = order;
+                        }
+                        m->order = order++;
 #ifdef LEVITTE_DEBUG_MEM
                         fprintf(stderr, "LEVITTE_DEBUG_MEM: [%5ld] %c 0x%p (%d)\n",
-                                m->order,
-                                (before_p & 128) ? '*' : '+',
-                                m->addr, m->num);
+                            m->order,
+                            (before_p & 128) ? '*' : '+',
+                            m->addr, m->num);
 #endif
                         if (options & V_CRYPTO_MDEBUG_TIME)
-                                m->time=time(NULL);
+                                m->time = time(NULL);
                         else
-                                m->time=0;
+                                m->time = 0;
 
                         CRYPTO_THREADID_current(&tmp.threadid);
-                        m->app_info=NULL;
-                        if (amih != NULL
-                            && (amim=lh_APP_INFO_retrieve(amih,&tmp)) != NULL)
-                                {
+                        m->app_info = NULL;
+                        if (amih != NULL &&
+                            (amim = lh_APP_INFO_retrieve(amih, &tmp)) != NULL) {
                                 m->app_info = amim;
                                 amim->references++;
-                                }
+                        }
 
-                        if ((mm=lh_MEM_insert(mh, m)) != NULL)
-                                {
+                        if ((mm = lh_MEM_insert(mh, m)) != NULL) {
                                 /* Not good, but don't sweat it */
-                                if (mm->app_info != NULL)
-                                        {
+                                if (mm->app_info != NULL) {
                                         mm->app_info->references--;
-                                        }
-                                OPENSSL_free(mm);
                                 }
-                err:
+                                OPENSSL_free(mm);
+                        }
+err:
                         MemCheck_on(); /* release MALLOC2 lock
                                         * if num_disabled drops to 0 */
-                        }
-                break;
                 }
-        return;
+                break;
         }
+        return;
+}
 
-void CRYPTO_dbg_free(void *addr, int before_p)
-        {
-        MEM m,*mp;
+void
+CRYPTO_dbg_free(void *addr, int before_p)
+{
+        MEM m, *mp;
 
-        switch(before_p)
-                {
+        switch (before_p) {
         case 0:
                 if (addr == NULL)
                         break;
 
-                if (is_MemCheck_on() && (mh != NULL))
-                        {
+                if (is_MemCheck_on() && (mh != NULL)) {
                         MemCheck_off(); /* make sure we hold MALLOC2 lock */
 
-                        m.addr=addr;
-                        mp=lh_MEM_delete(mh,&m);
-                        if (mp != NULL)
-                                {
+                        m.addr = addr;
+                        mp = lh_MEM_delete(mh, &m);
+                        if (mp != NULL) {
 #ifdef LEVITTE_DEBUG_MEM
-                        fprintf(stderr, "LEVITTE_DEBUG_MEM: [%5ld] - 0x%p (%d)\n",
+                                fprintf(stderr, "LEVITTE_DEBUG_MEM: [%5ld] - 0x%p (%d)\n",
                                 mp->order, mp->addr, mp->num);
 #endif
                                 if (mp->app_info != NULL)
                                         app_info_free(mp->app_info);
                                 OPENSSL_free(mp);
-                                }
+                        }
 
                         MemCheck_on(); /* release MALLOC2 lock
                                         * if num_disabled drops to 0 */
-                        }
+                }
                 break;
         case 1:
                 break;
-                }
         }
+}
 
-void CRYPTO_dbg_realloc(void *addr1, void *addr2, int num,
-        const char *file, int line, int before_p)
-        {
-        MEM m,*mp;
+void
+CRYPTO_dbg_realloc(void *addr1, void *addr2, int num,
+    const char *file, int line, int before_p)
+{
+        MEM m, *mp;
 
 #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);
+        addr1, addr2, num, file, line, before_p);
 #endif
 
-        switch(before_p)
-                {
+        switch (before_p) {
         case 0:
                 break;
         case 1:
                 if (addr2 == NULL)
                         break;
 
-                if (addr1 == NULL)
-                        {
+                if (addr1 == NULL) {
                         CRYPTO_dbg_malloc(addr2, num, file, line, 128 | before_p);
                         break;
-                        }
+                }
 
-                if (is_MemCheck_on())
-                        {
+                if (is_MemCheck_on()) {
                         MemCheck_off(); /* make sure we hold MALLOC2 lock */
 
-                        m.addr=addr1;
-                        mp=lh_MEM_delete(mh,&m);
-                        if (mp != NULL)
-                                {
+                        m.addr = addr1;
+                        mp = lh_MEM_delete(mh, &m);
+                        if (mp != NULL) {
 #ifdef LEVITTE_DEBUG_MEM
                                 fprintf(stderr, "LEVITTE_DEBUG_MEM: [%5ld] * 0x%p (%d) -> 0x%p (%d)\n",
-                                        mp->order,
-                                        mp->addr, mp->num,
-                                        addr2, num);
+                                    mp->order,
+                                    mp->addr, mp->num,
+                                    addr2, num);
 #endif
-                                mp->addr=addr2;
-                                mp->num=num;
-                                (void)lh_MEM_insert(mh,mp);
-                                }
+                                mp->addr = addr2;
+                                mp->num = num;
+                                (void)lh_MEM_insert(mh, mp);
+                        }
 
                         MemCheck_on(); /* release MALLOC2 lock
                                         * if num_disabled drops to 0 */
-                        }
-                break;
                 }
-        return;
+                break;
         }
+        return;
+}
 
 
-typedef struct mem_leak_st
-        {
+typedef struct mem_leak_st {
         BIO *bio;
         int chunks;
         long bytes;
-        } MEM_LEAK;
+} MEM_LEAK;
 
-static void print_leak_doall_arg(const MEM *m, MEM_LEAK *l)
-        {
+static void
+print_leak_doall_arg(const MEM *m, MEM_LEAK *l)
+{
         char buf[1024];
         char *bufp = buf;
         APP_INFO *amip;
@@ -672,89 +659,83 @@ static void print_leak_doall_arg(const MEM *m, MEM_LEAK *l)
 
 #define BUF_REMAIN (sizeof buf - (size_t)(bufp - buf))
 
-        if(m->addr == (char *)l->bio)
-            return;
+        if (m->addr == (char *)l->bio)
+                return;
 
-        if (options & V_CRYPTO_MDEBUG_TIME)
-                {
+        if (options & V_CRYPTO_MDEBUG_TIME) {
                 lcl = localtime(&m->time);
-        
+
                 BIO_snprintf(bufp, BUF_REMAIN, "[%02d:%02d:%02d] ",
-                        lcl->tm_hour,lcl->tm_min,lcl->tm_sec);
+                lcl->tm_hour, lcl->tm_min, lcl->tm_sec);
                 bufp += strlen(bufp);
-                }
+        }
 
         BIO_snprintf(bufp, BUF_REMAIN, "%5lu file=%s, line=%d, ",
-                m->order,m->file,m->line);
+        m->order, m->file, m->line);
         bufp += strlen(bufp);
 
-        if (options & V_CRYPTO_MDEBUG_THREAD)
-                {
+        if (options & V_CRYPTO_MDEBUG_THREAD) {
                 BIO_snprintf(bufp, BUF_REMAIN, "thread=%lu, ",
-                        CRYPTO_THREADID_hash(&m->threadid));
+                CRYPTO_THREADID_hash(&m->threadid));
                 bufp += strlen(bufp);
-                }
+        }
 
         BIO_snprintf(bufp, BUF_REMAIN, "number=%d, address=%08lX\n",
-                m->num,(unsigned long)m->addr);
+        m->num,(unsigned long)m->addr);
         bufp += strlen(bufp);
 
-        BIO_puts(l->bio,buf);
-        
+        BIO_puts(l->bio, buf);
+
         l->chunks++;
-        l->bytes+=m->num;
+        l->bytes += m->num;
 
-        amip=m->app_info;
-        ami_cnt=0;
+        amip = m->app_info;
+        ami_cnt = 0;
         if (!amip)
                 return;
         CRYPTO_THREADID_cpy(&ti, &amip->threadid);
 
-        do
-                {
+        do {
                 int buf_len;
                 int info_len;
 
                 ami_cnt++;
-                memset(buf,'>',ami_cnt);
+                memset(buf, '>', ami_cnt);
                 BIO_snprintf(buf + ami_cnt, sizeof buf - ami_cnt,
-                        " thread=%lu, file=%s, line=%d, info=\"",
-                        CRYPTO_THREADID_hash(&amip->threadid), amip->file,
-                        amip->line);
-                buf_len=strlen(buf);
-                info_len=strlen(amip->info);
-                if (128 - buf_len - 3 < info_len)
-                        {
+                " thread=%lu, file=%s, line=%d, info=\"",
+                CRYPTO_THREADID_hash(&amip->threadid), amip->file,
+                amip->line);
+                buf_len = strlen(buf);
+                info_len = strlen(amip->info);
+                if (128 - buf_len - 3 < info_len) {
                         memcpy(buf + buf_len, amip->info, 128 - buf_len - 3);
                         buf_len = 128 - 3;
-                        }
-                else
-                        {
+                } else {
                         BUF_strlcpy(buf + buf_len, amip->info,
-                                    sizeof buf - buf_len);
+                        sizeof buf - buf_len);
                         buf_len = strlen(buf);
-                        }
+                }
                 BIO_snprintf(buf + buf_len, sizeof buf - buf_len, "\"\n");
-                
-                BIO_puts(l->bio,buf);
+
+                BIO_puts(l->bio, buf);
 
                 amip = amip->next;
-                }
-        while(amip && !CRYPTO_THREADID_cmp(&amip->threadid, &ti));
+        } while (amip && !CRYPTO_THREADID_cmp(&amip->threadid, &ti));
 
 #ifdef LEVITTE_DEBUG_MEM
-        if (amip)
-                {
+        if (amip) {
                 fprintf(stderr, "Thread switch detected in backtrace!!!!\n");
                 abort();
-                }
-#endif
         }
+#endif
+}
 
-static IMPLEMENT_LHASH_DOALL_ARG_FN(print_leak, const MEM, MEM_LEAK)
+static
+IMPLEMENT_LHASH_DOALL_ARG_FN(print_leak, const MEM, MEM_LEAK)
 
-void CRYPTO_mem_leaks(BIO *b)
-        {
+void
+CRYPTO_mem_leaks(BIO *b)
+{
         MEM_LEAK ml;
 
         if (mh == NULL && amih == NULL)
@@ -762,22 +743,19 @@ void CRYPTO_mem_leaks(BIO *b)
 
         MemCheck_off(); /* obtain MALLOC2 lock */
 
-        ml.bio=b;
-        ml.bytes=0;
-        ml.chunks=0;
+        ml.bio = b;
+        ml.bytes = 0;
+        ml.chunks = 0;
         if (mh != NULL)
-                lh_MEM_doall_arg(mh, LHASH_DOALL_ARG_FN(print_leak), MEM_LEAK,
-                                 &ml);
-        if (ml.chunks != 0)
-                {
-                BIO_printf(b,"%ld bytes leaked in %d chunks\n",
-                           ml.bytes,ml.chunks);
+                lh_MEM_doall_arg(mh, LHASH_DOALL_ARG_FN(print_leak),
+                    MEM_LEAK, &ml);
+        if (ml.chunks != 0) {
+                BIO_printf(b, "%ld bytes leaked in %d chunks\n",
+                ml.bytes, ml.chunks);
 #ifdef CRYPTO_MDEBUG_ABORT
                 abort();
 #endif
-                }
-        else
-                {
+        } else {
                 /* Make sure that, if we found no leaks, memory-leak debugging itself
                  * does not introduce memory leaks (which might irritate
                  * external debugging tools).
@@ -802,43 +780,43 @@ void CRYPTO_mem_leaks(BIO *b)
                 old_mh_mode = mh_mode;
                 mh_mode = CRYPTO_MEM_CHECK_OFF;
 
-                if (mh != NULL)
-                        {
+                if (mh != NULL) {
                         lh_MEM_free(mh);
                         mh = NULL;
-                        }
-                if (amih != NULL)
-                        {
-                        if (lh_APP_INFO_num_items(amih) == 0) 
-                                {
+                }
+                if (amih != NULL) {
+                        if (lh_APP_INFO_num_items(amih) == 0) {
                                 lh_APP_INFO_free(amih);
                                 amih = NULL;
-                                }
                         }
+                }
 
                 mh_mode = old_mh_mode;
                 CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
-                }
-        MemCheck_on(); /* release MALLOC2 lock */
         }
+        MemCheck_on(); /* release MALLOC2 lock */
+}
 
 #ifndef OPENSSL_NO_FP_API
-void CRYPTO_mem_leaks_fp(FILE *fp)
-        {
+void
+CRYPTO_mem_leaks_fp(FILE *fp)
+{
         BIO *b;
 
-        if (mh == NULL) return;
+        if (mh == 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);
+        if (!b)
+                return;
+        BIO_set_fp(b, fp, BIO_NOCLOSE);
         CRYPTO_mem_leaks(b);
         BIO_free(b);
-        }
+}
 #endif
 
 
@@ -857,18 +835,21 @@ void CRYPTO_mem_leaks_fp(FILE *fp)
 
 typedef CRYPTO_MEM_LEAK_CB *PCRYPTO_MEM_LEAK_CB;
 
-static void cb_leak_doall_arg(const MEM *m, PCRYPTO_MEM_LEAK_CB *cb)
-        {
-        (*cb)(m->order,m->file,m->line,m->num,m->addr);
-        }
+static void
+cb_leak_doall_arg(const MEM *m, PCRYPTO_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, PCRYPTO_MEM_LEAK_CB)
 
-void CRYPTO_mem_leaks_cb(CRYPTO_MEM_LEAK_CB *cb)
-        {
-        if (mh == NULL) return;
+void
+CRYPTO_mem_leaks_cb(CRYPTO_MEM_LEAK_CB *cb)
+{
+        if (mh == NULL)
+                return;
         CRYPTO_w_lock(CRYPTO_LOCK_MALLOC2);
         lh_MEM_doall_arg(mh, LHASH_DOALL_ARG_FN(cb_leak), PCRYPTO_MEM_LEAK_CB,
-                         &cb);
+        &cb);
         CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC2);
-        }
+}