Commit 7e5363ab authored by Rich Salz's avatar Rich Salz Committed by Rich Salz
Browse files

Rewrite crypto/ex_data 



Removed ability to set ex_data impl at runtime.  This removed these
three functions:
    const CRYPTO_EX_DATA_IMPL *CRYPTO_get_ex_data_implementation(void);
    int CRYPTO_set_ex_data_implementation(const CRYPTO_EX_DATA_IMPL *i);
    int CRYPTO_ex_data_new_class(void);
It is no longer possible to change the ex_data implementation at
runtime.  (Luckily those functions were never documented :)

Also removed the ability to add new exdata "classes."  We don't believe
this received much (if any) use, since you can't add it to OpenSSL objects,
and there are probably better (native) methods for developers to add
their own extensible data, if they really need that.

Replaced the internal hash table (of per-"class" stacks) with a simple
indexed array.  Reserved an index for "app" application.

Each API used to take the lock twice; now it only locks once.

Use local stack storage for function pointers, rather than malloc,
if possible (i.e., number of ex_data items is under a dozen).

Make CRYPTO_EX_DATA_FUNCS opaque/internal.

Also fixes RT3710; index zero is reserved.

Reviewed-by: default avatarRichard Levitte <levitte@openssl.org>
parent f7d53487

crypto/cpt_err.c

+4 −1
Original line number Original line Diff line number Diff line 
/* crypto/cpt_err.c */

/* crypto/cpt_err.c */

