crypto/objects/o_names.c

   1 /*
   2  * Copyright 1998-2021 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;
  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
  63 int OBJ_NAME_init(void)
  64 {
  65     return RUN_ONCE(&init, o_names_init);
  66 }
  67
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 363 static void name_funcs_free(NAME_FUNCS *ptr)
 364 {
 365     OPENSSL_free(ptr);
 366 }
 367
 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 }