First step in fixing "ex_data" support. Warning: big commit log ...
authorGeoff Thorpe <geoff@openssl.org>
Sat, 1 Sep 2001 19:56:46 +0000 (19:56 +0000)
committerGeoff Thorpe <geoff@openssl.org>
Sat, 1 Sep 2001 19:56:46 +0000 (19:56 +0000)
Currently, this change merely addresses where ex_data indexes are stored
and managed, and thus fixes the thread-safety issues that existed at that
level. "Class" code (eg. RSA, DSA, etc) no longer store their own STACKS
and per-class index counters - all such data is stored inside ex_data.c. So
rather than passing both STACK+counter to index-management ex_data
functions, a 'class_index' is instead passed to indicate the class (eg.
CRYPTO_EX_INDEX_RSA). New classes can be dynamically registered on-the-fly
and this is also thread-safe inside ex_data.c (though whether the caller
manages the return value in a thread-safe way is not addressed).

This does not change the "get/set" functions on individual "ex_data"
structures, and so thread-safety at that level isn't (yet) assured.
Likewise, the method of getting and storing per-class indexes has not
changed, so locking may still be required at the "caller" end but is
nonetheless thread-safe inside "ex_data"'s internal implementation.
Typically this occurs when code implements a new method of some kind and
stores its own per-class index in a global variable without locking the
setting and usage of that variable. If the code in question is likely to be
used in multiple threads, locking the setting and use of that index is
still up to the code in question. Possible fixes to this are being
sketched, but definitely require more major changes to the API itself than
this change undertakes.

The underlying implementation in ex_data.c has also been modularised so
that alternative "ex_data" implementations (that control all access to
state) can be plugged in. Eg. a loaded module can have its implementation
set to that of the application loaded it - the result being that
thread-safety and consistency of "ex_data" classes and indexes can be
maintained in the same place rather than the loaded module using its own
copy of ex_data support code and state.

Due to the centralisation of "state" with this change, cleanup of all
"ex_data" state can now be performed properly. Previously all allocation of
ex_data state was guaranteed to leak - and MemCheck_off() had been used to
avoid it flagging up the memory debugging. A new function has been added to
perfrom all this cleanup, CRYPTO_cleanup_all_ex_data(). The "openssl"
command(s) have been changed to use this cleanup, as have the relevant test
programs. External application code may want to do so too - failure to
cleanup will not induce more memory leaking than was the case before, but
the memory debugging is not tricked into hiding it any more so it may
"appear" where it previously did not.

crypto/cpt_err.c
crypto/cryptlib.c
crypto/crypto.h
crypto/ex_data.c

index e10cea1..1b4a1cb 100644 (file)
@@ -70,6 +70,11 @@ static ERR_STRING_DATA CRYPTO_str_functs[]=
 {ERR_PACK(0,CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,0),      "CRYPTO_get_new_dynlockid"},
 {ERR_PACK(0,CRYPTO_F_CRYPTO_GET_NEW_LOCKID,0), "CRYPTO_get_new_lockid"},
 {ERR_PACK(0,CRYPTO_F_CRYPTO_SET_EX_DATA,0),    "CRYPTO_set_ex_data"},
+{ERR_PACK(0,CRYPTO_F_DEF_ADD_INDEX,0), "DEF_ADD_INDEX"},
+{ERR_PACK(0,CRYPTO_F_DEF_GET_CLASS,0), "DEF_GET_CLASS"},
+{ERR_PACK(0,CRYPTO_F_INT_DUP_EX_DATA,0),       "INT_DUP_EX_DATA"},
+{ERR_PACK(0,CRYPTO_F_INT_FREE_EX_DATA,0),      "INT_FREE_EX_DATA"},
+{ERR_PACK(0,CRYPTO_F_INT_NEW_EX_DATA,0),       "INT_NEW_EX_DATA"},
 {0,NULL}
        };
 
index be83f56..6a2e546 100644 (file)
@@ -103,7 +103,8 @@ static const char* lock_names[CRYPTO_NUM_LOCKS] =
        "dynlock",
        "engine",
        "ui",
