[thirdparty/openssl.git] / crypto / store / str_mem.c

/* crypto/store/str_mem.c */
/*
 * Written by Richard Levitte (richard@levitte.org) for the OpenSSL project
 * 2003.
 */
/* ====================================================================
 * Copyright (c) 2003 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    openssl-core@openssl.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */

#include <string.h>
#include <openssl/err.h>
#include "str_locl.h"

/*
 * The memory store is currently highly experimental.  It's meant to become a
 * base store used by other stores for internal caching (for full caching
 * support, aging needs to be added).
 *
 * The database use is meant to support as much attribute association as
 * possible, while providing for as small search ranges as possible. This is
 * currently provided for by sorting the entries by numbers that are composed
 * of bits set at the positions indicated by attribute type codes.  This
 * provides for ranges determined by the highest attribute type code value.
 * A better idea might be to sort by values computed from the range of
 * attributes associated with the object (basically, the difference between
 * the highest and lowest attribute type code) and it's distance from a base
 * (basically, the lowest associated attribute type code).
 */

typedef struct mem_object_data_st {
    STORE_OBJECT *object;
    STORE_ATTR_INFO *attr_info;
    int references;
} MEM_OBJECT_DATA;

DEFINE_STACK_OF(MEM_OBJECT_DATA)
struct mem_data_st {
    /*
     * sorted with
     * STORE_ATTR_INFO_compare().
     */
    STACK_OF(MEM_OBJECT_DATA) *data;
    /*
     * Currently unused, but can
     * be used to add attributes
     * from parts of the data.
     */
    unsigned int compute_components:1;
};

DEFINE_STACK_OF(STORE_ATTR_INFO)
struct mem_ctx_st {
    /* The type we're searching for */
    int type;
    /*
     * Sets of
     * attributes to search for.  Each
     * element is a STORE_ATTR_INFO.
     */
    STACK_OF(STORE_ATTR_INFO) *search_attributes;
    /*
     * which of the search attributes we
     * found a match for, -1 when we still
     * haven't found any
     */
    int search_index;
    /* -1 as long as we're searching for the first */
    int index;
};

static int mem_init(STORE *s);
static void mem_clean(STORE *s);
static STORE_OBJECT *mem_generate(STORE *s, STORE_OBJECT_TYPES type,
                                  OPENSSL_ITEM attributes[],
                                  OPENSSL_ITEM parameters[]);
static STORE_OBJECT *mem_get(STORE *s, STORE_OBJECT_TYPES type,
                             OPENSSL_ITEM attributes[],
                             OPENSSL_ITEM parameters[]);
static int mem_store(STORE *s, STORE_OBJECT_TYPES type, STORE_OBJECT *data,
                     OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]);
static int mem_modify(STORE *s, STORE_OBJECT_TYPES type,
                      OPENSSL_ITEM search_attributes[],
                      OPENSSL_ITEM add_attributes[],
                      OPENSSL_ITEM modify_attributes[],
                      OPENSSL_ITEM delete_attributes[],
                      OPENSSL_ITEM parameters[]);
static int mem_delete(STORE *s, STORE_OBJECT_TYPES type,
                      OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]);
static void *mem_list_start(STORE *s, STORE_OBJECT_TYPES type,
                            OPENSSL_ITEM attributes[],
                            OPENSSL_ITEM parameters[]);
static STORE_OBJECT *mem_list_next(STORE *s, void *handle);
static int mem_list_end(STORE *s, void *handle);
static int mem_list_endp(STORE *s, void *handle);
static int mem_lock(STORE *s, OPENSSL_ITEM attributes[],
                    OPENSSL_ITEM parameters[]);
static int mem_unlock(STORE *s, OPENSSL_ITEM attributes[],
                      OPENSSL_ITEM parameters[]);
static int mem_ctrl(STORE *s, int cmd, long l, void *p, void (*f) (void));

