-/* crypto/store/str_mem.c -*- mode:C; c-file-style: "eay" -*- */
-/* Written by Richard Levitte (richard@levitte.org) for the OpenSSL
- * project 2003.
+/* 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.
* are met:
*
* 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
+ * 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
#include <openssl/err.h>
#include "str_locl.h"
-struct mem_object_data_st
- {
- STORE_OBJECT *object;
- STORE_ATTR_INFO *attr_info;
- int references;
- };
-
-struct mem_data_st
- {
- STACK *data; /* A stack of mem_object_data_st,
- potentially sorted with a wrapper
- around STORE_ATTR_INFO_cmp(). */
- unsigned int compute_components : 1; /* Currently unused, but can
- be used to add attributes
- from parts of the data. */
- };
-
-struct mem_ctx_st
- {
- int type; /* The type we're searching for */
- STACK *search_attributes; /* Sets of attributes to search for.
- Each element is a STORE_ATTR_INFO. */
- int search_index; /* which of the search attributes we found a match
- for, -1 when we still haven't found any */
- int index; /* -1 as long as we're searching for the first */
- };
+/*
+ * 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;
+
+DECLARE_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;
+};
+
+DECLARE_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 parameters[], OPENSSL_ITEM attributes[]);
+ OPENSSL_ITEM attributes[],
+ OPENSSL_ITEM parameters[]);
static STORE_OBJECT *mem_get(STORE *s, STORE_OBJECT_TYPES type,
- OPENSSL_ITEM attributes[]);
-static int mem_store(STORE *s, STORE_OBJECT_TYPES type,
- STORE_OBJECT *data, OPENSSL_ITEM attributes[]);
+ 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 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 attributes[], OPENSSL_ITEM parameters[]);
static void *mem_list_start(STORE *s, STORE_OBJECT_TYPES type,
- OPENSSL_ITEM attributes[]);
+ 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[]);
-static int mem_unlock(STORE *s, OPENSSL_ITEM attributes[]);
-static int mem_ctrl(STORE *s, int cmd, long l, void *p, void (*f)());
-
-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
- };
+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;
- }
+{
+ return &store_memory;
+}
static int mem_init(STORE *s)
- {
- return 1;
- }
+{
+ return 1;
+}
static void mem_clean(STORE *s)
- {
- return;
- }
+{
+ return;
+}
static STORE_OBJECT *mem_generate(STORE *s, STORE_OBJECT_TYPES type,
- OPENSSL_ITEM parameters[], OPENSSL_ITEM attributes[])
- {
- STOREerr(STORE_F_MEM_GENERATE, STORE_R_NOT_IMPLEMENTED);
- return 0;
- }
+ 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[])
- {
- void *context = mem_list_start(s, type, attributes);
-
- if (context)
- {
- STORE_OBJECT *object = mem_list_next(s, context);
-
- if (mem_list_end(s, context))
- return object;
- }
- return NULL;
- }
+ 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[])
- {
- STOREerr(STORE_F_MEM_STORE, STORE_R_NOT_IMPLEMENTED);
- return 0;
- }
+ 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[])
- {
- STOREerr(STORE_F_MEM_STORE, STORE_R_NOT_IMPLEMENTED);
- return 0;
- }
+ 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[])
- {
- STOREerr(STORE_F_MEM_DELETE, STORE_R_NOT_IMPLEMENTED);
- return 0;
- }
+ 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[])
- {
- struct mem_ctx_st *context =
- (struct mem_ctx_st *)OPENSSL_malloc(sizeof(struct mem_ctx_st));
- void *attribute_context = NULL;
- STORE_ATTR_INFO *attrs = NULL;
-
- if (!context)
- {
- STOREerr(STORE_F_MEM_LIST_START, ERR_R_MALLOC_FAILURE);
- return 0;
- }
- memset(context, 0, sizeof(struct mem_ctx_st));
-
- 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_new((int (*)(const char * const *, const char * const *))STORE_ATTR_INFO_compare);
- if (!context->search_attributes)
- {
- STOREerr(STORE_F_MEM_LIST_START,
- ERR_R_MALLOC_FAILURE);
- goto err;
- }
- }
- sk_push(context->search_attributes,(char *)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;
+ OPENSSL_ITEM attributes[],
+ OPENSSL_ITEM parameters[])
+{
+ struct mem_ctx_st *context =
+ (struct mem_ctx_st *)OPENSSL_malloc(sizeof(struct mem_ctx_st));
+ void *attribute_context = NULL;
+ STORE_ATTR_INFO *attrs = NULL;
+
+ if (!context) {
+ STOREerr(STORE_F_MEM_LIST_START, ERR_R_MALLOC_FAILURE);
+ return 0;
+ }
+ memset(context, 0, sizeof(struct mem_ctx_st));
+
+ 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) {
+ 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;
- }
+ 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_num(context->search_attributes); i++)
- {
- key.attr_info =
- (STORE_ATTR_INFO *)sk_value(context->search_attributes, i);
- srch = sk_find_ex(store->data, (char *)&key);
-
- if (srch >= 0)
- {
- context->search_index = srch;
- break;
- }
- }
- }
- if (context->search_index < 0)
- return NULL;
-
- key.attr_info =
- (STORE_ATTR_INFO *)sk_value(context->search_attributes,
- context->search_index);
- for(srch = context->search_index;
- srch < sk_num(store->data)
- && !(cres = STORE_ATTR_INFO_in_ex(key.attr_info,
- (STORE_ATTR_INFO *)sk_value(store->data, srch)));
- srch++)
- ;
-
- context->search_index = srch;
- if (cres)
- return ((struct mem_object_data_st *)sk_value(store->data,
- srch))->object;
- return NULL;
- }
+{
+ 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_NEXT, ERR_R_PASSED_NULL_PARAMETER);
- return 0;
- }
- if (context && context->search_attributes)
- sk_free(context->search_attributes);
- if (context) OPENSSL_free(context);
- return 1;
- }
+{
+ 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 && context->search_attributes)
+ sk_STORE_ATTR_INFO_free(context->search_attributes);
+ if (context)
+ 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_num(context->search_attributes))
- return 1;
- return 0;
- }
-static int mem_lock(STORE *s, OPENSSL_ITEM attributes[])
- {
- return 1;
- }
-static int mem_unlock(STORE *s, OPENSSL_ITEM attributes[])
- {
- return 1;
- }
-static int mem_ctrl(STORE *s, int cmd, long l, void *p, void (*f)())
- {
- return 1;
- }
+{
+ 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;
+}