putting most of the braces in the right column is the very least we can do.

1 files changed, 69 insertions, 69 deletions

diff --git a/src/lib/libcrypto/asn1/x_pubkey.c b/src/lib/libcrypto/asn1/x_pubkey.c
index 684f40899f..454d50f24c 100644
--- a/src/lib/libcrypto/asn1/x_pubkey.c
+++ b/src/lib/libcrypto/asn1/x_pubkey.c
@@ -71,14 +71,14 @@
 /* Minor tweak to operation: free up EVP_PKEY */
 static int pubkey_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
                         void *exarg)
-        {
+{
         if (operation == ASN1_OP_FREE_POST)
-                {
+        {
                 X509_PUBKEY *pubkey = (X509_PUBKEY *)*pval;
                 EVP_PKEY_free(pubkey->pkey);
-                }
-        return 1;
         }
+        return 1;
+}
 
 ASN1_SEQUENCE_cb(X509_PUBKEY, pubkey_cb) = {
         ASN1_SIMPLE(X509_PUBKEY, algor, X509_ALGOR),
@@ -88,7 +88,7 @@ ASN1_SEQUENCE_cb(X509_PUBKEY, pubkey_cb) = {
 IMPLEMENT_ASN1_FUNCTIONS(X509_PUBKEY)
 
 int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)
-        {
+{
         X509_PUBKEY *pk=NULL;
 
         if (x == NULL) return(0);
@@ -96,28 +96,28 @@ int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)
         if ((pk=X509_PUBKEY_new()) == NULL) goto error;
 
         if (pkey->ameth)
-                {
+        {
                 if (pkey->ameth->pub_encode)
-                        {
+                {
                         if (!pkey->ameth->pub_encode(pk, pkey))
-                                {
+                        {
                                 X509err(X509_F_X509_PUBKEY_SET,
                                         X509_R_PUBLIC_KEY_ENCODE_ERROR);
                                 goto error;
-                                }
                         }
+                }
                 else
-                        {
+                {
                         X509err(X509_F_X509_PUBKEY_SET,
                                 X509_R_METHOD_NOT_SUPPORTED);
                         goto error;
-                        }
                 }
+        }
         else
-                {
+        {
                 X509err(X509_F_X509_PUBKEY_SET,X509_R_UNSUPPORTED_ALGORITHM);
                 goto error;
-                }
+        }
 
         if (*x != NULL)
                 X509_PUBKEY_free(*x);
@@ -128,62 +128,62 @@ int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)
 error:
         if (pk != NULL) X509_PUBKEY_free(pk);
         return 0;
-        }
+}
 
 EVP_PKEY *X509_PUBKEY_get(X509_PUBKEY *key)
-        {
+{
         EVP_PKEY *ret=NULL;
 
         if (key == NULL) goto error;
 
         if (key->pkey != NULL)
-                {
+        {
                 CRYPTO_add(&key->pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
                 return key->pkey;
-                }
+        }
 
         if (key->public_key == NULL) goto error;
 
         if ((ret = EVP_PKEY_new()) == NULL)
-                {
+        {
                 X509err(X509_F_X509_PUBKEY_GET, ERR_R_MALLOC_FAILURE);
                 goto error;
-                }
+        }
 
         if (!EVP_PKEY_set_type(ret, OBJ_obj2nid(key->algor->algorithm)))
-                {
+        {
                 X509err(X509_F_X509_PUBKEY_GET,X509_R_UNSUPPORTED_ALGORITHM);
                 goto error;
-                }
+        }
 
         if (ret->ameth->pub_decode)
-                {
+        {
                 if (!ret->ameth->pub_decode(ret, key))
-                        {
+                {
                         X509err(X509_F_X509_PUBKEY_GET,
                                                 X509_R_PUBLIC_KEY_DECODE_ERROR);
                         goto error;
-                        }
                 }
+        }
         else
-                {
+        {
                 X509err(X509_F_X509_PUBKEY_GET, X509_R_METHOD_NOT_SUPPORTED);
                 goto error;
-                }
+        }
 
         /* Check to see if another thread set key->pkey first */
         CRYPTO_w_lock(CRYPTO_LOCK_EVP_PKEY);
         if (key->pkey)
-                {
+        {
                 CRYPTO_w_unlock(CRYPTO_LOCK_EVP_PKEY);
                 EVP_PKEY_free(ret);
                 ret = key->pkey;
-                }
+        }
         else
-                {
+        {
                 key->pkey = ret;
                 CRYPTO_w_unlock(CRYPTO_LOCK_EVP_PKEY);
-                }
+        }
         CRYPTO_add(&ret->references, 1, CRYPTO_LOCK_EVP_PKEY);
 
         return ret;
@@ -192,7 +192,7 @@ EVP_PKEY *X509_PUBKEY_get(X509_PUBKEY *key)
         if (ret != NULL)
                 EVP_PKEY_free(ret);
         return(NULL);
-        }
+}
 
 /* Now two pseudo ASN1 routines that take an EVP_PKEY structure
  * and encode or decode as X509_PUBKEY
@@ -200,7 +200,7 @@ EVP_PKEY *X509_PUBKEY_get(X509_PUBKEY *key)
 
 EVP_PKEY *d2i_PUBKEY(EVP_PKEY **a, const unsigned char **pp,
              long length)
-        {
+{
         X509_PUBKEY *xpk;
         EVP_PKEY *pktmp;
         xpk = d2i_X509_PUBKEY(NULL, pp, length);
@@ -209,15 +209,15 @@ EVP_PKEY *d2i_PUBKEY(EVP_PKEY **a, const unsigned char **pp,
         X509_PUBKEY_free(xpk);
         if(!pktmp) return NULL;
         if(a)
-                {
+        {
                 EVP_PKEY_free(*a);
                 *a = pktmp;
-                }
-        return pktmp;
         }
+        return pktmp;
+}
 
 int i2d_PUBKEY(EVP_PKEY *a, unsigned char **pp)
-        {
+{
         X509_PUBKEY *xpk=NULL;
         int ret;
         if(!a) return 0;
@@ -225,7 +225,7 @@ int i2d_PUBKEY(EVP_PKEY *a, unsigned char **pp)
         ret = i2d_X509_PUBKEY(xpk, pp);
         X509_PUBKEY_free(xpk);
         return ret;
-        }
+}
 
 /* The following are equivalents but which return RSA and DSA
  * keys
@@ -233,7 +233,7 @@ int i2d_PUBKEY(EVP_PKEY *a, unsigned char **pp)
 #ifndef OPENSSL_NO_RSA
 RSA *d2i_RSA_PUBKEY(RSA **a, const unsigned char **pp,
              long length)
-        {
+{
         EVP_PKEY *pkey;
         RSA *key;
         const unsigned char *q;
@@ -245,35 +245,35 @@ RSA *d2i_RSA_PUBKEY(RSA **a, const unsigned char **pp,
         if (!key) return NULL;
         *pp = q;
         if (a)
-                {
+        {
                 RSA_free(*a);
                 *a = key;
-                }
-        return key;
         }
+        return key;
+}
 
 int i2d_RSA_PUBKEY(RSA *a, unsigned char **pp)
-        {
+{
         EVP_PKEY *pktmp;
         int ret;
         if (!a) return 0;
         pktmp = EVP_PKEY_new();
         if (!pktmp)
-                {
+        {
                 ASN1err(ASN1_F_I2D_RSA_PUBKEY, ERR_R_MALLOC_FAILURE);
                 return 0;
-                }
+        }
         EVP_PKEY_set1_RSA(pktmp, a);
         ret = i2d_PUBKEY(pktmp, pp);
         EVP_PKEY_free(pktmp);
         return ret;
-        }
+}
 #endif
 
 #ifndef OPENSSL_NO_DSA
 DSA *d2i_DSA_PUBKEY(DSA **a, const unsigned char **pp,
              long length)
-        {
+{
         EVP_PKEY *pkey;
         DSA *key;
         const unsigned char *q;
@@ -285,34 +285,34 @@ DSA *d2i_DSA_PUBKEY(DSA **a, const unsigned char **pp,
         if (!key) return NULL;
         *pp = q;
         if (a)
-                {
+        {
                 DSA_free(*a);
                 *a = key;
-                }
-        return key;
         }
+        return key;
+}
 
 int i2d_DSA_PUBKEY(DSA *a, unsigned char **pp)
-        {
+{
         EVP_PKEY *pktmp;
         int ret;
         if(!a) return 0;
         pktmp = EVP_PKEY_new();
         if(!pktmp)
-                {
+        {
                 ASN1err(ASN1_F_I2D_DSA_PUBKEY, ERR_R_MALLOC_FAILURE);
                 return 0;
-                }
+        }
         EVP_PKEY_set1_DSA(pktmp, a);
         ret = i2d_PUBKEY(pktmp, pp);
         EVP_PKEY_free(pktmp);
         return ret;
-        }
+}
 #endif
 
 #ifndef OPENSSL_NO_EC
 EC_KEY *d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, long length)
-        {
+{
         EVP_PKEY *pkey;
         EC_KEY *key;
         const unsigned char *q;
@@ -324,38 +324,38 @@ EC_KEY *d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, long length)
         if (!key)  return(NULL);
         *pp = q;
         if (a)
-                {
+        {
                 EC_KEY_free(*a);
                 *a = key;
-                }
-        return(key);
         }
+        return(key);
+}
 
 int i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp)
-        {
+{
         EVP_PKEY *pktmp;
         int ret;
         if (!a) return(0);
         if ((pktmp = EVP_PKEY_new()) == NULL)
-                {
+        {
                 ASN1err(ASN1_F_I2D_EC_PUBKEY, ERR_R_MALLOC_FAILURE);
                 return(0);
-                }
+        }
         EVP_PKEY_set1_EC_KEY(pktmp, a);
         ret = i2d_PUBKEY(pktmp, pp);
         EVP_PKEY_free(pktmp);
         return(ret);
-        }
+}
 #endif
 
 int X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj,
                                         int ptype, void *pval,
                                         unsigned char *penc, int penclen)
-        {
+{
         if (!X509_ALGOR_set0(pub->algor, aobj, ptype, pval))
                 return 0;
         if (penc)
-                {
+        {
                 if (pub->public_key->data)
                         free(pub->public_key->data);
                 pub->public_key->data = penc;
@@ -363,23 +363,23 @@ int X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj,
                 /* Set number of unused bits to zero */
                 pub->public_key->flags&= ~(ASN1_STRING_FLAG_BITS_LEFT|0x07);
                 pub->public_key->flags|=ASN1_STRING_FLAG_BITS_LEFT;
-                }
-        return 1;
         }
+        return 1;
+}
 
 int X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg,
                 const unsigned char **pk, int *ppklen,
                 X509_ALGOR **pa,
                 X509_PUBKEY *pub)
-        {
+{
         if (ppkalg)
                 *ppkalg = pub->algor->algorithm;
         if (pk)
-                {
+        {
                 *pk = pub->public_key->data;
                 *ppklen = pub->public_key->length;
-                }
+        }
         if (pa)
                 *pa = pub->algor;
         return 1;
-        }
+}