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

1 files changed, 61 insertions, 61 deletions

diff --git a/src/lib/libcrypto/asn1/ameth_lib.c b/src/lib/libcrypto/asn1/ameth_lib.c
index 228392f1e6..8f96e00c93 100644
--- a/src/lib/libcrypto/asn1/ameth_lib.c
+++ b/src/lib/libcrypto/asn1/ameth_lib.c
@@ -73,7 +73,7 @@ extern const EVP_PKEY_ASN1_METHOD cmac_asn1_meth;
 
 /* Keep this sorted in type order !! */
 static const EVP_PKEY_ASN1_METHOD *standard_methods[] = 
-        {
+{
 #ifndef OPENSSL_NO_RSA
         &rsa_asn1_meths[0],
         &rsa_asn1_meths[1],
@@ -93,7 +93,7 @@ static const EVP_PKEY_ASN1_METHOD *standard_methods[] =
 #endif
         &hmac_asn1_meth,
         &cmac_asn1_meth
-        };
+};
 
 typedef int sk_cmp_fn_type(const char * const *a, const char * const *b);
 DECLARE_STACK_OF(EVP_PKEY_ASN1_METHOD)
@@ -103,7 +103,7 @@ static STACK_OF(EVP_PKEY_ASN1_METHOD) *app_methods = NULL;
 
 #ifdef TEST
 void main()
-        {
+{
         int i;
         for (i = 0;
                 i < sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *);
@@ -111,7 +111,7 @@ void main()
                 fprintf(stderr, "Number %d id=%d (%s)\n", i,
                         standard_methods[i]->pkey_id,
                         OBJ_nid2sn(standard_methods[i]->pkey_id));
-        }
+}
 #endif
 
 DECLARE_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_ASN1_METHOD *,
@@ -119,23 +119,23 @@ DECLARE_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_ASN1_METHOD *,
 
 static int ameth_cmp(const EVP_PKEY_ASN1_METHOD * const *a,
                      const EVP_PKEY_ASN1_METHOD * const *b)
-        {
+{
         return ((*a)->pkey_id - (*b)->pkey_id);
-        }
+}
 
 IMPLEMENT_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_ASN1_METHOD *,
                              const EVP_PKEY_ASN1_METHOD *, ameth);
 
 int EVP_PKEY_asn1_get_count(void)
-        {
+{
         int num = sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *);
         if (app_methods)
                 num += sk_EVP_PKEY_ASN1_METHOD_num(app_methods);
         return num;
-        }
+}
 
 const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx)
-        {
+{
         int num = sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *);
         if (idx < 0)
                 return NULL; 
@@ -143,27 +143,27 @@ const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx)
                 return standard_methods[idx];
         idx -= num;
         return sk_EVP_PKEY_ASN1_METHOD_value(app_methods, idx);
-        }
+}
 
 static const EVP_PKEY_ASN1_METHOD *pkey_asn1_find(int type)
-        {
+{
         EVP_PKEY_ASN1_METHOD tmp;
         const EVP_PKEY_ASN1_METHOD *t = &tmp, **ret;
         tmp.pkey_id = type;
         if (app_methods)
-                {
+        {
                 int idx;
                 idx = sk_EVP_PKEY_ASN1_METHOD_find(app_methods, &tmp);
                 if (idx >= 0)
                         return sk_EVP_PKEY_ASN1_METHOD_value(app_methods, idx);
-                }
+        }
         ret = OBJ_bsearch_ameth(&t, standard_methods,
                           sizeof(standard_methods)
                           /sizeof(EVP_PKEY_ASN1_METHOD *));
         if (!ret || !*ret)
                 return NULL;
         return *ret;
-        }
+}
 
 /* Find an implementation of an ASN1 algorithm. If 'pe' is not NULL
  * also search through engines and set *pe to a functional reference
@@ -172,47 +172,47 @@ static const EVP_PKEY_ASN1_METHOD *pkey_asn1_find(int type)
  */
 
 const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(ENGINE **pe, int type)