static STORE_METHOD store_memory = {
    "OpenSSL memory store interface",
    mem_init,
    mem_clean,
    mem_generate,
    mem_get,
    mem_store,
    mem_modify,
    NULL,                       /* revoke */
    mem_delete,
    mem_list_start,
    mem_list_next,
    mem_list_end,
    mem_list_endp,
    NULL,                       /* update */
    mem_lock,
    mem_unlock,
    mem_ctrl
};

const STORE_METHOD *STORE_Memory(void)
{
    return &store_memory;
}

static int mem_init(STORE *s)
{
    return 1;
}

static void mem_clean(STORE *s)
{
    return;
}

static STORE_OBJECT *mem_generate(STORE *s, STORE_OBJECT_TYPES type,
                                  OPENSSL_ITEM attributes[],
                                  OPENSSL_ITEM parameters[])
{
    STOREerr(STORE_F_MEM_GENERATE, STORE_R_NOT_IMPLEMENTED);
    return 0;
}

static STORE_OBJECT *mem_get(STORE *s, STORE_OBJECT_TYPES type,
                             OPENSSL_ITEM attributes[],
                             OPENSSL_ITEM parameters[])
{
    void *context = mem_list_start(s, type, attributes, parameters);

    if (context) {
        STORE_OBJECT *object = mem_list_next(s, context);

        if (mem_list_end(s, context))
            return object;
    }
    return NULL;
}

static int mem_store(STORE *s, STORE_OBJECT_TYPES type,
                     STORE_OBJECT *data, OPENSSL_ITEM attributes[],
                     OPENSSL_ITEM parameters[])
{
    STOREerr(STORE_F_MEM_STORE, STORE_R_NOT_IMPLEMENTED);
    return 0;
}

static int mem_modify(STORE *s, STORE_OBJECT_TYPES type,
                      OPENSSL_ITEM search_attributes[],
                      OPENSSL_ITEM add_attributes[],
                      OPENSSL_ITEM modify_attributes[],
                      OPENSSL_ITEM delete_attributes[],
                      OPENSSL_ITEM parameters[])
{
    STOREerr(STORE_F_MEM_MODIFY, STORE_R_NOT_IMPLEMENTED);
    return 0;
}

static int mem_delete(STORE *s, STORE_OBJECT_TYPES type,
                      OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[])
{
    STOREerr(STORE_F_MEM_DELETE, STORE_R_NOT_IMPLEMENTED);
    return 0;
}

/*
 * The list functions may be the hardest to understand.  Basically,
 * mem_list_start compiles a stack of attribute info elements, and puts that
 * stack into the context to be returned.  mem_list_next will then find the
 * first matching element in the store, and then walk all the way to the end
 * of the store (since any combination of attribute bits above the starting
 * point may match the searched for bit pattern...).
 */
static void *mem_list_start(STORE *s, STORE_OBJECT_TYPES type,
                            OPENSSL_ITEM attributes[],
                            OPENSSL_ITEM parameters[])
{
    struct mem_ctx_st *context = OPENSSL_zalloc(sizeof(*context));
    void *attribute_context = NULL;
    STORE_ATTR_INFO *attrs = NULL;

    if (context == NULL) {
        STOREerr(STORE_F_MEM_LIST_START, ERR_R_MALLOC_FAILURE);
        return 0;
    }

    attribute_context = STORE_parse_attrs_start(attributes);
    if (!attribute_context) {
        STOREerr(STORE_F_MEM_LIST_START, ERR_R_STORE_LIB);
        goto err;
    }

    while ((attrs = STORE_parse_attrs_next(attribute_context))) {
        if (context->search_attributes == NULL) {
            context->search_attributes =
                sk_STORE_ATTR_INFO_new(STORE_ATTR_INFO_compare);
            if (context->search_attributes == NULL) {
                STOREerr(STORE_F_MEM_LIST_START, ERR_R_MALLOC_FAILURE);
                goto err;
            }
        }
        sk_STORE_ATTR_INFO_push(context->search_attributes, attrs);
    }
    if (!STORE_parse_attrs_endp(attribute_context))
        goto err;
    STORE_parse_attrs_end(attribute_context);
    context->search_index = -1;
    context->index = -1;
    return context;
 err:
    if (attribute_context)
        STORE_parse_attrs_end(attribute_context);
    mem_list_end(s, context);
    return NULL;
}

