crypto/store/store_register.c

   1 /*
   2  * Copyright 2016-2017 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (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 <string.h>
  11 #include <ctype.h>
  12 #include <assert.h>
  13
  14 #include <openssl/err.h>
  15 #include <openssl/lhash.h>
  16 #include "store_locl.h"
  17
  18 static CRYPTO_RWLOCK *registry_lock;
  19 static CRYPTO_ONCE registry_init = CRYPTO_ONCE_STATIC_INIT;
  20
  21 DEFINE_RUN_ONCE_STATIC(do_registry_init)
  22 {
  23     registry_lock = CRYPTO_THREAD_lock_new();
  24     return registry_lock != NULL;
  25 }
  26
  27 /*
  28  *  Functions for manipulating OSSL_STORE_LOADERs
  29  */
  30
  31 OSSL_STORE_LOADER *OSSL_STORE_LOADER_new(const char *scheme)
  32 {
  33     OSSL_STORE_LOADER *res = OPENSSL_zalloc(sizeof(*res));
  34
  35     if (res == NULL) {
  36         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_LOADER_NEW, ERR_R_MALLOC_FAILURE);
  37         return NULL;
  38     }
  39
  40     /*
  41      * We usually don't check NULL arguments.  For loaders, though, the
  42      * scheme is crucial and must never be NULL, or the user will get
  43      * mysterious errors when trying to register the created loader
  44      * later on.
  45      */
  46     if (scheme == NULL) {
  47         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_LOADER_NEW,
  48                       OSSL_STORE_R_INVALID_SCHEME);
  49         return NULL;
  50     }
  51
  52     res->scheme = scheme;
  53     return res;
  54 }
  55
  56 const char *OSSL_STORE_LOADER_get0_scheme(const OSSL_STORE_LOADER *loader)
  57 {
  58     return loader->scheme;
  59 }
  60
  61 int OSSL_STORE_LOADER_set_open(OSSL_STORE_LOADER *loader,
  62                                OSSL_STORE_open_fn open_function)
  63 {
  64     loader->open = open_function;
  65     return 1;
  66 }
  67
  68 int OSSL_STORE_LOADER_set_ctrl(OSSL_STORE_LOADER *loader,
  69                                OSSL_STORE_ctrl_fn ctrl_function)
  70 {
  71     loader->ctrl = ctrl_function;
  72     return 1;
  73 }
  74
  75 int OSSL_STORE_LOADER_set_load(OSSL_STORE_LOADER *loader,
  76                                OSSL_STORE_load_fn load_function)
  77 {
  78     loader->load = load_function;
  79     return 1;
  80 }
  81
  82 int OSSL_STORE_LOADER_set_eof(OSSL_STORE_LOADER *loader,
  83                               OSSL_STORE_eof_fn eof_function)
  84 {
  85     loader->eof = eof_function;
  86     return 1;
  87 }
  88
  89 int OSSL_STORE_LOADER_set_error(OSSL_STORE_LOADER *loader,
  90                                 OSSL_STORE_error_fn error_function)
  91 {
  92     loader->error = error_function;
  93     return 1;
  94 }
  95
  96 int OSSL_STORE_LOADER_set_close(OSSL_STORE_LOADER *loader,
  97                                 OSSL_STORE_close_fn close_function)
  98 {
  99     loader->close = close_function;
 100     return 1;
 101 }
 102
 103 void OSSL_STORE_LOADER_free(OSSL_STORE_LOADER *loader)
 104 {
 105     OPENSSL_free(loader);
 106 }
 107
 108 /*
 109  *  Functions for registering OSSL_STORE_LOADERs
 110  */
 111
 112 static unsigned long store_loader_hash(const OSSL_STORE_LOADER *v)
 113 {
 114     return OPENSSL_LH_strhash(v->scheme);
 115 }
 116
 117 static int store_loader_cmp(const OSSL_STORE_LOADER *a,
 118                             const OSSL_STORE_LOADER *b)
 119 {
 120     if (a->scheme != NULL && b->scheme != NULL)
 121         return strcmp(a->scheme, b->scheme);
 122     else if (a->scheme == b->scheme)
 123         return 0;
 124     return a->scheme == NULL ? -1 : 1;
 125 }
 126
 127 static LHASH_OF(OSSL_STORE_LOADER) *loader_register = NULL;
 128
 129 int ossl_store_register_loader_int(OSSL_STORE_LOADER *loader)
 130 {
 131     const char *scheme = loader->scheme;
 132     int ok = 0;
 133
 134     /*
 135      * Check that the given scheme conforms to correct scheme syntax as per
 136      * RFC 3986:
 137      *
 138      * scheme        = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
 139      */
 140     if (isalpha(*scheme))
 141         while (*scheme != '\0'
 142                && (isalpha(*scheme)
 143                    || isdigit(*scheme)
 144                    || strchr("+-.", *scheme) != NULL))
 145             scheme++;
 146     if (*scheme != '\0') {
 147         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_REGISTER_LOADER_INT,
 148                       OSSL_STORE_R_INVALID_SCHEME);
 149         ERR_add_error_data(4, "scheme=", loader->scheme);
 150         return 0;
 151     }
 152
 153     if (!RUN_ONCE(&registry_init, do_registry_init)) {
 154         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_REGISTER_LOADER_INT,
 155                       ERR_R_MALLOC_FAILURE);
 156         return 0;
 157     }
 158     CRYPTO_THREAD_write_lock(registry_lock);
 159
 160     if (loader_register == NULL) {
 161         loader_register = lh_OSSL_STORE_LOADER_new(store_loader_hash,
 162                                                    store_loader_cmp);
 163     }
 164
 165     if (loader_register != NULL
 166         && (lh_OSSL_STORE_LOADER_insert(loader_register, loader) != NULL
 167             || lh_OSSL_STORE_LOADER_error(loader_register) == 0))
 168         ok = 1;
 169
 170     CRYPTO_THREAD_unlock(registry_lock);
 171
 172     return ok;
 173 }
 174 int OSSL_STORE_register_loader(OSSL_STORE_LOADER *loader)
 175 {
 176     if (!ossl_store_init_once())
 177         return 0;
 178     return ossl_store_register_loader_int(loader);
 179 }
 180
 181 const OSSL_STORE_LOADER *ossl_store_get0_loader_int(const char *scheme)
 182 {
 183     OSSL_STORE_LOADER template;
 184     OSSL_STORE_LOADER *loader = NULL;
 185
 186     template.scheme = scheme;
 187     template.open = NULL;
 188     template.load = NULL;
 189     template.eof = NULL;
 190     template.close = NULL;
 191
 192     if (!ossl_store_init_once())
 193         return NULL;
 194
 195     if (!RUN_ONCE(&registry_init, do_registry_init)) {
 196         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_GET0_LOADER_INT,
 197                       ERR_R_MALLOC_FAILURE);
 198         return NULL;
 199     }
 200     CRYPTO_THREAD_write_lock(registry_lock);
 201
 202     loader = lh_OSSL_STORE_LOADER_retrieve(loader_register, &template);
 203
 204     if (loader == NULL) {
 205         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_GET0_LOADER_INT,
 206                       OSSL_STORE_R_UNREGISTERED_SCHEME);
 207         ERR_add_error_data(2, "scheme=", scheme);
 208     }
 209
 210     CRYPTO_THREAD_unlock(registry_lock);
 211
 212     return loader;
 213 }
 214
 215 OSSL_STORE_LOADER *ossl_store_unregister_loader_int(const char *scheme)
 216 {
 217     OSSL_STORE_LOADER template;
 218     OSSL_STORE_LOADER *loader = NULL;
 219
 220     template.scheme = scheme;
 221     template.open = NULL;
 222     template.load = NULL;
 223     template.eof = NULL;
 224     template.close = NULL;
 225
 226     if (!RUN_ONCE(&registry_init, do_registry_init)) {
 227         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_UNREGISTER_LOADER_INT,
 228                       ERR_R_MALLOC_FAILURE);
 229         return NULL;
 230     }
 231     CRYPTO_THREAD_write_lock(registry_lock);
 232
 233     loader = lh_OSSL_STORE_LOADER_delete(loader_register, &template);
 234
 235     if (loader == NULL) {
 236         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_UNREGISTER_LOADER_INT,
 237                       OSSL_STORE_R_UNREGISTERED_SCHEME);
 238         ERR_add_error_data(2, "scheme=", scheme);
 239     }
 240
 241     CRYPTO_THREAD_unlock(registry_lock);
 242
 243     return loader;
 244 }
 245 OSSL_STORE_LOADER *OSSL_STORE_unregister_loader(const char *scheme)
 246 {
 247     if (!ossl_store_init_once())
 248         return 0;
 249     return ossl_store_unregister_loader_int(scheme);
 250 }
 251
 252 void ossl_store_destroy_loaders_int(void)
 253 {
 254     assert(lh_OSSL_STORE_LOADER_num_items(loader_register) == 0);
 255     lh_OSSL_STORE_LOADER_free(loader_register);
 256     loader_register = NULL;
 257     CRYPTO_THREAD_lock_free(registry_lock);
 258     registry_lock = NULL;
 259 }