blunt force knf

1 files changed, 134 insertions, 183 deletions

diff --git a/src/lib/libcrypto/x509/x509_lu.c b/src/lib/libcrypto/x509/x509_lu.c
index 38b034bfee..a89cd70313 100644
--- a/src/lib/libcrypto/x509/x509_lu.c
+++ b/src/lib/libcrypto/x509/x509_lu.c
@@ -63,7 +63,7 @@
 #include <openssl/x509v3.h>
 
 X509_LOOKUP *X509_LOOKUP_new(X509_LOOKUP_METHOD *method)
-        {
+{
         X509_LOOKUP *ret;
 
         ret=(X509_LOOKUP *)malloc(sizeof(X509_LOOKUP));
@@ -74,50 +74,49 @@ X509_LOOKUP *X509_LOOKUP_new(X509_LOOKUP_METHOD *method)
         ret->method=method;
         ret->method_data=NULL;
         ret->store_ctx=NULL;
-        if ((method->new_item != NULL) && !method->new_item(ret))
-                {
+        if ((method->new_item != NULL) && !method->new_item(ret)) {
                 free(ret);
                 return NULL;
-                }
-        return ret;
         }
+        return ret;
+}
 
 void X509_LOOKUP_free(X509_LOOKUP *ctx)
-        {
+{
         if (ctx == NULL) return;
         if (    (ctx->method != NULL) &&
                 (ctx->method->free != NULL))
                 (*ctx->method->free)(ctx);
         free(ctx);
-        }
+}
 
 int X509_LOOKUP_init(X509_LOOKUP *ctx)
-        {
+{
         if (ctx->method == NULL) return 0;
         if (ctx->method->init != NULL)
                 return ctx->method->init(ctx);
         else
                 return 1;
-        }
+}
 
 int X509_LOOKUP_shutdown(X509_LOOKUP *ctx)
-        {
+{
         if (ctx->method == NULL) return 0;
         if (ctx->method->shutdown != NULL)
                 return ctx->method->shutdown(ctx);
         else
                 return 1;
-        }
+}
 
 int X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, long argl,
              char **ret)
-        {
+{
         if (ctx->method == NULL) return -1;
         if (ctx->method->ctrl != NULL)
                 return ctx->method->ctrl(ctx,cmd,argc,argl,ret);
         else
                 return 1;
-        }
+}
 
 int X509_LOOKUP_by_subject(X509_LOOKUP *ctx, int type, X509_NAME *name,
              X509_OBJECT *ret)
@@ -126,42 +125,41 @@ int X509_LOOKUP_by_subject(X509_LOOKUP *ctx, int type, X509_NAME *name,
                 return X509_LU_FAIL;
         if (ctx->skip) return 0;
         return ctx->method->get_by_subject(ctx,type,name,ret);
-        }
+}
 
 int X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, int type, X509_NAME *name,
              ASN1_INTEGER *serial, X509_OBJECT *ret)
-        {
+{
         if ((ctx->method == NULL) ||
                 (ctx->method->get_by_issuer_serial == NULL))
                 return X509_LU_FAIL;
         return ctx->method->get_by_issuer_serial(ctx,type,name,serial,ret);
-        }
+}
 
 int X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, int type,
              unsigned char *bytes, int len, X509_OBJECT *ret)
-        {
+{
         if ((ctx->method == NULL) || (ctx->method->get_by_fingerprint == NULL))
                 return X509_LU_FAIL;
         return ctx->method->get_by_fingerprint(ctx,type,bytes,len,ret);
-        }
+}
 
 int X509_LOOKUP_by_alias(X509_LOOKUP *ctx, int type, char *str, int len,
              X509_OBJECT *ret)
-        {
+{
         if ((ctx->method == NULL) || (ctx->method->get_by_alias == NULL))
                 return X509_LU_FAIL;
         return ctx->method->get_by_alias(ctx,type,str,len,ret);
-        }
+}
 
   
 static int x509_object_cmp(const X509_OBJECT * const *a, const X509_OBJECT * const *b)
