2 * Written by Richard Levitte (richard@levitte.org) for the OpenSSL project
5 /* ====================================================================
6 * Copyright (c) 2003 The OpenSSL Project. All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in
17 * the documentation and/or other materials provided with the
20 * 3. All advertising materials mentioning features or use of this
21 * software must display the following acknowledgment:
22 * "This product includes software developed by the OpenSSL Project
23 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
25 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26 * endorse or promote products derived from this software without
27 * prior written permission. For written permission, please contact
28 * openssl-core@openssl.org.
30 * 5. Products derived from this software may not be called "OpenSSL"
31 * nor may "OpenSSL" appear in their names without prior written
32 * permission of the OpenSSL Project.
34 * 6. Redistributions of any form whatsoever must retain the following
36 * "This product includes software developed by the OpenSSL Project
37 * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
39 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
43 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50 * OF THE POSSIBILITY OF SUCH DAMAGE.
51 * ====================================================================
53 * This product includes cryptographic software written by Eric Young
54 * (eay@cryptsoft.com). This product includes software written by Tim
55 * Hudson (tjh@cryptsoft.com).
60 #include <openssl/err.h>
64 * The memory store is currently highly experimental. It's meant to become a
65 * base store used by other stores for internal caching (for full caching
66 * support, aging needs to be added).
68 * The database use is meant to support as much attribute association as
69 * possible, while providing for as small search ranges as possible. This is
70 * currently provided for by sorting the entries by numbers that are composed
71 * of bits set at the positions indicated by attribute type codes. This
72 * provides for ranges determined by the highest attribute type code value.
73 * A better idea might be to sort by values computed from the range of
74 * attributes associated with the object (basically, the difference between
75 * the highest and lowest attribute type code) and it's distance from a base
76 * (basically, the lowest associated attribute type code).
79 typedef struct mem_object_data_st {
81 STORE_ATTR_INFO *attr_info;
85 DEFINE_STACK_OF(MEM_OBJECT_DATA)
89 * STORE_ATTR_INFO_compare().
91 STACK_OF(MEM_OBJECT_DATA) *data;
93 * Currently unused, but can
94 * be used to add attributes
95 * from parts of the data.
97 unsigned int compute_components:1;
100 DEFINE_STACK_OF(STORE_ATTR_INFO)
102 /* The type we're searching for */
106 * attributes to search for. Each
107 * element is a STORE_ATTR_INFO.
109 STACK_OF(STORE_ATTR_INFO) *search_attributes;
111 * which of the search attributes we
112 * found a match for, -1 when we still
116 /* -1 as long as we're searching for the first */
120 static int mem_init(STORE *s);
121 static void mem_clean(STORE *s);
122 static STORE_OBJECT *mem_generate(STORE *s, STORE_OBJECT_TYPES type,
123 OPENSSL_ITEM attributes[],
124 OPENSSL_ITEM parameters[]);
125 static STORE_OBJECT *mem_get(STORE *s, STORE_OBJECT_TYPES type,
126 OPENSSL_ITEM attributes[],
127 OPENSSL_ITEM parameters[]);
128 static int mem_store(STORE *s, STORE_OBJECT_TYPES type, STORE_OBJECT *data,
129 OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]);
130 static int mem_modify(STORE *s, STORE_OBJECT_TYPES type,
131 OPENSSL_ITEM search_attributes[],
132 OPENSSL_ITEM add_attributes[],
133 OPENSSL_ITEM modify_attributes[],
134 OPENSSL_ITEM delete_attributes[],
135 OPENSSL_ITEM parameters[]);
136 static int mem_delete(STORE *s, STORE_OBJECT_TYPES type,
137 OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]);
138 static void *mem_list_start(STORE *s, STORE_OBJECT_TYPES type,
139 OPENSSL_ITEM attributes[],
140 OPENSSL_ITEM parameters[]);
141 static STORE_OBJECT *mem_list_next(STORE *s, void *handle);
142 static int mem_list_end(STORE *s, void *handle);
143 static int mem_list_endp(STORE *s, void *handle);
144 static int mem_lock(STORE *s, OPENSSL_ITEM attributes[],
145 OPENSSL_ITEM parameters[]);
146 static int mem_unlock(STORE *s, OPENSSL_ITEM attributes[],
147 OPENSSL_ITEM parameters[]);
148 static int mem_ctrl(STORE *s, int cmd, long l, void *p, void (*f) (void));
150 static STORE_METHOD store_memory = {
151 "OpenSSL memory store interface",
170 const STORE_METHOD *STORE_Memory(void)
172 return &store_memory;
175 static int mem_init(STORE *s)
180 static void mem_clean(STORE *s)
185 static STORE_OBJECT *mem_generate(STORE *s, STORE_OBJECT_TYPES type,
186 OPENSSL_ITEM attributes[],
187 OPENSSL_ITEM parameters[])
189 STOREerr(STORE_F_MEM_GENERATE, STORE_R_NOT_IMPLEMENTED);
193 static STORE_OBJECT *mem_get(STORE *s, STORE_OBJECT_TYPES type,
194 OPENSSL_ITEM attributes[],
195 OPENSSL_ITEM parameters[])
197 void *context = mem_list_start(s, type, attributes, parameters);
200 STORE_OBJECT *object = mem_list_next(s, context);
202 if (mem_list_end(s, context))
208 static int mem_store(STORE *s, STORE_OBJECT_TYPES type,
209 STORE_OBJECT *data, OPENSSL_ITEM attributes[],
210 OPENSSL_ITEM parameters[])
212 STOREerr(STORE_F_MEM_STORE, STORE_R_NOT_IMPLEMENTED);
216 static int mem_modify(STORE *s, STORE_OBJECT_TYPES type,
217 OPENSSL_ITEM search_attributes[],
218 OPENSSL_ITEM add_attributes[],
219 OPENSSL_ITEM modify_attributes[],
220 OPENSSL_ITEM delete_attributes[],
221 OPENSSL_ITEM parameters[])
223 STOREerr(STORE_F_MEM_MODIFY, STORE_R_NOT_IMPLEMENTED);
227 static int mem_delete(STORE *s, STORE_OBJECT_TYPES type,
228 OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[])
230 STOREerr(STORE_F_MEM_DELETE, STORE_R_NOT_IMPLEMENTED);
235 * The list functions may be the hardest to understand. Basically,
236 * mem_list_start compiles a stack of attribute info elements, and puts that
237 * stack into the context to be returned. mem_list_next will then find the
238 * first matching element in the store, and then walk all the way to the end
239 * of the store (since any combination of attribute bits above the starting
240 * point may match the searched for bit pattern...).
242 static void *mem_list_start(STORE *s, STORE_OBJECT_TYPES type,
243 OPENSSL_ITEM attributes[],
244 OPENSSL_ITEM parameters[])
246 struct mem_ctx_st *context = OPENSSL_zalloc(sizeof(*context));
247 void *attribute_context = NULL;
248 STORE_ATTR_INFO *attrs = NULL;
250 if (context == NULL) {
251 STOREerr(STORE_F_MEM_LIST_START, ERR_R_MALLOC_FAILURE);
255 attribute_context = STORE_parse_attrs_start(attributes);
256 if (!attribute_context) {
257 STOREerr(STORE_F_MEM_LIST_START, ERR_R_STORE_LIB);
261 while ((attrs = STORE_parse_attrs_next(attribute_context))) {
262 if (context->search_attributes == NULL) {
263 context->search_attributes =
264 sk_STORE_ATTR_INFO_new(STORE_ATTR_INFO_compare);
265 if (context->search_attributes == NULL) {
266 STOREerr(STORE_F_MEM_LIST_START, ERR_R_MALLOC_FAILURE);
270 sk_STORE_ATTR_INFO_push(context->search_attributes, attrs);
272 if (!STORE_parse_attrs_endp(attribute_context))
274 STORE_parse_attrs_end(attribute_context);
275 context->search_index = -1;
279 if (attribute_context)
280 STORE_parse_attrs_end(attribute_context);
281 mem_list_end(s, context);
285 static STORE_OBJECT *mem_list_next(STORE *s, void *handle)
288 struct mem_ctx_st *context = (struct mem_ctx_st *)handle;
289 struct mem_object_data_st key = { 0, 0, 1 };
290 struct mem_data_st *store = (struct mem_data_st *)STORE_get_ex_data(s, 1);
295 STOREerr(STORE_F_MEM_LIST_NEXT, ERR_R_PASSED_NULL_PARAMETER);
299 STOREerr(STORE_F_MEM_LIST_NEXT, STORE_R_NO_STORE);
303 if (context->search_index == -1) {
305 i < sk_STORE_ATTR_INFO_num(context->search_attributes); i++) {
307 = sk_STORE_ATTR_INFO_value(context->search_attributes, i);
308 srch = sk_MEM_OBJECT_DATA_find_ex(store->data, &key);
311 context->search_index = srch;
316 if (context->search_index < 0)
320 sk_STORE_ATTR_INFO_value(context->search_attributes,
321 context->search_index);
322 for (srch = context->search_index;
323 srch < sk_MEM_OBJECT_DATA_num(store->data)
324 && STORE_ATTR_INFO_in_range(key.attr_info,
325 sk_MEM_OBJECT_DATA_value(store->data,
328 STORE_ATTR_INFO_in_ex(key.attr_info,
329 sk_MEM_OBJECT_DATA_value(store->data,
333 context->search_index = srch;
335 return (sk_MEM_OBJECT_DATA_value(store->data, srch))->object;
339 static int mem_list_end(STORE *s, void *handle)
341 struct mem_ctx_st *context = (struct mem_ctx_st *)handle;
344 STOREerr(STORE_F_MEM_LIST_END, ERR_R_PASSED_NULL_PARAMETER);
348 sk_STORE_ATTR_INFO_free(context->search_attributes);
349 OPENSSL_free(context);
353 static int mem_list_endp(STORE *s, void *handle)
355 struct mem_ctx_st *context = (struct mem_ctx_st *)handle;
358 || context->search_index
359 == sk_STORE_ATTR_INFO_num(context->search_attributes))
364 static int mem_lock(STORE *s, OPENSSL_ITEM attributes[],
365 OPENSSL_ITEM parameters[])
370 static int mem_unlock(STORE *s, OPENSSL_ITEM attributes[],
371 OPENSSL_ITEM parameters[])
376 static int mem_ctrl(STORE *s, int cmd, long l, void *p, void (*f) (void))