1 files changed, 75 insertions, 75 deletions

diff --git a/src/lib/libcrypto/asn1/x_crl.c b/src/lib/libcrypto/asn1/x_crl.c
index cf7e69aaaf..b3a6355795 100644
--- a/src/lib/libcrypto/asn1/x_crl.c
+++ b/src/lib/libcrypto/asn1/x_crl.c
@@ -78,12 +78,12 @@ static int def_crl_lookup(X509_CRL *crl,
                 X509_REVOKED **ret, ASN1_INTEGER *serial, X509_NAME *issuer);
 
 static X509_CRL_METHOD int_crl_meth =
-        {
+{
         0,
         0,0,
         def_crl_lookup,
         def_crl_verify
-        };
+};
 
 static const X509_CRL_METHOD *default_crl_method = &int_crl_meth;
 
@@ -104,7 +104,7 @@ static int crl_inf_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
                 case ASN1_OP_D2I_POST:
                 (void)sk_X509_REVOKED_set_cmp_func(a->revoked,X509_REVOKED_cmp);
                 break;
-        }
+}
         return 1;
 }
 
@@ -124,7 +124,7 @@ ASN1_SEQUENCE_enc(X509_CRL_INFO, enc, crl_inf_cb) = {
  */
 
 static int crl_set_issuers(X509_CRL *crl)
-        {
+{
 
         int i, j;
         GENERAL_NAMES *gens, *gtmp;
@@ -134,7 +134,7 @@ static int crl_set_issuers(X509_CRL *crl)
 
         gens = NULL;
         for (i = 0; i < sk_X509_REVOKED_num(revoked); i++)
-                {
+        {
                 X509_REVOKED *rev = sk_X509_REVOKED_value(revoked, i);
                 STACK_OF(X509_EXTENSION) *exts;
                 ASN1_ENUMERATED *reason;
@@ -143,38 +143,38 @@ static int crl_set_issuers(X509_CRL *crl)
                                                 NID_certificate_issuer,
                                                 &j, NULL);
                 if (!gtmp && (j != -1))
-                        {
+                {
                         crl->flags |= EXFLAG_INVALID;
                         return 1;
-                        }
+                }
 
                 if (gtmp)
-                        {
+                {
                         gens = gtmp;
                         if (!crl->issuers)
-                                {
+                        {
                                 crl->issuers = sk_GENERAL_NAMES_new_null();
                                 if (!crl->issuers)
                                         return 0;
-                                }
+                        }
                         if (!sk_GENERAL_NAMES_push(crl->issuers, gtmp))
                                 return 0;
-                        }
+                }
                 rev->issuer = gens;
 
                 reason = X509_REVOKED_get_ext_d2i(rev, NID_crl_reason,
                                                                 &j, NULL);
                 if (!reason && (j != -1))
-                        {
+                {
                         crl->flags |= EXFLAG_INVALID;
                         return 1;
-                        }
+                }
 
                 if (reason)
-                        {
+                {
                         rev->reason = ASN1_ENUMERATED_get(reason);
                         ASN1_ENUMERATED_free(reason);
-                        }
+                }
                 else
                         rev->reason = CRL_REASON_NONE;  
 
@@ -183,38 +183,38 @@ static int crl_set_issuers(X509_CRL *crl)
                 exts = rev->extensions;
 
                 for (j = 0; j < sk_X509_EXTENSION_num(exts); j++)
-                        {
+                {
                         ext = sk_X509_EXTENSION_value(exts, j);
                         if (ext->critical > 0)
-                                {
+                        {
                                 if (OBJ_obj2nid(ext->object) ==
                                         NID_certificate_issuer)
                                         continue;
                                 crl->flags |= EXFLAG_CRITICAL;
                                 break;
-                                }
                         }
+                }
 
 
-                }
+        }
 
         return 1;
 
-        }
+}
 
 /* The X509_CRL structure needs a bit of customisation. Cache some extensions
  * and hash of the whole CRL.
  */
 static int crl_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
                                                                 void *exarg)
