Add and use OPENSSL_zalloc
[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 = OPENSSL_zalloc(sizeof(*context));
248     void *attribute_context = NULL;
249     STORE_ATTR_INFO *attrs = NULL;
250
251     if (!context) {
252         STOREerr(STORE_F_MEM_LIST_START, ERR_R_MALLOC_FAILURE);
253         return 0;
254     }
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);
266             if (!context->search_attributes) {
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;
279  err:
280     if (attribute_context)
281         STORE_parse_attrs_end(attribute_context);
282     mem_list_end(s, context);
283     return NULL;
284 }
285
286 static STORE_OBJECT *mem_list_next(STORE *s, void *handle)
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
340 static int mem_list_end(STORE *s, void *handle)
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     }
348     if (context)
349         sk_STORE_ATTR_INFO_free(context->search_attributes);
350     OPENSSL_free(context);
351     return 1;
352 }
353
354 static int mem_list_endp(STORE *s, void *handle)
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
365 static int mem_lock(STORE *s, OPENSSL_ITEM attributes[],
366                     OPENSSL_ITEM parameters[])
367 {
368     return 1;
369 }
370
371 static int mem_unlock(STORE *s, OPENSSL_ITEM attributes[],
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 }