-        {
+  {
         int ret;
 
         ret=((*a)->type - (*b)->type);
         if (ret) return ret;
-        switch ((*a)->type)
-                {
+        switch ((*a)->type) {
         case X509_LU_X509:
                 ret=X509_subject_name_cmp((*a)->data.x509,(*b)->data.x509);
                 break;
@@ -171,12 +169,12 @@ static int x509_object_cmp(const X509_OBJECT * const *a, const X509_OBJECT * con
         default:
                 /* abort(); */
                 return 0;
-                }
-        return ret;
         }
+        return ret;
+}
 
 X509_STORE *X509_STORE_new(void)
-        {
+{
         X509_STORE *ret;
 
         if ((ret=(X509_STORE *)malloc(sizeof(X509_STORE))) == NULL)
@@ -191,7 +189,7 @@ X509_STORE *X509_STORE_new(void)
                 sk_X509_OBJECT_free(ret->objs);
                 free(ret);
                 return NULL;
-        }
+}
 
         ret->get_issuer = 0;
         ret->check_issued = 0;
@@ -203,37 +201,31 @@ X509_STORE *X509_STORE_new(void)
         ret->lookup_crls = 0;
         ret->cleanup = 0;
 
-        if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_X509_STORE, ret, &ret->ex_data))
-                {
+        if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_X509_STORE, ret, &ret->ex_data)) {
                 sk_X509_OBJECT_free(ret->objs);
                 free(ret);
                 return NULL;
-                }
+        }
 
         ret->references=1;
         return ret;
-        }
+}
 
 static void cleanup(X509_OBJECT *a)
-        {
-        if (a->type == X509_LU_X509)
-                {
+{
+        if (a->type == X509_LU_X509) {
                 X509_free(a->data.x509);
-                }
-        else if (a->type == X509_LU_CRL)
-                {
+        } else if (a->type == X509_LU_CRL) {
                 X509_CRL_free(a->data.crl);
-                }
-        else
-                {
+        } else {
                 /* abort(); */
-                }
+        }
 
         free(a);
-        }
+}
 
 void X509_STORE_free(X509_STORE *vfy)
-        {
+{
         int i;
         STACK_OF(X509_LOOKUP) *sk;
         X509_LOOKUP *lu;
@@ -242,12 +234,11 @@ void X509_STORE_free(X509_STORE *vfy)
             return;
 
         sk=vfy->get_cert_methods;
-        for (i=0; i<sk_X509_LOOKUP_num(sk); i++)
-                {
+        for (i=0; i<sk_X509_LOOKUP_num(sk); i++) {
                 lu=sk_X509_LOOKUP_value(sk,i);
                 X509_LOOKUP_shutdown(lu);
                 X509_LOOKUP_free(lu);
-                }
+        }
         sk_X509_LOOKUP_free(sk);
         sk_X509_OBJECT_pop_free(vfy->objs, cleanup);
 
@@ -255,43 +246,39 @@ void X509_STORE_free(X509_STORE *vfy)
         if (vfy->param)
                 X509_VERIFY_PARAM_free(vfy->param);
         free(vfy);
-        }
+}
 
 X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m)
