1 files changed, 312 insertions, 331 deletions

diff --git a/lib/libssl/src/crypto/mem_dbg.c b/lib/libssl/src/crypto/mem_dbg.c
index ac793397f10..9324ec4c7dd 100644
--- a/lib/libssl/src/crypto/mem_dbg.c
+++ b/lib/libssl/src/crypto/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);
-	}
+}