 @@ -69,27 +69,27 @@
 #ifdef OPENSSL_NO_BF
 int main(int argc, char *argv[])
+{
     printf("No BF support\n");
     return(0);
+}
 #else
 #include <openssl/blowfish.h>
 #ifdef CHARSET_EBCDIC
 #include <openssl/ebcdic.h>
 #endif
-static char *bf_key[2]={
+static const char *bf_key[2]={
 	"abcdefghijklmnopqrstuvwxyz",
 	"Who is John Galt?"
 	};
 /* big endian */
 static BF_LONG bf_plain[2][2]={
 	{0x424c4f57L,0x46495348L},
 	{0xfedcba98L,0x76543210L}
 	};
 static BF_LONG bf_cipher[2][2]={
 	{0x324ed0feL,0xf413a203L},
 	{0xcc91732bL,0x8022f684L}
 @@ -361,27 +361,27 @@ static int test(void)
 	unsigned char out[8];
 	BF_LONG len;
 #ifdef CHARSET_EBCDIC
 	ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data));
 #endif
 	printf("testing blowfish in raw ecb mode\n");
 	for (n=0; n<2; n++)
+		{
 #ifdef CHARSET_EBCDIC
 		ebcdic2ascii(bf_key[n], bf_key[n], strlen(bf_key[n]));
 #endif
-		BF_set_key(&key,strlen(bf_key[n]),(unsigned char *)bf_key[n]);
+		BF_set_key(&key,strlen(bf_key[n]), (const unsigned char *)bf_key[n]);
 		data[0]=bf_plain[n][0];
 		data[1]=bf_plain[n][1];
 		BF_encrypt(data,&key);
 		if (memcmp(&(bf_cipher[n][0]),&(data[0]),8) != 0)
+			{
 			printf("BF_encrypt error encrypting\n");
 			printf("got     :");
 			for (i=0; i<2; i++)
 				printf("%08lX ",(unsigned long)data[i]);
 			printf("\n");
 			printf("expected:");
 			for (i=0; i<2; i++)

 @@ -117,27 +117,27 @@ int test_gf2m_mod_div(BIO *bp,BN_CTX *ct
 int test_gf2m_mod_exp(BIO *bp,BN_CTX *ctx);
 int test_gf2m_mod_sqrt(BIO *bp,BN_CTX *ctx);
 int test_gf2m_mod_solve_quad(BIO *bp,BN_CTX *ctx);
 int test_kron(BIO *bp,BN_CTX *ctx);
 int test_sqrt(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"
 "\x9B\x04\x5D\x48\x36\xC2\xFD\x16\xC9\x64\xF0";
 static const char rnd_seed[] = "string to make the random number generator think it has entropy";
-static void message(BIO *out, char *m)
+static void message(BIO *out, const 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[])
+	{
 	BN_CTX *ctx;
 	BIO *out;
 	char *outfile=NULL;

	@@ -1,24 +1,24 @@		@@ -1,24 +1,24 @@
1	#include <openssl/bn.h>	1	#include <openssl/bn.h>
2	#include <openssl/rand.h>	2	#include <openssl/rand.h>
3		3
4	static int Rand(void)	4	static int Rand(void)
5	{	5	{
6	unsigned char x[2];	6	unsigned char x[2];
7	RAND_pseudo_bytes(x,2);	7	RAND_pseudo_bytes(x,2);
8	return (x[0] + 2*x[1]);	8	return (x[0] + 2*x[1]);
9	}	9	}
10		10
11	static void bug(char m, BIGNUM a, BIGNUM *b)	11	static void bug(const char m, BIGNUM a, BIGNUM *b)
12	{	12	{
13	printf("%s!\na=",m);	13	printf("%s!\na=",m);
14	BN_print_fp(stdout, a);	14	BN_print_fp(stdout, a);
15	printf("\nb=");	15	printf("\nb=");
16	BN_print_fp(stdout, b);	16	BN_print_fp(stdout, b);
17	printf("\n");	17	printf("\n");
18	fflush(stdout);	18	fflush(stdout);
19	exit(1);	19	exit(1);
20	}	20	}
21		21
22	int	22	int
23	main(int argc, char *argv[])	23	main(int argc, char *argv[])
24	{	24	{

 @@ -170,27 +170,27 @@ int main(int argc, char *argv[])
 	    printf("expected:");
 	    for (i=0; i<8; i++)
 		printf("%02X ",in[i]);
 	    printf("\n");
 	    err=3;
+	    }
+	}
     if (err == 0)
 	printf("ecb cast5 ok\n");
 #ifdef FULL_TEST
+      {
       unsigned char out_a[16],out_b[16];
-      static char *hex="0123456789ABCDEF";
+      static const char *hex="0123456789ABCDEF";
       printf("This test will take some time....");
       fflush(stdout);
       memcpy(out_a,in_a,sizeof(in_a));
       memcpy(out_b,in_b,sizeof(in_b));
       i=1;
       for (l=0; l<1000000L; l++)
+	  {
 	  CAST_set_key(&key_b,16,out_b);
 	  CAST_ecb_encrypt(&(out_a[0]),&(out_a[0]),&key_b,CAST_ENCRYPT);
 	  CAST_ecb_encrypt(&(out_a[8]),&(out_a[8]),&key_b,CAST_ENCRYPT);
 	  CAST_set_key(&key,16,out_a);

 @@ -56,27 +56,27 @@
  * [including the GNU Public Licence.]
  */
 #include <stdio.h>
 #include <stdlib.h>
 #include <openssl/conf.h>
 #include <openssl/err.h>
 int
 main(void)
+	{
 	LHASH_OF(CONF_VALUE) *conf;
 	long eline;
-	char *s,*s2;
+	char *s;
 #ifdef USE_WIN32
 	CONF_set_default_method(CONF_WIN32);
 #endif
 	conf=CONF_load(NULL,"ssleay.cnf",&eline);
 	if (conf == NULL)
+		{
 		ERR_load_crypto_strings();
 		printf("unable to load configuration, line %ld\n",eline);
 		ERR_print_errors_fp(stderr);
 		exit(1);
+		}
 	lh_stats((_LHASH *)conf,stdout);

 @@ -376,27 +376,27 @@ int main(int argc, char *argv[])
 			      &iv3,&iv2,DES_ENCRYPT);
 	/*	if (memcmp(cbc_out,cbc3_ok,
 		(unsigned int)(strlen((char *)cbc_data)+1+7)/8*8) != 0)
+		{
 		printf("DES_ede3_cbc_encrypt encrypt error\n");
 		err=1;
+		}
 	*/
 	memcpy(iv3,cbc_iv,sizeof(cbc_iv));
 	memset(iv2,'\0',sizeof iv2);
 	DES_ede3_cbcm_encrypt(cbc_out,cbc_in,i,&ks,&ks2,&ks3,&iv3,&iv2,DES_DECRYPT);
 	if (memcmp(cbc_in,cbc_data,strlen((char *)cbc_data)+1) != 0)
+		{
-		int n;
+		unsigned int n;
 		printf("DES_ede3_cbcm_encrypt decrypt error\n");
 		for(n=0 ; n < i ; ++n)
 		    printf(" %02x",cbc_data[n]);
 		printf("\n");
 		for(n=0 ; n < i ; ++n)
 		    printf(" %02x",cbc_in[n]);
 		printf("\n");
 		err=1;
+		}
 #endif
 	printf("Doing ecb\n");
 @@ -525,43 +525,43 @@ int main(int argc, char *argv[])
 	memset(cbc_out,0,40);
 	memset(cbc_in,0,40);
 	i=strlen((char *)cbc_data)+1;
 	/* i=((i+7)/8)*8; */
 	memcpy(iv3,cbc_iv,sizeof(cbc_iv));
 	DES_ede3_cbc_encrypt(cbc_data,cbc_out,16L,&ks,&ks2,&ks3,&iv3,
 			     DES_ENCRYPT);
 	DES_ede3_cbc_encrypt(&(cbc_data[16]),&(cbc_out[16]),i-16,&ks,&ks2,&ks3,
 			     &iv3,DES_ENCRYPT);
 	if (memcmp(cbc_out,cbc3_ok,
 		(unsigned int)(strlen((char *)cbc_data)+1+7)/8*8) != 0)
+		{
-		int n;
+		unsigned int n;
 		printf("DES_ede3_cbc_encrypt encrypt error\n");
 		for(n=0 ; n < i ; ++n)
 		    printf(" %02x",cbc_out[n]);
 		printf("\n");
 		for(n=0 ; n < i ; ++n)
 		    printf(" %02x",cbc3_ok[n]);
 		printf("\n");
 		err=1;
+		}
 	memcpy(iv3,cbc_iv,sizeof(cbc_iv));
 	DES_ede3_cbc_encrypt(cbc_out,cbc_in,i,&ks,&ks2,&ks3,&iv3,DES_DECRYPT);
 	if (memcmp(cbc_in,cbc_data,strlen((char *)cbc_data)+1) != 0)
+		{
-		int n;
+		unsigned int n;
 		printf("DES_ede3_cbc_encrypt decrypt error\n");
 		for(n=0 ; n < i ; ++n)
 		    printf(" %02x",cbc_data[n]);
 		printf("\n");
 		for(n=0 ; n < i ; ++n)
 		    printf(" %02x",cbc_in[n]);
 		printf("\n");
 		err=1;
+		}
 #ifndef LIBDES_LIT
 	printf("Doing pcbc\n");
 @@ -818,27 +818,27 @@ plain[8+4], plain[8+5], plain[8+6], plai
 #ifdef OPENSSL_SYS_NETWARE
     if (err) printf("ERROR: %d\n", err);
 #endif
 	printf("\n");
 	return(err);
+	}
 static char *pt(unsigned char *p)
+	{
 	static char bufs[10][20];
 	static int bnum=0;
 	char *ret;
 	int i;
-	static char *f="0123456789ABCDEF";
+	static const char *f="0123456789ABCDEF";
 	ret= &(bufs[bnum++][0]);
 	bnum%=10;
 	for (i=0; i<8; i++)
+		{
 		ret[i*2]=f[(p[i]>>4)&0xf];
 		ret[i*2+1]=f[p[i]&0xf];
+		}
 	ret[16]='\0';
 	return(ret);
+	}
 #ifndef LIBDES_LIT

 @@ -224,27 +224,27 @@ static void group_order_tests(EC_GROUP *
 	/* n2 = (1 - order) * (1 + order) */
 	if (!BN_mul(n2, n1, n2, ctx)) ABORT;
 	if(!EC_POINT_mul(group, Q, NULL, P, n2, ctx)) ABORT;
 	if (0 != EC_POINT_cmp(group, Q, P, ctx)) ABORT;
 	fprintf(stdout, "ok\n");
 	EC_POINT_free(P);
 	EC_POINT_free(Q);
 	BN_free(n1);
 	BN_free(n2);
 	BN_free(order);
 	BN_CTX_free(ctx);
+	}
-static void prime_field_tests()
+static void prime_field_tests(void)
+	{
 	BN_CTX *ctx = NULL;
 	BIGNUM *p, *a, *b;
 	EC_GROUP *group;
 	EC_GROUP *P_160 = NULL, *P_192 = NULL, *P_224 = NULL, *P_256 = NULL, *P_384 = NULL, *P_521 = NULL;
 	EC_POINT *P, *Q, *R;
 	BIGNUM *x, *y, *z;
 	unsigned char buf[100];
 	size_t i, len;
 	int k;
 #if 1 /* optional */
 	ctx = BN_CTX_new();
 @@ -767,27 +767,27 @@ static void prime_field_tests()
 	if (!BN_hex2bn(&p, _p)) ABORT; \
 	if (!BN_hex2bn(&a, _a)) ABORT; \
 	if (!BN_hex2bn(&b, _b)) ABORT; \
 	if (!EC_GROUP_set_curve_GF2m(group, p, a, b, ctx)) ABORT; \
 	CHAR2_CURVE_TEST_INTERNAL(_name, _p, _a, _b, _x, _y, _y_bit, _order, _cof, _degree, _variable) \
 	fprintf(stdout, "verify degree ..."); \
 	if (EC_GROUP_get_degree(group) != _degree) ABORT; \
 	fprintf(stdout, " ok\n"); \
 	group_order_tests(group); \
 	if (!(_variable = EC_GROUP_new(EC_GROUP_method_of(group)))) ABORT; \
 	if (!EC_GROUP_copy(_variable, group)) ABORT; \
-static void char2_field_tests()
+static void char2_field_tests(void)
+	{
 	BN_CTX *ctx = NULL;
 	BIGNUM *p, *a, *b;
 	EC_GROUP *group;
 	EC_GROUP *C2_K163 = NULL, *C2_K233 = NULL, *C2_K283 = NULL, *C2_K409 = NULL, *C2_K571 = NULL;
 	EC_GROUP *C2_B163 = NULL, *C2_B233 = NULL, *C2_B283 = NULL, *C2_B409 = NULL, *C2_B571 = NULL;
 	EC_POINT *P, *Q, *R;
 	BIGNUM *x, *y, *z, *cof;
 	unsigned char buf[100];
 	size_t i, len;
 	int k;
 #if 1 /* optional */

	@@ -248,28 +248,28 @@ cleanup_loop:		@@ -248,28 +248,28 @@ cleanup_loop:
248	printf("\nAbout to empty the engine-type list\n");	248	printf("\nAbout to empty the engine-type list\n");
249	while((ptr = ENGINE_get_first()) != NULL)	249	while((ptr = ENGINE_get_first()) != NULL)
250	{	250	{
251	if(!ENGINE_remove(ptr))	251	if(!ENGINE_remove(ptr))
252	{	252	{
253	printf("\nRemove failed!\n");	253	printf("\nRemove failed!\n");
254	goto end;	254	goto end;
255	}	255	}
256	ENGINE_free(ptr);	256	ENGINE_free(ptr);
257	printf("."); fflush(stdout);	257	printf("."); fflush(stdout);
258	}	258	}
259	for(loop = 0; loop < 512; loop++)	259	for(loop = 0; loop < 512; loop++)
260	{	260	{
261	OPENSSL_free((void *)ENGINE_get_id(block[loop]));	261	OPENSSL_free((void *)(intptr_t)ENGINE_get_id(block[loop]));
262	OPENSSL_free((void *)ENGINE_get_name(block[loop]));	262	OPENSSL_free((void *)(intptr_t)ENGINE_get_name(block[loop]));
263	}	263	}
264	printf("\nTests completed happily\n");	264	printf("\nTests completed happily\n");
265	to_return = 0;	265	to_return = 0;
266	end:	266	end:
267	if(to_return)	267	if(to_return)
268	ERR_print_errors_fp(stderr);	268	ERR_print_errors_fp(stderr);
269	if(new_h1) ENGINE_free(new_h1);	269	if(new_h1) ENGINE_free(new_h1);
270	if(new_h2) ENGINE_free(new_h2);	270	if(new_h2) ENGINE_free(new_h2);
271	if(new_h3) ENGINE_free(new_h3);	271	if(new_h3) ENGINE_free(new_h3);
272	if(new_h4) ENGINE_free(new_h4);	272	if(new_h4) ENGINE_free(new_h4);
273	for(loop = 0; loop < 512; loop++)	273	for(loop = 0; loop < 512; loop++)
274	if(block[loop])	274	if(block[loop])
275	ENGINE_free(block[loop]);	275	ENGINE_free(block[loop]);

 @@ -71,61 +71,61 @@ int main(int argc, char *argv[])
 #else
 #include <openssl/hmac.h>
 #ifndef OPENSSL_NO_MD5
 #include <openssl/md5.h>
 #endif
 #ifdef CHARSET_EBCDIC
 #include <openssl/ebcdic.h>
 #endif
 #ifndef OPENSSL_NO_MD5
 static struct test_st
+	{
-	unsigned char key[16];
+	const unsigned char key[16];
 	int key_len;
-	unsigned char data[64];
+	const unsigned char data[64];
 	int data_len;
-	unsigned char *digest;
+	const unsigned char *digest;
 	} test[4]={
 	{	"",
 ,
 		"More text test vectors to stuff up EBCDIC machines :-)",
 ,
-		(unsigned char *)"e9139d1e6ee064ef8cf514fc7dc83e86",
+		(const unsigned char *)"e9139d1e6ee064ef8cf514fc7dc83e86",
 	},{	{0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,
 x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,0x0b,},
 ,
 		"Hi There",
 ,
-		(unsigned char *)"9294727a3638bb1c13f48ef8158bfc9d",
+		(const unsigned char *)"9294727a3638bb1c13f48ef8158bfc9d",
 	},{	"Jefe",
 ,
 		"what do ya want for nothing?",
 ,
-		(unsigned char *)"750c783e6ab0b503eaa86e310a5db738",
+		(const unsigned char *)"750c783e6ab0b503eaa86e310a5db738",
 	},{
 		{0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,
 xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,},
 ,
 		{0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,
 xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,
 xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,
 xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,
 xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,
 xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,
 xdd,0xdd},
 ,
-		(unsigned char *)"56be34521d144c88dbb8c733f0e8b3f6",
+		(const unsigned char *)"56be34521d144c88dbb8c733f0e8b3f6",
 	},
 	};
 #endif
 static char *pt(unsigned char *md);
 int main(int argc, char *argv[])
+	{
 #ifndef OPENSSL_NO_MD5
 	int i;
 	char *p;
 #endif
 	int err=0;
 @@ -137,27 +137,27 @@ int main(int argc, char *argv[])
 	ebcdic2ascii(test[0].data, test[0].data, test[0].data_len);
 	ebcdic2ascii(test[1].data, test[1].data, test[1].data_len);
 	ebcdic2ascii(test[2].key,  test[2].key,  test[2].key_len);
 	ebcdic2ascii(test[2].data, test[2].data, test[2].data_len);
 #endif
 	for (i=0; i<4; i++)
+		{
 		p=pt(HMAC(EVP_md5(),
 			test[i].key, test[i].key_len,
 			test[i].data, test[i].data_len,
 			NULL,NULL));
-		if (strcmp(p,(char *)test[i].digest) != 0)
+		if (strcmp(p,(const char *)test[i].digest) != 0)
+			{
 			printf("error calculating HMAC on %d entry'\n",i);
 			printf("got %s instead of %s\n",p,test[i].digest);
 			err++;
+			}
 		else
 			printf("test %d ok\n",i);
+		}
 #endif /* OPENSSL_NO_MD5 */
 	EXIT(err);
 	return(0);
+	}

 @@ -66,61 +66,61 @@
 int main(int argc, char *argv[])
+{
     printf("No MD2 support\n");
     return(0);
+}
 #else
 #include <openssl/evp.h>
 #include <openssl/md2.h>
 #ifdef CHARSET_EBCDIC
 #include <openssl/ebcdic.h>
 #endif
-static char *test[]={
+static const char *test[]={
 	"",
 	"a",
 	"abc",
 	"message digest",
 	"abcdefghijklmnopqrstuvwxyz",
 	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
 	"12345678901234567890123456789012345678901234567890123456789012345678901234567890",
 	NULL,
 	};
-static char *ret[]={
+static const char *ret[]={
 	"8350e5a3e24c153df2275c9f80692773",
 	"32ec01ec4a6dac72c0ab96fb34c0b5d1",
 	"da853b0d3f88d99b30283a69e6ded6bb",
 	"ab4f496bfb2a530b219ff33031fe06b0",
 	"4e8ddff3650292ab5a4108c3aa47940b",
 	"da33def2a42df13975352846c30338cd",
 	"d5976f79d83d3a0dc9806c3c66f3efd8",
 	};
 static char *pt(unsigned char *md);
 int main(int argc, char *argv[])
+	{
 	int i,err=0;
-	char **P,**R;
+	const char **P,**R;
 	char *p;
 	unsigned char md[MD2_DIGEST_LENGTH];
 	P=test;
 	R=ret;
 	i=1;
 	while (*P != NULL)
+		{
-		EVP_Digest((unsigned char *)*P,strlen(*P),md,NULL,EVP_md2(), NULL);
+		EVP_Digest((const unsigned char *)*P,strlen(*P),md,NULL,EVP_md2(), NULL);
 		p=pt(md);
 		if (strcmp(p,*R) != 0)
+			{
 			printf("error calculating MD2 on '%s'\n",*P);
 			printf("got %s instead of %s\n",p,*R);
 			err++;
+			}
 		else
 			printf("test %d ok\n",i);
 		i++;
 		R++;
 		P++;
+		}

 @@ -62,63 +62,63 @@
 #include "../e_os.h"
 #ifdef OPENSSL_NO_MD4
 int main(int argc, char *argv[])
+{
     printf("No MD4 support\n");
     return(0);
+}
 #else
 #include <openssl/evp.h>
 #include <openssl/md4.h>
-static char *test[]={
+static const char *test[]={
 	"",
 	"a",
 	"abc",
 	"message digest",
 	"abcdefghijklmnopqrstuvwxyz",
 	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
 	"12345678901234567890123456789012345678901234567890123456789012345678901234567890",
 	NULL,
 	};
-static char *ret[]={
+static const char *ret[]={
 "31d6cfe0d16ae931b73c59d7e0c089c0",
 "bde52cb31de33e46245e05fbdbd6fb24",
 "a448017aaf21d8525fc10ae87aa6729d",
 "d9130a8164549fe818874806e1c7014b",
 "d79e1c308aa5bbcdeea8ed63df412da9",
 "043f8582f241db351ce627e153e7f0e4",
 "e33b4ddc9c38f2199c3e7b164fcc0536",
 };
 static char *pt(unsigned char *md);
 int main(int argc, char *argv[])
+	{
 	int i,err=0;
-	char **P,**R;
+	const char **P,**R;
 	char *p;
 	unsigned char md[MD4_DIGEST_LENGTH];
 	P=test;
 	R=ret;
 	i=1;
 	while (*P != NULL)
+		{
-		EVP_Digest(&(P[0][0]),strlen((char *)*P),md,NULL,EVP_md4(), NULL);
+		EVP_Digest(&(P[0][0]),strlen((const char *)*P),md,NULL,EVP_md4(), NULL);
 		p=pt(md);
-		if (strcmp(p,(char *)*R) != 0)
+		if (strcmp(p,(const char *)*R) != 0)
+			{
 			printf("error calculating MD4 on '%s'\n",*P);
 			printf("got %s instead of %s\n",p,*R);
 			err++;
+			}
 		else
 			printf("test %d ok\n",i);
 		i++;
 		R++;
 		P++;
+		}
 	EXIT(err);
 	return(0);

 @@ -62,63 +62,63 @@
 #include "../e_os.h"
 #ifdef OPENSSL_NO_MD5
 int main(int argc, char *argv[])
+{
     printf("No MD5 support\n");
     return(0);
+}
 #else
 #include <openssl/evp.h>
 #include <openssl/md5.h>
-static char *test[]={
+static const char *test[]={
 	"",
 	"a",
 	"abc",
 	"message digest",
 	"abcdefghijklmnopqrstuvwxyz",
 	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
 	"12345678901234567890123456789012345678901234567890123456789012345678901234567890",
 	NULL,
 	};
-static char *ret[]={
+static const char *ret[]={
 	"d41d8cd98f00b204e9800998ecf8427e",
 	"0cc175b9c0f1b6a831c399e269772661",
 	"900150983cd24fb0d6963f7d28e17f72",
 	"f96b697d7cb7938d525a2f31aaf161d0",
 	"c3fcd3d76192e4007dfb496cca67e13b",
 	"d174ab98d277d9f5a5611c2c9f419d9f",
 	"57edf4a22be3c955ac49da2e2107b67a",
 	};
 static char *pt(unsigned char *md);
 int main(int argc, char *argv[])
+	{
 	int i,err=0;
-	char **P,**R;
+	const char **P,**R;
 	char *p;
 	unsigned char md[MD5_DIGEST_LENGTH];
 	P=test;
 	R=ret;
 	i=1;
 	while (*P != NULL)
+		{
-		EVP_Digest(&(P[0][0]),strlen((char *)*P),md,NULL,EVP_md5(), NULL);
+		EVP_Digest(&(P[0][0]),strlen((const char *)*P),md,NULL,EVP_md5(), NULL);
 		p=pt(md);
-		if (strcmp(p,(char *)*R) != 0)
+		if (strcmp(p,(const char *)*R) != 0)
+			{
 			printf("error calculating MD5 on '%s'\n",*P);
 			printf("got %s instead of %s\n",p,*R);
 			err++;
+			}
 		else
 			printf("test %d ok\n",i);
 		i++;
 		R++;
 		P++;
+		}
 #ifdef OPENSSL_SYS_NETWARE

 @@ -66,68 +66,68 @@
 int main(int argc, char *argv[])
+{
     printf("No ripemd support\n");
     return(0);
+}
 #else
 #include <openssl/ripemd.h>
 #include <openssl/evp.h>
 #ifdef CHARSET_EBCDIC
 #include <openssl/ebcdic.h>
 #endif
-static char *test[]={
+static const char *test[]={
 	"",
 	"a",
 	"abc",
 	"message digest",
 	"abcdefghijklmnopqrstuvwxyz",
 	"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
 	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
 	"12345678901234567890123456789012345678901234567890123456789012345678901234567890",
 	NULL,
 	};
-static char *ret[]={
+static const char *ret[]={
 	"9c1185a5c5e9fc54612808977ee8f548b2258d31",
 	"0bdc9d2d256b3ee9daae347be6f4dc835a467ffe",
 	"8eb208f7e05d987a9b044a8e98c6b087f15a0bfc",
 	"5d0689ef49d2fae572b881b123a85ffa21595f36",
 	"f71c27109c692c1b56bbdceb5b9d2865b3708dbc",
 	"12a053384a9c0c88e405a06c27dcf49ada62eb2b",
 	"b0e20b6e3116640286ed3a87a5713079b21f5189",
 	"9b752e45573d4b39f4dbd3323cab82bf63326bfb",
 	};
 static char *pt(unsigned char *md);
 int main(int argc, char *argv[])
+	{
 	int i,err=0;
-	char **P,**R;
+	const char **P,**R;
 	char *p;
 	unsigned char md[RIPEMD160_DIGEST_LENGTH];
 	P=test;
 	R=ret;
 	i=1;
 	while (*P != NULL)
+		{
 #ifdef CHARSET_EBCDIC
-		ebcdic2ascii((char *)*P, (char *)*P, strlen((char *)*P));
+		ebcdic2ascii((const char *)*P, (const char *)*P, strlen((const char *)*P));
 #endif
-		EVP_Digest(&(P[0][0]),strlen((char *)*P),md,NULL,EVP_ripemd160(), NULL);
+		EVP_Digest(&(P[0][0]),strlen((const char *)*P),md,NULL,EVP_ripemd160(), NULL);
 		p=pt(md);
-		if (strcmp(p,(char *)*R) != 0)
+		if (strcmp(p,(const char *)*R) != 0)
+			{
 			printf("error calculating RIPEMD160 on '%s'\n",*P);
 			printf("got %s instead of %s\n",p,*R);
 			err++;
+			}
 		else
 			printf("test %d ok\n",i);
 		i++;
 		R++;
 		P++;
+		}
 	EXIT(err);
 	return(0);

 @@ -69,73 +69,73 @@ int main(int argc, char *argv[])
     return(0);
+}
 #else
 #include <openssl/evp.h>
 #include <openssl/sha.h>
 #ifdef CHARSET_EBCDIC
 #include <openssl/ebcdic.h>
 #endif
 #undef SHA_0 /* FIPS 180 */
 #define  SHA_1 /* FIPS 180-1 */
-static char *test[]={
+static const char *test[]={
 	"abc",
 	"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
 	NULL,
 	};
 #ifdef SHA_0
-static char *ret[]={
+static const char *ret[]={
 	"0164b8a914cd2a5e74c4f7ff082c4d97f1edf880",
 	"d2516ee1acfa5baf33dfc1c471e438449ef134c8",
 	};
-static char *bigret=
+static const char *bigret=
 	"3232affa48628a26653b5aaa44541fd90d690603";
 #endif
 #ifdef SHA_1
-static char *ret[]={
+static const char *ret[]={
 	"a9993e364706816aba3e25717850c26c9cd0d89d",
 	"84983e441c3bd26ebaae4aa1f95129e5e54670f1",
 	};
-static char *bigret=
+static const char *bigret=
 	"34aa973cd4c4daa4f61eeb2bdbad27316534016f";
 #endif
 static char *pt(unsigned char *md);
 int main(int argc, char *argv[])
+	{
 	int i,err=0;
-	char **P,**R;
+	const char **P,**R;
 	static unsigned char buf[1000];
-	char *p,*r;
+	const char *p,*r;
 	EVP_MD_CTX c;
 	unsigned char md[SHA_DIGEST_LENGTH];
 #ifdef CHARSET_EBCDIC
 	ebcdic2ascii(test[0], test[0], strlen(test[0]));
 	ebcdic2ascii(test[1], test[1], strlen(test[1]));
 #endif
 	EVP_MD_CTX_init(&c);
 	P=test;
 	R=ret;
 	i=1;
 	while (*P != NULL)
+		{
-		EVP_Digest(*P,strlen((char *)*P),md,NULL,EVP_sha1(), NULL);
+		EVP_Digest(*P,strlen((const char *)*P),md,NULL,EVP_sha1(), NULL);
 		p=pt(md);
-		if (strcmp(p,(char *)*R) != 0)
+		if (strcmp(p,(const char *)*R) != 0)
+			{
 			printf("error calculating SHA1 on '%s'\n",*P);
 			printf("got %s instead of %s\n",p,*R);
 			err++;
+			}
 		else
 			printf("test %d ok\n",i);
 		i++;
 		R++;
 		P++;
+		}
 	memset(buf,'a',1000);

 @@ -69,56 +69,56 @@ int main(int argc, char *argv[])
     return(0);
+}
 #else
 #include <openssl/evp.h>
 #include <openssl/sha.h>
 #ifdef CHARSET_EBCDIC
 #include <openssl/ebcdic.h>
 #endif
 #define SHA_0 /* FIPS 180 */
 #undef  SHA_1 /* FIPS 180-1 */
-static char *test[]={
+static const char *test[]={
 	"abc",
 	"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
 	NULL,
 	};
 #ifdef SHA_0
-static char *ret[]={
+static const char *ret[]={
 	"0164b8a914cd2a5e74c4f7ff082c4d97f1edf880",
 	"d2516ee1acfa5baf33dfc1c471e438449ef134c8",
 	};
-static char *bigret=
+static const char *bigret=
 	"3232affa48628a26653b5aaa44541fd90d690603";
 #endif
 #ifdef SHA_1
-static char *ret[]={
+static const char *ret[]={
 	"a9993e364706816aba3e25717850c26c9cd0d89d",
 	"84983e441c3bd26ebaae4aa1f95129e5e54670f1",
 	};
-static char *bigret=
+static const char *bigret=
 	"34aa973cd4c4daa4f61eeb2bdbad27316534016f";
 #endif
 static char *pt(unsigned char *md);
 int main(int argc, char *argv[])
+	{
 	int i,err=0;
-	char **P,**R;
+	const char **P,**R;
 	static unsigned char buf[1000];
-	char *p,*r;
+	const char *p,*r;
 	EVP_MD_CTX c;
 	unsigned char md[SHA_DIGEST_LENGTH];
 #ifdef CHARSET_EBCDIC
 	ebcdic2ascii(test[0], test[0], strlen(test[0]));
 	ebcdic2ascii(test[1], test[1], strlen(test[1]));
 #endif
 	EVP_MD_CTX_init(&c);
 	P=test;
 	R=ret;
 	i=1;
 	while (*P != NULL)

	@@ -142,37 +142,37 @@ static int s_nbio=0;		@@ -142,37 +142,37 @@ static int s_nbio=0;
142		142
143	int thread_number=10;	143	int thread_number=10;
144	int number_of_loops=10;	144	int number_of_loops=10;
145	int reconnect=0;	145	int reconnect=0;
146	int cache_stats=0;	146	int cache_stats=0;
147		147
148	static const char rnd_seed[] = "string to make the random number generator think it has entropy";	148	static const char rnd_seed[] = "string to make the random number generator think it has entropy";
149		149
150	int doit(char *ctx[4]);	150	int doit(char *ctx[4]);
151	static void print_stats(FILE fp, SSL_CTX ctx)	151	static void print_stats(FILE fp, SSL_CTX ctx)
152	{	152	{
153	fprintf(fp,"%4ld items in the session cache\n",	153	fprintf(fp,"%4ld items in the session cache\n",
154	SSL_CTX_sess_number(ctx));	154	SSL_CTX_sess_number(ctx));
155	fprintf(fp,"%4d client connects (SSL_connect())\n",	155	fprintf(fp,"%4ld client connects (SSL_connect())\n",
156	SSL_CTX_sess_connect(ctx));	156	SSL_CTX_sess_connect(ctx));
157	fprintf(fp,"%4d client connects that finished\n",	157	fprintf(fp,"%4ld client connects that finished\n",
158	SSL_CTX_sess_connect_good(ctx));	158	SSL_CTX_sess_connect_good(ctx));
159	fprintf(fp,"%4d server connects (SSL_accept())\n",	159	fprintf(fp,"%4ld server connects (SSL_accept())\n",
160	SSL_CTX_sess_accept(ctx));	160	SSL_CTX_sess_accept(ctx));
161	fprintf(fp,"%4d server connects that finished\n",	161	fprintf(fp,"%4ld server connects that finished\n",
162	SSL_CTX_sess_accept_good(ctx));	162	SSL_CTX_sess_accept_good(ctx));
163	fprintf(fp,"%4d session cache hits\n",SSL_CTX_sess_hits(ctx));	163	fprintf(fp,"%4ld session cache hits\n",SSL_CTX_sess_hits(ctx));
164	fprintf(fp,"%4d session cache misses\n",SSL_CTX_sess_misses(ctx));	164	fprintf(fp,"%4ld session cache misses\n",SSL_CTX_sess_misses(ctx));
165	fprintf(fp,"%4d session cache timeouts\n",SSL_CTX_sess_timeouts(ctx));	165	fprintf(fp,"%4ld session cache timeouts\n",SSL_CTX_sess_timeouts(ctx));
166	}	166	}
167		167
168	static void sv_usage(void)	168	static void sv_usage(void)
169	{	169	{
170	fprintf(stderr,"usage: ssltest [args ...]\n");	170	fprintf(stderr,"usage: ssltest [args ...]\n");
171	fprintf(stderr,"\n");	171	fprintf(stderr,"\n");
172	fprintf(stderr," -server_auth - check server certificate\n");	172	fprintf(stderr," -server_auth - check server certificate\n");
173	fprintf(stderr," -client_auth - do client authentication\n");	173	fprintf(stderr," -client_auth - do client authentication\n");
174	fprintf(stderr," -v - more output\n");	174	fprintf(stderr," -v - more output\n");
175	fprintf(stderr," -CApath arg - PEM format directory of CA's\n");	175	fprintf(stderr," -CApath arg - PEM format directory of CA's\n");
176	fprintf(stderr," -CAfile arg - PEM format file of CA's\n");	176	fprintf(stderr," -CAfile arg - PEM format file of CA's\n");
177	fprintf(stderr," -threads arg - number of threads\n");	177	fprintf(stderr," -threads arg - number of threads\n");
178	fprintf(stderr," -loops arg - number of 'connections', per thread\n");	178	fprintf(stderr," -loops arg - number of 'connections', per thread\n");
	@@ -182,28 +182,28 @@ static void sv_usage(void)		@@ -182,28 +182,28 @@ static void sv_usage(void)
182	fprintf(stderr," -ccert arg - client certificate/key\n");	182	fprintf(stderr," -ccert arg - client certificate/key\n");
183	fprintf(stderr," -ssl3 - just SSLv3n\n");	183	fprintf(stderr," -ssl3 - just SSLv3n\n");
184	}	184	}
185		185
186	int main(int argc, char *argv[])	186	int main(int argc, char *argv[])
187	{	187	{
188	char CApath=NULL,CAfile=NULL;	188	char CApath=NULL,CAfile=NULL;
189	int badop=0;	189	int badop=0;
190	int ret=1;	190	int ret=1;
191	int client_auth=0;	191	int client_auth=0;
192	int server_auth=0;	192	int server_auth=0;
193	SSL_CTX *s_ctx=NULL;	193	SSL_CTX *s_ctx=NULL;
194	SSL_CTX *c_ctx=NULL;	194	SSL_CTX *c_ctx=NULL;
195	char *scert=TEST_SERVER_CERT;	195	const char *scert=TEST_SERVER_CERT;
196	char *ccert=TEST_CLIENT_CERT;	196	const char *ccert=TEST_CLIENT_CERT;
197	const SSL_METHOD *ssl_method=SSLv23_method();	197	const SSL_METHOD *ssl_method=SSLv23_method();
198		198
199	RAND_seed(rnd_seed, sizeof rnd_seed);	199	RAND_seed(rnd_seed, sizeof rnd_seed);
200		200
201	if (bio_err == NULL)	201	if (bio_err == NULL)
202	bio_err=BIO_new_fp(stderr,BIO_NOCLOSE);	202	bio_err=BIO_new_fp(stderr,BIO_NOCLOSE);
203	if (bio_stdout == NULL)	203	if (bio_stdout == NULL)
204	bio_stdout=BIO_new_fp(stdout,BIO_NOCLOSE);	204	bio_stdout=BIO_new_fp(stdout,BIO_NOCLOSE);
205	argc--;	205	argc--;
206	argv++;	206	argv++;
207		207
208	while (argc >= 1)	208	while (argc >= 1)
209	{	209	{
	@@ -357,27 +357,27 @@ end:		@@ -357,27 +357,27 @@ end:
357	}	357	}
358	SSL_CTX_free(s_ctx);	358	SSL_CTX_free(s_ctx);
359	fprintf(stderr,"done free\n");	359	fprintf(stderr,"done free\n");
360	}	360	}
361	exit(ret);	361	exit(ret);
362	return(0);	362	return(0);
363	}	363	}
364		364
365	#define W_READ 1	365	#define W_READ 1
366	#define W_WRITE 2	366	#define W_WRITE 2
367	#define C_DONE 1	367	#define C_DONE 1
368	#define S_DONE 2	368	#define S_DONE 2
369		369
370	int ndoit(SSL_CTX *ssl_ctx[2])	370	static int ndoit(SSL_CTX *ssl_ctx[2])
371	{	371	{
372	int i;	372	int i;
373	int ret;	373	int ret;
374	char *ctx[4];	374	char *ctx[4];
375		375
376	ctx[0]=(char *)ssl_ctx[0];	376	ctx[0]=(char *)ssl_ctx[0];
377	ctx[1]=(char *)ssl_ctx[1];	377	ctx[1]=(char *)ssl_ctx[1];
378		378
379	if (reconnect)	379	if (reconnect)
380	{	380	{
381	ctx[2]=(char *)SSL_new(ssl_ctx[0]);	381	ctx[2]=(char *)SSL_new(ssl_ctx[0]);
382	ctx[3]=(char *)SSL_new(ssl_ctx[1]);	382	ctx[3]=(char *)SSL_new(ssl_ctx[1]);
383	}	383	}
	@@ -821,28 +821,28 @@ static long *lock_count;		@@ -821,28 +821,28 @@ static long *lock_count;
821	void thread_setup(void)	821	void thread_setup(void)
822	{	822	{
823	int i;	823	int i;
824		824
825	lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(mutex_t));	825	lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(mutex_t));
826	lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));	826	lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
827	for (i=0; i<CRYPTO_num_locks(); i++)	827	for (i=0; i<CRYPTO_num_locks(); i++)
828	{	828	{
829	lock_count[i]=0;	829	lock_count[i]=0;
830	/* rwlock_init(&(lock_cs[i]),USYNC_THREAD,NULL); */	830	/* rwlock_init(&(lock_cs[i]),USYNC_THREAD,NULL); */
831	mutex_init(&(lock_cs[i]),USYNC_THREAD,NULL);	831	mutex_init(&(lock_cs[i]),USYNC_THREAD,NULL);
832	}	832	}
833		833
834	CRYPTO_set_id_callback((unsigned long (*)())solaris_thread_id);	834	CRYPTO_set_id_callback((unsigned long (*)(void))solaris_thread_id);
835	CRYPTO_set_locking_callback((void (*)())solaris_locking_callback);	835	CRYPTO_set_locking_callback((void (*)(void))solaris_locking_callback);
836	}	836	}
837		837
838	void thread_cleanup(void)	838	void thread_cleanup(void)
839	{	839	{
840	int i;	840	int i;
841		841
842	CRYPTO_set_locking_callback(NULL);	842	CRYPTO_set_locking_callback(NULL);
843		843
844	fprintf(stderr,"cleanup\n");	844	fprintf(stderr,"cleanup\n");
845		845
846	for (i=0; i<CRYPTO_num_locks(); i++)	846	for (i=0; i<CRYPTO_num_locks(); i++)
847	{	847	{
848	/* rwlock_destroy(&(lock_cs[i])); */	848	/* rwlock_destroy(&(lock_cs[i])); */
	@@ -943,28 +943,28 @@ void thread_setup(void)		@@ -943,28 +943,28 @@ void thread_setup(void)
943	usconfig(CONF_STHREADIOOFF);	943	usconfig(CONF_STHREADIOOFF);
944	usconfig(CONF_STHREADMALLOCOFF);	944	usconfig(CONF_STHREADMALLOCOFF);
945	usconfig(CONF_INITUSERS,100);	945	usconfig(CONF_INITUSERS,100);
946	usconfig(CONF_LOCKTYPE,US_DEBUGPLUS);	946	usconfig(CONF_LOCKTYPE,US_DEBUGPLUS);
947	arena=usinit(filename);	947	arena=usinit(filename);
948	unlink(filename);	948	unlink(filename);
949		949
950	lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(usema_t *));	950	lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(usema_t *));
951	for (i=0; i<CRYPTO_num_locks(); i++)	951	for (i=0; i<CRYPTO_num_locks(); i++)
952	{	952	{
953	lock_cs[i]=usnewsema(arena,1);	953	lock_cs[i]=usnewsema(arena,1);
954	}	954	}
955		955
956	CRYPTO_set_id_callback((unsigned long (*)())irix_thread_id);	956	CRYPTO_set_id_callback((unsigned long (*)(void))irix_thread_id);
957	CRYPTO_set_locking_callback((void (*)())irix_locking_callback);	957	CRYPTO_set_locking_callback((void (*)(void))irix_locking_callback);
958	}	958	}
959		959
960	void thread_cleanup(void)	960	void thread_cleanup(void)
961	{	961	{
962	int i;	962	int i;
963		963
964	CRYPTO_set_locking_callback(NULL);	964	CRYPTO_set_locking_callback(NULL);
965	for (i=0; i<CRYPTO_num_locks(); i++)	965	for (i=0; i<CRYPTO_num_locks(); i++)
966	{	966	{
967	char buf[10];	967	char buf[10];
968		968
969	snprintf(buf, sizeof(buf), "%2d:",i);	969	snprintf(buf, sizeof(buf), "%2d:",i);
970	usdumpsema(lock_cs[i],stdout,buf);	970	usdumpsema(lock_cs[i],stdout,buf);
	@@ -1028,28 +1028,28 @@ static long *lock_count;		@@ -1028,28 +1028,28 @@ static long *lock_count;
1028		1028
1029	void thread_setup(void)	1029	void thread_setup(void)
1030	{	1030	{
1031	int i;	1031	int i;
1032		1032
1033	lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));	1033	lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
1034	lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));	1034	lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
1035	for (i=0; i<CRYPTO_num_locks(); i++)	1035	for (i=0; i<CRYPTO_num_locks(); i++)
1036	{	1036	{
1037	lock_count[i]=0;	1037	lock_count[i]=0;
1038	pthread_mutex_init(&(lock_cs[i]),NULL);	1038	pthread_mutex_init(&(lock_cs[i]),NULL);
1039	}	1039	}
1040		1040
1041	CRYPTO_set_id_callback((unsigned long (*)())pthreads_thread_id);	1041	CRYPTO_set_id_callback((unsigned long (*)(void))pthreads_thread_id);
1042	CRYPTO_set_locking_callback((void (*)())pthreads_locking_callback);	1042	CRYPTO_set_locking_callback((void ()(int, int, const char , int))pthreads_locking_callback);
1043	}	1043	}
1044		1044
1045	void thread_cleanup(void)	1045	void thread_cleanup(void)
1046	{	1046	{
1047	int i;	1047	int i;
1048		1048
1049	CRYPTO_set_locking_callback(NULL);	1049	CRYPTO_set_locking_callback(NULL);
1050	fprintf(stderr,"cleanup\n");	1050	fprintf(stderr,"cleanup\n");
1051	for (i=0; i<CRYPTO_num_locks(); i++)	1051	for (i=0; i<CRYPTO_num_locks(); i++)
1052	{	1052	{
1053	pthread_mutex_destroy(&(lock_cs[i]));	1053	pthread_mutex_destroy(&(lock_cs[i]));
1054	fprintf(stderr,"%8ld:%s\n",lock_count[i],	1054	fprintf(stderr,"%8ld:%s\n",lock_count[i],
1055	CRYPTO_get_lock_name(i));	1055	CRYPTO_get_lock_name(i));
	@@ -1091,27 +1091,27 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX		@@ -1091,27 +1091,27 @@ void do_threads(SSL_CTX *s_ctx, SSL_CTX
1091	SSL_CTX *ssl_ctx[2];	1091	SSL_CTX *ssl_ctx[2];
1092	pthread_t thread_ctx[MAX_THREAD_NUMBER];	1092	pthread_t thread_ctx[MAX_THREAD_NUMBER];
1093	int i;	1093	int i;
1094		1094
1095	ssl_ctx[0]=s_ctx;	1095	ssl_ctx[0]=s_ctx;
1096	ssl_ctx[1]=c_ctx;	1096	ssl_ctx[1]=c_ctx;
1097		1097
1098	/*	1098	/*
1099	thr_setconcurrency(thread_number);	1099	thr_setconcurrency(thread_number);
1100	*/	1100	*/
1101	for (i=0; i<thread_number; i++)	1101	for (i=0; i<thread_number; i++)
1102	{	1102	{
1103	pthread_create(&(thread_ctx[i]), NULL,	1103	pthread_create(&(thread_ctx[i]), NULL,
1104	(void ()())ndoit, (void *)ssl_ctx);	1104	(void ()(void ))ndoit, (void )ssl_ctx);
1105	}	1105	}
1106		1106
1107	printf("reaping\n");	1107	printf("reaping\n");
1108	for (i=0; i<thread_number; i++)	1108	for (i=0; i<thread_number; i++)
1109	{	1109	{
1110	pthread_join(thread_ctx[i],NULL);	1110	pthread_join(thread_ctx[i],NULL);
1111	}	1111	}
1112		1112
1113	printf("pthreads threads done (%d,%d)\n",	1113	printf("pthreads threads done (%d,%d)\n",
1114	s_ctx->references,c_ctx->references);	1114	s_ctx->references,c_ctx->references);
1115	}	1115	}
1116		1116
1117	unsigned long pthreads_thread_id(void)	1117	unsigned long pthreads_thread_id(void)
	@@ -1132,28 +1132,28 @@ void thread_setup(void)		@@ -1132,28 +1132,28 @@ void thread_setup(void)
1132	{	1132	{
1133	int i;	1133	int i;
1134		1134
1135	lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(MPKMutex));	1135	lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(MPKMutex));
1136	lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));	1136	lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
1137	for (i=0; i<CRYPTO_num_locks(); i++)	1137	for (i=0; i<CRYPTO_num_locks(); i++)
1138	{	1138	{
1139	lock_count[i]=0;	1139	lock_count[i]=0;
1140	lock_cs[i]=MPKMutexAlloc("OpenSSL mutex");	1140	lock_cs[i]=MPKMutexAlloc("OpenSSL mutex");
1141	}	1141	}
1142		1142
1143	ThreadSem = MPKSemaphoreAlloc("OpenSSL mttest semaphore", 0 );	1143	ThreadSem = MPKSemaphoreAlloc("OpenSSL mttest semaphore", 0 );
1144		1144
1145	CRYPTO_set_id_callback((unsigned long (*)())netware_thread_id);	1145	CRYPTO_set_id_callback((unsigned long (*)(void))netware_thread_id);
1146	CRYPTO_set_locking_callback((void (*)())netware_locking_callback);	1146	CRYPTO_set_locking_callback((void (*)(void))netware_locking_callback);
1147	}	1147	}
1148		1148
1149	void thread_cleanup(void)	1149	void thread_cleanup(void)
1150	{	1150	{
1151	int i;	1151	int i;
1152		1152
1153	CRYPTO_set_locking_callback(NULL);	1153	CRYPTO_set_locking_callback(NULL);
1154		1154
1155	fprintf(stdout,"thread_cleanup\n");	1155	fprintf(stdout,"thread_cleanup\n");
1156		1156
1157	for (i=0; i<CRYPTO_num_locks(); i++)	1157	for (i=0; i<CRYPTO_num_locks(); i++)
1158	{	1158	{
1159	MPKMutexFree(lock_cs[i]);	1159	MPKMutexFree(lock_cs[i]);
	@@ -1221,27 +1221,27 @@ static long* lock_count;		@@ -1221,27 +1221,27 @@ static long* lock_count;
1221		1221
1222	void thread_setup(void)	1222	void thread_setup(void)
1223	{	1223	{
1224	int i;	1224	int i;
1225		1225
1226	lock_cs=(BLocker*)OPENSSL_malloc(CRYPTO_num_locks() sizeof(BLocker*));	1226	lock_cs=(BLocker*)OPENSSL_malloc(CRYPTO_num_locks() sizeof(BLocker*));
1227	lock_count=(long)OPENSSL_malloc(CRYPTO_num_locks() sizeof(long));	1227	lock_count=(long)OPENSSL_malloc(CRYPTO_num_locks() sizeof(long));
1228	for (i=0; i<CRYPTO_num_locks(); i++)	1228	for (i=0; i<CRYPTO_num_locks(); i++)
1229	{	1229	{
1230	lock_count[i]=0;	1230	lock_count[i]=0;
1231	lock_cs[i] = new BLocker(CRYPTO_get_lock_name(i));	1231	lock_cs[i] = new BLocker(CRYPTO_get_lock_name(i));
1232	}	1232	}
1233		1233
1234	CRYPTO_set_id_callback((unsigned long (*)())beos_thread_id);	1234	CRYPTO_set_id_callback((unsigned long (*)(void))beos_thread_id);
1235	CRYPTO_set_locking_callback(beos_locking_callback);	1235	CRYPTO_set_locking_callback(beos_locking_callback);
1236	}	1236	}
1237		1237
1238	void thread_cleanup(void)	1238	void thread_cleanup(void)
1239	{	1239	{
1240	int i;	1240	int i;
1241		1241
1242	CRYPTO_set_locking_callback(NULL);	1242	CRYPTO_set_locking_callback(NULL);
1243	fprintf(stderr,"cleanup\n");	1243	fprintf(stderr,"cleanup\n");
1244	for (i=0; i<CRYPTO_num_locks(); i++)	1244	for (i=0; i<CRYPTO_num_locks(); i++)
1245	{	1245	{
1246	delete lock_cs[i];	1246	delete lock_cs[i];
1247	fprintf(stderr,"%8ld:%s\n",lock_count[i],	1247	fprintf(stderr,"%8ld:%s\n",lock_count[i],

 @@ -59,27 +59,28 @@
 /* Simple program to check the ext_dat.h is correct and print out
  * problems if it is not.
  */
 #include <stdio.h>
 #include <openssl/x509v3.h>
 #include "ext_dat.h"
 int
 main(void)
+{
-	int i, prev = -1, bad = 0;
+	int prev = -1, bad = 0;
 	unsigned int i;
 	const X509V3_EXT_METHOD **tmp;
 	i = sizeof(standard_exts) / sizeof(X509V3_EXT_METHOD *);
 	if(i != STANDARD_EXTENSION_COUNT)
 		fprintf(stderr, "Extension number invalid expecting %d\n", i);
 	tmp = standard_exts;
 	for(i = 0; i < STANDARD_EXTENSION_COUNT; i++, tmp++) {
 		if((*tmp)->ext_nid < prev) bad = 1;
 		prev = (*tmp)->ext_nid;
+	}
 	if(bad) {
 		tmp = standard_exts;
 		fprintf(stderr, "Extensions out of order!\n");