First pass at applying KNF to the OpenSSL code, which almost makes it

readable. This pass is whitespace only and can readily be verified using
tr and md5.

1 files changed, 220 insertions, 220 deletions

diff --git a/src/lib/libcrypto/ex_data.c b/src/lib/libcrypto/ex_data.c
index e2bc8298d0..44bad59527 100644
--- a/src/lib/libcrypto/ex_data.c
+++ b/src/lib/libcrypto/ex_data.c
@@ -142,8 +142,7 @@
 #include <openssl/lhash.h>
 
 /* What an "implementation of ex_data functionality" looks like */
-struct st_CRYPTO_EX_DATA_IMPL
-        {
+struct st_CRYPTO_EX_DATA_IMPL {
         /*********************/
         /* GLOBAL OPERATIONS */
         /* Return a new class index */
@@ -154,79 +153,83 @@ struct st_CRYPTO_EX_DATA_IMPL
         /* PER-CLASS OPERATIONS */
         /* Get a new method index within a class */
         int (*cb_get_new_index)(int class_index, long argl, void *argp,
-                        CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func,
-                        CRYPTO_EX_free *free_func);
+            CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func,
+            CRYPTO_EX_free *free_func);
         /* Initialise a new CRYPTO_EX_DATA of a given class */
         int (*cb_new_ex_data)(int class_index, void *obj,
-                        CRYPTO_EX_DATA *ad);
+            CRYPTO_EX_DATA *ad);
         /* Duplicate a CRYPTO_EX_DATA of a given class onto a copy */
         int (*cb_dup_ex_data)(int class_index, CRYPTO_EX_DATA *to,
-                        CRYPTO_EX_DATA *from);
+            CRYPTO_EX_DATA *from);
         /* Cleanup a CRYPTO_EX_DATA of a given class */
         void (*cb_free_ex_data)(int class_index, void *obj,
-                        CRYPTO_EX_DATA *ad);
-        };
+            CRYPTO_EX_DATA *ad);
+};
 
 /* The implementation we use at run-time */
 static const CRYPTO_EX_DATA_IMPL *impl = NULL;
 
 /* To call "impl" functions, use this macro rather than referring to 'impl' directly, eg.
- * EX_IMPL(get_new_index)(...); */
+ * EX_IMPL(get_new_index)(...);
+*/
 #define EX_IMPL(a) impl->cb_##a
 
 /* Predeclare the "default" ex_data implementation */
 static int int_new_class(void);
 static void int_cleanup(void);
 static int int_get_new_index(int class_index, long argl, void *argp,
-                CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func,
-                CRYPTO_EX_free *free_func);
+    CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func,
+    CRYPTO_EX_free *free_func);
 static int int_new_ex_data(int class_index, void *obj,
-                CRYPTO_EX_DATA *ad);
+    CRYPTO_EX_DATA *ad);
 static int int_dup_ex_data(int class_index, CRYPTO_EX_DATA *to,
-                CRYPTO_EX_DATA *from);
+    CRYPTO_EX_DATA *from);
 static void int_free_ex_data(int class_index, void *obj,
-                CRYPTO_EX_DATA *ad);
-static CRYPTO_EX_DATA_IMPL impl_default =
-        {
+    CRYPTO_EX_DATA *ad);
+
+static CRYPTO_EX_DATA_IMPL impl_default = {
         int_new_class,
         int_cleanup,
         int_get_new_index,
         int_new_ex_data,
         int_dup_ex_data,
         int_free_ex_data
-        };
+};
 
 /* Internal function that checks whether "impl" is set and if not, sets it to
  * the default. */
-static void impl_check(void)
-        {
+static void
+impl_check(void)
+{
         CRYPTO_w_lock(CRYPTO_LOCK_EX_DATA);
-        if(!impl)
+        if (!impl)
                 impl = &impl_default;
         CRYPTO_w_unlock(CRYPTO_LOCK_EX_DATA);
-        }
+}
 /* A macro wrapper for impl_check that first uses a non-locked test before
  * invoking the function (which checks again inside a lock). */
 #define IMPL_CHECK if(!impl) impl_check();
 
 /* API functions to get/set the "ex_data" implementation */
