From 69a8d2dcc19aed0d1116ba2ecd81cce5ae736c94 Mon Sep 17 00:00:00 2001 From: jsing <> Date: Tue, 15 Apr 2014 13:42:55 +0000 Subject: 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. --- src/lib/libcrypto/ex_data.c | 440 ++++++++++++++++++++++---------------------- 1 file changed, 220 insertions(+), 220 deletions(-) (limited to 'src/lib/libcrypto/ex_data.c') 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 /* 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) -- cgit v1.2.3-55-g6feb