Compile in gost engine.

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

diff --git a/crypto/engine/eng_lib.c b/crypto/engine/eng_lib.c
index 86f5ec78476b6488b67701f6da4795475f36b3fb..18a66646458a9aa033abfdde32ce936229f75f57 100644 (file)
--- a/crypto/engine/eng_lib.c
+++ b/crypto/engine/eng_lib.c
@@ -56,11 +56,8 @@
  *
  */
 
-#include <openssl/crypto.h>
-#include "cryptlib.h"
 #include "eng_int.h"
-#include <openssl/rand.h> /* FIXME: This shouldn't be needed */
-#include <openssl/engine.h>
+#include <openssl/rand.h>
 
 /* The "new"/"free" stuff first */
 
@@ -81,13 +78,37 @@ ENGINE *ENGINE_new(void)
        return ret;
        }
 
+/* Placed here (close proximity to ENGINE_new) so that modifications to the
+ * elements of the ENGINE structure are more likely to be caught and changed
+ * here. */
+void engine_set_all_null(ENGINE *e)
+       {
+       e->id = NULL;
+       e->name = NULL;
+       e->rsa_meth = NULL;
+       e->dsa_meth = NULL;
+       e->dh_meth = NULL;
+       e->rand_meth = NULL;
+       e->store_meth = NULL;
+       e->ciphers = NULL;
+       e->digests = NULL;
+       e->destroy = NULL;
+       e->init = NULL;
+       e->finish = NULL;
+       e->ctrl = NULL;
+       e->load_privkey = NULL;
+       e->load_pubkey = NULL;
+       e->cmd_defns = NULL;
+       e->flags = 0;
+       }
+
 int engine_free_util(ENGINE *e, int locked)
        {
        int i;
 
        if(e == NULL)
                {
-               ENGINEerr(ENGINE_F_ENGINE_FREE,
+               ENGINEerr(ENGINE_F_ENGINE_FREE_UTIL,
                        ERR_R_PASSED_NULL_PARAMETER);
                return 0;
                }
@@ -104,6 +125,9 @@ int engine_free_util(ENGINE *e, int locked)
                abort();
                }
 #endif
+       /* Free up any dynamically allocated public key methods */
+       engine_pkey_meths_free(e);
+       engine_pkey_asn1_meths_free(e);
        /* Give the ENGINE a chance to do any structural cleanup corresponding
         * to allocation it did in its constructor (eg. unload error strings) */
        if(e->destroy)
@@ -157,19 +181,17 @@ void engine_cleanup_add_last(ENGINE_CLEANUP_CB *cb)
                sk_ENGINE_CLEANUP_ITEM_push(cleanup_stack, item);
        }
 /* The API function that performs all cleanup */
+static void engine_cleanup_cb_free(ENGINE_CLEANUP_ITEM *item)
+       {
+       (*(item->cb))();
+       OPENSSL_free(item);
+       }
 void ENGINE_cleanup(void)
        {
        if(int_cleanup_check(0))
                {
-               int loop = 0, num = sk_ENGINE_CLEANUP_ITEM_num(cleanup_stack);
-               while(loop < num)
-                       {
-                       ENGINE_CLEANUP_ITEM *item = sk_ENGINE_CLEANUP_ITEM_value(
-                                       cleanup_stack, loop++);
-                       (*(item->cb))();
-                       OPENSSL_free(item);
-                       }
-               sk_ENGINE_CLEANUP_ITEM_free(cleanup_stack);
+               sk_ENGINE_CLEANUP_ITEM_pop_free(cleanup_stack,
+                       engine_cleanup_cb_free);
                cleanup_stack = NULL;
                }
        /* FIXME: This should be handled (somehow) through RAND, eg. by it
@@ -298,3 +320,13 @@ const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e)
        {
        return e->cmd_defns;
        }
+
+/* eng_lib.o is pretty much linked into anything that touches ENGINE already, so
+ * put the "static_state" hack here. */
+
+static int internal_static_hack = 0;
+
+void *ENGINE_get_static_state(void)
+       {
+       return &internal_static_hack;
+       }