-#if CRYPTO_NUM_LOCKS != 31
+       "ex_data",
+#if CRYPTO_NUM_LOCKS != 32
 # error "Inconsistency between crypto.h and cryptlib.c"
 #endif
        };
index 53b8523..b708a07 100644 (file)
@@ -126,7 +126,8 @@ extern "C" {
 #define        CRYPTO_LOCK_DYNLOCK             28
 #define        CRYPTO_LOCK_ENGINE              29
 #define        CRYPTO_LOCK_UI                  30
-#define        CRYPTO_NUM_LOCKS                31
+#define        CRYPTO_LOCK_EX_DATA             31
+#define        CRYPTO_NUM_LOCKS                32
 
 #define CRYPTO_LOCK            1
 #define CRYPTO_UNLOCK          2
@@ -227,6 +228,16 @@ DECLARE_STACK_OF(CRYPTO_EX_DATA_FUNCS)
 #define CRYPTO_EX_INDEX_SSL_SESSION    3
 #define CRYPTO_EX_INDEX_X509_STORE     4
 #define CRYPTO_EX_INDEX_X509_STORE_CTX 5
+#define CRYPTO_EX_INDEX_RSA            6
+#define CRYPTO_EX_INDEX_DSA            7
+#define CRYPTO_EX_INDEX_DH             8
+#define CRYPTO_EX_INDEX_ENGINE         9
+#define CRYPTO_EX_INDEX_X509           10
+#define CRYPTO_EX_INDEX_UI             11
+
+/* Dynamically assigned indexes start from this value (don't use directly, use
+ * via CRYPTO_ex_data_new_class). */
+#define CRYPTO_EX_INDEX_USER           100
 
 
 /* This is the default callbacks, but we can have others as well:
@@ -283,14 +294,31 @@ unsigned long SSLeay(void);
 
 int OPENSSL_issetugid(void);
 
-int CRYPTO_get_ex_new_index(int idx, STACK_OF(CRYPTO_EX_DATA_FUNCS) **skp, long argl, void *argp,
-            CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
+/* An opaque type representing an implementation of "ex_data" support */
+typedef struct st_CRYPTO_EX_DATA_IMPL  CRYPTO_EX_DATA_IMPL;
+/* Return an opaque pointer to the current "ex_data" implementation */
+const CRYPTO_EX_DATA_IMPL *CRYPTO_get_ex_data_implementation(void);
+/* Sets the "ex_data" implementation to be used (if it's not too late) */
+int CRYPTO_set_ex_data_implementation(const CRYPTO_EX_DATA_IMPL *i);
+/* Get a new "ex_data" class, and return the corresponding "class_index" */
+int CRYPTO_ex_data_new_class(void);
+/* Within a given 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);
+/* Initialise/duplicate/free CRYPTO_EX_DATA variables corresponding to a given
+ * class (invokes whatever per-class callbacks are applicable) */
+int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
+int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to,
+               CRYPTO_EX_DATA *from);
+void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
+/* Get/set data in a CRYPTO_EX_DATA variable corresponding to a particular index
+ * (relative to the class type involved) */
 int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val);
 void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad,int idx);
-int CRYPTO_dup_ex_data(STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth, CRYPTO_EX_DATA *to,
-            CRYPTO_EX_DATA *from);
-void CRYPTO_free_ex_data(STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth, void *obj, CRYPTO_EX_DATA *ad);
-void CRYPTO_new_ex_data(STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth, void *obj, CRYPTO_EX_DATA *ad);
+/* This function cleans up all "ex_data" state. It mustn't be called under
+ * potential race-conditions. */
+void CRYPTO_cleanup_all_ex_data(void);
 
 int CRYPTO_get_new_lockid(char *name);
 
@@ -398,6 +426,7 @@ void ERR_load_CRYPTO_strings(void);
 /* The following lines are auto generated by the script mkerr.pl. Any changes
  * made after this point may be overwritten when the script is next run.
  */
+void ERR_load_CRYPTO_strings(void);
 
 /* Error codes for the CRYPTO functions. */
 
@@ -406,6 +435,11 @@ void ERR_load_CRYPTO_strings(void);
 #define CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID               103
 #define CRYPTO_F_CRYPTO_GET_NEW_LOCKID                  101
 #define CRYPTO_F_CRYPTO_SET_EX_DATA                     102
