Initial KNF.

4 files changed, 505 insertions, 508 deletions

diff --git a/lib/libcrypto/asn1/a_bitstr.c b/lib/libcrypto/asn1/a_bitstr.c
index e2b65bf2ac4..5633cfca1c5 100644
--- a/lib/libcrypto/asn1/a_bitstr.c
+++ b/lib/libcrypto/asn1/a_bitstr.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
@@ -60,82 +60,91 @@
 #include "cryptlib.h"
 #include <openssl/asn1.h>
 
-int ASN1_BIT_STRING_set(ASN1_BIT_STRING *x, unsigned char *d, int len)
-{ return M_ASN1_BIT_STRING_set(x, d, len); }
+int
+ASN1_BIT_STRING_set(ASN1_BIT_STRING *x, unsigned char *d, int len)
+{
+	return M_ASN1_BIT_STRING_set(x, d, len);
+}
 
-int i2c_ASN1_BIT_STRING(ASN1_BIT_STRING *a, unsigned char **pp)
-	{
-	int ret,j,bits,len;
-	unsigned char *p,*d;
+int
+i2c_ASN1_BIT_STRING(ASN1_BIT_STRING *a, unsigned char **pp)
+{
+	int ret, j,bits, len;
+	unsigned char *p, *d;
 
-	if (a == NULL) return(0);
+	if (a == NULL)
+		return (0);
 
-	len=a->length;
+	len = a->length;
 
-	if (len > 0)
-		{
-		if (a->flags & ASN1_STRING_FLAG_BITS_LEFT)
-			{
-			bits=(int)a->flags&0x07;
-			}
-		else
-			{
-			for ( ; len > 0; len--)
-				{
-				if (a->data[len-1]) break;
-				}
-			j=a->data[len-1];
-			if      (j & 0x01) bits=0;
-			else if (j & 0x02) bits=1;
-			else if (j & 0x04) bits=2;
-			else if (j & 0x08) bits=3;
-			else if (j & 0x10) bits=4;
-			else if (j & 0x20) bits=5;
-			else if (j & 0x40) bits=6;
-			else if (j & 0x80) bits=7;
-			else bits=0; /* should not happen */
+	if (len > 0) {
+		if (a->flags & ASN1_STRING_FLAG_BITS_LEFT) {
+			bits = (int)a->flags & 0x07;
+		} else {
+			for (; len > 0; len--) {
+				if (a->data[len - 1])
+					break;
 			}
+			j = a->data[len - 1];
+			if (j & 0x01)
+				bits = 0;
+			else if (j & 0x02)
+				bits = 1;
+			else if (j & 0x04)
+				bits = 2;
+			else if (j & 0x08)
+				bits = 3;
+			else if (j & 0x10)
+				bits = 4;
+			else if (j & 0x20)
+				bits = 5;
+			else if (j & 0x40)
+				bits = 6;
+			else if (j & 0x80)
+				bits = 7;
+			else
+				bits = 0; /* should not happen */
 		}
-	else
-		bits=0;
+	} else
+		bits = 0;
 
-	ret=1+len;
-	if (pp == NULL) return(ret);
+	ret = 1 + len;
+	if (pp == NULL)
+		return (ret);
 
 	p= *pp;
 
-	*(p++)=(unsigned char)bits;
-	d=a->data;
-	memcpy(p,d,len);
-	p+=len;
-	if (len > 0) p[-1]&=(0xff<<bits);
-	*pp=p;
-	return(ret);
-	}
+	*(p++) = (unsigned char)bits;
+	d = a->data;
+	memcpy(p, d, len);
+	p += len;
+	if (len > 0)
+		p[-1]&=(0xff << bits);
+	*pp = p;
+	return (ret);
+}
 
-ASN1_BIT_STRING *c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a,
-	const unsigned char **pp, long len)
-	{
-	ASN1_BIT_STRING *ret=NULL;
+ASN1_BIT_STRING *
+c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a, const unsigned char **pp, long len)
+{
+	ASN1_BIT_STRING *ret = NULL;
 	const unsigned char *p;
 	unsigned char *s;
 	int i;
 
-	if (len < 1)
-		{
-		i=ASN1_R_STRING_TOO_SHORT;
+	if (len < 1) {
+		i = ASN1_R_STRING_TOO_SHORT;
 		goto err;
-		}
+	}
 
-	if ((a == NULL) || ((*a) == NULL))
-		{
-		if ((ret=M_ASN1_BIT_STRING_new()) == NULL) return(NULL);
-		}
-	else
-		ret=(*a);
+	if ((a == NULL) || ((*a) == NULL)) {
+		if ((ret = M_ASN1_BIT_STRING_new()) == NULL)
+			return (NULL);
+	} else
+		ret = (*a);
 
-	p= *pp;
-	i= *(p++);
+	p = *pp;
+	i = *(p++);
 	/* We do this to preserve the settings.  If we modify
 	 * the settings, via the _set_bit function, we will recalculate
 	 * on output */
@@ -143,106 +152,111 @@ ASN1_BIT_STRING *c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a,
 	ret->flags|=(ASN1_STRING_FLAG_BITS_LEFT|(i&0x07)); /* set */
 
 	if (len-- > 1) /* using one because of the bits left byte */
-		{
-		s=(unsigned char *)malloc((int)len);
-		if (s == NULL)
-			{
-			i=ERR_R_MALLOC_FAILURE;
+	{
+		s = (unsigned char *)malloc((int)len);
+		if (s == NULL) {
+			i = ERR_R_MALLOC_FAILURE;
 			goto err;
-			}
-		memcpy(s,p,(int)len);
-		s[len-1]&=(0xff<<i);
-		p+=len;
 		}
-	else
-		s=NULL;
-
-	ret->length=(int)len;
-	if (ret->data != NULL) free(ret->data);
-	ret->data=s;
-	ret->type=V_ASN1_BIT_STRING;
-	if (a != NULL) (*a)=ret;
-	*pp=p;
-	return(ret);
+		memcpy(s, p, (int)len);
+		s[len - 1] &= (0xff << i);
+		p += len;
+	} else
+		s = NULL;
+
+	ret->length = (int)len;
+	if (ret->data != NULL)
+		free(ret->data);
+	ret->data = s;
+	ret->type = V_ASN1_BIT_STRING;
+	if (a != NULL)
+		(*a) = ret;
+	*pp = p;
+	return (ret);
+
 err:
-	ASN1err(ASN1_F_C2I_ASN1_BIT_STRING,i);
+	ASN1err(ASN1_F_C2I_ASN1_BIT_STRING, i);
 	if ((ret != NULL) && ((a == NULL) || (*a != ret)))
 		M_ASN1_BIT_STRING_free(ret);
-	return(NULL);
-	}
+	return (NULL);
+}
 
 /* These next 2 functions from Goetz Babin-Ebell <babinebell@trustcenter.de>
  */
-int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value)
-	{
-	int w,v,iv;
+int
+ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value)
+{
+	int w, v, iv;
 	unsigned char *c;
 
-	w=n/8;
-	v=1<<(7-(n&0x07));
-	iv= ~v;
-	if (!value) v=0;
+	w = n/8;
+	v = 1 << (7 - (n & 0x07));
+	iv = ~v;
+	if (!value)
+		v = 0;
 
 	if (a == NULL)
 		return 0;
 
-	a->flags&= ~(ASN1_STRING_FLAG_BITS_LEFT|0x07); /* clear, set on write */
+	a->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT|0x07); /* clear, set on write */
 