static STORE_OBJECT *mem_list_next(STORE *s, void *handle)
{
    int i;
    struct mem_ctx_st *context = (struct mem_ctx_st *)handle;
    struct mem_object_data_st key = { 0, 0, 1 };
    struct mem_data_st *store = (struct mem_data_st *)STORE_get_ex_data(s, 1);
    int srch;
    int cres = 0;

    if (!context) {
        STOREerr(STORE_F_MEM_LIST_NEXT, ERR_R_PASSED_NULL_PARAMETER);
        return NULL;
    }
    if (!store) {
        STOREerr(STORE_F_MEM_LIST_NEXT, STORE_R_NO_STORE);
        return NULL;
    }

    if (context->search_index == -1) {
        for (i = 0;
             i < sk_STORE_ATTR_INFO_num(context->search_attributes); i++) {
            key.attr_info
                = sk_STORE_ATTR_INFO_value(context->search_attributes, i);
            srch = sk_MEM_OBJECT_DATA_find_ex(store->data, &key);

            if (srch >= 0) {
                context->search_index = srch;
                break;
            }
        }
    }
    if (context->search_index < 0)
        return NULL;

    key.attr_info =
        sk_STORE_ATTR_INFO_value(context->search_attributes,
                                 context->search_index);
    for (srch = context->search_index;
         srch < sk_MEM_OBJECT_DATA_num(store->data)
         && STORE_ATTR_INFO_in_range(key.attr_info,
                                     sk_MEM_OBJECT_DATA_value(store->data,
                                                              srch)->attr_info)
         && !(cres =
              STORE_ATTR_INFO_in_ex(key.attr_info,
                                    sk_MEM_OBJECT_DATA_value(store->data,
                                                             srch)->attr_info));
         srch++) ;

    context->search_index = srch;
    if (cres)
        return (sk_MEM_OBJECT_DATA_value(store->data, srch))->object;
    return NULL;
}

static int mem_list_end(STORE *s, void *handle)
{
    struct mem_ctx_st *context = (struct mem_ctx_st *)handle;

    if (!context) {
        STOREerr(STORE_F_MEM_LIST_END, ERR_R_PASSED_NULL_PARAMETER);
        return 0;
    }
    if (context)
        sk_STORE_ATTR_INFO_free(context->search_attributes);
    OPENSSL_free(context);
    return 1;
}

static int mem_list_endp(STORE *s, void *handle)
{
    struct mem_ctx_st *context = (struct mem_ctx_st *)handle;

    if (!context
        || context->search_index
        == sk_STORE_ATTR_INFO_num(context->search_attributes))
        return 1;
    return 0;
}

static int mem_lock(STORE *s, OPENSSL_ITEM attributes[],
                    OPENSSL_ITEM parameters[])
{
    return 1;
}

static int mem_unlock(STORE *s, OPENSSL_ITEM attributes[],
                      OPENSSL_ITEM parameters[])
{
    return 1;
}

