Include correctly.

[openssl.git] / crypto / engine / eng_table.c

diff --git a/crypto/engine/eng_table.c b/crypto/engine/eng_table.c
index 1f0fff6180aa0fe4d42435b7c8234260f81162e2..4fde9481852c0e47c7d2062182b72207db01cc21 100644 (file)
--- a/crypto/engine/eng_table.c
+++ b/crypto/engine/eng_table.c
@@ -70,10 +70,12 @@ typedef struct st_engine_pile
        int uptodate;
        } ENGINE_PILE;
 
+DECLARE_LHASH_OF(ENGINE_PILE);
+
 /* The type exposed in eng_int.h */
 struct st_engine_table
        {
-       LHASH piles;
+       LHASH_OF(ENGINE_PILE) piles;
        }; /* ENGINE_TABLE */
 
 
@@ -92,6 +94,7 @@ unsigned int ENGINE_get_table_flags(void)
        {
        return table_flags;
        }
+
 void ENGINE_set_table_flags(unsigned int flags)
        {
        table_flags = flags;
@@ -102,19 +105,21 @@ 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)
        {
        return a->nid - b->nid;
        }
-static IMPLEMENT_LHASH_HASH_FN(engine_pile_hash, const ENGINE_PILE *)
-static IMPLEMENT_LHASH_COMP_FN(engine_pile_cmp, const ENGINE_PILE *)
+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)
        {
-       LHASH *lh;
+       LHASH_OF(ENGINE_PILE) *lh;
+
        if(*t) return 1;
        if(!create) return 0;
-       if((lh = lh_new(LHASH_HASH_FN(engine_pile_hash),
-                       LHASH_COMP_FN(engine_pile_cmp))) == NULL)
+       if((lh = lh_ENGINE_PILE_new()) == NULL)
                return 0;
        *t = (ENGINE_TABLE *)lh;
        return 1;
@@ -138,7 +143,7 @@ int engine_table_register(ENGINE_TABLE **table, ENGINE_CLEANUP_CB *cleanup,
        while(num_nids--)
                {
                tmplate.nid = *nids;
-               fnd = lh_retrieve(&(*table)->piles, &tmplate);
+               fnd = lh_ENGINE_PILE_retrieve(&(*table)->piles, &tmplate);
                if(!fnd)
                        {
                        fnd = OPENSSL_malloc(sizeof(ENGINE_PILE));
@@ -152,7 +157,7 @@ int engine_table_register(ENGINE_TABLE **table, ENGINE_CLEANUP_CB *cleanup,
                                goto end;
                                }
                        fnd->funct = NULL;
-                       lh_insert(&(*table)->piles, fnd);
+                       (void)lh_ENGINE_PILE_insert(&(*table)->piles, fnd);
                        }
                /* A registration shouldn't add duplciate entries */
                (void)sk_ENGINE_delete_ptr(fnd->sk, e);
@@ -181,7 +186,7 @@ end:
        CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
        return ret;
        }
-static void int_unregister_cb(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' */
@@ -196,31 +201,35 @@ static void int_unregister_cb(ENGINE_PILE *pile, ENGINE *e)
                pile->funct = NULL;
                }
        }
-static IMPLEMENT_LHASH_DOALL_ARG_FN(int_unregister_cb,ENGINE_PILE *,ENGINE *)
+static IMPLEMENT_LHASH_DOALL_ARG_FN(int_unregister_cb, ENGINE_PILE, ENGINE)
+
 void engine_table_unregister(ENGINE_TABLE **table, ENGINE *e)
        {
        CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
        if(int_table_check(table, 0))
-               lh_doall_arg(&(*table)->piles,
-                       LHASH_DOALL_ARG_FN(int_unregister_cb), e);
+               lh_ENGINE_PILE_doall_arg(&(*table)->piles,
+                                        LHASH_DOALL_ARG_FN(int_unregister_cb),
+                                        ENGINE, e);
        CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
        }
 
-static void int_cleanup_cb(ENGINE_PILE *p)
+static void int_cleanup_cb_doall(ENGINE_PILE *p)
        {
        sk_ENGINE_free(p->sk);
        if(p->funct)
                engine_unlocked_finish(p->funct, 0);
        OPENSSL_free(p);
        }
-static IMPLEMENT_LHASH_DOALL_FN(int_cleanup_cb,ENGINE_PILE *)
+static IMPLEMENT_LHASH_DOALL_FN(int_cleanup_cb, ENGINE_PILE)
+
 void engine_table_cleanup(ENGINE_TABLE **table)
        {
        CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
        if(*table)
                {
-               lh_doall(&(*table)->piles, LHASH_DOALL_FN(int_cleanup_cb));
-               lh_free(&(*table)->piles);
+               lh_ENGINE_PILE_doall(&(*table)->piles,
+                                    LHASH_DOALL_FN(int_cleanup_cb));
+               lh_ENGINE_PILE_free(&(*table)->piles);
                *table = NULL;
                }
        CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
@@ -245,12 +254,13 @@ ENGINE *engine_table_select_tmp(ENGINE_TABLE **table, int nid, const char *f, in
 #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;
        tmplate.nid = nid;
-       fnd = lh_retrieve(&(*table)->piles, &tmplate);
+       fnd = lh_ENGINE_PILE_retrieve(&(*table)->piles, &tmplate);
        if(!fnd) goto end;
        if(fnd->funct && engine_unlocked_init(fnd->funct))
                {
@@ -318,24 +328,24 @@ end:
        CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
        /* Whatever happened, any failed init()s are not failures in this
         * context, so clear our error state. */
-       ERR_clear_error();
+       ERR_pop_to_mark();
        return ret;
        }
 
 /* Table enumeration */
 
-static void int_doall_cb(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_doall_cb,ENGINE_PILE *,ENGINE_PILE_DOALL *)
 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_doall_arg(&table->piles,
-                       LHASH_DOALL_ARG_FN(int_doall_cb), &dall);
+       lh_ENGINE_PILE_doall_arg(&table->piles, LHASH_DOALL_ARG_FN(int_cb),
+                                ENGINE_PILE_DOALL, &dall);
        }