-	if ((a->length < (w+1)) || (a->data == NULL))
-		{
-		if (!value) return(1); /* Don't need to set */
+	if ((a->length < (w + 1)) || (a->data == NULL)) {
+		if (!value)
+			return(1); /* Don't need to set */
 		if (a->data == NULL)
-			c=(unsigned char *)malloc(w+1);
+			c = (unsigned char *)malloc(w + 1);
 		else
-			c=(unsigned char *)OPENSSL_realloc_clean(a->data,
-								 a->length,
-								 w+1);
-		if (c == NULL)
-			{
-			ASN1err(ASN1_F_ASN1_BIT_STRING_SET_BIT,ERR_R_MALLOC_FAILURE);
+			c = (unsigned char *)OPENSSL_realloc_clean(a->data,
+			    a->length, w + 1);
+		if (c == NULL) {
+			ASN1err(ASN1_F_ASN1_BIT_STRING_SET_BIT, ERR_R_MALLOC_FAILURE);
 			return 0;
-			}
-  		if (w+1-a->length > 0) memset(c+a->length, 0, w+1-a->length);
-		a->data=c;
-		a->length=w+1;
+		}
+		if (w + 1 - a->length > 0)
+			memset(c + a->length, 0, w + 1 - a->length);
+		a->data = c;
+		a->length = w + 1;
 	}
-	a->data[w]=((a->data[w])&iv)|v;
-	while ((a->length > 0) && (a->data[a->length-1] == 0))
+	a->data[w] = ((a->data[w]) & iv) | v;
+	while ((a->length > 0) && (a->data[a->length - 1] == 0))
 		a->length--;
-	return(1);
-	}
 
-int ASN1_BIT_STRING_get_bit(ASN1_BIT_STRING *a, int n)
-	{
-	int w,v;
+	return (1);
+}
 
-	w=n/8;
-	v=1<<(7-(n&0x07));
-	if ((a == NULL) || (a->length < (w+1)) || (a->data == NULL))
-		return(0);
-	return((a->data[w]&v) != 0);
-	}
+int
+ASN1_BIT_STRING_get_bit(ASN1_BIT_STRING *a, int n)
+{
+	int w, v;
+
+	w = n / 8;
+	v = 1 << (7 - (n & 0x07));
+	if ((a == NULL) || (a->length < (w + 1)) || (a->data == NULL))
+		return (0);
+	return ((a->data[w] & v) != 0);
+}
 
 /*
- * Checks if the given bit string contains only bits specified by 
+ * Checks if the given bit string contains only bits specified by
  * the flags vector. Returns 0 if there is at least one bit set in 'a'
  * which is not specified in 'flags', 1 otherwise.
  * 'len' is the length of 'flags'.
  */
