From 23a04fa2273190c4874c5263ecbaf03e743b19f6 Mon Sep 17 00:00:00 2001
From: miod <>
Date: Sun, 15 Feb 2015 09:46:47 +0000
Subject: Fix various memory leaks by not exiting so abruptly from failed
 tests.

---
 src/regress/lib/libcrypto/bn/general/bntest.c | 1086 ++++++++++++-------------
 1 file changed, 507 insertions(+), 579 deletions(-)

(limited to 'src')

diff --git a/src/regress/lib/libcrypto/bn/general/bntest.c b/src/regress/lib/libcrypto/bn/general/bntest.c
index a3206aba8c..ad000fcf56 100644
--- a/src/regress/lib/libcrypto/bn/general/bntest.c
+++ b/src/regress/lib/libcrypto/bn/general/bntest.c
@@ -120,19 +120,21 @@ int test_mod_exp_sizes(BIO *bp, BN_CTX *ctx);
 int rand_neg(void);
 static int results=0;
 
-static unsigned char lst[]="\xC6\x4F\x43\x04\x2A\xEA\xCA\x6E\x58\x36\x80\x5B\xE8\xC9"
+static const unsigned char lst[]="\xC6\x4F\x43\x04\x2A\xEA\xCA\x6E\x58\x36\x80\x5B\xE8\xC9"
 "\x9B\x04\x5D\x48\x36\xC2\xFD\x16\xC9\x64\xF0";
 
-static void message(BIO *out, char *m)
-	{
+static void
+message(BIO *out, char *m)
+{
 	fprintf(stderr, "test %s\n", m);
 	BIO_puts(out, "print \"test ");
 	BIO_puts(out, m);
 	BIO_puts(out, "\\n\"\n");
-	}
+}
 