static int mem_ctrl(STORE *s, int cmd, long l, void *p, void (*f) (void))
{
    return 1;
}
Commit	Line	Data
31384753	1	/* crypto/store/str_mem.c */
0f113f3e MC	2	/*
	3	* Written by Richard Levitte (richard@levitte.org) for the OpenSSL project
	4	* 2003.
a5db6fa5 RL	5	*/
	6	/* ====================================================================
	7	* Copyright (c) 2003 The OpenSSL Project. All rights reserved.
	8	*
	9	* Redistribution and use in source and binary forms, with or without
	10	* modification, are permitted provided that the following conditions
	11	* are met:
	12	*
	13	* 1. Redistributions of source code must retain the above copyright
0f113f3e	14	* notice, this list of conditions and the following disclaimer.
a5db6fa5 RL	15	*
	16	* 2. Redistributions in binary form must reproduce the above copyright
	17	* notice, this list of conditions and the following disclaimer in
	18	* the documentation and/or other materials provided with the
	19	* distribution.
	20	*
	21	* 3. All advertising materials mentioning features or use of this
	22	* software must display the following acknowledgment:
	23	* "This product includes software developed by the OpenSSL Project
	24	* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
	25	*
	26	* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
	27	* endorse or promote products derived from this software without
	28	* prior written permission. For written permission, please contact
	29	* openssl-core@openssl.org.
	30	*
	31	* 5. Products derived from this software may not be called "OpenSSL"
	32	* nor may "OpenSSL" appear in their names without prior written
	33	* permission of the OpenSSL Project.
	34	*
	35	* 6. Redistributions of any form whatsoever must retain the following
	36	* acknowledgment:
	37	* "This product includes software developed by the OpenSSL Project
	38	* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
	39	*
	40	* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
	41	* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	42	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	43	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
	44	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	45	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	46	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	47	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	48	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	49	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	50	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
	51	* OF THE POSSIBILITY OF SUCH DAMAGE.
	52	* ====================================================================
	53	*
	54	* This product includes cryptographic software written by Eric Young
	55	* (eay@cryptsoft.com). This product includes software written by Tim
	56	* Hudson (tjh@cryptsoft.com).
	57	*
	58	*/
	59
	60	#include <string.h>
	61	#include <openssl/err.h>
	62	#include "str_locl.h"
	63
0f113f3e MC	64	/*
	65	* The memory store is currently highly experimental. It's meant to become a
	66	* base store used by other stores for internal caching (for full caching
	67	* support, aging needs to be added).
	68	*
	69	* The database use is meant to support as much attribute association as
	70	* possible, while providing for as small search ranges as possible. This is
	71	* currently provided for by sorting the entries by numbers that are composed
	72	* of bits set at the positions indicated by attribute type codes. This
	73	* provides for ranges determined by the highest attribute type code value.
	74	* A better idea might be to sort by values computed from the range of
	75	* attributes associated with the object (basically, the difference between
	76	* the highest and lowest attribute type code) and it's distance from a base
	77	* (basically, the lowest associated attribute type code).
	78	*/
	79
	80	typedef struct mem_object_data_st {
	81	STORE_OBJECT *object;
	82	STORE_ATTR_INFO *attr_info;
	83	int references;
	84	} MEM_OBJECT_DATA;
a5db6fa5	85
85885715	86	DEFINE_STACK_OF(MEM_OBJECT_DATA)
0f113f3e MC	87	struct mem_data_st {
	88	/*
	89	* sorted with
	90	* STORE_ATTR_INFO_compare().
	91	*/
	92	STACK_OF(MEM_OBJECT_DATA) *data;
	93	/*
	94	* Currently unused, but can
	95	* be used to add attributes
	96	* from parts of the data.
	97	*/
	98	unsigned int compute_components:1;
	99	};
a5db6fa5	100
85885715	101	DEFINE_STACK_OF(STORE_ATTR_INFO)
0f113f3e MC	102	struct mem_ctx_st {
	103	/* The type we're searching for */
	104	int type;
	105	/*
	106	* Sets of
	107	* attributes to search for. Each
	108	* element is a STORE_ATTR_INFO.
	109	*/
	110	STACK_OF(STORE_ATTR_INFO) *search_attributes;
	111	/*
	112	* which of the search attributes we
	113	* found a match for, -1 when we still
	114	* haven't found any
	115	*/
	116	int search_index;
	117	/* -1 as long as we're searching for the first */
	118	int index;
	119	};
