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 typedef struct doall_names_data_st {
 123     int number;
 124     void (*fn)(const char *name, void *data);
 125     void *data;
 126 } DOALL_NAMES_DATA;
 127
 128 static void do_name(const NAMENUM_ENTRY *namenum, DOALL_NAMES_DATA *data)
 129 {
 130     if (namenum->number == data->number)
 131         data->fn(namenum->name, data->data);
 132 }
 133
 134 IMPLEMENT_LHASH_DOALL_ARG_CONST(NAMENUM_ENTRY, DOALL_NAMES_DATA);
 135
 136 void ossl_namemap_doall_names(const OSSL_NAMEMAP *namemap, int number,
 137                               void (*fn)(const char *name, void *data),
 138                               void *data)
 139 {
 140     DOALL_NAMES_DATA cbdata;
 141
 142     cbdata.number = number;
 143     cbdata.fn = fn;
 144     cbdata.data = data;
 145     CRYPTO_THREAD_read_lock(namemap->lock);
 146     lh_NAMENUM_ENTRY_doall_DOALL_NAMES_DATA(namemap->namenum, do_name,
 147                                             &cbdata);
 148     CRYPTO_THREAD_unlock(namemap->lock);
 149 }
 150
 151 int ossl_namemap_name2num_n(const OSSL_NAMEMAP *namemap,
 152                             const char *name, size_t name_len)
 153 {
 154     NAMENUM_ENTRY *namenum_entry, namenum_tmpl;
 155     int number = 0;
 156
 157 #ifndef FIPS_MODE
 158     if (namemap == NULL)
 159         namemap = ossl_namemap_stored(NULL);
 160 #endif
 161
 162     if (namemap == NULL)
 163         return 0;
 164
 165     if ((namenum_tmpl.name = OPENSSL_strndup(name, name_len)) == NULL)
 166         return 0;
 167     namenum_tmpl.number = 0;
 168     CRYPTO_THREAD_read_lock(namemap->lock);
 169     namenum_entry =
 170         lh_NAMENUM_ENTRY_retrieve(namemap->namenum, &namenum_tmpl);
 171     if (namenum_entry != NULL)
 172         number = namenum_entry->number;
 173     CRYPTO_THREAD_unlock(namemap->lock);
 174     OPENSSL_free(namenum_tmpl.name);
 175
 176     return number;
 177 }
 178
 179 int ossl_namemap_name2num(const OSSL_NAMEMAP *namemap, const char *name)
 180 {
 181     if (name == NULL)
 182         return 0;
 183
 184     return ossl_namemap_name2num_n(namemap, name, strlen(name));
 185 }
 186
 187 struct num2name_data_st {
 188     size_t idx;                  /* Countdown */
 189     const char *name;            /* Result */
 190 };
 191
 192 static void do_num2name(const char *name, void *vdata)
 193 {
 194     struct num2name_data_st *data = vdata;
 195
 196     if (data->idx > 0)
 197         data->idx--;
 198     else if (data->name == NULL)
 199         data->name = name;
 200 }
 201
 202 const char *ossl_namemap_num2name(const OSSL_NAMEMAP *namemap, int number,
 203                                   size_t idx)
 204 {
 205     struct num2name_data_st data;
 206
 207     data.idx = idx;
 208     data.name = NULL;
 209     ossl_namemap_doall_names(namemap, number, do_num2name, &data);
 210     return data.name;
 211 }
 212
 213 int ossl_namemap_add_n(OSSL_NAMEMAP *namemap, int number,
 214                        const char *name, size_t name_len)
 215 {
 216     NAMENUM_ENTRY *namenum = NULL;
 217     int tmp_number;
 218
 219 #ifndef FIPS_MODE
 220     if (namemap == NULL)
 221         namemap = ossl_namemap_stored(NULL);
 222 #endif
 223
 224     if (name == NULL || name_len == 0 || namemap == NULL)
 225         return 0;
 226
 227     if ((tmp_number = ossl_namemap_name2num_n(namemap, name, name_len)) != 0)
 228         return tmp_number;       /* Pretend success */
 229
 230     CRYPTO_THREAD_write_lock(namemap->lock);
 231
 232     if ((namenum = OPENSSL_zalloc(sizeof(*namenum))) == NULL
 233         || (namenum->name = OPENSSL_strndup(name, name_len)) == NULL)
 234         goto err;
 235
 236     namenum->number = tmp_number =
 237         number != 0 ? number : ++namemap->max_number;
 238     (void)lh_NAMENUM_ENTRY_insert(namemap->namenum, namenum);
 239
 240     if (lh_NAMENUM_ENTRY_error(namemap->namenum))
 241         goto err;
 242
 243     CRYPTO_THREAD_unlock(namemap->lock);
 244
 245     return tmp_number;
 246
 247  err:
 248     namenum_free(namenum);
 249
 250     CRYPTO_THREAD_unlock(namemap->lock);
 251     return 0;
 252 }
 253
 254 int ossl_namemap_add(OSSL_NAMEMAP *namemap, int number, const char *name)
 255 {
 256     if (name == NULL)
 257         return 0;
 258
 259     return ossl_namemap_add_n(namemap, number, name, strlen(name));
 260 }