1 files changed, 130 insertions, 128 deletions

diff --git a/src/lib/libcrypto/engine/eng_table.c b/src/lib/libcrypto/engine/eng_table.c
index 5781af1eb9..44f3e892b8 100644
--- a/src/lib/libcrypto/engine/eng_table.c
+++ b/src/lib/libcrypto/engine/eng_table.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: eng_table.c,v 1.5 2014/06/12 15:49:29 deraadt Exp $ */
+/* $OpenBSD: eng_table.c,v 1.6 2014/06/22 12:05:09 jsing Exp $ */
 /* ====================================================================
  * Copyright (c) 2001 The OpenSSL Project.  All rights reserved.
  *
@@ -7,7 +7,7 @@
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer. 
+ *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
@@ -59,8 +59,7 @@
 #include "eng_int.h"
 
 /* The type of the items in the table */
-typedef struct st_engine_pile
-        {
+typedef struct st_engine_pile {
         /* The 'nid' of this algorithm/mode */
         int nid;
         /* ENGINEs that implement this algorithm/mode. */
@@ -69,284 +68,287 @@ typedef struct st_engine_pile
         ENGINE *funct;
         /* Zero if 'sk' is newer than the cached 'funct', non-zero otherwise */
         int uptodate;
-        } ENGINE_PILE;
+} ENGINE_PILE;
 
 DECLARE_LHASH_OF(ENGINE_PILE);
 
 /* The type exposed in eng_int.h */
-struct st_engine_table
-        {
+struct st_engine_table {
         LHASH_OF(ENGINE_PILE) piles;
-        }; /* ENGINE_TABLE */
+}; /* ENGINE_TABLE */
 
-
-typedef struct st_engine_pile_doall
-        {
+typedef struct st_engine_pile_doall {
         engine_table_doall_cb *cb;
         void *arg;
-        } ENGINE_PILE_DOALL;
-        
+} ENGINE_PILE_DOALL;
 
 /* Global flags (ENGINE_TABLE_FLAG_***). */
 static unsigned int table_flags = 0;
 
 /* API function manipulating 'table_flags' */
-unsigned int ENGINE_get_table_flags(void)
-        {
+unsigned int
+ENGINE_get_table_flags(void)
+{
         return table_flags;
-        }
+}
 
-void ENGINE_set_table_flags(unsigned int flags)
-        {
+void
+ENGINE_set_table_flags(unsigned int flags)
+{
         table_flags = flags;
-        }
+}
 
 /* Internal functions for the "piles" hash table */
-static unsigned long engine_pile_hash(const ENGINE_PILE *c)
-        {
+static unsigned long
+engine_pile_hash(const ENGINE_PILE *c)
+{
         return c->nid;
-        }
+}
 
-static int engine_pile_cmp(const ENGINE_PILE *a, const ENGINE_PILE *b)
-        {
+static int
+engine_pile_cmp(const ENGINE_PILE *a, const ENGINE_PILE *b)
+{
         return a->nid - b->nid;
-        }
+}
 static IMPLEMENT_LHASH_HASH_FN(engine_pile, ENGINE_PILE)
 static IMPLEMENT_LHASH_COMP_FN(engine_pile, ENGINE_PILE)
 
-static int int_table_check(ENGINE_TABLE **t, int create)
-        {
+static int
+int_table_check(ENGINE_TABLE **t, int create)
+{
         LHASH_OF(ENGINE_PILE) *lh;
 
-        if(*t) return 1;
-        if(!create) return 0;
-        if((lh = lh_ENGINE_PILE_new()) == NULL)
+        if (*t)
+                return 1;
+        if (!create)
+                return 0;
+        if ((lh = lh_ENGINE_PILE_new()) == NULL)
                 return 0;
         *t = (ENGINE_TABLE *)lh;
         return 1;
-        }
+}
 
 /* Privately exposed (via eng_int.h) functions for adding and/or removing
  * ENGINEs from the implementation table */
