298 lines
8.0 KiB
C
298 lines
8.0 KiB
C
|
/*
|
||
|
* Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved.
|
||
|
*
|
||
|
* Licensed under the OpenSSL license (the "License"). You may not use
|
||
|
* this file except in compliance with the License. You can obtain a copy
|
||
|
* in the file LICENSE in the source distribution or at
|
||
|
* https://www.openssl.org/source/license.html
|
||
|
*/
|
||
|
|
||
|
#include <string.h>
|
||
|
#include "crypto/ctype.h"
|
||
|
#include <assert.h>
|
||
|
|
||
|
#include <openssl/err.h>
|
||
|
#include <openssl/lhash.h>
|
||
|
#include "store_local.h"
|
||
|
|
||
|
static CRYPTO_RWLOCK *registry_lock;
|
||
|
static CRYPTO_ONCE registry_init = CRYPTO_ONCE_STATIC_INIT;
|
||
|
|
||
|
DEFINE_RUN_ONCE_STATIC(do_registry_init)
|
||
|
{
|
||
|
registry_lock = CRYPTO_THREAD_lock_new();
|
||
|
return registry_lock != NULL;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Functions for manipulating OSSL_STORE_LOADERs
|
||
|
*/
|
||
|
|
||
|
OSSL_STORE_LOADER *OSSL_STORE_LOADER_new(ENGINE *e, const char *scheme)
|
||
|
{
|
||
|
OSSL_STORE_LOADER *res = NULL;
|
||
|
|
||
|
/*
|
||
|
* We usually don't check NULL arguments. For loaders, though, the
|
||
|
* scheme is crucial and must never be NULL, or the user will get
|
||
|
* mysterious errors when trying to register the created loader
|
||
|
* later on.
|
||
|
*/
|
||
|
if (scheme == NULL) {
|
||
|
OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_LOADER_NEW,
|
||
|
OSSL_STORE_R_INVALID_SCHEME);
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
if ((res = OPENSSL_zalloc(sizeof(*res))) == NULL) {
|
||
|
OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_LOADER_NEW, ERR_R_MALLOC_FAILURE);
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
res->engine = e;
|
||
|
res->scheme = scheme;
|
||
|
return res;
|
||
|
}
|
||
|
|
||
|
const ENGINE *OSSL_STORE_LOADER_get0_engine(const OSSL_STORE_LOADER *loader)
|
||
|
{
|
||
|
return loader->engine;
|
||
|
}
|
||
|
|
||
|
const char *OSSL_STORE_LOADER_get0_scheme(const OSSL_STORE_LOADER *loader)
|
||
|
{
|
||
|
return loader->scheme;
|
||
|
}
|
||
|
|
||
|
int OSSL_STORE_LOADER_set_open(OSSL_STORE_LOADER *loader,
|
||
|
OSSL_STORE_open_fn open_function)
|
||
|
{
|
||
|
loader->open = open_function;
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
int OSSL_STORE_LOADER_set_ctrl(OSSL_STORE_LOADER *loader,
|
||
|
OSSL_STORE_ctrl_fn ctrl_function)
|
||
|
{
|
||
|
loader->ctrl = ctrl_function;
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
int OSSL_STORE_LOADER_set_expect(OSSL_STORE_LOADER *loader,
|
||
|
OSSL_STORE_expect_fn expect_function)
|
||
|
{
|
||
|
loader->expect = expect_function;
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
int OSSL_STORE_LOADER_set_find(OSSL_STORE_LOADER *loader,
|
||
|
OSSL_STORE_find_fn find_function)
|
||
|
{
|
||
|
loader->find = find_function;
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
int OSSL_STORE_LOADER_set_load(OSSL_STORE_LOADER *loader,
|
||
|
OSSL_STORE_load_fn load_function)
|
||
|
{
|
||
|
loader->load = load_function;
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
int OSSL_STORE_LOADER_set_eof(OSSL_STORE_LOADER *loader,
|
||
|
OSSL_STORE_eof_fn eof_function)
|
||
|
{
|
||
|
loader->eof = eof_function;
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
int OSSL_STORE_LOADER_set_error(OSSL_STORE_LOADER *loader,
|
||
|
OSSL_STORE_error_fn error_function)
|
||
|
{
|
||
|
loader->error = error_function;
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
int OSSL_STORE_LOADER_set_close(OSSL_STORE_LOADER *loader,
|
||
|
OSSL_STORE_close_fn close_function)
|
||
|
{
|
||
|
loader->close = close_function;
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
void OSSL_STORE_LOADER_free(OSSL_STORE_LOADER *loader)
|
||
|
{
|
||
|
OPENSSL_free(loader);
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Functions for registering OSSL_STORE_LOADERs
|
||
|
*/
|
||
|
|
||
|
static unsigned long store_loader_hash(const OSSL_STORE_LOADER *v)
|
||
|
{
|
||
|
return OPENSSL_LH_strhash(v->scheme);
|
||
|
}
|
||
|
|
||
|
static int store_loader_cmp(const OSSL_STORE_LOADER *a,
|
||
|
const OSSL_STORE_LOADER *b)
|
||
|
{
|
||
|
assert(a->scheme != NULL && b->scheme != NULL);
|
||
|
return strcmp(a->scheme, b->scheme);
|
||
|
}
|
||
|
|
||
|
static LHASH_OF(OSSL_STORE_LOADER) *loader_register = NULL;
|
||
|
|
||
|
int ossl_store_register_loader_int(OSSL_STORE_LOADER *loader)
|
||
|
{
|
||
|
const char *scheme = loader->scheme;
|
||
|
int ok = 0;
|
||
|
|
||
|
/*
|
||
|
* Check that the given scheme conforms to correct scheme syntax as per
|
||
|
* RFC 3986:
|
||
|
*
|
||
|
* scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
|
||
|
*/
|
||
|
if (ossl_isalpha(*scheme))
|
||
|
while (*scheme != '\0'
|
||
|
&& (ossl_isalpha(*scheme)
|
||
|
|| ossl_isdigit(*scheme)
|
||
|
|| strchr("+-.", *scheme) != NULL))
|
||
|
scheme++;
|
||
|
if (*scheme != '\0') {
|
||
|
OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_REGISTER_LOADER_INT,
|
||
|
OSSL_STORE_R_INVALID_SCHEME);
|
||
|
ERR_add_error_data(2, "scheme=", loader->scheme);
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
/* Check that functions we absolutely require are present */
|
||
|
if (loader->open == NULL || loader->load == NULL || loader->eof == NULL
|
||
|
|| loader->error == NULL || loader->close == NULL) {
|
||
|
OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_REGISTER_LOADER_INT,
|
||
|
OSSL_STORE_R_LOADER_INCOMPLETE);
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
if (!RUN_ONCE(®istry_init, do_registry_init)) {
|
||
|
OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_REGISTER_LOADER_INT,
|
||
|
ERR_R_MALLOC_FAILURE);
|
||
|
return 0;
|
||
|
}
|
||
|
CRYPTO_THREAD_write_lock(registry_lock);
|
||
|
|
||
|
if (loader_register == NULL) {
|
||
|
loader_register = lh_OSSL_STORE_LOADER_new(store_loader_hash,
|
||
|
store_loader_cmp);
|
||
|
}
|
||
|
|
||
|
if (loader_register != NULL
|
||
|
&& (lh_OSSL_STORE_LOADER_insert(loader_register, loader) != NULL
|
||
|
|| lh_OSSL_STORE_LOADER_error(loader_register) == 0))
|
||
|
ok = 1;
|
||
|
|
||
|
CRYPTO_THREAD_unlock(registry_lock);
|
||
|
|
||
|
return ok;
|
||
|
}
|
||
|
int OSSL_STORE_register_loader(OSSL_STORE_LOADER *loader)
|
||
|
{
|
||
|
if (!ossl_store_init_once())
|
||
|
return 0;
|
||
|
return ossl_store_register_loader_int(loader);
|
||
|
}
|
||
|
|
||
|
const OSSL_STORE_LOADER *ossl_store_get0_loader_int(const char *scheme)
|
||
|
{
|
||
|
OSSL_STORE_LOADER template;
|
||
|
OSSL_STORE_LOADER *loader = NULL;
|
||
|
|
||
|
template.scheme = scheme;
|
||
|
template.open = NULL;
|
||
|
template.load = NULL;
|
||
|
template.eof = NULL;
|
||
|
template.close = NULL;
|
||
|
|
||
|
if (!ossl_store_init_once())
|
||
|
return NULL;
|
||
|
|
||
|
if (!RUN_ONCE(®istry_init, do_registry_init)) {
|
||
|
OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_GET0_LOADER_INT,
|
||
|
ERR_R_MALLOC_FAILURE);
|
||
|
return NULL;
|
||
|
}
|
||
|
CRYPTO_THREAD_write_lock(registry_lock);
|
||
|
|
||
|
loader = lh_OSSL_STORE_LOADER_retrieve(loader_register, &template);
|
||
|
|
||
|
if (loader == NULL) {
|
||
|
OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_GET0_LOADER_INT,
|
||
|
OSSL_STORE_R_UNREGISTERED_SCHEME);
|
||
|
ERR_add_error_data(2, "scheme=", scheme);
|
||
|
}
|
||
|
|
||
|
CRYPTO_THREAD_unlock(registry_lock);
|
||
|
|
||
|
return loader;
|
||
|
}
|
||
|
|
||
|
OSSL_STORE_LOADER *ossl_store_unregister_loader_int(const char *scheme)
|
||
|
{
|
||
|
OSSL_STORE_LOADER template;
|
||
|
OSSL_STORE_LOADER *loader = NULL;
|
||
|
|
||
|
template.scheme = scheme;
|
||
|
template.open = NULL;
|
||
|
template.load = NULL;
|
||
|
template.eof = NULL;
|
||
|
template.close = NULL;
|
||
|
|
||
|
if (!RUN_ONCE(®istry_init, do_registry_init)) {
|
||
|
OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_UNREGISTER_LOADER_INT,
|
||
|
ERR_R_MALLOC_FAILURE);
|
||
|
return NULL;
|
||
|
}
|
||
|
CRYPTO_THREAD_write_lock(registry_lock);
|
||
|
|
||
|
loader = lh_OSSL_STORE_LOADER_delete(loader_register, &template);
|
||
|
|
||
|
if (loader == NULL) {
|
||
|
OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_UNREGISTER_LOADER_INT,
|
||
|
OSSL_STORE_R_UNREGISTERED_SCHEME);
|
||
|
ERR_add_error_data(2, "scheme=", scheme);
|
||
|
}
|
||
|
|
||
|
CRYPTO_THREAD_unlock(registry_lock);
|
||
|
|
||
|
return loader;
|
||
|
}
|
||
|
OSSL_STORE_LOADER *OSSL_STORE_unregister_loader(const char *scheme)
|
||
|
{
|
||
|
if (!ossl_store_init_once())
|
||
|
return 0;
|
||
|
return ossl_store_unregister_loader_int(scheme);
|
||
|
}
|
||
|
|
||
|
void ossl_store_destroy_loaders_int(void)
|
||
|
{
|
||
|
assert(lh_OSSL_STORE_LOADER_num_items(loader_register) == 0);
|
||
|
lh_OSSL_STORE_LOADER_free(loader_register);
|
||
|
loader_register = NULL;
|
||
|
CRYPTO_THREAD_lock_free(registry_lock);
|
||
|
registry_lock = NULL;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Functions to list OSSL_STORE loaders
|
||
|
*/
|
||
|
|
||
|
IMPLEMENT_LHASH_DOALL_ARG_CONST(OSSL_STORE_LOADER, void);
|
||
|
int OSSL_STORE_do_all_loaders(void (*do_function) (const OSSL_STORE_LOADER
|
||
|
*loader, void *do_arg),
|
||
|
void *do_arg)
|
||
|
{
|
||
|
lh_OSSL_STORE_LOADER_doall_void(loader_register, do_function, do_arg);
|
||
|
return 1;
|
||
|
}
|