1 /* crypto/store/str_mem.c */
3 * Written by Richard Levitte (richard@levitte.org) for the OpenSSL project
6 /* ====================================================================
7 * Copyright (c) 2003 The OpenSSL Project. All rights reserved.
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
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
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/)"
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.
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.
35 * 6. Redistributions of any form whatsoever must retain the following
37 * "This product includes software developed by the OpenSSL Project
38 * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
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 * ====================================================================
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).
61 #include <openssl/err.h>
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).
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).
80 typedef struct mem_object_data_st
{
82 STORE_ATTR_INFO
*attr_info
;
86 DEFINE_STACK_OF(MEM_OBJECT_DATA
)
90 * STORE_ATTR_INFO_compare().
92 STACK_OF(MEM_OBJECT_DATA
) *data
;
94 * Currently unused, but can
95 * be used to add attributes
96 * from parts of the data.
98 unsigned int compute_components
:1;
101 DEFINE_STACK_OF(STORE_ATTR_INFO
)
103 /* The type we're searching for */
107 * attributes to search for. Each
108 * element is a STORE_ATTR_INFO.
110 STACK_OF(STORE_ATTR_INFO
) *search_attributes
;
112 * which of the search attributes we
113 * found a match for, -1 when we still
117 /* -1 as long as we're searching for the first */
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
,
124 OPENSSL_ITEM attributes
[],
125 OPENSSL_ITEM parameters
[]);
126 static STORE_OBJECT
*mem_get(STORE
*s
, STORE_OBJECT_TYPES type
,
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
[]);
131 static int mem_modify(STORE
*s
, STORE_OBJECT_TYPES type
,
132 OPENSSL_ITEM search_attributes
[],
133 OPENSSL_ITEM add_attributes
[],
134 OPENSSL_ITEM modify_attributes
[],
135 OPENSSL_ITEM delete_attributes
[],
136 OPENSSL_ITEM parameters
[]);
137 static int mem_delete(STORE
*s
, STORE_OBJECT_TYPES type
,
138 OPENSSL_ITEM attributes
[], OPENSSL_ITEM parameters
[]);
139 static void *mem_list_start(STORE
*s
, STORE_OBJECT_TYPES type
,
140 OPENSSL_ITEM attributes
[],
141 OPENSSL_ITEM parameters
[]);
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
);
145 static int mem_lock(STORE
*s
, OPENSSL_ITEM attributes
[],
146 OPENSSL_ITEM parameters
[]);
147 static int mem_unlock(STORE
*s
, OPENSSL_ITEM attributes
[],
148 OPENSSL_ITEM parameters
[]);
149 static int mem_ctrl(STORE
*s
, int cmd
, long l
, void *p
, void (*f
) (void));
151 static STORE_METHOD store_memory
= {
152 "OpenSSL memory store interface",
171 const STORE_METHOD
*STORE_Memory(void)
173 return &store_memory
;
176 static int mem_init(STORE
*s
)
181 static void mem_clean(STORE
*s
)
186 static STORE_OBJECT
*mem_generate(STORE
*s
, STORE_OBJECT_TYPES type
,
187 OPENSSL_ITEM attributes
[],
188 OPENSSL_ITEM parameters
[])
190 STOREerr(STORE_F_MEM_GENERATE
, STORE_R_NOT_IMPLEMENTED
);
194 static STORE_OBJECT
*mem_get(STORE
*s
, STORE_OBJECT_TYPES type
,
195 OPENSSL_ITEM attributes
[],
196 OPENSSL_ITEM parameters
[])
198 void *context
= mem_list_start(s
, type
, attributes
, parameters
);
201 STORE_OBJECT
*object
= mem_list_next(s
, context
);
203 if (mem_list_end(s
, context
))
209 static int mem_store(STORE
*s
, STORE_OBJECT_TYPES type
,
210 STORE_OBJECT
*data
, OPENSSL_ITEM attributes
[],
211 OPENSSL_ITEM parameters
[])
213 STOREerr(STORE_F_MEM_STORE
, STORE_R_NOT_IMPLEMENTED
);
217 static int mem_modify(STORE
*s
, STORE_OBJECT_TYPES type
,
218 OPENSSL_ITEM search_attributes
[],
219 OPENSSL_ITEM add_attributes
[],
220 OPENSSL_ITEM modify_attributes
[],
221 OPENSSL_ITEM delete_attributes
[],
222 OPENSSL_ITEM parameters
[])
224 STOREerr(STORE_F_MEM_MODIFY
, STORE_R_NOT_IMPLEMENTED
);
228 static int mem_delete(STORE
*s
, STORE_OBJECT_TYPES type
,
229 OPENSSL_ITEM attributes
[], OPENSSL_ITEM parameters
[])
231 STOREerr(STORE_F_MEM_DELETE
, STORE_R_NOT_IMPLEMENTED
);
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...).
243 static void *mem_list_start(STORE
*s
, STORE_OBJECT_TYPES type
,
244 OPENSSL_ITEM attributes
[],
245 OPENSSL_ITEM parameters
[])
247 struct mem_ctx_st
*context
= OPENSSL_zalloc(sizeof(*context
));
248 void *attribute_context
= NULL
;
249 STORE_ATTR_INFO
*attrs
= NULL
;
251 if (context
== NULL
) {
252 STOREerr(STORE_F_MEM_LIST_START
, ERR_R_MALLOC_FAILURE
);
256 attribute_context
= STORE_parse_attrs_start(attributes
);
257 if (!attribute_context
) {
258 STOREerr(STORE_F_MEM_LIST_START
, ERR_R_STORE_LIB
);
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
);
266 if (context
->search_attributes
== NULL
) {
267 STOREerr(STORE_F_MEM_LIST_START
, ERR_R_MALLOC_FAILURE
);
271 sk_STORE_ATTR_INFO_push(context
->search_attributes
, attrs
);
273 if (!STORE_parse_attrs_endp(attribute_context
))
275 STORE_parse_attrs_end(attribute_context
);
276 context
->search_index
= -1;
280 if (attribute_context
)
281 STORE_parse_attrs_end(attribute_context
);
282 mem_list_end(s
, context
);
286 static STORE_OBJECT
*mem_list_next(STORE
*s
, void *handle
)
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);
296 STOREerr(STORE_F_MEM_LIST_NEXT
, ERR_R_PASSED_NULL_PARAMETER
);
300 STOREerr(STORE_F_MEM_LIST_NEXT
, STORE_R_NO_STORE
);
304 if (context
->search_index
== -1) {
306 i
< sk_STORE_ATTR_INFO_num(context
->search_attributes
); i
++) {
308 = sk_STORE_ATTR_INFO_value(context
->search_attributes
, i
);
309 srch
= sk_MEM_OBJECT_DATA_find_ex(store
->data
, &key
);
312 context
->search_index
= srch
;
317 if (context
->search_index
< 0)
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
,
329 STORE_ATTR_INFO_in_ex(key
.attr_info
,
330 sk_MEM_OBJECT_DATA_value(store
->data
,
334 context
->search_index
= srch
;
336 return (sk_MEM_OBJECT_DATA_value(store
->data
, srch
))->object
;
340 static int mem_list_end(STORE
*s
, void *handle
)
342 struct mem_ctx_st
*context
= (struct mem_ctx_st
*)handle
;
345 STOREerr(STORE_F_MEM_LIST_END
, ERR_R_PASSED_NULL_PARAMETER
);
349 sk_STORE_ATTR_INFO_free(context
->search_attributes
);
350 OPENSSL_free(context
);
354 static int mem_list_endp(STORE
*s
, void *handle
)
356 struct mem_ctx_st
*context
= (struct mem_ctx_st
*)handle
;
359 || context
->search_index
360 == sk_STORE_ATTR_INFO_num(context
->search_attributes
))
365 static int mem_lock(STORE
*s
, OPENSSL_ITEM attributes
[],
366 OPENSSL_ITEM parameters
[])
371 static int mem_unlock(STORE
*s
, OPENSSL_ITEM attributes
[],
372 OPENSSL_ITEM parameters
[])
377 static int mem_ctrl(STORE
*s
, int cmd
, long l
, void *p
, void (*f
) (void))