First pass for KNF.

2 files changed, 1235 insertions, 1294 deletions

diff --git a/lib/libssl/src/apps/apps.c b/lib/libssl/src/apps/apps.c
index 4d5e3f172af..47347678e5b 100644
--- a/lib/libssl/src/apps/apps.c
+++ b/lib/libssl/src/apps/apps.c
@@ -5,21 +5,21 @@
  * This package is an SSL implementation written
  * by Eric Young (eay@cryptsoft.com).
  * The implementation was written so as to conform with Netscapes SSL.
- * 
+ *
  * This library is free for commercial and non-commercial use as long as
  * the following conditions are aheared to.  The following conditions
  * apply to all code found in this distribution, be it the RC4, RSA,
  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  * included with this distribution is covered by the same copyright terms
  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- * 
+ *
  * Copyright remains Eric Young's, and as such any Copyright notices in
  * the code are not to be removed.
  * If this package is used in a product, Eric Young should be given attribution
  * as the author of the parts of the library used.
  * This can be in the form of a textual message at program startup or
  * in documentation (online or textual) provided with the package.
- * 
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ -34,10 +34,10 @@
  *     Eric Young (eay@cryptsoft.com)"
  *    The word 'cryptographic' can be left out if the rouines from the library
  *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from 
+ * 4. If you include any Windows specific code (or a derivative thereof) from
  *    the apps directory (application code) you must include an acknowledgement:
  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- * 
+ *
  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
@@ -49,7 +49,7 @@
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
- * 
+ *
  * The licence and distribution terms for any publically available version or
  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  * copied and put under another distribution licence
