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 "e_os.h"                /* strcasecmp */
  11 #include "internal/namemap.h"
  12 #include <openssl/lhash.h>
  13 #include "crypto/lhash.h"      /* openssl_lh_strcasehash */
  14
  15 /*-
  16  * The namenum entry
  17  * =================
  18  */
  19 typedef struct {
  20     char *name;
  21     int number;
  22 } NAMENUM_ENTRY;
  23
  24 DEFINE_LHASH_OF(NAMENUM_ENTRY);
  25
  26 /*-
  27  * The namemap itself
  28  * ==================
  29  */
  30
  31 struct ossl_namemap_st {
  32     /* Flags */
  33     unsigned int stored:1; /* If 1, it's stored in a library context */
  34
  35     CRYPTO_RWLOCK *lock;
  36     LHASH_OF(NAMENUM_ENTRY) *namenum;  /* Name->number mapping */
  37     int max_number;                    /* Current max number */
  38 };
  39
  40 /* LHASH callbacks */
  41
  42 static unsigned long namenum_hash(const NAMENUM_ENTRY *n)
  43 {
  44     return openssl_lh_strcasehash(n->name);
  45 }
  46
  47 static int namenum_cmp(const NAMENUM_ENTRY *a, const NAMENUM_ENTRY *b)
  48 {
  49     return strcasecmp(a->name, b->name);
  50 }
  51
  52 static void namenum_free(NAMENUM_ENTRY *n)
  53 {
  54     if (n != NULL)
  55         OPENSSL_free(n->name);
  56     OPENSSL_free(n);
  57 }
  58
  59 /* OPENSSL_CTX_METHOD functions for a namemap stored in a library context */
  60
  61 static void *stored_namemap_new(OPENSSL_CTX *libctx)
  62 {
  63     OSSL_NAMEMAP *namemap = ossl_namemap_new();
  64
  65     if (namemap != NULL)
  66         namemap->stored = 1;
  67
  68     return namemap;
  69 }
  70
  71 static void stored_namemap_free(void *vnamemap)
  72 {
  73     OSSL_NAMEMAP *namemap = vnamemap;
  74
  75     /* Pretend it isn't stored, or ossl_namemap_free() will do nothing */
  76     namemap->stored = 0;
  77     ossl_namemap_free(namemap);
  78 }
  79
  80 static const OPENSSL_CTX_METHOD stored_namemap_method = {
  81     stored_namemap_new,
  82     stored_namemap_free,
  83 };
  84
  85 /*-
  86  * API functions
  87  * =============
  88  */
  89
  90 OSSL_NAMEMAP *ossl_namemap_stored(OPENSSL_CTX *libctx)
  91 {
  92     return openssl_ctx_get_data(libctx, OPENSSL_CTX_NAMEMAP_INDEX,
  93                                 &stored_namemap_method);
  94 }
  95
  96 OSSL_NAMEMAP *ossl_namemap_new(void)
  97 {
  98     OSSL_NAMEMAP *namemap;
  99
 100     if ((namemap = OPENSSL_zalloc(sizeof(*namemap))) != NULL
 101         && (namemap->lock = CRYPTO_THREAD_lock_new()) != NULL
 102         && (namemap->namenum =
 103             lh_NAMENUM_ENTRY_new(namenum_hash, namenum_cmp)) != NULL)
 104         return namemap;
 105
 106     ossl_namemap_free(namemap);
 107     return NULL;
 108 }
 109
 110 void ossl_namemap_free(OSSL_NAMEMAP *namemap)
 111 {
 112     if (namemap == NULL || namemap->stored)
 113         return;
 114
 115     lh_NAMENUM_ENTRY_doall(namemap->namenum, namenum_free);
 116     lh_NAMENUM_ENTRY_free(namemap->namenum);
 117
 118     CRYPTO_THREAD_lock_free(namemap->lock);
 119     OPENSSL_free(namemap);
 120 }
 121
 122 int ossl_namemap_empty(OSSL_NAMEMAP *namemap)
 123 {
 124     int rv = 0;
 125
 126     CRYPTO_THREAD_read_lock(namemap->lock);
 127     if (namemap->max_number == 0)
 128         rv = 1;
 129     CRYPTO_THREAD_unlock(namemap->lock);
 130
 131     return rv;
 132 }
 133
 134 typedef struct doall_names_data_st {
 135     int number;
 136     void (*fn)(const char *name, void *data);
 137     void *data;
 138 } DOALL_NAMES_DATA;
 139
 140 static void do_name(const NAMENUM_ENTRY *namenum, DOALL_NAMES_DATA *data)
 141 {
 142     if (namenum->number == data->number)
 143         data->fn(namenum->name, data->data);
 144 }
 145
 146 IMPLEMENT_LHASH_DOALL_ARG_CONST(NAMENUM_ENTRY, DOALL_NAMES_DATA);
 147
 148 void ossl_namemap_doall_names(const OSSL_NAMEMAP *namemap, int number,
 149                               void (*fn)(const char *name, void *data),
 150                               void *data)
 151 {
 152     DOALL_NAMES_DATA cbdata;
 153
 154     cbdata.number = number;
 155     cbdata.fn = fn;
 156     cbdata.data = data;
 157     CRYPTO_THREAD_read_lock(namemap->lock);
 158     lh_NAMENUM_ENTRY_doall_DOALL_NAMES_DATA(namemap->namenum, do_name,
 159                                             &cbdata);
 160     CRYPTO_THREAD_unlock(namemap->lock);
 161 }
 162
 163 int ossl_namemap_name2num_n(const OSSL_NAMEMAP *namemap,
 164                             const char *name, size_t name_len)
 165 {
 166     NAMENUM_ENTRY *namenum_entry, namenum_tmpl;
 167     int number = 0;
 168
 169 #ifndef FIPS_MODE
 170     if (namemap == NULL)
 171         namemap = ossl_namemap_stored(NULL);
 172 #endif
 173
 174     if (namemap == NULL)
 175         return 0;
 176
 177     if ((namenum_tmpl.name = OPENSSL_strndup(name, name_len)) == NULL)
 178         return 0;
 179     namenum_tmpl.number = 0;
 180     CRYPTO_THREAD_read_lock(namemap->lock);
 181     namenum_entry =
 182         lh_NAMENUM_ENTRY_retrieve(namemap->namenum, &namenum_tmpl);
 183     if (namenum_entry != NULL)
 184         number = namenum_entry->number;
 185     CRYPTO_THREAD_unlock(namemap->lock);
 186     OPENSSL_free(namenum_tmpl.name);
 187
 188     return number;
 189 }
 190
 191 int ossl_namemap_name2num(const OSSL_NAMEMAP *namemap, const char *name)
 192 {
 193     if (name == NULL)
 194         return 0;
 195
 196     return ossl_namemap_name2num_n(namemap, name, strlen(name));
 197 }
 198
 199 struct num2name_data_st {
 200     size_t idx;                  /* Countdown */
 201     const char *name;            /* Result */
 202 };
 203
 204 static void do_num2name(const char *name, void *vdata)
 205 {
 206     struct num2name_data_st *data = vdata;
 207
 208     if (data->idx > 0)
 209         data->idx--;
 210     else if (data->name == NULL)
 211         data->name = name;
 212 }
 213
 214 const char *ossl_namemap_num2name(const OSSL_NAMEMAP *namemap, int number,
 215                                   size_t idx)
 216 {
 217     struct num2name_data_st data;
 218
 219     data.idx = idx;
 220     data.name = NULL;
 221     ossl_namemap_doall_names(namemap, number, do_num2name, &data);
 222     return data.name;
 223 }
 224
 225 int ossl_namemap_add_n(OSSL_NAMEMAP *namemap, int number,
 226                        const char *name, size_t name_len)
 227 {
 228     NAMENUM_ENTRY *namenum = NULL;
 229     int tmp_number;
 230
 231 #ifndef FIPS_MODE
 232     if (namemap == NULL)
 233         namemap = ossl_namemap_stored(NULL);
 234 #endif
 235
 236     if (name == NULL || name_len == 0 || namemap == NULL)
 237         return 0;
 238
 239     if ((tmp_number = ossl_namemap_name2num_n(namemap, name, name_len)) != 0)
 240         return tmp_number;       /* Pretend success */
 241
 242     CRYPTO_THREAD_write_lock(namemap->lock);
 243
 244     if ((namenum = OPENSSL_zalloc(sizeof(*namenum))) == NULL
 245         || (namenum->name = OPENSSL_strndup(name, name_len)) == NULL)
 246         goto err;
 247
 248     namenum->number = tmp_number =
 249         number != 0 ? number : ++namemap->max_number;
 250     (void)lh_NAMENUM_ENTRY_insert(namemap->namenum, namenum);
 251
 252     if (lh_NAMENUM_ENTRY_error(namemap->namenum))
 253         goto err;
 254
 255     CRYPTO_THREAD_unlock(namemap->lock);
 256
 257     return tmp_number;
 258
 259  err:
 260     namenum_free(namenum);
 261
 262     CRYPTO_THREAD_unlock(namemap->lock);
 263     return 0;
 264 }
 265
 266 int ossl_namemap_add(OSSL_NAMEMAP *namemap, int number, const char *name)
 267 {
 268     if (name == NULL)
 269         return 0;
 270
 271     return ossl_namemap_add_n(namemap, number, name, strlen(name));
 272 }