-        {
+{
         int i;
         STACK_OF(X509_LOOKUP) *sk;
         X509_LOOKUP *lu;
 
         sk=v->get_cert_methods;
-        for (i=0; i<sk_X509_LOOKUP_num(sk); i++)
-                {
+        for (i=0; i<sk_X509_LOOKUP_num(sk); i++) {
                 lu=sk_X509_LOOKUP_value(sk,i);
-                if (m == lu->method)
-                        {
+                if (m == lu->method) {
                         return lu;
-                        }
                 }
+        }
         /* a new one */
         lu=X509_LOOKUP_new(m);
         if (lu == NULL)
                 return NULL;
-        else
-                {
+        else {
                 lu->store_ctx=v;
                 if (sk_X509_LOOKUP_push(v->get_cert_methods,lu))
                         return lu;
-                else
-                        {
+                else {
                         X509_LOOKUP_free(lu);
                         return NULL;
-                        }
                 }
         }
+}
 
 int X509_STORE_get_by_subject(X509_STORE_CTX *vs, int type, X509_NAME *name,
              X509_OBJECT *ret)
-        {
+{
         X509_STORE *ctx=vs->ctx;
         X509_LOOKUP *lu;
         X509_OBJECT stmp,*tmp;
@@ -301,27 +288,22 @@ int X509_STORE_get_by_subject(X509_STORE_CTX *vs, int type, X509_NAME *name,
         tmp=X509_OBJECT_retrieve_by_subject(ctx->objs,type,name);
         CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
 
-        if (tmp == NULL || type == X509_LU_CRL)
-                {
-                for (i=vs->current_method; i<sk_X509_LOOKUP_num(ctx->get_cert_methods); i++)
-                        {
+        if (tmp == NULL || type == X509_LU_CRL) {
+                for (i=vs->current_method; i<sk_X509_LOOKUP_num(ctx->get_cert_methods); i++) {
                         lu=sk_X509_LOOKUP_value(ctx->get_cert_methods,i);
                         j=X509_LOOKUP_by_subject(lu,type,name,&stmp);
-                        if (j < 0)
-                                {
+                        if (j < 0) {
                                 vs->current_method=j;
                                 return j;
-                                }
-                        else if (j)
-                                {
+                        } else if (j) {
                                 tmp= &stmp;
                                 break;
-                                }
                         }
+                }
                 vs->current_method=0;
                 if (tmp == NULL)
                         return 0;
-                }
+        }
 
 /*      if (ret->data.ptr != NULL)
                 X509_OBJECT_free_contents(ret); */
@@ -332,20 +314,19 @@ int X509_STORE_get_by_subject(X509_STORE_CTX *vs, int type, X509_NAME *name,
         X509_OBJECT_up_ref_count(ret);
 
         return 1;
-        }
+}
 
 int X509_STORE_add_cert(X509_STORE *ctx, X509 *x)
-        {
+{
         X509_OBJECT *obj;
         int ret=1;
 
         if (x == NULL) return 0;
         obj=(X509_OBJECT *)malloc(sizeof(X509_OBJECT));
-        if (obj == NULL)
-                {
+        if (obj == NULL) {
                 X509err(X509_F_X509_STORE_ADD_CERT,ERR_R_MALLOC_FAILURE);
                 return 0;
-                }
+        }
         obj->type=X509_LU_X509;
         obj->data.x509=x;
 
@@ -353,32 +334,30 @@ int X509_STORE_add_cert(X509_STORE *ctx, X509 *x)
 
         X509_OBJECT_up_ref_count(obj);
 
-        if (X509_OBJECT_retrieve_match(ctx->objs, obj))
-                {
+        if (X509_OBJECT_retrieve_match(ctx->objs, obj)) {
                 X509_OBJECT_free_contents(obj);
                 free(obj);
                 X509err(X509_F_X509_STORE_ADD_CERT,X509_R_CERT_ALREADY_IN_HASH_TABLE);
                 ret=0;
-                } 
+        } 
         else sk_X509_OBJECT_push(ctx->objs, obj);
 
         CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
 
         return ret;
-        }
+}
 
 int X509_STORE_add_crl(X509_STORE *ctx, X509_CRL *x)
-        {
+{
         X509_OBJECT *obj;
         int ret=1;
 
         if (x == NULL) return 0;
         obj=(X509_OBJECT *)malloc(sizeof(X509_OBJECT));
-        if (obj == NULL)
-                {
+        if (obj == NULL) {
                 X509err(X509_F_X509_STORE_ADD_CRL,ERR_R_MALLOC_FAILURE);
                 return 0;
-                }
+        }
         obj->type=X509_LU_CRL;
         obj->data.crl=x;
 
@@ -386,49 +365,46 @@ int X509_STORE_add_crl(X509_STORE *ctx, X509_CRL *x)
 
         X509_OBJECT_up_ref_count(obj);
 
-        if (X509_OBJECT_retrieve_match(ctx->objs, obj))
-                {
+        if (X509_OBJECT_retrieve_match(ctx->objs, obj)) {
                 X509_OBJECT_free_contents(obj);
                 free(obj);
                 X509err(X509_F_X509_STORE_ADD_CRL,X509_R_CERT_ALREADY_IN_HASH_TABLE);
                 ret=0;
-                }
-        else sk_X509_OBJECT_push(ctx->objs, obj);
+        } else
+                sk_X509_OBJECT_push(ctx->objs, obj);
 
         CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
 
         return ret;
-        }
+}
 
 void X509_OBJECT_up_ref_count(X509_OBJECT *a)
-        {
-        switch (a->type)
-                {
+{
+        switch (a->type) {
         case X509_LU_X509:
                 CRYPTO_add(&a->data.x509->references,1,CRYPTO_LOCK_X509);
                 break;
         case X509_LU_CRL:
                 CRYPTO_add(&a->data.crl->references,1,CRYPTO_LOCK_X509_CRL);
                 break;
-                }
         }
+}
 
 void X509_OBJECT_free_contents(X509_OBJECT *a)
-        {
-        switch (a->type)
-                {
+{
+        switch (a->type) {
         case X509_LU_X509:
                 X509_free(a->data.x509);
                 break;
         case X509_LU_CRL:
                 X509_CRL_free(a->data.crl);
                 break;
-                }
         }
+}
 
 static int x509_object_idx_cnt(STACK_OF(X509_OBJECT) *h, int type,
              X509_NAME *name, int *pnmatch)
-        {
+{
         X509_OBJECT stmp;
         X509 x509_s;
         X509_CINF cinf_s;
@@ -437,8 +413,7 @@ static int x509_object_idx_cnt(STACK_OF(X509_OBJECT) *h, int type,
         int idx;
 
         stmp.type=type;
-        switch (type)
-                {
+        switch (type) {
         case X509_LU_X509:
                 stmp.data.x509= &x509_s;
                 x509_s.cert_info= &cinf_s;
@@ -452,44 +427,42 @@ static int x509_object_idx_cnt(STACK_OF(X509_OBJECT) *h, int type,
         default:
                 /* abort(); */
                 return -1;
-                }
+        }
 
         idx = sk_X509_OBJECT_find(h,&stmp);
-        if (idx >= 0 && pnmatch)
-                {
+        if (idx >= 0 && pnmatch) {
                 int tidx;
                 const X509_OBJECT *tobj, *pstmp;
                 *pnmatch = 1;
                 pstmp = &stmp;
-                for (tidx = idx + 1; tidx < sk_X509_OBJECT_num(h); tidx++)
-                        {
+                for (tidx = idx + 1; tidx < sk_X509_OBJECT_num(h); tidx++) {
                         tobj = sk_X509_OBJECT_value(h, tidx);
                         if (x509_object_cmp(&tobj, &pstmp))
                                 break;
                         (*pnmatch)++;
-                        }
                 }
-        return idx;
         }
+        return idx;
+}
 
 
 int X509_OBJECT_idx_by_subject(STACK_OF(X509_OBJECT) *h, int type,
              X509_NAME *name)
-        {
+{
         return x509_object_idx_cnt(h, type, name, NULL);
-        }
+}
 
 X509_OBJECT *X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h, int type,
              X509_NAME *name)
-        {
+{
         int idx;
         idx = X509_OBJECT_idx_by_subject(h, type, name);
         if (idx==-1) return NULL;
         return sk_X509_OBJECT_value(h, idx);
-        }
+}
 
 STACK_OF(X509)* X509_STORE_get1_certs(X509_STORE_CTX *ctx, X509_NAME *nm)
-        {
+{
         int i, idx, cnt;
         STACK_OF(X509) *sk;
         X509 *x;
@@ -497,48 +470,43 @@ STACK_OF(X509)* X509_STORE_get1_certs(X509_STORE_CTX *ctx, X509_NAME *nm)
         sk = sk_X509_new_null();
         CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
         idx = x509_object_idx_cnt(ctx->ctx->objs, X509_LU_X509, nm, &cnt);
-        if (idx < 0)
-                {
+        if (idx < 0) {
                 /* Nothing found in cache: do lookup to possibly add new
                  * objects to cache
                  */
                 X509_OBJECT xobj;
                 CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
-                if (!X509_STORE_get_by_subject(ctx, X509_LU_X509, nm, &xobj))
-                        {
+                if (!X509_STORE_get_by_subject(ctx, X509_LU_X509, nm, &xobj)) {
                         sk_X509_free(sk);
                         return NULL;
-                        }
+                }
                 X509_OBJECT_free_contents(&xobj);
                 CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
                 idx = x509_object_idx_cnt(ctx->ctx->objs,X509_LU_X509,nm, &cnt);
-                if (idx < 0)
-                        {
+                if (idx < 0) {
                         CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
                         sk_X509_free(sk);
                         return NULL;
-                        }
                 }
-        for (i = 0; i < cnt; i++, idx++)
-                {
+        }
+        for (i = 0; i < cnt; i++, idx++) {
                 obj = sk_X509_OBJECT_value(ctx->ctx->objs, idx);
                 x = obj->data.x509;
                 CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);
-                if (!sk_X509_push(sk, x))
-                        {
+                if (!sk_X509_push(sk, x)) {
                         CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
                         X509_free(x);
                         sk_X509_pop_free(sk, X509_free);
                         return NULL;
-                        }
                 }
+        }
         CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
         return sk;
 
-        }
+}
 
 STACK_OF(X509_CRL)* X509_STORE_get1_crls(X509_STORE_CTX *ctx, X509_NAME *nm)
-        {
+{
         int i, idx, cnt;
         STACK_OF(X509_CRL) *sk;
         X509_CRL *x;
@@ -551,66 +519,57 @@ STACK_OF(X509_CRL)* X509_STORE_get1_crls(X509_STORE_CTX *ctx, X509_NAME *nm)
         /* Always do lookup to possibly add new CRLs to cache
          */
         CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
-        if (!X509_STORE_get_by_subject(ctx, X509_LU_CRL, nm, &xobj))
-                {
+        if (!X509_STORE_get_by_subject(ctx, X509_LU_CRL, nm, &xobj)) {
                 sk_X509_CRL_free(sk);
                 return NULL;
-                }
+        }
         X509_OBJECT_free_contents(&xobj);
         CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
         idx = x509_object_idx_cnt(ctx->ctx->objs,X509_LU_CRL, nm, &cnt);
-        if (idx < 0)
-                {
+        if (idx < 0) {
                 CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
                 sk_X509_CRL_free(sk);
                 return NULL;
-                }
+        }
 
-        for (i = 0; i < cnt; i++, idx++)
-                {
+        for (i = 0; i < cnt; i++, idx++) {
                 obj = sk_X509_OBJECT_value(ctx->ctx->objs, idx);
                 x = obj->data.crl;
                 CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509_CRL);
-                if (!sk_X509_CRL_push(sk, x))
-                        {
+                if (!sk_X509_CRL_push(sk, x)) {
                         CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
                         X509_CRL_free(x);
                         sk_X509_CRL_pop_free(sk, X509_CRL_free);
                         return NULL;
-                        }
                 }
+        }
         CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
         return sk;
-        }
+}
 
 X509_OBJECT *X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h, X509_OBJECT *x)
-        {
+{
         int idx, i;
         X509_OBJECT *obj;
         idx = sk_X509_OBJECT_find(h, x);
         if (idx == -1) return NULL;
         if ((x->type != X509_LU_X509) && (x->type != X509_LU_CRL))
                 return sk_X509_OBJECT_value(h, idx);
-        for (i = idx; i < sk_X509_OBJECT_num(h); i++)
-                {
+        for (i = idx; i < sk_X509_OBJECT_num(h); i++) {
                 obj = sk_X509_OBJECT_value(h, i);
                 if (x509_object_cmp((const X509_OBJECT **)&obj, (const X509_OBJECT **)&x))
                         return NULL;
-                if (x->type == X509_LU_X509)
-                        {
+                if (x->type == X509_LU_X509) {
                         if (!X509_cmp(obj->data.x509, x->data.x509))
                                 return obj;
-                        }
-                else if (x->type == X509_LU_CRL)
-                        {
+                } else if (x->type == X509_LU_CRL) {
                         if (!X509_CRL_match(obj->data.crl, x->data.crl))
                                 return obj;
-                        }
-                else
+                } else
                         return obj;
-                }
-        return NULL;
         }
+        return NULL;
+}
 
 
 /* Try to get issuer certificate from store. Due to limitations
@@ -625,95 +584,87 @@ X509_OBJECT *X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h, X509_OBJECT *x
  * -1 some other error.
  */
 int X509_STORE_CTX_get1_issuer(X509 **issuer, X509_STORE_CTX *ctx, X509 *x)
-        {
+{
         X509_NAME *xn;
         X509_OBJECT obj, *pobj;
         int i, ok, idx, ret;
         xn=X509_get_issuer_name(x);
         ok=X509_STORE_get_by_subject(ctx,X509_LU_X509,xn,&obj);
-        if (ok != X509_LU_X509)
-                {
-                if (ok == X509_LU_RETRY)
-                        {
+        if (ok != X509_LU_X509) {
+                if (ok == X509_LU_RETRY) {
                         X509_OBJECT_free_contents(&obj);
                         X509err(X509_F_X509_STORE_CTX_GET1_ISSUER,X509_R_SHOULD_RETRY);
                         return -1;
-                        }
-                else if (ok != X509_LU_FAIL)
-                        {
+                } else if (ok != X509_LU_FAIL) {
                         X509_OBJECT_free_contents(&obj);
                         /* not good :-(, break anyway */
                         return -1;
-                        }
-                return 0;
                 }
+                return 0;
+        }
         /* If certificate matches all OK */
-        if (ctx->check_issued(ctx, x, obj.data.x509))
-                {
+        if (ctx->check_issued(ctx, x, obj.data.x509)) {
                 *issuer = obj.data.x509;
                 return 1;
-                }
+        }
         X509_OBJECT_free_contents(&obj);
 
         /* Else find index of first cert accepted by 'check_issued' */
         ret = 0;
         CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
         idx = X509_OBJECT_idx_by_subject(ctx->ctx->objs, X509_LU_X509, xn);
-        if (idx != -1) /* should be true as we've had at least one match */
-                {
+        if (idx != -1) /* should be true as we've had at least one match */ {
                 /* Look through all matching certs for suitable issuer */
-                for (i = idx; i < sk_X509_OBJECT_num(ctx->ctx->objs); i++)
-                        {
+                for (i = idx; i < sk_X509_OBJECT_num(ctx->ctx->objs); i++) {
                         pobj = sk_X509_OBJECT_value(ctx->ctx->objs, i);
                         /* See if we've run past the matches */
                         if (pobj->type != X509_LU_X509)
                                 break;
                         if (X509_NAME_cmp(xn, X509_get_subject_name(pobj->data.x509)))
                                 break;
-                        if (ctx->check_issued(ctx, x, pobj->data.x509))
-                                {
+                        if (ctx->check_issued(ctx, x, pobj->data.x509)) {
                                 *issuer = pobj->data.x509;
                                 X509_OBJECT_up_ref_count(pobj);
                                 ret = 1;
                                 break;
-                                }
                         }
                 }
+        }
         CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
         return ret;
-        }
+}
 
 int X509_STORE_set_flags(X509_STORE *ctx, unsigned long flags)
-        {
+{
         return X509_VERIFY_PARAM_set_flags(ctx->param, flags);
-        }
+}
 
 int X509_STORE_set_depth(X509_STORE *ctx, int depth)
-        {
+{
         X509_VERIFY_PARAM_set_depth(ctx->param, depth);
         return 1;
-        }
+}
 
 int X509_STORE_set_purpose(X509_STORE *ctx, int purpose)
-        {
+{
         return X509_VERIFY_PARAM_set_purpose(ctx->param, purpose);
-        }
+}
 
 int X509_STORE_set_trust(X509_STORE *ctx, int trust)
-        {
+{
         return X509_VERIFY_PARAM_set_trust(ctx->param, trust);
-        }
+}
 
 int X509_STORE_set1_param(X509_STORE *ctx, X509_VERIFY_PARAM *param)
-        {
+{
         return X509_VERIFY_PARAM_set1(ctx->param, param);
-        }
+}
 
 void X509_STORE_set_verify_cb(X509_STORE *ctx,
                                   int (*verify_cb)(int, X509_STORE_CTX *))
-        {
+{
         ctx->verify_cb = verify_cb;
-        }
+}
 
 IMPLEMENT_STACK_OF(X509_LOOKUP)
 IMPLEMENT_STACK_OF(X509_OBJECT)