@@ -63,7 +63,7 @@
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer. 
+ *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
@@ -159,256 +159,258 @@ static int set_multi_opts(unsigned long *flags, const char *arg, const NAME_EX_T
 
 #if !defined(OPENSSL_NO_RC4) && !defined(OPENSSL_NO_RSA)
 /* Looks like this stuff is worth moving into separate function */
-static EVP_PKEY *
-load_netscape_key(BIO *err, BIO *key, const char *file,
-		const char *key_descrip, int format);
+static EVP_PKEY *load_netscape_key(BIO *err, BIO *key, const char *file,
+    const char *key_descrip, int format);
 #endif
 
 int app_init(long mesgwin);
 #ifdef undef /* never finished - probably never will be :-) */
-int args_from_file(char *file, int *argc, char **argv[])
-	{
+int
+args_from_file(char *file, int *argc, char **argv[])
+{
 	FILE *fp;
-	int num,i;
+	int num, i;
 	unsigned int len;
-	static char *buf=NULL;
-	static char **arg=NULL;
+	static char *buf = NULL;
+	static char **arg = NULL;
 	char *p;
 
-	fp=fopen(file,"r");
+	fp = fopen(file, "r");
 	if (fp == NULL)
-		return(0);
+		return (0);
 
-	if (fseek(fp,0,SEEK_END)==0)
-		len=ftell(fp), rewind(fp);
-	else	len=-1;
-	if (len<=0)
-		{
+	if (fseek(fp, 0, SEEK_END) == 0)
+		len = ftell(fp), rewind(fp);
+	else
+		len = -1;
+	if (len <= 0) {
 		fclose(fp);
-		return(0);
-		}
+		return (0);
+	}
 
-	*argc=0;
-	*argv=NULL;
+	*argc = 0;
+	*argv = NULL;
 
 	if (buf != NULL) OPENSSL_free(buf);
-	buf=(char *)OPENSSL_malloc(len+1);
-	if (buf == NULL) return(0);
+		buf = (char *)OPENSSL_malloc(len + 1);
+	if (buf == NULL)
+		return (0);
 
-	len=fread(buf,1,len,fp);
-	if (len <= 1) return(0);
-	buf[len]='\0';
+	len = fread(buf, 1, len, fp);
+	if (len <= 1) return (0);
+		buf[len] = '\0';
 
-	i=0;
-	for (p=buf; *p; p++)
-		if (*p == '\n') i++;
+	i = 0;
+	for (p = buf; *p; p++)
+		if (*p == '\n')
+			i++;
 	if (arg != NULL) OPENSSL_free(arg);
-	arg=(char **)OPENSSL_malloc(sizeof(char *)*(i*2));
+		arg = (char **)OPENSSL_malloc(sizeof(char *)*(i*2));
 
-	*argv=arg;
-	num=0;
-	p=buf;
-	for (;;)
-		{
-		if (!*p) break;
+	*argv = arg;
+	num = 0;
+	p = buf;
+	for (;;) {
+		if (!*p)
+			break;
 		if (*p == '#') /* comment line */
-			{
-			while (*p && (*p != '\n')) p++;
+		{
+			while (*p && (*p != '\n'))
+				p++;
 			continue;
-			}
+		}
 		/* else we have a line */
-		*(arg++)=p;
+		*(arg++) = p;
 		num++;
 		while (*p && ((*p != ' ') && (*p != '\t') && (*p != '\n')))
 			p++;
-		if (!*p) break;
-		if (*p == '\n')
-			{
-			*(p++)='\0';
+		if (!*p)
+			break;
+		if (*p == '\n') {
+			*(p++) = '\0';
 			continue;
-			}
+		}
 		/* else it is a tab or space */
 		p++;
 		while (*p && ((*p == ' ') || (*p == '\t') || (*p == '\n')))
 			p++;
-		if (!*p) break;
-		if (*p == '\n')
-			{
+		if (!*p)
+			break;
+		if (*p == '\n') {
 			p++;
 			continue;
-			}
-		*(arg++)=p++;
+		}
+		*(arg++) = p++;
 		num++;
-		while (*p && (*p != '\n')) p++;
-		if (!*p) break;
+		while (*p && (*p != '\n'))
+			p++;
+		if (!*p)
+			break;
 		/* else *p == '\n' */
-		*(p++)='\0';
-		}
-	*argc=num;
-	return(1);
+		*(p++) = '\0';
 	}
+	*argc = num;
+	return (1);
+}
 #endif
 
-int str2fmt(char *s)
-	{
+int
+str2fmt(char *s)
+{
 	if (s == NULL)
 		return FORMAT_UNDEF;
-	if 	((*s == 'D') || (*s == 'd'))
-		return(FORMAT_ASN1);
+	if ((*s == 'D') || (*s == 'd'))
+		return (FORMAT_ASN1);
 	else if ((*s == 'T') || (*s == 't'))
-		return(FORMAT_TEXT);
-  	else if ((*s == 'N') || (*s == 'n'))
-  		return(FORMAT_NETSCAPE);
-  	else if ((*s == 'S') || (*s == 's'))
-  		return(FORMAT_SMIME);
- 	else if ((*s == 'M') || (*s == 'm'))
- 		return(FORMAT_MSBLOB);
-	else if ((*s == '1')
-		|| (strcmp(s,"PKCS12") == 0) || (strcmp(s,"pkcs12") == 0)
-		|| (strcmp(s,"P12") == 0) || (strcmp(s,"p12") == 0))
-		return(FORMAT_PKCS12);
+		return (FORMAT_TEXT);
+	else if ((*s == 'N') || (*s == 'n'))
+		return (FORMAT_NETSCAPE);
+	else if ((*s == 'S') || (*s == 's'))
+		return (FORMAT_SMIME);
+	else if ((*s == 'M') || (*s == 'm'))
+		return (FORMAT_MSBLOB);
+	else if ((*s == '1') ||
+	    (strcmp(s, "PKCS12") == 0) || (strcmp(s, "pkcs12") == 0) ||
+	    (strcmp(s, "P12") == 0) || (strcmp(s, "p12") == 0))
+		return (FORMAT_PKCS12);
 	else if ((*s == 'E') || (*s == 'e'))
-		return(FORMAT_ENGINE);
-	else if ((*s == 'P') || (*s == 'p'))
- 		{
- 		if (s[1] == 'V' || s[1] == 'v')
- 			return FORMAT_PVK;
- 		else
-  			return(FORMAT_PEM);
- 		}
-	else
-		return(FORMAT_UNDEF);
-	}
+		return (FORMAT_ENGINE);
+	else if ((*s == 'P') || (*s == 'p')) {
+		if (s[1] == 'V' || s[1] == 'v')
+			return FORMAT_PVK;
+		else
+			return (FORMAT_PEM);
+	} else
+		return (FORMAT_UNDEF);
+}
 
 #if defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN16) || defined(OPENSSL_SYS_NETWARE)
-void program_name(char *in, char *out, int size)
-	{
-	int i,n;
-	char *p=NULL;
+void
+program_name(char *in, char *out, int size)
+{
+	int i, n;
+	char *p = NULL;
 
-	n=strlen(in);
+	n = strlen(in);
 	/* find the last '/', '\' or ':' */
-	for (i=n-1; i>0; i--)
-		{
-		if ((in[i] == '/') || (in[i] == '\\') || (in[i] == ':'))
-			{
-			p= &(in[i+1]);
+	for (i = n - 1; i > 0; i--) {
+		if ((in[i] == '/') || (in[i] == '\\') || (in[i] == ':')) {
+			p = &(in[i + 1]);
 			break;
-			}
 		}
+	}
 	if (p == NULL)
-		p=in;
-	n=strlen(p);
+		p = in;
+	n = strlen(p);
 
 	/* strip off trailing .exe if present. */
-	if ((n > 4) && (p[n-4] == '.') &&
-		((p[n-3] == 'e') || (p[n-3] == 'E')) &&
-		((p[n-2] == 'x') || (p[n-2] == 'X')) &&
-		((p[n-1] == 'e') || (p[n-1] == 'E')))
-		n-=4;
+	if ((n > 4) && (p[n - 4] == '.') &&
+	    ((p[n - 3] == 'e') || (p[n - 3] == 'E')) &&
+	    ((p[n - 2] == 'x') || (p[n - 2] == 'X')) &&
+	    ((p[n - 1] == 'e') || (p[n - 1] == 'E')))
+		n -= 4;
 
-	if (n > size-1)
-		n=size-1;
+	if (n > size - 1)
+		n = size - 1;
 
-	for (i=0; i<n; i++)
-		{
+	for (i = 0; i < n; i++) {
 		if ((p[i] >= 'A') && (p[i] <= 'Z'))
-			out[i]=p[i]-'A'+'a';
+			out[i] = p[i] - 'A' + 'a';
 		else
-			out[i]=p[i];
-		}
-	out[n]='\0';
+			out[i] = p[i];
 	}
+	out[n] = '\0';
+}
 #else
-void program_name(char *in, char *out, int size)
-	{
+void
+program_name(char *in, char *out, int size)
+{
 	char *p;
 
-	p=strrchr(in,'/');
+	p = strrchr(in, '/');
 	if (p != NULL)
 		p++;
 	else
-		p=in;
-	BUF_strlcpy(out,p,size);
-	}
+		p = in;
+	BUF_strlcpy(out, p, size);
+}
 #endif
 
-int chopup_args(ARGS *arg, char *buf, int *argc, char **argv[])
-	{
-	int num,i;
+int
+chopup_args(ARGS *arg, char *buf, int *argc, char **argv[])
+{
+	int num, i;
 	char *p;
 
-	*argc=0;
-	*argv=NULL;
+	*argc = 0;
+	*argv = NULL;
 
-	i=0;
-	if (arg->count == 0)
-		{
-		arg->count=20;
-		arg->data=(char **)OPENSSL_malloc(sizeof(char *)*arg->count);
-		}
-	for (i=0; i<arg->count; i++)
-		arg->data[i]=NULL;
+	i = 0;
+	if (arg->count == 0) {
+		arg->count = 20;
+		arg->data = (char **)OPENSSL_malloc(sizeof(char *)*arg->count);
+	}
+	for (i = 0; i < arg->count; i++)
+		arg->data[i] = NULL;
 
-	num=0;
-	p=buf;
-	for (;;)
-		{
+	num = 0;
+	p = buf;
+	for (;;) {
 		/* first scan over white space */
-		if (!*p) break;
+		if (!*p)
+			break;
 		while (*p && ((*p == ' ') || (*p == '\t') || (*p == '\n')))
 			p++;
-		if (!*p) break;
+		if (!*p)
+			break;
 
 		/* The start of something good :-) */
-		if (num >= arg->count)
-			{
+		if (num >= arg->count) {
 			char **tmp_p;
 			int tlen = arg->count + 20;
 			tmp_p = (char **)OPENSSL_realloc(arg->data,
-				sizeof(char *)*tlen);
+			    sizeof(char *)*tlen);
 			if (tmp_p == NULL)
 				return 0;
-			arg->data  = tmp_p;
+			arg->data = tmp_p;
 			arg->count = tlen;
 			/* initialize newly allocated data */
 			for (i = num; i < arg->count; i++)
 				arg->data[i] = NULL;
-			}
-		arg->data[num++]=p;
+		}
+		arg->data[num++] = p;
 
 		/* now look for the end of this */
 		if ((*p == '\'') || (*p == '\"')) /* scan for closing quote */
-			{
+		{
 			i= *(p++);
 			arg->data[num-1]++; /* jump over quote */
 			while (*p && (*p != i))
 				p++;
-			*p='\0';
-			}
-		else
-			{
+			*p = '\0';
+		} else {
 			while (*p && ((*p != ' ') &&
-				(*p != '\t') && (*p != '\n')))
+			    (*p != '\t') && (*p != '\n')))
 				p++;
 
 			if (*p == '\0')
 				p--;
 			else
-				*p='\0';
-			}
-		p++;
+				*p = '\0';
 		}
-	*argc=num;
-	*argv=arg->data;
-	return(1);
+		p++;
 	}
+	*argc = num;
+	*argv = arg->data;
+	return (1);
+}
 
 #ifndef APP_INIT
-int app_init(long mesgwin)
-	{
-	return(1);
-	}
+int
+app_init(long mesgwin)
+{
+	return (1);
+}
 #endif
 
 
@@ -416,209 +418,212 @@ int dump_cert_text (BIO *out, X509 *x)
 {
 	char *p;
 
-	p=X509_NAME_oneline(X509_get_subject_name(x),NULL,0);
-	BIO_puts(out,"subject=");
-	BIO_puts(out,p);
+	p = X509_NAME_oneline(X509_get_subject_name(x), NULL, 0);
+	BIO_puts(out, "subject=");
+	BIO_puts(out, p);
 	OPENSSL_free(p);
 
-	p=X509_NAME_oneline(X509_get_issuer_name(x),NULL,0);
-	BIO_puts(out,"\nissuer=");
-	BIO_puts(out,p);
-	BIO_puts(out,"\n");
+	p = X509_NAME_oneline(X509_get_issuer_name(x), NULL, 0);
+	BIO_puts(out, "\nissuer=");
+	BIO_puts(out, p);
+	BIO_puts(out, "\n");
 	OPENSSL_free(p);
 
 	return 0;
 }
 
-static int ui_open(UI *ui)
-	{
+static int
+ui_open(UI *ui)
+{
 	return UI_method_get_opener(UI_OpenSSL())(ui);
-	}
-static int ui_read(UI *ui, UI_STRING *uis)
-	{
-	if (UI_get_input_flags(uis) & UI_INPUT_FLAG_DEFAULT_PWD
-		&& UI_get0_user_data(ui))
-		{
-		switch(UI_get_string_type(uis))
-			{
+}
+
+static int
+ui_read(UI *ui, UI_STRING *uis)
+{
+	if (UI_get_input_flags(uis) & UI_INPUT_FLAG_DEFAULT_PWD &&
+	    UI_get0_user_data(ui)) {
+		switch (UI_get_string_type(uis)) {
 		case UIT_PROMPT:
 		case UIT_VERIFY:
 			{
-			const char *password =
+				const char *password =
 				((PW_CB_DATA *)UI_get0_user_data(ui))->password;
-			if (password && password[0] != '\0')
-				{
-				UI_set_result(ui, uis, password);
-				return 1;
+				if (password && password[0] != '\0') {
+					UI_set_result(ui, uis, password);
+					return 1;
 				}
 			}
 		default:
 			break;
-			}
 		}
-	return UI_method_get_reader(UI_OpenSSL())(ui, uis);
 	}
-static int ui_write(UI *ui, UI_STRING *uis)
-	{
-	if (UI_get_input_flags(uis) & UI_INPUT_FLAG_DEFAULT_PWD
-		&& UI_get0_user_data(ui))
-		{
-		switch(UI_get_string_type(uis))
-			{
+	return UI_method_get_reader(UI_OpenSSL())(ui, uis);
+}
+
+static int
+ui_write(UI *ui, UI_STRING *uis)
+{
+	if (UI_get_input_flags(uis) & UI_INPUT_FLAG_DEFAULT_PWD &&
+	    UI_get0_user_data(ui)) {
+		switch (UI_get_string_type(uis)) {
 		case UIT_PROMPT:
 		case UIT_VERIFY:
 			{
-			const char *password =
-				((PW_CB_DATA *)UI_get0_user_data(ui))->password;
-			if (password && password[0] != '\0')
-				return 1;
+				const char *password =
+				    ((PW_CB_DATA *)UI_get0_user_data(ui))->password;
+				if (password && password[0] != '\0')
+					return 1;
 			}
 		default:
 			break;
-			}
 		}
-	return UI_method_get_writer(UI_OpenSSL())(ui, uis);
 	}
-static int ui_close(UI *ui)
-	{
+	return UI_method_get_writer(UI_OpenSSL())(ui, uis);
+}
+
+static int
+ui_close(UI *ui)
+{
 	return UI_method_get_closer(UI_OpenSSL())(ui);
-	}
-int setup_ui_method(void)
-	{
+}
+
+int
+setup_ui_method(void)
+{
 	ui_method = UI_create_method("OpenSSL application user interface");
 	UI_method_set_opener(ui_method, ui_open);
 	UI_method_set_reader(ui_method, ui_read);
 	UI_method_set_writer(ui_method, ui_write);
 	UI_method_set_closer(ui_method, ui_close);
 	return 0;
-	}
-void destroy_ui_method(void)
-	{
-	if(ui_method)
-		{
+}
+
+void
+destroy_ui_method(void)
+{
+	if (ui_method) {
 		UI_destroy_method(ui_method);
 		ui_method = NULL;
-		}
 	}
-int password_callback(char *buf, int bufsiz, int verify,
-	PW_CB_DATA *cb_tmp)
-	{
+}
+
+int
+password_callback(char *buf, int bufsiz, int verify,
+    PW_CB_DATA *cb_tmp)
+{
 	UI *ui = NULL;
 	int res = 0;
 	const char *prompt_info = NULL;
 	const char *password = NULL;
 	PW_CB_DATA *cb_data = (PW_CB_DATA *)cb_tmp;
 
-	if (cb_data)
-		{
+	if (cb_data) {
 		if (cb_data->password)
 			password = cb_data->password;
 		if (cb_data->prompt_info)
 			prompt_info = cb_data->prompt_info;
-		}
+	}
 
-	if (password)
-		{
+	if (password) {
 		res = strlen(password);
 		if (res > bufsiz)
 			res = bufsiz;
 		memcpy(buf, password, res);
 		return res;
-		}
+	}
 
 	ui = UI_new_method(ui_method);
-	if (ui)
-		{
+	if (ui) {
 		int ok = 0;
 		char *buff = NULL;
 		int ui_flags = 0;
 		char *prompt = NULL;
 
 		prompt = UI_construct_prompt(ui, "pass phrase",
-			prompt_info);
+		    prompt_info);
 
 		ui_flags |= UI_INPUT_FLAG_DEFAULT_PWD;
 		UI_ctrl(ui, UI_CTRL_PRINT_ERRORS, 1, 0, 0);
 
 		if (ok >= 0)
-			ok = UI_add_input_string(ui,prompt,ui_flags,buf,
-				PW_MIN_LENGTH,bufsiz-1);
-		if (ok >= 0 && verify)
-			{
+			ok = UI_add_input_string(ui, prompt, ui_flags, buf,
+			    PW_MIN_LENGTH, bufsiz - 1);
+		if (ok >= 0 && verify) {
 			buff = (char *)OPENSSL_malloc(bufsiz);
-			ok = UI_add_verify_string(ui,prompt,ui_flags,buff,
-				PW_MIN_LENGTH,bufsiz-1, buf);
-			}
+			ok = UI_add_verify_string(ui, prompt, ui_flags, buff,
+			    PW_MIN_LENGTH, bufsiz - 1, buf);
+		}
 		if (ok >= 0)
-			do
-				{
+			do {
 				ok = UI_process(ui);
-				}
-			while (ok < 0 && UI_ctrl(ui, UI_CTRL_IS_REDOABLE, 0, 0, 0));
+			} while (ok < 0 &&
+			    UI_ctrl(ui, UI_CTRL_IS_REDOABLE, 0, 0, 0));
 
-		if (buff)
-			{
-			OPENSSL_cleanse(buff,(unsigned int)bufsiz);
+		if (buff) {
+			OPENSSL_cleanse(buff, (unsigned int)bufsiz);
 			OPENSSL_free(buff);
-			}
+		}
 
 		if (ok >= 0)
 			res = strlen(buf);
-		if (ok == -1)
-			{
+		if (ok == -1) {
 			BIO_printf(bio_err, "User interface error\n");
 			ERR_print_errors(bio_err);
-			OPENSSL_cleanse(buf,(unsigned int)bufsiz);
+			OPENSSL_cleanse(buf, (unsigned int)bufsiz);
 			res = 0;
-			}
-		if (ok == -2)
-			{
-			BIO_printf(bio_err,"aborted!\n");
-			OPENSSL_cleanse(buf,(unsigned int)bufsiz);
+		}
+		if (ok == -2) {
+			BIO_printf(bio_err, "aborted!\n");
+			OPENSSL_cleanse(buf, (unsigned int)bufsiz);
 			res = 0;
-			}
+		}
 		UI_free(ui);
 		OPENSSL_free(prompt);
-		}
-	return res;
 	}
+	return res;
+}
 
 static char *app_get_pass(BIO *err, char *arg, int keepbio);
 
-int app_passwd(BIO *err, char *arg1, char *arg2, char **pass1, char **pass2)
+int
+app_passwd(BIO *err, char *arg1, char *arg2, char **pass1, char **pass2)
 {
 	int same;
-	if(!arg2 || !arg1 || strcmp(arg1, arg2)) same = 0;
-	else same = 1;
-	if(arg1) {
+	if (!arg2 || !arg1 || strcmp(arg1, arg2)) same = 0;
+		else
+		same = 1;
+	if (arg1) {
 		*pass1 = app_get_pass(err, arg1, same);
-		if(!*pass1) return 0;
-	} else if(pass1) *pass1 = NULL;
-	if(arg2) {
+		if (!*pass1) return 0;
+		} else if (pass1) *pass1 = NULL;
+			if (arg2) {
 		*pass2 = app_get_pass(err, arg2, same ? 2 : 0);
-		if(!*pass2) return 0;
-	} else if(pass2) *pass2 = NULL;
-	return 1;
+		if (!*pass2) return 0;
+		} else if (pass2) *pass2 = NULL;
+		return 1;
 }
 
-static char *app_get_pass(BIO *err, char *arg, int keepbio)
+static char *
+app_get_pass(BIO *err, char *arg, int keepbio)
 {
 	char *tmp, tpass[APP_PASS_LEN];
 	static BIO *pwdbio = NULL;
 	int i;
-	if(!strncmp(arg, "pass:", 5)) return BUF_strdup(arg + 5);
-	if(!strncmp(arg, "env:", 4)) {
+	if (!strncmp(arg, "pass:", 5))
+		return BUF_strdup(arg + 5);
+	if (!strncmp(arg, "env:", 4)) {
 		tmp = getenv(arg + 4);
-		if(!tmp) {
+		if (!tmp) {
 			BIO_printf(err, "Can't read environment variable %s\n", arg + 4);
 			return NULL;
 		}
 		return BUF_strdup(tmp);
 	}
-	if(!keepbio || !pwdbio) {
-		if(!strncmp(arg, "file:", 5)) {
+	if (!keepbio || !pwdbio) {
+		if (!strncmp(arg, "file:", 5)) {
 			pwdbio = BIO_new_file(arg + 5, "r");
-			if(!pwdbio) {
+			if (!pwdbio) {
 				BIO_printf(err, "Can't open file %s\n", arg + 5);
 				return NULL;
 			}
@@ -631,11 +636,11 @@ static char *app_get_pass(BIO *err, char *arg, int keepbio)
 		 * on real Windows descriptors, such as those obtained
 		 * with CreateFile.
 		 */
-		} else if(!strncmp(arg, "fd:", 3)) {
+		} else if (!strncmp(arg, "fd:", 3)) {
 			BIO *btmp;
 			i = atoi(arg + 3);
-			if(i >= 0) pwdbio = BIO_new_fd(i, BIO_NOCLOSE);
-			if((i < 0) || !pwdbio) {
+			if (i >= 0) pwdbio = BIO_new_fd(i, BIO_NOCLOSE);
+			if ((i < 0) || !pwdbio) {
 				BIO_printf(err, "Can't access file descriptor %s\n", arg + 3);
 				return NULL;
 			}
@@ -643,9 +648,9 @@ static char *app_get_pass(BIO *err, char *arg, int keepbio)
 			btmp = BIO_new(BIO_f_buffer());
 			pwdbio = BIO_push(btmp, pwdbio);
 #endif
-		} else if(!strcmp(arg, "stdin")) {
+		} else if (!strcmp(arg, "stdin")) {
 			pwdbio = BIO_new_fp(stdin, BIO_NOCLOSE);
-			if(!pwdbio) {
+			if (!pwdbio) {
 				BIO_printf(err, "Can't open BIO for stdin\n");
 				return NULL;
 			}
@@ -655,353 +660,311 @@ static char *app_get_pass(BIO *err, char *arg, int keepbio)
 		}
 	}
 	i = BIO_gets(pwdbio, tpass, APP_PASS_LEN);
-	if(keepbio != 1) {
+	if (keepbio != 1) {
 		BIO_free_all(pwdbio);
 		pwdbio = NULL;
 	}
-	if(i <= 0) {
+	if (i <= 0) {
 		BIO_printf(err, "Error reading password from BIO\n");
 		return NULL;
 	}
 	tmp = strchr(tpass, '\n');
-	if(tmp) *tmp = 0;
-	return BUF_strdup(tpass);
+	if (tmp) *tmp = 0;
+		return BUF_strdup(tpass);
 }
 
-int add_oid_section(BIO *err, CONF *conf)
-{	
+int
+add_oid_section(BIO *err, CONF *conf)
+{
 	char *p;
 	STACK_OF(CONF_VALUE) *sktmp;
 	CONF_VALUE *cnf;
 	int i;
-	if(!(p=NCONF_get_string(conf,NULL,"oid_section")))
-		{
+	if (!(p = NCONF_get_string(conf, NULL, "oid_section"))) {
 		ERR_clear_error();
 		return 1;
-		}
-	if(!(sktmp = NCONF_get_section(conf, p))) {
+	}
+	if (!(sktmp = NCONF_get_section(conf, p))) {
 		BIO_printf(err, "problem loading oid section %s\n", p);
 		return 0;
 	}
-	for(i = 0; i < sk_CONF_VALUE_num(sktmp); i++) {
+	for (i = 0; i < sk_CONF_VALUE_num(sktmp); i++) {
 		cnf = sk_CONF_VALUE_value(sktmp, i);
-		if(OBJ_create(cnf->value, cnf->name, cnf->name) == NID_undef) {
+		if (OBJ_create(cnf->value, cnf->name, cnf->name) == NID_undef) {
 			BIO_printf(err, "problem creating object %s=%s\n",
-							 cnf->name, cnf->value);
+			    cnf->name, cnf->value);
 			return 0;
 		}
 	}
 	return 1;
 }
 
-static int load_pkcs12(BIO *err, BIO *in, const char *desc,
-		pem_password_cb *pem_cb,  void *cb_data,
-		EVP_PKEY **pkey, X509 **cert, STACK_OF(X509) **ca)
-	{
- 	const char *pass;
+static int
+load_pkcs12(BIO *err, BIO *in, const char *desc, pem_password_cb *pem_cb,
+    void *cb_data, EVP_PKEY **pkey, X509 **cert, STACK_OF(X509) **ca)
+{
+	const char *pass;
 	char tpass[PEM_BUFSIZE];
 	int len, ret = 0;
 	PKCS12 *p12;
 	p12 = d2i_PKCS12_bio(in, NULL);
-	if (p12 == NULL)
-		{
-		BIO_printf(err, "Error loading PKCS12 file for %s\n", desc);	
+	if (p12 == NULL) {
+		BIO_printf(err, "Error loading PKCS12 file for %s\n", desc);
 		goto die;
-		}
+	}
 	/* See if an empty password will do */
 	if (PKCS12_verify_mac(p12, "", 0) || PKCS12_verify_mac(p12, NULL, 0))
 		pass = "";
-	else
-		{
+	else {
 		if (!pem_cb)
 			pem_cb = (pem_password_cb *)password_callback;
 		len = pem_cb(tpass, PEM_BUFSIZE, 0, cb_data);
-		if (len < 0) 
-			{
+		if (len < 0) {
 			BIO_printf(err, "Passpharse callback error for %s\n",
-					desc);
+			    desc);
 			goto die;
-			}
+		}
 		if (len < PEM_BUFSIZE)
 			tpass[len] = 0;
-		if (!PKCS12_verify_mac(p12, tpass, len))
-			{
+		if (!PKCS12_verify_mac(p12, tpass, len)) {
 			BIO_printf(err,
-	"Mac verify error (wrong password?) in PKCS12 file for %s\n", desc);	
+			    "Mac verify error (wrong password?) in PKCS12 file for %s\n", desc);
 			goto die;
-			}
-		pass = tpass;
 		}
+		pass = tpass;
+	}
 	ret = PKCS12_parse(p12, pass, pkey, cert, ca);
-	die:
+die:
 	if (p12)
 		PKCS12_free(p12);
 	return ret;
-	}
+}
 
-X509 *load_cert(BIO *err, const char *file, int format,
-	const char *pass, ENGINE *e, const char *cert_descrip)
-	{
-	X509 *x=NULL;
+X509 *
+load_cert(BIO *err, const char *file, int format, const char *pass, ENGINE *e,
+    const char *cert_descrip)
+{
+	X509 *x = NULL;
 	BIO *cert;
 
-	if ((cert=BIO_new(BIO_s_file())) == NULL)
-		{
+	if ((cert = BIO_new(BIO_s_file())) == NULL) {
 		ERR_print_errors(err);
 		goto end;
-		}
+	}
 
-	if (file == NULL)
-		{
+	if (file == NULL) {
 #ifdef _IONBF
 # ifndef OPENSSL_NO_SETVBUF_IONBF
 		setvbuf(stdin, NULL, _IONBF, 0);
 # endif /* ndef OPENSSL_NO_SETVBUF_IONBF */
 #endif
-		BIO_set_fp(cert,stdin,BIO_NOCLOSE);
-		}
-	else
-		{
-		if (BIO_read_filename(cert,file) <= 0)
-			{
+		BIO_set_fp(cert, stdin, BIO_NOCLOSE);
+	} else {
+		if (BIO_read_filename(cert, file) <= 0) {
 			BIO_printf(err, "Error opening %s %s\n",
-				cert_descrip, file);
+			    cert_descrip, file);
 			ERR_print_errors(err);
 			goto end;
-			}
 		}
+	}
 
-	if 	(format == FORMAT_ASN1)
-		x=d2i_X509_bio(cert,NULL);
-	else if (format == FORMAT_NETSCAPE)
-		{
+	if (format == FORMAT_ASN1)
+		x = d2i_X509_bio(cert, NULL);
+	else if (format == FORMAT_NETSCAPE) {
 		NETSCAPE_X509 *nx;
-		nx=ASN1_item_d2i_bio(ASN1_ITEM_rptr(NETSCAPE_X509),cert,NULL);
+		nx = ASN1_item_d2i_bio(ASN1_ITEM_rptr(NETSCAPE_X509), cert, NULL);
 		if (nx == NULL)
-				goto end;
+			goto end;
 
-		if ((strncmp(NETSCAPE_CERT_HDR,(char *)nx->header->data,
-			nx->header->length) != 0))
-			{
+		if ((strncmp(NETSCAPE_CERT_HDR, (char *)nx->header->data,
+		    nx->header->length) != 0)) {
 			NETSCAPE_X509_free(nx);
-			BIO_printf(err,"Error reading header on certificate\n");
+			BIO_printf(err, "Error reading header on certificate\n");
 			goto end;
-			}
-		x=nx->cert;
+		}
+		x = nx->cert;
 		nx->cert = NULL;
 		NETSCAPE_X509_free(nx);
-		}
-	else if (format == FORMAT_PEM)
-		x=PEM_read_bio_X509_AUX(cert,NULL,
-			(pem_password_cb *)password_callback, NULL);
-	else if (format == FORMAT_PKCS12)
-		{
-		if (!load_pkcs12(err, cert,cert_descrip, NULL, NULL,
-					NULL, &x, NULL))
+	} else if (format == FORMAT_PEM)
+		x = PEM_read_bio_X509_AUX(cert, NULL,
+		    (pem_password_cb *)password_callback, NULL);
+	else if (format == FORMAT_PKCS12) {
+		if (!load_pkcs12(err, cert, cert_descrip, NULL, NULL,
+			    NULL, &x, NULL))
 			goto end;
-		}
-	else	{
-		BIO_printf(err,"bad input format specified for %s\n",
-			cert_descrip);
+	} else {
+		BIO_printf(err, "bad input format specified for %s\n",
+		    cert_descrip);
 		goto end;
-		}
+	}
 end:
-	if (x == NULL)
-		{
-		BIO_printf(err,"unable to load certificate\n");
+	if (x == NULL) {
+		BIO_printf(err, "unable to load certificate\n");
 		ERR_print_errors(err);
-		}
-	if (cert != NULL) BIO_free(cert);
-	return(x);
 	}
+	if (cert != NULL) BIO_free(cert);
+		return (x);
+}
 
-EVP_PKEY *load_key(BIO *err, const char *file, int format, int maybe_stdin,
-	const char *pass, ENGINE *e, const char *key_descrip)
-	{
-	BIO *key=NULL;
-	EVP_PKEY *pkey=NULL;
+EVP_PKEY *
+load_key(BIO *err, const char *file, int format, int maybe_stdin,
+    const char *pass, ENGINE *e, const char *key_descrip)
+{
+	BIO *key = NULL;
+	EVP_PKEY *pkey = NULL;
 	PW_CB_DATA cb_data;
 
 	cb_data.password = pass;
 	cb_data.prompt_info = file;
 
-	if (file == NULL && (!maybe_stdin || format == FORMAT_ENGINE))
-		{
-		BIO_printf(err,"no keyfile specified\n");
+	if (file == NULL && (!maybe_stdin || format == FORMAT_ENGINE)) {
+		BIO_printf(err, "no keyfile specified\n");
 		goto end;
-		}
+	}
 #ifndef OPENSSL_NO_ENGINE
-	if (format == FORMAT_ENGINE)
-		{
+	if (format == FORMAT_ENGINE) {
 		if (!e)
-			BIO_printf(err,"no engine specified\n");
-		else
-			{
+			BIO_printf(err, "no engine specified\n");
+		else {
 			pkey = ENGINE_load_private_key(e, file,
-				ui_method, &cb_data);
-			if (!pkey) 
-				{
-				BIO_printf(err,"cannot load %s from engine\n",key_descrip);
+			    ui_method, &cb_data);
+			if (!pkey) {
+				BIO_printf(err, "cannot load %s from engine\n", key_descrip);
 				ERR_print_errors(err);
-				}	
 			}
-		goto end;
 		}
+		goto end;
+	}
 #endif
-	key=BIO_new(BIO_s_file());
-	if (key == NULL)
-		{
+	key = BIO_new(BIO_s_file());
+	if (key == NULL) {
 		ERR_print_errors(err);
 		goto end;
-		}
-	if (file == NULL && maybe_stdin)
-		{
+	}
+	if (file == NULL && maybe_stdin) {
 #ifdef _IONBF
 # ifndef OPENSSL_NO_SETVBUF_IONBF
 		setvbuf(stdin, NULL, _IONBF, 0);
 # endif /* ndef OPENSSL_NO_SETVBUF_IONBF */
 #endif
-		BIO_set_fp(key,stdin,BIO_NOCLOSE);
-		}
-	else
-		if (BIO_read_filename(key,file) <= 0)
-			{
-			BIO_printf(err, "Error opening %s %s\n",
-				key_descrip, file);
-			ERR_print_errors(err);
-			goto end;
-			}
-	if (format == FORMAT_ASN1)
-		{
-		pkey=d2i_PrivateKey_bio(key, NULL);
-		}
-	else if (format == FORMAT_PEM)
-		{
-		pkey=PEM_read_bio_PrivateKey(key,NULL,
-			(pem_password_cb *)password_callback, &cb_data);
-		}
+		BIO_set_fp(key, stdin, BIO_NOCLOSE);
+	} else if (BIO_read_filename(key, file) <= 0) {
+		BIO_printf(err, "Error opening %s %s\n",
+		    key_descrip, file);
+		ERR_print_errors(err);
+		goto end;
+	}
+	if (format == FORMAT_ASN1) {
+		pkey = d2i_PrivateKey_bio(key, NULL);
+	} else if (format == FORMAT_PEM) {
+		pkey = PEM_read_bio_PrivateKey(key, NULL,
+		    (pem_password_cb *)password_callback, &cb_data);
+	}
 #if !defined(OPENSSL_NO_RC4) && !defined(OPENSSL_NO_RSA)
 	else if (format == FORMAT_NETSCAPE || format == FORMAT_IISSGC)
 		pkey = load_netscape_key(err, key, file, key_descrip, format);
 #endif
-	else if (format == FORMAT_PKCS12)
-		{
+	else if (format == FORMAT_PKCS12) {
 		if (!load_pkcs12(err, key, key_descrip,
-				(pem_password_cb *)password_callback, &cb_data,
-				&pkey, NULL, NULL))
+		    (pem_password_cb *)password_callback, &cb_data,
+		    &pkey, NULL, NULL))
 			goto end;
-		}
+	}
 #if !defined(OPENSSL_NO_RSA) && !defined(OPENSSL_NO_DSA) && !defined (OPENSSL_NO_RC4)
 	else if (format == FORMAT_MSBLOB)
 		pkey = b2i_PrivateKey_bio(key);
 	else if (format == FORMAT_PVK)
 		pkey = b2i_PVK_bio(key, (pem_password_cb *)password_callback,
-								&cb_data);
+		    &cb_data);
 #endif
-	else
-		{
-		BIO_printf(err,"bad input format specified for key file\n");
+	else {
+		BIO_printf(err, "bad input format specified for key file\n");
 		goto end;
-		}
- end:
-	if (key != NULL) BIO_free(key);
-	if (pkey == NULL) 
-		{
-		BIO_printf(err,"unable to load %s\n", key_descrip);
+	}
+end:
+	if (key != NULL)
+		BIO_free(key);
+	if (pkey == NULL) {
+		BIO_printf(err, "unable to load %s\n", key_descrip);
 		ERR_print_errors(err);
-		}	
-	return(pkey);
 	}
+	return (pkey);
+}
 
-EVP_PKEY *load_pubkey(BIO *err, const char *file, int format, int maybe_stdin,
-	const char *pass, ENGINE *e, const char *key_descrip)
-	{
-	BIO *key=NULL;
-	EVP_PKEY *pkey=NULL;
+EVP_PKEY *
+load_pubkey(BIO *err, const char *file, int format, int maybe_stdin,
+    const char *pass, ENGINE *e, const char *key_descrip)
+{
+	BIO *key = NULL;
+	EVP_PKEY *pkey = NULL;
 	PW_CB_DATA cb_data;
 
 	cb_data.password = pass;
 	cb_data.prompt_info = file;
 
-	if (file == NULL && (!maybe_stdin || format == FORMAT_ENGINE))
-		{
-		BIO_printf(err,"no keyfile specified\n");
+	if (file == NULL && (!maybe_stdin || format == FORMAT_ENGINE)) {
+		BIO_printf(err, "no keyfile specified\n");
 		goto end;
-		}
+	}
 #ifndef OPENSSL_NO_ENGINE
-	if (format == FORMAT_ENGINE)
-		{
+	if (format == FORMAT_ENGINE) {
 		if (!e)
-			BIO_printf(bio_err,"no engine specified\n");
+			BIO_printf(bio_err, "no engine specified\n");
 		else
 			pkey = ENGINE_load_public_key(e, file,
-				ui_method, &cb_data);
+			    ui_method, &cb_data);
 		goto end;
-		}
+	}
 #endif
-	key=BIO_new(BIO_s_file());
-	if (key == NULL)
-		{
+	key = BIO_new(BIO_s_file());
+	if (key == NULL) {
 		ERR_print_errors(err);
 		goto end;
-		}
-	if (file == NULL && maybe_stdin)
-		{
+	}
+	if (file == NULL && maybe_stdin) {
 #ifdef _IONBF
 # ifndef OPENSSL_NO_SETVBUF_IONBF
 		setvbuf(stdin, NULL, _IONBF, 0);
 # endif /* ndef OPENSSL_NO_SETVBUF_IONBF */
 #endif
-		BIO_set_fp(key,stdin,BIO_NOCLOSE);
-		}
-	else
-		if (BIO_read_filename(key,file) <= 0)
-			{
-			BIO_printf(err, "Error opening %s %s\n",
-				key_descrip, file);
-			ERR_print_errors(err);
-			goto end;
-		}
-	if (format == FORMAT_ASN1)
-		{
-		pkey=d2i_PUBKEY_bio(key, NULL);
-		}
+		BIO_set_fp(key, stdin, BIO_NOCLOSE);
+	} else if (BIO_read_filename(key, file) <= 0) {
+		BIO_printf(err, "Error opening %s %s\n",
+		    key_descrip, file);
+		ERR_print_errors(err);
+		goto end;
+	}
+	if (format == FORMAT_ASN1) {
+		pkey = d2i_PUBKEY_bio(key, NULL);
+	}
 #ifndef OPENSSL_NO_RSA
-	else if (format == FORMAT_ASN1RSA)
-		{
+	else if (format == FORMAT_ASN1RSA) {
 		RSA *rsa;
 		rsa = d2i_RSAPublicKey_bio(key, NULL);
-		if (rsa)
-			{
+		if (rsa) {
 			pkey = EVP_PKEY_new();
 			if (pkey)
 				EVP_PKEY_set1_RSA(pkey, rsa);
 			RSA_free(rsa);
-			}
-		else
+		} else
 			pkey = NULL;
-		}
-	else if (format == FORMAT_PEMRSA)
-		{
+	} else if (format == FORMAT_PEMRSA) {
 		RSA *rsa;
-		rsa = PEM_read_bio_RSAPublicKey(key, NULL, 
-			(pem_password_cb *)password_callback, &cb_data);
-		if (rsa)
-			{
+		rsa = PEM_read_bio_RSAPublicKey(key, NULL,
+		    (pem_password_cb *)password_callback, &cb_data);
+		if (rsa) {
 			pkey = EVP_PKEY_new();
 			if (pkey)
 				EVP_PKEY_set1_RSA(pkey, rsa);
 			RSA_free(rsa);
-			}
-		else
+		} else
 			pkey = NULL;
-		}
+	}
 #endif
-	else if (format == FORMAT_PEM)
-		{
-		pkey=PEM_read_bio_PUBKEY(key,NULL,
-			(pem_password_cb *)password_callback, &cb_data);
-		}
+	else if (format == FORMAT_PEM) {
+		pkey = PEM_read_bio_PUBKEY(key, NULL,
+		    (pem_password_cb *)password_callback, &cb_data);
+	}
 #if !defined(OPENSSL_NO_RC4) && !defined(OPENSSL_NO_RSA)
 	else if (format == FORMAT_NETSCAPE || format == FORMAT_IISSGC)
 		pkey = load_netscape_key(err, key, file, key_descrip, format);
@@ -1010,52 +973,49 @@ EVP_PKEY *load_pubkey(BIO *err, const char *file, int format, int maybe_stdin,
 	else if (format == FORMAT_MSBLOB)
 		pkey = b2i_PublicKey_bio(key);
 #endif
-	else
-		{
-		BIO_printf(err,"bad input format specified for key file\n");
+	else {
+		BIO_printf(err, "bad input format specified for key file\n");
 		goto end;
-		}
- end:
-	if (key != NULL) BIO_free(key);
-	if (pkey == NULL)
-		BIO_printf(err,"unable to load %s\n", key_descrip);
-	return(pkey);
 	}
+end:
+	if (key != NULL) BIO_free(key);
+		if (pkey == NULL)
+			BIO_printf(err, "unable to load %s\n", key_descrip);
+	return (pkey);
+}
 
 #if !defined(OPENSSL_NO_RC4) && !defined(OPENSSL_NO_RSA)
 static EVP_PKEY *
 load_netscape_key(BIO *err, BIO *key, const char *file,
-		const char *key_descrip, int format)
-	{
+    const char *key_descrip, int format)
+{
 	EVP_PKEY *pkey;
 	BUF_MEM *buf;
 	RSA	*rsa;
 	const unsigned char *p;
 	int size, i;
 
-	buf=BUF_MEM_new();
+	buf = BUF_MEM_new();
 	pkey = EVP_PKEY_new();
 	size = 0;
 	if (buf == NULL || pkey == NULL)
 		goto error;
-	for (;;)
-		{
-		if (!BUF_MEM_grow_clean(buf,size+1024*10))
+	for (;;) {
+		if (!BUF_MEM_grow_clean(buf, size + 1024*10))
 			goto error;
 		i = BIO_read(key, &(buf->data[size]), 1024*10);
 		size += i;
 		if (i == 0)
 			break;
-		if (i < 0)
-			{
-				BIO_printf(err, "Error reading %s %s",
-					key_descrip, file);
-				goto error;
-			}
+		if (i < 0) {
+			BIO_printf(err, "Error reading %s %s",
+			    key_descrip, file);
+			goto error;
 		}
-	p=(unsigned char *)buf->data;
-	rsa = d2i_RSA_NET(NULL,&p,(long)size,NULL,
-		(format == FORMAT_IISSGC ? 1 : 0));
+	}
+	p = (unsigned char *)buf->data;
+	rsa = d2i_RSA_NET(NULL, &p, (long)size, NULL,
+	    (format == FORMAT_IISSGC ? 1 : 0));
 	if (rsa == NULL)
 		goto error;
 	BUF_MEM_free(buf);
@@ -1065,13 +1025,14 @@ error:
 	BUF_MEM_free(buf);
 	EVP_PKEY_free(pkey);
 	return NULL;
-	}
+}
 #endif /* ndef OPENSSL_NO_RC4 */
 
-static int load_certs_crls(BIO *err, const char *file, int format,
-	const char *pass, ENGINE *e, const char *desc,
-	STACK_OF(X509) **pcerts, STACK_OF(X509_CRL) **pcrls)
-	{
+static int
+load_certs_crls(BIO *err, const char *file, int format, const char *pass,
+    ENGINE *e, const char *desc, STACK_OF(X509) **pcerts,
+    STACK_OF(X509_CRL) **pcrls)
+{
 	int i;
 	BIO *bio;
 	STACK_OF(X509_INFO) *xis = NULL;
@@ -1082,60 +1043,53 @@ static int load_certs_crls(BIO *err, const char *file, int format,
 	cb_data.password = pass;
 	cb_data.prompt_info = file;
 
-	if (format != FORMAT_PEM)
-		{
-		BIO_printf(err,"bad input format specified for %s\n", desc);
+	if (format != FORMAT_PEM) {
+		BIO_printf(err, "bad input format specified for %s\n", desc);
 		return 0;
-		}
+	}
 
 	if (file == NULL)
-		bio = BIO_new_fp(stdin,BIO_NOCLOSE);
+		bio = BIO_new_fp(stdin, BIO_NOCLOSE);
 	else
 		bio = BIO_new_file(file, "r");
 
-	if (bio == NULL)
-		{
+	if (bio == NULL) {
 		BIO_printf(err, "Error opening %s %s\n",
-				desc, file ? file : "stdin");
+		    desc, file ? file : "stdin");
 		ERR_print_errors(err);
 		return 0;
-		}
+	}
 
 	xis = PEM_X509_INFO_read_bio(bio, NULL,
-				(pem_password_cb *)password_callback, &cb_data);
+	    (pem_password_cb *)password_callback, &cb_data);
 
 	BIO_free(bio);
 
-	if (pcerts)
-		{
+	if (pcerts) {
 		*pcerts = sk_X509_new_null();
 		if (!*pcerts)
 			goto end;
-		}
+	}
 
-	if (pcrls)
-		{
+	if (pcrls) {
 		*pcrls = sk_X509_CRL_new_null();
 		if (!*pcrls)
 			goto end;
-		}
+	}
 
-	for(i = 0; i < sk_X509_INFO_num(xis); i++)
-		{
+	for (i = 0; i < sk_X509_INFO_num(xis); i++) {
 		xi = sk_X509_INFO_value (xis, i);
-		if (xi->x509 && pcerts)
-			{
+		if (xi->x509 && pcerts) {
 			if (!sk_X509_push(*pcerts, xi->x509))
 				goto end;
 			xi->x509 = NULL;
-			}
-		if (xi->crl && pcrls)
-			{
+		}
+		if (xi->crl && pcrls) {
 			if (!sk_X509_CRL_push(*pcrls, xi->crl))
 				goto end;
 			xi->crl = NULL;
-			}
 		}
+	}
 
 	if (pcerts && sk_X509_num(*pcerts) > 0)
 		rv = 1;
@@ -1143,47 +1097,45 @@ static int load_certs_crls(BIO *err, const char *file, int format,
 	if (pcrls && sk_X509_CRL_num(*pcrls) > 0)
 		rv = 1;
 
-	end:
-
+end:
 	if (xis)
 		sk_X509_INFO_pop_free(xis, X509_INFO_free);
 
-	if (rv == 0)
-		{
-		if (pcerts)
-			{
+	if (rv == 0) {
+		if (pcerts) {
 			sk_X509_pop_free(*pcerts, X509_free);
 			*pcerts = NULL;
-			}
-		if (pcrls)
-			{
+		}
+		if (pcrls) {
 			sk_X509_CRL_pop_free(*pcrls, X509_CRL_free);
 			*pcrls = NULL;
-			}
-		BIO_printf(err,"unable to load %s\n",
-				pcerts ? "certificates" : "CRLs");
-		ERR_print_errors(err);
 		}
-	return rv;
+		BIO_printf(err, "unable to load %s\n",
+		    pcerts ? "certificates" : "CRLs");
+		ERR_print_errors(err);
 	}
+	return rv;
+}
 
-STACK_OF(X509) *load_certs(BIO *err, const char *file, int format,
-	const char *pass, ENGINE *e, const char *desc)
-	{
+STACK_OF(X509) *
+load_certs(BIO *err, const char *file, int format, const char *pass, ENGINE *e,
+    const char *desc)
+{
 	STACK_OF(X509) *certs;
 	if (!load_certs_crls(err, file, format, pass, e, desc, &certs, NULL))
 		return NULL;
 	return certs;
-	}	
+}
 
-STACK_OF(X509_CRL) *load_crls(BIO *err, const char *file, int format,
-	const char *pass, ENGINE *e, const char *desc)
-	{
+STACK_OF(X509_CRL) *
+load_crls(BIO *err, const char *file, int format, const char *pass, ENGINE *e,
+    const char *desc)
+{
 	STACK_OF(X509_CRL) *crls;
 	if (!load_certs_crls(err, file, format, pass, e, desc, NULL, &crls))
 		return NULL;
 	return crls;
-	}	
+}
 
 #define X509V3_EXT_UNKNOWN_MASK		(0xfL << 16)
 /* Return error for unknown extensions */
@@ -1198,7 +1150,8 @@ STACK_OF(X509_CRL) *load_crls(BIO *err, const char *file, int format,
 #define X509_FLAG_CA (X509_FLAG_NO_ISSUER | X509_FLAG_NO_PUBKEY | \
 			 X509_FLAG_NO_HEADER | X509_FLAG_NO_VERSION)
 
-int set_cert_ex(unsigned long *flags, const char *arg)
+int
+set_cert_ex(unsigned long *flags, const char *arg)
 {
 	static const NAME_EX_TBL cert_tbl[] = {
 		{ "compatible", X509_FLAG_COMPAT, 0xffffffffl},
@@ -1224,7 +1177,8 @@ int set_cert_ex(unsigned long *flags, const char *arg)
 	return set_multi_opts(flags, arg, cert_tbl);
 }
 
-int set_name_ex(unsigned long *flags, const char *arg)
+int
+set_name_ex(unsigned long *flags, const char *arg)
 {
 	static const NAME_EX_TBL ex_tbl[] = {
 		{ "esc_2253", ASN1_STRFLGS_ESC_2253, 0},
@@ -1259,7 +1213,8 @@ int set_name_ex(unsigned long *flags, const char *arg)
 	return set_multi_opts(flags, arg, ex_tbl);
 }
 
-int set_ext_copy(int *copy_type, const char *arg)
+int
+set_ext_copy(int *copy_type, const char *arg)
 {
 	if (!strcasecmp(arg, "none"))
 		*copy_type = EXT_COPY_NONE;
@@ -1272,7 +1227,8 @@ int set_ext_copy(int *copy_type, const char *arg)
 	return 1;
 }
 
-int copy_extensions(X509 *x, X509_REQ *req, int copy_type)
+int
+copy_extensions(X509 *x, X509_REQ *req, int copy_type)
 {
 	STACK_OF(X509_EXTENSION) *exts = NULL;
 	X509_EXTENSION *ext, *tmpext;
@@ -1282,7 +1238,7 @@ int copy_extensions(X509 *x, X509_REQ *req, int copy_type)
 		return 1;
 	exts = X509_REQ_get_extensions(req);
 
-	for(i = 0; i < sk_X509_EXTENSION_num(exts); i++) {
+	for (i = 0; i < sk_X509_EXTENSION_num(exts); i++) {
 		ext = sk_X509_EXTENSION_value(exts, i);
 		obj = X509_EXTENSION_get_object(ext);
 		idx = X509_get_ext_by_OBJ(x, obj, -1);
@@ -1305,23 +1261,20 @@ int copy_extensions(X509 *x, X509_REQ *req, int copy_type)
 
 	ret = 1;
 
-	end:
-
+end:
 	sk_X509_EXTENSION_pop_free(exts, X509_EXTENSION_free);
 
 	return ret;
 }
-		
-		
-			
 
-static int set_multi_opts(unsigned long *flags, const char *arg, const NAME_EX_TBL *in_tbl)
+static int
+set_multi_opts(unsigned long *flags, const char *arg, const NAME_EX_TBL *in_tbl)
 {
 	STACK_OF(CONF_VALUE) *vals;
 	CONF_VALUE *val;
 	int i, ret = 1;
-	if(!arg) return 0;
-	vals = X509V3_parse_list(arg);
+	if (!arg) return 0;
+		vals = X509V3_parse_list(arg);
 	for (i = 0; i < sk_CONF_VALUE_num(vals); i++) {
 		val = sk_CONF_VALUE_value(vals, i);
 		if (!set_table_opts(flags, val->name, in_tbl))
@@ -1331,13 +1284,14 @@ static int set_multi_opts(unsigned long *flags, const char *arg, const NAME_EX_T
 	return ret;
 }
 
-static int set_table_opts(unsigned long *flags, const char *arg, const NAME_EX_TBL *in_tbl)
+static int
+set_table_opts(unsigned long *flags, const char *arg, const NAME_EX_TBL *in_tbl)
 {
 	char c;
 	const NAME_EX_TBL *ptbl;
 	c = arg[0];
 
-	if(c == '-') {
+	if (c == '-') {
 		c = 0;
 		arg++;
 	} else if (c == '+') {
@@ -1345,131 +1299,139 @@ static int set_table_opts(unsigned long *flags, const char *arg, const NAME_EX_T
 		arg++;
 	} else c = 1;
 
-	for(ptbl = in_tbl; ptbl->name; ptbl++) {
-		if(!strcasecmp(arg, ptbl->name)) {
+	for (ptbl = in_tbl; ptbl->name; ptbl++) {
+		if (!strcasecmp(arg, ptbl->name)) {
 			*flags &= ~ptbl->mask;
-			if(c) *flags |= ptbl->flag;
-			else *flags &= ~ptbl->flag;
+			if (c)
+				*flags |= ptbl->flag;
+			else
+				*flags &= ~ptbl->flag;
 			return 1;
 		}
 	}
 	return 0;
 }
 
-void print_name(BIO *out, const char *title, X509_NAME *nm, unsigned long lflags)
+void
+print_name(BIO *out, const char *title, X509_NAME *nm, unsigned long lflags)
 {
 	char *buf;
 	char mline = 0;
 	int indent = 0;
 
-	if(title) BIO_puts(out, title);
-	if((lflags & XN_FLAG_SEP_MASK) == XN_FLAG_SEP_MULTILINE) {
+	if (title)
+		BIO_puts(out, title);
+	if ((lflags & XN_FLAG_SEP_MASK) == XN_FLAG_SEP_MULTILINE) {
 		mline = 1;
 		indent = 4;
 	}
-	if(lflags == XN_FLAG_COMPAT) {
+	if (lflags == XN_FLAG_COMPAT) {
 		buf = X509_NAME_oneline(nm, 0, 0);
 		BIO_puts(out, buf);
 		BIO_puts(out, "\n");
 		OPENSSL_free(buf);
 	} else {
-		if(mline) BIO_puts(out, "\n");
+		if (mline)
+			BIO_puts(out, "\n");
 		X509_NAME_print_ex(out, nm, indent, lflags);
 		BIO_puts(out, "\n");
 	}
 }
 
-X509_STORE *setup_verify(BIO *bp, char *CAfile, char *CApath)
+X509_STORE *
+setup_verify(BIO *bp, char *CAfile, char *CApath)
 {
 	X509_STORE *store;
 	X509_LOOKUP *lookup;
-	if(!(store = X509_STORE_new())) goto end;
-	lookup=X509_STORE_add_lookup(store,X509_LOOKUP_file());
-	if (lookup == NULL) goto end;
+	if (!(store = X509_STORE_new()))
+		goto end;
+	lookup = X509_STORE_add_lookup(store, X509_LOOKUP_file());
+	if (lookup == NULL)
+		goto end;
 	if (CAfile) {
-		if(!X509_LOOKUP_load_file(lookup,CAfile,X509_FILETYPE_PEM)) {
+		if (!X509_LOOKUP_load_file(lookup, CAfile, X509_FILETYPE_PEM)) {
 			BIO_printf(bp, "Error loading file %s\n", CAfile);
 			goto end;
 		}
-	} else X509_LOOKUP_load_file(lookup,NULL,X509_FILETYPE_DEFAULT);
-		
-	lookup=X509_STORE_add_lookup(store,X509_LOOKUP_hash_dir());
-	if (lookup == NULL) goto end;
+	} else
+		X509_LOOKUP_load_file(lookup, NULL, X509_FILETYPE_DEFAULT);
+
+	lookup = X509_STORE_add_lookup(store, X509_LOOKUP_hash_dir());
+	if (lookup == NULL)
+		goto end;
 	if (CApath) {
-		if(!X509_LOOKUP_add_dir(lookup,CApath,X509_FILETYPE_PEM)) {
+		if (!X509_LOOKUP_add_dir(lookup, CApath, X509_FILETYPE_PEM)) {
 			BIO_printf(bp, "Error loading directory %s\n", CApath);
 			goto end;
 		}
-	} else X509_LOOKUP_add_dir(lookup,NULL,X509_FILETYPE_DEFAULT);
+	} else
+		X509_LOOKUP_add_dir(lookup, NULL, X509_FILETYPE_DEFAULT);
 
 	ERR_clear_error();
 	return store;
-	end:
+
+end:
 	X509_STORE_free(store);
 	return NULL;
 }
 
 #ifndef OPENSSL_NO_ENGINE
 /* Try to load an engine in a shareable library */
-static ENGINE *try_load_engine(BIO *err, const char *engine, int debug)
-	{
+static ENGINE *
+try_load_engine(BIO *err, const char *engine, int debug)
+{
 	ENGINE *e = ENGINE_by_id("dynamic");
-	if (e)
-		{
-		if (!ENGINE_ctrl_cmd_string(e, "SO_PATH", engine, 0)
-			|| !ENGINE_ctrl_cmd_string(e, "LOAD", NULL, 0))
-			{
+	if (e) {
+		if (!ENGINE_ctrl_cmd_string(e, "SO_PATH", engine, 0) ||
+		    !ENGINE_ctrl_cmd_string(e, "LOAD", NULL, 0)) {
 			ENGINE_free(e);
 			e = NULL;
-			}
 		}
-	return e;
 	}
+	return e;
+}
 
-ENGINE *setup_engine(BIO *err, const char *engine, int debug)
-        {
-        ENGINE *e = NULL;
+ENGINE *
+setup_engine(BIO *err, const char *engine, int debug)
+{
+	ENGINE *e = NULL;
 
-        if (engine)
-                {
-		if(strcmp(engine, "auto") == 0)
-			{
-			BIO_printf(err,"enabling auto ENGINE support\n");
+	if (engine) {
+		if (strcmp(engine, "auto") == 0) {
+			BIO_printf(err, "enabling auto ENGINE support\n");
 			ENGINE_register_all_complete();
 			return NULL;
-			}
-		if((e = ENGINE_by_id(engine)) == NULL
-			&& (e = try_load_engine(err, engine, debug)) == NULL)
-			{
-			BIO_printf(err,"invalid engine \"%s\"\n", engine);
+		}
+		if ((e = ENGINE_by_id(engine)) == NULL &&
+		    (e = try_load_engine(err, engine, debug)) == NULL) {
+			BIO_printf(err, "invalid engine \"%s\"\n", engine);
 			ERR_print_errors(err);
 			return NULL;
-			}
-		if (debug)
-			{
+		}
+		if (debug) {
 			ENGINE_ctrl(e, ENGINE_CTRL_SET_LOGSTREAM,
-				0, err, 0);
-			}
-                ENGINE_ctrl_cmd(e, "SET_USER_INTERFACE", 0, ui_method, 0, 1);
-		if(!ENGINE_set_default(e, ENGINE_METHOD_ALL))
-			{
-			BIO_printf(err,"can't use that engine\n");
+			    0, err, 0);
+		}
+		ENGINE_ctrl_cmd(e, "SET_USER_INTERFACE", 0, ui_method, 0, 1);
+		if (!ENGINE_set_default(e, ENGINE_METHOD_ALL)) {
+			BIO_printf(err, "can't use that engine\n");
 			ERR_print_errors(err);
 			ENGINE_free(e);
 			return NULL;
-			}
+		}
 
-		BIO_printf(err,"engine \"%s\" set.\n", ENGINE_get_id(e));
+		BIO_printf(err, "engine \"%s\" set.\n", ENGINE_get_id(e));
 
 		/* Free our "structural" reference. */
 		ENGINE_free(e);
-		}
-        return e;
-        }
+	}
+	return e;
+}
 #endif
 
-int load_config(BIO *err, CONF *cnf)
-	{
+int
+load_config(BIO *err, CONF *cnf)
+{
 	static int load_config_called = 0;
 	if (load_config_called)
 		return 1;
@@ -1481,56 +1443,70 @@ int load_config(BIO *err, CONF *cnf)
 
 	OPENSSL_load_builtin_modules();
 
-	if (CONF_modules_load(cnf, NULL, 0) <= 0)
-		{
+	if (CONF_modules_load(cnf, NULL, 0) <= 0) {
 		BIO_printf(err, "Error configuring OpenSSL\n");
 		ERR_print_errors(err);
 		return 0;
-		}
-	return 1;
 	}
+	return 1;
+}
 
-char *make_config_name()
-	{
-	const char *t=X509_get_default_cert_area();
+char *
+make_config_name()
+{
+	const char *t = X509_get_default_cert_area();
 	size_t len;
 	char *p;
 
-	len=strlen(t)+strlen(OPENSSL_CONF)+2;
-	p=OPENSSL_malloc(len);
-	BUF_strlcpy(p,t,len);
-	BUF_strlcat(p,"/",len);
-	BUF_strlcat(p,OPENSSL_CONF,len);
+	len = strlen(t) + strlen(OPENSSL_CONF) + 2;
+	p = OPENSSL_malloc(len);
+	BUF_strlcpy(p, t, len);
+	BUF_strlcat(p, "/", len);
+	BUF_strlcat(p, OPENSSL_CONF, len);
 
 	return p;
-	}
+}
 
-static unsigned long index_serial_hash(const OPENSSL_CSTRING *a)
-	{
+static unsigned long
+index_serial_hash(const OPENSSL_CSTRING *a)
+{
 	const char *n;
 
-	n=a[DB_serial];
-	while (*n == '0') n++;
-	return(lh_strhash(n));
-	}
+	n = a[DB_serial];
+	while (*n == '0')
+		n++;
+	return (lh_strhash(n));
+}
 
-static int index_serial_cmp(const OPENSSL_CSTRING *a, const OPENSSL_CSTRING *b)
-	{
-	const char *aa,*bb;
+static int
+index_serial_cmp(const OPENSSL_CSTRING *a, const OPENSSL_CSTRING *b)
+{
+	const char *aa, *bb;
 
-	for (aa=a[DB_serial]; *aa == '0'; aa++);
-	for (bb=b[DB_serial]; *bb == '0'; bb++);
-	return(strcmp(aa,bb));
-	}
+	for (aa = a[DB_serial]; *aa == '0'; aa++)
+		;
+	for (bb = b[DB_serial]; *bb == '0'; bb++)
+		;
+	return (strcmp(aa, bb));
+}
 
-static int index_name_qual(char **a)
-	{ return(a[0][0] == 'V'); }
+static int
+index_name_qual(char **a)
+{
+	return (a[0][0] == 'V');
+}
 
-static unsigned long index_name_hash(const OPENSSL_CSTRING *a)
-	{ return(lh_strhash(a[DB_name])); }
+static unsigned long
+index_name_hash(const OPENSSL_CSTRING *a)
+{
+	return (lh_strhash(a[DB_name]));
+}
 
-int index_name_cmp(const OPENSSL_CSTRING *a, const OPENSSL_CSTRING *b)
-	{ return(strcmp(a[DB_name], b[DB_name])); }
+int
+index_name_cmp(const OPENSSL_CSTRING *a, const OPENSSL_CSTRING *b)
+{
+	return (strcmp(a[DB_name], b[DB_name]));
+}
 
 static IMPLEMENT_LHASH_HASH_FN(index_serial, OPENSSL_CSTRING)
 static IMPLEMENT_LHASH_COMP_FN(index_serial, OPENSSL_CSTRING)
@@ -1540,80 +1516,73 @@ static IMPLEMENT_LHASH_COMP_FN(index_name, OPENSSL_CSTRING)
 #undef BSIZE
 #define BSIZE 256
 
-BIGNUM *load_serial(char *serialfile, int create, ASN1_INTEGER **retai)
-	{
-	BIO *in=NULL;
-	BIGNUM *ret=NULL;
+BIGNUM *
+load_serial(char *serialfile, int create, ASN1_INTEGER **retai)
+{
+	BIO *in = NULL;
+	BIGNUM *ret = NULL;
 	char buf[1024];
-	ASN1_INTEGER *ai=NULL;
+	ASN1_INTEGER *ai = NULL;
 
-	ai=ASN1_INTEGER_new();
-	if (ai == NULL) goto err;
+	ai = ASN1_INTEGER_new();
+	if (ai == NULL)
+		goto err;
 
-	if ((in=BIO_new(BIO_s_file())) == NULL)
-		{
+	if ((in = BIO_new(BIO_s_file())) == NULL) {
 		ERR_print_errors(bio_err);
 		goto err;
-		}
+	}
 
-	if (BIO_read_filename(in,serialfile) <= 0)
-		{
-		if (!create)
-			{
+	if (BIO_read_filename(in, serialfile) <= 0) {
+		if (!create) {
 			perror(serialfile);
 			goto err;
-			}
-		else
-			{
-			ret=BN_new();
+		} else {
+			ret = BN_new();
 			if (ret == NULL || !rand_serial(ret, ai))
 				BIO_printf(bio_err, "Out of memory\n");
-			}
 		}
-	else
-		{
-		if (!a2i_ASN1_INTEGER(in,ai,buf,1024))
-			{
-			BIO_printf(bio_err,"unable to load number from %s\n",
-				serialfile);
+	} else {
+		if (!a2i_ASN1_INTEGER(in, ai, buf, 1024)) {
+			BIO_printf(bio_err, "unable to load number from %s\n",
+			    serialfile);
 			goto err;
-			}
-		ret=ASN1_INTEGER_to_BN(ai,NULL);
-		if (ret == NULL)
-			{
-			BIO_printf(bio_err,"error converting number from bin to BIGNUM\n");
+		}
+		ret = ASN1_INTEGER_to_BN(ai, NULL);
+		if (ret == NULL) {
+			BIO_printf(bio_err, "error converting number from bin to BIGNUM\n");
 			goto err;
-			}
 		}
+	}
 
-	if (ret && retai)
-		{
+	if (ret && retai) {
 		*retai = ai;
 		ai = NULL;
-		}
- err:
-	if (in != NULL) BIO_free(in);
-	if (ai != NULL) ASN1_INTEGER_free(ai);
-	return(ret);
 	}
+err:
+	if (in != NULL) BIO_free(in);
+		if (ai != NULL) ASN1_INTEGER_free(ai);
+		return (ret);
+}
 
-int save_serial(char *serialfile, char *suffix, BIGNUM *serial, ASN1_INTEGER **retai)
-	{
+int
+save_serial(char *serialfile, char *suffix, BIGNUM *serial,
+    ASN1_INTEGER **retai)
+{
 	char buf[1][BSIZE];
 	BIO *out = NULL;
-	int ret=0;
-	ASN1_INTEGER *ai=NULL;
+	int ret = 0;
+	ASN1_INTEGER *ai = NULL;
 	int j;
 
 	if (suffix == NULL)
 		j = strlen(serialfile);
 	else
 		j = strlen(serialfile) + strlen(suffix) + 1;
-	if (j >= BSIZE)
-		{
-		BIO_printf(bio_err,"file name too long\n");
+	if (j >= BSIZE) {
+		BIO_printf(bio_err, "file name too long\n");
 		goto err;
-		}
+	}
 
 	if (suffix == NULL)
 		BUF_strlcpy(buf[0], serialfile, BSIZE);
@@ -1622,90 +1591,89 @@ int save_serial(char *serialfile, char *suffix, BIGNUM *serial, ASN1_INTEGER **r
 #ifdef RL_DEBUG
 	BIO_printf(bio_err, "DEBUG: writing \"%s\"\n", buf[0]);
 #endif
-	out=BIO_new(BIO_s_file());
-	if (out == NULL)
-		{
+	out = BIO_new(BIO_s_file());
+	if (out == NULL) {
 		ERR_print_errors(bio_err);
 		goto err;
-		}
-	if (BIO_write_filename(out,buf[0]) <= 0)
-		{
+	}
+	if (BIO_write_filename(out, buf[0]) <= 0) {
 		perror(serialfile);
 		goto err;
-		}
+	}
 
-	if ((ai=BN_to_ASN1_INTEGER(serial,NULL)) == NULL)
-		{
-		BIO_printf(bio_err,"error converting serial to ASN.1 format\n");
+	if ((ai = BN_to_ASN1_INTEGER(serial, NULL)) == NULL) {
+		BIO_printf(bio_err, "error converting serial to ASN.1 format\n");
 		goto err;
-		}
-	i2a_ASN1_INTEGER(out,ai);
-	BIO_puts(out,"\n");
-	ret=1;
-	if (retai)
-		{
+	}
+	i2a_ASN1_INTEGER(out, ai);
+	BIO_puts(out, "\n");
+	ret = 1;
+	if (retai) {
 		*retai = ai;
 		ai = NULL;
-		}
-err:
-	if (out != NULL) BIO_free_all(out);
-	if (ai != NULL) ASN1_INTEGER_free(ai);
-	return(ret);
 	}
+err:
+	if (out != NULL)
+		BIO_free_all(out);
+	if (ai != NULL)
+		ASN1_INTEGER_free(ai);
+	return (ret);
+}
 
-int rotate_serial(char *serialfile, char *new_suffix, char *old_suffix)
-	{
+int
+rotate_serial(char *serialfile, char *new_suffix, char *old_suffix)
+{
 	char buf[5][BSIZE];
-	int i,j;
+	int i, j;
 
 	i = strlen(serialfile) + strlen(old_suffix);
 	j = strlen(serialfile) + strlen(new_suffix);
-	if (i > j) j = i;
-	if (j + 1 >= BSIZE)
-		{
-		BIO_printf(bio_err,"file name too long\n");
+	if (i > j)
+		j = i;
+	if (j + 1 >= BSIZE) {
+		BIO_printf(bio_err, "file name too long\n");
 		goto err;
-		}
+	}
 
 	(void) snprintf(buf[0], sizeof buf[0], "%s.%s",
-		serialfile, new_suffix);
+	    serialfile, new_suffix);
 	(void) snprintf(buf[1], sizeof buf[1], "%s.%s",
-		serialfile, old_suffix);
+	    serialfile, old_suffix);
 #ifdef RL_DEBUG
 	BIO_printf(bio_err, "DEBUG: renaming \"%s\" to \"%s\"\n",
-		serialfile, buf[1]);
+	    serialfile, buf[1]);
 #endif
-	if (rename(serialfile,buf[1]) < 0 && errno != ENOENT
+	if (rename(serialfile, buf[1]) < 0 && errno != ENOENT
 #ifdef ENOTDIR
-			&& errno != ENOTDIR
+	    && errno != ENOTDIR
 #endif
-	   )		{
-			BIO_printf(bio_err,
-				"unable to rename %s to %s\n",
-				serialfile, buf[1]);
-			perror("reason");
-			goto err;
-			}
+	) {
+		BIO_printf(bio_err,
+		    "unable to rename %s to %s\n",
+		    serialfile, buf[1]);
+		perror("reason");
+		goto err;
+	}
 #ifdef RL_DEBUG
 	BIO_printf(bio_err, "DEBUG: renaming \"%s\" to \"%s\"\n",
-		buf[0],serialfile);
+	    buf[0], serialfile);
 #endif
-	if (rename(buf[0],serialfile) < 0)
-		{
+	if (rename(buf[0], serialfile) < 0) {
 		BIO_printf(bio_err,
-			"unable to rename %s to %s\n",
-			buf[0],serialfile);
+		    "unable to rename %s to %s\n",
+		    buf[0], serialfile);
 		perror("reason");
-		rename(buf[1],serialfile);
+		rename(buf[1], serialfile);
 		goto err;
-		}
+	}
 	return 1;
- err:
+err:
 	return 0;
-	}
+}
 
-int rand_serial(BIGNUM *b, ASN1_INTEGER *ai)
-	{
+int
+rand_serial(BIGNUM *b, ASN1_INTEGER *ai)
+{
 	BIGNUM *btmp;
 	int ret = 0;
 	if (b)
@@ -1722,132 +1690,122 @@ int rand_serial(BIGNUM *b, ASN1_INTEGER *ai)
 		goto error;
 
 	ret = 1;
-	
-	error:
 
+error:
 	if (!b)
 		BN_free(btmp);
-	
+
 	return ret;
-	}
+}
 
-CA_DB *load_index(char *dbfile, DB_ATTR *db_attr)
-	{
+CA_DB *
+load_index(char *dbfile, DB_ATTR *db_attr)
+{
 	CA_DB *retdb = NULL;
 	TXT_DB *tmpdb = NULL;
 	BIO *in = BIO_new(BIO_s_file());
 	CONF *dbattr_conf = NULL;
 	char buf[1][BSIZE];
-	long errorline= -1;
+	long errorline = -1;
 
-	if (in == NULL)
-		{
+	if (in == NULL) {
 		ERR_print_errors(bio_err);
 		goto err;
-		}
-	if (BIO_read_filename(in,dbfile) <= 0)
-		{
+	}
+	if (BIO_read_filename(in, dbfile) <= 0) {
 		perror(dbfile);
-		BIO_printf(bio_err,"unable to open '%s'\n",dbfile);
+		BIO_printf(bio_err, "unable to open '%s'\n", dbfile);
 		goto err;
-		}
-	if ((tmpdb = TXT_DB_read(in,DB_NUMBER)) == NULL)
+	}
+	if ((tmpdb = TXT_DB_read(in, DB_NUMBER)) == NULL)
 		goto err;
 
 	(void) snprintf(buf[0], sizeof buf[0], "%s.attr", dbfile);
 	dbattr_conf = NCONF_new(NULL);
-	if (NCONF_load(dbattr_conf,buf[0],&errorline) <= 0)
-		{
-		if (errorline > 0)
-			{
+	if (NCONF_load(dbattr_conf, buf[0], &errorline) <= 0) {
+		if (errorline > 0) {
 			BIO_printf(bio_err,
-				"error on line %ld of db attribute file '%s'\n"
-				,errorline,buf[0]);
+			"error on line %ld of db attribute file '%s'\n"
+			, errorline, buf[0]);
 			goto err;
-			}
-		else
-			{
+		} else {
 			NCONF_free(dbattr_conf);
 			dbattr_conf = NULL;
-			}
 		}
+	}
 
-	if ((retdb = OPENSSL_malloc(sizeof(CA_DB))) == NULL)
-		{
+	if ((retdb = OPENSSL_malloc(sizeof(CA_DB))) == NULL) {
 		fprintf(stderr, "Out of memory\n");
 		goto err;
-		}
+	}
 
 	retdb->db = tmpdb;
 	tmpdb = NULL;
 	if (db_attr)
 		retdb->attributes = *db_attr;
-	else
-		{
+	else {
 		retdb->attributes.unique_subject = 1;
-		}
+	}
 
-	if (dbattr_conf)
-		{
-		char *p = NCONF_get_string(dbattr_conf,NULL,"unique_subject");
-		if (p)
-			{
+	if (dbattr_conf) {
+		char *p = NCONF_get_string(dbattr_conf, NULL, "unique_subject");
+		if (p) {
 #ifdef RL_DEBUG
 			BIO_printf(bio_err, "DEBUG[load_index]: unique_subject = \"%s\"\n", p);
 #endif
-			retdb->attributes.unique_subject = parse_yesno(p,1);
-			}
+			retdb->attributes.unique_subject = parse_yesno(p, 1);
 		}
+	}
 
- err:
-	if (dbattr_conf) NCONF_free(dbattr_conf);
-	if (tmpdb) TXT_DB_free(tmpdb);
-	if (in) BIO_free_all(in);
+err:
+	if (dbattr_conf)
+		NCONF_free(dbattr_conf);
+	if (tmpdb)
+		TXT_DB_free(tmpdb);
+	if (in)
+		BIO_free_all(in);
 	return retdb;
-	}
+}
 
-int index_index(CA_DB *db)
-	{
+int
+index_index(CA_DB *db)
+{
 	if (!TXT_DB_create_index(db->db, DB_serial, NULL,
-				LHASH_HASH_FN(index_serial),
-				LHASH_COMP_FN(index_serial)))
-		{
+	    LHASH_HASH_FN(index_serial),
+	    LHASH_COMP_FN(index_serial))) {
 		BIO_printf(bio_err,
-		  "error creating serial number index:(%ld,%ld,%ld)\n",
-		  			db->db->error,db->db->arg1,db->db->arg2);
-			return 0;
-		}
+		    "error creating serial number index:(%ld,%ld,%ld)\n",
+		    db->db->error, db->db->arg1, db->db->arg2);
+		return 0;
+	}
 
-	if (db->attributes.unique_subject
-		&& !TXT_DB_create_index(db->db, DB_name, index_name_qual,
-			LHASH_HASH_FN(index_name),
-			LHASH_COMP_FN(index_name)))
-		{
-		BIO_printf(bio_err,"error creating name index:(%ld,%ld,%ld)\n",
-			db->db->error,db->db->arg1,db->db->arg2);
+	if (db->attributes.unique_subject &&
+	    !TXT_DB_create_index(db->db, DB_name, index_name_qual,
+	    LHASH_HASH_FN(index_name), LHASH_COMP_FN(index_name))) {
+		BIO_printf(bio_err, "error creating name index:(%ld,%ld,%ld)\n",
+		    db->db->error, db->db->arg1, db->db->arg2);
 		return 0;
-		}
-	return 1;
 	}
+	return 1;
+}
 
-int save_index(const char *dbfile, const char *suffix, CA_DB *db)
-	{
+int
+save_index(const char *dbfile, const char *suffix, CA_DB *db)
+{
 	char buf[3][BSIZE];
 	BIO *out = BIO_new(BIO_s_file());
 	int j;
 
-	if (out == NULL)
-		{
+	if (out == NULL) {
 		ERR_print_errors(bio_err);
 		goto err;
-		}
+	}
 
 	j = strlen(dbfile) + strlen(suffix);
-	if (j + 6 >= BSIZE)
-		{
-		BIO_printf(bio_err,"file name too long\n");
+	if (j + 6 >= BSIZE) {
+		BIO_printf(bio_err, "file name too long\n");
 		goto err;
-		}
+	}
 
 	(void) snprintf(buf[2], sizeof buf[2], "%s.attr", dbfile);
 	(void) snprintf(buf[1], sizeof buf[1], "%s.attr.%s", dbfile, suffix);
@@ -1855,140 +1813,138 @@ int save_index(const char *dbfile, const char *suffix, CA_DB *db)
 #ifdef RL_DEBUG
 	BIO_printf(bio_err, "DEBUG: writing \"%s\"\n", buf[0]);
 #endif
-	if (BIO_write_filename(out,buf[0]) <= 0)
-		{
+	if (BIO_write_filename(out, buf[0]) <= 0) {
 		perror(dbfile);
-		BIO_printf(bio_err,"unable to open '%s'\n", dbfile);
+		BIO_printf(bio_err, "unable to open '%s'\n", dbfile);
 		goto err;
-		}
-	j=TXT_DB_write(out,db->db);
-	if (j <= 0) goto err;
-			
+	}
+	j = TXT_DB_write(out, db->db);
+	if (j <= 0)
+		goto err;
+
 	BIO_free(out);
 
 	out = BIO_new(BIO_s_file());
 #ifdef RL_DEBUG
 	BIO_printf(bio_err, "DEBUG: writing \"%s\"\n", buf[1]);
 #endif
-	if (BIO_write_filename(out,buf[1]) <= 0)
-		{
+	if (BIO_write_filename(out, buf[1]) <= 0) {
 		perror(buf[2]);
-		BIO_printf(bio_err,"unable to open '%s'\n", buf[2]);
+		BIO_printf(bio_err, "unable to open '%s'\n", buf[2]);
 		goto err;
-		}
-	BIO_printf(out,"unique_subject = %s\n",
-		db->attributes.unique_subject ? "yes" : "no");
+	}
+	BIO_printf(out, "unique_subject = %s\n",
+	    db->attributes.unique_subject ? "yes" : "no");
 	BIO_free(out);
 
 	return 1;
- err:
+err:
 	return 0;
-	}
+}
 
-int rotate_index(const char *dbfile, const char *new_suffix, const char *old_suffix)
-	{
+int
+rotate_index(const char *dbfile, const char *new_suffix, const char *old_suffix)
+{
 	char buf[5][BSIZE];
-	int i,j;
+	int i, j;
 
 	i = strlen(dbfile) + strlen(old_suffix);
 	j = strlen(dbfile) + strlen(new_suffix);
-	if (i > j) j = i;
-	if (j + 6 >= BSIZE)
-		{
-		BIO_printf(bio_err,"file name too long\n");
+	if (i > j)
+		j = i;
+	if (j + 6 >= BSIZE) {
+		BIO_printf(bio_err, "file name too long\n");
 		goto err;
-		}
+	}
 
 	(void) snprintf(buf[4], sizeof buf[4], "%s.attr", dbfile);
 	(void) snprintf(buf[2], sizeof buf[2], "%s.attr.%s",
-		dbfile, new_suffix);
+	    dbfile, new_suffix);
 	(void) snprintf(buf[0], sizeof buf[0], "%s.%s",
-		dbfile, new_suffix);
+	    dbfile, new_suffix);
 	(void) snprintf(buf[1], sizeof buf[1], "%s.%s",
-		dbfile, old_suffix);
+	    dbfile, old_suffix);
 	(void) snprintf(buf[3], sizeof buf[3], "%s.attr.%s",
-		dbfile, old_suffix);
+	    dbfile, old_suffix);
 #ifdef RL_DEBUG
 	BIO_printf(bio_err, "DEBUG: renaming \"%s\" to \"%s\"\n",
-		dbfile, buf[1]);
+	    dbfile, buf[1]);
 #endif
-	if (rename(dbfile,buf[1]) < 0 && errno != ENOENT
+	if (rename(dbfile, buf[1]) < 0 && errno != ENOENT
 #ifdef ENOTDIR
-		&& errno != ENOTDIR
+	    && errno != ENOTDIR
 #endif
-	   )		{
-			BIO_printf(bio_err,
-				"unable to rename %s to %s\n",
-				dbfile, buf[1]);
-			perror("reason");
-			goto err;
-			}
+	) {
+		BIO_printf(bio_err,
+		    "unable to rename %s to %s\n",
+		    dbfile, buf[1]);
+		perror("reason");
+		goto err;
+	}
 #ifdef RL_DEBUG
 	BIO_printf(bio_err, "DEBUG: renaming \"%s\" to \"%s\"\n",
-		buf[0],dbfile);
+	    buf[0], dbfile);
 #endif
-	if (rename(buf[0],dbfile) < 0)
-		{
+	if (rename(buf[0], dbfile) < 0) {
 		BIO_printf(bio_err,
-			"unable to rename %s to %s\n",
-			buf[0],dbfile);
+		    "unable to rename %s to %s\n",
+		    buf[0], dbfile);
 		perror("reason");
-		rename(buf[1],dbfile);
+		rename(buf[1], dbfile);
 		goto err;
-		}
+	}
 #ifdef RL_DEBUG
 	BIO_printf(bio_err, "DEBUG: renaming \"%s\" to \"%s\"\n",
-		buf[4],buf[3]);
+	    buf[4], buf[3]);
 #endif
-	if (rename(buf[4],buf[3]) < 0 && errno != ENOENT
+	if (rename(buf[4], buf[3]) < 0 && errno != ENOENT
 #ifdef ENOTDIR
-		&& errno != ENOTDIR
+	    && errno != ENOTDIR
 #endif
-	   )		{
-			BIO_printf(bio_err,
-				"unable to rename %s to %s\n",
-				buf[4], buf[3]);
-			perror("reason");
-			rename(dbfile,buf[0]);
-			rename(buf[1],dbfile);
-			goto err;
-			}
+	) {
+		BIO_printf(bio_err,
+		    "unable to rename %s to %s\n",
+		    buf[4], buf[3]);
+		perror("reason");
+		rename(dbfile, buf[0]);
+		rename(buf[1], dbfile);
+		goto err;
+	}
 #ifdef RL_DEBUG
 	BIO_printf(bio_err, "DEBUG: renaming \"%s\" to \"%s\"\n",
-		buf[2],buf[4]);
+	    buf[2], buf[4]);
 #endif
-	if (rename(buf[2],buf[4]) < 0)
-		{
+	if (rename(buf[2], buf[4]) < 0) {
 		BIO_printf(bio_err,
-			"unable to rename %s to %s\n",
-			buf[2],buf[4]);
+		    "unable to rename %s to %s\n",
+		    buf[2], buf[4]);
 		perror("reason");
-		rename(buf[3],buf[4]);
-		rename(dbfile,buf[0]);
-		rename(buf[1],dbfile);
+		rename(buf[3], buf[4]);
+		rename(dbfile, buf[0]);
+		rename(buf[1], dbfile);
 		goto err;
-		}
+	}
 	return 1;
- err:
+
+err:
 	return 0;
-	}
+}
 
-void free_index(CA_DB *db)
-	{
-	if (db)
-		{
+void
+free_index(CA_DB *db)
+{
+	if (db) {
 		if (db->db) TXT_DB_free(db->db);
-		OPENSSL_free(db);
-		}
+			OPENSSL_free(db);
 	}
+}
 
-int parse_yesno(const char *str, int def)
-	{
+int
+parse_yesno(const char *str, int def)
+{
 	int ret = def;
-	if (str)
-		{
-		switch (*str)
-			{
+	if (str) {
+		switch (*str) {
 		case 'f': /* false */
 		case 'F': /* FALSE */
 		case 'n': /* no */
@@ -2006,17 +1962,18 @@ int parse_yesno(const char *str, int def)
 		default:
 			ret = def;
 			break;
-			}
 		}
-	return ret;
 	}
+	return ret;
+}
 
 /*
  * subject is expected to be in the format /type0=value0/type1=value1/type2=...
  * where characters may be escaped by \
  */
-X509_NAME *parse_name(char *subject, long chtype, int multirdn)
-	{
+X509_NAME *
+parse_name(char *subject, long chtype, int multirdn)
+{
 	size_t buflen = strlen(subject)+1; /* to copy the types and values into. due to escaping, the copy can only become shorter */
 	char *buf = OPENSSL_malloc(buflen);
 	size_t max_ne = buflen / 2 + 1; /* maximum number of name elements */
@@ -2030,106 +1987,86 @@ X509_NAME *parse_name(char *subject, long chtype, int multirdn)
 	X509_NAME *n = NULL;
 	int nid;
 
-	if (!buf || !ne_types || !ne_values || !mval)
-		{
+	if (!buf || !ne_types || !ne_values || !mval) {
 		BIO_printf(bio_err, "malloc error\n");
 		goto error;
-		}	
+	}
 
-	if (*subject != '/')
-		{
+	if (*subject != '/') {
 		BIO_printf(bio_err, "Subject does not start with '/'.\n");
 		goto error;
-		}
+	}
 	sp++; /* skip leading / */
 
 	/* no multivalued RDN by default */
 	mval[ne_num] = 0;
 
-	while (*sp)
-		{
+	while (*sp) {
 		/* collect type */
 		ne_types[ne_num] = bp;
-		while (*sp)
-			{
+		while (*sp) {
 			if (*sp == '\\') /* is there anything to escape in the type...? */
-				{
+			{
 				if (*++sp)
 					*bp++ = *sp++;
-				else	
-					{
+				else {
 					BIO_printf(bio_err, "escape character at end of string\n");
 					goto error;
-					}
-				}	
-			else if (*sp == '=')
-				{
+				}
+			} else if (*sp == '=') {
 				sp++;
 				*bp++ = '\0';
 				break;
-				}
-			else
+			} else
 				*bp++ = *sp++;
-			}
-		if (!*sp)
-			{
+		}
+		if (!*sp) {
 			BIO_printf(bio_err, "end of string encountered while processing type of subject name element #%d\n", ne_num);
 			goto error;
-			}
+		}
 		ne_values[ne_num] = bp;
-		while (*sp)
-			{
-			if (*sp == '\\')
-				{
+		while (*sp) {
+			if (*sp == '\\') {
 				if (*++sp)
 					*bp++ = *sp++;
-				else
-					{
+				else {
 					BIO_printf(bio_err, "escape character at end of string\n");
 					goto error;
-					}
 				}
-			else if (*sp == '/')
-				{
+			} else if (*sp == '/') {
 				sp++;
 				/* no multivalued RDN by default */
-				mval[ne_num+1] = 0;
+				mval[ne_num + 1] = 0;
 				break;
-				}
-			else if (*sp == '+' && multirdn)
-				{
+			} else if (*sp == '+' && multirdn) {
 				/* a not escaped + signals a mutlivalued RDN */
 				sp++;
-				mval[ne_num+1] = -1;
+				mval[ne_num + 1] = -1;
 				break;
-				}
-			else
+			} else
 				*bp++ = *sp++;
-			}
+		}
 		*bp++ = '\0';
 		ne_num++;
-		}	
+	}
 
 	if (!(n = X509_NAME_new()))
 		goto error;
 
-	for (i = 0; i < ne_num; i++)
-		{
-		if ((nid=OBJ_txt2nid(ne_types[i])) == NID_undef)
-			{
+	for (i = 0; i < ne_num; i++) {
+		if ((nid = OBJ_txt2nid(ne_types[i])) == NID_undef) {
 			BIO_printf(bio_err, "Subject Attribute %s has no known NID, skipped\n", ne_types[i]);
 			continue;
-			}
+		}
 
-		if (!*ne_values[i])
-			{
+		if (!*ne_values[i]) {
 			BIO_printf(bio_err, "No value provided for Subject Attribute %s, skipped\n", ne_types[i]);
 			continue;
-			}
+		}
 
-		if (!X509_NAME_add_entry_by_NID(n, nid, chtype, (unsigned char*)ne_values[i], -1,-1,mval[i]))
+		if (!X509_NAME_add_entry_by_NID(n, nid, chtype, (unsigned char*)ne_values[i], -1, -1, mval[i]))
 			goto error;
-		}
+	}
 
 	OPENSSL_free(ne_values);
 	OPENSSL_free(ne_types);
@@ -2150,9 +2087,10 @@ error:
 	return NULL;
 }
 
-int args_verify(char ***pargs, int *pargc,
-			int *badarg, BIO *err, X509_VERIFY_PARAM **pm)
-	{
+int
+args_verify(char ***pargs, int *pargc,
+    int *badarg, BIO *err, X509_VERIFY_PARAM **pm)
+{
 	ASN1_OBJECT *otmp = NULL;
 	unsigned long flags = 0;
 	int i;
@@ -2160,80 +2098,62 @@ int args_verify(char ***pargs, int *pargc,
 	char **oldargs = *pargs;
 	char *arg = **pargs, *argn = (*pargs)[1];
 	time_t at_time = 0;
-	if (!strcmp(arg, "-policy"))
-		{
+	if (!strcmp(arg, "-policy")) {
 		if (!argn)
 			*badarg = 1;
-		else
-			{
+		else {
 			otmp = OBJ_txt2obj(argn, 0);
-			if (!otmp)
-				{
+			if (!otmp) {
 				BIO_printf(err, "Invalid Policy \"%s\"\n",
-									argn);
+				    argn);
 				*badarg = 1;
-				}
 			}
-		(*pargs)++;
 		}
-	else if (strcmp(arg,"-purpose") == 0)
-		{
+		(*pargs)++;
+	} else if (strcmp(arg, "-purpose") == 0) {
 		X509_PURPOSE *xptmp;
 		if (!argn)
 			*badarg = 1;
-		else
-			{
+		else {
 			i = X509_PURPOSE_get_by_sname(argn);
-			if(i < 0)
-				{
+			if (i < 0) {
 				BIO_printf(err, "unrecognized purpose\n");
 				*badarg = 1;
-				}
-			else
-				{
+			} else {
 				xptmp = X509_PURPOSE_get0(i);
 				purpose = X509_PURPOSE_get_id(xptmp);
-				}
 			}
-		(*pargs)++;
 		}
-	else if (strcmp(arg,"-verify_depth") == 0)
-		{
+		(*pargs)++;
+	} else if (strcmp(arg, "-verify_depth") == 0) {
 		if (!argn)
 			*badarg = 1;
-		else
-			{
+		else {
 			depth = atoi(argn);
-			if(depth < 0)
-				{
+			if (depth < 0) {
 				BIO_printf(err, "invalid depth\n");
 				*badarg = 1;
-				}
 			}
-		(*pargs)++;
 		}
-	else if (strcmp(arg,"-attime") == 0)
-		{
+		(*pargs)++;
+	} else if (strcmp(arg, "-attime") == 0) {
 		if (!argn)
 			*badarg = 1;
-		else
-			{
+		else {
 			long timestamp;
 			/* interpret the -attime argument as seconds since
 			 * Epoch */
-			if (sscanf(argn, "%li", &timestamp) != 1)
-				{
+			if (sscanf(argn, "%li", &timestamp) != 1) {
 				BIO_printf(bio_err,
-						"Error parsing timestamp %s\n",
-					   	argn);
+				    "Error parsing timestamp %s\n",
+				    argn);
 				*badarg = 1;
-				}
+			}
 			/* on some platforms time_t may be a float */
 			at_time = (time_t) timestamp;
-			}
-		(*pargs)++;
 		}
-	else if (!strcmp(arg, "-ignore_critical"))
+		(*pargs)++;
+	} else if (!strcmp(arg, "-ignore_critical"))
 		flags |= X509_V_FLAG_IGNORE_CRITICAL;
 	else if (!strcmp(arg, "-issuer_checks"))
 		flags |= X509_V_FLAG_CB_ISSUER_CHECK;
@@ -2262,19 +2182,17 @@ int args_verify(char ***pargs, int *pargc,
 	else
 		return 0;
 
-	if (*badarg)
-		{
+	if (*badarg) {
 		if (*pm)
 			X509_VERIFY_PARAM_free(*pm);
 		*pm = NULL;
 		goto end;
-		}
+	}
 
-	if (!*pm && !(*pm = X509_VERIFY_PARAM_new()))
-		{
+	if (!*pm && !(*pm = X509_VERIFY_PARAM_new())) {
 		*badarg = 1;
 		goto end;
-		}
+	}
 
 	if (otmp)
 		X509_VERIFY_PARAM_add0_policy(*pm, otmp);
@@ -2287,34 +2205,32 @@ int args_verify(char ***pargs, int *pargc,
 	if (depth >= 0)
 		X509_VERIFY_PARAM_set_depth(*pm, depth);
 
-	if (at_time) 
+	if (at_time)
 		X509_VERIFY_PARAM_set_time(*pm, at_time);
 
-	end:
-
+end:
 	(*pargs)++;
 
 	if (pargc)
 		*pargc -= *pargs - oldargs;
 
 	return 1;
-
-	}
+}
 
 /* Read whole contents of a BIO into an allocated memory buffer and
  * return it.
  */
 
-int bio_to_mem(unsigned char **out, int maxlen, BIO *in)
-	{
+int
+bio_to_mem(unsigned char **out, int maxlen, BIO *in)
+{
 	BIO *mem;
 	int len, ret;
 	unsigned char tbuf[1024];
 	mem = BIO_new(BIO_s_mem());
 	if (!mem)
 		return -1;
-	for(;;)
-		{
+	for (;;) {
 		if ((maxlen != -1) && maxlen < 1024)
 			len = maxlen;
 		else
@@ -2322,86 +2238,83 @@ int bio_to_mem(unsigned char **out, int maxlen, BIO *in)
 		len = BIO_read(in, tbuf, len);
 		if (len <= 0)
 			break;
-		if (BIO_write(mem, tbuf, len) != len)
-			{
+		if (BIO_write(mem, tbuf, len) != len) {
 			BIO_free(mem);
 			return -1;
-			}
+		}
 		maxlen -= len;
 
 		if (maxlen == 0)
 			break;
-		}
+	}
 	ret = BIO_get_mem_data(mem, (char **)out);
 	BIO_set_flags(mem, BIO_FLAGS_MEM_RDONLY);
 	BIO_free(mem);
 	return ret;
-	}
+}
 
-int pkey_ctrl_string(EVP_PKEY_CTX *ctx, char *value)
-	{
+int
+pkey_ctrl_string(EVP_PKEY_CTX *ctx, char *value)
+{
 	int rv;
 	char *stmp, *vtmp = NULL;
 	stmp = BUF_strdup(value);
 	if (!stmp)
 		return -1;
 	vtmp = strchr(stmp, ':');
-	if (vtmp)
-		{
+	if (vtmp) {
 		*vtmp = 0;
 		vtmp++;
-		}
+	}
 	rv = EVP_PKEY_CTX_ctrl_str(ctx, stmp, vtmp);
 	OPENSSL_free(stmp);
 	return rv;
-	}
+}
 
-static void nodes_print(BIO *out, const char *name,
-	STACK_OF(X509_POLICY_NODE) *nodes)
-	{
+static void
+nodes_print(BIO *out, const char *name, STACK_OF(X509_POLICY_NODE) *nodes)
+{
 	X509_POLICY_NODE *node;
 	int i;
 	BIO_printf(out, "%s Policies:", name);
-	if (nodes)
-		{
+	if (nodes) {
 		BIO_puts(out, "\n");
-		for (i = 0; i < sk_X509_POLICY_NODE_num(nodes); i++)
-			{
+		for (i = 0; i < sk_X509_POLICY_NODE_num(nodes); i++) {
 			node = sk_X509_POLICY_NODE_value(nodes, i);
 			X509_POLICY_NODE_print(out, node, 2);
-			}
 		}
-	else
+	} else
 		BIO_puts(out, " <empty>\n");
-	}
+}
 
-void policies_print(BIO *out, X509_STORE_CTX *ctx)
-	{
+void
+policies_print(BIO *out, X509_STORE_CTX *ctx)
+{
 	X509_POLICY_TREE *tree;
 	int explicit_policy;
 	int free_out = 0;
-	if (out == NULL)
-		{
+	if (out == NULL) {
 		out = BIO_new_fp(stderr, BIO_NOCLOSE);
 		free_out = 1;
-		}
+	}
 	tree = X509_STORE_CTX_get0_policy_tree(ctx);
 	explicit_policy = X509_STORE_CTX_get_explicit_policy(ctx);
 
 	BIO_printf(out, "Require explicit Policy: %s\n",
-				explicit_policy ? "True" : "False");
+	    explicit_policy ? "True" : "False");
 
 	nodes_print(out, "Authority", X509_policy_tree_get0_policies(tree));
 	nodes_print(out, "User", X509_policy_tree_get0_user_policies(tree));
 	if (free_out)
 		BIO_free(out);
-	}
+}
 
 #if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
 
-static JPAKE_CTX *jpake_init(const char *us, const char *them,
-							 const char *secret)
-	{
+static JPAKE_CTX *
+jpake_init(const char *us, const char *them,
+    const char *secret)
+{
 	BIGNUM *p = NULL;
 	BIGNUM *g = NULL;
 	BIGNUM *q = NULL;
@@ -2424,20 +2337,22 @@ static JPAKE_CTX *jpake_init(const char *us, const char *them,
 	BN_free(p);
 
 	return ctx;
-	}
+}
 
-static void jpake_send_part(BIO *conn, const JPAKE_STEP_PART *p)
-	{
+static void
+jpake_send_part(BIO *conn, const JPAKE_STEP_PART *p)
+{
 	BN_print(conn, p->gx);
 	BIO_puts(conn, "\n");
 	BN_print(conn, p->zkpx.gr);
 	BIO_puts(conn, "\n");
 	BN_print(conn, p->zkpx.b);
 	BIO_puts(conn, "\n");
-	}
+}
 
-static void jpake_send_step1(BIO *bconn, JPAKE_CTX *ctx)
-	{
+static void
+jpake_send_step1(BIO *bconn, JPAKE_CTX *ctx)
+{
 	JPAKE_STEP1 s1;
 
 	JPAKE_STEP1_init(&s1);
@@ -2446,10 +2361,11 @@ static void jpake_send_step1(BIO *bconn, JPAKE_CTX *ctx)
 	jpake_send_part(bconn, &s1.p2);
 	(void)BIO_flush(bconn);
 	JPAKE_STEP1_release(&s1);
-	}
+}
 
-static void jpake_send_step2(BIO *bconn, JPAKE_CTX *ctx)
-	{
+static void
+jpake_send_step2(BIO *bconn, JPAKE_CTX *ctx)
+{
 	JPAKE_STEP2 s2;
 
 	JPAKE_STEP2_init(&s2);
@@ -2457,10 +2373,11 @@ static void jpake_send_step2(BIO *bconn, JPAKE_CTX *ctx)
 	jpake_send_part(bconn, &s2);
 	(void)BIO_flush(bconn);
 	JPAKE_STEP2_release(&s2);
-	}
+}
 
-static void jpake_send_step3a(BIO *bconn, JPAKE_CTX *ctx)
-	{
+static void
+jpake_send_step3a(BIO *bconn, JPAKE_CTX *ctx)
+{
 	JPAKE_STEP3A s3a;
 
 	JPAKE_STEP3A_init(&s3a);
@@ -2468,10 +2385,11 @@ static void jpake_send_step3a(BIO *bconn, JPAKE_CTX *ctx)
 	BIO_write(bconn, s3a.hhk, sizeof s3a.hhk);
 	(void)BIO_flush(bconn);
 	JPAKE_STEP3A_release(&s3a);
-	}
+}
 
-static void jpake_send_step3b(BIO *bconn, JPAKE_CTX *ctx)
-	{
+static void
+jpake_send_step3b(BIO *bconn, JPAKE_CTX *ctx)
+{
 	JPAKE_STEP3B s3b;
 
 	JPAKE_STEP3B_init(&s3b);
@@ -2479,90 +2397,93 @@ static void jpake_send_step3b(BIO *bconn, JPAKE_CTX *ctx)
 	BIO_write(bconn, s3b.hk, sizeof s3b.hk);
 	(void)BIO_flush(bconn);
 	JPAKE_STEP3B_release(&s3b);
-	}
+}
 
-static void readbn(BIGNUM **bn, BIO *bconn)
-	{
+static void
+readbn(BIGNUM **bn, BIO *bconn)
+{
 	char buf[10240];
 	int l;
 
 	l = BIO_gets(bconn, buf, sizeof buf);
 	assert(l > 0);
-	assert(buf[l-1] == '\n');
-	buf[l-1] = '\0';
+	assert(buf[l - 1] == '\n');
+	buf[l - 1] = '\0';
 	BN_hex2bn(bn, buf);
-	}
+}
 
-static void jpake_receive_part(JPAKE_STEP_PART *p, BIO *bconn)
-	{
+static void
+jpake_receive_part(JPAKE_STEP_PART *p, BIO *bconn)
+{
 	readbn(&p->gx, bconn);
 	readbn(&p->zkpx.gr, bconn);
 	readbn(&p->zkpx.b, bconn);
-	}
+}
 
-static void jpake_receive_step1(JPAKE_CTX *ctx, BIO *bconn)
-	{
+static void
+jpake_receive_step1(JPAKE_CTX *ctx, BIO *bconn)
+{
 	JPAKE_STEP1 s1;
 
 	JPAKE_STEP1_init(&s1);
 	jpake_receive_part(&s1.p1, bconn);
 	jpake_receive_part(&s1.p2, bconn);
-	if(!JPAKE_STEP1_process(ctx, &s1))
-		{
+	if (!JPAKE_STEP1_process(ctx, &s1)) {
 		ERR_print_errors(bio_err);
 		exit(1);
-		}
-	JPAKE_STEP1_release(&s1);
 	}
+	JPAKE_STEP1_release(&s1);
+}
 
-static void jpake_receive_step2(JPAKE_CTX *ctx, BIO *bconn)
-	{
+static void
+jpake_receive_step2(JPAKE_CTX *ctx, BIO *bconn)
+{
 	JPAKE_STEP2 s2;
 
 	JPAKE_STEP2_init(&s2);
 	jpake_receive_part(&s2, bconn);
-	if(!JPAKE_STEP2_process(ctx, &s2))
-		{
+	if (!JPAKE_STEP2_process(ctx, &s2)) {
 		ERR_print_errors(bio_err);
 		exit(1);
-		}
-	JPAKE_STEP2_release(&s2);
 	}
+	JPAKE_STEP2_release(&s2);
+}
 
-static void jpake_receive_step3a(JPAKE_CTX *ctx, BIO *bconn)
-	{
+static void
+jpake_receive_step3a(JPAKE_CTX *ctx, BIO *bconn)
+{
 	JPAKE_STEP3A s3a;
 	int l;
 
 	JPAKE_STEP3A_init(&s3a);
 	l = BIO_read(bconn, s3a.hhk, sizeof s3a.hhk);
 	assert(l == sizeof s3a.hhk);
-	if(!JPAKE_STEP3A_process(ctx, &s3a))
-		{
+	if (!JPAKE_STEP3A_process(ctx, &s3a)) {
 		ERR_print_errors(bio_err);
 		exit(1);
-		}
-	JPAKE_STEP3A_release(&s3a);
 	}
+	JPAKE_STEP3A_release(&s3a);
+}
 
-static void jpake_receive_step3b(JPAKE_CTX *ctx, BIO *bconn)
-	{
+static void
+jpake_receive_step3b(JPAKE_CTX *ctx, BIO *bconn)
+{
 	JPAKE_STEP3B s3b;
 	int l;
 
 	JPAKE_STEP3B_init(&s3b);
 	l = BIO_read(bconn, s3b.hk, sizeof s3b.hk);
 	assert(l == sizeof s3b.hk);
-	if(!JPAKE_STEP3B_process(ctx, &s3b))
-		{
+	if (!JPAKE_STEP3B_process(ctx, &s3b)) {
 		ERR_print_errors(bio_err);
 		exit(1);
-		}
-	JPAKE_STEP3B_release(&s3b);
 	}
+	JPAKE_STEP3B_release(&s3b);
+}
 
-void jpake_client_auth(BIO *out, BIO *conn, const char *secret)
-	{
+void
+jpake_client_auth(BIO *out, BIO *conn, const char *secret)
+{
 	JPAKE_CTX *ctx;
 	BIO *bconn;
 
@@ -2588,10 +2509,11 @@ void jpake_client_auth(BIO *out, BIO *conn, const char *secret)
 	BIO_free(bconn);
 
 	JPAKE_CTX_free(ctx);
-	}
+}
 
-void jpake_server_auth(BIO *out, BIO *conn, const char *secret)
-	{
+void
+jpake_server_auth(BIO *out, BIO *conn, const char *secret)
+{
 	JPAKE_CTX *ctx;
 	BIO *bconn;
 
@@ -2617,7 +2539,7 @@ void jpake_server_auth(BIO *out, BIO *conn, const char *secret)
 	BIO_free(bconn);
 
 	JPAKE_CTX_free(ctx);
-	}
+}
 
 #endif
 
@@ -2630,8 +2552,9 @@ void jpake_server_auth(BIO *out, BIO *conn, const char *secret)
  *
  *   returns: a malloced buffer or NULL on failure.
  */
-unsigned char *next_protos_parse(unsigned short *outlen, const char *in)
-	{
+unsigned char *
+next_protos_parse(unsigned short *outlen, const char *in)
+{
 	size_t len;
 	unsigned char *out;
 	size_t i, start = 0;
@@ -2644,25 +2567,21 @@ unsigned char *next_protos_parse(unsigned short *outlen, const char *in)
 	if (!out)
 		return NULL;
 
-	for (i = 0; i <= len; ++i)
-		{
-		if (i == len || in[i] == ',')
-			{
-			if (i - start > 255)
-				{
+	for (i = 0; i <= len; ++i) {
+		if (i == len || in[i] == ', ') {
+			if (i - start > 255) {
 				OPENSSL_free(out);
 				return NULL;
-				}
+			}
 			out[start] = i - start;
 			start = i + 1;
-			}
-		else
-			out[i+1] = in[i];
-		}
+		} else
+			out[i + 1] = in[i];
+	}
 
 	*outlen = len + 1;
 	return out;
-	}
+}
 #endif  /* !OPENSSL_NO_TLSEXT && !OPENSSL_NO_NEXTPROTONEG */
 
 /*
@@ -2677,117 +2596,115 @@ unsigned char *next_protos_parse(unsigned short *outlen, const char *in)
 # include <windows.h>
 # include <tchar.h>
 
-static int WIN32_rename(const char *from, const char *to)
-	{
-	TCHAR  *tfrom=NULL,*tto;
+static int
+WIN32_rename(const char *from, const char *to)
+{
+	TCHAR  *tfrom = NULL, *tto;
 	DWORD	err;
-	int	ret=0;
+	int	ret = 0;
 
-	if (sizeof(TCHAR) == 1)
-		{
+	if (sizeof(TCHAR) == 1) {
 		tfrom = (TCHAR *)from;
-		tto   = (TCHAR *)to;
-		}
+		tto = (TCHAR *)to;
+	}
 	else	/* UNICODE path */
-		{
-		size_t i,flen=strlen(from)+1,tlen=strlen(to)+1;
-		tfrom = (TCHAR *)malloc(sizeof(TCHAR)*(flen+tlen));
-		if (tfrom==NULL) goto err;
-		tto=tfrom+flen;
+	{
+		size_t i, flen = strlen(from) + 1, tlen = strlen(to) + 1;
+		tfrom = (TCHAR *)malloc(sizeof(TCHAR)*(flen + tlen));
+		if (tfrom == NULL)
+			goto err;
+		tto = tfrom + flen;
 #if !defined(_WIN32_WCE) || _WIN32_WCE>=101
-		if (!MultiByteToWideChar(CP_ACP,0,from,flen,(WCHAR *)tfrom,flen))
+		if (!MultiByteToWideChar(CP_ACP, 0, from, flen, (WCHAR *)tfrom, flen))
 #endif
-			for (i=0;i<flen;i++)	tfrom[i]=(TCHAR)from[i];
+		for (i = 0;i < flen;i++)	tfrom[i] = (TCHAR)from[i];
 #if !defined(_WIN32_WCE) || _WIN32_WCE>=101
-		if (!MultiByteToWideChar(CP_ACP,0,to,  tlen,(WCHAR *)tto,  tlen))
+		if (!MultiByteToWideChar(CP_ACP, 0, to,  tlen, (WCHAR *)tto,  tlen))
 #endif
-			for (i=0;i<tlen;i++)	tto[i]  =(TCHAR)to[i];
+		for (i = 0;i < tlen;i++)	tto[i] = (TCHAR)to[i];
 		}
 
-	if (MoveFile(tfrom,tto))	goto ok;
-	err=GetLastError();
-	if (err==ERROR_ALREADY_EXISTS || err==ERROR_FILE_EXISTS)
-		{
-		if (DeleteFile(tto) && MoveFile(tfrom,tto))
+		if (MoveFile(tfrom, tto))
 			goto ok;
-		err=GetLastError();
-		}
-	if (err==ERROR_FILE_NOT_FOUND || err==ERROR_PATH_NOT_FOUND)
+	err = GetLastError();
+	if (err == ERROR_ALREADY_EXISTS || err == ERROR_FILE_EXISTS) {
+		if (DeleteFile(tto) && MoveFile(tfrom, tto))
+			goto ok;
+		err = GetLastError();
+	}
+	if (err == ERROR_FILE_NOT_FOUND || err == ERROR_PATH_NOT_FOUND)
 		errno = ENOENT;
-	else if (err==ERROR_ACCESS_DENIED)
+	else if (err == ERROR_ACCESS_DENIED)
 		errno = EACCES;
 	else
 		errno = EINVAL;	/* we could map more codes... */
 err:
-	ret=-1;
+	ret = -1;
 ok:
-	if (tfrom!=NULL && tfrom!=(TCHAR *)from)	free(tfrom);
-	return ret;
-	}
+	if (tfrom != NULL && tfrom != (TCHAR *)from)	free(tfrom);
+		return ret;
+}
 #endif
 
 /* app_tminterval section */
 #if defined(_WIN32)
-double app_tminterval(int stop,int usertime)
-	{
+double
+app_tminterval(int stop, int usertime)
+{
 	FILETIME		now;
-	double			ret=0;
+	double			ret = 0;
 	static ULARGE_INTEGER	tmstart;
-	static int		warning=1;
+	static int		warning = 1;
 #ifdef _WIN32_WINNT
-	static HANDLE		proc=NULL;
+	static HANDLE		proc = NULL;
 
-	if (proc==NULL)
-		{
+	if (proc == NULL) {
 		if (check_winnt())
-			proc = OpenProcess(PROCESS_QUERY_INFORMATION,FALSE,
-						GetCurrentProcessId());
-		if (proc==NULL) proc = (HANDLE)-1;
+			proc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE,
+			    GetCurrentProcessId());
+		if (proc == NULL) proc = (HANDLE) - 1;
 		}
 
-	if (usertime && proc!=(HANDLE)-1)
-		{
+		if (usertime && proc != (HANDLE) - 1) {
 		FILETIME junk;
-		GetProcessTimes(proc,&junk,&junk,&junk,&now);
-		}
-	else
+		GetProcessTimes(proc, &junk, &junk, &junk, &now);
+	} else
 #endif
-		{
+	{
 		SYSTEMTIME systime;
 
-		if (usertime && warning)
-			{
-			BIO_printf(bio_err,"To get meaningful results, run "
-					   "this program on idle system.\n");
-			warning=0;
-			}
-		GetSystemTime(&systime);
-		SystemTimeToFileTime(&systime,&now);
+		if (usertime && warning) {
+			BIO_printf(bio_err, "To get meaningful results, run "
+			"this program on idle system.\n");
+			warning = 0;
 		}
+		GetSystemTime(&systime);
+		SystemTimeToFileTime(&systime, &now);
+	}
 
-	if (stop==TM_START)
-		{
-		tmstart.u.LowPart  = now.dwLowDateTime;
+	if (stop == TM_START) {
+		tmstart.u.LowPart = now.dwLowDateTime;
 		tmstart.u.HighPart = now.dwHighDateTime;
-		}
+	}
 	else	{
 		ULARGE_INTEGER tmstop;
 
-		tmstop.u.LowPart   = now.dwLowDateTime;
-		tmstop.u.HighPart  = now.dwHighDateTime;
+		tmstop.u.LowPart = now.dwLowDateTime;
+		tmstop.u.HighPart = now.dwHighDateTime;
 
-		ret = (__int64)(tmstop.QuadPart - tmstart.QuadPart)*1e-7;
-		}
+		ret = (__int64)(tmstop.QuadPart - tmstart.QuadPart)*1e - 7;
+	}
 
 	return (ret);
-	}
+}
 
 #elif defined(OPENSSL_SYSTEM_VXWORKS)
 #include <time.h>
 
-double app_tminterval(int stop,int usertime)
-	{
-	double ret=0;
+double
+app_tminterval(int stop, int usertime)
+{
+	double ret = 0;
 #ifdef CLOCK_REALTIME
 	static struct timespec	tmstart;
 	struct timespec		now;
@@ -2795,34 +2712,37 @@ double app_tminterval(int stop,int usertime)
 	static unsigned long	tmstart;
 	unsigned long		now;
 #endif
-	static int warning=1;
+	static int warning = 1;
 
-	if (usertime && warning)
-		{
-		BIO_printf(bio_err,"To get meaningful results, run "
-				   "this program on idle system.\n");
-		warning=0;
-		}
+	if (usertime && warning) {
+		BIO_printf(bio_err, "To get meaningful results, run "
+		"this program on idle system.\n");
+		warning = 0;
+	}
 
 #ifdef CLOCK_REALTIME
-	clock_gettime(CLOCK_REALTIME,&now);
-	if (stop==TM_START)	tmstart = now;
-	else	ret = ( (now.tv_sec+now.tv_nsec*1e-9)
-			- (tmstart.tv_sec+tmstart.tv_nsec*1e-9) );
+	clock_gettime(CLOCK_REALTIME, &now);
+	if (stop == TM_START)
+		tmstart = now;
+	else	ret = ( (now.tv_sec + now.tv_nsec*1e - 9)
+		- (tmstart.tv_sec + tmstart.tv_nsec*1e - 9) );
 #else
 	now = tickGet();
-	if (stop==TM_START)	tmstart = now;
-	else			ret = (now - tmstart)/(double)sysClkRateGet();
+	if (stop == TM_START)
+		tmstart = now;
+	else
+		ret = (now - tmstart)/(double)sysClkRateGet();
 #endif
 	return (ret);
-	}
+}
 
 #elif defined(OPENSSL_SYSTEM_VMS)
 #include <time.h>
 #include <times.h>
 
-double app_tminterval(int stop,int usertime)
-	{
+double
+app_tminterval(int stop, int usertime)
+{
 	static clock_t	tmstart;
 	double		ret = 0;
 	clock_t		now;
@@ -2830,141 +2750,166 @@ double app_tminterval(int stop,int usertime)
 	struct tms	rus;
 
 	now = times(&rus);
-	if (usertime)	now = rus.tms_utime;
+	if (usertime)
+		now = rus.tms_utime;
 #else
 	if (usertime)
 		now = clock(); /* sum of user and kernel times */
 	else	{
 		struct timeval tv;
-		gettimeofday(&tv,NULL);
+		gettimeofday(&tv, NULL);
 		now = (clock_t)(
-			(unsigned long long)tv.tv_sec*CLK_TCK +
-			(unsigned long long)tv.tv_usec*(1000000/CLK_TCK)
-			);
-		}
+		    (unsigned long long)tv.tv_sec*CLK_TCK +
+		    (unsigned long long)tv.tv_usec*(1000000/CLK_TCK)
+		);
+	}
 #endif
-	if (stop==TM_START)	tmstart = now;
-	else			ret = (now - tmstart)/(double)(CLK_TCK);
+	if (stop == TM_START)
+		tmstart = now;
+	else
+		ret = (now - tmstart)/(double)(CLK_TCK);
 
 	return (ret);
-	}
+}
 
 #elif defined(_SC_CLK_TCK)	/* by means of unistd.h */
 #include <sys/times.h>
 
-double app_tminterval(int stop,int usertime)
-	{
+double
+app_tminterval(int stop, int usertime)
+{
 	double		ret = 0;
 	struct tms	rus;
 	clock_t		now = times(&rus);
 	static clock_t	tmstart;
 
-	if (usertime)		now = rus.tms_utime;
+	if (usertime)
+		now = rus.tms_utime;
 
-	if (stop==TM_START)	tmstart = now;
-	else
-		{
+	if (stop == TM_START)
+		tmstart = now;
+	else {
 		long int tck = sysconf(_SC_CLK_TCK);
 		ret = (now - tmstart)/(double)tck;
-		}
+	}
 
 	return (ret);
-	}
+}
 
 #else
 #include <sys/time.h>
 #include <sys/resource.h>
 
-double app_tminterval(int stop,int usertime)
-	{
+double
+app_tminterval(int stop, int usertime)
+{
 	double		ret = 0;
 	struct rusage	rus;
 	struct timeval	now;
 	static struct timeval tmstart;
 
-	if (usertime)		getrusage(RUSAGE_SELF,&rus), now = rus.ru_utime;
-	else			gettimeofday(&now,NULL);
+	if (usertime)
+		getrusage(RUSAGE_SELF, &rus), now = rus.ru_utime;
+	else
+		gettimeofday(&now, NULL);
 
-	if (stop==TM_START)	tmstart = now;
-	else			ret = ( (now.tv_sec+now.tv_usec*1e-6)
-					- (tmstart.tv_sec+tmstart.tv_usec*1e-6) );
+	if (stop == TM_START)
+		tmstart = now;
+	else
+		ret = ((now.tv_sec + now.tv_usec * 1e-6) -
+		    (tmstart.tv_sec + tmstart.tv_usec * 1e-6) );
 
 	return ret;
-	}
+}
 #endif
 
 /* app_isdir section */
 #ifdef _WIN32
-int app_isdir(const char *name)
-	{
+int
+app_isdir(const char *name)
+{
 	HANDLE		hList;
 	WIN32_FIND_DATA	FileData;
 #if defined(UNICODE) || defined(_UNICODE)
-	size_t i, len_0 = strlen(name)+1;
+	size_t i, len_0 = strlen(name) + 1;
 
 	if (len_0 > sizeof(FileData.cFileName)/sizeof(FileData.cFileName[0]))
 		return -1;
 
 #if !defined(_WIN32_WCE) || _WIN32_WCE>=101
-	if (!MultiByteToWideChar(CP_ACP,0,name,len_0,FileData.cFileName,len_0))
+	if (!MultiByteToWideChar(CP_ACP, 0, name, len_0, FileData.cFileName, len_0))
 #endif
-		for (i=0;i<len_0;i++)
-			FileData.cFileName[i] = (WCHAR)name[i];
+	for (i = 0; i < len_0; i++)
+		FileData.cFileName[i] = (WCHAR)name[i];
 
-	hList = FindFirstFile(FileData.cFileName,&FileData);
+	hList = FindFirstFile(FileData.cFileName, &FileData);
 #else
-	hList = FindFirstFile(name,&FileData);
+	hList = FindFirstFile(name, &FileData);
 #endif
-	if (hList == INVALID_HANDLE_VALUE)	return -1;
+	if (hList == INVALID_HANDLE_VALUE)
+		return -1;
 	FindClose(hList);
-	return ((FileData.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)!=0);
-	}
+	return ((FileData.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) != 0);
+}
 #else
 #include <sys/stat.h>
 #ifndef S_ISDIR
 # if defined(_S_IFMT) && defined(_S_IFDIR)
 #  define S_ISDIR(a)   (((a) & _S_IFMT) == _S_IFDIR)
-# else 
+# else
 #  define S_ISDIR(a)   (((a) & S_IFMT) == S_IFDIR)
-# endif 
-#endif 
+# endif
+#endif
 
-int app_isdir(const char *name)
-	{
+int
+app_isdir(const char *name)
+{
 #if defined(S_ISDIR)
 	struct stat st;
 
-	if (stat(name,&st)==0)	return S_ISDIR(st.st_mode);
-	else			return -1;
+	if (stat(name, &st) == 0)
+		return S_ISDIR(st.st_mode);
+	else
+		return -1;
 #else
 	return -1;
 #endif
-	}
+}
 #endif
 
 /* raw_read|write section */
 #if defined(_WIN32) && defined(STD_INPUT_HANDLE)
-int raw_read_stdin(void *buf,int siz)
-	{
+int
+raw_read_stdin(void *buf, int siz)
+{
 	DWORD n;
-	if (ReadFile(GetStdHandle(STD_INPUT_HANDLE),buf,siz,&n,NULL))
+	if (ReadFile(GetStdHandle(STD_INPUT_HANDLE), buf, siz, &n, NULL))
 		return (n);
-	else	return (-1);
-	}
+	else
+		return (-1);
+}
 #else
-int raw_read_stdin(void *buf,int siz)
-	{	return read(fileno(stdin),buf,siz);	}
+int
+raw_read_stdin(void *buf, int siz)
+{
+	return read(fileno(stdin), buf, siz);
+}
 #endif
 
 #if defined(_WIN32) && defined(STD_OUTPUT_HANDLE)
-int raw_write_stdout(const void *buf,int siz)
-	{
+int
+raw_write_stdout(const void *buf, int siz)
+{
 	DWORD n;
-	if (WriteFile(GetStdHandle(STD_OUTPUT_HANDLE),buf,siz,&n,NULL))
+	if (WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buf, siz, &n, NULL))
 		return (n);
-	else	return (-1);
-	}
+	else
+		return (-1);
+}
 #else
-int raw_write_stdout(const void *buf,int siz)
-	{	return write(fileno(stdout),buf,siz);	}
+int
+raw_write_stdout(const void *buf, int siz)
+{
+	return write(fileno(stdout), buf, siz);
+}
 #endif
diff --git a/lib/libssl/src/apps/apps.h b/lib/libssl/src/apps/apps.h
index 3aeb46c4e29..02af3176517 100644
--- a/lib/libssl/src/apps/apps.h
+++ b/lib/libssl/src/apps/apps.h
@@ -5,21 +5,21 @@
  * This package is an SSL implementation written
  * by Eric Young (eay@cryptsoft.com).
  * The implementation was written so as to conform with Netscapes SSL.
- * 
+ *
  * This library is free for commercial and non-commercial use as long as
  * the following conditions are aheared to.  The following conditions
  * apply to all code found in this distribution, be it the RC4, RSA,
  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  * included with this distribution is covered by the same copyright terms
  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- * 
+ *
  * Copyright remains Eric Young's, and as such any Copyright notices in
  * the code are not to be removed.
  * If this package is used in a product, Eric Young should be given attribution
  * as the author of the parts of the library used.
  * This can be in the form of a textual message at program startup or
  * in documentation (online or textual) provided with the package.
- * 
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ -34,10 +34,10 @@
  *     Eric Young (eay@cryptsoft.com)"
  *    The word 'cryptographic' can be left out if the rouines from the library
  *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from 
+ * 4. If you include any Windows specific code (or a derivative thereof) from
  *    the apps directory (application code) you must include an acknowledgement:
  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- * 
+ *
  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
@@ -49,7 +49,7 @@
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
- * 
+ *
  * The licence and distribution terms for any publically available version or
  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  * copied and put under another distribution licence
@@ -63,7 +63,7 @@
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer. 
+ *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
@@ -142,8 +142,8 @@ long app_RAND_load_files(char *file); /* `file' is a list of files to read,
 #define MAIN(a,v)	main(a,v)
 
 #ifndef NON_MAIN
-CONF *config=NULL;
-BIO *bio_err=NULL;
+CONF *config = NULL;
+BIO *bio_err = NULL;
 #else
 extern CONF *config;
 extern BIO *bio_err;
@@ -169,7 +169,7 @@ extern BIO *bio_err;
 #endif
 
 #ifdef OPENSSL_NO_COMP
-#define zlib_cleanup() 
+#define zlib_cleanup()
 #else
 #define zlib_cleanup() COMP_zlib_cleanup()
 #endif
@@ -211,21 +211,20 @@ extern BIO *bio_err;
 #endif
 
 
-typedef struct args_st
-	{
+typedef struct args_st {
 	char **data;
 	int count;
-	} ARGS;
+} ARGS;
 
 #define PW_MIN_LENGTH 4
-typedef struct pw_cb_data
-	{
+typedef struct pw_cb_data {
 	const void *password;
 	const char *prompt_info;
-	} PW_CB_DATA;
+} PW_CB_DATA;
 
-int password_callback(char *buf, int bufsiz, int verify,
-	PW_CB_DATA *cb_data);
+int
+password_callback(char *buf, int bufsiz, int verify,
+PW_CB_DATA *cb_data);
 
 int setup_ui_method(void);
 void destroy_ui_method(void);
@@ -233,8 +232,8 @@ void destroy_ui_method(void);
 int should_retry(int i);
 int args_from_file(char *file, int *argc, char **argv[]);
 int str2fmt(char *s);
-void program_name(char *in,char *out,int size);
-int chopup_args(ARGS *arg,char *buf, int *argc, char **argv[]);
+void program_name(char *in, char *out, int size);
+int chopup_args(ARGS *arg, char *buf, int *argc, char **argv[]);
 #ifdef HEADER_X509_H
 int dump_cert_text(BIO *out, X509 *x);
 void print_name(BIO *out, const char *title, X509_NAME *nm, unsigned long lflags);
@@ -246,15 +245,15 @@ int copy_extensions(X509 *x, X509_REQ *req, int copy_type);
 int app_passwd(BIO *err, char *arg1, char *arg2, char **pass1, char **pass2);
 int add_oid_section(BIO *err, CONF *conf);
 X509 *load_cert(BIO *err, const char *file, int format,
-	const char *pass, ENGINE *e, const char *cert_descrip);
+    const char *pass, ENGINE *e, const char *cert_descrip);
 EVP_PKEY *load_key(BIO *err, const char *file, int format, int maybe_stdin,
-	const char *pass, ENGINE *e, const char *key_descrip);
+    const char *pass, ENGINE *e, const char *key_descrip);
 EVP_PKEY *load_pubkey(BIO *err, const char *file, int format, int maybe_stdin,
-	const char *pass, ENGINE *e, const char *key_descrip);
+    const char *pass, ENGINE *e, const char *key_descrip);
 STACK_OF(X509) *load_certs(BIO *err, const char *file, int format,
-	const char *pass, ENGINE *e, const char *cert_descrip);
+    const char *pass, ENGINE *e, const char *cert_descrip);
 STACK_OF(X509_CRL) *load_crls(BIO *err, const char *file, int format,
-	const char *pass, ENGINE *e, const char *cert_descrip);
+    const char *pass, ENGINE *e, const char *cert_descrip);
 X509_STORE *setup_verify(BIO *bp, char *CAfile, char *CApath);
 #ifndef OPENSSL_NO_ENGINE
 ENGINE *setup_engine(BIO *err, const char *engine, int debug);
@@ -262,9 +261,8 @@ ENGINE *setup_engine(BIO *err, const char *engine, int debug);
 
 #ifndef OPENSSL_NO_OCSP
 OCSP_RESPONSE *process_responder(BIO *err, OCSP_REQUEST *req,
-			char *host, char *path, char *port, int use_ssl,
-			STACK_OF(CONF_VALUE) *headers,
-			int req_timeout);
+    char *host, char *path, char *port, int use_ssl,
+    STACK_OF(CONF_VALUE) *headers, int req_timeout);
 #endif
 
 int load_config(BIO *err, CONF *cnf);
@@ -272,13 +270,13 @@ char *make_config_name(void);
 
 /* Functions defined in ca.c and also used in ocsp.c */
 int unpack_revinfo(ASN1_TIME **prevtm, int *preason, ASN1_OBJECT **phold,
-			ASN1_GENERALIZEDTIME **pinvtm, const char *str);
+    ASN1_GENERALIZEDTIME **pinvtm, const char *str);
 
 #define DB_type         0
 #define DB_exp_date     1
 #define DB_rev_date     2
 #define DB_serial       3       /* index - unique */
-#define DB_file         4       
+#define DB_file         4
 #define DB_name         5       /* index - unique when active and not disabled */
 #define DB_NUMBER       6
 
@@ -286,15 +284,13 @@ int unpack_revinfo(ASN1_TIME **prevtm, int *preason, ASN1_OBJECT **phold,
 #define DB_TYPE_EXP	'E'
 #define DB_TYPE_VAL	'V'
 
-typedef struct db_attr_st
-	{
+typedef struct db_attr_st {
 	int unique_subject;
-	} DB_ATTR;
-typedef struct ca_db_st
-	{
+} DB_ATTR;
+typedef struct ca_db_st {
 	DB_ATTR attributes;
 	TXT_DB *db;
-	} CA_DB;
+} CA_DB;
 
 BIGNUM *load_serial(char *serialfile, int create, ASN1_INTEGER **retai);
 int save_serial(char *serialfile, char *suffix, BIGNUM *serial, ASN1_INTEGER **retai);
@@ -312,19 +308,19 @@ int index_name_cmp(const OPENSSL_CSTRING *a, const OPENSSL_CSTRING *b);
 int parse_yesno(const char *str, int def);
 
 X509_NAME *parse_name(char *str, long chtype, int multirdn);
-int args_verify(char ***pargs, int *pargc,
-			int *badarg, BIO *err, X509_VERIFY_PARAM **pm);
+int args_verify(char ***pargs, int *pargc, int *badarg, BIO *err,
+    X509_VERIFY_PARAM **pm);
 void policies_print(BIO *out, X509_STORE_CTX *ctx);
 int bio_to_mem(unsigned char **out, int maxlen, BIO *in);
 int pkey_ctrl_string(EVP_PKEY_CTX *ctx, char *value);
-int init_gen_str(BIO *err, EVP_PKEY_CTX **pctx,
-			const char *algname, ENGINE *e, int do_param);
+int init_gen_str(BIO *err, EVP_PKEY_CTX **pctx, const char *algname, ENGINE *e,
+    int do_param);
 int do_X509_sign(BIO *err, X509 *x, EVP_PKEY *pkey, const EVP_MD *md,
-			STACK_OF(OPENSSL_STRING) *sigopts);
+    STACK_OF(OPENSSL_STRING) *sigopts);
 int do_X509_REQ_sign(BIO *err, X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md,
-			STACK_OF(OPENSSL_STRING) *sigopts);
+    STACK_OF(OPENSSL_STRING) *sigopts);
 int do_X509_CRL_sign(BIO *err, X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md,
-			STACK_OF(OPENSSL_STRING) *sigopts);
+    STACK_OF(OPENSSL_STRING) *sigopts);
 #ifndef OPENSSL_NO_PSK
 extern char *psk_key;
 #endif
@@ -363,12 +359,12 @@ unsigned char *next_protos_parse(unsigned short *outlen, const char *in);
 #define SERIAL_RAND_BITS	64
 
 int app_isdir(const char *);
-int raw_read_stdin(void *,int);
-int raw_write_stdout(const void *,int);
+int raw_read_stdin(void *, int);
+int raw_write_stdout(const void *, int);
 
 #define TM_START	0
 #define TM_STOP		1
-double app_tminterval (int stop,int usertime);
+double app_tminterval (int stop, int usertime);
 
 #define OPENSSL_NO_SSL_INTERN