Line data Source code
1 : #include <stdio.h>
2 : #include <stdlib.h>
3 : #include <string.h>
4 :
5 : #include <openssl/err.h>
6 : #include <openssl/lhash.h>
7 : #include <openssl/objects.h>
8 : #include <openssl/safestack.h>
9 : #include <openssl/e_os2.h>
10 :
11 : /*
12 : * Later versions of DEC C has started to add lnkage information to certain
13 : * functions, which makes it tricky to use them as values to regular function
14 : * pointers. One way is to define a macro that takes care of casting them
15 : * correctly.
16 : */
17 : #ifdef OPENSSL_SYS_VMS_DECC
18 : # define OPENSSL_strcmp (int (*)(const char *,const char *))strcmp
19 : #else
20 : # define OPENSSL_strcmp strcmp
21 : #endif
22 :
23 : /*
24 : * I use the ex_data stuff to manage the identifiers for the obj_name_types
25 : * that applications may define. I only really use the free function field.
26 : */
27 : DECLARE_LHASH_OF(OBJ_NAME);
28 : static LHASH_OF(OBJ_NAME) *names_lh = NULL;
29 : static int names_type_num = OBJ_NAME_TYPE_NUM;
30 :
31 : typedef struct name_funcs_st {
32 : unsigned long (*hash_func) (const char *name);
33 : int (*cmp_func) (const char *a, const char *b);
34 : void (*free_func) (const char *, int, const char *);
35 : } NAME_FUNCS;
36 :
37 : DECLARE_STACK_OF(NAME_FUNCS)
38 : IMPLEMENT_STACK_OF(NAME_FUNCS)
39 :
40 : static STACK_OF(NAME_FUNCS) *name_funcs_stack;
41 :
42 : /*
43 : * The LHASH callbacks now use the raw "void *" prototypes and do
44 : * per-variable casting in the functions. This prevents function pointer
45 : * casting without the need for macro-generated wrapper functions.
46 : */
47 :
48 : /* static unsigned long obj_name_hash(OBJ_NAME *a); */
49 : static unsigned long obj_name_hash(const void *a_void);
50 : /* static int obj_name_cmp(OBJ_NAME *a,OBJ_NAME *b); */
51 : static int obj_name_cmp(const void *a_void, const void *b_void);
52 :
53 49404 : static IMPLEMENT_LHASH_HASH_FN(obj_name, OBJ_NAME)
54 16371 : static IMPLEMENT_LHASH_COMP_FN(obj_name, OBJ_NAME)
55 :
56 121 : int OBJ_NAME_init(void)
57 : {
58 121 : if (names_lh != NULL)
59 : return (1);
60 121 : MemCheck_off();
61 121 : names_lh = lh_OBJ_NAME_new();
62 121 : MemCheck_on();
63 121 : return (names_lh != NULL);
64 : }
65 :
66 0 : int OBJ_NAME_new_index(unsigned long (*hash_func) (const char *),
67 : int (*cmp_func) (const char *, const char *),
68 : void (*free_func) (const char *, int, const char *))
69 : {
70 : int ret;
71 : int i;
72 : NAME_FUNCS *name_funcs;
73 :
74 0 : if (name_funcs_stack == NULL) {
75 0 : MemCheck_off();
76 0 : name_funcs_stack = sk_NAME_FUNCS_new_null();
77 0 : MemCheck_on();
78 : }
79 0 : if (name_funcs_stack == NULL) {
80 : /* ERROR */
81 : return (0);
82 : }
83 0 : ret = names_type_num;
84 0 : names_type_num++;
85 0 : for (i = sk_NAME_FUNCS_num(name_funcs_stack); i < names_type_num; i++) {
86 0 : MemCheck_off();
87 0 : name_funcs = OPENSSL_malloc(sizeof(NAME_FUNCS));
88 0 : MemCheck_on();
89 0 : if (!name_funcs) {
90 0 : OBJerr(OBJ_F_OBJ_NAME_NEW_INDEX, ERR_R_MALLOC_FAILURE);
91 0 : return (0);
92 : }
93 0 : name_funcs->hash_func = lh_strhash;
94 0 : name_funcs->cmp_func = OPENSSL_strcmp;
95 0 : name_funcs->free_func = 0; /* NULL is often declared to * ((void
96 : * *)0), which according * to Compaq C is
97 : * not really * compatible with a function
98 : * * pointer. -- Richard Levitte */
99 0 : MemCheck_off();
100 0 : sk_NAME_FUNCS_push(name_funcs_stack, name_funcs);
101 0 : MemCheck_on();
102 : }
103 0 : name_funcs = sk_NAME_FUNCS_value(name_funcs_stack, ret);
104 0 : if (hash_func != NULL)
105 0 : name_funcs->hash_func = hash_func;
106 0 : if (cmp_func != NULL)
107 0 : name_funcs->cmp_func = cmp_func;
108 0 : if (free_func != NULL)
109 0 : name_funcs->free_func = free_func;
110 0 : return (ret);
111 : }
112 :
113 : /* static int obj_name_cmp(OBJ_NAME *a, OBJ_NAME *b) */
114 16371 : static int obj_name_cmp(const void *a_void, const void *b_void)
115 : {
116 : int ret;
117 : const OBJ_NAME *a = (const OBJ_NAME *)a_void;
118 : const OBJ_NAME *b = (const OBJ_NAME *)b_void;
119 :
120 16371 : ret = a->type - b->type;
121 16371 : if (ret == 0) {
122 16371 : if ((name_funcs_stack != NULL)
123 0 : && (sk_NAME_FUNCS_num(name_funcs_stack) > a->type)) {
124 0 : ret = sk_NAME_FUNCS_value(name_funcs_stack,
125 0 : a->type)->cmp_func(a->name, b->name);
126 : } else
127 16371 : ret = strcmp(a->name, b->name);
128 : }
129 16371 : return (ret);
130 : }
131 :
132 : /* static unsigned long obj_name_hash(OBJ_NAME *a) */
133 49404 : static unsigned long obj_name_hash(const void *a_void)
134 : {
135 : unsigned long ret;
136 : const OBJ_NAME *a = (const OBJ_NAME *)a_void;
137 :
138 49404 : if ((name_funcs_stack != NULL)
139 0 : && (sk_NAME_FUNCS_num(name_funcs_stack) > a->type)) {
140 0 : ret =
141 0 : sk_NAME_FUNCS_value(name_funcs_stack,
142 0 : a->type)->hash_func(a->name);
143 : } else {
144 49404 : ret = lh_strhash(a->name);
145 : }
146 49404 : ret ^= a->type;
147 49404 : return (ret);
148 : }
149 :
150 5285 : const char *OBJ_NAME_get(const char *name, int type)
151 : {
152 : OBJ_NAME on, *ret;
153 : int num = 0, alias;
154 :
155 5285 : if (name == NULL)
156 : return (NULL);
157 5285 : if ((names_lh == NULL) && !OBJ_NAME_init())
158 : return (NULL);
159 :
160 5285 : alias = type & OBJ_NAME_ALIAS;
161 5285 : type &= ~OBJ_NAME_ALIAS;
162 :
163 5285 : on.name = name;
164 5285 : on.type = type;
165 :
166 : for (;;) {
167 7901 : ret = lh_OBJ_NAME_retrieve(names_lh, &on);
168 7901 : if (ret == NULL)
169 : return (NULL);
170 7538 : if ((ret->alias) && !alias) {
171 2616 : if (++num > 10)
172 : return (NULL);
173 2616 : on.name = ret->data;
174 : } else {
175 4922 : return (ret->data);
176 : }
177 2616 : }
178 : }
179 :
180 41503 : int OBJ_NAME_add(const char *name, int type, const char *data)
181 : {
182 : OBJ_NAME *onp, *ret;
183 : int alias;
184 :
185 41503 : if ((names_lh == NULL) && !OBJ_NAME_init())
186 : return (0);
187 :
188 41503 : alias = type & OBJ_NAME_ALIAS;
189 41503 : type &= ~OBJ_NAME_ALIAS;
190 :
191 41503 : onp = (OBJ_NAME *)OPENSSL_malloc(sizeof(OBJ_NAME));
192 41503 : if (onp == NULL) {
193 : /* ERROR */
194 : return (0);
195 : }
196 :
197 41503 : onp->name = name;
198 41503 : onp->alias = alias;
199 41503 : onp->type = type;
200 41503 : onp->data = data;
201 :
202 41503 : ret = lh_OBJ_NAME_insert(names_lh, onp);
203 41503 : if (ret != NULL) {
204 : /* free things */
205 8833 : if ((name_funcs_stack != NULL)
206 0 : && (sk_NAME_FUNCS_num(name_funcs_stack) > ret->type)) {
207 : /*
208 : * XXX: I'm not sure I understand why the free function should
209 : * get three arguments... -- Richard Levitte
210 : */
211 0 : sk_NAME_FUNCS_value(name_funcs_stack,
212 0 : ret->type)->free_func(ret->name, ret->type,
213 : ret->data);
214 : }
215 8833 : OPENSSL_free(ret);
216 : } else {
217 32670 : if (lh_OBJ_NAME_error(names_lh)) {
218 : /* ERROR */
219 : return (0);
220 : }
221 : }
222 : return (1);
223 : }
224 :
225 0 : int OBJ_NAME_remove(const char *name, int type)
226 : {
227 : OBJ_NAME on, *ret;
228 :
229 0 : if (names_lh == NULL)
230 : return (0);
231 :
232 0 : type &= ~OBJ_NAME_ALIAS;
233 0 : on.name = name;
234 0 : on.type = type;
235 0 : ret = lh_OBJ_NAME_delete(names_lh, &on);
236 0 : if (ret != NULL) {
237 : /* free things */
238 0 : if ((name_funcs_stack != NULL)
239 0 : && (sk_NAME_FUNCS_num(name_funcs_stack) > ret->type)) {
240 : /*
241 : * XXX: I'm not sure I understand why the free function should
242 : * get three arguments... -- Richard Levitte
243 : */
244 0 : sk_NAME_FUNCS_value(name_funcs_stack,
245 0 : ret->type)->free_func(ret->name, ret->type,
246 : ret->data);
247 : }
248 0 : OPENSSL_free(ret);
249 0 : return (1);
250 : } else
251 : return (0);
252 : }
253 :
254 : struct doall {
255 : int type;
256 : void (*fn) (const OBJ_NAME *, void *arg);
257 : void *arg;
258 : };
259 :
260 : static void do_all_fn_doall_arg(const OBJ_NAME *name, struct doall *d)
261 : {
262 0 : if (name->type == d->type)
263 0 : d->fn(name, d->arg);
264 : }
265 :
266 0 : static IMPLEMENT_LHASH_DOALL_ARG_FN(do_all_fn, const OBJ_NAME, struct doall)
267 :
268 0 : void OBJ_NAME_do_all(int type, void (*fn) (const OBJ_NAME *, void *arg),
269 : void *arg)
270 : {
271 : struct doall d;
272 :
273 0 : d.type = type;
274 0 : d.fn = fn;
275 0 : d.arg = arg;
276 :
277 0 : lh_OBJ_NAME_doall_arg(names_lh, LHASH_DOALL_ARG_FN(do_all_fn),
278 : struct doall, &d);
279 0 : }
280 :
281 : struct doall_sorted {
282 : int type;
283 : int n;
284 : const OBJ_NAME **names;
285 : };
286 :
287 0 : static void do_all_sorted_fn(const OBJ_NAME *name, void *d_)
288 : {
289 : struct doall_sorted *d = d_;
290 :
291 0 : if (name->type != d->type)
292 0 : return;
293 :
294 0 : d->names[d->n++] = name;
295 : }
296 :
297 0 : static int do_all_sorted_cmp(const void *n1_, const void *n2_)
298 : {
299 : const OBJ_NAME *const *n1 = n1_;
300 : const OBJ_NAME *const *n2 = n2_;
301 :
302 0 : return strcmp((*n1)->name, (*n2)->name);
303 : }
304 :
305 0 : void OBJ_NAME_do_all_sorted(int type,
306 : void (*fn) (const OBJ_NAME *, void *arg),
307 : void *arg)
308 : {
309 : struct doall_sorted d;
310 : int n;
311 :
312 0 : d.type = type;
313 0 : d.names =
314 0 : OPENSSL_malloc(lh_OBJ_NAME_num_items(names_lh) * sizeof *d.names);
315 : /* Really should return an error if !d.names...but its a void function! */
316 0 : if (d.names) {
317 0 : d.n = 0;
318 : OBJ_NAME_do_all(type, do_all_sorted_fn, &d);
319 :
320 0 : qsort((void *)d.names, d.n, sizeof *d.names, do_all_sorted_cmp);
321 :
322 0 : for (n = 0; n < d.n; ++n)
323 0 : fn(d.names[n], arg);
324 :
325 0 : OPENSSL_free((void *)d.names);
326 : }
327 0 : }
328 :
329 : static int free_type;
330 :
331 0 : static void names_lh_free_doall(OBJ_NAME *onp)
332 : {
333 0 : if (onp == NULL)
334 0 : return;
335 :
336 0 : if (free_type < 0 || free_type == onp->type)
337 0 : OBJ_NAME_remove(onp->name, onp->type);
338 : }
339 :
340 0 : static IMPLEMENT_LHASH_DOALL_FN(names_lh_free, OBJ_NAME)
341 :
342 0 : static void name_funcs_free(NAME_FUNCS *ptr)
343 : {
344 0 : OPENSSL_free(ptr);
345 0 : }
346 :
347 0 : void OBJ_NAME_cleanup(int type)
348 : {
349 : unsigned long down_load;
350 :
351 0 : if (names_lh == NULL)
352 0 : return;
353 :
354 0 : free_type = type;
355 0 : down_load = lh_OBJ_NAME_down_load(names_lh);
356 0 : lh_OBJ_NAME_down_load(names_lh) = 0;
357 :
358 0 : lh_OBJ_NAME_doall(names_lh, LHASH_DOALL_FN(names_lh_free));
359 0 : if (type < 0) {
360 0 : lh_OBJ_NAME_free(names_lh);
361 0 : sk_NAME_FUNCS_pop_free(name_funcs_stack, name_funcs_free);
362 0 : names_lh = NULL;
363 0 : name_funcs_stack = NULL;
364 : } else
365 0 : lh_OBJ_NAME_down_load(names_lh) = down_load;
366 : }
|