/* ====================================================================

/* ====================================================================

 * Copyright (c) 1999-2011 The OpenSSL Project.  All rights reserved.

 * Copyright (c) 1999-2015 The OpenSSL Project.  All rights reserved.

 *

 *

 * Redistribution and use in source and binary forms, with or without

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * modification, are permitted provided that the following conditions
@@ -70,9 +70,12 @@ 
# define ERR_REASON(reason) ERR_PACK(ERR_LIB_CRYPTO,0,reason)

# define ERR_REASON(reason) ERR_PACK(ERR_LIB_CRYPTO,0,reason)





static ERR_STRING_DATA CRYPTO_str_functs[] = {

static ERR_STRING_DATA CRYPTO_str_functs[] = {

    {ERR_FUNC(CRYPTO_F_CRYPTO_DUP_EX_DATA), "CRYPTO_dup_ex_data"},

    {ERR_FUNC(CRYPTO_F_CRYPTO_FREE_EX_DATA), "CRYPTO_free_ex_data"},

    {ERR_FUNC(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX), "CRYPTO_get_ex_new_index"},

    {ERR_FUNC(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX), "CRYPTO_get_ex_new_index"},

    {ERR_FUNC(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID), "CRYPTO_get_new_dynlockid"},

    {ERR_FUNC(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID), "CRYPTO_get_new_dynlockid"},

    {ERR_FUNC(CRYPTO_F_CRYPTO_GET_NEW_LOCKID), "CRYPTO_get_new_lockid"},

    {ERR_FUNC(CRYPTO_F_CRYPTO_GET_NEW_LOCKID), "CRYPTO_get_new_lockid"},

    {ERR_FUNC(CRYPTO_F_CRYPTO_NEW_EX_DATA), "CRYPTO_new_ex_data"},

    {ERR_FUNC(CRYPTO_F_CRYPTO_SET_EX_DATA), "CRYPTO_set_ex_data"},

    {ERR_FUNC(CRYPTO_F_CRYPTO_SET_EX_DATA), "CRYPTO_set_ex_data"},

    {ERR_FUNC(CRYPTO_F_DEF_ADD_INDEX), "DEF_ADD_INDEX"},

    {ERR_FUNC(CRYPTO_F_DEF_ADD_INDEX), "DEF_ADD_INDEX"},

    {ERR_FUNC(CRYPTO_F_DEF_GET_CLASS), "DEF_GET_CLASS"},

    {ERR_FUNC(CRYPTO_F_DEF_GET_CLASS), "DEF_GET_CLASS"},

crypto/engine/eng_dyn.c

+0 −1
Original line number Original line Diff line number Diff line
@@ -512,7 +512,6 @@ static int dynamic_load(ENGINE *e, dynamic_data_ctx *ctx) 
     * would also increase opaqueness.

     * would also increase opaqueness.

     */

     */

    fns.static_state = ENGINE_get_static_state();

    fns.static_state = ENGINE_get_static_state();

    fns.ex_data_fns = CRYPTO_get_ex_data_implementation();

    CRYPTO_get_mem_functions(&fns.mem_fns.malloc_cb,

    CRYPTO_get_mem_functions(&fns.mem_fns.malloc_cb,

                             &fns.mem_fns.realloc_cb, &fns.mem_fns.free_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_locking_cb = CRYPTO_get_locking_callback();

crypto/ex_data.c

+153 −388
Original line number Original line Diff line number Diff line 
/* crypto/ex_data.c */



/*

 * Overhaul notes;

 *

 * 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)

/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)

 * All rights reserved.

 * All rights reserved.

 *

 *
@@ -141,300 +111,150 @@ 
#include "internal/cryptlib.h"

#include "internal/cryptlib.h"

#include <openssl/lhash.h>

#include <openssl/lhash.h>





/* What an "implementation of ex_data functionality" looks like */

struct st_CRYPTO_EX_DATA_IMPL {

        /*********************/

    /* 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);

};



/* 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)

typedef struct {

{

    long argl;                  /* Arbitary long */

    int toret = 0;

    void *argp;                 /* Arbitary void * */

    CRYPTO_w_lock(CRYPTO_LOCK_EX_DATA);

    CRYPTO_EX_new *new_func;

    if (!impl) {

    CRYPTO_EX_free *free_func;

        impl = i;

    CRYPTO_EX_dup *dup_func;

        toret = 1;

} CRYPTO_EX_DATA_FUNCS;

    }

    CRYPTO_w_unlock(CRYPTO_LOCK_EX_DATA);

    return toret;

}





/****************************************************************************/

DECLARE_STACK_OF(CRYPTO_EX_DATA_FUNCS)

/*

 * Interal (default) implementation of "ex_data" support. API functions are

 * further down.

 */





/*

/*

 * The type that represents what each "class" used to implement locally. A

 * State for each class; could just be a typedef, but this allows future

 * STACK of CRYPTO_EX_DATA_FUNCS plus a index-counter. The 'class_index' is

 * changes.

 * the global value representing the class that is used to distinguish these

 * items.

 */

 */

typedef struct st_ex_class_item {

typedef struct {

    int class_index;

    STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth;

    STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth;

    int meth_num;

} EX_CLASS_ITEM;

} EX_CLASS_ITEM;





/* When assigning new class indexes, this is our counter */

static EX_CLASS_ITEM ex_data[CRYPTO_EX_INDEX__COUNT];

static int ex_class = CRYPTO_EX_INDEX_USER;





/* The global hash table of EX_CLASS_ITEM items */

/*

DECLARE_LHASH_OF(EX_CLASS_ITEM);

 * Return the EX_CLASS_ITEM from the "ex_data" array that corresponds to

static LHASH_OF(EX_CLASS_ITEM) *ex_data = NULL;

 * a given class.  On success, *holds the lock.*



 */

/* The callbacks required in the "ex_data" hash table */

static EX_CLASS_ITEM *def_get_class(int class_index)

static unsigned long ex_class_item_hash(const EX_CLASS_ITEM *a)

{

{

    return a->class_index;

    EX_CLASS_ITEM *ip;

}



static IMPLEMENT_LHASH_HASH_FN(ex_class_item, EX_CLASS_ITEM)





static int ex_class_item_cmp(const EX_CLASS_ITEM *a, const EX_CLASS_ITEM *b)

    if (class_index < 0 || class_index >= CRYPTO_EX_INDEX__COUNT) {

{

        CRYPTOerr(CRYPTO_F_DEF_GET_CLASS, ERR_R_MALLOC_FAILURE);

    return a->class_index - b->class_index;

        return NULL;

    }

    }





static IMPLEMENT_LHASH_COMP_FN(ex_class_item, EX_CLASS_ITEM)

    ip = &ex_data[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);

    CRYPTO_w_lock(CRYPTO_LOCK_EX_DATA);

    if (!ex_data && (ex_data = lh_EX_CLASS_ITEM_new()) == NULL)

    if (ip->meth == NULL) {

        toret = 0;

        ip->meth = sk_CRYPTO_EX_DATA_FUNCS_new_null();

        /* We push an initial value on the stack because the SSL

         * "app_data" routines use ex_data index zero.  See RT 3710. */

        if (ip->meth == NULL

            || !sk_CRYPTO_EX_DATA_FUNCS_push(ip->meth, NULL)) {

            CRYPTOerr(CRYPTO_F_DEF_GET_CLASS, ERR_R_MALLOC_FAILURE);

            CRYPTO_w_unlock(CRYPTO_LOCK_EX_DATA);

            CRYPTO_w_unlock(CRYPTO_LOCK_EX_DATA);

    return toret;

            return NULL;

        }

    }

    return ip;

}

}





