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