a5db6fa5 RL	120
	121	static int mem_init(STORE *s);
	122	static void mem_clean(STORE *s);
	123	static STORE_OBJECT mem_generate(STORE s, STORE_OBJECT_TYPES type,
0f113f3e MC	124	OPENSSL_ITEM attributes[],
0f113f3e MC	125	OPENSSL_ITEM parameters[]);
a5db6fa5	126	static STORE_OBJECT mem_get(STORE s, STORE_OBJECT_TYPES type,
0f113f3e MC	127	OPENSSL_ITEM attributes[],
	128	OPENSSL_ITEM parameters[]);
	129	static int mem_store(STORE s, STORE_OBJECT_TYPES type, STORE_OBJECT data,
	130	OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]);
a5db6fa5	131	static int mem_modify(STORE *s, STORE_OBJECT_TYPES type,
0f113f3e MC	132	OPENSSL_ITEM search_attributes[],
	133	OPENSSL_ITEM add_attributes[],
	134	OPENSSL_ITEM modify_attributes[],
	135	OPENSSL_ITEM delete_attributes[],
	136	OPENSSL_ITEM parameters[]);
a5db6fa5	137	static int mem_delete(STORE *s, STORE_OBJECT_TYPES type,
0f113f3e	138	OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]);
a5db6fa5	139	static void mem_list_start(STORE s, STORE_OBJECT_TYPES type,
0f113f3e MC	140	OPENSSL_ITEM attributes[],
0f113f3e MC	141	OPENSSL_ITEM parameters[]);
a5db6fa5 RL	142	static STORE_OBJECT mem_list_next(STORE s, void *handle);
	143	static int mem_list_end(STORE s, void handle);
	144	static int mem_list_endp(STORE s, void handle);
48c36fdb	145	static int mem_lock(STORE *s, OPENSSL_ITEM attributes[],
0f113f3e	146	OPENSSL_ITEM parameters[]);
48c36fdb	147	static int mem_unlock(STORE *s, OPENSSL_ITEM attributes[],
0f113f3e MC	148	OPENSSL_ITEM parameters[]);
	149	static int mem_ctrl(STORE s, int cmd, long l, void p, void (*f) (void));
	150
	151	static STORE_METHOD store_memory = {
	152	"OpenSSL memory store interface",
	153	mem_init,
	154	mem_clean,
	155	mem_generate,
	156	mem_get,
	157	mem_store,
	158	mem_modify,
	159	NULL, /* revoke */
	160	mem_delete,
	161	mem_list_start,
	162	mem_list_next,
	163	mem_list_end,
	164	mem_list_endp,
	165	NULL, /* update */
	166	mem_lock,
	167	mem_unlock,
	168	mem_ctrl
	169	};
a5db6fa5 RL	170
a5db6fa5 RL	171	const STORE_METHOD *STORE_Memory(void)
0f113f3e MC	172	{
	173	return &store_memory;
	174	}
a5db6fa5 RL	175
a5db6fa5 RL	176	static int mem_init(STORE *s)
0f113f3e MC	177	{
	178	return 1;
	179	}
a5db6fa5 RL	180
a5db6fa5 RL	181	static void mem_clean(STORE *s)
0f113f3e MC	182	{
	183	return;
	184	}
a5db6fa5 RL	185
a5db6fa5 RL	186	static STORE_OBJECT mem_generate(STORE s, STORE_OBJECT_TYPES type,
0f113f3e MC	187	OPENSSL_ITEM attributes[],
	188	OPENSSL_ITEM parameters[])
	189	{
	190	STOREerr(STORE_F_MEM_GENERATE, STORE_R_NOT_IMPLEMENTED);
	191	return 0;
	192	}
	193
