[331] | 1 | /*
|
---|
| 2 | * Copyright 1998-2016 The OpenSSL Project Authors. All Rights Reserved.
|
---|
| 3 | *
|
---|
| 4 | * Licensed under the OpenSSL license (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 "obj_lcl.h"
|
---|
| 20 |
|
---|
| 21 | /*
|
---|
| 22 | * We define this wrapper for two reasons. Firstly, later versions of
|
---|
| 23 | * DEC C add linkage information to certain functions, which makes it
|
---|
| 24 | * tricky to use them as values to regular function pointers.
|
---|
| 25 | * Secondly, in the EDK2 build environment, the strcmp function is
|
---|
| 26 | * actually an external function (AsciiStrCmp) with the Microsoft ABI,
|
---|
| 27 | * so we can't transparently assign function pointers to it.
|
---|
| 28 | * Arguably the latter is a stupidity of the UEFI environment, but
|
---|
| 29 | * since the wrapper solves the DEC C issue too, let's just use the
|
---|
| 30 | * same solution.
|
---|
| 31 | */
|
---|
| 32 | #if defined(OPENSSL_SYS_VMS_DECC) || defined(OPENSSL_SYS_UEFI)
|
---|
| 33 | static int obj_strcmp(const char *a, const char *b)
|
---|
| 34 | {
|
---|
| 35 | return strcmp(a, b);
|
---|
| 36 | }
|
---|
| 37 | #else
|
---|
| 38 | #define obj_strcmp strcmp
|
---|
| 39 | #endif
|
---|
| 40 |
|
---|
| 41 | /*
|
---|
| 42 | * I use the ex_data stuff to manage the identifiers for the obj_name_types
|
---|
| 43 | * that applications may define. I only really use the free function field.
|
---|
| 44 | */
|
---|
| 45 | static LHASH_OF(OBJ_NAME) *names_lh = NULL;
|
---|
| 46 | static int names_type_num = OBJ_NAME_TYPE_NUM;
|
---|
| 47 |
|
---|
| 48 | struct name_funcs_st {
|
---|
| 49 | unsigned long (*hash_func) (const char *name);
|
---|
| 50 | int (*cmp_func) (const char *a, const char *b);
|
---|
| 51 | void (*free_func) (const char *, int, const char *);
|
---|
| 52 | };
|
---|
| 53 |
|
---|
| 54 | static STACK_OF(NAME_FUNCS) *name_funcs_stack;
|
---|
| 55 |
|
---|
| 56 | /*
|
---|
| 57 | * The LHASH callbacks now use the raw "void *" prototypes and do
|
---|
| 58 | * per-variable casting in the functions. This prevents function pointer
|
---|
| 59 | * casting without the need for macro-generated wrapper functions.
|
---|
| 60 | */
|
---|
| 61 |
|
---|
| 62 | static unsigned long obj_name_hash(const OBJ_NAME *a);
|
---|
| 63 | static int obj_name_cmp(const OBJ_NAME *a, const OBJ_NAME *b);
|
---|
| 64 |
|
---|
| 65 | int OBJ_NAME_init(void)
|
---|
| 66 | {
|
---|
| 67 | if (names_lh != NULL)
|
---|
| 68 | return (1);
|
---|
| 69 | CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
|
---|
| 70 | names_lh = lh_OBJ_NAME_new(obj_name_hash, obj_name_cmp);
|
---|
| 71 | CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
|
---|
| 72 | return (names_lh != NULL);
|
---|
| 73 | }
|
---|
| 74 |
|
---|
| 75 | int OBJ_NAME_new_index(unsigned long (*hash_func) (const char *),
|
---|
| 76 | int (*cmp_func) (const char *, const char *),
|
---|
| 77 | void (*free_func) (const char *, int, const char *))
|
---|
| 78 | {
|
---|
| 79 | int ret, i, push;
|
---|
| 80 | NAME_FUNCS *name_funcs;
|
---|
| 81 |
|
---|
| 82 | if (name_funcs_stack == NULL) {
|
---|
| 83 | CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
|
---|
| 84 | name_funcs_stack = sk_NAME_FUNCS_new_null();
|
---|
| 85 | CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
|
---|
| 86 | }
|
---|
| 87 | if (name_funcs_stack == NULL) {
|
---|
| 88 | /* ERROR */
|
---|
| 89 | return (0);
|
---|
| 90 | }
|
---|
| 91 | ret = names_type_num;
|
---|
| 92 | names_type_num++;
|
---|
| 93 | for (i = sk_NAME_FUNCS_num(name_funcs_stack); i < names_type_num; i++) {
|
---|
| 94 | CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
|
---|
| 95 | name_funcs = OPENSSL_zalloc(sizeof(*name_funcs));
|
---|
| 96 | CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
|
---|
| 97 | if (name_funcs == NULL) {
|
---|
| 98 | OBJerr(OBJ_F_OBJ_NAME_NEW_INDEX, ERR_R_MALLOC_FAILURE);
|
---|
| 99 | return (0);
|
---|
| 100 | }
|
---|
| 101 | name_funcs->hash_func = OPENSSL_LH_strhash;
|
---|
| 102 | name_funcs->cmp_func = obj_strcmp;
|
---|
| 103 | CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
|
---|
| 104 |
|
---|
| 105 | push = sk_NAME_FUNCS_push(name_funcs_stack, name_funcs);
|
---|
| 106 | CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
|
---|
| 107 |
|
---|
| 108 | if (!push) {
|
---|
| 109 | OBJerr(OBJ_F_OBJ_NAME_NEW_INDEX, ERR_R_MALLOC_FAILURE);
|
---|
| 110 | OPENSSL_free(name_funcs);
|
---|
| 111 | return 0;
|
---|
| 112 | }
|
---|
| 113 | }
|
---|
| 114 | name_funcs = sk_NAME_FUNCS_value(name_funcs_stack, ret);
|
---|
| 115 | if (hash_func != NULL)
|
---|
| 116 | name_funcs->hash_func = hash_func;
|
---|
| 117 | if (cmp_func != NULL)
|
---|
| 118 | name_funcs->cmp_func = cmp_func;
|
---|
| 119 | if (free_func != NULL)
|
---|
| 120 | name_funcs->free_func = free_func;
|
---|
| 121 | return (ret);
|
---|
| 122 | }
|
---|
| 123 |
|
---|
| 124 | static int obj_name_cmp(const OBJ_NAME *a, const OBJ_NAME *b)
|
---|
| 125 | {
|
---|
| 126 | int ret;
|
---|
| 127 |
|
---|
| 128 | ret = a->type - b->type;
|
---|
| 129 | if (ret == 0) {
|
---|
| 130 | if ((name_funcs_stack != NULL)
|
---|
| 131 | && (sk_NAME_FUNCS_num(name_funcs_stack) > a->type)) {
|
---|
| 132 | ret = sk_NAME_FUNCS_value(name_funcs_stack,
|
---|
| 133 | a->type)->cmp_func(a->name, b->name);
|
---|
| 134 | } else
|
---|
| 135 | ret = strcmp(a->name, b->name);
|
---|
| 136 | }
|
---|
| 137 | return (ret);
|
---|
| 138 | }
|
---|
| 139 |
|
---|
| 140 | static unsigned long obj_name_hash(const OBJ_NAME *a)
|
---|
| 141 | {
|
---|
| 142 | unsigned long ret;
|
---|
| 143 |
|
---|
| 144 | if ((name_funcs_stack != NULL)
|
---|
| 145 | && (sk_NAME_FUNCS_num(name_funcs_stack) > a->type)) {
|
---|
| 146 | ret =
|
---|
| 147 | sk_NAME_FUNCS_value(name_funcs_stack,
|
---|
| 148 | a->type)->hash_func(a->name);
|
---|
| 149 | } else {
|
---|
| 150 | ret = OPENSSL_LH_strhash(a->name);
|
---|
| 151 | }
|
---|
| 152 | ret ^= a->type;
|
---|
| 153 | return (ret);
|
---|
| 154 | }
|
---|
| 155 |
|
---|
| 156 | const char *OBJ_NAME_get(const char *name, int type)
|
---|
| 157 | {
|
---|
| 158 | OBJ_NAME on, *ret;
|
---|
| 159 | int num = 0, alias;
|
---|
| 160 |
|
---|
| 161 | if (name == NULL)
|
---|
| 162 | return (NULL);
|
---|
| 163 | if ((names_lh == NULL) && !OBJ_NAME_init())
|
---|
| 164 | return (NULL);
|
---|
| 165 |
|
---|
| 166 | alias = type & OBJ_NAME_ALIAS;
|
---|
| 167 | type &= ~OBJ_NAME_ALIAS;
|
---|
| 168 |
|
---|
| 169 | on.name = name;
|
---|
| 170 | on.type = type;
|
---|
| 171 |
|
---|
| 172 | for (;;) {
|
---|
| 173 | ret = lh_OBJ_NAME_retrieve(names_lh, &on);
|
---|
| 174 | if (ret == NULL)
|
---|
| 175 | return (NULL);
|
---|
| 176 | if ((ret->alias) && !alias) {
|
---|
| 177 | if (++num > 10)
|
---|
| 178 | return (NULL);
|
---|
| 179 | on.name = ret->data;
|
---|
| 180 | } else {
|
---|
| 181 | return (ret->data);
|
---|
| 182 | }
|
---|
| 183 | }
|
---|
| 184 | }
|
---|
| 185 |
|
---|
| 186 | int OBJ_NAME_add(const char *name, int type, const char *data)
|
---|
| 187 | {
|
---|
| 188 | OBJ_NAME *onp, *ret;
|
---|
| 189 | int alias;
|
---|
| 190 |
|
---|
| 191 | if ((names_lh == NULL) && !OBJ_NAME_init())
|
---|
| 192 | return (0);
|
---|
| 193 |
|
---|
| 194 | alias = type & OBJ_NAME_ALIAS;
|
---|
| 195 | type &= ~OBJ_NAME_ALIAS;
|
---|
| 196 |
|
---|
| 197 | onp = OPENSSL_malloc(sizeof(*onp));
|
---|
| 198 | if (onp == NULL) {
|
---|
| 199 | /* ERROR */
|
---|
| 200 | return 0;
|
---|
| 201 | }
|
---|
| 202 |
|
---|
| 203 | onp->name = name;
|
---|
| 204 | onp->alias = alias;
|
---|
| 205 | onp->type = type;
|
---|
| 206 | onp->data = data;
|
---|
| 207 |
|
---|
| 208 | ret = lh_OBJ_NAME_insert(names_lh, onp);
|
---|
| 209 | if (ret != NULL) {
|
---|
| 210 | /* free things */
|
---|
| 211 | if ((name_funcs_stack != NULL)
|
---|
| 212 | && (sk_NAME_FUNCS_num(name_funcs_stack) > ret->type)) {
|
---|
| 213 | /*
|
---|
| 214 | * XXX: I'm not sure I understand why the free function should
|
---|
| 215 | * get three arguments... -- Richard Levitte
|
---|
| 216 | */
|
---|
| 217 | sk_NAME_FUNCS_value(name_funcs_stack,
|
---|
| 218 | ret->type)->free_func(ret->name, ret->type,
|
---|
| 219 | ret->data);
|
---|
| 220 | }
|
---|
| 221 | OPENSSL_free(ret);
|
---|
| 222 | } else {
|
---|
| 223 | if (lh_OBJ_NAME_error(names_lh)) {
|
---|
| 224 | /* ERROR */
|
---|
| 225 | OPENSSL_free(onp);
|
---|
| 226 | return 0;
|
---|
| 227 | }
|
---|
| 228 | }
|
---|
| 229 | return 1;
|
---|
| 230 | }
|
---|
| 231 |
|
---|
| 232 | int OBJ_NAME_remove(const char *name, int type)
|
---|
| 233 | {
|
---|
| 234 | OBJ_NAME on, *ret;
|
---|
| 235 |
|
---|
| 236 | if (names_lh == NULL)
|
---|
| 237 | return (0);
|
---|
| 238 |
|
---|
| 239 | type &= ~OBJ_NAME_ALIAS;
|
---|
| 240 | on.name = name;
|
---|
| 241 | on.type = type;
|
---|
| 242 | ret = lh_OBJ_NAME_delete(names_lh, &on);
|
---|
| 243 | if (ret != NULL) {
|
---|
| 244 | /* free things */
|
---|
| 245 | if ((name_funcs_stack != NULL)
|
---|
| 246 | && (sk_NAME_FUNCS_num(name_funcs_stack) > ret->type)) {
|
---|
| 247 | /*
|
---|
| 248 | * XXX: I'm not sure I understand why the free function should
|
---|
| 249 | * get three arguments... -- Richard Levitte
|
---|
| 250 | */
|
---|
| 251 | sk_NAME_FUNCS_value(name_funcs_stack,
|
---|
| 252 | ret->type)->free_func(ret->name, ret->type,
|
---|
| 253 | ret->data);
|
---|
| 254 | }
|
---|
| 255 | OPENSSL_free(ret);
|
---|
| 256 | return (1);
|
---|
| 257 | } else
|
---|
| 258 | return (0);
|
---|
| 259 | }
|
---|
| 260 |
|
---|
| 261 | typedef struct {
|
---|
| 262 | int type;
|
---|
| 263 | void (*fn) (const OBJ_NAME *, void *arg);
|
---|
| 264 | void *arg;
|
---|
| 265 | } OBJ_DOALL;
|
---|
| 266 |
|
---|
| 267 | static void do_all_fn(const OBJ_NAME *name, OBJ_DOALL *d)
|
---|
| 268 | {
|
---|
| 269 | if (name->type == d->type)
|
---|
| 270 | d->fn(name, d->arg);
|
---|
| 271 | }
|
---|
| 272 |
|
---|
| 273 | IMPLEMENT_LHASH_DOALL_ARG_CONST(OBJ_NAME, OBJ_DOALL);
|
---|
| 274 |
|
---|
| 275 | void OBJ_NAME_do_all(int type, void (*fn) (const OBJ_NAME *, void *arg),
|
---|
| 276 | void *arg)
|
---|
| 277 | {
|
---|
| 278 | OBJ_DOALL d;
|
---|
| 279 |
|
---|
| 280 | d.type = type;
|
---|
| 281 | d.fn = fn;
|
---|
| 282 | d.arg = arg;
|
---|
| 283 |
|
---|
| 284 | lh_OBJ_NAME_doall_OBJ_DOALL(names_lh, do_all_fn, &d);
|
---|
| 285 | }
|
---|
| 286 |
|
---|
| 287 | struct doall_sorted {
|
---|
| 288 | int type;
|
---|
| 289 | int n;
|
---|
| 290 | const OBJ_NAME **names;
|
---|
| 291 | };
|
---|
| 292 |
|
---|
| 293 | static void do_all_sorted_fn(const OBJ_NAME *name, void *d_)
|
---|
| 294 | {
|
---|
| 295 | struct doall_sorted *d = d_;
|
---|
| 296 |
|
---|
| 297 | if (name->type != d->type)
|
---|
| 298 | return;
|
---|
| 299 |
|
---|
| 300 | d->names[d->n++] = name;
|
---|
| 301 | }
|
---|
| 302 |
|
---|
| 303 | static int do_all_sorted_cmp(const void *n1_, const void *n2_)
|
---|
| 304 | {
|
---|
| 305 | const OBJ_NAME *const *n1 = n1_;
|
---|
| 306 | const OBJ_NAME *const *n2 = n2_;
|
---|
| 307 |
|
---|
| 308 | return strcmp((*n1)->name, (*n2)->name);
|
---|
| 309 | }
|
---|
| 310 |
|
---|
| 311 | void OBJ_NAME_do_all_sorted(int type,
|
---|
| 312 | void (*fn) (const OBJ_NAME *, void *arg),
|
---|
| 313 | void *arg)
|
---|
| 314 | {
|
---|
| 315 | struct doall_sorted d;
|
---|
| 316 | int n;
|
---|
| 317 |
|
---|
| 318 | d.type = type;
|
---|
| 319 | d.names =
|
---|
| 320 | OPENSSL_malloc(sizeof(*d.names) * lh_OBJ_NAME_num_items(names_lh));
|
---|
| 321 | /* Really should return an error if !d.names...but its a void function! */
|
---|
| 322 | if (d.names != NULL) {
|
---|
| 323 | d.n = 0;
|
---|
| 324 | OBJ_NAME_do_all(type, do_all_sorted_fn, &d);
|
---|
| 325 |
|
---|
| 326 | qsort((void *)d.names, d.n, sizeof(*d.names), do_all_sorted_cmp);
|
---|
| 327 |
|
---|
| 328 | for (n = 0; n < d.n; ++n)
|
---|
| 329 | fn(d.names[n], arg);
|
---|
| 330 |
|
---|
| 331 | OPENSSL_free((void *)d.names);
|
---|
| 332 | }
|
---|
| 333 | }
|
---|
| 334 |
|
---|
| 335 | static int free_type;
|
---|
| 336 |
|
---|
| 337 | static void names_lh_free_doall(OBJ_NAME *onp)
|
---|
| 338 | {
|
---|
| 339 | if (onp == NULL)
|
---|
| 340 | return;
|
---|
| 341 |
|
---|
| 342 | if (free_type < 0 || free_type == onp->type)
|
---|
| 343 | OBJ_NAME_remove(onp->name, onp->type);
|
---|
| 344 | }
|
---|
| 345 |
|
---|
| 346 | static void name_funcs_free(NAME_FUNCS *ptr)
|
---|
| 347 | {
|
---|
| 348 | OPENSSL_free(ptr);
|
---|
| 349 | }
|
---|
| 350 |
|
---|
| 351 | void OBJ_NAME_cleanup(int type)
|
---|
| 352 | {
|
---|
| 353 | unsigned long down_load;
|
---|
| 354 |
|
---|
| 355 | if (names_lh == NULL)
|
---|
| 356 | return;
|
---|
| 357 |
|
---|
| 358 | free_type = type;
|
---|
| 359 | down_load = lh_OBJ_NAME_get_down_load(names_lh);
|
---|
| 360 | lh_OBJ_NAME_set_down_load(names_lh, 0);
|
---|
| 361 |
|
---|
| 362 | lh_OBJ_NAME_doall(names_lh, names_lh_free_doall);
|
---|
| 363 | if (type < 0) {
|
---|
| 364 | lh_OBJ_NAME_free(names_lh);
|
---|
| 365 | sk_NAME_FUNCS_pop_free(name_funcs_stack, name_funcs_free);
|
---|
| 366 | names_lh = NULL;
|
---|
| 367 | name_funcs_stack = NULL;
|
---|
| 368 | } else
|
---|
| 369 | lh_OBJ_NAME_set_down_load(names_lh, down_load);
|
---|
| 370 | }
|
---|