-const CRYPTO_EX_DATA_IMPL *CRYPTO_get_ex_data_implementation(void)
-        {
+const CRYPTO_EX_DATA_IMPL
+*CRYPTO_get_ex_data_implementation(void)
+{
         IMPL_CHECK
         return impl;
-        }
-int CRYPTO_set_ex_data_implementation(const CRYPTO_EX_DATA_IMPL *i)
-        {
+}
+
+int
+CRYPTO_set_ex_data_implementation(const CRYPTO_EX_DATA_IMPL *i)
+{
         int toret = 0;
         CRYPTO_w_lock(CRYPTO_LOCK_EX_DATA);
-        if(!impl)
-                {
+        if (!impl) {
                 impl = i;
                 toret = 1;
-                }
+        }
         CRYPTO_w_unlock(CRYPTO_LOCK_EX_DATA);
         return toret;
-        }
+}
 
 /****************************************************************************/
 /* Interal (default) implementation of "ex_data" support. API functions are
@@ -249,288 +252,283 @@ DECLARE_LHASH_OF(EX_CLASS_ITEM);
 static LHASH_OF(EX_CLASS_ITEM) *ex_data = NULL;
 
 /* The callbacks required in the "ex_data" hash table */
-static unsigned long ex_class_item_hash(const EX_CLASS_ITEM *a)
-        {
+static unsigned long
+ex_class_item_hash(const EX_CLASS_ITEM *a)
+{
         return a->class_index;
-        }
+}
+
 static IMPLEMENT_LHASH_HASH_FN(ex_class_item, EX_CLASS_ITEM)
 
-static int ex_class_item_cmp(const EX_CLASS_ITEM *a, const EX_CLASS_ITEM *b)
-        {
+static int
+ex_class_item_cmp(const EX_CLASS_ITEM *a, const EX_CLASS_ITEM *b)
+{
         return a->class_index - b->class_index;
-        }
+}
+
 static IMPLEMENT_LHASH_COMP_FN(ex_class_item, EX_CLASS_ITEM)
 
 /* Internal functions used by the "impl_default" implementation to access the
  * state */
 
-static int ex_data_check(void)
-        {
+static int
+ex_data_check(void)
+{
         int toret = 1;
         CRYPTO_w_lock(CRYPTO_LOCK_EX_DATA);
-        if(!ex_data
-           && (ex_data = lh_EX_CLASS_ITEM_new()) == NULL)
-                toret = 0;
+        if (!ex_data
+                && (ex_data = lh_EX_CLASS_ITEM_new()) == NULL)
+        toret = 0;
         CRYPTO_w_unlock(CRYPTO_LOCK_EX_DATA);
         return toret;
-        }
+}
 /* This macros helps reduce the locking from repeated checks because the
  * ex_data_check() function checks ex_data again inside a lock. */
 #define EX_DATA_CHECK(iffail) if(!ex_data && !ex_data_check()) {iffail}
 
 /* This "inner" callback is used by the callback function that follows it */
-static void def_cleanup_util_cb(CRYPTO_EX_DATA_FUNCS *funcs)
-        {
+static void
+def_cleanup_util_cb(CRYPTO_EX_DATA_FUNCS *funcs)
+{
         OPENSSL_free(funcs);
-        }
+}
 
 /* This callback is used in lh_doall to destroy all EX_CLASS_ITEM values from
  * "ex_data" prior to the ex_data hash table being itself destroyed. Doesn't do
  * any locking. */
-static void def_cleanup_cb(void *a_void)
-        {
+static void
+def_cleanup_cb(void *a_void)
+{
         EX_CLASS_ITEM *item = (EX_CLASS_ITEM *)a_void;
         sk_CRYPTO_EX_DATA_FUNCS_pop_free(item->meth, def_cleanup_util_cb);
         OPENSSL_free(item);
-        }
+}
 
 /* Return the EX_CLASS_ITEM from the "ex_data" hash table that corresponds to a
  * given class. Handles locking. */