a5db6fa5	194	static STORE_OBJECT mem_get(STORE s, STORE_OBJECT_TYPES type,
0f113f3e MC	195	OPENSSL_ITEM attributes[],
	196	OPENSSL_ITEM parameters[])
	197	{
	198	void *context = mem_list_start(s, type, attributes, parameters);
	199
	200	if (context) {
	201	STORE_OBJECT *object = mem_list_next(s, context);
	202
	203	if (mem_list_end(s, context))
	204	return object;
	205	}
	206	return NULL;
	207	}
	208
a5db6fa5	209	static int mem_store(STORE *s, STORE_OBJECT_TYPES type,
0f113f3e MC	210	STORE_OBJECT *data, OPENSSL_ITEM attributes[],
	211	OPENSSL_ITEM parameters[])
	212	{
	213	STOREerr(STORE_F_MEM_STORE, STORE_R_NOT_IMPLEMENTED);
	214	return 0;
	215	}
	216
a5db6fa5	217	static int mem_modify(STORE *s, STORE_OBJECT_TYPES type,
0f113f3e MC	218	OPENSSL_ITEM search_attributes[],
	219	OPENSSL_ITEM add_attributes[],
	220	OPENSSL_ITEM modify_attributes[],
	221	OPENSSL_ITEM delete_attributes[],
	222	OPENSSL_ITEM parameters[])
	223	{
	224	STOREerr(STORE_F_MEM_MODIFY, STORE_R_NOT_IMPLEMENTED);
	225	return 0;
	226	}
	227
a5db6fa5	228	static int mem_delete(STORE *s, STORE_OBJECT_TYPES type,
0f113f3e MC	229	OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[])
	230	{
	231	STOREerr(STORE_F_MEM_DELETE, STORE_R_NOT_IMPLEMENTED);
	232	return 0;
	233	}
	234
	235	/*
	236	* The list functions may be the hardest to understand. Basically,
	237	* mem_list_start compiles a stack of attribute info elements, and puts that
	238	* stack into the context to be returned. mem_list_next will then find the
	239	* first matching element in the store, and then walk all the way to the end
	240	* of the store (since any combination of attribute bits above the starting
	241	* point may match the searched for bit pattern...).
	242	*/
a5db6fa5	243	static void mem_list_start(STORE s, STORE_OBJECT_TYPES type,
0f113f3e MC	244	OPENSSL_ITEM attributes[],
	245	OPENSSL_ITEM parameters[])
	246	{
b51bce94	247	struct mem_ctx_st context = OPENSSL_zalloc(sizeof(context));
0f113f3e MC	248	void *attribute_context = NULL;
	249	STORE_ATTR_INFO *attrs = NULL;
	250
90945fa3	251	if (context == NULL) {
0f113f3e MC	252	STOREerr(STORE_F_MEM_LIST_START, ERR_R_MALLOC_FAILURE);
	253	return 0;
	254	}
0f113f3e MC	255
	256	attribute_context = STORE_parse_attrs_start(attributes);
	257	if (!attribute_context) {
	258	STOREerr(STORE_F_MEM_LIST_START, ERR_R_STORE_LIB);
	259	goto err;
	260	}
	261
	262	while ((attrs = STORE_parse_attrs_next(attribute_context))) {
	263	if (context->search_attributes == NULL) {
	264	context->search_attributes =
	265	sk_STORE_ATTR_INFO_new(STORE_ATTR_INFO_compare);
90945fa3	266	if (context->search_attributes == NULL) {
0f113f3e MC	267	STOREerr(STORE_F_MEM_LIST_START, ERR_R_MALLOC_FAILURE);
	268	goto err;
	269	}
	270	}
	271	sk_STORE_ATTR_INFO_push(context->search_attributes, attrs);
	272	}
	273	if (!STORE_parse_attrs_endp(attribute_context))
	274	goto err;
	275	STORE_parse_attrs_end(attribute_context);
	276	context->search_index = -1;
	277	context->index = -1;
	278	return context;
a5db6fa5	279	err:
0f113f3e MC	280	if (attribute_context)
	281	STORE_parse_attrs_end(attribute_context);
	282	mem_list_end(s, context);
	283	return NULL;
	284	}
	285
