Move engine library over to using the new thread API

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

diff --git a/crypto/engine/eng_dyn.c b/crypto/engine/eng_dyn.c
index 777f44018b0b84a3a05fbbc79f2170b2af3f2325..bdfc00cce610639fea766b8762c028d9b8debcef 100644 (file)
--- a/crypto/engine/eng_dyn.c
+++ b/crypto/engine/eng_dyn.c
@@ -1,4 +1,3 @@
-/* crypto/engine/eng_dyn.c */

 /*
  * Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL project
  * 2001.
 /*
  * Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL project
  * 2001.


@@ -59,6 +58,7 @@
 
 #include "eng_int.h"
 #include <openssl/dso.h>
 
 #include "eng_int.h"
 #include <openssl/dso.h>

+#include <openssl/crypto.h>

 
 /*
  * Shared libraries implementing ENGINEs for use by the "dynamic" ENGINE
 
 /*
  * Shared libraries implementing ENGINEs for use by the "dynamic" ENGINE


@@ -204,27 +204,20 @@ static int dynamic_set_data_ctx(ENGINE *e, dynamic_data_ctx **ctx)
 {
     dynamic_data_ctx *c = OPENSSL_zalloc(sizeof(*c));
 
 {
     dynamic_data_ctx *c = OPENSSL_zalloc(sizeof(*c));
 

-    if (!c) {
+    if (c == NULL) {

         ENGINEerr(ENGINE_F_DYNAMIC_SET_DATA_CTX, ERR_R_MALLOC_FAILURE);
         return 0;
     }
         ENGINEerr(ENGINE_F_DYNAMIC_SET_DATA_CTX, ERR_R_MALLOC_FAILURE);
         return 0;
     }

-    c->dynamic_dso = NULL;
-    c->v_check = NULL;
-    c->bind_engine = NULL;
-    c->DYNAMIC_LIBNAME = NULL;
-    c->no_vcheck = 0;
-    c->engine_id = NULL;
-    c->list_add_value = 0;
-    c->DYNAMIC_F1 = "v_check";
-    c->DYNAMIC_F2 = "bind_engine";
-    c->dir_load = 1;

     c->dirs = sk_OPENSSL_STRING_new_null();
     c->dirs = sk_OPENSSL_STRING_new_null();

-    if (!c->dirs) {
+    if (c->dirs == NULL) {

         ENGINEerr(ENGINE_F_DYNAMIC_SET_DATA_CTX, ERR_R_MALLOC_FAILURE);
         OPENSSL_free(c);
         return 0;
     }
         ENGINEerr(ENGINE_F_DYNAMIC_SET_DATA_CTX, ERR_R_MALLOC_FAILURE);
         OPENSSL_free(c);
         return 0;
     }

-    CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
+    c->DYNAMIC_F1 = "v_check";
+    c->DYNAMIC_F2 = "bind_engine";
+    c->dir_load = 1;
+    CRYPTO_THREAD_write_lock(global_engine_lock);

     if ((*ctx = (dynamic_data_ctx *)ENGINE_get_ex_data(e,
                                                        dynamic_ex_data_idx))
         == NULL) {
     if ((*ctx = (dynamic_data_ctx *)ENGINE_get_ex_data(e,
                                                        dynamic_ex_data_idx))
         == NULL) {


@@ -233,11 +226,13 @@ static int dynamic_set_data_ctx(ENGINE *e, dynamic_data_ctx **ctx)
         *ctx = c;
         c = NULL;
     }
         *ctx = c;
         c = NULL;
     }

-    CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
+    CRYPTO_THREAD_unlock(global_engine_lock);

     /*
      * If we lost the race to set the context, c is non-NULL and *ctx is the
      * context of the thread that won.
      */
     /*
      * If we lost the race to set the context, c is non-NULL and *ctx is the
      * context of the thread that won.
      */

+    if (c)
+        sk_OPENSSL_STRING_free(c->dirs);

     OPENSSL_free(c);
     return 1;
 }
     OPENSSL_free(c);
     return 1;
 }


@@ -261,14 +256,14 @@ static dynamic_data_ctx *dynamic_get_data_ctx(ENGINE *e)
             ENGINEerr(ENGINE_F_DYNAMIC_GET_DATA_CTX, ENGINE_R_NO_INDEX);
             return NULL;
         }
             ENGINEerr(ENGINE_F_DYNAMIC_GET_DATA_CTX, ENGINE_R_NO_INDEX);
             return NULL;
         }

-        CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
+        CRYPTO_THREAD_write_lock(global_engine_lock);

         /* Avoid a race by checking again inside this lock */
         if (dynamic_ex_data_idx < 0) {
             /* Good, someone didn't beat us to it */
             dynamic_ex_data_idx = new_idx;
             new_idx = -1;
         }
         /* Avoid a race by checking again inside this lock */
         if (dynamic_ex_data_idx < 0) {
             /* Good, someone didn't beat us to it */
             dynamic_ex_data_idx = new_idx;
             new_idx = -1;
         }