-int engine_table_register(ENGINE_TABLE **table, ENGINE_CLEANUP_CB *cleanup,
-                ENGINE *e, const int *nids, int num_nids, int setdefault)
-        {
+int
+engine_table_register(ENGINE_TABLE **table, ENGINE_CLEANUP_CB *cleanup,
+    ENGINE *e, const int *nids, int num_nids, int setdefault)
+{
         int ret = 0, added = 0;
         ENGINE_PILE tmplate, *fnd;
+
         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
-        if(!(*table))
+        if (!(*table))
                 added = 1;
-        if(!int_table_check(table, 1))
+        if (!int_table_check(table, 1))
                 goto end;
-        if(added)
+        if (added)
                 /* The cleanup callback needs to be added */
                 engine_cleanup_add_first(cleanup);
-        while(num_nids--)
-                {
+        while (num_nids--) {
                 tmplate.nid = *nids;
                 fnd = lh_ENGINE_PILE_retrieve(&(*table)->piles, &tmplate);
-                if(!fnd)
-                        {
+                if (!fnd) {
                         fnd = malloc(sizeof(ENGINE_PILE));
-                        if(!fnd) goto end;
+                        if (!fnd)
+                                goto end;
                         fnd->uptodate = 1;
                         fnd->nid = *nids;
                         fnd->sk = sk_ENGINE_new_null();
-                        if(!fnd->sk)
-                                {
+                        if (!fnd->sk) {
                                 free(fnd);
                                 goto end;
-                                }
+                        }
                         fnd->funct = NULL;
                         (void)lh_ENGINE_PILE_insert(&(*table)->piles, fnd);
-                        }
+                }
                 /* A registration shouldn't add duplciate entries */
                 (void)sk_ENGINE_delete_ptr(fnd->sk, e);
                 /* if 'setdefault', this ENGINE goes to the head of the list */
-                if(!sk_ENGINE_push(fnd->sk, e))
+                if (!sk_ENGINE_push(fnd->sk, e))
                         goto end;
                 /* "touch" this ENGINE_PILE */
                 fnd->uptodate = 0;
-                if(setdefault)
-                        {
-                        if(!engine_unlocked_init(e))
-                                {
+                if (setdefault) {
+                        if (!engine_unlocked_init(e)) {
                                 ENGINEerr(ENGINE_F_ENGINE_TABLE_REGISTER,
-                                                ENGINE_R_INIT_FAILED);
+                                    ENGINE_R_INIT_FAILED);
                                 goto end;
-                                }
-                        if(fnd->funct)
+                        }
+                        if (fnd->funct)
                                 engine_unlocked_finish(fnd->funct, 0);
                         fnd->funct = e;
                         fnd->uptodate = 1;
-                        }
-                nids++;
                 }
+                nids++;
+        }
         ret = 1;
 end:
         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
         return ret;
-        }
-static void int_unregister_cb_doall_arg(ENGINE_PILE *pile, ENGINE *e)
-        {
+}
+
+static void
+int_unregister_cb_doall_arg(ENGINE_PILE *pile, ENGINE *e)
+{
         int n;
+
         /* Iterate the 'c->sk' stack removing any occurance of 'e' */
-        while((n = sk_ENGINE_find(pile->sk, e)) >= 0)
-                {
+        while ((n = sk_ENGINE_find(pile->sk, e)) >= 0) {
                 (void)sk_ENGINE_delete(pile->sk, n);
                 pile->uptodate = 0;
-                }
-        if(pile->funct == e)
-                {
+        }
+        if (pile->funct == e) {
                 engine_unlocked_finish(e, 0);
                 pile->funct = NULL;
-                }
         }
+}
 static IMPLEMENT_LHASH_DOALL_ARG_FN(int_unregister_cb, ENGINE_PILE, ENGINE)
 
-void engine_table_unregister(ENGINE_TABLE **table, ENGINE *e)
-        {
+void
+engine_table_unregister(ENGINE_TABLE **table, ENGINE *e)
+{
         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
-        if(int_table_check(table, 0))
+        if (int_table_check(table, 0))
                 lh_ENGINE_PILE_doall_arg(&(*table)->piles,
-                                         LHASH_DOALL_ARG_FN(int_unregister_cb),
-                                         ENGINE, e);
+                    LHASH_DOALL_ARG_FN(int_unregister_cb), ENGINE, e);
         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
-        }
+}
 
-static void int_cleanup_cb_doall(ENGINE_PILE *p)
-        {
+static void
+int_cleanup_cb_doall(ENGINE_PILE *p)
+{
         sk_ENGINE_free(p->sk);
-        if(p->funct)
+        if (p->funct)
                 engine_unlocked_finish(p->funct, 0);
         free(p);
-        }
+}
 static IMPLEMENT_LHASH_DOALL_FN(int_cleanup_cb, ENGINE_PILE)
 
-void engine_table_cleanup(ENGINE_TABLE **table)
-        {
+void
+engine_table_cleanup(ENGINE_TABLE **table)
+{
         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
-        if(*table)
-                {
+        if (*table) {
                 lh_ENGINE_PILE_doall(&(*table)->piles,
-                                     LHASH_DOALL_FN(int_cleanup_cb));
+                    LHASH_DOALL_FN(int_cleanup_cb));
                 lh_ENGINE_PILE_free(&(*table)->piles);
                 *table = NULL;
-                }
-        CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
         }
+        CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
+}
 
 /* return a functional reference for a given 'nid' */
 #ifndef ENGINE_TABLE_DEBUG
-ENGINE *engine_table_select(ENGINE_TABLE **table, int nid)
+ENGINE *
+engine_table_select(ENGINE_TABLE **table, int nid)
 #else
-ENGINE *engine_table_select_tmp(ENGINE_TABLE **table, int nid, const char *f, int l)
+ENGINE *
+engine_table_select_tmp(ENGINE_TABLE **table, int nid, const char *f, int l)
 #endif
-        {
+{
         ENGINE *ret = NULL;
-        ENGINE_PILE tmplate, *fnd=NULL;
+        ENGINE_PILE tmplate, *fnd = NULL;
         int initres, loop = 0;
 
-        if(!(*table))
-                {
+        if (!(*table)) {
 #ifdef ENGINE_TABLE_DEBUG
                 fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, nothing "
-                        "registered!\n", f, l, nid);
+                    "registered!\n", f, l, nid);
 #endif
                 return NULL;
-                }
+        }
         ERR_set_mark();
         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
         /* Check again inside the lock otherwise we could race against cleanup
          * operations. But don't worry about a fprintf(stderr). */