a5db6fa5	286	static STORE_OBJECT mem_list_next(STORE s, void *handle)
0f113f3e MC	287	{
	288	int i;
	289	struct mem_ctx_st context = (struct mem_ctx_st )handle;
	290	struct mem_object_data_st key = { 0, 0, 1 };
	291	struct mem_data_st store = (struct mem_data_st )STORE_get_ex_data(s, 1);
	292	int srch;
	293	int cres = 0;
	294
	295	if (!context) {
	296	STOREerr(STORE_F_MEM_LIST_NEXT, ERR_R_PASSED_NULL_PARAMETER);
	297	return NULL;
	298	}
	299	if (!store) {
	300	STOREerr(STORE_F_MEM_LIST_NEXT, STORE_R_NO_STORE);
	301	return NULL;
	302	}
	303
	304	if (context->search_index == -1) {
	305	for (i = 0;
	306	i < sk_STORE_ATTR_INFO_num(context->search_attributes); i++) {
	307	key.attr_info
	308	= sk_STORE_ATTR_INFO_value(context->search_attributes, i);
	309	srch = sk_MEM_OBJECT_DATA_find_ex(store->data, &key);
	310
	311	if (srch >= 0) {
	312	context->search_index = srch;
	313	break;
	314	}
	315	}
	316	}
	317	if (context->search_index < 0)
	318	return NULL;
	319
	320	key.attr_info =
	321	sk_STORE_ATTR_INFO_value(context->search_attributes,
	322	context->search_index);
	323	for (srch = context->search_index;
	324	srch < sk_MEM_OBJECT_DATA_num(store->data)
	325	&& STORE_ATTR_INFO_in_range(key.attr_info,
	326	sk_MEM_OBJECT_DATA_value(store->data,
	327	srch)->attr_info)
	328	&& !(cres =
	329	STORE_ATTR_INFO_in_ex(key.attr_info,
	330	sk_MEM_OBJECT_DATA_value(store->data,
	331	srch)->attr_info));
	332	srch++) ;
	333
	334	context->search_index = srch;
	335	if (cres)
	336	return (sk_MEM_OBJECT_DATA_value(store->data, srch))->object;
	337	return NULL;
	338	}
	339
a5db6fa5	340	static int mem_list_end(STORE s, void handle)
0f113f3e MC	341	{
	342	struct mem_ctx_st context = (struct mem_ctx_st )handle;
	343
	344	if (!context) {
	345	STOREerr(STORE_F_MEM_LIST_END, ERR_R_PASSED_NULL_PARAMETER);
	346	return 0;
	347	}
25aaa98a	348	if (context)
0f113f3e	349	sk_STORE_ATTR_INFO_free(context->search_attributes);
b548a1f1	350	OPENSSL_free(context);
0f113f3e MC	351	return 1;
	352	}
	353
a5db6fa5	354	static int mem_list_endp(STORE s, void handle)
0f113f3e MC	355	{
	356	struct mem_ctx_st context = (struct mem_ctx_st )handle;
	357
	358	if (!context
	359	\|\| context->search_index
	360	== sk_STORE_ATTR_INFO_num(context->search_attributes))
	361	return 1;
	362	return 0;
	363	}
	364
48c36fdb	365	static int mem_lock(STORE *s, OPENSSL_ITEM attributes[],
0f113f3e MC	366	OPENSSL_ITEM parameters[])
	367	{
	368	return 1;
	369	}
	370
48c36fdb	371	static int mem_unlock(STORE *s, OPENSSL_ITEM attributes[],
0f113f3e MC	372	OPENSSL_ITEM parameters[])
	373	{
	374	return 1;
	375	}
	376
	377	static int mem_ctrl(STORE s, int cmd, long l, void p, void (*f) (void))
	378	{
	379	return 1;
	380	}