-        {
+{
         const EVP_PKEY_ASN1_METHOD *t;
 
         for (;;)
-                {
+        {
                 t = pkey_asn1_find(type);
                 if (!t || !(t->pkey_flags & ASN1_PKEY_ALIAS))
                         break;
                 type = t->pkey_base_id;
-                }
+        }
         if (pe)
-                {
+        {
 #ifndef OPENSSL_NO_ENGINE
                 ENGINE *e;
                 /* type will contain the final unaliased type */
                 e = ENGINE_get_pkey_asn1_meth_engine(type);
                 if (e)
-                        {
+                {
                         *pe = e;
                         return ENGINE_get_pkey_asn1_meth(e, type);
-                        }
+                }
 #endif
                 *pe = NULL;
-                }
-        return t;
         }
+        return t;
+}
 
 const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find_str(ENGINE **pe,
                                         const char *str, int len)
-        {
+{
         int i;
         const EVP_PKEY_ASN1_METHOD *ameth;
         if (len == -1)
                 len = strlen(str);
         if (pe)
-                {
+        {
 #ifndef OPENSSL_NO_ENGINE
                 ENGINE *e;
                 ameth = ENGINE_pkey_asn1_find_str(&e, str, len);
                 if (ameth)
-                        {
+                {
                         /* Convert structural into
                          * functional reference
                          */
@@ -221,50 +221,50 @@ const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find_str(ENGINE **pe,
                         ENGINE_free(e);
                         *pe = e;
                         return ameth;
-                        }
+                }
 #endif
                 *pe = NULL;
-                }
+        }
         for (i = 0; i < EVP_PKEY_asn1_get_count(); i++)
-                {
+        {
                 ameth = EVP_PKEY_asn1_get0(i);
                 if (ameth->pkey_flags & ASN1_PKEY_ALIAS)
                         continue;
                 if (((int)strlen(ameth->pem_str) == len) && 
                         !strncasecmp(ameth->pem_str, str, len))
                         return ameth;
-                }
-        return NULL;
         }
+        return NULL;
+}
 
 int EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth)
-        {
+{
         if (app_methods == NULL)
-                {
+        {
                 app_methods = sk_EVP_PKEY_ASN1_METHOD_new(ameth_cmp);
                 if (!app_methods)
                         return 0;
-                }
+        }
         if (!sk_EVP_PKEY_ASN1_METHOD_push(app_methods, ameth))
                 return 0;
         sk_EVP_PKEY_ASN1_METHOD_sort(app_methods);
         return 1;
-        }
+}
 
 int EVP_PKEY_asn1_add_alias(int to, int from)
-        {
+{
         EVP_PKEY_ASN1_METHOD *ameth;
         ameth = EVP_PKEY_asn1_new(from, ASN1_PKEY_ALIAS, NULL, NULL);
         if (!ameth)
                 return 0;
         ameth->pkey_base_id = to;
         return EVP_PKEY_asn1_add0(ameth);
-        }
+}
 
 int EVP_PKEY_asn1_get0_info(int *ppkey_id, int *ppkey_base_id, int *ppkey_flags,
                                 const char **pinfo, const char **ppem_str,
                                         const EVP_PKEY_ASN1_METHOD *ameth)
-        {
+{
         if (!ameth)
                 return 0;
         if (ppkey_id)
@@ -278,16 +278,16 @@ int EVP_PKEY_asn1_get0_info(int *ppkey_id, int *ppkey_base_id, int *ppkey_flags,
         if (ppem_str)
                 *ppem_str = ameth->pem_str;
         return 1;
-        }
+}
 
 const EVP_PKEY_ASN1_METHOD* EVP_PKEY_get0_asn1(EVP_PKEY *pkey)
-        {
+{
         return pkey->ameth;
-        }
+}
 
 EVP_PKEY_ASN1_METHOD* EVP_PKEY_asn1_new(int id, int flags,
                                         const char *pem_str, const char *info)
-        {
+{
         EVP_PKEY_ASN1_METHOD *ameth;
         ameth = malloc(sizeof(EVP_PKEY_ASN1_METHOD));
         if (!ameth)
@@ -300,20 +300,20 @@ EVP_PKEY_ASN1_METHOD* EVP_PKEY_asn1_new(int id, int flags,
         ameth->pkey_flags = flags | ASN1_PKEY_DYNAMIC;
 
         if (info)
-                {
+        {
                 ameth->info = BUF_strdup(info);
                 if (!ameth->info)
                         goto err;
-                }
+        }
         else
                 ameth->info = NULL;
 
         if (pem_str)
-                {
+        {
                 ameth->pem_str = BUF_strdup(pem_str);
                 if (!ameth->pem_str)
                         goto err;
-                }
+        }
         else
                 ameth->pem_str = NULL;
 
@@ -352,11 +352,11 @@ EVP_PKEY_ASN1_METHOD* EVP_PKEY_asn1_new(int id, int flags,
         EVP_PKEY_asn1_free(ameth);
         return NULL;
 
-        }
+}
 
 void EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst, 
                         const EVP_PKEY_ASN1_METHOD *src)
-        {
+{
 
         dst->pub_decode = src->pub_decode;
         dst->pub_encode = src->pub_encode;
@@ -386,19 +386,19 @@ void EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst,
         dst->item_sign = src->item_sign;
         dst->item_verify = src->item_verify;
 
-        }
+}
 
 void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth)
-        {
+{
         if (ameth && (ameth->pkey_flags & ASN1_PKEY_DYNAMIC))
-                {
+        {
                 if (ameth->pem_str)
                         free(ameth->pem_str);
                 if (ameth->info)
                         free(ameth->info);
                 free(ameth);
-                }
         }
+}
 
 void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth,
                 int (*pub_decode)(EVP_PKEY *pk, X509_PUBKEY *pub),
@@ -408,25 +408,25 @@ void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth,
                                                         ASN1_PCTX *pctx),
                 int (*pkey_size)(const EVP_PKEY *pk),
                 int (*pkey_bits)(const EVP_PKEY *pk))
-        {
+{
         ameth->pub_decode = pub_decode;
         ameth->pub_encode = pub_encode;
         ameth->pub_cmp = pub_cmp;
         ameth->pub_print = pub_print;
         ameth->pkey_size = pkey_size;
         ameth->pkey_bits = pkey_bits;
-        }
+}
 
 void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth,
                 int (*priv_decode)(EVP_PKEY *pk, PKCS8_PRIV_KEY_INFO *p8inf),
                 int (*priv_encode)(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pk),
                 int (*priv_print)(BIO *out, const EVP_PKEY *pkey, int indent,
                                                         ASN1_PCTX *pctx))
-        {
+{
         ameth->priv_decode = priv_decode;
         ameth->priv_encode = priv_encode;
         ameth->priv_print = priv_print;
-        }
+}
 
 void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth,
                 int (*param_decode)(EVP_PKEY *pkey,
@@ -437,24 +437,24 @@ void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth,
                 int (*param_cmp)(const EVP_PKEY *a, const EVP_PKEY *b),
                 int (*param_print)(BIO *out, const EVP_PKEY *pkey, int indent,
                                                         ASN1_PCTX *pctx))
-        {
+{
         ameth->param_decode = param_decode;
         ameth->param_encode = param_encode;
         ameth->param_missing = param_missing;
         ameth->param_copy = param_copy;
         ameth->param_cmp = param_cmp;
         ameth->param_print = param_print;
-        }
+}
 
 void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth,
                 void (*pkey_free)(EVP_PKEY *pkey))
-        {
+{
         ameth->pkey_free = pkey_free;
-        }
+}
 
 void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth,
                 int (*pkey_ctrl)(EVP_PKEY *pkey, int op,
                                                         long arg1, void *arg2))
-        {
+{
         ameth->pkey_ctrl = pkey_ctrl;
-        }
+}