-        CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
+        CRYPTO_THREAD_unlock(global_engine_lock);

         /*
          * In theory we could "give back" the index here if (new_idx>-1), but
          * it's not possible and wouldn't gain us much if it were.
         /*
          * In theory we could "give back" the index here if (new_idx>-1), but
          * it's not possible and wouldn't gain us much if it were.


@@ -285,7 +280,7 @@ static dynamic_data_ctx *dynamic_get_data_ctx(ENGINE *e)
 static ENGINE *engine_dynamic(void)
 {
     ENGINE *ret = ENGINE_new();
 static ENGINE *engine_dynamic(void)
 {
     ENGINE *ret = ENGINE_new();

-    if (!ret)
+    if (ret == NULL)

         return NULL;
     if (!ENGINE_set_id(ret, engine_dynamic_id) ||
         !ENGINE_set_name(ret, engine_dynamic_name) ||
         return NULL;
     if (!ENGINE_set_id(ret, engine_dynamic_id) ||
         !ENGINE_set_name(ret, engine_dynamic_name) ||


@@ -300,7 +295,7 @@ static ENGINE *engine_dynamic(void)
     return ret;
 }
 
     return ret;
 }
 

-void ENGINE_load_dynamic(void)
+void engine_load_dynamic_internal(void)

 {
     ENGINE *toadd = engine_dynamic();
     if (!toadd)
 {
     ENGINE *toadd = engine_dynamic();
     if (!toadd)


@@ -322,7 +317,7 @@ void ENGINE_load_dynamic(void)
 static int dynamic_init(ENGINE *e)
 {
     /*
 static int dynamic_init(ENGINE *e)
 {
     /*

-     * We always return failure - the "dyanamic" engine itself can't be used
+     * We always return failure - the "dynamic" engine itself can't be used

      * for anything.
      */
     return 0;
      * for anything.
      */
     return 0;


@@ -359,7 +354,7 @@ static int dynamic_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void))
             p = NULL;
         OPENSSL_free(ctx->DYNAMIC_LIBNAME);
         if (p)
             p = NULL;
         OPENSSL_free(ctx->DYNAMIC_LIBNAME);
         if (p)

-            ctx->DYNAMIC_LIBNAME = BUF_strdup(p);
+            ctx->DYNAMIC_LIBNAME = OPENSSL_strdup(p);

         else
             ctx->DYNAMIC_LIBNAME = NULL;
         return (ctx->DYNAMIC_LIBNAME ? 1 : 0);
         else
             ctx->DYNAMIC_LIBNAME = NULL;
         return (ctx->DYNAMIC_LIBNAME ? 1 : 0);


@@ -372,7 +367,7 @@ static int dynamic_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void))
             p = NULL;
         OPENSSL_free(ctx->engine_id);
         if (p)
             p = NULL;
         OPENSSL_free(ctx->engine_id);
         if (p)

-            ctx->engine_id = BUF_strdup(p);
+            ctx->engine_id = OPENSSL_strdup(p);

         else
             ctx->engine_id = NULL;
         return (ctx->engine_id ? 1 : 0);
         else
             ctx->engine_id = NULL;
         return (ctx->engine_id ? 1 : 0);


@@ -399,7 +394,7 @@ static int dynamic_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void))
             return 0;
         }
         {
             return 0;
         }
         {

-            char *tmp_str = BUF_strdup(p);
+            char *tmp_str = OPENSSL_strdup(p);

             if (!tmp_str) {
                 ENGINEerr(ENGINE_F_DYNAMIC_CTRL, ERR_R_MALLOC_FAILURE);
                 return 0;
             if (!tmp_str) {
                 ENGINEerr(ENGINE_F_DYNAMIC_CTRL, ERR_R_MALLOC_FAILURE);
                 return 0;


@@ -445,11 +440,15 @@ static int dynamic_load(ENGINE *e, dynamic_data_ctx *ctx)
     ENGINE cpy;
     dynamic_fns fns;
 
     ENGINE cpy;
     dynamic_fns fns;
 

-    if (!ctx->dynamic_dso)
+    if (ctx->dynamic_dso == NULL)

         ctx->dynamic_dso = DSO_new();
         ctx->dynamic_dso = DSO_new();

+    if (ctx->dynamic_dso == NULL)
+        return 0;

     if (!ctx->DYNAMIC_LIBNAME) {
         if (!ctx->engine_id)
             return 0;
     if (!ctx->DYNAMIC_LIBNAME) {
         if (!ctx->engine_id)
             return 0;

+        DSO_ctrl(ctx->dynamic_dso, DSO_CTRL_SET_FLAGS,
+                 DSO_FLAG_NAME_TRANSLATION_EXT_ONLY, NULL);

         ctx->DYNAMIC_LIBNAME =
             DSO_convert_filename(ctx->dynamic_dso, ctx->engine_id);
     }
         ctx->DYNAMIC_LIBNAME =
             DSO_convert_filename(ctx->dynamic_dso, ctx->engine_id);
     }


@@ -511,13 +510,8 @@ static int dynamic_load(ENGINE *e, dynamic_data_ctx *ctx)
      * would also increase opaqueness.
      */
     fns.static_state = ENGINE_get_static_state();
      * would also increase opaqueness.
      */
     fns.static_state = ENGINE_get_static_state();

-    CRYPTO_get_mem_functions(&fns.mem_fns.malloc_cb,
-                             &fns.mem_fns.realloc_cb, &fns.mem_fns.free_cb);
-    fns.lock_fns.lock_locking_cb = CRYPTO_get_locking_callback();
-    fns.lock_fns.lock_add_lock_cb = CRYPTO_get_add_lock_callback();
-    fns.lock_fns.dynlock_create_cb = CRYPTO_get_dynlock_create_callback();
-    fns.lock_fns.dynlock_lock_cb = CRYPTO_get_dynlock_lock_callback();
-    fns.lock_fns.dynlock_destroy_cb = CRYPTO_get_dynlock_destroy_callback();
+    CRYPTO_get_mem_functions(&fns.mem_fns.malloc_fn, &fns.mem_fns.realloc_fn,
+                             &fns.mem_fns.free_fn);

     /*
      * Now that we've loaded the dynamic engine, make sure no "dynamic"
      * ENGINE elements will show through.
     /*
      * Now that we've loaded the dynamic engine, make sure no "dynamic"
      * ENGINE elements will show through.