-        {
+{
         X509_CRL *crl = (X509_CRL *)*pval;
         STACK_OF(X509_EXTENSION) *exts;
         X509_EXTENSION *ext;
         int idx;
 
         switch(operation)
-                {
+        {
                 case ASN1_OP_NEW_POST:
                 crl->idp = NULL;
                 crl->akid = NULL;
@@ -260,40 +260,40 @@ static int crl_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
                 exts = crl->crl->extensions;
 
                 for (idx = 0; idx < sk_X509_EXTENSION_num(exts); idx++)
-                        {
+                {
                         int nid;
                         ext = sk_X509_EXTENSION_value(exts, idx);
                         nid = OBJ_obj2nid(ext->object);
                         if (nid == NID_freshest_crl)
                                 crl->flags |= EXFLAG_FRESHEST;
                         if (ext->critical > 0)
-                                {
+                        {
                                 /* We handle IDP and deltas */
                                 if ((nid == NID_issuing_distribution_point)
                                         || (nid == NID_delta_crl))
                                         break;;
                                 crl->flags |= EXFLAG_CRITICAL;
                                 break;
-                                }
                         }
+                }
 
 
                 if (!crl_set_issuers(crl))
                         return 0;
 
                 if (crl->meth->crl_init)
-                        {
+                {
                         if (crl->meth->crl_init(crl) == 0)
                                 return 0;
-                        }
+                }
                 break;
 
                 case ASN1_OP_FREE_POST:
                 if (crl->meth->crl_free)
-                        {
+                {
                         if (!crl->meth->crl_free(crl))
                                 return 0;
-                        }
+                }
                 if (crl->akid)
                         AUTHORITY_KEYID_free(crl->akid);
                 if (crl->idp)
@@ -302,32 +302,32 @@ static int crl_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
                 ASN1_INTEGER_free(crl->base_crl_number);
                 sk_GENERAL_NAMES_pop_free(crl->issuers, GENERAL_NAMES_free);
                 break;
-                }
-        return 1;
         }
+        return 1;
+}
 
 /* Convert IDP into a more convenient form */
 
 static void setup_idp(X509_CRL *crl, ISSUING_DIST_POINT *idp)
-        {
+{
         int idp_only = 0;
         /* Set various flags according to IDP */
         crl->idp_flags |= IDP_PRESENT;
         if (idp->onlyuser > 0)
-                {
+        {
                 idp_only++;
                 crl->idp_flags |= IDP_ONLYUSER;
-                }
+        }
         if (idp->onlyCA > 0)
-                {
+        {
                 idp_only++;
                 crl->idp_flags |= IDP_ONLYCA;
-                }
+        }
         if (idp->onlyattr > 0)
-                {
+        {
                 idp_only++;
                 crl->idp_flags |= IDP_ONLYATTR;
-                }
+        }
 
         if (idp_only > 1)
                 crl->idp_flags |= IDP_INVALID;
@@ -336,7 +336,7 @@ static void setup_idp(X509_CRL *crl, ISSUING_DIST_POINT *idp)
                 crl->idp_flags |= IDP_INDIRECT;
 
         if (idp->onlysomereasons)
-                {
+        {
                 crl->idp_flags |= IDP_REASONS;
                 if (idp->onlysomereasons->length > 0)
                         crl->idp_reasons = idp->onlysomereasons->data[0];
@@ -344,10 +344,10 @@ static void setup_idp(X509_CRL *crl, ISSUING_DIST_POINT *idp)
                         crl->idp_reasons |=
                                 (idp->onlysomereasons->data[1] << 8);
                 crl->idp_reasons &= CRLDP_ALL_REASONS;
-                }
+        }
 
         DIST_POINT_set_dpname(idp->distpoint, X509_CRL_get_issuer(crl));
-        }
+}
 
 ASN1_SEQUENCE_ref(X509_CRL, crl_cb, CRYPTO_LOCK_X509_CRL) = {
         ASN1_SIMPLE(X509_CRL, crl, X509_CRL_INFO),
@@ -362,11 +362,11 @@ IMPLEMENT_ASN1_DUP_FUNCTION(X509_CRL)
 
 static int X509_REVOKED_cmp(const X509_REVOKED * const *a,
                         const X509_REVOKED * const *b)
-        {
+{
         return(ASN1_STRING_cmp(
                 (ASN1_STRING *)(*a)->serialNumber,
                 (ASN1_STRING *)(*b)->serialNumber));
-        }
+}
 
 int X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev)
 {
@@ -377,73 +377,73 @@ int X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev)
         if(!inf->revoked || !sk_X509_REVOKED_push(inf->revoked, rev)) {
                 ASN1err(ASN1_F_X509_CRL_ADD0_REVOKED, ERR_R_MALLOC_FAILURE);
                 return 0;
-        }
+}
         inf->enc.modified = 1;
         return 1;
 }
 
 int X509_CRL_verify(X509_CRL *crl, EVP_PKEY *r)
-        {
+{
         if (crl->meth->crl_verify)
                 return crl->meth->crl_verify(crl, r);
         return 0;
-        }
+}
 
 int X509_CRL_get0_by_serial(X509_CRL *crl,
                 X509_REVOKED **ret, ASN1_INTEGER *serial)
-        {
+{
         if (crl->meth->crl_lookup)
                 return crl->meth->crl_lookup(crl, ret, serial, NULL);
         return 0;
-        }
+}
 
 int X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x)