-        if(!int_table_check(table, 0)) goto end;
+        if (!int_table_check(table, 0))
+                goto end;
         tmplate.nid = nid;
         fnd = lh_ENGINE_PILE_retrieve(&(*table)->piles, &tmplate);
-        if(!fnd) goto end;
-        if(fnd->funct && engine_unlocked_init(fnd->funct))
-                {
+        if (!fnd)
+                goto end;
+        if (fnd->funct && engine_unlocked_init(fnd->funct)) {
 #ifdef ENGINE_TABLE_DEBUG
                 fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, using "
-                        "ENGINE '%s' cached\n", f, l, nid, fnd->funct->id);
+                    "ENGINE '%s' cached\n", f, l, nid, fnd->funct->id);
 #endif
                 ret = fnd->funct;
                 goto end;
-                }
-        if(fnd->uptodate)
-                {
+        }
+        if (fnd->uptodate) {
                 ret = fnd->funct;
                 goto end;
-                }
+        }
 trynext:
         ret = sk_ENGINE_value(fnd->sk, loop++);
-        if(!ret)
-                {
+        if (!ret) {
 #ifdef ENGINE_TABLE_DEBUG
                 fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, no "
-                                "registered implementations would initialise\n",
-                                f, l, nid);
+                    "registered implementations would initialise\n", f, l, nid);
 #endif
                 goto end;
-                }
+        }
         /* Try to initialise the ENGINE? */
-        if((ret->funct_ref > 0) || !(table_flags & ENGINE_TABLE_FLAG_NOINIT))
+        if ((ret->funct_ref > 0) || !(table_flags & ENGINE_TABLE_FLAG_NOINIT))
                 initres = engine_unlocked_init(ret);
         else
                 initres = 0;
-        if(initres)
-                {
+        if (initres) {
                 /* Update 'funct' */
-                if((fnd->funct != ret) && engine_unlocked_init(ret))
-                        {
+                if ((fnd->funct != ret) && engine_unlocked_init(ret)) {
                         /* If there was a previous default we release it. */
-                        if(fnd->funct)
+                        if (fnd->funct)
                                 engine_unlocked_finish(fnd->funct, 0);
                         fnd->funct = ret;
 #ifdef ENGINE_TABLE_DEBUG
                         fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, "
-                                "setting default to '%s'\n", f, l, nid, ret->id);
+                            "setting default to '%s'\n", f, l, nid, ret->id);
 #endif
-                        }
+                }
 #ifdef ENGINE_TABLE_DEBUG
                 fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, using "
-                                "newly initialised '%s'\n", f, l, nid, ret->id);
+                    "newly initialised '%s'\n", f, l, nid, ret->id);
 #endif
                 goto end;
-                }
+        }
         goto trynext;
 end:
         /* If it failed, it is unlikely to succeed again until some future
          * registrations have taken place. In all cases, we cache. */
-        if(fnd) fnd->uptodate = 1;
+        if (fnd)
+                fnd->uptodate = 1;
 #ifdef ENGINE_TABLE_DEBUG
-        if(ret)
+        if (ret)
                 fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, caching "
-                                "ENGINE '%s'\n", f, l, nid, ret->id);
+                    "ENGINE '%s'\n", f, l, nid, ret->id);
         else
                 fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, caching "
-                                "'no matching ENGINE'\n", f, l, nid);
+                    "'no matching ENGINE'\n", f, l, nid);
 #endif
         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
         /* Whatever happened, any failed init()s are not failures in this
          * context, so clear our error state. */
         ERR_pop_to_mark();
         return ret;
-        }
+}
 
 /* Table enumeration */
 
-static void int_cb_doall_arg(ENGINE_PILE *pile, ENGINE_PILE_DOALL *dall)
-        {
+static void
+int_cb_doall_arg(ENGINE_PILE *pile, ENGINE_PILE_DOALL *dall)
+{
         dall->cb(pile->nid, pile->sk, pile->funct, dall->arg);
-        }
-static IMPLEMENT_LHASH_DOALL_ARG_FN(int_cb, ENGINE_PILE,ENGINE_PILE_DOALL)
+}
+static IMPLEMENT_LHASH_DOALL_ARG_FN(int_cb, ENGINE_PILE, ENGINE_PILE_DOALL)
 
-void engine_table_doall(ENGINE_TABLE *table, engine_table_doall_cb *cb,
-                                                                void *arg)
-        {
+void
+engine_table_doall(ENGINE_TABLE *table, engine_table_doall_cb *cb, void *arg)
+{
         ENGINE_PILE_DOALL dall;
+
         dall.cb = cb;
         dall.arg = arg;
         lh_ENGINE_PILE_doall_arg(&table->piles, LHASH_DOALL_ARG_FN(int_cb),
-                                 ENGINE_PILE_DOALL, &dall);
-        }
+            ENGINE_PILE_DOALL, &dall);
+}