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 "internal/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(const OSSL_NAMEMAP *namemap, const char *name)
 152 {
 153     NAMENUM_ENTRY *namenum_entry, namenum_tmpl;
 154     int number = 0;
 155
 156 #ifndef FIPS_MODE
 157     if (namemap == NULL)
 158         namemap = ossl_namemap_stored(NULL);
 159 #endif
 160
 161     if (namemap == NULL)
 162         return 0;
 163
 164     namenum_tmpl.name = (char *)name;
 165     namenum_tmpl.number = 0;
 166     CRYPTO_THREAD_read_lock(namemap->lock);
 167     namenum_entry =
 168         lh_NAMENUM_ENTRY_retrieve(namemap->namenum, &namenum_tmpl);
 169     if (namenum_entry != NULL)
 170         number = namenum_entry->number;
 171     CRYPTO_THREAD_unlock(namemap->lock);
 172
 173     return number;
 174 }
 175
 176 struct num2name_data_st {
 177     size_t idx;                  /* Countdown */
 178     const char *name;            /* Result */
 179 };
 180
 181 static void do_num2name(const char *name, void *vdata)
 182 {
 183     struct num2name_data_st *data = vdata;
 184
 185     if (data->idx > 0)
 186         data->idx--;
 187     else if (data->name == NULL)
 188         data->name = name;
 189 }
 190
 191 const char *ossl_namemap_num2name(const OSSL_NAMEMAP *namemap, int number,
 192                                   size_t idx)
 193 {
 194     struct num2name_data_st data;
 195
 196     data.idx = idx;
 197     data.name = NULL;
 198     ossl_namemap_doall_names(namemap, number, do_num2name, &data);
 199     return data.name;
 200 }
 201
 202 int ossl_namemap_add(OSSL_NAMEMAP *namemap, int number, const char *name)
 203 {
 204     NAMENUM_ENTRY *namenum = NULL;
 205     int tmp_number;
 206
 207 #ifndef FIPS_MODE
 208     if (namemap == NULL)
 209         namemap = ossl_namemap_stored(NULL);
 210 #endif
 211
 212     if (name == NULL || namemap == NULL)
 213         return 0;
 214
 215     if ((tmp_number = ossl_namemap_name2num(namemap, name)) != 0)
 216         return tmp_number;       /* Pretend success */
 217
 218     CRYPTO_THREAD_write_lock(namemap->lock);
 219
 220     if ((namenum = OPENSSL_zalloc(sizeof(*namenum))) == NULL
 221         || (namenum->name = OPENSSL_strdup(name)) == NULL)
 222         goto err;
 223
 224     namenum->number = tmp_number =
 225         number != 0 ? number : ++namemap->max_number;
 226     (void)lh_NAMENUM_ENTRY_insert(namemap->namenum, namenum);
 227
 228     if (lh_NAMENUM_ENTRY_error(namemap->namenum))
 229         goto err;
 230
 231     CRYPTO_THREAD_unlock(namemap->lock);
 232
 233     return tmp_number;
 234
 235  err:
 236     namenum_free(namenum);
 237
 238     CRYPTO_THREAD_unlock(namemap->lock);
 239     return 0;
 240 }