/*

static void cleanup_cb(CRYPTO_EX_DATA_FUNCS *funcs)

 * 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(CRYPTO_EX_DATA_FUNCS *funcs)

{

{

    OPENSSL_free(funcs);

    OPENSSL_free(funcs);

}

}





/*

/*

 * This callback is used in lh_doall to destroy all EX_CLASS_ITEM values from

 * Release all "ex_data" state to prevent memory leaks. This can't be made

 * "ex_data" prior to the ex_data hash table being itself destroyed. Doesn't

 * thread-safe without overhauling a lot of stuff, and shouldn't really be

 * do any locking.

 * called under potential race-conditions anyway (it's for program shutdown

 * after all).

 */

 */

static void def_cleanup_cb(void *a_void)

void CRYPTO_cleanup_all_ex_data(void)

{

{

    EX_CLASS_ITEM *item = (EX_CLASS_ITEM *)a_void;

    int i;

    sk_CRYPTO_EX_DATA_FUNCS_pop_free(item->meth, def_cleanup_util_cb);

    OPENSSL_free(item);

}





/*

    for (i = 0; i < CRYPTO_EX_INDEX__COUNT; ++i) {

 * Return the EX_CLASS_ITEM from the "ex_data" hash table that corresponds to

        EX_CLASS_ITEM *ip = &ex_data[i];

 * a given class. Handles locking.



 */

        sk_CRYPTO_EX_DATA_FUNCS_pop_free(ip->meth, cleanup_cb);

static EX_CLASS_ITEM *def_get_class(int class_index)

        ip->meth = NULL;

{

    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_EX_CLASS_ITEM_retrieve(ex_data, &d);

    if (!p) {

        gen = OPENSSL_malloc(sizeof(*gen));

        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

                 */

                (void)lh_EX_CLASS_ITEM_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

 * Inside an existing class, get/register a new index.

 * index (or -1 for error). Handles locking.

 */

 */

static int def_add_index(EX_CLASS_ITEM *item, long argl, void *argp,

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_new *new_func, CRYPTO_EX_dup *dup_func,

                            CRYPTO_EX_free *free_func)

                            CRYPTO_EX_free *free_func)

{

{

    int toret = -1;

    int toret = -1;

    CRYPTO_EX_DATA_FUNCS *a = OPENSSL_malloc(sizeof(*a));

    CRYPTO_EX_DATA_FUNCS *a;

    if (!a) {

    EX_CLASS_ITEM *ip = def_get_class(class_index);

        CRYPTOerr(CRYPTO_F_DEF_ADD_INDEX, ERR_R_MALLOC_FAILURE);



    if (!ip)

        return -1;

        return -1;

    a = (CRYPTO_EX_DATA_FUNCS *)OPENSSL_malloc(sizeof(*a));

    if (!a) {

        CRYPTOerr(CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX, ERR_R_MALLOC_FAILURE);

        goto err;

    }

    }

    a->argl = argl;

    a->argl = argl;

    a->argp = argp;

    a->argp = argp;

    a->new_func = new_func;

    a->new_func = new_func;

    a->dup_func = dup_func;

    a->dup_func = dup_func;

    a->free_func = free_func;

    a->free_func = free_func;

    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(ip->meth, 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);

        OPENSSL_free(a);

        goto err;

        goto err;

    }

    }

    }

    toret = sk_CRYPTO_EX_DATA_FUNCS_num(ip->meth) - 1;

    toret = item->meth_num++;

    (void)sk_CRYPTO_EX_DATA_FUNCS_set(ip->meth, toret, a);

    (void)sk_CRYPTO_EX_DATA_FUNCS_set(item->meth, toret, a);

 err:

    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)

 err:

{

    int toret;

    CRYPTO_w_lock(CRYPTO_LOCK_EX_DATA);

    toret = ex_class++;

    CRYPTO_w_unlock(CRYPTO_LOCK_EX_DATA);

    CRYPTO_w_unlock(CRYPTO_LOCK_EX_DATA);

    return toret;

    return toret;

}

}