-static EX_CLASS_ITEM *def_get_class(int class_index)
-        {
+static EX_CLASS_ITEM
+*def_get_class(int class_index)
+{
         EX_CLASS_ITEM d, *p, *gen;
         EX_DATA_CHECK(return NULL;)
         d.class_index = class_index;
         CRYPTO_w_lock(CRYPTO_LOCK_EX_DATA);
         p = lh_EX_CLASS_ITEM_retrieve(ex_data, &d);
-        if(!p)
-                {
+        if (!p) {
                 gen = OPENSSL_malloc(sizeof(EX_CLASS_ITEM));
-                if(gen)
-                        {
+                if (gen) {
                         gen->class_index = class_index;
                         gen->meth_num = 0;
                         gen->meth = sk_CRYPTO_EX_DATA_FUNCS_new_null();
-                        if(!gen->meth)
+                        if (!gen->meth)
                                 OPENSSL_free(gen);
-                        else
-                                {
+                        else {
                                 /* Because we're inside the ex_data lock, the
                                  * return value from the insert will be NULL */
                                 (void)lh_EX_CLASS_ITEM_insert(ex_data, gen);
                                 p = gen;
-                                }
                         }
                 }
+        }
         CRYPTO_w_unlock(CRYPTO_LOCK_EX_DATA);
-        if(!p)
-                CRYPTOerr(CRYPTO_F_DEF_GET_CLASS,ERR_R_MALLOC_FAILURE);
+        if (!p)
+                CRYPTOerr(CRYPTO_F_DEF_GET_CLASS, ERR_R_MALLOC_FAILURE);
         return p;
-        }
+}
 
 /* Add a new method to the given EX_CLASS_ITEM and return the corresponding
  * index (or -1 for error). Handles locking. */
-static int def_add_index(EX_CLASS_ITEM *item, long argl, void *argp,
-                CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func,
-                CRYPTO_EX_free *free_func)
-        {
+static int
+def_add_index(EX_CLASS_ITEM *item, long argl, void *argp,
+    CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
+{
         int toret = -1;
         CRYPTO_EX_DATA_FUNCS *a = (CRYPTO_EX_DATA_FUNCS *)OPENSSL_malloc(
-                                        sizeof(CRYPTO_EX_DATA_FUNCS));
-        if(!a)
-                {
-                CRYPTOerr(CRYPTO_F_DEF_ADD_INDEX,ERR_R_MALLOC_FAILURE);
+        sizeof(CRYPTO_EX_DATA_FUNCS));
+        if (!a) {
+                CRYPTOerr(CRYPTO_F_DEF_ADD_INDEX, ERR_R_MALLOC_FAILURE);
                 return -1;
-                }
-        a->argl=argl;
-        a->argp=argp;
-        a->new_func=new_func;
-        a->dup_func=dup_func;
-        a->free_func=free_func;
+        }
+        a->argl = argl;
+        a->argp = argp;
+        a->new_func = new_func;
+        a->dup_func = dup_func;
+        a->free_func = free_func;
         CRYPTO_w_lock(CRYPTO_LOCK_EX_DATA);
-        while (sk_CRYPTO_EX_DATA_FUNCS_num(item->meth) <= item->meth_num)
-                {
-                if (!sk_CRYPTO_EX_DATA_FUNCS_push(item->meth, NULL))
-                        {
-                        CRYPTOerr(CRYPTO_F_DEF_ADD_INDEX,ERR_R_MALLOC_FAILURE);
+        while (sk_CRYPTO_EX_DATA_FUNCS_num(item->meth) <= item->meth_num) {
+                if (!sk_CRYPTO_EX_DATA_FUNCS_push(item->meth, NULL)) {
+                        CRYPTOerr(CRYPTO_F_DEF_ADD_INDEX, ERR_R_MALLOC_FAILURE);
                         OPENSSL_free(a);
                         goto err;
-                        }
                 }
+        }
         toret = item->meth_num++;
         (void)sk_CRYPTO_EX_DATA_FUNCS_set(item->meth, toret, a);
 err:
         CRYPTO_w_unlock(CRYPTO_LOCK_EX_DATA);
         return toret;
-        }
+}
 
 /**************************************************************/
 /* The functions in the default CRYPTO_EX_DATA_IMPL structure */
 
-static int int_new_class(void)
-        {
+static int
+int_new_class(void)
+{
         int toret;
         CRYPTO_w_lock(CRYPTO_LOCK_EX_DATA);
         toret = ex_class++;
         CRYPTO_w_unlock(CRYPTO_LOCK_EX_DATA);
         return toret;
-        }
+}
 
-static void int_cleanup(void)
-        {
+static void
+int_cleanup(void)
+{
         EX_DATA_CHECK(return;)
         lh_EX_CLASS_ITEM_doall(ex_data, def_cleanup_cb);
         lh_EX_CLASS_ITEM_free(ex_data);
         ex_data = NULL;
         impl = NULL;
-        }
+}
 
-static int int_get_new_index(int class_index, long argl, void *argp,
-                CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func,
-                CRYPTO_EX_free *free_func)
-        {
+static int
+int_get_new_index(int class_index, long argl, void *argp,
+    CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func,
+CRYPTO_EX_free *free_func)
+{
         EX_CLASS_ITEM *item = def_get_class(class_index);
-        if(!item)
+        if (!item)
                 return -1;
         return def_add_index(item, argl, argp, new_func, dup_func, free_func);
-        }
+}
 
 /* Thread-safe by copying a class's array of "CRYPTO_EX_DATA_FUNCS" entries in
  * the lock, then using them outside the lock. NB: Thread-safety only applies to
  * the global "ex_data" state (ie. class definitions), not thread-safe on 'ad'
  * itself. */
-static int int_new_ex_data(int class_index, void *obj,
-                CRYPTO_EX_DATA *ad)
-        {
-        int mx,i;
+static int
+int_new_ex_data(int class_index, void *obj,
+    CRYPTO_EX_DATA *ad)
+{
+        int mx, i;
         void *ptr;
         CRYPTO_EX_DATA_FUNCS **storage = NULL;
         EX_CLASS_ITEM *item = def_get_class(class_index);
-        if(!item)
+        if (!item)
                 /* error is already set */
                 return 0;
         ad->sk = NULL;
         CRYPTO_r_lock(CRYPTO_LOCK_EX_DATA);
         mx = sk_CRYPTO_EX_DATA_FUNCS_num(item->meth);
-        if(mx > 0)
-                {
+        if (mx > 0) {
                 storage = OPENSSL_malloc(mx * sizeof(CRYPTO_EX_DATA_FUNCS*));
-                if(!storage)
+                if (!storage)
                         goto skip;
-                for(i = 0; i < mx; i++)
-                        storage[i] = sk_CRYPTO_EX_DATA_FUNCS_value(item->meth,i);
-                }
+                for (i = 0; i < mx; i++)
+                        storage[i] = sk_CRYPTO_EX_DATA_FUNCS_value(item->meth, i);
+        }
 skip:
         CRYPTO_r_unlock(CRYPTO_LOCK_EX_DATA);
-        if((mx > 0) && !storage)
-                {
-                CRYPTOerr(CRYPTO_F_INT_NEW_EX_DATA,ERR_R_MALLOC_FAILURE);
+        if ((mx > 0) && !storage) {
+                CRYPTOerr(CRYPTO_F_INT_NEW_EX_DATA, ERR_R_MALLOC_FAILURE);
                 return 0;
-                }
-        for(i = 0; i < mx; i++)
-                {
-                if(storage[i] && storage[i]->new_func)
-                        {
+        }
+        for (i = 0; i < mx; i++) {
+                if (storage[i] && storage[i]->new_func) {
                         ptr = CRYPTO_get_ex_data(ad, i);
-                        storage[i]->new_func(obj,ptr,ad,i,
-                                storage[i]->argl,storage[i]->argp);
-                        }
+                        storage[i]->new_func(obj, ptr, ad, i,
+                        storage[i]->argl, storage[i]->argp);
                 }
-        if(storage)
+        }
+        if (storage)
                 OPENSSL_free(storage);
         return 1;
-        }
+}
 
 /* Same thread-safety notes as for "int_new_ex_data" */
-static int int_dup_ex_data(int class_index, CRYPTO_EX_DATA *to,
-                CRYPTO_EX_DATA *from)
-        {
+static int
+int_dup_ex_data(int class_index, CRYPTO_EX_DATA *to,
+    CRYPTO_EX_DATA *from)
+{
         int mx, j, i;
         char *ptr;
         CRYPTO_EX_DATA_FUNCS **storage = NULL;
         EX_CLASS_ITEM *item;
-        if(!from->sk)
+        if (!from->sk)
                 /* 'to' should be "blank" which *is* just like 'from' */
                 return 1;
-        if((item = def_get_class(class_index)) == NULL)
+        if ((item = def_get_class(class_index)) == NULL)
                 return 0;
         CRYPTO_r_lock(CRYPTO_LOCK_EX_DATA);
         mx = sk_CRYPTO_EX_DATA_FUNCS_num(item->meth);
         j = sk_void_num(from->sk);
-        if(j < mx)
+        if (j < mx)
                 mx = j;
-        if(mx > 0)
-                {
+        if (mx > 0) {
                 storage = OPENSSL_malloc(mx * sizeof(CRYPTO_EX_DATA_FUNCS*));
-                if(!storage)
+                if (!storage)
                         goto skip;
-                for(i = 0; i < mx; i++)
-                        storage[i] = sk_CRYPTO_EX_DATA_FUNCS_value(item->meth,i);
-                }
+                for (i = 0; i < mx; i++)
+                        storage[i] = sk_CRYPTO_EX_DATA_FUNCS_value(item->meth, i);
+        }
 skip:
         CRYPTO_r_unlock(CRYPTO_LOCK_EX_DATA);
-        if((mx > 0) && !storage)
-                {
-                CRYPTOerr(CRYPTO_F_INT_DUP_EX_DATA,ERR_R_MALLOC_FAILURE);
+        if ((mx > 0) && !storage) {
+                CRYPTOerr(CRYPTO_F_INT_DUP_EX_DATA, ERR_R_MALLOC_FAILURE);
                 return 0;
-                }
-        for(i = 0; i < mx; i++)
-                {
+        }
+        for (i = 0; i < mx; i++) {
                 ptr = CRYPTO_get_ex_data(from, i);
-                if(storage[i] && storage[i]->dup_func)
-                        storage[i]->dup_func(to,from,&ptr,i,
-                                storage[i]->argl,storage[i]->argp);
-                CRYPTO_set_ex_data(to,i,ptr);
-                }
-        if(storage)
+                if (storage[i] && storage[i]->dup_func)
+                        storage[i]->dup_func(to, from, &ptr, i,
+                            storage[i]->argl, storage[i]->argp);
+                CRYPTO_set_ex_data(to, i, ptr);
+        }
+        if (storage)
                 OPENSSL_free(storage);
         return 1;
-        }
+}
 
 /* Same thread-safety notes as for "int_new_ex_data" */
-static void int_free_ex_data(int class_index, void *obj,
-                CRYPTO_EX_DATA *ad)
-        {
-        int mx,i;
+static void
+int_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad)
+{
+        int mx, i;
         EX_CLASS_ITEM *item;
         void *ptr;
         CRYPTO_EX_DATA_FUNCS **storage = NULL;
-        if((item = def_get_class(class_index)) == NULL)
+        if ((item = def_get_class(class_index)) == NULL)
                 return;
         CRYPTO_r_lock(CRYPTO_LOCK_EX_DATA);
         mx = sk_CRYPTO_EX_DATA_FUNCS_num(item->meth);
-        if(mx > 0)
-                {
+        if (mx > 0) {
                 storage = OPENSSL_malloc(mx * sizeof(CRYPTO_EX_DATA_FUNCS*));
-                if(!storage)
+                if (!storage)
                         goto skip;
-                for(i = 0; i < mx; i++)
-                        storage[i] = sk_CRYPTO_EX_DATA_FUNCS_value(item->meth,i);
-                }
+                for (i = 0; i < mx; i++)
+                        storage[i] = sk_CRYPTO_EX_DATA_FUNCS_value(item->meth, i);
+        }
 skip:
         CRYPTO_r_unlock(CRYPTO_LOCK_EX_DATA);
-        if((mx > 0) && !storage)
-                {
-                CRYPTOerr(CRYPTO_F_INT_FREE_EX_DATA,ERR_R_MALLOC_FAILURE);
+        if ((mx > 0) && !storage) {
+                CRYPTOerr(CRYPTO_F_INT_FREE_EX_DATA, ERR_R_MALLOC_FAILURE);
                 return;
+        }
+        for (i = 0; i < mx; i++) {
+                if (storage[i] && storage[i]->free_func) {
+                        ptr = CRYPTO_get_ex_data(ad, i);
+                        storage[i]->free_func(obj, ptr, ad, i,
+                        storage[i]->argl, storage[i]->argp);
                 }
-        for(i = 0; i < mx; i++)
-                {
-                if(storage[i] && storage[i]->free_func)
-                        {
-                        ptr = CRYPTO_get_ex_data(ad,i);
-                        storage[i]->free_func(obj,ptr,ad,i,
-                                storage[i]->argl,storage[i]->argp);
-                        }
-                }
-        if(storage)
+        }
+        if (storage)
                 OPENSSL_free(storage);
-        if(ad->sk)
-                {
+        if (ad->sk) {
                 sk_void_free(ad->sk);
-                ad->sk=NULL;
-                }
+                ad->sk = NULL;
         }
+}
 
 /********************************************************************/
 /* API functions that defer all "state" operations to the "ex_data"
@@ -538,99 +536,101 @@ skip:
 
 /* Obtain an index for a new class (not the same as getting a new index within
  * an existing class - this is actually getting a new *class*) */
-int CRYPTO_ex_data_new_class(void)
-        {
+int
+CRYPTO_ex_data_new_class(void)
+{
         IMPL_CHECK
         return EX_IMPL(new_class)();
-        }
+}
 
 /* Release all "ex_data" state to prevent memory leaks. This can't be made
  * thread-safe without overhauling a lot of stuff, and shouldn't really be
  * called under potential race-conditions anyway (it's for program shutdown
  * after all). */
-void CRYPTO_cleanup_all_ex_data(void)
-        {
+void
+CRYPTO_cleanup_all_ex_data(void)
+{
         IMPL_CHECK
         EX_IMPL(cleanup)();
-        }
+}
 
 /* Inside an existing class, get/register a new index. */
-int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp,
-                CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func,
-                CRYPTO_EX_free *free_func)
-        {
+int
+CRYPTO_get_ex_new_index(int class_index, long argl, void *argp,
+    CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
+{
         int ret = -1;
 
         IMPL_CHECK
         ret = EX_IMPL(get_new_index)(class_index,
-                        argl, argp, new_func, dup_func, free_func);
+        argl, argp, new_func, dup_func, free_func);
         return ret;
-        }
+}
 
 /* Initialise a new CRYPTO_EX_DATA for use in a particular class - including
  * calling new() callbacks for each index in the class used by this variable */
-int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad)
-        {
+int
+CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad)
+{
         IMPL_CHECK
         return EX_IMPL(new_ex_data)(class_index, obj, ad);
-        }
+}
 
 /* Duplicate a CRYPTO_EX_DATA variable - including calling dup() callbacks for
  * each index in the class used by this variable */
-int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to,
-             CRYPTO_EX_DATA *from)
-        {
+int
+CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to, CRYPTO_EX_DATA *from)
+{
         IMPL_CHECK
         return EX_IMPL(dup_ex_data)(class_index, to, from);
-        }
+}
 
 /* Cleanup a CRYPTO_EX_DATA variable - including calling free() callbacks for
  * each index in the class used by this variable */
