1 /*
2 * Copyright 1998-2022 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <string.h>
13
14 #include <openssl/err.h>
15 #include <openssl/lhash.h>
16 #include <openssl/objects.h>
17 #include <openssl/safestack.h>
18 #include <openssl/e_os2.h>
19 #include "internal/thread_once.h"
20 #include "crypto/lhash.h"
21 #include "obj_local.h"
22 #include "e_os.h"
23
24 /*
25 * I use the ex_data stuff to manage the identifiers for the obj_name_types
26 * that applications may define. I only really use the free function field.
27 */
28 static LHASH_OF(OBJ_NAME) *names_lh = NULL;
29 static int names_type_num = OBJ_NAME_TYPE_NUM;
30 static CRYPTO_RWLOCK *obj_lock = NULL;
31
32 struct name_funcs_st {
33 unsigned long (*hash_func) (const char *name);
34 int (*cmp_func) (const char *a, const char *b);
35 void (*free_func) (const char *, int, const char *);
36 };
37
38 static STACK_OF(NAME_FUNCS) *name_funcs_stack;
39
40 /*
41 * The LHASH callbacks now use the raw "void *" prototypes and do
42 * per-variable casting in the functions. This prevents function pointer
43 * casting without the need for macro-generated wrapper functions.
44 */
45
46 static unsigned long obj_name_hash(const OBJ_NAME *a);
47 static int obj_name_cmp(const OBJ_NAME *a, const OBJ_NAME *b);
48
49 static CRYPTO_ONCE init = CRYPTO_ONCE_STATIC_INIT;
DEFINE_RUN_ONCE_STATIC(o_names_init)50 DEFINE_RUN_ONCE_STATIC(o_names_init)
51 {
52 names_lh = NULL;
53 obj_lock = CRYPTO_THREAD_lock_new();
54 if (obj_lock != NULL)
55 names_lh = lh_OBJ_NAME_new(obj_name_hash, obj_name_cmp);
56 if (names_lh == NULL) {
57 CRYPTO_THREAD_lock_free(obj_lock);
58 obj_lock = NULL;
59 }
60 return names_lh != NULL && obj_lock != NULL;
61 }
62
OBJ_NAME_init(void)63 int OBJ_NAME_init(void)
64 {
65 return RUN_ONCE(&init, o_names_init);
66 }
67
OBJ_NAME_new_index(unsigned long (* hash_func)(const char *),int (* cmp_func)(const char *,const char *),void (* free_func)(const char *,int,const char *))68 int OBJ_NAME_new_index(unsigned long (*hash_func) (const char *),
69 int (*cmp_func) (const char *, const char *),
70 void (*free_func) (const char *, int, const char *))
71 {
72 int ret = 0, i, push;
73 NAME_FUNCS *name_funcs;
74
75 if (!OBJ_NAME_init())
76 return 0;
77
78 if (!CRYPTO_THREAD_write_lock(obj_lock))
79 return 0;
80
81 if (name_funcs_stack == NULL)
82 name_funcs_stack = sk_NAME_FUNCS_new_null();
83 if (name_funcs_stack == NULL) {
84 /* ERROR */
85 goto out;
86 }
87 ret = names_type_num;
88 names_type_num++;
89 for (i = sk_NAME_FUNCS_num(name_funcs_stack); i < names_type_num; i++) {
90 name_funcs = OPENSSL_zalloc(sizeof(*name_funcs));
91 if (name_funcs == NULL) {
92 ERR_raise(ERR_LIB_OBJ, ERR_R_MALLOC_FAILURE);
93 ret = 0;
94 goto out;
95 }
96 name_funcs->hash_func = ossl_lh_strcasehash;
97 name_funcs->cmp_func = OPENSSL_strcasecmp;
98 push = sk_NAME_FUNCS_push(name_funcs_stack, name_funcs);
99
100 if (!push) {
101 ERR_raise(ERR_LIB_OBJ, ERR_R_MALLOC_FAILURE);
102 OPENSSL_free(name_funcs);
103 ret = 0;
104 goto out;
105 }
106 }
107 name_funcs = sk_NAME_FUNCS_value(name_funcs_stack, ret);
108 if (hash_func != NULL)
109 name_funcs->hash_func = hash_func;
110 if (cmp_func != NULL)
111 name_funcs->cmp_func = cmp_func;
112 if (free_func != NULL)
113 name_funcs->free_func = free_func;
114
115 out:
116 CRYPTO_THREAD_unlock(obj_lock);
117 return ret;
118 }
119
obj_name_cmp(const OBJ_NAME * a,const OBJ_NAME * b)120 static int obj_name_cmp(const OBJ_NAME *a, const OBJ_NAME *b)
121 {
122 int ret;
123
124 ret = a->type - b->type;
125 if (ret == 0) {
126 if ((name_funcs_stack != NULL)
127 && (sk_NAME_FUNCS_num(name_funcs_stack) > a->type)) {
128 ret = sk_NAME_FUNCS_value(name_funcs_stack,
129 a->type)->cmp_func(a->name, b->name);
130 } else
131 ret = OPENSSL_strcasecmp(a->name, b->name);
132 }
133 return ret;
134 }
135
obj_name_hash(const OBJ_NAME * a)136 static unsigned long obj_name_hash(const OBJ_NAME *a)
137 {
138 unsigned long ret;
139
140 if ((name_funcs_stack != NULL)
141 && (sk_NAME_FUNCS_num(name_funcs_stack) > a->type)) {
142 ret =
143 sk_NAME_FUNCS_value(name_funcs_stack,
144 a->type)->hash_func(a->name);
145 } else {
146 ret = ossl_lh_strcasehash(a->name);
147 }
148 ret ^= a->type;
149 return ret;
150 }
151
OBJ_NAME_get(const char * name,int type)152 const char *OBJ_NAME_get(const char *name, int type)
153 {
154 OBJ_NAME on, *ret;
155 int num = 0, alias;
156 const char *value = NULL;
157
158 if (name == NULL)
159 return NULL;
160 if (!OBJ_NAME_init())
161 return NULL;
162 if (!CRYPTO_THREAD_read_lock(obj_lock))
163 return NULL;
164
165 alias = type & OBJ_NAME_ALIAS;
166 type &= ~OBJ_NAME_ALIAS;
167
168 on.name = name;
169 on.type = type;
170
171 for (;;) {
172 ret = lh_OBJ_NAME_retrieve(names_lh, &on);
173 if (ret == NULL)
174 break;
175 if ((ret->alias) && !alias) {
176 if (++num > 10)
177 break;
178 on.name = ret->data;
179 } else {
180 value = ret->data;
181 break;
182 }
183 }
184
185 CRYPTO_THREAD_unlock(obj_lock);
186 return value;
187 }
188
OBJ_NAME_add(const char * name,int type,const char * data)189 int OBJ_NAME_add(const char *name, int type, const char *data)
190 {
191 OBJ_NAME *onp, *ret;
192 int alias, ok = 0;
193
194 if (!OBJ_NAME_init())
195 return 0;
196
197 alias = type & OBJ_NAME_ALIAS;
198 type &= ~OBJ_NAME_ALIAS;
199
200 onp = OPENSSL_malloc(sizeof(*onp));
201 if (onp == NULL)
202 return 0;
203
204 onp->name = name;
205 onp->alias = alias;
206 onp->type = type;
207 onp->data = data;
208
209 if (!CRYPTO_THREAD_write_lock(obj_lock)) {
210 OPENSSL_free(onp);
211 return 0;
212 }
213
214 ret = lh_OBJ_NAME_insert(names_lh, onp);
215 if (ret != NULL) {
216 /* free things */
217 if ((name_funcs_stack != NULL)
218 && (sk_NAME_FUNCS_num(name_funcs_stack) > ret->type)) {
219 /*
220 * XXX: I'm not sure I understand why the free function should
221 * get three arguments... -- Richard Levitte
222 */
223 sk_NAME_FUNCS_value(name_funcs_stack,
224 ret->type)->free_func(ret->name, ret->type,
225 ret->data);
226 }
227 OPENSSL_free(ret);
228 } else {
229 if (lh_OBJ_NAME_error(names_lh)) {
230 /* ERROR */
231 OPENSSL_free(onp);
232 goto unlock;
233 }
234 }
235
236 ok = 1;
237
238 unlock:
239 CRYPTO_THREAD_unlock(obj_lock);
240 return ok;
241 }
242
OBJ_NAME_remove(const char * name,int type)243 int OBJ_NAME_remove(const char *name, int type)
244 {
245 OBJ_NAME on, *ret;
246 int ok = 0;
247
248 if (!OBJ_NAME_init())
249 return 0;
250
251 if (!CRYPTO_THREAD_write_lock(obj_lock))
252 return 0;
253
254 type &= ~OBJ_NAME_ALIAS;
255 on.name = name;
256 on.type = type;
257 ret = lh_OBJ_NAME_delete(names_lh, &on);
258 if (ret != NULL) {
259 /* free things */
260 if ((name_funcs_stack != NULL)
261 && (sk_NAME_FUNCS_num(name_funcs_stack) > ret->type)) {
262 /*
263 * XXX: I'm not sure I understand why the free function should
264 * get three arguments... -- Richard Levitte
265 */
266 sk_NAME_FUNCS_value(name_funcs_stack,
267 ret->type)->free_func(ret->name, ret->type,
268 ret->data);
269 }
270 OPENSSL_free(ret);
271 ok = 1;
272 }
273
274 CRYPTO_THREAD_unlock(obj_lock);
275 return ok;
276 }
277
278 typedef struct {
279 int type;
280 void (*fn) (const OBJ_NAME *, void *arg);
281 void *arg;
282 } OBJ_DOALL;
283
do_all_fn(const OBJ_NAME * name,OBJ_DOALL * d)284 static void do_all_fn(const OBJ_NAME *name, OBJ_DOALL *d)
285 {
286 if (name->type == d->type)
287 d->fn(name, d->arg);
288 }
289
290 IMPLEMENT_LHASH_DOALL_ARG_CONST(OBJ_NAME, OBJ_DOALL);
291
OBJ_NAME_do_all(int type,void (* fn)(const OBJ_NAME *,void * arg),void * arg)292 void OBJ_NAME_do_all(int type, void (*fn) (const OBJ_NAME *, void *arg),
293 void *arg)
294 {
295 OBJ_DOALL d;
296
297 d.type = type;
298 d.fn = fn;
299 d.arg = arg;
300
301 lh_OBJ_NAME_doall_OBJ_DOALL(names_lh, do_all_fn, &d);
302 }
303
304 struct doall_sorted {
305 int type;
306 int n;
307 const OBJ_NAME **names;
308 };
309
do_all_sorted_fn(const OBJ_NAME * name,void * d_)310 static void do_all_sorted_fn(const OBJ_NAME *name, void *d_)
311 {
312 struct doall_sorted *d = d_;
313
314 if (name->type != d->type)
315 return;
316
317 d->names[d->n++] = name;
318 }
319
do_all_sorted_cmp(const void * n1_,const void * n2_)320 static int do_all_sorted_cmp(const void *n1_, const void *n2_)
321 {
322 const OBJ_NAME *const *n1 = n1_;
323 const OBJ_NAME *const *n2 = n2_;
324
325 return strcmp((*n1)->name, (*n2)->name);
326 }
327
OBJ_NAME_do_all_sorted(int type,void (* fn)(const OBJ_NAME *,void * arg),void * arg)328 void OBJ_NAME_do_all_sorted(int type,
329 void (*fn) (const OBJ_NAME *, void *arg),
330 void *arg)
331 {
332 struct doall_sorted d;
333 int n;
334
335 d.type = type;
336 d.names =
337 OPENSSL_malloc(sizeof(*d.names) * lh_OBJ_NAME_num_items(names_lh));
338 /* Really should return an error if !d.names...but its a void function! */
339 if (d.names != NULL) {
340 d.n = 0;
341 OBJ_NAME_do_all(type, do_all_sorted_fn, &d);
342
343 qsort((void *)d.names, d.n, sizeof(*d.names), do_all_sorted_cmp);
344
345 for (n = 0; n < d.n; ++n)
346 fn(d.names[n], arg);
347
348 OPENSSL_free((void *)d.names);
349 }
350 }
351
352 static int free_type;
353
names_lh_free_doall(OBJ_NAME * onp)354 static void names_lh_free_doall(OBJ_NAME *onp)
355 {
356 if (onp == NULL)
357 return;
358
359 if (free_type < 0 || free_type == onp->type)
360 OBJ_NAME_remove(onp->name, onp->type);
361 }
362
name_funcs_free(NAME_FUNCS * ptr)363 static void name_funcs_free(NAME_FUNCS *ptr)
364 {
365 OPENSSL_free(ptr);
366 }
367
OBJ_NAME_cleanup(int type)368 void OBJ_NAME_cleanup(int type)
369 {
370 unsigned long down_load;
371
372 if (names_lh == NULL)
373 return;
374
375 free_type = type;
376 down_load = lh_OBJ_NAME_get_down_load(names_lh);
377 lh_OBJ_NAME_set_down_load(names_lh, 0);
378
379 lh_OBJ_NAME_doall(names_lh, names_lh_free_doall);
380 if (type < 0) {
381 lh_OBJ_NAME_free(names_lh);
382 sk_NAME_FUNCS_pop_free(name_funcs_stack, name_funcs_free);
383 CRYPTO_THREAD_lock_free(obj_lock);
384 names_lh = NULL;
385 name_funcs_stack = NULL;
386 obj_lock = NULL;
387 } else
388 lh_OBJ_NAME_set_down_load(names_lh, down_load);
389 }
390