crypto/core_namemap.c

   1 /*
   2  * Copyright 2019 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 "internal/namemap.h"
  11 #include <openssl/lhash.h>
  12
  13 /*-
  14  * The namenum entry
  15  * =================
  16  */
  17 typedef struct {
  18     char *name;
  19     int number;
  20 } NAMENUM_ENTRY;
  21
  22 DEFINE_LHASH_OF(NAMENUM_ENTRY);
  23
  24 /*-
  25  * The namemap itself
  26  * ==================
  27  */
  28
  29 struct ossl_namemap_st {
  30     /* Flags */
  31     unsigned int stored:1; /* If 1, it's stored in a library context */
  32
  33     CRYPTO_RWLOCK *lock;
  34     LHASH_OF(NAMENUM_ENTRY) *namenum;  /* Name->number mapping */
  35     int max_number;                    /* Current max number */
  36 };
  37
  38 /* LHASH callbacks */
  39
  40 static unsigned long namenum_hash(const NAMENUM_ENTRY *n)
  41 {
  42     return OPENSSL_LH_strhash(n->name);
  43 }
  44
  45 static int namenum_cmp(const NAMENUM_ENTRY *a, const NAMENUM_ENTRY *b)
  46 {
  47     return strcmp(a->name, b->name);
  48 }
  49
  50 static void namenum_free(NAMENUM_ENTRY *n)
  51 {
  52     if (n != NULL)
  53         OPENSSL_free(n->name);
  54     OPENSSL_free(n);
  55 }
  56
  57 /* OPENSSL_CTX_METHOD functions for a namemap stored in a library context */
  58
  59 static void *stored_namemap_new(OPENSSL_CTX *libctx)
  60 {
  61     OSSL_NAMEMAP *namemap = ossl_namemap_new();
  62
  63     if (namemap != NULL)
  64         namemap->stored = 1;
  65
  66     return namemap;
  67 }
  68
  69 static void stored_namemap_free(void *vnamemap)
  70 {
  71     OSSL_NAMEMAP *namemap = vnamemap;
  72
  73     /* Pretend it isn't stored, or ossl_namemap_free() will do nothing */
  74     namemap->stored = 0;
  75     ossl_namemap_free(namemap);
  76 }
  77
  78 static const OPENSSL_CTX_METHOD stored_namemap_method = {
  79     stored_namemap_new,
  80     stored_namemap_free,
  81 };
  82
  83 /*-
  84  * API functions
  85  * =============
  86  */
  87
  88 OSSL_NAMEMAP *ossl_namemap_stored(OPENSSL_CTX *libctx)
  89 {
  90     return openssl_ctx_get_data(libctx, OPENSSL_CTX_NAMEMAP_INDEX,
  91                                 &stored_namemap_method);
  92 }
  93
  94 OSSL_NAMEMAP *ossl_namemap_new(void)
  95 {
  96     OSSL_NAMEMAP *namemap;
  97
  98     if ((namemap = OPENSSL_zalloc(sizeof(*namemap))) != NULL
  99         && (namemap->lock = CRYPTO_THREAD_lock_new()) != NULL
 100         && (namemap->namenum =
 101             lh_NAMENUM_ENTRY_new(namenum_hash, namenum_cmp)) != NULL)
 102         return namemap;
 103
 104     ossl_namemap_free(namemap);
 105     return NULL;
 106 }
 107
 108 void ossl_namemap_free(OSSL_NAMEMAP *namemap)
 109 {
 110     if (namemap == NULL || namemap->stored)
 111         return;
 112
 113     lh_NAMENUM_ENTRY_doall(namemap->namenum, namenum_free);
 114     lh_NAMENUM_ENTRY_free(namemap->namenum);
 115
 116     CRYPTO_THREAD_lock_free(namemap->lock);
 117     OPENSSL_free(namemap);
 118 }
 119
 120 typedef struct doall_names_data_st {
 121     int number;
 122     void (*fn)(const char *name, void *data);
 123     void *data;
 124 } DOALL_NAMES_DATA;
 125
 126 static void do_name(const NAMENUM_ENTRY *namenum, DOALL_NAMES_DATA *data)
 127 {
 128     if (namenum->number == data->number)
 129         data->fn(namenum->name, data->data);
 130 }
 131
 132 IMPLEMENT_LHASH_DOALL_ARG_CONST(NAMENUM_ENTRY, DOALL_NAMES_DATA);
 133
 134 void ossl_namemap_doall_names(const OSSL_NAMEMAP *namemap, int number,
 135                               void (*fn)(const char *name, void *data),
 136                               void *data)
 137 {
 138     DOALL_NAMES_DATA cbdata;
 139
 140     cbdata.number = number;
 141     cbdata.fn = fn;
 142     cbdata.data = data;
 143     CRYPTO_THREAD_read_lock(namemap->lock);
 144     lh_NAMENUM_ENTRY_doall_DOALL_NAMES_DATA(namemap->namenum, do_name,
 145                                             &cbdata);
 146     CRYPTO_THREAD_unlock(namemap->lock);
 147 }
 148
 149 int ossl_namemap_name2num(const OSSL_NAMEMAP *namemap, const char *name)
 150 {
 151     NAMENUM_ENTRY *namenum_entry, namenum_tmpl;
 152     int number = 0;
 153
 154 #ifndef FIPS_MODE
 155     if (namemap == NULL)
 156         namemap = ossl_namemap_stored(NULL);
 157 #endif
 158
 159     if (namemap == NULL)
 160         return 0;
 161
 162     namenum_tmpl.name = (char *)name;
 163     namenum_tmpl.number = 0;
 164     CRYPTO_THREAD_read_lock(namemap->lock);
 165     namenum_entry =
 166         lh_NAMENUM_ENTRY_retrieve(namemap->namenum, &namenum_tmpl);
 167     if (namenum_entry != NULL)
 168         number = namenum_entry->number;
 169     CRYPTO_THREAD_unlock(namemap->lock);
 170
 171     return number;
 172 }
 173
 174 int ossl_namemap_add(OSSL_NAMEMAP *namemap, int number, const char *name)
 175 {
 176     NAMENUM_ENTRY *namenum = NULL;
 177     int tmp_number;
 178
 179 #ifndef FIPS_MODE
 180     if (namemap == NULL)
 181         namemap = ossl_namemap_stored(NULL);
 182 #endif
 183
 184     if (name == NULL || namemap == NULL)
 185         return 0;
 186
 187     if ((tmp_number = ossl_namemap_name2num(namemap, name)) != 0)
 188         return tmp_number;       /* Pretend success */
 189
 190     CRYPTO_THREAD_write_lock(namemap->lock);
 191
 192     if ((namenum = OPENSSL_zalloc(sizeof(*namenum))) == NULL
 193         || (namenum->name = OPENSSL_strdup(name)) == NULL)
 194         goto err;
 195
 196     namenum->number = tmp_number =
 197         number != 0 ? number : ++namemap->max_number;
 198     (void)lh_NAMENUM_ENTRY_insert(namemap->namenum, namenum);
 199
 200     if (lh_NAMENUM_ENTRY_error(namemap->namenum))
 201         goto err;
 202
 203     CRYPTO_THREAD_unlock(namemap->lock);
 204
 205     return tmp_number;
 206
 207  err:
 208     namenum_free(namenum);
 209
 210     CRYPTO_THREAD_unlock(namemap->lock);
 211     return 0;
 212 }