-int ASN1_BIT_STRING_check(ASN1_BIT_STRING *a,
-			  unsigned char *flags, int flags_len)
-	{
+int
+ASN1_BIT_STRING_check(ASN1_BIT_STRING *a, unsigned char *flags, int flags_len)
+{
 	int i, ok;
+
 	/* Check if there is one bit set at all. */
-	if (!a || !a->data) return 1;
+	if (!a || !a->data)
+		return 1;
 
 	/* Check each byte of the internal representation of the bit string. */
 	ok = 1;
-	for (i = 0; i < a->length && ok; ++i)
-		{
+	for (i = 0; i < a->length && ok; ++i) {
 		unsigned char mask = i < flags_len ? ~flags[i] : 0xff;
 		/* We are done if there is an unneeded bit set. */
 		ok = (a->data[i] & mask) == 0;
-		}
-	return ok;
 	}
+	return ok;
+}
diff --git a/lib/libcrypto/asn1/a_bool.c b/lib/libcrypto/asn1/a_bool.c
index 331acdf0535..c8c180d6f7a 100644
--- a/lib/libcrypto/asn1/a_bool.c
+++ b/lib/libcrypto/asn1/a_bool.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
@@ -60,55 +60,55 @@
 #include "cryptlib.h"
 #include <openssl/asn1t.h>
 
-int i2d_ASN1_BOOLEAN(int a, unsigned char **pp)
-	{
+int
+i2d_ASN1_BOOLEAN(int a, unsigned char **pp)
+{
 	int r;
 	unsigned char *p;
 
-	r=ASN1_object_size(0,1,V_ASN1_BOOLEAN);
-	if (pp == NULL) return(r);
-	p= *pp;
+	r = ASN1_object_size(0, 1, V_ASN1_BOOLEAN);
+	if (pp == NULL)
+		return (r);
+	p = *pp;
 
-	ASN1_put_object(&p,0,1,V_ASN1_BOOLEAN,V_ASN1_UNIVERSAL);
-	*(p++)= (unsigned char)a;
-	*pp=p;
-	return(r);
-	}
+	ASN1_put_object(&p, 0, 1, V_ASN1_BOOLEAN, V_ASN1_UNIVERSAL);
+	*(p++) = (unsigned char)a;
+	*pp = p;
+	return (r);
+}
 
-int d2i_ASN1_BOOLEAN(int *a, const unsigned char **pp, long length)
-	{
-	int ret= -1;
+int
+d2i_ASN1_BOOLEAN(int *a, const unsigned char **pp, long length)
+{
+	int ret = -1;
 	const unsigned char *p;
 	long len;
-	int inf,tag,xclass;
-	int i=0;
+	int inf, tag, xclass;
+	int i = 0;
 
-	p= *pp;
-	inf=ASN1_get_object(&p,&len,&tag,&xclass,length);
-	if (inf & 0x80)
-		{
-		i=ASN1_R_BAD_OBJECT_HEADER;
+	p = *pp;
+	inf = ASN1_get_object(&p, &len, &tag, &xclass, length);
+	if (inf & 0x80) {
+		i = ASN1_R_BAD_OBJECT_HEADER;
 		goto err;
-		}
+	}
 
-	if (tag != V_ASN1_BOOLEAN)
-		{
-		i=ASN1_R_EXPECTING_A_BOOLEAN;
+	if (tag != V_ASN1_BOOLEAN) {
+		i = ASN1_R_EXPECTING_A_BOOLEAN;
 		goto err;
-		}
+	}
 
-	if (len != 1)
-		{
-		i=ASN1_R_BOOLEAN_IS_WRONG_LENGTH;
+	if (len != 1) {
+		i = ASN1_R_BOOLEAN_IS_WRONG_LENGTH;
 		goto err;
-		}
-	ret= (int)*(p++);
-	if (a != NULL) (*a)=ret;
-	*pp=p;
-	return(ret);
-err:
-	ASN1err(ASN1_F_D2I_ASN1_BOOLEAN,i);
-	return(ret);
 	}
+	ret = (int)*(p++);
+	if (a != NULL)
+		(*a) = ret;
+	*pp = p;
+	return (ret);
 
-
+err:
+	ASN1err(ASN1_F_D2I_ASN1_BOOLEAN, i);
+	return (ret);
+}
diff --git a/lib/libcrypto/asn1/a_bytes.c b/lib/libcrypto/asn1/a_bytes.c
index 8431d89edff..30647c97b5e 100644
--- a/lib/libcrypto/asn1/a_bytes.c
+++ b/lib/libcrypto/asn1/a_bytes.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,252 +63,247 @@
 static int asn1_collate_primitive(ASN1_STRING *a, ASN1_const_CTX *c);
 /* type is a 'bitmap' of acceptable string types.
  */
-ASN1_STRING *d2i_ASN1_type_bytes(ASN1_STRING **a, const unsigned char **pp,
-	     long length, int type)
-	{
-	ASN1_STRING *ret=NULL;
+ASN1_STRING *
+d2i_ASN1_type_bytes(ASN1_STRING **a, const unsigned char **pp,
+    long length, int type)
+{
+	ASN1_STRING *ret = NULL;
 	const unsigned char *p;
 	unsigned char *s;
 	long len;
-	int inf,tag,xclass;
-	int i=0;
+	int inf, tag, xclass;
+	int i = 0;
 
-	p= *pp;
-	inf=ASN1_get_object(&p,&len,&tag,&xclass,length);
-	if (inf & 0x80) goto err;
+	p = *pp;
+	inf = ASN1_get_object(&p, &len, &tag, &xclass, length);
+	if (inf & 0x80)
+		goto err;
 
-	if (tag >= 32)
-		{
-		i=ASN1_R_TAG_VALUE_TOO_HIGH;
+	if (tag >= 32) {
+		i = ASN1_R_TAG_VALUE_TOO_HIGH;
 		goto err;
-		}
-	if (!(ASN1_tag2bit(tag) & type))
-		{
-		i=ASN1_R_WRONG_TYPE;
+	}
+	if (!(ASN1_tag2bit(tag) & type)) {
+		i = ASN1_R_WRONG_TYPE;
 		goto err;
-		}
+	}
 
 	/* If a bit-string, exit early */
 	if (tag == V_ASN1_BIT_STRING)
-		return(d2i_ASN1_BIT_STRING(a,pp,length));
+		return (d2i_ASN1_BIT_STRING(a, pp, length));
 
-	if ((a == NULL) || ((*a) == NULL))
-		{
-		if ((ret=ASN1_STRING_new()) == NULL) return(NULL);
-		}
-	else
-		ret=(*a);
-
-	if (len != 0)
-		{
-		s=(unsigned char *)malloc((int)len+1);
-		if (s == NULL)
-			{
-			i=ERR_R_MALLOC_FAILURE;
+	if ((a == NULL) || ((*a) == NULL)) {
+		if ((ret = ASN1_STRING_new()) == NULL)
+			return (NULL);
+	} else
+		ret = (*a);
+
+	if (len != 0) {
+		s = (unsigned char *)malloc((int)len + 1);
+		if (s == NULL) {
+			i = ERR_R_MALLOC_FAILURE;
 			goto err;
-			}
-		memcpy(s,p,(int)len);
-		s[len]='\0';
-		p+=len;
 		}
-	else
-		s=NULL;
-
-	if (ret->data != NULL) free(ret->data);
-	ret->length=(int)len;
-	ret->data=s;
-	ret->type=tag;
-	if (a != NULL) (*a)=ret;
-	*pp=p;
-	return(ret);
+		memcpy(s, p, (int)len);
+		s[len]='\0';
+		p += len;
+	} else
+		s = NULL;
+
+	if (ret->data != NULL)
+		free(ret->data);
+	ret->length = (int)len;
+	ret->data = s;
+	ret->type = tag;
+	if (a != NULL)
+		(*a) = ret;
+	*pp = p;
+	return (ret);
+
 err:
-	ASN1err(ASN1_F_D2I_ASN1_TYPE_BYTES,i);
+	ASN1err(ASN1_F_D2I_ASN1_TYPE_BYTES, i);
 	if ((ret != NULL) && ((a == NULL) || (*a != ret)))
 		ASN1_STRING_free(ret);
-	return(NULL);
-	}
+	return (NULL);
+}
 
-int i2d_ASN1_bytes(ASN1_STRING *a, unsigned char **pp, int tag, int xclass)
-	{
-	int ret,r,constructed;
+int
+i2d_ASN1_bytes(ASN1_STRING *a, unsigned char **pp, int tag, int xclass)
+{
+	int ret, r, constructed;
 	unsigned char *p;
 
-	if (a == NULL)  return(0);
+	if (a == NULL)
+		return (0);
 
 	if (tag == V_ASN1_BIT_STRING)
-		return(i2d_ASN1_BIT_STRING(a,pp));
-		
-	ret=a->length;
-	r=ASN1_object_size(0,ret,tag);
-	if (pp == NULL) return(r);
-	p= *pp;
+		return (i2d_ASN1_BIT_STRING(a, pp));
+
+	ret = a->length;
+	r = ASN1_object_size(0, ret, tag);
+	if (pp == NULL)
+		return (r);
+	p = *pp;
 
 	if ((tag == V_ASN1_SEQUENCE) || (tag == V_ASN1_SET))
-		constructed=1;
+		constructed = 1;
 	else
-		constructed=0;
-	ASN1_put_object(&p,constructed,ret,tag,xclass);
-	memcpy(p,a->data,a->length);
-	p+=a->length;
-	*pp= p;
-	return(r);
-	}
+		constructed = 0;
+	ASN1_put_object(&p, constructed, ret, tag, xclass);
+	memcpy(p, a->data, a->length);
+	p += a->length;
+	*pp = p;
+	return (r);
+}
 
-ASN1_STRING *d2i_ASN1_bytes(ASN1_STRING **a, const unsigned char **pp,
-	     long length, int Ptag, int Pclass)
-	{
-	ASN1_STRING *ret=NULL;
+ASN1_STRING *
+d2i_ASN1_bytes(ASN1_STRING **a, const unsigned char **pp,
+    long length, int Ptag, int Pclass)
+{
+	ASN1_STRING *ret = NULL;
 	const unsigned char *p;
 	unsigned char *s;
 	long len;
-	int inf,tag,xclass;
-	int i=0;
+	int inf, tag, xclass;
+	int i = 0;
 
-	if ((a == NULL) || ((*a) == NULL))
-		{
-		if ((ret=ASN1_STRING_new()) == NULL) return(NULL);
-		}
-	else
-		ret=(*a);
+	if ((a == NULL) || ((*a) == NULL)) {
+		if ((ret = ASN1_STRING_new()) == NULL)
+			return (NULL);
+	} else
+		ret = (*a);
 
 	p= *pp;
-	inf=ASN1_get_object(&p,&len,&tag,&xclass,length);
-	if (inf & 0x80)
-		{
-		i=ASN1_R_BAD_OBJECT_HEADER;
+	inf = ASN1_get_object(&p, &len, &tag, &xclass, length);
+	if (inf & 0x80) {
+		i = ASN1_R_BAD_OBJECT_HEADER;
 		goto err;
-		}
+	}
 
-	if (tag != Ptag)
-		{
-		i=ASN1_R_WRONG_TAG;
+	if (tag != Ptag) {
+		i = ASN1_R_WRONG_TAG;
 		goto err;
-		}
+	}
 
-	if (inf & V_ASN1_CONSTRUCTED)
-		{
+	if (inf & V_ASN1_CONSTRUCTED) {
 		ASN1_const_CTX c;
 
-		c.pp=pp;
-		c.p=p;
-		c.inf=inf;
-		c.slen=len;
-		c.tag=Ptag;
-		c.xclass=Pclass;
-		c.max=(length == 0)?0:(p+length);
-		if (!asn1_collate_primitive(ret,&c)) 
-			goto err; 
-		else
-			{
-			p=c.p;
-			}
+		c.pp = pp;
+		c.p = p;
+		c.inf = inf;
+		c.slen = len;
+		c.tag = Ptag;
+		c.xclass = Pclass;
+		c.max = (length == 0) ? 0 : (p + length);
+		if (!asn1_collate_primitive(ret, &c))
+			goto err;
+		else {
+			p = c.p;
 		}
-	else
-		{
-		if (len != 0)
-			{
-			if ((ret->length < len) || (ret->data == NULL))
-				{
-				if (ret->data != NULL) free(ret->data);
-				s=(unsigned char *)malloc((int)len + 1);
-				if (s == NULL)
-					{
-					i=ERR_R_MALLOC_FAILURE;
+	} else {
+		if (len != 0) {
+			if ((ret->length < len) || (ret->data == NULL)) {
+				if (ret->data != NULL)
+					free(ret->data);
+				s = (unsigned char *)malloc((int)len + 1);
+				if (s == NULL) {
+					i = ERR_R_MALLOC_FAILURE;
 					goto err;
-					}
 				}
-			else
-				s=ret->data;
-			memcpy(s,p,(int)len);
+			} else
+				s = ret->data;
+			memcpy(s, p, (int)len);
 			s[len] = '\0';
-			p+=len;
-			}
-		else
-			{
-			s=NULL;
-			if (ret->data != NULL) free(ret->data);
-			}
-
-		ret->length=(int)len;
-		ret->data=s;
-		ret->type=Ptag;
+			p += len;
+		} else {
+			s = NULL;
+			if (ret->data != NULL)
+				free(ret->data);
 		}
 
-	if (a != NULL) (*a)=ret;
-	*pp=p;
-	return(ret);
+		ret->length = (int)len;
+		ret->data = s;
+		ret->type = Ptag;
+	}
+
+	if (a != NULL)
+		(*a) = ret;
+	*pp = p;
+	return (ret);
+
 err:
 	if ((ret != NULL) && ((a == NULL) || (*a != ret)))
 		ASN1_STRING_free(ret);
-	ASN1err(ASN1_F_D2I_ASN1_BYTES,i);
-	return(NULL);
-	}
+	ASN1err(ASN1_F_D2I_ASN1_BYTES, i);
+	return (NULL);
+}
 
 
 /* We are about to parse 0..n d2i_ASN1_bytes objects, we are to collapse
  * them into the one structure that is then returned */
 /* There have been a few bug fixes for this function from
  * Paul Keogh <paul.keogh@sse.ie>, many thanks to him */
-static int asn1_collate_primitive(ASN1_STRING *a, ASN1_const_CTX *c)
-	{
-	ASN1_STRING *os=NULL;
+static int
+asn1_collate_primitive(ASN1_STRING *a, ASN1_const_CTX *c)
+{
+	ASN1_STRING *os = NULL;
 	BUF_MEM b;
 	int num;
 
-	b.length=0;
-	b.max=0;
-	b.data=NULL;
+	b.length = 0;
+	b.max = 0;
+	b.data = NULL;
 
-	if (a == NULL)
-		{
-		c->error=ERR_R_PASSED_NULL_PARAMETER;
+	if (a == NULL) {
+		c->error = ERR_R_PASSED_NULL_PARAMETER;
 		goto err;
+	}
+
+	num = 0;
+	for (;;) {
+		if (c->inf & 1) {
+			c->eos = ASN1_const_check_infinite_end(&c->p,
+			    (long)(c->max - c->p));
+			if (c->eos)
+				break;
+		} else {
+			if (c->slen <= 0)
+				break;
 		}
 
-	num=0;
-	for (;;)
-		{
-		if (c->inf & 1)
-			{
-			c->eos=ASN1_const_check_infinite_end(&c->p,
-				(long)(c->max-c->p));
-			if (c->eos) break;
-			}
-		else
-			{
-			if (c->slen <= 0) break;
-			}
-
-		c->q=c->p;
-		if (d2i_ASN1_bytes(&os,&c->p,c->max-c->p,c->tag,c->xclass)
-			== NULL)
-			{
-			c->error=ERR_R_ASN1_LIB;
+		c->q = c->p;
+		if (d2i_ASN1_bytes(&os, &c->p, c->max - c->p, c->tag,
+		    c->xclass) == NULL) {
+			c->error = ERR_R_ASN1_LIB;
 			goto err;
-			}
+		}
 
-		if (!BUF_MEM_grow_clean(&b,num+os->length))
-			{
-			c->error=ERR_R_BUF_LIB;
+		if (!BUF_MEM_grow_clean(&b, num + os->length)) {
+			c->error = ERR_R_BUF_LIB;
 			goto err;
-			}
-		memcpy(&(b.data[num]),os->data,os->length);
-		if (!(c->inf & 1))
-			c->slen-=(c->p-c->q);
-		num+=os->length;
 		}
+		memcpy(&(b.data[num]), os->data, os->length);
+		if (!(c->inf & 1))
+			c->slen -= (c->p - c->q);
+		num += os->length;
+	}
+
+	if (!asn1_const_Finish(c))
+		goto err;
 
-	if (!asn1_const_Finish(c)) goto err;
+	a->length = num;
+	if (a->data != NULL)
+		free(a->data);
+	a->data = (unsigned char *)b.data;
+	if (os != NULL)
+		ASN1_STRING_free(os);
+	return (1);
 
-	a->length=num;
-	if (a->data != NULL) free(a->data);
-	a->data=(unsigned char *)b.data;
-	if (os != NULL) ASN1_STRING_free(os);
-	return(1);
 err:
-	ASN1err(ASN1_F_ASN1_COLLATE_PRIMITIVE,c->error);
-	if (os != NULL) ASN1_STRING_free(os);
-	if (b.data != NULL) free(b.data);
-	return(0);
-	}
-
+	ASN1err(ASN1_F_ASN1_COLLATE_PRIMITIVE, c->error);
+	if (os != NULL)
+		ASN1_STRING_free(os);
+	if (b.data != NULL)
+		free(b.data);
+	return (0);
+}
diff --git a/lib/libcrypto/asn1/a_d2i_fp.c b/lib/libcrypto/asn1/a_d2i_fp.c
index 52b2ebdb631..af7a4bac30f 100644
--- a/lib/libcrypto/asn1/a_d2i_fp.c
+++ b/lib/libcrypto/asn1/a_d2i_fp.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
@@ -67,220 +67,208 @@ static int asn1_d2i_read_bio(BIO *in, BUF_MEM **pb);
 #ifndef NO_OLD_ASN1
 #ifndef OPENSSL_NO_FP_API
 
-void *ASN1_d2i_fp(void *(*xnew)(void), d2i_of_void *d2i, FILE *in, void **x)
-        {
-        BIO *b;
-        void *ret;
+void *
+ASN1_d2i_fp(void *(*xnew)(void), d2i_of_void *d2i, FILE *in, void **x)
+{
+	BIO *b;
+	void *ret;
 
-        if ((b=BIO_new(BIO_s_file())) == NULL)
-		{
-		ASN1err(ASN1_F_ASN1_D2I_FP,ERR_R_BUF_LIB);
-                return(NULL);
-		}
-        BIO_set_fp(b,in,BIO_NOCLOSE);
-        ret=ASN1_d2i_bio(xnew,d2i,b,x);
-        BIO_free(b);
-        return(ret);
-        }
+	if ((b = BIO_new(BIO_s_file())) == NULL) {
+		ASN1err(ASN1_F_ASN1_D2I_FP, ERR_R_BUF_LIB);
+		return (NULL);
+	}
+	BIO_set_fp(b, in, BIO_NOCLOSE);
+	ret = ASN1_d2i_bio(xnew, d2i, b, x);
+	BIO_free(b);
+	return (ret);
+}
 #endif
 
-void *ASN1_d2i_bio(void *(*xnew)(void), d2i_of_void *d2i, BIO *in, void **x)
-	{
+void *
+ASN1_d2i_bio(void *(*xnew)(void), d2i_of_void *d2i, BIO *in, void **x)
+{
 	BUF_MEM *b = NULL;
 	const unsigned char *p;
-	void *ret=NULL;
+	void *ret = NULL;
 	int len;
 
 	len = asn1_d2i_read_bio(in, &b);
-	if(len < 0) goto err;
+	if (len < 0)
+		goto err;
+
+	p = (unsigned char *)b->data;
+	ret = d2i(x, &p, len);
 
-	p=(unsigned char *)b->data;
-	ret=d2i(x,&p,len);
 err:
-	if (b != NULL) BUF_MEM_free(b);
-	return(ret);
-	}
+	if (b != NULL)
+		BUF_MEM_free(b);
+	return (ret);
+}
 
 #endif
 
-void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x)
-	{
+void *
+ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x)
+{
 	BUF_MEM *b = NULL;
 	const unsigned char *p;
-	void *ret=NULL;
+	void *ret = NULL;
 	int len;
 
 	len = asn1_d2i_read_bio(in, &b);
-	if(len < 0) goto err;
+	if (len < 0)
+		goto err;
+
+	p = (const unsigned char *)b->data;
+	ret = ASN1_item_d2i(x, &p, len, it);
 
-	p=(const unsigned char *)b->data;
-	ret=ASN1_item_d2i(x,&p,len, it);
 err:
-	if (b != NULL) BUF_MEM_free(b);
-	return(ret);
-	}
+	if (b != NULL)
+		BUF_MEM_free(b);
+	return (ret);
+}
 
 #ifndef OPENSSL_NO_FP_API
-void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x)
-        {
-        BIO *b;
-        char *ret;
+void *
+ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x)
+{
+	BIO *b;
+	char *ret;
 
-        if ((b=BIO_new(BIO_s_file())) == NULL)
-		{
-		ASN1err(ASN1_F_ASN1_ITEM_D2I_FP,ERR_R_BUF_LIB);
-                return(NULL);
-		}
-        BIO_set_fp(b,in,BIO_NOCLOSE);
-        ret=ASN1_item_d2i_bio(it,b,x);
-        BIO_free(b);
-        return(ret);
-        }
+	if ((b = BIO_new(BIO_s_file())) == NULL) {
+		ASN1err(ASN1_F_ASN1_ITEM_D2I_FP, ERR_R_BUF_LIB);
+		return (NULL);
+	}
+	BIO_set_fp(b, in, BIO_NOCLOSE);
+	ret = ASN1_item_d2i_bio(it, b, x);
+	BIO_free(b);
+	return (ret);
+}
 #endif
 
 #define HEADER_SIZE   8
-static int asn1_d2i_read_bio(BIO *in, BUF_MEM **pb)
-	{
+static int
+asn1_d2i_read_bio(BIO *in, BUF_MEM **pb)
+{
 	BUF_MEM *b;
 	unsigned char *p;
 	int i;
 	ASN1_const_CTX c;
-	size_t want=HEADER_SIZE;
-	int eos=0;
-	size_t off=0;
-	size_t len=0;
+	size_t want = HEADER_SIZE;
+	int eos = 0;
+	size_t off = 0;
+	size_t len = 0;
 
-	b=BUF_MEM_new();
-	if (b == NULL)
-		{
-		ASN1err(ASN1_F_ASN1_D2I_READ_BIO,ERR_R_MALLOC_FAILURE);
+	b = BUF_MEM_new();
+	if (b == NULL) {
+		ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ERR_R_MALLOC_FAILURE);
 		return -1;
-		}
+	}
 
 	ERR_clear_error();
-	for (;;)
-		{
-		if (want >= (len-off))
-			{
-			want-=(len-off);
+	for (;;) {
+		if (want >= (len - off)) {
+			want -= (len - off);
 
-			if (len + want < len || !BUF_MEM_grow_clean(b,len+want))
-				{
-				ASN1err(ASN1_F_ASN1_D2I_READ_BIO,ERR_R_MALLOC_FAILURE);
+			if (len + want < len || !BUF_MEM_grow_clean(b, len + want)) {
+				ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ERR_R_MALLOC_FAILURE);
 				goto err;
-				}
-			i=BIO_read(in,&(b->data[len]),want);
-			if ((i < 0) && ((len-off) == 0))
-				{
-				ASN1err(ASN1_F_ASN1_D2I_READ_BIO,ASN1_R_NOT_ENOUGH_DATA);
+			}
+			i = BIO_read(in, &(b->data[len]), want);
+			if ((i < 0) && ((len - off) == 0)) {
+				ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_NOT_ENOUGH_DATA);
 				goto err;
-				}
-			if (i > 0)
-				{
-				if (len+i < len)
-					{
-					ASN1err(ASN1_F_ASN1_D2I_READ_BIO,ASN1_R_TOO_LONG);
+			}
+			if (i > 0) {
+				if (len + i < len) {
+					ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG);
 					goto err;
-					}
-				len+=i;
 				}
+				len += i;
 			}
+		}
 		/* else data already loaded */
 
-		p=(unsigned char *)&(b->data[off]);
-		c.p=p;
-		c.inf=ASN1_get_object(&(c.p),&(c.slen),&(c.tag),&(c.xclass),
-			len-off);
-		if (c.inf & 0x80)
-			{
+		p = (unsigned char *) & (b->data[off]);
+		c.p = p;
+		c.inf = ASN1_get_object(&(c.p), &(c.slen), &(c.tag),
+		    &(c.xclass), len - off);
+		if (c.inf & 0x80) {
 			unsigned long e;
 
-			e=ERR_GET_REASON(ERR_peek_error());
+			e = ERR_GET_REASON(ERR_peek_error());
 			if (e != ASN1_R_TOO_LONG)
 				goto err;
 			else
 				ERR_clear_error(); /* clear error */
-			}
-		i=c.p-p;/* header length */
-		off+=i;	/* end of data */
+		}
+		i = c.p - p;	/* header length */
+		off += i;	/* end of data */
 
-		if (c.inf & 1)
-			{
+		if (c.inf & 1) {
 			/* no data body so go round again */
 			eos++;
-			if (eos < 0)
-				{
-				ASN1err(ASN1_F_ASN1_D2I_READ_BIO,ASN1_R_HEADER_TOO_LONG);
+			if (eos < 0) {
+				ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_HEADER_TOO_LONG);
 				goto err;
-				}
-			want=HEADER_SIZE;
 			}
-		else if (eos && (c.slen == 0) && (c.tag == V_ASN1_EOC))
-			{
+			want = HEADER_SIZE;
+		} else if (eos && (c.slen == 0) && (c.tag == V_ASN1_EOC)) {
 			/* eos value, so go back and read another header */
 			eos--;
 			if (eos <= 0)
 				break;
 			else
-				want=HEADER_SIZE;
-			}
-		else 
-			{
+				want = HEADER_SIZE;
+		} else {
 			/* suck in c.slen bytes of data */
-			want=c.slen;
-			if (want > (len-off))
-				{
-				want-=(len-off);
+			want = c.slen;
+			if (want > (len - off)) {
+				want -= (len - off);
 				if (want > INT_MAX /* BIO_read takes an int length */ ||
-					len+want < len)
-						{
-						ASN1err(ASN1_F_ASN1_D2I_READ_BIO,ASN1_R_TOO_LONG);
-						goto err;
-						}
-				if (!BUF_MEM_grow_clean(b,len+want))
-					{
-					ASN1err(ASN1_F_ASN1_D2I_READ_BIO,ERR_R_MALLOC_FAILURE);
+				    len+want < len) {
+					ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG);
 					goto err;
-					}
-				while (want > 0)
-					{
-					i=BIO_read(in,&(b->data[len]),want);
-					if (i <= 0)
-						{
+				}
+				if (!BUF_MEM_grow_clean(b, len + want)) {
+					ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ERR_R_MALLOC_FAILURE);
+					goto err;
+				}
+				while (want > 0) {
+					i = BIO_read(in, &(b->data[len]), want);
+					if (i <= 0) {
 						ASN1err(ASN1_F_ASN1_D2I_READ_BIO,
 						    ASN1_R_NOT_ENOUGH_DATA);
 						goto err;
-						}
+					}
 					/* This can't overflow because
 					 * |len+want| didn't overflow. */
-					len+=i;
-					want-=i;
-					}
+					len += i;
+					want -= i;
 				}
-			if (off + c.slen < off)
-				{
-				ASN1err(ASN1_F_ASN1_D2I_READ_BIO,ASN1_R_TOO_LONG);
+			}
+			if (off + c.slen < off) {
+				ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG);
 				goto err;
-				}
-			off+=c.slen;
-			if (eos <= 0)
-				{
-				break;
-				}
-			else
-				want=HEADER_SIZE;
 			}
+			off += c.slen;
+			if (eos <= 0) {
+				break;
+			} else
+				want = HEADER_SIZE;
 		}
+	}
 
-	if (off > INT_MAX)
-		{
-		ASN1err(ASN1_F_ASN1_D2I_READ_BIO,ASN1_R_TOO_LONG);
+	if (off > INT_MAX) {
+		ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG);
 		goto err;
-		}
+	}
 
 	*pb = b;
 	return off;
+
 err:
-	if (b != NULL) BUF_MEM_free(b);
+	if (b != NULL)
+		BUF_MEM_free(b);
 	return -1;
-	}
+}