static void int_cleanup(void)

{

    EX_DATA_CHECK(return;)

        lh_EX_CLASS_ITEM_doall(ex_data, def_cleanup_cb);

    lh_EX_CLASS_ITEM_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);

}



/*

/*

 * 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

 * Thread-safe by copying a class's array of "CRYPTO_EX_DATA_FUNCS" entries

 * 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

 * in the lock, then using them outside the lock. Note this only applies

 * applies to the global "ex_data" state (ie. class definitions), not

 * to the global "ex_data" state (ie. class definitions), not 'ad' itself.

 * thread-safe on 'ad' itself.

 */

 */

static int int_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad)

int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad)

{

{

    int mx, i;

    int mx, i;

    void *ptr;

    void *ptr;

    CRYPTO_EX_DATA_FUNCS **storage = NULL;

    CRYPTO_EX_DATA_FUNCS **storage = NULL;

    EX_CLASS_ITEM *item = def_get_class(class_index);

    CRYPTO_EX_DATA_FUNCS *stack[10];

    if (!item)

    EX_CLASS_ITEM *ip = def_get_class(class_index);

        /* error is already set */



    if (!ip)

        return 0;

        return 0;



    ad->sk = NULL;

    ad->sk = NULL;

    CRYPTO_r_lock(CRYPTO_LOCK_EX_DATA);



    mx = sk_CRYPTO_EX_DATA_FUNCS_num(item->meth);

    mx = sk_CRYPTO_EX_DATA_FUNCS_num(ip->meth);

    if (mx > 0) {

    if (mx > 0) {

        storage = OPENSSL_malloc(mx * sizeof(CRYPTO_EX_DATA_FUNCS *));

        if (mx < (int)OSSL_NELEM(stack))

        if (!storage)

            storage = stack;

            goto skip;

        else

            storage = OPENSSL_malloc(sizeof(*storage) * mx);

        if (storage)

            for (i = 0; i < mx; i++)

            for (i = 0; i < mx; i++)

            storage[i] = sk_CRYPTO_EX_DATA_FUNCS_value(item->meth, i);

                storage[i] = sk_CRYPTO_EX_DATA_FUNCS_value(ip->meth, i);

    }

    }

 skip:

    CRYPTO_w_unlock(CRYPTO_LOCK_EX_DATA);

    CRYPTO_r_unlock(CRYPTO_LOCK_EX_DATA);



    if ((mx > 0) && !storage) {

    if (mx > 0 && storage == NULL) {

        CRYPTOerr(CRYPTO_F_INT_NEW_EX_DATA, ERR_R_MALLOC_FAILURE);

        CRYPTOerr(CRYPTO_F_CRYPTO_NEW_EX_DATA, ERR_R_MALLOC_FAILURE);

        return 0;

        return 0;

    }

    }

    for (i = 0; i < mx; i++) {

    for (i = 0; i < mx; i++) {
@@ -444,41 +264,50 @@ static int int_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad) 
                                 storage[i]->argl, storage[i]->argp);

                                 storage[i]->argl, storage[i]->argp);

        }

        }

    }

    }

    if (storage != stack)

        OPENSSL_free(storage);

        OPENSSL_free(storage);

    return 1;

    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,

 * 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)

                       CRYPTO_EX_DATA *from)

