8edd0eb41b1296c3db432fe4d7ceb427c3359f3c
[openssl.git] / crypto / store / str_mem.c
1 /* crypto/store/str_mem.c -*- mode:C; c-file-style: "eay" -*- */
2 /*
3  * Written by Richard Levitte (richard@levitte.org) for the OpenSSL project
4  * 2003.
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
14  *    notice, this list of conditions and the following disclaimer.
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
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;
85
86 DECLARE_STACK_OF(MEM_OBJECT_DATA)
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 };
100
101 DECLARE_STACK_OF(STORE_ATTR_INFO)
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 };
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,
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));
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 };
170
171 const STORE_METHOD *STORE_Memory(void)
172 {
173     return &store_memory;
174 }
175
176 static int mem_init(STORE *s)
177 {
178     return 1;
179 }
180
181 static void mem_clean(STORE *s)
182 {
183     return;
184 }
185
186 static STORE_OBJECT *mem_generate(STORE *s, STORE_OBJECT_TYPES type,
187                                   OPENSSL_ITEM attributes[],
188                                   OPENSSL_ITEM parameters[])
189 {
190     STOREerr(STORE_F_MEM_GENERATE, STORE_R_NOT_IMPLEMENTED);
191     return 0;
192 }
193
194 static STORE_OBJECT *mem_get(STORE *s, STORE_OBJECT_TYPES type,
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
209 static int mem_store(STORE *s, STORE_OBJECT_TYPES type,
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
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[])
223 {
224     STOREerr(STORE_F_MEM_MODIFY, STORE_R_NOT_IMPLEMENTED);
225     return 0;
226 }
227
228 static int mem_delete(STORE *s, STORE_OBJECT_TYPES type,
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  */
243 static void *mem_list_start(STORE *s, STORE_OBJECT_TYPES type,
244                             OPENSSL_ITEM attributes[],
245                             OPENSSL_ITEM parameters[])
246 {
247     struct mem_ctx_st *context =
248         (struct mem_ctx_st *)OPENSSL_malloc(sizeof(struct mem_ctx_st));
249     void *attribute_context = NULL;
250     STORE_ATTR_INFO *attrs = NULL;
251
252     if (!context) {
253         STOREerr(STORE_F_MEM_LIST_START, ERR_R_MALLOC_FAILURE);
254         return 0;
255     }
256     memset(context, 0, sizeof(struct mem_ctx_st));
257
258     attribute_context = STORE_parse_attrs_start(attributes);
259     if (!attribute_context) {
260         STOREerr(STORE_F_MEM_LIST_START, ERR_R_STORE_LIB);
261         goto err;
262     }
263
264     while ((attrs = STORE_parse_attrs_next(attribute_context))) {
265         if (context->search_attributes == NULL) {
266             context->search_attributes =
267                 sk_STORE_ATTR_INFO_new(STORE_ATTR_INFO_compare);
268             if (!context->search_attributes) {
269                 STOREerr(STORE_F_MEM_LIST_START, ERR_R_MALLOC_FAILURE);
270                 goto err;
271             }
272         }
273         sk_STORE_ATTR_INFO_push(context->search_attributes, attrs);
274     }
275     if (!STORE_parse_attrs_endp(attribute_context))
276         goto err;
277     STORE_parse_attrs_end(attribute_context);
278     context->search_index = -1;
279     context->index = -1;
280     return context;
281  err:
282     if (attribute_context)
283         STORE_parse_attrs_end(attribute_context);
284     mem_list_end(s, context);
285     return NULL;
286 }
287
288 static STORE_OBJECT *mem_list_next(STORE *s, void *handle)
289 {
290     int i;
291     struct mem_ctx_st *context = (struct mem_ctx_st *)handle;
292     struct mem_object_data_st key = { 0, 0, 1 };
293     struct mem_data_st *store = (struct mem_data_st *)STORE_get_ex_data(s, 1);
294     int srch;
295     int cres = 0;
296
297     if (!context) {
298         STOREerr(STORE_F_MEM_LIST_NEXT, ERR_R_PASSED_NULL_PARAMETER);
299         return NULL;
300     }
301     if (!store) {
302         STOREerr(STORE_F_MEM_LIST_NEXT, STORE_R_NO_STORE);
303         return NULL;
304     }
305
306     if (context->search_index == -1) {
307         for (i = 0;
308              i < sk_STORE_ATTR_INFO_num(context->search_attributes); i++) {
309             key.attr_info
310                 = sk_STORE_ATTR_INFO_value(context->search_attributes, i);
311             srch = sk_MEM_OBJECT_DATA_find_ex(store->data, &key);
312
313             if (srch >= 0) {
314                 context->search_index = srch;
315                 break;
316             }
317         }
318     }
319     if (context->search_index < 0)
320         return NULL;
321
322     key.attr_info =
323         sk_STORE_ATTR_INFO_value(context->search_attributes,
324                                  context->search_index);
325     for (srch = context->search_index;
326          srch < sk_MEM_OBJECT_DATA_num(store->data)
327          && STORE_ATTR_INFO_in_range(key.attr_info,
328                                      sk_MEM_OBJECT_DATA_value(store->data,
329                                                               srch)->attr_info)
330          && !(cres =
331               STORE_ATTR_INFO_in_ex(key.attr_info,
332                                     sk_MEM_OBJECT_DATA_value(store->data,
333                                                              srch)->attr_info));
334          srch++) ;
335
336     context->search_index = srch;
337     if (cres)
338         return (sk_MEM_OBJECT_DATA_value(store->data, srch))->object;
339     return NULL;
340 }
341
342 static int mem_list_end(STORE *s, void *handle)
343 {
344     struct mem_ctx_st *context = (struct mem_ctx_st *)handle;
345
346     if (!context) {
347         STOREerr(STORE_F_MEM_LIST_END, ERR_R_PASSED_NULL_PARAMETER);
348         return 0;
349     }
350     if (context && context->search_attributes)
351         sk_STORE_ATTR_INFO_free(context->search_attributes);
352     if (context)
353         OPENSSL_free(context);
354     return 1;
355 }
356
357 static int mem_list_endp(STORE *s, void *handle)
358 {
359     struct mem_ctx_st *context = (struct mem_ctx_st *)handle;
360
361     if (!context
362         || context->search_index
363         == sk_STORE_ATTR_INFO_num(context->search_attributes))
364         return 1;
365     return 0;
366 }
367
368 static int mem_lock(STORE *s, OPENSSL_ITEM attributes[],
369                     OPENSSL_ITEM parameters[])
370 {
371     return 1;
372 }
373
374 static int mem_unlock(STORE *s, OPENSSL_ITEM attributes[],
375                       OPENSSL_ITEM parameters[])
376 {
377     return 1;
378 }
379
380 static int mem_ctrl(STORE *s, int cmd, long l, void *p, void (*f) (void))
381 {
382     return 1;
383 }