static const OSSL_LIB_CTX_METHOD encoder_store_method = {
- OSSL_LIB_CTX_METHOD_DEFAULT_PRIORITY,
+ /* We want encoder_store to be cleaned up before the provider store */
+ OSSL_LIB_CTX_METHOD_PRIORITY_2,
encoder_store_new,
encoder_store_free,
};
/* Data to be passed through ossl_method_construct() */
struct encoder_data_st {
OSSL_LIB_CTX *libctx;
- OSSL_METHOD_CONSTRUCT_METHOD *mcm;
int id; /* For get_encoder_from_store() */
const char *names; /* For get_encoder_from_store() */
const char *propquery; /* For get_encoder_from_store() */
+ OSSL_METHOD_STORE *tmp_store; /* For get_tmp_encoder_store() */
+
unsigned int flag_construct_error_occurred : 1;
};
*/
/* Temporary encoder method store, constructor and destructor */
-static void *alloc_tmp_encoder_store(OSSL_LIB_CTX *ctx)
+static void *get_tmp_encoder_store(void *data)
{
- return ossl_method_store_new(ctx);
+ struct encoder_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_encoder_store(void *store)
}
/* Get encoder methods from a store, or put one in */
-static void *get_encoder_from_store(OSSL_LIB_CTX *libctx, void *store,
+static void *get_encoder_from_store(void *store, const OSSL_PROVIDER **prov,
void *data)
{
struct encoder_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_encoder_from_store() is only called to try and get the method
+ * that OSSL_ENCODER_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, methdata->names, l);
}
+ if (id == 0)
+ return NULL;
+
if (store == NULL
- && (store = get_encoder_store(libctx)) == NULL)
+ && (store = get_encoder_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_encoder_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_encoder_in_store(void *store, void *method,
+ const OSSL_PROVIDER *prov,
+ const char *names, const char *propdef,
+ void *data)
{
+ struct encoder_data_st *methdata = data;
OSSL_NAMEMAP *namemap;
int id;
+ size_t l = 0;
+
+ /*
+ * put_encoder_in_store() is only called with an OSSL_ENCODER method that
+ * was successfully created by construct_encoder() 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(libctx)) == NULL
- || (id = ossl_namemap_name2num(namemap, names)) == 0)
+ if ((namemap = ossl_namemap_stored(methdata->libctx)) == NULL
+ || (id = ossl_namemap_name2num_n(namemap, names, l)) == 0)
return 0;
- if (store == NULL && (store = get_encoder_store(libctx)) == NULL)
+ if (store == NULL && (store = get_encoder_store(methdata->libctx)) == NULL)
return 0;
return ossl_method_store_add(store, prov, id, propdef, method,
OSSL_ENCODER_free(encoder);
return NULL;
}
- encoder->base.propdef = algodef->property_definition;
- encoder->base.description = algodef->algorithm_description;
+ encoder->base.algodef = algodef;
encoder->base.parsed_propdef
= ossl_parse_property(libctx, algodef->property_definition);
}
/* Fetching support. Can fetch by numeric identity or by name */
-static OSSL_ENCODER *inner_ossl_encoder_fetch(OSSL_LIB_CTX *libctx,
- int id, const char *name,
- const char *properties)
+static OSSL_ENCODER *
+inner_ossl_encoder_fetch(struct encoder_data_st *methdata, int id,
+ const char *name, const char *properties)
{
- OSSL_METHOD_STORE *store = get_encoder_store(libctx);
- OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
+ OSSL_METHOD_STORE *store = get_encoder_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_ENCODER, ERR_R_INTERNAL_ERROR);
return NULL;
}
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_encoder_store,
- dealloc_tmp_encoder_store,
+ get_tmp_encoder_store,
get_encoder_from_store,
put_encoder_in_store,
construct_encoder,
destruct_encoder
};
- struct encoder_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_ENCODER,
- 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_ENCODER,
+ &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
*/
if (id == 0)
id = ossl_namemap_name2num(namemap, name);
- ossl_method_store_cache_set(store, id, properties, method,
+ ossl_method_store_cache_set(store, prov, id, properties, method,
up_ref_encoder, free_encoder);
}
* 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_ENCODER, 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_ENCODER *OSSL_ENCODER_fetch(OSSL_LIB_CTX *libctx, const char *name,
const char *properties)
{
- return inner_ossl_encoder_fetch(libctx, 0, name, properties);
+ struct encoder_data_st methdata;
+ void *method;
+
+ methdata.libctx = libctx;
+ methdata.tmp_store = NULL;
+ method = inner_ossl_encoder_fetch(&methdata, 0, name, properties);
+ dealloc_tmp_encoder_store(methdata.tmp_store);
+ return method;
}
OSSL_ENCODER *ossl_encoder_fetch_by_number(OSSL_LIB_CTX *libctx, int id,
const char *properties)
{
- return inner_ossl_encoder_fetch(libctx, id, NULL, properties);
+ struct encoder_data_st methdata;
+ void *method;
+
+ methdata.libctx = libctx;
+ methdata.tmp_store = NULL;
+ method = inner_ossl_encoder_fetch(&methdata, id, NULL, properties);
+ dealloc_tmp_encoder_store(methdata.tmp_store);
+ return method;
}
/*
return 0;
}
- return encoder->base.propdef;
+ return encoder->base.algodef->property_definition;
}
const OSSL_PROPERTY_LIST *
const char *OSSL_ENCODER_get0_description(const OSSL_ENCODER *encoder)
{
- return encoder->base.description;
+ return encoder->base.algodef->algorithm_description;
}
int OSSL_ENCODER_is_a(const OSSL_ENCODER *encoder, const char *name)
return 0;
}
-struct encoder_do_all_data_st {
- void (*user_fn)(void *method, void *arg);
+struct do_one_data_st {
+ void (*user_fn)(OSSL_ENCODER *encoder, void *arg);
void *user_arg;
};
-static void encoder_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 encoder_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;
+ struct do_one_data_st *data = arg;
- if (id != 0)
- method =
- encoder_from_algorithm(id, algodef, provider);
-
- if (method != NULL) {
- data->user_fn(method, data->user_arg);
- OSSL_ENCODER_free(method);
- }
+ data->user_fn(method, data->user_arg);
}
void OSSL_ENCODER_do_all_provided(OSSL_LIB_CTX *libctx,
- void (*fn)(OSSL_ENCODER *encoder, void *arg),
- void *arg)
-{
- struct encoder_do_all_data_st data;
-
- data.user_fn = (void (*)(void *, void *))fn;
- data.user_arg = arg;
-
- /*
- * No pre- or post-condition for this call, as this only creates methods
- * temporarly and then promptly destroys them.
- */
- ossl_algorithm_do_all(libctx, OSSL_OP_ENCODER, NULL, NULL,
- encoder_do_one, NULL, &data);
+ void (*user_fn)(OSSL_ENCODER *encoder,
+ void *arg),
+ void *user_arg)
+{
+ struct encoder_data_st methdata;
+ struct do_one_data_st data;
+
+ methdata.libctx = libctx;
+ methdata.tmp_store = NULL;
+ (void)inner_ossl_encoder_fetch(&methdata, 0, NULL, NULL /* properties */);
+
+ 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_encoder_store(libctx), &do_one, &data);
+ dealloc_tmp_encoder_store(methdata.tmp_store);
}
int OSSL_ENCODER_names_do_all(const OSSL_ENCODER *encoder,
projects / openssl.git / blobdiff