CRYPTO_DOWN_REF(&decoder->base.refcnt, &ref, decoder->base.lock);
if (ref > 0)
return;
+ OPENSSL_free(decoder->base.name);
+ ossl_property_free(decoder->base.parsed_propdef);
ossl_provider_free(decoder->base.prov);
CRYPTO_THREAD_lock_free(decoder->base.lock);
OPENSSL_free(decoder);
static const OSSL_LIB_CTX_METHOD decoder_store_method = {
+ /* We want decoder_store to be cleaned up before the provider store */
+ OSSL_LIB_CTX_METHOD_PRIORITY_2,
decoder_store_new,
decoder_store_free,
};
/* Data to be passed through ossl_method_construct() */
struct decoder_data_st {
OSSL_LIB_CTX *libctx;
- OSSL_METHOD_CONSTRUCT_METHOD *mcm;
int id; /* For get_decoder_from_store() */
const char *names; /* For get_decoder_from_store() */
const char *propquery; /* For get_decoder_from_store() */
+ OSSL_METHOD_STORE *tmp_store; /* For get_tmp_decoder_store() */
+
unsigned int flag_construct_error_occurred : 1;
};
*/
/* Temporary decoder method store, constructor and destructor */
-static void *alloc_tmp_decoder_store(OSSL_LIB_CTX *ctx)
+static void *get_tmp_decoder_store(void *data)
{
- return ossl_method_store_new(ctx);
+ struct decoder_data_st *methdata = data;
+
+ if (methdata->tmp_store == NULL)
+ methdata->tmp_store = ossl_method_store_new(methdata->libctx);
+ return methdata->tmp_store;
}
static void dealloc_tmp_decoder_store(void *store)
}
/* Get decoder methods from a store, or put one in */
-static void *get_decoder_from_store(OSSL_LIB_CTX *libctx, void *store,
+static void *get_decoder_from_store(void *store, const OSSL_PROVIDER **prov,
void *data)
{
struct decoder_data_st *methdata = data;
void *method = NULL;
int id;
- if ((id = methdata->id) == 0) {
- OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
-
- id = ossl_namemap_name2num(namemap, methdata->names);
+ /*
+ * get_decoder_from_store() is only called to try and get the method
+ * that OSSL_DECODER_fetch() is asking for, and the name or name id are
+ * passed via methdata.
+ */
+ if ((id = methdata->id) == 0 && methdata->names != NULL) {
+ OSSL_NAMEMAP *namemap = ossl_namemap_stored(methdata->libctx);
+ const char *names = methdata->names;
+ const char *q = strchr(names, NAME_SEPARATOR);
+ size_t l = (q == NULL ? strlen(names) : (size_t)(q - names));
+
+ if (namemap == 0)
+ return NULL;
+ id = ossl_namemap_name2num_n(namemap, names, l);
}
+ if (id == 0)
+ return NULL;
+
if (store == NULL
- && (store = get_decoder_store(libctx)) == NULL)
+ && (store = get_decoder_store(methdata->libctx)) == NULL)
return NULL;
- if (!ossl_method_store_fetch(store, id, methdata->propquery, &method))
+ if (!ossl_method_store_fetch(store, id, methdata->propquery, prov, &method))
return NULL;
return method;
}
-static int put_decoder_in_store(OSSL_LIB_CTX *libctx, void *store,
- void *method, const OSSL_PROVIDER *prov,
- int operation_id, const char *names,
- const char *propdef, void *unused)
+static int put_decoder_in_store(void *store, void *method,
+ const OSSL_PROVIDER *prov,
+ const char *names, const char *propdef,
+ void *data)
{
+ struct decoder_data_st *methdata = data;
OSSL_NAMEMAP *namemap;
int id;
+ size_t l = 0;
- if ((namemap = ossl_namemap_stored(libctx)) == NULL
- || (id = ossl_namemap_name2num(namemap, names)) == 0)
+ /*
+ * put_decoder_in_store() is only called with an OSSL_DECODER method that
+ * was successfully created by construct_decoder() below, which means that
+ * all the names should already be stored in the namemap with the same
+ * numeric identity, so just use the first to get that identity.
+ */
+ if (names != NULL) {
+ const char *q = strchr(names, NAME_SEPARATOR);
+
+ l = (q == NULL ? strlen(names) : (size_t)(q - names));
+ }
+
+ if ((namemap = ossl_namemap_stored(methdata->libctx)) == NULL
+ || (id = ossl_namemap_name2num_n(namemap, names, l)) == 0)
return 0;
- if (store == NULL && (store = get_decoder_store(libctx)) == NULL)
+ if (store == NULL && (store = get_decoder_store(methdata->libctx)) == NULL)
return 0;
return ossl_method_store_add(store, prov, id, propdef, method,
{
OSSL_DECODER *decoder = NULL;
const OSSL_DISPATCH *fns = algodef->implementation;
+ OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov);
if ((decoder = ossl_decoder_new()) == NULL)
return NULL;
decoder->base.id = id;
- decoder->base.propdef = algodef->property_definition;
- decoder->base.description = algodef->algorithm_description;
+ if ((decoder->base.name = ossl_algorithm_get1_first_name(algodef)) == NULL) {
+ OSSL_DECODER_free(decoder);
+ return NULL;
+ }
+ decoder->base.algodef = algodef;
+ decoder->base.parsed_propdef
+ = ossl_parse_property(libctx, algodef->property_definition);
for (; fns->function_id != 0; fns++) {
switch (fns->function_id) {
}
/* Fetching support. Can fetch by numeric identity or by name */
-static OSSL_DECODER *inner_ossl_decoder_fetch(OSSL_LIB_CTX *libctx, int id,
- const char *name,
- const char *properties)
+static OSSL_DECODER *
+inner_ossl_decoder_fetch(struct decoder_data_st *methdata, int id,
+ const char *name, const char *properties)
{
- OSSL_METHOD_STORE *store = get_decoder_store(libctx);
- OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
+ OSSL_METHOD_STORE *store = get_decoder_store(methdata->libctx);
+ OSSL_NAMEMAP *namemap = ossl_namemap_stored(methdata->libctx);
void *method = NULL;
int unsupported = 0;
}
/*
- * If we have been passed neither a name_id or a name, we have an
+ * If we have been passed both an id and a name, we have an
* internal programming error.
*/
- if (!ossl_assert(id != 0 || name != NULL)) {
+ if (!ossl_assert(id == 0 || name == NULL)) {
ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_INTERNAL_ERROR);
return NULL;
}
- if (id == 0)
+ if (id == 0 && name != NULL)
id = ossl_namemap_name2num(namemap, name);
/*
unsupported = 1;
if (id == 0
- || !ossl_method_store_cache_get(store, id, properties, &method)) {
+ || !ossl_method_store_cache_get(store, NULL, id, properties, &method)) {
OSSL_METHOD_CONSTRUCT_METHOD mcm = {
- alloc_tmp_decoder_store,
- dealloc_tmp_decoder_store,
+ get_tmp_decoder_store,
get_decoder_from_store,
put_decoder_in_store,
construct_decoder,
destruct_decoder
};
- struct decoder_data_st mcmdata;
-
- mcmdata.libctx = libctx;
- mcmdata.mcm = &mcm;
- mcmdata.id = id;
- mcmdata.names = name;
- mcmdata.propquery = properties;
- mcmdata.flag_construct_error_occurred = 0;
- if ((method = ossl_method_construct(libctx, OSSL_OP_DECODER,
- 0 /* !force_cache */,
- &mcm, &mcmdata)) != NULL) {
+ OSSL_PROVIDER *prov = NULL;
+
+ methdata->id = id;
+ methdata->names = name;
+ methdata->propquery = properties;
+ methdata->flag_construct_error_occurred = 0;
+ if ((method = ossl_method_construct(methdata->libctx, OSSL_OP_DECODER,
+ &prov, 0 /* !force_cache */,
+ &mcm, methdata)) != NULL) {
/*
* If construction did create a method for us, we know that
* there is a correct name_id and meth_id, since those have
* already been calculated in get_decoder_from_store() and
* put_decoder_in_store() above.
*/
- if (id == 0)
+ if (id == 0 && name != NULL)
id = ossl_namemap_name2num(namemap, name);
- ossl_method_store_cache_set(store, id, properties, method,
- up_ref_decoder, free_decoder);
+ if (id != 0)
+ ossl_method_store_cache_set(store, prov, id, properties, method,
+ up_ref_decoder, free_decoder);
}
/*
* If we never were in the constructor, the algorithm to be fetched
* is unsupported.
*/
- unsupported = !mcmdata.flag_construct_error_occurred;
+ unsupported = !methdata->flag_construct_error_occurred;
}
- if (method == NULL) {
+ if ((id != 0 || name != NULL) && method == NULL) {
int code = unsupported ? ERR_R_UNSUPPORTED : ERR_R_FETCH_FAILED;
if (name == NULL)
name = ossl_namemap_num2name(namemap, id, 0);
ERR_raise_data(ERR_LIB_OSSL_DECODER, code,
"%s, Name (%s : %d), Properties (%s)",
- ossl_lib_ctx_get_descriptor(libctx),
+ ossl_lib_ctx_get_descriptor(methdata->libctx),
name = NULL ? "<null>" : name, id,
properties == NULL ? "<null>" : properties);
}
OSSL_DECODER *OSSL_DECODER_fetch(OSSL_LIB_CTX *libctx, const char *name,
const char *properties)
{
- return inner_ossl_decoder_fetch(libctx, 0, name, properties);
+ struct decoder_data_st methdata;
+ void *method;
+
+ methdata.libctx = libctx;
+ methdata.tmp_store = NULL;
+ method = inner_ossl_decoder_fetch(&methdata, 0, name, properties);
+ dealloc_tmp_decoder_store(methdata.tmp_store);
+ return method;
}
OSSL_DECODER *ossl_decoder_fetch_by_number(OSSL_LIB_CTX *libctx, int id,
const char *properties)
{
- return inner_ossl_decoder_fetch(libctx, id, NULL, properties);
+ struct decoder_data_st methdata;
+ void *method;
+
+ methdata.libctx = libctx;
+ methdata.tmp_store = NULL;
+ method = inner_ossl_decoder_fetch(&methdata, id, NULL, properties);
+ dealloc_tmp_decoder_store(methdata.tmp_store);
+ return method;
}
/*
* Library of basic method functions
*/
-const OSSL_PROVIDER *OSSL_DECODER_provider(const OSSL_DECODER *decoder)
+const OSSL_PROVIDER *OSSL_DECODER_get0_provider(const OSSL_DECODER *decoder)
{
if (!ossl_assert(decoder != NULL)) {
ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_PASSED_NULL_PARAMETER);
return decoder->base.prov;
}
-const char *OSSL_DECODER_properties(const OSSL_DECODER *decoder)
+const char *OSSL_DECODER_get0_properties(const OSSL_DECODER *decoder)
+{
+ if (!ossl_assert(decoder != NULL)) {
+ ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_PASSED_NULL_PARAMETER);
+ return 0;
+ }
+
+ return decoder->base.algodef->property_definition;
+}
+
+const OSSL_PROPERTY_LIST *
+ossl_decoder_parsed_properties(const OSSL_DECODER *decoder)
{
if (!ossl_assert(decoder != NULL)) {
ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
- return decoder->base.propdef;
+ return decoder->base.parsed_propdef;
}
-int OSSL_DECODER_number(const OSSL_DECODER *decoder)
+int ossl_decoder_get_number(const OSSL_DECODER *decoder)
{
if (!ossl_assert(decoder != NULL)) {
ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_PASSED_NULL_PARAMETER);
return decoder->base.id;
}
-const char *OSSL_DECODER_description(const OSSL_DECODER *decoder)
+const char *OSSL_DECODER_get0_name(const OSSL_DECODER *decoder)
{
- return decoder->base.description;
+ return decoder->base.name;
+}
+
+const char *OSSL_DECODER_get0_description(const OSSL_DECODER *decoder)
+{
+ return decoder->base.algodef->algorithm_description;
}
int OSSL_DECODER_is_a(const OSSL_DECODER *decoder, const char *name)
return 0;
}
-struct decoder_do_all_data_st {
- void (*user_fn)(void *method, void *arg);
+struct do_one_data_st {
+ void (*user_fn)(OSSL_DECODER *decoder, void *arg);
void *user_arg;
};
-static void decoder_do_one(OSSL_PROVIDER *provider,
- const OSSL_ALGORITHM *algodef,
- int no_store, void *vdata)
+static void do_one(ossl_unused int id, void *method, void *arg)
{
- struct decoder_do_all_data_st *data = vdata;
- OSSL_LIB_CTX *libctx = ossl_provider_libctx(provider);
- OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
- const char *names = algodef->algorithm_names;
- int id = ossl_namemap_add_names(namemap, 0, names, NAME_SEPARATOR);
- void *method = NULL;
-
- if (id != 0)
- method = ossl_decoder_from_algorithm(id, algodef, provider);
+ struct do_one_data_st *data = arg;
- if (method != NULL) {
- data->user_fn(method, data->user_arg);
- OSSL_DECODER_free(method);
- }
+ data->user_fn(method, data->user_arg);
}
void OSSL_DECODER_do_all_provided(OSSL_LIB_CTX *libctx,
- void (*fn)(OSSL_DECODER *decoder, void *arg),
- void *arg)
+ void (*user_fn)(OSSL_DECODER *decoder,
+ void *arg),
+ void *user_arg)
{
- struct decoder_do_all_data_st data;
+ struct decoder_data_st methdata;
+ struct do_one_data_st data;
+
+ methdata.libctx = libctx;
+ methdata.tmp_store = NULL;
+ (void)inner_ossl_decoder_fetch(&methdata, 0, NULL, NULL /* properties */);
- data.user_fn = (void (*)(void *, void *))fn;
- data.user_arg = arg;
- ossl_algorithm_do_all(libctx, OSSL_OP_DECODER, NULL,
- NULL, decoder_do_one, NULL,
- &data);
+ data.user_fn = user_fn;
+ data.user_arg = user_arg;
+ if (methdata.tmp_store != NULL)
+ ossl_method_store_do_all(methdata.tmp_store, &do_one, &data);
+ ossl_method_store_do_all(get_decoder_store(libctx), &do_one, &data);
+ dealloc_tmp_decoder_store(methdata.tmp_store);
}
int OSSL_DECODER_names_do_all(const OSSL_DECODER *decoder,
OSSL_DECODER_gettable_params(OSSL_DECODER *decoder)
{
if (decoder != NULL && decoder->gettable_params != NULL) {
- void *provctx = ossl_provider_ctx(OSSL_DECODER_provider(decoder));
+ void *provctx = ossl_provider_ctx(OSSL_DECODER_get0_provider(decoder));
return decoder->gettable_params(provctx);
}
OSSL_DECODER_settable_ctx_params(OSSL_DECODER *decoder)
{
if (decoder != NULL && decoder->settable_ctx_params != NULL) {
- void *provctx = ossl_provider_ctx(OSSL_DECODER_provider(decoder));
+ void *provctx = ossl_provider_ctx(OSSL_DECODER_get0_provider(decoder));
return decoder->settable_ctx_params(provctx);
}
projects / openssl.git / blobdiff