+#define CRYPTO_F_DEF_ADD_INDEX                          104
+#define CRYPTO_F_DEF_GET_CLASS                          105
+#define CRYPTO_F_INT_DUP_EX_DATA                        106
+#define CRYPTO_F_INT_FREE_EX_DATA                       107
+#define CRYPTO_F_INT_NEW_EX_DATA                        108
 
 /* Reason codes. */
 #define CRYPTO_R_NO_DYNLOCK_CREATE_CALLBACK             100
@@ -414,4 +448,3 @@ void ERR_load_CRYPTO_strings(void);
 }
 #endif
 #endif
-
index ff32ad5..af8ee70 100644 (file)
@@ -1,17 +1,31 @@
 /* crypto/ex_data.c */
 
 /*
- * This is not thread-safe, nor can it be changed to become thread-safe
- * without changing various function prototypes and using a lot of locking.
- * Luckily, it's not really used anywhere except in ssl_verify_cert_chain
- * via SSL_get_ex_data_X509_STORE_CTX_idx (ssl/ssl_cert.c),
- * where new_func, dup_func, and free_func all are 0, and in
- * hwcrhk_init (crypto/engine/hw_ncipher.c), which is hopefully only
- * ever used during program initialization.
+ * Overhaul notes;
  *
- * Any multi-threaded application crazy enough to use ex_data for its own
- * purposes had better make sure that SSL_get_ex_data_X509_STORE_CTX_idx
- * is called once before multiple threads are created.
+ * This code is now *mostly* thread-safe. It is now easier to understand in what
+ * ways it is safe and in what ways it is not, which is an improvement. Firstly,
+ * all per-class stacks and index-counters for ex_data are stored in the same
+ * global LHASH table (keyed by class). This hash table uses locking for all
+ * access with the exception of CRYPTO_cleanup_all_ex_data(), which must only be
+ * called when no other threads can possibly race against it (even if it was
+ * locked, the race would mean it's possible the hash table might have been
+ * recreated after the cleanup). As classes can only be added to the hash table,
+ * and within each class, the stack of methods can only be incremented, the
+ * locking mechanics are simpler than they would otherwise be. For example, the
+ * new/dup/free ex_data functions will lock the hash table, copy the method
+ * pointers it needs from the relevant class, then unlock the hash table before
+ * actually applying those method pointers to the task of the new/dup/free
+ * operations. As they can't be removed from the method-stack, only
+ * supplemented, there's no race conditions associated with using them outside
+ * the lock. The get/set_ex_data functions are not locked because they do not
+ * involve this global state at all - they operate directly with a previously
+ * obtained per-class method index and a particular "ex_data" variable. These
+ * variables are usually instantiated per-context (eg. each RSA structure has
+ * one) so locking on read/write access to that variable can be locked locally
+ * if required (eg. using the "RSA" lock to synchronise access to a
+ * per-RSA-structure ex_data variable if required).
+ * [Geoff]
  */
 
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 #include <openssl/lhash.h>
 #include "cryptlib.h"
 