{

{

    int mx, j, i;

    int mx, j, i;

    char *ptr;

    char *ptr;

    CRYPTO_EX_DATA_FUNCS *stack[10];

    CRYPTO_EX_DATA_FUNCS **storage = NULL;

    CRYPTO_EX_DATA_FUNCS **storage = NULL;

    EX_CLASS_ITEM *item;

    EX_CLASS_ITEM *ip;

    if (!from->sk)



        /* 'to' should be "blank" which *is* just like 'from' */

    if (from->sk == NULL)

        /* Nothing to copy over */

        return 1;

        return 1;

    if ((item = def_get_class(class_index)) == NULL)

    if ((ip = def_get_class(class_index)) == NULL)

        return 0;

        return 0;

    CRYPTO_r_lock(CRYPTO_LOCK_EX_DATA);



    mx = sk_CRYPTO_EX_DATA_FUNCS_num(item->meth);

    mx = sk_CRYPTO_EX_DATA_FUNCS_num(ip->meth);

    j = sk_void_num(from->sk);

    j = sk_void_num(from->sk);

    if (j < mx)

    if (j < mx)

        mx = j;

        mx = j;

    if (mx > 0) {

    if (mx > 0) {

        storage = OPENSSL_malloc(mx * sizeof(CRYPTO_EX_DATA_FUNCS *));

        if (mx < (int)OSSL_NELEM(stack))

        if (!storage)

            storage = stack;

            goto skip;

        else

            storage = OPENSSL_malloc(sizeof(*storage) * mx);

        if (storage)

            for (i = 0; i < mx; i++)

            for (i = 0; i < mx; i++)

            storage[i] = sk_CRYPTO_EX_DATA_FUNCS_value(item->meth, i);

                storage[i] = sk_CRYPTO_EX_DATA_FUNCS_value(ip->meth, i);

    }

    }

 skip:

    CRYPTO_w_unlock(CRYPTO_LOCK_EX_DATA);

    CRYPTO_r_unlock(CRYPTO_LOCK_EX_DATA);



    if ((mx > 0) && !storage) {

    if (mx > 0 && storage == NULL) {

        CRYPTOerr(CRYPTO_F_INT_DUP_EX_DATA, ERR_R_MALLOC_FAILURE);

        CRYPTOerr(CRYPTO_F_CRYPTO_DUP_EX_DATA, ERR_R_MALLOC_FAILURE);

        return 0;

        return 0;

    }

    }



    for (i = 0; i < mx; i++) {

    for (i = 0; i < mx; i++) {

        ptr = CRYPTO_get_ex_data(from, i);

        ptr = CRYPTO_get_ex_data(from, i);

        if (storage[i] && storage[i]->dup_func)

        if (storage[i] && storage[i]->dup_func)
@@ -486,34 +315,41 @@ static int int_dup_ex_data(int class_index, CRYPTO_EX_DATA *to, 
                                 storage[i]->argl, storage[i]->argp);

                                 storage[i]->argl, storage[i]->argp);

        CRYPTO_set_ex_data(to, i, ptr);

        CRYPTO_set_ex_data(to, i, ptr);

    }

    }

    if (storage != stack)

        OPENSSL_free(storage);

        OPENSSL_free(storage);

    return 1;

    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)