-        {
+{
         if (crl->meth->crl_lookup)
                 return crl->meth->crl_lookup(crl, ret,
                                                 X509_get_serialNumber(x),
                                                 X509_get_issuer_name(x));
         return 0;
-        }
+}
 
 static int def_crl_verify(X509_CRL *crl, EVP_PKEY *r)
-        {
+{
         return(ASN1_item_verify(ASN1_ITEM_rptr(X509_CRL_INFO),
                 crl->sig_alg, crl->signature,crl->crl,r));
-        }
+}
 
 static int crl_revoked_issuer_match(X509_CRL *crl, X509_NAME *nm,
                                                 X509_REVOKED *rev)
-        {
+{
         int i;
 
         if (!rev->issuer)
-                {
+        {
                 if (!nm)
                         return 1;
                 if (!X509_NAME_cmp(nm, X509_CRL_get_issuer(crl)))
                         return 1;
                 return 0;
-                }
+        }
 
         if (!nm)
                 nm = X509_CRL_get_issuer(crl);
 
         for (i = 0; i < sk_GENERAL_NAME_num(rev->issuer); i++)
-                {
+        {
                 GENERAL_NAME *gen = sk_GENERAL_NAME_value(rev->issuer, i);
                 if (gen->type != GEN_DIRNAME)
                         continue;
                 if (!X509_NAME_cmp(nm, gen->d.directoryName))
                         return 1;
-                }
+        }
         return 0;
 
-        }
+}
 
 static int def_crl_lookup(X509_CRL *crl,
                 X509_REVOKED **ret, ASN1_INTEGER *serial, X509_NAME *issuer)
-        {
+{
         X509_REVOKED rtmp, *rev;
         int idx;
         rtmp.serialNumber = serial;
@@ -451,39 +451,39 @@ static int def_crl_lookup(X509_CRL *crl,
          * Do this under a lock to avoid race condition.
          */
         if (!sk_X509_REVOKED_is_sorted(crl->crl->revoked))
-                {
+        {
                 CRYPTO_w_lock(CRYPTO_LOCK_X509_CRL);
                 sk_X509_REVOKED_sort(crl->crl->revoked);
                 CRYPTO_w_unlock(CRYPTO_LOCK_X509_CRL);
-                }
+        }
         idx = sk_X509_REVOKED_find(crl->crl->revoked, &rtmp);
         if(idx < 0)
                 return 0;
         /* Need to look for matching name */
         for(;idx < sk_X509_REVOKED_num(crl->crl->revoked); idx++)
-                {
+        {
                 rev = sk_X509_REVOKED_value(crl->crl->revoked, idx);
                 if (ASN1_INTEGER_cmp(rev->serialNumber, serial))
                         return 0;
                 if (crl_revoked_issuer_match(crl, issuer, rev))
-                        {
+                {
                         if (ret)
                                 *ret = rev;
                         if (rev->reason == CRL_REASON_REMOVE_FROM_CRL)
                                 return 2;
                         return 1;
-                        }
                 }
-        return 0;
         }
+        return 0;
+}
 
 void X509_CRL_set_default_method(const X509_CRL_METHOD *meth)
-        {
+{
         if (meth == NULL)
                 default_crl_method = &int_crl_meth;
         else 
                 default_crl_method = meth;
-        }
+}
 
 X509_CRL_METHOD *X509_CRL_METHOD_new(
         int (*crl_init)(X509_CRL *crl),
@@ -491,7 +491,7 @@ X509_CRL_METHOD *X509_CRL_METHOD_new(
         int (*crl_lookup)(X509_CRL *crl, X509_REVOKED **ret,
                                 ASN1_INTEGER *ser, X509_NAME *issuer),
         int (*crl_verify)(X509_CRL *crl, EVP_PKEY *pk))
-        {
+{
         X509_CRL_METHOD *m;
         m = malloc(sizeof(X509_CRL_METHOD));
         if (!m)
@@ -502,24 +502,24 @@ X509_CRL_METHOD *X509_CRL_METHOD_new(
         m->crl_verify = crl_verify;
         m->flags = X509_CRL_METHOD_DYNAMIC;
         return m;
-        }
+}
 
 void X509_CRL_METHOD_free(X509_CRL_METHOD *m)
-        {
+{
         if (!(m->flags & X509_CRL_METHOD_DYNAMIC))
                 return;
         free(m);
-        }
+}
 
 void X509_CRL_set_meth_data(X509_CRL *crl, void *dat)
-        {
+{
         crl->meth_data = dat;
-        }
+}
 
 void *X509_CRL_get_meth_data(X509_CRL *crl)
-        {
+{
         return crl->meth_data;
-        }
+}
 
 IMPLEMENT_STACK_OF(X509_REVOKED)
 IMPLEMENT_ASN1_SET_OF(X509_REVOKED)