-int CRYPTO_get_ex_new_index(int idx, STACK_OF(CRYPTO_EX_DATA_FUNCS) **skp, long argl, void *argp,
-            CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
+/* What an "implementation of ex_data functionality" looks like */
+struct st_CRYPTO_EX_DATA_IMPL
        {
-       int ret= -1;
-       CRYPTO_EX_DATA_FUNCS *a;
+       /*********************/
+       /* GLOBAL OPERATIONS */
+       /* Return a new class index */
+       int (*cb_new_class)(void);
+       /* Cleanup all state used by the implementation */
+       void (*cb_cleanup)(void);
+       /************************/
+       /* 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);
+       /* Initialise a new CRYPTO_EX_DATA of a given class */
+       int (*cb_new_ex_data)(int class_index, void *obj,
+                       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);
+       /* Cleanup a CRYPTO_EX_DATA of a given class */
+       void (*cb_free_ex_data)(int class_index, void *obj,
+                       CRYPTO_EX_DATA *ad);
+       };
 
-       MemCheck_off();
-       if (*skp == NULL)
-               *skp=sk_CRYPTO_EX_DATA_FUNCS_new_null();
-       if (*skp == NULL)
+/* 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)(...); */
+#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);
+static int int_new_ex_data(int class_index, void *obj,
+               CRYPTO_EX_DATA *ad);
+static int int_dup_ex_data(int class_index, CRYPTO_EX_DATA *to,
+               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 =
+       {
+       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)
+       {
+       CRYPTO_w_lock(CRYPTO_LOCK_EX_DATA);
+       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)
+       {
+       IMPL_CHECK
+       return impl;
+       }
+int CRYPTO_set_ex_data_implementation(const CRYPTO_EX_DATA_IMPL *i)
+       {
+       int toret = 0;
+       CRYPTO_w_lock(CRYPTO_LOCK_EX_DATA);
+       if(!impl)
                {
-               CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX,ERR_R_MALLOC_FAILURE);
-               goto err;
+               impl = i;
+               toret = 1;
                }
-       a=(CRYPTO_EX_DATA_FUNCS *)OPENSSL_malloc(sizeof(CRYPTO_EX_DATA_FUNCS));
-       if (a == NULL)
+       CRYPTO_w_unlock(CRYPTO_LOCK_EX_DATA);
+       return toret;
+       }
+
+/****************************************************************************/
+/* Interal (default) implementation of "ex_data" support. API functions are
+ * further down. */
+
+/* The type that represents what each "class" used to implement locally. A STACK
+ * of CRYPTO_EX_DATA_FUNCS plus a index-counter. The 'class_index' is the global
+ * value representing the class that is used to distinguish these items. */
+typedef struct st_ex_class_item {
+       int class_index;
+       STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth;
+       int meth_num;
+} EX_CLASS_ITEM;
+
+/* When assigning new class indexes, this is our counter */
+static int ex_class = CRYPTO_EX_INDEX_USER;
+
+/* The global hash table of EX_CLASS_ITEM items */
+static LHASH *ex_data = NULL;
+
+/* The callbacks required in the "ex_data" hash table */
+static unsigned long ex_hash_cb(const void *a_void)
+       {
+       return ((const EX_CLASS_ITEM *)a_void)->class_index;
+       }
+static int ex_cmp_cb(const void *a_void, const void *b_void)
+       {
+       return (((const EX_CLASS_ITEM *)a_void)->class_index -
+               ((const EX_CLASS_ITEM *)b_void)->class_index);
+       }
+
+/* Internal functions used by the "impl_default" implementation to access the
+ * state */
+
+static int ex_data_check(void)
+       {
+       int toret = 1;
+       CRYPTO_w_lock(CRYPTO_LOCK_EX_DATA);
+       if(!ex_data && ((ex_data = lh_new(ex_hash_cb, ex_cmp_cb)) == 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(void *a_void)
+       {
+       CRYPTO_EX_DATA_FUNCS *v = (CRYPTO_EX_DATA_FUNCS *)a_void;
+       OPENSSL_free(v);
+       }
+
+/* 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(const 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)
+       {
+       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_retrieve(ex_data, &d);
+       if(!p)
                {
-               CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX,ERR_R_MALLOC_FAILURE);
-               goto err;
+               gen = OPENSSL_malloc(sizeof(EX_CLASS_ITEM));
+               if(gen)
+                       {
+                       gen->class_index = class_index;
+                       gen->meth_num = 0;
+                       gen->meth = sk_CRYPTO_EX_DATA_FUNCS_new_null();
+                       if(!gen->meth)
+                               OPENSSL_free(gen);
+                       else
+                               {
+                               /* Because we're inside the ex_data lock, the
+                                * return value from the insert will be NULL */
+                               lh_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);
+       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)
+       {
+       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);
+               return -1;
                }
        a->argl=argl;
        a->argp=argp;
        a->new_func=new_func;
        a->dup_func=dup_func;
        a->free_func=free_func;
-       while (sk_CRYPTO_EX_DATA_FUNCS_num(*skp) <= idx)
+       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(*skp,NULL))
+               if (!sk_CRYPTO_EX_DATA_FUNCS_push(item->meth, NULL))
                        {
-                       CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX,ERR_R_MALLOC_FAILURE);
+                       CRYPTOerr(CRYPTO_F_DEF_ADD_INDEX,ERR_R_MALLOC_FAILURE);
                        OPENSSL_free(a);
                        goto err;
                        }
                }