-int main(int argc, char *argv[])
-	{
+int
+main(int argc, char *argv[])
+{
 	BN_CTX *ctx;
 	BIO *out;
 	char *outfile=NULL;
@@ -141,18 +143,16 @@ int main(int argc, char *argv[])
 
 	argc--;
 	argv++;
-	while (argc >= 1)
-		{
+	while (argc >= 1) {
 		if (strcmp(*argv,"-results") == 0)
 			results=1;
-		else if (strcmp(*argv,"-out") == 0)
-			{
+		else if (strcmp(*argv,"-out") == 0) {
 			if (--argc < 1) break;
 			outfile= *(++argv);
-			}
+		}
 		argc--;
 		argv++;
-		}
+	}
 
 
 	ctx=BN_CTX_new();
@@ -160,18 +160,14 @@ int main(int argc, char *argv[])
 
 	out=BIO_new(BIO_s_file());
 	if (out == NULL) exit(1);
-	if (outfile == NULL)
-		{
+	if (outfile == NULL) {
 		BIO_set_fp(out,stdout,BIO_NOCLOSE);
-		}
-	else
-		{
-		if (!BIO_write_filename(out,outfile))
-			{
+	} else {
+		if (!BIO_write_filename(out,outfile)) {
 			perror(outfile);
 			exit(1);
-			}
 		}
+	}
 
 	if (!results)
 		BIO_puts(out,"obase=16\nibase=16\n");
@@ -311,107 +307,107 @@ err:
 	ERR_load_crypto_strings();
 	ERR_print_errors_fp(stderr);
 	exit(1);
-	}
+}
 
-int test_add(BIO *bp)
-	{
+int
+test_add(BIO *bp)
+{
 	BIGNUM a,b,c;
 	int i;
+	int rc = 1;
 
 	BN_init(&a);
 	BN_init(&b);
 	BN_init(&c);
 
 	BN_bntest_rand(&a,512,0,0);
-	for (i=0; i<num0; i++)
-		{
+	for (i=0; i<num0; i++) {
 		BN_bntest_rand(&b,450+i,0,0);
 		a.neg=rand_neg();
 		b.neg=rand_neg();
 		BN_add(&c,&a,&b);
-		if (bp != NULL)
-			{
-			if (!results)
-				{
+		if (bp != NULL) {
+			if (!results) {
 				BN_print(bp,&a);
 				BIO_puts(bp," + ");
 				BN_print(bp,&b);
 				BIO_puts(bp," - ");
-				}
+			}
 			BN_print(bp,&c);
 			BIO_puts(bp,"\n");
-			}
+		}
 		a.neg=!a.neg;
 		b.neg=!b.neg;
 		BN_add(&c,&c,&b);
 		BN_add(&c,&c,&a);
-		if(!BN_is_zero(&c))
-		    {
+		if(!BN_is_zero(&c)) {
 		    fprintf(stderr,"Add test failed!\n");
-		    return 0;
-		    }
+		    rc = 0;
+		    break;
 		}
+	}
 	BN_free(&a);
 	BN_free(&b);
 	BN_free(&c);
-	return(1);
-	}
+	return(rc);
+}
 
-int test_sub(BIO *bp)
-	{
+int
+test_sub(BIO *bp)
+{
 	BIGNUM a,b,c;
 	int i;
+	int rc = 1;
 
 	BN_init(&a);
 	BN_init(&b);
 	BN_init(&c);
 
-	for (i=0; i<num0+num1; i++)
-		{
-		if (i < num1)
-			{
+	for (i=0; i<num0+num1; i++) {
+		if (i < num1) {
 			BN_bntest_rand(&a,512,0,0);
 			BN_copy(&b,&a);
-			if (BN_set_bit(&a,i)==0) return(0);
-			BN_add_word(&b,i);
+			if (BN_set_bit(&a,i)==0) {
+				rc = 0;
+				break;
 			}
-		else
-			{
+			BN_add_word(&b,i);
+		} else {
 			BN_bntest_rand(&b,400+i-num1,0,0);
 			a.neg=rand_neg();
 			b.neg=rand_neg();
-			}
+		}
 		BN_sub(&c,&a,&b);
-		if (bp != NULL)
-			{
-			if (!results)
-				{
+		if (bp != NULL) {
+			if (!results) {
 				BN_print(bp,&a);
 				BIO_puts(bp," - ");
 				BN_print(bp,&b);
 				BIO_puts(bp," - ");
-				}
+			}
 			BN_print(bp,&c);
 			BIO_puts(bp,"\n");
-			}
+		}
 		BN_add(&c,&c,&b);
 		BN_sub(&c,&c,&a);
-		if(!BN_is_zero(&c))
-		    {
+		if(!BN_is_zero(&c)) {
 		    fprintf(stderr,"Subtract test failed!\n");
-		    return 0;
-		    }
+		    rc = 0;
+		    break;
 		}
+	}
 	BN_free(&a);
 	BN_free(&b);
 	BN_free(&c);
-	return(1);
-	}
+	return(rc);
+}
 
-int test_div(BIO *bp, BN_CTX *ctx)
-	{
+int
+test_div(BIO *bp, BN_CTX *ctx)
+{
 	BIGNUM a,b,c,d,e;
 	int i;
+	int rc = 1;
 
 	BN_init(&a);
 	BN_init(&b);
@@ -419,86 +415,82 @@ int test_div(BIO *bp, BN_CTX *ctx)
 	BN_init(&d);
 	BN_init(&e);
 
-	for (i=0; i<num0+num1; i++)
-		{
-		if (i < num1)
-			{
+	for (i=0; i<num0+num1; i++) {
+		if (i < num1) {
 			BN_bntest_rand(&a,400,0,0);
 			BN_copy(&b,&a);
 			BN_lshift(&a,&a,i);
 			BN_add_word(&a,i);
-			}
-		else
+		} else
 			BN_bntest_rand(&b,50+3*(i-num1),0,0);
 		a.neg=rand_neg();
 		b.neg=rand_neg();
 		BN_div(&d,&c,&a,&b,ctx);
-		if (bp != NULL)
-			{
-			if (!results)
-				{
+		if (bp != NULL) {
+			if (!results) {
 				BN_print(bp,&a);
 				BIO_puts(bp," / ");
 				BN_print(bp,&b);
 				BIO_puts(bp," - ");
-				}
+			}
 			BN_print(bp,&d);
 			BIO_puts(bp,"\n");
 
-			if (!results)
-				{
+			if (!results) {
 				BN_print(bp,&a);
 				BIO_puts(bp," % ");
 				BN_print(bp,&b);
 				BIO_puts(bp," - ");
-				}
+			}
 			BN_print(bp,&c);
 			BIO_puts(bp,"\n");
-			}
+		}
 		BN_mul(&e,&d,&b,ctx);
 		BN_add(&d,&e,&c);
 		BN_sub(&d,&d,&a);
-		if(!BN_is_zero(&d))
-		    {
+		if(!BN_is_zero(&d)) {
 		    fprintf(stderr,"Division test failed!\n");
-		    return 0;
-		    }
+		    rc = 0;
+		    break;
 		}
+	}
 	BN_free(&a);
 	BN_free(&b);
 	BN_free(&c);
 	BN_free(&d);
 	BN_free(&e);
-	return(1);
-	}
+	return(rc);
+}
 
-static void print_word(BIO *bp,BN_ULONG w)
-	{
+static void
+print_word(BIO *bp,BN_ULONG w)
+{
 #ifdef SIXTY_FOUR_BIT
-	if (sizeof(w) > sizeof(unsigned long))
-		{
-		unsigned long	h=(unsigned long)(w>>32),
-				l=(unsigned long)(w);
+	if (sizeof(w) > sizeof(unsigned long)) {
+		unsigned long h=(unsigned long)(w>>32), l=(unsigned long)(w);
 
-		if (h)	BIO_printf(bp,"%lX%08lX",h,l);
-		else	BIO_printf(bp,"%lX",l);
+		if (h)
+			BIO_printf(bp,"%lX%08lX",h,l);
+		else
+			BIO_printf(bp,"%lX",l);
 		return;
-		}
+	}
 #endif
 	BIO_printf(bp,BN_HEX_FMT1,w);
-	}
+}
 
-int test_div_word(BIO *bp)
-	{
+int
+test_div_word(BIO *bp)
+{
 	BIGNUM   a,b;
 	BN_ULONG r,s;
 	int i;
+	int rc = 1;
 
 	BN_init(&a);
 	BN_init(&b);
 
-	for (i=0; i<num0; i++)
-		{
+	for (i=0; i<num0; i++) {
 		do {
 			BN_bntest_rand(&a,512,-1,0);
 			BN_bntest_rand(&b,BN_BITS2,-1,0);
@@ -508,47 +500,46 @@ int test_div_word(BIO *bp)
 		BN_copy(&b, &a);
 		r = BN_div_word(&b, s);
 
-		if (bp != NULL)
-			{
-			if (!results)
-				{
+		if (bp != NULL) {
+			if (!results) {
 				BN_print(bp,&a);
 				BIO_puts(bp," / ");
 				print_word(bp,s);
 				BIO_puts(bp," - ");
-				}
+			}
 			BN_print(bp,&b);
 			BIO_puts(bp,"\n");
 
-			if (!results)
-				{
+			if (!results) {
 				BN_print(bp,&a);
 				BIO_puts(bp," % ");
 				print_word(bp,s);
 				BIO_puts(bp," - ");
-				}
+			}
 			print_word(bp,r);
 			BIO_puts(bp,"\n");
-			}
+		}
 		BN_mul_word(&b,s);
 		BN_add_word(&b,r);
 		BN_sub(&b,&a,&b);
-		if(!BN_is_zero(&b))
-		    {
+		if(!BN_is_zero(&b)) {
 		    fprintf(stderr,"Division (word) test failed!\n");
-		    return 0;
-		    }
+		    rc = 0;
+		    break;
 		}
+	}
 	BN_free(&a);
 	BN_free(&b);
-	return(1);
-	}
+	return(rc);
+}
 
-int test_div_recp(BIO *bp, BN_CTX *ctx)
-	{
+int
+test_div_recp(BIO *bp, BN_CTX *ctx)
+{
 	BIGNUM a,b,c,d,e;
 	BN_RECP_CTX recp;
 	int i;
+	int rc = 1;
 
 	BN_RECP_CTX_init(&recp);
 	BN_init(&a);
@@ -557,70 +548,66 @@ int test_div_recp(BIO *bp, BN_CTX *ctx)
 	BN_init(&d);
 	BN_init(&e);
 
-	for (i=0; i<num0+num1; i++)
-		{
-		if (i < num1)
-			{
+	for (i=0; i<num0+num1; i++) {
+		if (i < num1) {
 			BN_bntest_rand(&a,400,0,0);
 			BN_copy(&b,&a);
 			BN_lshift(&a,&a,i);
 			BN_add_word(&a,i);
-			}
-		else
+		} else
 			BN_bntest_rand(&b,50+3*(i-num1),0,0);
 		a.neg=rand_neg();
 		b.neg=rand_neg();
 		BN_RECP_CTX_set(&recp,&b,ctx);
 		BN_div_recp(&d,&c,&a,&recp,ctx);
-		if (bp != NULL)
-			{
-			if (!results)
-				{
+		if (bp != NULL) {
+			if (!results) {
 				BN_print(bp,&a);
 				BIO_puts(bp," / ");
 				BN_print(bp,&b);
 				BIO_puts(bp," - ");
-				}
+			}
 			BN_print(bp,&d);
 			BIO_puts(bp,"\n");
 
-			if (!results)
-				{
+			if (!results) {
 				BN_print(bp,&a);
 				BIO_puts(bp," % ");
 				BN_print(bp,&b);
 				BIO_puts(bp," - ");
-				}
+			}
 			BN_print(bp,&c);
 			BIO_puts(bp,"\n");
-			}
+		}
 		BN_mul(&e,&d,&b,ctx);
 		BN_add(&d,&e,&c);
 		BN_sub(&d,&d,&a);
-		if(!BN_is_zero(&d))
-		    {
+		if(!BN_is_zero(&d)) {
 		    fprintf(stderr,"Reciprocal division test failed!\n");
 		    fprintf(stderr,"a=");
 		    BN_print_fp(stderr,&a);
 		    fprintf(stderr,"\nb=");
 		    BN_print_fp(stderr,&b);
 		    fprintf(stderr,"\n");
-		    return 0;
-		    }
+		    rc = 0;
+		    break;
 		}
+	}
 	BN_free(&a);
 	BN_free(&b);
 	BN_free(&c);
 	BN_free(&d);
 	BN_free(&e);
 	BN_RECP_CTX_free(&recp);
-	return(1);
-	}
+	return(rc);
+}
 
-int test_mul(BIO *bp)
-	{
+int
+test_mul(BIO *bp)
+{
 	BIGNUM a,b,c,d,e;
 	int i;
+	int rc = 1;
 	BN_CTX *ctx;
 
 	ctx = BN_CTX_new();
@@ -632,96 +619,96 @@ int test_mul(BIO *bp)
 	BN_init(&d);
 	BN_init(&e);
 
-	for (i=0; i<num0+num1; i++)
-		{
-		if (i <= num1)
-			{
+	for (i=0; i<num0+num1; i++) {
+		if (i <= num1) {
 			BN_bntest_rand(&a,100,0,0);
 			BN_bntest_rand(&b,100,0,0);
-			}
-		else
+		} else
 			BN_bntest_rand(&b,i-num1,0,0);
 		a.neg=rand_neg();
 		b.neg=rand_neg();
 		BN_mul(&c,&a,&b,ctx);
-		if (bp != NULL)
-			{
-			if (!results)
-				{
+		if (bp != NULL) {
+			if (!results) {
 				BN_print(bp,&a);
 				BIO_puts(bp," * ");
 				BN_print(bp,&b);
 				BIO_puts(bp," - ");
-				}
+			}
 			BN_print(bp,&c);
 			BIO_puts(bp,"\n");
-			}
+		}
 		BN_div(&d,&e,&c,&a,ctx);
 		BN_sub(&d,&d,&b);
-		if(!BN_is_zero(&d) || !BN_is_zero(&e))
-		    {
+		if(!BN_is_zero(&d) || !BN_is_zero(&e)) {
 		    fprintf(stderr,"Multiplication test failed!\n");
-		    return 0;
-		    }
+		    rc = 0;
+		    break;
 		}
+	}
 	BN_free(&a);
 	BN_free(&b);
 	BN_free(&c);
 	BN_free(&d);
 	BN_free(&e);
 	BN_CTX_free(ctx);
-	return(1);
-	}
+	return(rc);
+}
 
-int test_sqr(BIO *bp, BN_CTX *ctx)
-	{
+int
+test_sqr(BIO *bp, BN_CTX *ctx)
+{
 	BIGNUM a,c,d,e;
 	int i;
+	int rc = 1;
 
 	BN_init(&a);
 	BN_init(&c);
 	BN_init(&d);
 	BN_init(&e);
 
-	for (i=0; i<num0; i++)
-		{
+	for (i=0; i<num0; i++) {
 		BN_bntest_rand(&a,40+i*10,0,0);
 		a.neg=rand_neg();
 		BN_sqr(&c,&a,ctx);
-		if (bp != NULL)
-			{
-			if (!results)
-				{
+		if (bp != NULL) {
+			if (!results) {
 				BN_print(bp,&a);
 				BIO_puts(bp," * ");
 				BN_print(bp,&a);
 				BIO_puts(bp," - ");
-				}
+			}
 			BN_print(bp,&c);
 			BIO_puts(bp,"\n");
-			}
+		}
 		BN_div(&d,&e,&c,&a,ctx);
 		BN_sub(&d,&d,&a);
-		if(!BN_is_zero(&d) || !BN_is_zero(&e))
-		    {
+		if(!BN_is_zero(&d) || !BN_is_zero(&e)) {
 		    fprintf(stderr,"Square test failed!\n");
-		    return 0;
-		    }
+		    rc = 0;
+		    break;
 		}
+	}
 	BN_free(&a);
 	BN_free(&c);
 	BN_free(&d);
 	BN_free(&e);
-	return(1);
-	}
+	return(rc);
+}
 
-int test_mont(BIO *bp, BN_CTX *ctx)
-	{
+int
+test_mont(BIO *bp, BN_CTX *ctx)
+{
 	BIGNUM a,b,c,d,A,B;
 	BIGNUM n;
 	int i;
+	int rc = 1;
 	BN_MONT_CTX *mont;
 
+	mont=BN_MONT_CTX_new();
+	if (mont == NULL)
+		return 0;
+
 	BN_init(&a);
 	BN_init(&b);
 	BN_init(&c);
@@ -730,14 +717,9 @@ int test_mont(BIO *bp, BN_CTX *ctx)
 	BN_init(&B);
 	BN_init(&n);
 
-	mont=BN_MONT_CTX_new();
-	if (mont == NULL)
-		return 0;
-
 	BN_bntest_rand(&a,100,0,0); /**/
 	BN_bntest_rand(&b,100,0,0); /**/
-	for (i=0; i<num2; i++)
-		{
+	for (i=0; i<num2; i++) {
 		int bits = (200*(i+1))/num2;
 
 		if (bits == 0)
@@ -753,28 +735,26 @@ int test_mont(BIO *bp, BN_CTX *ctx)
 
 		BN_mod_mul_montgomery(&c,&A,&B,mont,ctx);/**/
 		BN_from_montgomery(&A,&c,mont,ctx);/**/
-		if (bp != NULL)
-			{
-			if (!results)
-				{
+		if (bp != NULL) {
+			if (!results) {
 				BN_print(bp,&a);
 				BIO_puts(bp," * ");
 				BN_print(bp,&b);
 				BIO_puts(bp," % ");
 				BN_print(bp,&(mont->N));
 				BIO_puts(bp," - ");
-				}
+			}
 			BN_print(bp,&A);
 			BIO_puts(bp,"\n");
-			}
+		}
 		BN_mod_mul(&d,&a,&b,&n,ctx);
 		BN_sub(&d,&d,&A);
-		if(!BN_is_zero(&d))
-		    {
+		if(!BN_is_zero(&d)) {
 		    fprintf(stderr,"Montgomery multiplication test failed!\n");
-		    return 0;
-		    }
+		    rc = 0;
+		    break;
 		}
+	}
 	BN_MONT_CTX_free(mont);
 	BN_free(&a);
 	BN_free(&b);
@@ -783,13 +763,15 @@ int test_mont(BIO *bp, BN_CTX *ctx)
 	BN_free(&A);
 	BN_free(&B);
 	BN_free(&n);
-	return(1);
-	}
+	return(rc);
+}
 
-int test_mod(BIO *bp, BN_CTX *ctx)
-	{
+int
+test_mod(BIO *bp, BN_CTX *ctx)
+{
 	BIGNUM *a,*b,*c,*d,*e;
 	int i;
+	int rc = 1;
 
 	a=BN_new();
 	b=BN_new();
@@ -798,44 +780,43 @@ int test_mod(BIO *bp, BN_CTX *ctx)
 	e=BN_new();
 
 	BN_bntest_rand(a,1024,0,0); /**/
-	for (i=0; i<num0; i++)
-		{
+	for (i=0; i<num0; i++) {
 		BN_bntest_rand(b,450+i*10,0,0); /**/
 		a->neg=rand_neg();
 		b->neg=rand_neg();
 		BN_mod(c,a,b,ctx);/**/
-		if (bp != NULL)
-			{
-			if (!results)
-				{
+		if (bp != NULL) {
+			if (!results) {
 				BN_print(bp,a);
 				BIO_puts(bp," % ");
 				BN_print(bp,b);
 				BIO_puts(bp," - ");
-				}
+			}
 			BN_print(bp,c);
 			BIO_puts(bp,"\n");
-			}
+		}
 		BN_div(d,e,a,b,ctx);
 		BN_sub(e,e,c);
-		if(!BN_is_zero(e))
-		    {
+		if(!BN_is_zero(e)) {
 		    fprintf(stderr,"Modulo test failed!\n");
-		    return 0;
-		    }
+		    rc = 0;
+		    break;
 		}
+	}
 	BN_free(a);
 	BN_free(b);
 	BN_free(c);
 	BN_free(d);
 	BN_free(e);
-	return(1);
-	}
+	return(rc);
+}
 
-int test_mod_mul(BIO *bp, BN_CTX *ctx)
-	{
+int
+test_mod_mul(BIO *bp, BN_CTX *ctx)
+{
 	BIGNUM *a,*b,*c,*d,*e;
 	int i,j;
+	int rc = 1;
 
 	a=BN_new();
 	b=BN_new();
@@ -844,69 +825,67 @@ int test_mod_mul(BIO *bp, BN_CTX *ctx)
 	e=BN_new();
 
 	for (j=0; j<3; j++) {
-	BN_bntest_rand(c,1024,0,0); /**/
-	for (i=0; i<num0; i++)
-		{
-		BN_bntest_rand(a,475+i*10,0,0); /**/
-		BN_bntest_rand(b,425+i*11,0,0); /**/
-		a->neg=rand_neg();
-		b->neg=rand_neg();
-		if (!BN_mod_mul(e,a,b,c,ctx))
-			{
-			unsigned long l;
-
-			while ((l=ERR_get_error()))
-				fprintf(stderr,"ERROR:%s\n",
-					ERR_error_string(l,NULL));
-			exit(1);
+		BN_bntest_rand(c,1024,0,0); /**/
+		for (i=0; i<num0; i++) {
+			BN_bntest_rand(a,475+i*10,0,0); /**/
+			BN_bntest_rand(b,425+i*11,0,0); /**/
+			a->neg=rand_neg();
+			b->neg=rand_neg();
+			if (!BN_mod_mul(e,a,b,c,ctx)) {
+				unsigned long l;
+
+				while ((l=ERR_get_error()))
+					fprintf(stderr,"ERROR:%s\n",
+					    ERR_error_string(l,NULL));
+				exit(1);
 			}
-		if (bp != NULL)
-			{
-			if (!results)
-				{
-				BN_print(bp,a);
-				BIO_puts(bp," * ");
-				BN_print(bp,b);
-				BIO_puts(bp," % ");
-				BN_print(bp,c);
-				if ((a->neg ^ b->neg) && !BN_is_zero(e))
-					{
-					/* If  (a*b) % c  is negative,  c  must be added
-					 * in order to obtain the normalized remainder
-					 * (new with OpenSSL 0.9.7, previous versions of
-					 * BN_mod_mul could generate negative results)
-					 */
-					BIO_puts(bp," + ");
+			if (bp != NULL) {
+				if (!results) {
+					BN_print(bp,a);
+					BIO_puts(bp," * ");
+					BN_print(bp,b);
+					BIO_puts(bp," % ");
 					BN_print(bp,c);
+					if ((a->neg ^ b->neg) && !BN_is_zero(e)) {
+						/* If  (a*b) % c  is negative,  c  must be added
+						 * in order to obtain the normalized remainder
+						 * (new with OpenSSL 0.9.7, previous versions of
+						 * BN_mod_mul could generate negative results)
+						 */
+						BIO_puts(bp," + ");
+						BN_print(bp,c);
 					}
-				BIO_puts(bp," - ");
+					BIO_puts(bp," - ");
 				}
-			BN_print(bp,e);
-			BIO_puts(bp,"\n");
+				BN_print(bp,e);
+				BIO_puts(bp,"\n");
+			}
+			BN_mul(d,a,b,ctx);
+			BN_sub(d,d,e);
+			BN_div(a,b,d,c,ctx);
+			if(!BN_is_zero(b)) {
+			    fprintf(stderr,"Modulo multiply test failed!\n");
+			    ERR_print_errors_fp(stderr);
+			    rc = 0;
+			    goto done;
 			}
-		BN_mul(d,a,b,ctx);
-		BN_sub(d,d,e);
-		BN_div(a,b,d,c,ctx);
-		if(!BN_is_zero(b))
-		    {
-		    fprintf(stderr,"Modulo multiply test failed!\n");
-		    ERR_print_errors_fp(stderr);
-		    return 0;
-		    }
 		}
 	}
+done:
 	BN_free(a);
 	BN_free(b);
 	BN_free(c);
 	BN_free(d);
 	BN_free(e);
-	return(1);
-	}
+	return(rc);
+}
 
-int test_mod_exp(BIO *bp, BN_CTX *ctx)
-	{
+int
+test_mod_exp(BIO *bp, BN_CTX *ctx)
+{
 	BIGNUM *a,*b,*c,*d,*e;
 	int i;
+	int rc = 1;
 
 	a=BN_new();
 	b=BN_new();
@@ -915,49 +894,50 @@ int test_mod_exp(BIO *bp, BN_CTX *ctx)
 	e=BN_new();
 
 	BN_bntest_rand(c,30,0,1); /* must be odd for montgomery */
-	for (i=0; i<num2; i++)
-		{
+	for (i=0; i<num2; i++) {
 		BN_bntest_rand(a,20+i*5,0,0); /**/
 		BN_bntest_rand(b,2+i,0,0); /**/
 
-		if (!BN_mod_exp(d,a,b,c,ctx))
-			return(0);
+		if (!BN_mod_exp(d,a,b,c,ctx)) {
+			rc = 0;
+			break;
+		}
 
-		if (bp != NULL)
-			{
-			if (!results)
-				{
+		if (bp != NULL) {
+			if (!results) {
 				BN_print(bp,a);
 				BIO_puts(bp," ^ ");
 				BN_print(bp,b);
 				BIO_puts(bp," % ");
 				BN_print(bp,c);
 				BIO_puts(bp," - ");
-				}
+			}
 			BN_print(bp,d);
 			BIO_puts(bp,"\n");
-			}
+		}
 		BN_exp(e,a,b,ctx);
 		BN_sub(e,e,d);
 		BN_div(a,b,e,c,ctx);
-		if(!BN_is_zero(b))
-		    {
+		if(!BN_is_zero(b)) {
 		    fprintf(stderr,"Modulo exponentiation test failed!\n");
-		    return 0;
-		    }
+		    rc = 0;
+		    break;
 		}
+	}
 	BN_free(a);
 	BN_free(b);
 	BN_free(c);
 	BN_free(d);
 	BN_free(e);
-	return(1);
-	}
+	return(rc);
+}
 
-int test_mod_exp_mont_consttime(BIO *bp, BN_CTX *ctx)
-	{
+int
+test_mod_exp_mont_consttime(BIO *bp, BN_CTX *ctx)
+{
 	BIGNUM *a,*b,*c,*d,*e;
 	int i;
+	int rc = 1;
 
 	a=BN_new();
 	b=BN_new();
@@ -966,49 +946,50 @@ int test_mod_exp_mont_consttime(BIO *bp, BN_CTX *ctx)
 	e=BN_new();
 
 	BN_bntest_rand(c,30,0,1); /* must be odd for montgomery */
-	for (i=0; i<num2; i++)
-		{
+	for (i=0; i<num2; i++) {
 		BN_bntest_rand(a,20+i*5,0,0); /**/
 		BN_bntest_rand(b,2+i,0,0); /**/
 
-		if (!BN_mod_exp_mont_consttime(d,a,b,c,ctx,NULL))
-			return(00);
+		if (!BN_mod_exp_mont_consttime(d,a,b,c,ctx,NULL)) {
+			rc = 0;
+			break;
+		}
 
-		if (bp != NULL)
-			{
-			if (!results)
-				{
+		if (bp != NULL) {
+			if (!results) {
 				BN_print(bp,a);
 				BIO_puts(bp," ^ ");
 				BN_print(bp,b);
 				BIO_puts(bp," % ");
 				BN_print(bp,c);
 				BIO_puts(bp," - ");
-				}
+			}
 			BN_print(bp,d);
 			BIO_puts(bp,"\n");
-			}
+		}
 		BN_exp(e,a,b,ctx);
 		BN_sub(e,e,d);
 		BN_div(a,b,e,c,ctx);
-		if(!BN_is_zero(b))
-		    {
+		if(!BN_is_zero(b)) {
 		    fprintf(stderr,"Modulo exponentiation test failed!\n");
-		    return 0;
-		    }
+		    rc = 0;
+		    break;
 		}
+	}
 	BN_free(a);
 	BN_free(b);
 	BN_free(c);
 	BN_free(d);
 	BN_free(e);
-	return(1);
-	}
+	return(rc);
+}
 
-int test_exp(BIO *bp, BN_CTX *ctx)
-	{
+int
+test_exp(BIO *bp, BN_CTX *ctx)
+{
 	BIGNUM *a,*b,*d,*e,*one;
 	int i;
+	int rc = 1;
 
 	a=BN_new();
 	b=BN_new();
@@ -1017,46 +998,47 @@ int test_exp(BIO *bp, BN_CTX *ctx)
 	one=BN_new();
 	BN_one(one);
 
-	for (i=0; i<num2; i++)
-		{
+	for (i=0; i<num2; i++) {
 		BN_bntest_rand(a,20+i*5,0,0); /**/
 		BN_bntest_rand(b,2+i,0,0); /**/
 
-		if (BN_exp(d,a,b,ctx) <= 0)
-			return(0);
+		if (BN_exp(d,a,b,ctx) <= 0) {
+			rc = 0;
+			break;
+		}
 
-		if (bp != NULL)
-			{
-			if (!results)
-				{
+		if (bp != NULL) {
+			if (!results) {
 				BN_print(bp,a);
 				BIO_puts(bp," ^ ");
 				BN_print(bp,b);
 				BIO_puts(bp," - ");
-				}
+			}
 			BN_print(bp,d);
 			BIO_puts(bp,"\n");
-			}
+		}
 		BN_one(e);
 		for( ; !BN_is_zero(b) ; BN_sub(b,b,one))
 		    BN_mul(e,e,a,ctx);
 		BN_sub(e,e,d);
-		if(!BN_is_zero(e))
-		    {
+		if(!BN_is_zero(e)) {
 		    fprintf(stderr,"Exponentiation test failed!\n");
-		    return 0;
-		    }
+		    rc = 0;
+		    break;
 		}
+	}
 	BN_free(a);
 	BN_free(b);
 	BN_free(d);
 	BN_free(e);
 	BN_free(one);
-	return(1);
-	}
+	return(rc);
+}
+
 #ifndef OPENSSL_NO_EC2M
-int test_gf2m_add(BIO *bp)
-	{
+int
+test_gf2m_add(BIO *bp)
+{
 	BIGNUM a,b,c;
 	int i, ret = 0;
 
@@ -1064,51 +1046,47 @@ int test_gf2m_add(BIO *bp)
 	BN_init(&b);
 	BN_init(&c);
 
-	for (i=0; i<num0; i++)
-		{
+	for (i=0; i<num0; i++) {
 		BN_rand(&a,512,0,0);
 		BN_copy(&b, BN_value_one());
 		a.neg=rand_neg();
 		b.neg=rand_neg();
 		BN_GF2m_add(&c,&a,&b);
 #if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
-		if (bp != NULL)
-			{
-			if (!results)
-				{
+		if (bp != NULL) {
+			if (!results) {
 				BN_print(bp,&a);
 				BIO_puts(bp," ^ ");
 				BN_print(bp,&b);
 				BIO_puts(bp," = ");
-				}
+			}
 			BN_print(bp,&c);
 			BIO_puts(bp,"\n");
-			}
+		}
 #endif
 		/* Test that two added values have the correct parity. */
-		if((BN_is_odd(&a) && BN_is_odd(&c)) || (!BN_is_odd(&a) && !BN_is_odd(&c)))
-			{
+		if((BN_is_odd(&a) && BN_is_odd(&c)) || (!BN_is_odd(&a) && !BN_is_odd(&c))) {
 		    fprintf(stderr,"GF(2^m) addition test (a) failed!\n");
 			goto err;
-			}
+		}
 		BN_GF2m_add(&c,&c,&c);
 		/* Test that c + c = 0. */
-		if(!BN_is_zero(&c))
-		    {
+		if(!BN_is_zero(&c)) {
 		    fprintf(stderr,"GF(2^m) addition test (b) failed!\n");
 			goto err;
-		    }
 		}
+	}
 	ret = 1;
-  err:
+err:
 	BN_free(&a);
 	BN_free(&b);
 	BN_free(&c);
 	return ret;
-	}
+}
 
-int test_gf2m_mod(BIO *bp)
-	{
+int
+test_gf2m_mod(BIO *bp)
+{
 	BIGNUM *a,*b[2],*c,*d,*e;
 	int i, j, ret = 0;
 	int p0[] = {163,7,6,3,0,-1};
@@ -1124,38 +1102,33 @@ int test_gf2m_mod(BIO *bp)
 	BN_GF2m_arr2poly(p0, b[0]);
 	BN_GF2m_arr2poly(p1, b[1]);
 
-	for (i=0; i<num0; i++)
-		{
+	for (i=0; i<num0; i++) {
 		BN_bntest_rand(a, 1024, 0, 0);
-		for (j=0; j < 2; j++)
-			{
+		for (j=0; j < 2; j++) {
 			BN_GF2m_mod(c, a, b[j]);
 #if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
-			if (bp != NULL)
-				{
-				if (!results)
-					{
+			if (bp != NULL) {
+				if (!results) {
 					BN_print(bp,a);
 					BIO_puts(bp," % ");
 					BN_print(bp,b[j]);
 					BIO_puts(bp," - ");
 					BN_print(bp,c);
 					BIO_puts(bp,"\n");
-					}
 				}
+			}
 #endif
 			BN_GF2m_add(d, a, c);
 			BN_GF2m_mod(e, d, b[j]);
 			/* Test that a + (a mod p) mod p == 0. */
-			if(!BN_is_zero(e))
-				{
+			if(!BN_is_zero(e)) {
 				fprintf(stderr,"GF(2^m) modulo test failed!\n");
 				goto err;
-				}
 			}
 		}
+	}
 	ret = 1;
-  err:
+err:
 	BN_free(a);
 	BN_free(b[0]);
 	BN_free(b[1]);
@@ -1163,10 +1136,11 @@ int test_gf2m_mod(BIO *bp)
 	BN_free(d);
 	BN_free(e);
 	return ret;
-	}
+}
 
-int test_gf2m_mod_mul(BIO *bp,BN_CTX *ctx)
-	{
+int
+test_gf2m_mod_mul(BIO *bp,BN_CTX *ctx)
+{
 	BIGNUM *a,*b[2],*c,*d,*e,*f,*g,*h;
 	int i, j, ret = 0;
 	int p0[] = {163,7,6,3,0,-1};
@@ -1185,19 +1159,15 @@ int test_gf2m_mod_mul(BIO *bp,BN_CTX *ctx)
 	BN_GF2m_arr2poly(p0, b[0]);
 	BN_GF2m_arr2poly(p1, b[1]);
 
-	for (i=0; i<num0; i++)
-		{
+	for (i=0; i<num0; i++) {
 		BN_bntest_rand(a, 1024, 0, 0);
 		BN_bntest_rand(c, 1024, 0, 0);
 		BN_bntest_rand(d, 1024, 0, 0);
-		for (j=0; j < 2; j++)
-			{
+		for (j=0; j < 2; j++) {
 			BN_GF2m_mod_mul(e, a, c, b[j], ctx);
 #if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
-			if (bp != NULL)
-				{
-				if (!results)
-					{
+			if (bp != NULL) {
+				if (!results) {
 					BN_print(bp,a);
 					BIO_puts(bp," * ");
 					BN_print(bp,c);
@@ -1206,8 +1176,8 @@ int test_gf2m_mod_mul(BIO *bp,BN_CTX *ctx)
 					BIO_puts(bp," - ");
 					BN_print(bp,e);
 					BIO_puts(bp,"\n");
-					}
 				}
+			}
 #endif
 			BN_GF2m_add(f, a, d);
 			BN_GF2m_mod_mul(g, f, c, b[j], ctx);
@@ -1215,15 +1185,14 @@ int test_gf2m_mod_mul(BIO *bp,BN_CTX *ctx)
 			BN_GF2m_add(f, e, g);
 			BN_GF2m_add(f, f, h);
 			/* Test that (a+d)*c = a*c + d*c. */
-			if(!BN_is_zero(f))
-				{
+			if(!BN_is_zero(f)) {
 				fprintf(stderr,"GF(2^m) modular multiplication test failed!\n");
 				goto err;
-				}
 			}
 		}
+	}
 	ret = 1;
-  err:
+err:
 	BN_free(a);
 	BN_free(b[0]);
 	BN_free(b[1]);
@@ -1234,10 +1203,11 @@ int test_gf2m_mod_mul(BIO *bp,BN_CTX *ctx)
 	BN_free(g);
 	BN_free(h);
 	return ret;
-	}
+}
 
-int test_gf2m_mod_sqr(BIO *bp,BN_CTX *ctx)
-	{
+int
+test_gf2m_mod_sqr(BIO *bp,BN_CTX *ctx)
+{
 	BIGNUM *a,*b[2],*c,*d;
 	int i, j, ret = 0;
 	int p0[] = {163,7,6,3,0,-1};
@@ -1252,19 +1222,15 @@ int test_gf2m_mod_sqr(BIO *bp,BN_CTX *ctx)
 	BN_GF2m_arr2poly(p0, b[0]);
 	BN_GF2m_arr2poly(p1, b[1]);
 
-	for (i=0; i<num0; i++)
-		{
+	for (i=0; i<num0; i++) {
 		BN_bntest_rand(a, 1024, 0, 0);
-		for (j=0; j < 2; j++)
-			{
+		for (j=0; j < 2; j++) {
 			BN_GF2m_mod_sqr(c, a, b[j], ctx);
 			BN_copy(d, a);
 			BN_GF2m_mod_mul(d, a, d, b[j], ctx);
 #if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
-			if (bp != NULL)
-				{
-				if (!results)
-					{
+			if (bp != NULL) {
+				if (!results) {
 					BN_print(bp,a);
 					BIO_puts(bp," ^ 2 % ");
 					BN_print(bp,b[j]);
@@ -1273,30 +1239,30 @@ int test_gf2m_mod_sqr(BIO *bp,BN_CTX *ctx)
 					BIO_puts(bp,"; a * a = ");
 					BN_print(bp,d);
 					BIO_puts(bp,"\n");
-					}
 				}
+			}
 #endif
 			BN_GF2m_add(d, c, d);
 			/* Test that a*a = a^2. */
-			if(!BN_is_zero(d))
-				{
+			if(!BN_is_zero(d)) {
 				fprintf(stderr,"GF(2^m) modular squaring test failed!\n");
 				goto err;
-				}
 			}
 		}
+	}
 	ret = 1;
-  err:
+err:
 	BN_free(a);
 	BN_free(b[0]);
 	BN_free(b[1]);
 	BN_free(c);
 	BN_free(d);
 	return ret;
-	}
+}
 
-int test_gf2m_mod_inv(BIO *bp,BN_CTX *ctx)
-	{
+int
+test_gf2m_mod_inv(BIO *bp,BN_CTX *ctx)
+{
 	BIGNUM *a,*b[2],*c,*d;
 	int i, j, ret = 0;
 	int p0[] = {163,7,6,3,0,-1};
@@ -1311,47 +1277,43 @@ int test_gf2m_mod_inv(BIO *bp,BN_CTX *ctx)
 	BN_GF2m_arr2poly(p0, b[0]);
 	BN_GF2m_arr2poly(p1, b[1]);
 
-	for (i=0; i<num0; i++)
-		{
+	for (i=0; i<num0; i++) {
 		BN_bntest_rand(a, 512, 0, 0); 
-		for (j=0; j < 2; j++)
-			{
+		for (j=0; j < 2; j++) {
 			BN_GF2m_mod_inv(c, a, b[j], ctx);
 			BN_GF2m_mod_mul(d, a, c, b[j], ctx);
 #if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
-			if (bp != NULL)
-				{
-				if (!results)
-					{
+			if (bp != NULL) {
+				if (!results) {
 					BN_print(bp,a);
 					BIO_puts(bp, " * ");
 					BN_print(bp,c);
 					BIO_puts(bp," - 1 % ");
 					BN_print(bp,b[j]);
 					BIO_puts(bp,"\n");
-					}
 				}
+			}
 #endif
 			/* Test that ((1/a)*a) = 1. */
-			if(!BN_is_one(d))
-				{
+			if(!BN_is_one(d)) {
 				fprintf(stderr,"GF(2^m) modular inversion test failed!\n");
 				goto err;
-				}
 			}
 		}
+	}
 	ret = 1;
-  err:
+err:
 	BN_free(a);
 	BN_free(b[0]);
 	BN_free(b[1]);
 	BN_free(c);
 	BN_free(d);
 	return ret;
-	}
+}
 
-int test_gf2m_mod_div(BIO *bp,BN_CTX *ctx)
-	{
+int
+test_gf2m_mod_div(BIO *bp,BN_CTX *ctx)
+{
 	BIGNUM *a,*b[2],*c,*d,*e,*f;
 	int i, j, ret = 0;
 	int p0[] = {163,7,6,3,0,-1};
@@ -1368,20 +1330,16 @@ int test_gf2m_mod_div(BIO *bp,BN_CTX *ctx)
 	BN_GF2m_arr2poly(p0, b[0]);
 	BN_GF2m_arr2poly(p1, b[1]);
 
-	for (i=0; i<num0; i++)
-		{
+	for (i=0; i<num0; i++) {
 		BN_bntest_rand(a, 512, 0, 0); 
 		BN_bntest_rand(c, 512, 0, 0);
-		for (j=0; j < 2; j++)
-			{
+		for (j=0; j < 2; j++) {
 			BN_GF2m_mod_div(d, a, c, b[j], ctx);
 			BN_GF2m_mod_mul(e, d, c, b[j], ctx);
 			BN_GF2m_mod_div(f, a, e, b[j], ctx);
 #if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
-			if (bp != NULL)
-				{
-				if (!results)
-					{
+			if (bp != NULL) {
+				if (!results) {
 					BN_print(bp,a);
 					BIO_puts(bp, " = ");
 					BN_print(bp,c);
@@ -1390,19 +1348,18 @@ int test_gf2m_mod_div(BIO *bp,BN_CTX *ctx)
 					BIO_puts(bp, " % ");
 					BN_print(bp,b[j]);
 					BIO_puts(bp,"\n");
-					}
 				}
+			}
 #endif
 			/* Test that ((a/c)*c)/a = 1. */
-			if(!BN_is_one(f))
-				{
+			if(!BN_is_one(f)) {
 				fprintf(stderr,"GF(2^m) modular division test failed!\n");
 				goto err;
-				}
 			}
 		}
+	}
 	ret = 1;
-  err:
+err:
 	BN_free(a);
 	BN_free(b[0]);
 	BN_free(b[1]);
@@ -1411,10 +1368,11 @@ int test_gf2m_mod_div(BIO *bp,BN_CTX *ctx)
 	BN_free(e);
 	BN_free(f);
 	return ret;
-	}
+}
 
-int test_gf2m_mod_exp(BIO *bp,BN_CTX *ctx)
-	{
+int
+test_gf2m_mod_exp(BIO *bp,BN_CTX *ctx)
+{
 	BIGNUM *a,*b[2],*c,*d,*e,*f;
 	int i, j, ret = 0;
 	int p0[] = {163,7,6,3,0,-1};
@@ -1431,23 +1389,19 @@ int test_gf2m_mod_exp(BIO *bp,BN_CTX *ctx)
 	BN_GF2m_arr2poly(p0, b[0]);
 	BN_GF2m_arr2poly(p1, b[1]);
 
-	for (i=0; i<num0; i++)
-		{
+	for (i=0; i<num0; i++) {
 		BN_bntest_rand(a, 512, 0, 0);
 		BN_bntest_rand(c, 512, 0, 0);
 		BN_bntest_rand(d, 512, 0, 0);
-		for (j=0; j < 2; j++)
-			{
+		for (j=0; j < 2; j++) {
 			BN_GF2m_mod_exp(e, a, c, b[j], ctx);
 			BN_GF2m_mod_exp(f, a, d, b[j], ctx);
 			BN_GF2m_mod_mul(e, e, f, b[j], ctx);
 			BN_add(f, c, d);
 			BN_GF2m_mod_exp(f, a, f, b[j], ctx);
 #if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
-			if (bp != NULL)
-				{
-				if (!results)
-					{
+			if (bp != NULL) {
+				if (!results) {
 					BN_print(bp,a);
 					BIO_puts(bp, " ^ (");
 					BN_print(bp,c);
@@ -1460,20 +1414,19 @@ int test_gf2m_mod_exp(BIO *bp,BN_CTX *ctx)
 					BIO_puts(bp, " % ");
 					BN_print(bp,b[j]);
 					BIO_puts(bp,"\n");
-					}
 				}
+			}
 #endif
 			BN_GF2m_add(f, e, f);
 			/* Test that a^(c+d)=a^c*a^d. */
-			if(!BN_is_zero(f))
-				{
+			if(!BN_is_zero(f)) {
 				fprintf(stderr,"GF(2^m) modular exponentiation test failed!\n");
 				goto err;
-				}
 			}
 		}
+	}
 	ret = 1;
-  err:
+err:
 	BN_free(a);
 	BN_free(b[0]);
 	BN_free(b[1]);
@@ -1482,10 +1435,11 @@ int test_gf2m_mod_exp(BIO *bp,BN_CTX *ctx)
 	BN_free(e);
 	BN_free(f);
 	return ret;
-	}
+}
 
-int test_gf2m_mod_sqrt(BIO *bp,BN_CTX *ctx)
-	{
+int
+test_gf2m_mod_sqrt(BIO *bp,BN_CTX *ctx)
+{
 	BIGNUM *a,*b[2],*c,*d,*e,*f;
 	int i, j, ret = 0;
 	int p0[] = {163,7,6,3,0,-1};
@@ -1502,37 +1456,32 @@ int test_gf2m_mod_sqrt(BIO *bp,BN_CTX *ctx)
 	BN_GF2m_arr2poly(p0, b[0]);
 	BN_GF2m_arr2poly(p1, b[1]);
 
-	for (i=0; i<num0; i++)
-		{
+	for (i=0; i<num0; i++) {
 		BN_bntest_rand(a, 512, 0, 0);
-		for (j=0; j < 2; j++)
-			{
+		for (j=0; j < 2; j++) {
 			BN_GF2m_mod(c, a, b[j]);
 			BN_GF2m_mod_sqrt(d, a, b[j], ctx);
 			BN_GF2m_mod_sqr(e, d, b[j], ctx);
 #if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
-			if (bp != NULL)
-				{
-				if (!results)
-					{
+			if (bp != NULL) {
+				if (!results) {
 					BN_print(bp,d);
 					BIO_puts(bp, " ^ 2 - ");
 					BN_print(bp,a);
 					BIO_puts(bp,"\n");
-					}
 				}
+			}
 #endif
 			BN_GF2m_add(f, c, e);
 			/* Test that d^2 = a, where d = sqrt(a). */
-			if(!BN_is_zero(f))
-				{
+			if(!BN_is_zero(f)) {
 				fprintf(stderr,"GF(2^m) modular square root test failed!\n");
 				goto err;
-				}
 			}
 		}
+	}
 	ret = 1;
-  err:
+err:
 	BN_free(a);
 	BN_free(b[0]);
 	BN_free(b[1]);
@@ -1541,10 +1490,11 @@ int test_gf2m_mod_sqrt(BIO *bp,BN_CTX *ctx)
 	BN_free(e);
 	BN_free(f);
 	return ret;
-	}
+}
 
-int test_gf2m_mod_solve_quad(BIO *bp,BN_CTX *ctx)
-	{
+int
+test_gf2m_mod_solve_quad(BIO *bp,BN_CTX *ctx)
+{
 	BIGNUM *a,*b[2],*c,*d,*e;
 	int i, j, s = 0, t, ret = 0;
 	int p0[] = {163,7,6,3,0,-1};
@@ -1560,67 +1510,55 @@ int test_gf2m_mod_solve_quad(BIO *bp,BN_CTX *ctx)
 	BN_GF2m_arr2poly(p0, b[0]);
 	BN_GF2m_arr2poly(p1, b[1]);
 
-	for (i=0; i<num0; i++)
-		{
+	for (i=0; i<num0; i++) {
 		BN_bntest_rand(a, 512, 0, 0);
-		for (j=0; j < 2; j++)
-			{
+		for (j=0; j < 2; j++) {
 			t = BN_GF2m_mod_solve_quad(c, a, b[j], ctx);
-			if (t)
-				{
+			if (t) {
 				s++;
 				BN_GF2m_mod_sqr(d, c, b[j], ctx);
 				BN_GF2m_add(d, c, d);
 				BN_GF2m_mod(e, a, b[j]);
 #if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
-				if (bp != NULL)
-					{
-					if (!results)
-						{
+				if (bp != NULL) {
+					if (!results) {
 						BN_print(bp,c);
 						BIO_puts(bp, " is root of z^2 + z = ");
 						BN_print(bp,a);
 						BIO_puts(bp, " % ");
 						BN_print(bp,b[j]);
 						BIO_puts(bp, "\n");
-						}
 					}
+				}
 #endif
 				BN_GF2m_add(e, e, d);
 				/* Test that solution of quadratic c satisfies c^2 + c = a. */
-				if(!BN_is_zero(e))
-					{
+				if(!BN_is_zero(e)) {
 					fprintf(stderr,"GF(2^m) modular solve quadratic test failed!\n");
 					goto err;
-					}
-
 				}
-			else 
-				{
+			} else {
 #if 0 /* make test uses ouput in bc but bc can't handle GF(2^m) arithmetic */
-				if (bp != NULL)
-					{
-					if (!results)
-						{
+				if (bp != NULL) {
+					if (!results) {
 						BIO_puts(bp, "There are no roots of z^2 + z = ");
 						BN_print(bp,a);
 						BIO_puts(bp, " % ");
 						BN_print(bp,b[j]);
 						BIO_puts(bp, "\n");
-						}
 					}
-#endif
 				}
+#endif
 			}
 		}
-	if (s == 0)
-		{	
+	}
+	if (s == 0) {	
 		fprintf(stderr,"All %i tests of GF(2^m) modular solve quadratic resulted in no roots;\n", num0);
 		fprintf(stderr,"this is very unlikely and probably indicates an error.\n");
 		goto err;
-		}
+	}
 	ret = 1;
-  err:
+err:
 	BN_free(a);
 	BN_free(b[0]);
 	BN_free(b[1]);
@@ -1628,10 +1566,12 @@ int test_gf2m_mod_solve_quad(BIO *bp,BN_CTX *ctx)
 	BN_free(d);
 	BN_free(e);
 	return ret;
-	}
+}
 #endif
-static int genprime_cb(int p, int n, BN_GENCB *arg)
-	{
+
+static int
+genprime_cb(int p, int n, BN_GENCB *arg)
+{
 	char c='*';
 
 	if (p == 0) c='.';
@@ -1641,10 +1581,11 @@ static int genprime_cb(int p, int n, BN_GENCB *arg)
 	putc(c, stderr);
 	fflush(stderr);
 	return 1;
-	}
+}
 
-int test_kron(BIO *bp, BN_CTX *ctx)
-	{
+int
+test_kron(BIO *bp, BN_CTX *ctx)
+{
 	BN_GENCB cb;
 	BIGNUM *a,*b,*r,*t;
 	int i;
@@ -1672,8 +1613,7 @@ int test_kron(BIO *bp, BN_CTX *ctx)
 	b->neg = rand_neg();
 	putc('\n', stderr);
 
-	for (i = 0; i < num0; i++)
-		{
+	for (i = 0; i < num0; i++) {
 		if (!BN_bntest_rand(a, 512, 0, 0)) goto err;
 		a->neg = rand_neg();
 
@@ -1692,16 +1632,14 @@ int test_kron(BIO *bp, BN_CTX *ctx)
 			legendre = 1;
 		else if (BN_is_zero(r))
 			legendre = 0;
-		else
-			{
+		else {
 			if (!BN_add_word(r, 1)) goto err;
-			if (0 != BN_ucmp(r, b))
-				{
+			if (0 != BN_ucmp(r, b)) {
 				fprintf(stderr, "Legendre symbol computation failed\n");
 				goto err;
-				}
-			legendre = -1;
 			}
+			legendre = -1;
+		}
 		
 		kronecker = BN_kronecker(a, b, ctx);
 		if (kronecker < -1) goto err;
@@ -1709,33 +1647,33 @@ int test_kron(BIO *bp, BN_CTX *ctx)
 		if (a->neg && b->neg)
 			kronecker = -kronecker;
 		
-		if (legendre != kronecker)
-			{
+		if (legendre != kronecker) {
 			fprintf(stderr, "legendre != kronecker; a = ");
 			BN_print_fp(stderr, a);
 			fprintf(stderr, ", b = ");
 			BN_print_fp(stderr, b);
 			fprintf(stderr, "\n");
 			goto err;
-			}
+		}
 
 		putc('.', stderr);
 		fflush(stderr);
-		}
+	}
 
 	putc('\n', stderr);
 	fflush(stderr);
 	ret = 1;
- err:
+err:
 	if (a != NULL) BN_free(a);
 	if (b != NULL) BN_free(b);
 	if (r != NULL) BN_free(r);
 	if (t != NULL) BN_free(t);
 	return ret;
-	}
+}
 
-int test_sqrt(BIO *bp, BN_CTX *ctx)
-	{
+int
+test_sqrt(BIO *bp, BN_CTX *ctx)
+{
 	BN_GENCB cb;
 	BIGNUM *a,*p,*r;
 	int i, j;
@@ -1748,26 +1686,21 @@ int test_sqrt(BIO *bp, BN_CTX *ctx)
 
 	BN_GENCB_set(&cb, genprime_cb, NULL);
 
-	for (i = 0; i < 16; i++)
-		{
-		if (i < 8)
-			{
+	for (i = 0; i < 16; i++) {
+		if (i < 8) {
 			unsigned primes[8] = { 2, 3, 5, 7, 11, 13, 17, 19 };
 			
 			if (!BN_set_word(p, primes[i])) goto err;
-			}
-		else
-			{
+		} else {
 			if (!BN_set_word(a, 32)) goto err;
 			if (!BN_set_word(r, 2*i + 1)) goto err;
 		
 			if (!BN_generate_prime_ex(p, 256, 0, a, r, &cb)) goto err;
 			putc('\n', stderr);
-			}
+		}
 		p->neg = rand_neg();
 
-		for (j = 0; j < num2; j++)
-			{
+		for (j = 0; j < num2; j++) {
 			/* construct 'a' such that it is a square modulo p,
 			 * but in general not a proper square and not reduced modulo p */
 			if (!BN_bntest_rand(r, 256, 0, 3)) goto err;
@@ -1785,8 +1718,7 @@ int test_sqrt(BIO *bp, BN_CTX *ctx)
 
 			if (!BN_nnmod(a, a, p, ctx)) goto err;
 
-			if (BN_cmp(a, r) != 0)
-				{
+			if (BN_cmp(a, r) != 0) {
 				fprintf(stderr, "BN_mod_sqrt failed: a = ");
 				BN_print_fp(stderr, a);
 				fprintf(stderr, ", r = ");
@@ -1795,27 +1727,29 @@ int test_sqrt(BIO *bp, BN_CTX *ctx)
 				BN_print_fp(stderr, p);
 				fprintf(stderr, "\n");
 				goto err;
-				}
+			}
 
 			putc('.', stderr);
 			fflush(stderr);
-			}
+		}
 		
 		putc('\n', stderr);
 		fflush(stderr);
-		}
+	}
 	ret = 1;
- err:
+err:
 	if (a != NULL) BN_free(a);
 	if (p != NULL) BN_free(p);
 	if (r != NULL) BN_free(r);
 	return ret;
-	}
+}
 
-int test_lshift(BIO *bp,BN_CTX *ctx,BIGNUM *a_)
-	{
+int
+test_lshift(BIO *bp,BN_CTX *ctx,BIGNUM *a_)
+{
 	BIGNUM *a,*b,*c,*d;
 	int i;
+	int rc = 1;
 
 	b=BN_new();
 	c=BN_new();
@@ -1824,32 +1758,27 @@ int test_lshift(BIO *bp,BN_CTX *ctx,BIGNUM *a_)
 
 	if(a_)
 	    a=a_;
-	else
-	    {
+	else {
 	    a=BN_new();
 	    BN_bntest_rand(a,200,0,0); /**/
 	    a->neg=rand_neg();
-	    }
-	for (i=0; i<num0; i++)
-		{
+	}
+	for (i=0; i<num0; i++) {
 		BN_lshift(b,a,i+1);
 		BN_add(c,c,c);
-		if (bp != NULL)
-			{
-			if (!results)
-				{
+		if (bp != NULL) {
+			if (!results) {
 				BN_print(bp,a);
 				BIO_puts(bp," * ");
 				BN_print(bp,c);
 				BIO_puts(bp," - ");
-				}
+			}
 			BN_print(bp,b);
 			BIO_puts(bp,"\n");
-			}
+		}
 		BN_mul(d,a,c,ctx);
 		BN_sub(d,d,b);
-		if(!BN_is_zero(d))
-		    {
+		if(!BN_is_zero(d)) {
 		    fprintf(stderr,"Left shift test failed!\n");
 		    fprintf(stderr,"a=");
 		    BN_print_fp(stderr,a);
@@ -1860,20 +1789,23 @@ int test_lshift(BIO *bp,BN_CTX *ctx,BIGNUM *a_)
 		    fprintf(stderr,"\nd=");
 		    BN_print_fp(stderr,d);
 		    fprintf(stderr,"\n");
-		    return 0;
-		    }
+		    rc = 0;
+		    break;
 		}
+	}
 	BN_free(a);
 	BN_free(b);
 	BN_free(c);
 	BN_free(d);
-	return(1);
-	}
+	return(rc);
+}
 
-int test_lshift1(BIO *bp)
-	{
+int
+test_lshift1(BIO *bp)
+{
 	BIGNUM *a,*b,*c;
 	int i;
+	int rc = 1;
 
 	a=BN_new();
 	b=BN_new();
@@ -1881,40 +1813,39 @@ int test_lshift1(BIO *bp)
 
 	BN_bntest_rand(a,200,0,0); /**/
 	a->neg=rand_neg();
-	for (i=0; i<num0; i++)
-		{
+	for (i=0; i<num0; i++) {
 		BN_lshift1(b,a);
-		if (bp != NULL)
-			{
-			if (!results)
-				{
+		if (bp != NULL) {
+			if (!results) {
 				BN_print(bp,a);
 				BIO_puts(bp," * 2");
 				BIO_puts(bp," - ");
-				}
+			}
 			BN_print(bp,b);
 			BIO_puts(bp,"\n");
-			}
+		}
 		BN_add(c,a,a);
 		BN_sub(a,b,c);
-		if(!BN_is_zero(a))
-		    {
+		if(!BN_is_zero(a)) {
 		    fprintf(stderr,"Left shift one test failed!\n");
-		    return 0;
-		    }
+		    rc = 0;
+		    break;
+		}
 		
 		BN_copy(a,b);
-		}
+	}
 	BN_free(a);
 	BN_free(b);
 	BN_free(c);
-	return(1);
-	}
+	return(rc);
+}
 
-int test_rshift(BIO *bp,BN_CTX *ctx)
-	{
+int
+test_rshift(BIO *bp,BN_CTX *ctx)
+{
 	BIGNUM *a,*b,*c,*d,*e;
 	int i;
+	int rc = 1;
 
 	a=BN_new();
 	b=BN_new();
@@ -1925,42 +1856,41 @@ int test_rshift(BIO *bp,BN_CTX *ctx)
 
 	BN_bntest_rand(a,200,0,0); /**/
 	a->neg=rand_neg();
-	for (i=0; i<num0; i++)
-		{
+	for (i=0; i<num0; i++) {
 		BN_rshift(b,a,i+1);
 		BN_add(c,c,c);
-		if (bp != NULL)
-			{
-			if (!results)
-				{
+		if (bp != NULL) {
+			if (!results) {
 				BN_print(bp,a);
 				BIO_puts(bp," / ");
 				BN_print(bp,c);
 				BIO_puts(bp," - ");
-				}
+			}
 			BN_print(bp,b);
 			BIO_puts(bp,"\n");
-			}
+		}
 		BN_div(d,e,a,c,ctx);
 		BN_sub(d,d,b);
-		if(!BN_is_zero(d))
-		    {
+		if(!BN_is_zero(d)) {
 		    fprintf(stderr,"Right shift test failed!\n");
-		    return 0;
-		    }
+		    rc = 0;
+		    break;
 		}
+	}
 	BN_free(a);
 	BN_free(b);
 	BN_free(c);
 	BN_free(d);
 	BN_free(e);
-	return(1);
-	}
+	return(rc);
+}
 
-int test_rshift1(BIO *bp)
-	{
+int
+test_rshift1(BIO *bp)
+{
 	BIGNUM *a,*b,*c;
 	int i;
+	int rc = 1;
 
 	a=BN_new();
 	b=BN_new();
@@ -1968,42 +1898,40 @@ int test_rshift1(BIO *bp)
 
 	BN_bntest_rand(a,200,0,0); /**/
 	a->neg=rand_neg();
-	for (i=0; i<num0; i++)
-		{
+	for (i=0; i<num0; i++) {
 		BN_rshift1(b,a);
-		if (bp != NULL)
-			{
-			if (!results)
-				{
+		if (bp != NULL) {
+			if (!results) {
 				BN_print(bp,a);
 				BIO_puts(bp," / 2");
 				BIO_puts(bp," - ");
-				}
+			}
 			BN_print(bp,b);
 			BIO_puts(bp,"\n");
-			}
+		}
 		BN_sub(c,a,b);
 		BN_sub(c,c,b);
-		if(!BN_is_zero(c) && !BN_abs_is_word(c, 1))
-		    {
+		if(!BN_is_zero(c) && !BN_abs_is_word(c, 1)) {
 		    fprintf(stderr,"Right shift one test failed!\n");
-		    return 0;
-		    }
-		BN_copy(a,b);
+		    rc = 0;
+		    break;
 		}
+		BN_copy(a,b);
+	}
 	BN_free(a);
 	BN_free(b);
 	BN_free(c);
-	return(1);
-	}
+	return(rc);
+}
 
-int rand_neg(void)
-	{
+int
+rand_neg(void)
+{
 	static unsigned int neg=0;
 	static int sign[8]={0,0,0,1,1,0,1,1};
 
 	return(sign[(neg++)%8]);
-	}
+}
 
 int
 test_mod_exp_sizes(BIO *bp, BN_CTX *ctx)
-- 
cgit v1.2.3-55-g6feb