/*

 * 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)

{

{

    int mx, i;

    int mx, i;

    EX_CLASS_ITEM *item;

    EX_CLASS_ITEM *ip;

    void *ptr;

    void *ptr;

    CRYPTO_EX_DATA_FUNCS *stack[10];

    CRYPTO_EX_DATA_FUNCS **storage = NULL;

    CRYPTO_EX_DATA_FUNCS **storage = NULL;

    if (ex_data == NULL)



        return;

    if ((ip = def_get_class(class_index)) == NULL)

    if ((item = def_get_class(class_index)) == NULL)

        return;

        return;

    CRYPTO_r_lock(CRYPTO_LOCK_EX_DATA);



    mx = sk_CRYPTO_EX_DATA_FUNCS_num(item->meth);

    mx = sk_CRYPTO_EX_DATA_FUNCS_num(ip->meth);

    if (mx > 0) {

    if (mx > 0) {

        storage = OPENSSL_malloc(mx * sizeof(CRYPTO_EX_DATA_FUNCS *));

        if (mx < (int)OSSL_NELEM(stack))

        if (!storage)

            storage = stack;

            goto skip;

        else

            storage = OPENSSL_malloc(sizeof(*storage) * mx);

        if (storage)

            for (i = 0; i < mx; i++)

            for (i = 0; i < mx; i++)

            storage[i] = sk_CRYPTO_EX_DATA_FUNCS_value(item->meth, i);

                storage[i] = sk_CRYPTO_EX_DATA_FUNCS_value(ip->meth, i);

    }

    }

 skip:

    CRYPTO_w_unlock(CRYPTO_LOCK_EX_DATA);

    CRYPTO_r_unlock(CRYPTO_LOCK_EX_DATA);



    if ((mx > 0) && !storage) {

    if (mx > 0 && storage == NULL) {

        CRYPTOerr(CRYPTO_F_INT_FREE_EX_DATA, ERR_R_MALLOC_FAILURE);

        CRYPTOerr(CRYPTO_F_CRYPTO_FREE_EX_DATA, ERR_R_MALLOC_FAILURE);

        return;

        return;

    }

    }

    for (i = 0; i < mx; i++) {

    for (i = 0; i < mx; i++) {
@@ -523,79 +359,13 @@ static void int_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad) 
                                  storage[i]->argl, storage[i]->argp);

                                  storage[i]->argl, storage[i]->argp);

        }

        }

    }

    }



    if (storage != stack)

        OPENSSL_free(storage);

        OPENSSL_free(storage);

    sk_void_free(ad->sk);

    sk_void_free(ad->sk);

    ad->sk = NULL;

    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 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 EX_IMPL(free_ex_data) (class_index, obj, ad);

}



/*

/*

 * For a given CRYPTO_EX_DATA variable, set the value corresponding to a

 * For a given CRYPTO_EX_DATA variable, set the value corresponding to a

 * particular index in the class used by this variable

 * particular index in the class used by this variable
@@ -607,20 +377,18 @@ int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val) 
    if (ad->sk == NULL) {

    if (ad->sk == NULL) {

        if ((ad->sk = sk_void_new_null()) == NULL) {

        if ((ad->sk = sk_void_new_null()) == NULL) {

            CRYPTOerr(CRYPTO_F_CRYPTO_SET_EX_DATA, ERR_R_MALLOC_FAILURE);

            CRYPTOerr(CRYPTO_F_CRYPTO_SET_EX_DATA, ERR_R_MALLOC_FAILURE);

            return (0);

            return 0;

        }

        }

    }

    }

    i = sk_void_num(ad->sk);





    while (i <= idx) {

    for (i = sk_void_num(ad->sk); i <= idx; ++i) {

        if (!sk_void_push(ad->sk, NULL)) {

        if (!sk_void_push(ad->sk, NULL)) {

            CRYPTOerr(CRYPTO_F_CRYPTO_SET_EX_DATA, ERR_R_MALLOC_FAILURE);

            CRYPTOerr(CRYPTO_F_CRYPTO_SET_EX_DATA, ERR_R_MALLOC_FAILURE);

            return (0);

            return 0;

        }

        }

        i++;

    }

    }

    sk_void_set(ad->sk, idx, val);

    sk_void_set(ad->sk, idx, val);

    return (1);

    return 1;

}

}





/*

/*
@@ -629,10 +397,7 @@ 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)

void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx)

{

{

    if (ad->sk == NULL)

    if (ad->sk == NULL || idx >= sk_void_num(ad->sk))

        return (0);

        return NULL;

    else if (idx >= sk_void_num(ad->sk))

    return sk_void_value(ad->sk, idx);

        return (0);

    else

        return (sk_void_value(ad->sk, idx));

}
 
}

include/openssl/crypto.h

+10 −35

File changed.

Preview size limit exceeded, changes collapsed.

include/openssl/engine.h

+0 −3
Original line number Original line Diff line number Diff line
@@ -776,7 +776,6 @@ typedef struct st_dynamic_LOCK_fns { 
/* The top-level structure */

/* The top-level structure */

typedef struct st_dynamic_fns {

typedef struct st_dynamic_fns {

    void *static_state;

    void *static_state;

    const CRYPTO_EX_DATA_IMPL *ex_data_fns;

    dynamic_MEM_fns mem_fns;

    dynamic_MEM_fns mem_fns;

    dynamic_LOCK_fns lock_fns;

    dynamic_LOCK_fns lock_fns;

} dynamic_fns;

} dynamic_fns;
@@ -834,8 +833,6 @@ typedef int (*dynamic_bind_engine) (ENGINE *e, const char *id, 
                CRYPTO_set_dynlock_create_callback(fns->lock_fns.dynlock_create_cb); \

                CRYPTO_set_dynlock_create_callback(fns->lock_fns.dynlock_create_cb); \

                CRYPTO_set_dynlock_lock_callback(fns->lock_fns.dynlock_lock_cb); \

                CRYPTO_set_dynlock_lock_callback(fns->lock_fns.dynlock_lock_cb); \

                CRYPTO_set_dynlock_destroy_callback(fns->lock_fns.dynlock_destroy_cb); \

                CRYPTO_set_dynlock_destroy_callback(fns->lock_fns.dynlock_destroy_cb); \

                if(!CRYPTO_set_ex_data_implementation(fns->ex_data_fns)) \

                        return 0; \

        skip_cbs: \

        skip_cbs: \

                if(!fn(e,id)) return 0; \

                if(!fn(e,id)) return 0; \

                return 1; }

                return 1; }