-void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad)
-        {
+void
+CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad)
+{
         IMPL_CHECK
         EX_IMPL(free_ex_data)(class_index, obj, ad);
-        }
+}
 
 /* For a given CRYPTO_EX_DATA variable, set the value corresponding to a
  * particular index in the class used by this variable */
-int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val)
-        {
+int
+CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val)
+{
         int i;
 
-        if (ad->sk == NULL)
-                {
-                if ((ad->sk=sk_void_new_null()) == NULL)
-                        {
-                        CRYPTOerr(CRYPTO_F_CRYPTO_SET_EX_DATA,ERR_R_MALLOC_FAILURE);
-                        return(0);
-                        }
+        if (ad->sk == NULL) {
+                if ((ad->sk = sk_void_new_null()) == NULL) {
+                        CRYPTOerr(CRYPTO_F_CRYPTO_SET_EX_DATA, ERR_R_MALLOC_FAILURE);
+                        return (0);
                 }
-        i=sk_void_num(ad->sk);
-
-        while (i <= idx)
-                {
-                if (!sk_void_push(ad->sk,NULL))
-                        {
-                        CRYPTOerr(CRYPTO_F_CRYPTO_SET_EX_DATA,ERR_R_MALLOC_FAILURE);
-                        return(0);
-                        }
-                i++;
+        }
+        i = sk_void_num(ad->sk);
+
+        while (i <= idx) {
+                if (!sk_void_push(ad->sk, NULL)) {
+                        CRYPTOerr(CRYPTO_F_CRYPTO_SET_EX_DATA, ERR_R_MALLOC_FAILURE);
+                        return (0);
                 }
-        sk_void_set(ad->sk,idx,val);
-        return(1);
+                i++;
         }
+        sk_void_set(ad->sk, idx, val);
+        return (1);
+}
 
 /* For a given CRYPTO_EX_DATA_ variable, get the value corresponding to a
  * particular index in the class used by this variable */
-void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx)
-        {
+void
+*CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx)
+{
         if (ad->sk == NULL)
-                return(0);
+                return (0);
         else if (idx >= sk_void_num(ad->sk))
-                return(0);
+                return (0);
         else
-                return(sk_void_value(ad->sk,idx));
-        }
+                return (sk_void_value(ad->sk, idx));
+}
 
 IMPLEMENT_STACK_OF(CRYPTO_EX_DATA_FUNCS)