-       sk_CRYPTO_EX_DATA_FUNCS_set(*skp,idx, a);
-       ret=idx;
+       toret = item->meth_num++;
+       sk_CRYPTO_EX_DATA_FUNCS_set(item->meth, toret, a);
 err:
-       MemCheck_on();
-       return(ret);
+       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)
+       {
+       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)
+       {
+       EX_DATA_CHECK(return;)
+       lh_doall(ex_data, def_cleanup_cb);
+       lh_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)
+       {
+       EX_CLASS_ITEM *item = def_get_class(class_index);
+       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 max,i;
+       void *ptr;
+       CRYPTO_EX_DATA_FUNCS **storage = NULL;
+       EX_CLASS_ITEM *item = def_get_class(class_index);
+       if(!item)
+               /* error is already set */
+               return 0;
+       ad->sk = NULL;
+       CRYPTO_r_lock(CRYPTO_LOCK_EX_DATA);
+       max = sk_CRYPTO_EX_DATA_FUNCS_num(item->meth);
+       if(max > 0)
+               {
+               storage = OPENSSL_malloc(max * sizeof(CRYPTO_EX_DATA_FUNCS*));
+               if(!storage)
+                       goto skip;
+               for(i = 0; i < max; i++)
+                       storage[i] = sk_CRYPTO_EX_DATA_FUNCS_value(item->meth,i);
+               }
+skip:
+       CRYPTO_r_unlock(CRYPTO_LOCK_EX_DATA);
+       if((max > 0) && !storage)
+               {
+               CRYPTOerr(CRYPTO_F_INT_NEW_EX_DATA,ERR_R_MALLOC_FAILURE);
+               return 0;
+               }
+       for(i = 0; i < max; 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);
+                       }
+               }
+       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)
+       {
+       int max, j, i;
+       char *ptr;
+       CRYPTO_EX_DATA_FUNCS **storage = NULL;
+       EX_CLASS_ITEM *item;
+       if(!from->sk)
+               /* 'to' should be "blank" which *is* just like 'from' */
+               return 1;
+       if((item = def_get_class(class_index)) == NULL)
+               return 0;
+       CRYPTO_r_lock(CRYPTO_LOCK_EX_DATA);
+       max = sk_CRYPTO_EX_DATA_FUNCS_num(item->meth);
+       j = sk_num(from->sk);
+       if(j < max)
+               max = j;
+       if(max > 0)
+               {
+               storage = OPENSSL_malloc(max * sizeof(CRYPTO_EX_DATA_FUNCS*));
+               if(!storage)
+                       goto skip;
+               for(i = 0; i < max; i++)
+                       storage[i] = sk_CRYPTO_EX_DATA_FUNCS_value(item->meth,i);
+               }
+skip:
+       CRYPTO_r_unlock(CRYPTO_LOCK_EX_DATA);
+       if((max > 0) && !storage)
+               {
+               CRYPTOerr(CRYPTO_F_INT_DUP_EX_DATA,ERR_R_MALLOC_FAILURE);
+               return 0;
+               }
+       for(i = 0; i < max; 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)
+               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 max,i;
+       EX_CLASS_ITEM *item;
+       void *ptr;
+       CRYPTO_EX_DATA_FUNCS **storage = NULL;
+       if((item = def_get_class(class_index)) == NULL)
+               return;
+       CRYPTO_r_lock(CRYPTO_LOCK_EX_DATA);
+       max = sk_CRYPTO_EX_DATA_FUNCS_num(item->meth);
+       if(max > 0)
+               {
+               storage = OPENSSL_malloc(max * sizeof(CRYPTO_EX_DATA_FUNCS*));
+               if(!storage)
+                       goto skip;
+               for(i = 0; i < max; i++)
+                       storage[i] = sk_CRYPTO_EX_DATA_FUNCS_value(item->meth,i);
+               }
+skip:
+       CRYPTO_r_unlock(CRYPTO_LOCK_EX_DATA);
+       if((max > 0) && !storage)
+               {
+               CRYPTOerr(CRYPTO_F_INT_FREE_EX_DATA,ERR_R_MALLOC_FAILURE);
+               return;
+               }
+       for(i = 0; i < max; 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)
+               OPENSSL_free(storage);
+       if(ad->sk)
+               {
+               sk_free(ad->sk);
+               ad->sk=NULL;
+               }
+       }
+
+/********************************************************************/
+/* API functions that defer all "state" operations to the "ex_data"
+ * implementation we have set. */
+
+/* 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)
+       {
+       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)
+       {
+       IMPL_CHECK
+       return 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 ret = -1;
+
+       IMPL_CHECK
+       ret = EX_IMPL(get_new_index)(class_index,
+                       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)
+       {
+       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)
+       {
+       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)
+       {
+       IMPL_CHECK
+       return 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 i;
@@ -146,6 +569,8 @@ int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *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)
        {
        if (ad->sk == NULL)
@@ -156,83 +581,4 @@ void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx)
                return(sk_value(ad->sk,idx));
        }
 
-/* The callback is called with the 'object', which is the original data object
- * being duplicated, a pointer to the
- * 'new' object to be inserted, the index, and the argi/argp
- */
-int CRYPTO_dup_ex_data(STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth, CRYPTO_EX_DATA *to,
-            CRYPTO_EX_DATA *from)
-       {
-       int i,j,m,r;
-       CRYPTO_EX_DATA_FUNCS *mm;
-       char *from_d;
-
-       if (meth == NULL) return(1);
-       if (from->sk == NULL) return(1);
-       m=sk_CRYPTO_EX_DATA_FUNCS_num(meth);
-       j=sk_num(from->sk);
-       for (i=0; i<j; i++)
-               {
-               from_d=CRYPTO_get_ex_data(from,i);
-               if (i < m)
-                       {
-                       mm=sk_CRYPTO_EX_DATA_FUNCS_value(meth,i);
-                       if (mm->dup_func != NULL)
-                               r=mm->dup_func(to,from,(char **)&from_d,i,
-                                       mm->argl,mm->argp);
-                       }
-               CRYPTO_set_ex_data(to,i,from_d);
-               }
-       return(1);
-       }
-
-/* Call each free callback */
-void CRYPTO_free_ex_data(STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth, void *obj, CRYPTO_EX_DATA *ad)
-       {
-       CRYPTO_EX_DATA_FUNCS *m;
-       void *ptr;
-       int i,max;
-
-       if (meth != NULL)
-               {
-               max=sk_CRYPTO_EX_DATA_FUNCS_num(meth);
-               for (i=0; i<max; i++)
-                       {
-                       m=sk_CRYPTO_EX_DATA_FUNCS_value(meth,i);
-                       if ((m != NULL) && (m->free_func != NULL))
-                               {
-                               ptr=CRYPTO_get_ex_data(ad,i);
-                               m->free_func(obj,ptr,ad,i,m->argl,m->argp);
-                               }
-                       }
-               }
-       if (ad->sk != NULL)
-               {
-               sk_free(ad->sk);
-               ad->sk=NULL;
-               }
-       }
-
-void CRYPTO_new_ex_data(STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth, void *obj, CRYPTO_EX_DATA *ad)
-       {
-       CRYPTO_EX_DATA_FUNCS *m;
-       void *ptr;
-       int i,max;
-
-       ad->sk=NULL;
-       if (meth != NULL)
-               {
-               max=sk_CRYPTO_EX_DATA_FUNCS_num(meth);
-               for (i=0; i<max; i++)
-                       {
-                       m=sk_CRYPTO_EX_DATA_FUNCS_value(meth,i);
-                       if ((m != NULL) && (m->new_func != NULL))
-                               {
-                               ptr=CRYPTO_get_ex_data(ad,i);
-                               m->new_func(obj,ptr,ad,i,m->argl,m->argp);
-                               }
-                       }
-               }
-       }
-
 IMPLEMENT_STACK_OF(CRYPTO_EX_DATA_FUNCS)