[thirdparty/openssl.git] / crypto / encode_decode / encoder_meth.c

/*
 * Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (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 <openssl/core.h>
#include <openssl/core_dispatch.h>
#include <openssl/encoder.h>
#include <openssl/ui.h>
#include "internal/core.h"
#include "internal/namemap.h"
#include "internal/property.h"
#include "internal/provider.h"
#include "crypto/encoder.h"
#include "encoder_local.h"

/*
 * Encoder can have multiple names, separated with colons in a name string
 */
#define NAME_SEPARATOR ':'

/* Simple method structure constructor and destructor */
static OSSL_ENCODER *ossl_encoder_new(void)
{
    OSSL_ENCODER *encoder = NULL;

    if ((encoder = OPENSSL_zalloc(sizeof(*encoder))) == NULL
        || (encoder->base.lock = CRYPTO_THREAD_lock_new()) == NULL) {
        OSSL_ENCODER_free(encoder);
        ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_MALLOC_FAILURE);
        return NULL;
    }

    encoder->base.refcnt = 1;

    return encoder;
}

int OSSL_ENCODER_up_ref(OSSL_ENCODER *encoder)
{
    int ref = 0;

    CRYPTO_UP_REF(&encoder->base.refcnt, &ref, encoder->base.lock);
    return 1;
}

void OSSL_ENCODER_free(OSSL_ENCODER *encoder)
{
    int ref = 0;

    if (encoder == NULL)
        return;

    CRYPTO_DOWN_REF(&encoder->base.refcnt, &ref, encoder->base.lock);
    if (ref > 0)
        return;
    ossl_provider_free(encoder->base.prov);
    CRYPTO_THREAD_lock_free(encoder->base.lock);
    OPENSSL_free(encoder);
}

/* Permanent encoder method store, constructor and destructor */
static void encoder_store_free(void *vstore)
{
    ossl_method_store_free(vstore);
}

static void *encoder_store_new(OSSL_LIB_CTX *ctx)
{
    return ossl_method_store_new(ctx);
}


static const OSSL_LIB_CTX_METHOD encoder_store_method = {
    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() */
};

/*
 * Generic routines to fetch / create ENCODER methods with
 * ossl_method_construct()
 */

/* Temporary encoder method store, constructor and destructor */
static void *alloc_tmp_encoder_store(OSSL_LIB_CTX *ctx)
{
    return ossl_method_store_new(ctx);
}

static void dealloc_tmp_encoder_store(void *store)
{
    if (store != NULL)
        ossl_method_store_free(store);
}

/* Get the permanent encoder store */
static OSSL_METHOD_STORE *get_encoder_store(OSSL_LIB_CTX *libctx)
{
    return ossl_lib_ctx_get_data(libctx, OSSL_LIB_CTX_ENCODER_STORE_INDEX,
                                 &encoder_store_method);
}

/* Get encoder methods from a store, or put one in */
static void *get_encoder_from_store(OSSL_LIB_CTX *libctx, void *store,
                                    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);
    }

    if (store == NULL
        && (store = get_encoder_store(libctx)) == NULL)
        return NULL;

    if (!ossl_method_store_fetch(store, id, methdata->propquery, &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)
{
    OSSL_NAMEMAP *namemap;
    int id;

    if ((namemap = ossl_namemap_stored(libctx)) == NULL
        || (id = ossl_namemap_name2num(namemap, names)) == 0)
        return 0;

    if (store == NULL && (store = get_encoder_store(libctx)) == NULL)
        return 0;

    return ossl_method_store_add(store, prov, id, propdef, method,
                                 (int (*)(void *))OSSL_ENCODER_up_ref,
                                 (void (*)(void *))OSSL_ENCODER_free);
}

/* Create and populate a encoder method */
static void *encoder_from_dispatch(int id, const OSSL_ALGORITHM *algodef,
                                   OSSL_PROVIDER *prov)
{
    OSSL_ENCODER *encoder = NULL;
    const OSSL_DISPATCH *fns = algodef->implementation;

    if ((encoder = ossl_encoder_new()) == NULL)
        return NULL;
    encoder->base.id = id;
    encoder->base.propdef = algodef->property_definition;

    for (; fns->function_id != 0; fns++) {
        switch (fns->function_id) {
        case OSSL_FUNC_ENCODER_NEWCTX:
            if (encoder->newctx == NULL)
                encoder->newctx =
                    OSSL_FUNC_encoder_newctx(fns);
            break;
        case OSSL_FUNC_ENCODER_FREECTX:
            if (encoder->freectx == NULL)
                encoder->freectx =
                    OSSL_FUNC_encoder_freectx(fns);
            break;
        case OSSL_FUNC_ENCODER_GET_PARAMS:
            if (encoder->get_params == NULL)
                encoder->get_params =
                    OSSL_FUNC_encoder_get_params(fns);
            break;
        case OSSL_FUNC_ENCODER_GETTABLE_PARAMS:
            if (encoder->gettable_params == NULL)
                encoder->gettable_params =
                    OSSL_FUNC_encoder_gettable_params(fns);
            break;
        case OSSL_FUNC_ENCODER_SET_CTX_PARAMS:
            if (encoder->set_ctx_params == NULL)
                encoder->set_ctx_params =
                    OSSL_FUNC_encoder_set_ctx_params(fns);
            break;
        case OSSL_FUNC_ENCODER_SETTABLE_CTX_PARAMS:
            if (encoder->settable_ctx_params == NULL)
                encoder->settable_ctx_params =
                    OSSL_FUNC_encoder_settable_ctx_params(fns);
            break;
        case OSSL_FUNC_ENCODER_ENCODE:
            if (encoder->encode == NULL)
                encoder->encode = OSSL_FUNC_encoder_encode(fns);
            break;
        case OSSL_FUNC_ENCODER_IMPORT_OBJECT:
            if (encoder->import_object == NULL)
                encoder->import_object =
                    OSSL_FUNC_encoder_import_object(fns);
            break;
        case OSSL_FUNC_ENCODER_FREE_OBJECT:
            if (encoder->free_object == NULL)
                encoder->free_object =
                    OSSL_FUNC_encoder_free_object(fns);
            break;
        }
    }
    /*
     * Try to check that the method is sensible.
     * If you have a constructor, you must have a destructor and vice versa.
     * You must have the encoding driver functions.
     */
    if (!((encoder->newctx == NULL && encoder->freectx == NULL)
          || (encoder->newctx != NULL && encoder->freectx != NULL)
          || (encoder->import_object != NULL && encoder->free_object != NULL)
          || (encoder->import_object == NULL && encoder->free_object == NULL))
        || encoder->encode == NULL
        || encoder->gettable_params == NULL
        || encoder->get_params == NULL) {
        OSSL_ENCODER_free(encoder);
        ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_INVALID_PROVIDER_FUNCTIONS);
        return NULL;
    }

    if (prov != NULL && !ossl_provider_up_ref(prov)) {
        OSSL_ENCODER_free(encoder);
        return NULL;
    }

    encoder->base.prov = prov;
    return encoder;
}


/*
 * The core fetching functionality passes the names of the implementation.
 * This function is responsible to getting an identity number for them,
 * then call encoder_from_dispatch() with that identity number.
 */
static void *construct_encoder(const OSSL_ALGORITHM *algodef,
                               OSSL_PROVIDER *prov, void *unused)
{
    /*
     * This function is only called if get_encoder_from_store() returned
     * NULL, so it's safe to say that of all the spots to create a new
     * namemap entry, this is it.  Should the name already exist there, we
     * know that ossl_namemap_add() will return its corresponding number.
     */
    OSSL_LIB_CTX *libctx = ossl_provider_library_context(prov);
    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 = encoder_from_dispatch(id, algodef, prov);

    return method;
}

/* Intermediary function to avoid ugly casts, used below */
static void destruct_encoder(void *method, void *data)
{
    OSSL_ENCODER_free(method);
}

static int up_ref_encoder(void *method)
{
    return OSSL_ENCODER_up_ref(method);
}

static void free_encoder(void *method)
{
    OSSL_ENCODER_free(method);
}

/* 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)
{
    OSSL_METHOD_STORE *store = get_encoder_store(libctx);
    OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
    void *method = NULL;

    if (store == NULL || namemap == NULL)
        return NULL;

    /*
     * If we have been passed neither a name_id or a name, we have an
     * internal programming error.
     */
    if (!ossl_assert(id != 0 || name != NULL))
        return NULL;

    if (id == 0)
        id = ossl_namemap_name2num(namemap, name);

    if (id == 0
        || !ossl_method_store_cache_get(store, id, properties, &method)) {
        OSSL_METHOD_CONSTRUCT_METHOD mcm = {
            alloc_tmp_encoder_store,
            dealloc_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;
        if ((method = ossl_method_construct(libctx, OSSL_OP_ENCODER,
                                            0 /* !force_cache */,
                                            &mcm, &mcmdata)) != 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_encoder_from_store() and
             * put_encoder_in_store() above.
             */
            if (id == 0)
                id = ossl_namemap_name2num(namemap, name);
            ossl_method_store_cache_set(store, id, properties, method,
                                        up_ref_encoder, free_encoder);
        }
    }

    return method;
}

OSSL_ENCODER *OSSL_ENCODER_fetch(OSSL_LIB_CTX *libctx, const char *name,
                                 const char *properties)
{
    return inner_ossl_encoder_fetch(libctx, 0, name, properties);
}

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);
}

/*
 * Library of basic method functions
 */

const OSSL_PROVIDER *OSSL_ENCODER_provider(const OSSL_ENCODER *encoder)
{
    if (!ossl_assert(encoder != NULL)) {
        ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
        return 0;
    }

    return encoder->base.prov;
}

const char *OSSL_ENCODER_properties(const OSSL_ENCODER *encoder)
{
    if (!ossl_assert(encoder != NULL)) {
        ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
        return 0;
    }

    return encoder->base.propdef;
}

int OSSL_ENCODER_number(const OSSL_ENCODER *encoder)
{
    if (!ossl_assert(encoder != NULL)) {
        ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
        return 0;
    }

    return encoder->base.id;
}

int OSSL_ENCODER_is_a(const OSSL_ENCODER *encoder, const char *name)
{
    if (encoder->base.prov != NULL) {
        OSSL_LIB_CTX *libctx = ossl_provider_library_context(encoder->base.prov);
        OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);

        return ossl_namemap_name2num(namemap, name) == encoder->base.id;
    }
    return 0;
}

struct encoder_do_all_data_st {
    void (*user_fn)(void *method, void *arg);
    void *user_arg;
};

static void encoder_do_one(OSSL_PROVIDER *provider,
                           const OSSL_ALGORITHM *algodef,
                           int no_store, void *vdata)
{
    struct encoder_do_all_data_st *data = vdata;
    OSSL_LIB_CTX *libctx = ossl_provider_library_context(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 =
            encoder_from_dispatch(id, algodef, provider);

    if (method != NULL) {
        data->user_fn(method, data->user_arg);
        OSSL_ENCODER_free(method);
    }
}

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 OSSL_ENCODER_names_do_all(const OSSL_ENCODER *encoder,
                               void (*fn)(const char *name, void *data),
                               void *data)
{
    if (encoder == NULL)
        return;

    if (encoder->base.prov != NULL) {
        OSSL_LIB_CTX *libctx = ossl_provider_library_context(encoder->base.prov);
        OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);

        ossl_namemap_doall_names(namemap, encoder->base.id, fn, data);
    }
}

const OSSL_PARAM *
OSSL_ENCODER_gettable_params(OSSL_ENCODER *encoder)
{
    if (encoder != NULL && encoder->gettable_params != NULL) {
        void *provctx = ossl_provider_ctx(OSSL_ENCODER_provider(encoder));

        return encoder->gettable_params(provctx);
    }
    return NULL;
}

int OSSL_ENCODER_get_params(OSSL_ENCODER *encoder, OSSL_PARAM params[])
{
    if (encoder != NULL && encoder->get_params != NULL)
        return encoder->get_params(params);
    return 0;
}

const OSSL_PARAM *OSSL_ENCODER_settable_ctx_params(OSSL_ENCODER *encoder)
{
    if (encoder != NULL && encoder->settable_ctx_params != NULL) {
        void *provctx = ossl_provider_ctx(OSSL_ENCODER_provider(encoder));

        return encoder->settable_ctx_params(provctx);
    }
    return NULL;
}

/*
 * Encoder context support
 */

OSSL_ENCODER_CTX *OSSL_ENCODER_CTX_new(void)
{
    OSSL_ENCODER_CTX *ctx;

    if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL)
        ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_MALLOC_FAILURE);

    return ctx;
}

int OSSL_ENCODER_CTX_set_params(OSSL_ENCODER_CTX *ctx,
                                const OSSL_PARAM params[])
{
    size_t i;
    size_t l;

    if (!ossl_assert(ctx != NULL)) {
        ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
        return 0;
    }

    if (ctx->encoder_insts == NULL)
        return 1;

    l = OSSL_ENCODER_CTX_get_num_encoders(ctx);
    for (i = 0; i < l; i++) {
        OSSL_ENCODER_INSTANCE *encoder_inst =
            sk_OSSL_ENCODER_INSTANCE_value(ctx->encoder_insts, i);
        OSSL_ENCODER *encoder = OSSL_ENCODER_INSTANCE_get_encoder(encoder_inst);
        void *encoderctx = OSSL_ENCODER_INSTANCE_get_encoder_ctx(encoder_inst);

        if (encoderctx == NULL || encoder->set_ctx_params == NULL)
            continue;
        if (!encoder->set_ctx_params(encoderctx, params))
            return 0;
    }
    return 1;
}

void OSSL_ENCODER_CTX_free(OSSL_ENCODER_CTX *ctx)
{
    if (ctx != NULL) {
        sk_OSSL_ENCODER_INSTANCE_pop_free(ctx->encoder_insts,
                                          ossl_encoder_instance_free);
        OPENSSL_free(ctx->construct_data);
        ossl_pw_clear_passphrase_data(&ctx->pwdata);
        OPENSSL_free(ctx);
    }
}
Commit	Line	Data
ece9304c RL	1	/*
	2	* Copyright 2019-2020 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 <openssl/core.h>
	11	#include <openssl/core_dispatch.h>
	12	#include <openssl/encoder.h>
	13	#include <openssl/ui.h>
	14	#include "internal/core.h"
	15	#include "internal/namemap.h"
	16	#include "internal/property.h"
	17	#include "internal/provider.h"
	18	#include "crypto/encoder.h"
	19	#include "encoder_local.h"
	20
	21	/*
	22	* Encoder can have multiple names, separated with colons in a name string
	23	*/
	24	#define NAME_SEPARATOR ':'
	25
	26	/* Simple method structure constructor and destructor */
	27	static OSSL_ENCODER *ossl_encoder_new(void)
	28	{
	29	OSSL_ENCODER *encoder = NULL;
	30
	31	if ((encoder = OPENSSL_zalloc(sizeof(*encoder))) == NULL
	32	\|\| (encoder->base.lock = CRYPTO_THREAD_lock_new()) == NULL) {
	33	OSSL_ENCODER_free(encoder);
	34	ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_MALLOC_FAILURE);
	35	return NULL;
	36	}
	37
	38	encoder->base.refcnt = 1;
	39
	40	return encoder;
	41	}
	42
	43	int OSSL_ENCODER_up_ref(OSSL_ENCODER *encoder)
	44	{
	45	int ref = 0;
	46
	47	CRYPTO_UP_REF(&encoder->base.refcnt, &ref, encoder->base.lock);
	48	return 1;
	49	}
	50
	51	void OSSL_ENCODER_free(OSSL_ENCODER *encoder)
	52	{
	53	int ref = 0;
	54
	55	if (encoder == NULL)
	56	return;
	57
	58	CRYPTO_DOWN_REF(&encoder->base.refcnt, &ref, encoder->base.lock);
	59	if (ref > 0)
	60	return;
	61	ossl_provider_free(encoder->base.prov);
	62	CRYPTO_THREAD_lock_free(encoder->base.lock);
	63	OPENSSL_free(encoder);
	64	}
65
66	/* Permanent encoder method store, constructor and destructor */
67	static void encoder_store_free(void *vstore)
68	{
69	ossl_method_store_free(vstore);
70	}
71
b4250010	72	static void encoder_store_new(OSSL_LIB_CTX ctx)
ece9304c RL	73	{
	74	return ossl_method_store_new(ctx);
	75	}
	76
	77
b4250010	78	static const OSSL_LIB_CTX_METHOD encoder_store_method = {
ece9304c RL	79	encoder_store_new,
	80	encoder_store_free,
	81	};
	82
	83	/* Data to be passed through ossl_method_construct() */
	84	struct encoder_data_st {
b4250010	85	OSSL_LIB_CTX *libctx;
ece9304c RL	86	OSSL_METHOD_CONSTRUCT_METHOD *mcm;
	87	int id; /* For get_encoder_from_store() */
	88	const char names; / For get_encoder_from_store() */
	89	const char propquery; / For get_encoder_from_store() */
	90	};
	91
	92	/*
	93	* Generic routines to fetch / create ENCODER methods with
	94	* ossl_method_construct()
	95	*/
	96
	97	/* Temporary encoder method store, constructor and destructor */
b4250010	98	static void alloc_tmp_encoder_store(OSSL_LIB_CTX ctx)
ece9304c RL	99	{
	100	return ossl_method_store_new(ctx);
	101	}
	102
	103	static void dealloc_tmp_encoder_store(void *store)
	104	{
	105	if (store != NULL)
	106	ossl_method_store_free(store);
	107	}
	108
	109	/* Get the permanent encoder store */
b4250010	110	static OSSL_METHOD_STORE get_encoder_store(OSSL_LIB_CTX libctx)
ece9304c	111	{
b4250010 DMSP	112	return ossl_lib_ctx_get_data(libctx, OSSL_LIB_CTX_ENCODER_STORE_INDEX,
b4250010 DMSP	113	&encoder_store_method);
ece9304c RL	114	}
	115
	116	/* Get encoder methods from a store, or put one in */
b4250010	117	static void get_encoder_from_store(OSSL_LIB_CTX libctx, void *store,
ece9304c RL	118	void *data)
	119	{
	120	struct encoder_data_st *methdata = data;
	121	void *method = NULL;
	122	int id;
	123
	124	if ((id = methdata->id) == 0) {
	125	OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
	126
	127	id = ossl_namemap_name2num(namemap, methdata->names);
	128	}
	129
	130	if (store == NULL
	131	&& (store = get_encoder_store(libctx)) == NULL)
	132	return NULL;
	133
	134	if (!ossl_method_store_fetch(store, id, methdata->propquery, &method))
	135	return NULL;
	136	return method;
	137	}
	138
b4250010	139	static int put_encoder_in_store(OSSL_LIB_CTX libctx, void store,
ece9304c RL	140	void method, const OSSL_PROVIDER prov,
	141	int operation_id, const char *names,
	142	const char propdef, void unused)
	143	{
	144	OSSL_NAMEMAP *namemap;
	145	int id;
	146
	147	if ((namemap = ossl_namemap_stored(libctx)) == NULL
	148	\|\| (id = ossl_namemap_name2num(namemap, names)) == 0)
	149	return 0;
	150
	151	if (store == NULL && (store = get_encoder_store(libctx)) == NULL)
	152	return 0;
	153
	154	return ossl_method_store_add(store, prov, id, propdef, method,
	155	(int ()(void ))OSSL_ENCODER_up_ref,
	156	(void ()(void ))OSSL_ENCODER_free);
	157	}
	158
	159	/* Create and populate a encoder method */
	160	static void encoder_from_dispatch(int id, const OSSL_ALGORITHM algodef,
	161	OSSL_PROVIDER *prov)
	162	{
	163	OSSL_ENCODER *encoder = NULL;
	164	const OSSL_DISPATCH *fns = algodef->implementation;
	165
	166	if ((encoder = ossl_encoder_new()) == NULL)
	167	return NULL;
	168	encoder->base.id = id;
	169	encoder->base.propdef = algodef->property_definition;
	170
	171	for (; fns->function_id != 0; fns++) {
	172	switch (fns->function_id) {
	173	case OSSL_FUNC_ENCODER_NEWCTX:
	174	if (encoder->newctx == NULL)
	175	encoder->newctx =
	176	OSSL_FUNC_encoder_newctx(fns);
	177	break;
	178	case OSSL_FUNC_ENCODER_FREECTX:
	179	if (encoder->freectx == NULL)
	180	encoder->freectx =
	181	OSSL_FUNC_encoder_freectx(fns);
	182	break;
b8975c68 RL	183	case OSSL_FUNC_ENCODER_GET_PARAMS:
	184	if (encoder->get_params == NULL)
	185	encoder->get_params =
	186	OSSL_FUNC_encoder_get_params(fns);
	187	break;
	188	case OSSL_FUNC_ENCODER_GETTABLE_PARAMS:
	189	if (encoder->gettable_params == NULL)
	190	encoder->gettable_params =
	191	OSSL_FUNC_encoder_gettable_params(fns);
	192	break;
ece9304c RL	193	case OSSL_FUNC_ENCODER_SET_CTX_PARAMS:
	194	if (encoder->set_ctx_params == NULL)
	195	encoder->set_ctx_params =
	196	OSSL_FUNC_encoder_set_ctx_params(fns);
	197	break;
	198	case OSSL_FUNC_ENCODER_SETTABLE_CTX_PARAMS:
	199	if (encoder->settable_ctx_params == NULL)
	200	encoder->settable_ctx_params =
	201	OSSL_FUNC_encoder_settable_ctx_params(fns);
	202	break;
b8975c68 RL	203	case OSSL_FUNC_ENCODER_ENCODE:
	204	if (encoder->encode == NULL)
	205	encoder->encode = OSSL_FUNC_encoder_encode(fns);
	206	break;
	207	case OSSL_FUNC_ENCODER_IMPORT_OBJECT:
	208	if (encoder->import_object == NULL)
	209	encoder->import_object =
	210	OSSL_FUNC_encoder_import_object(fns);
ece9304c	211	break;
b8975c68 RL	212	case OSSL_FUNC_ENCODER_FREE_OBJECT:
	213	if (encoder->free_object == NULL)
	214	encoder->free_object =
	215	OSSL_FUNC_encoder_free_object(fns);
ece9304c RL	216	break;
	217	}
	218	}
	219	/*
	220	* Try to check that the method is sensible.
	221	* If you have a constructor, you must have a destructor and vice versa.
b8975c68	222	* You must have the encoding driver functions.
ece9304c RL	223	*/
ece9304c RL	224	if (!((encoder->newctx == NULL && encoder->freectx == NULL)
b8975c68 RL	225	\|\| (encoder->newctx != NULL && encoder->freectx != NULL)
	226	\|\| (encoder->import_object != NULL && encoder->free_object != NULL)
	227	\|\| (encoder->import_object == NULL && encoder->free_object == NULL))
	228	\|\| encoder->encode == NULL
	229	\|\| encoder->gettable_params == NULL
	230	\|\| encoder->get_params == NULL) {
ece9304c RL	231	OSSL_ENCODER_free(encoder);
	232	ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_INVALID_PROVIDER_FUNCTIONS);
	233	return NULL;
	234	}
	235
	236	if (prov != NULL && !ossl_provider_up_ref(prov)) {
	237	OSSL_ENCODER_free(encoder);
	238	return NULL;
	239	}
	240
	241	encoder->base.prov = prov;
	242	return encoder;
	243	}
	244
	245
	246	/*
	247	* The core fetching functionality passes the names of the implementation.
	248	* This function is responsible to getting an identity number for them,
	249	* then call encoder_from_dispatch() with that identity number.
	250	*/
	251	static void construct_encoder(const OSSL_ALGORITHM algodef,
	252	OSSL_PROVIDER prov, void unused)
	253	{
	254	/*
	255	* This function is only called if get_encoder_from_store() returned
	256	* NULL, so it's safe to say that of all the spots to create a new
	257	* namemap entry, this is it. Should the name already exist there, we
	258	* know that ossl_namemap_add() will return its corresponding number.
	259	*/
b4250010	260	OSSL_LIB_CTX *libctx = ossl_provider_library_context(prov);
ece9304c RL	261	OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
	262	const char *names = algodef->algorithm_names;
	263	int id = ossl_namemap_add_names(namemap, 0, names, NAME_SEPARATOR);
	264	void *method = NULL;
	265
	266	if (id != 0)
	267	method = encoder_from_dispatch(id, algodef, prov);
	268
	269	return method;
	270	}
	271
	272	/* Intermediary function to avoid ugly casts, used below */
	273	static void destruct_encoder(void method, void data)
	274	{
	275	OSSL_ENCODER_free(method);
	276	}
	277
	278	static int up_ref_encoder(void *method)
	279	{
	280	return OSSL_ENCODER_up_ref(method);
	281	}
	282
	283	static void free_encoder(void *method)
	284	{
	285	OSSL_ENCODER_free(method);
	286	}
	287
	288	/* Fetching support. Can fetch by numeric identity or by name */
b4250010	289	static OSSL_ENCODER inner_ossl_encoder_fetch(OSSL_LIB_CTX libctx,
ece9304c RL	290	int id, const char *name,
	291	const char *properties)
	292	{
	293	OSSL_METHOD_STORE *store = get_encoder_store(libctx);
	294	OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
	295	void *method = NULL;
	296
	297	if (store == NULL \|\| namemap == NULL)
	298	return NULL;
	299
	300	/*
	301	* If we have been passed neither a name_id or a name, we have an
	302	* internal programming error.
	303	*/
	304	if (!ossl_assert(id != 0 \|\| name != NULL))
	305	return NULL;
	306
	307	if (id == 0)
	308	id = ossl_namemap_name2num(namemap, name);
	309
	310	if (id == 0
	311	\|\| !ossl_method_store_cache_get(store, id, properties, &method)) {
	312	OSSL_METHOD_CONSTRUCT_METHOD mcm = {
	313	alloc_tmp_encoder_store,
	314	dealloc_tmp_encoder_store,
	315	get_encoder_from_store,
	316	put_encoder_in_store,
	317	construct_encoder,
	318	destruct_encoder
	319	};
	320	struct encoder_data_st mcmdata;
	321
	322	mcmdata.libctx = libctx;
	323	mcmdata.mcm = &mcm;
	324	mcmdata.id = id;
	325	mcmdata.names = name;
	326	mcmdata.propquery = properties;
	327	if ((method = ossl_method_construct(libctx, OSSL_OP_ENCODER,
	328	0 /* !force_cache */,
	329	&mcm, &mcmdata)) != NULL) {
	330	/*
	331	* If construction did create a method for us, we know that
	332	* there is a correct name_id and meth_id, since those have
	333	* already been calculated in get_encoder_from_store() and
	334	* put_encoder_in_store() above.
	335	*/
	336	if (id == 0)
	337	id = ossl_namemap_name2num(namemap, name);
	338	ossl_method_store_cache_set(store, id, properties, method,
	339	up_ref_encoder, free_encoder);
	340	}
	341	}
	342
	343	return method;
	344	}
	345
b4250010	346	OSSL_ENCODER OSSL_ENCODER_fetch(OSSL_LIB_CTX libctx, const char *name,
ece9304c RL	347	const char *properties)
	348	{
	349	return inner_ossl_encoder_fetch(libctx, 0, name, properties);
	350	}
	351
b4250010	352	OSSL_ENCODER ossl_encoder_fetch_by_number(OSSL_LIB_CTX libctx, int id,
ece9304c RL	353	const char *properties)
	354	{
	355	return inner_ossl_encoder_fetch(libctx, id, NULL, properties);
	356	}
	357
	358	/*
	359	* Library of basic method functions
	360	*/
	361
	362	const OSSL_PROVIDER OSSL_ENCODER_provider(const OSSL_ENCODER encoder)
	363	{
	364	if (!ossl_assert(encoder != NULL)) {
	365	ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
	366	return 0;
	367	}
	368
	369	return encoder->base.prov;
	370	}
	371
	372	const char OSSL_ENCODER_properties(const OSSL_ENCODER encoder)
	373	{
	374	if (!ossl_assert(encoder != NULL)) {
	375	ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
	376	return 0;
	377	}
	378
	379	return encoder->base.propdef;
	380	}
	381
	382	int OSSL_ENCODER_number(const OSSL_ENCODER *encoder)
	383	{
	384	if (!ossl_assert(encoder != NULL)) {
	385	ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
	386	return 0;
	387	}
	388
	389	return encoder->base.id;
	390	}
	391
	392	int OSSL_ENCODER_is_a(const OSSL_ENCODER encoder, const char name)
	393	{
	394	if (encoder->base.prov != NULL) {
b4250010	395	OSSL_LIB_CTX *libctx = ossl_provider_library_context(encoder->base.prov);
ece9304c RL	396	OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
	397
	398	return ossl_namemap_name2num(namemap, name) == encoder->base.id;
	399	}
	400	return 0;
	401	}
	402
	403	struct encoder_do_all_data_st {
	404	void (user_fn)(void method, void *arg);
	405	void *user_arg;
	406	};
	407
	408	static void encoder_do_one(OSSL_PROVIDER *provider,
	409	const OSSL_ALGORITHM *algodef,
	410	int no_store, void *vdata)
	411	{
	412	struct encoder_do_all_data_st *data = vdata;
b4250010	413	OSSL_LIB_CTX *libctx = ossl_provider_library_context(provider);
ece9304c RL	414	OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
	415	const char *names = algodef->algorithm_names;
	416	int id = ossl_namemap_add_names(namemap, 0, names, NAME_SEPARATOR);
	417	void *method = NULL;
	418
	419	if (id != 0)
	420	method =
	421	encoder_from_dispatch(id, algodef, provider);
	422
	423	if (method != NULL) {
	424	data->user_fn(method, data->user_arg);
	425	OSSL_ENCODER_free(method);
	426	}
	427	}
	428
b4250010	429	void OSSL_ENCODER_do_all_provided(OSSL_LIB_CTX *libctx,
ece9304c RL	430	void (fn)(OSSL_ENCODER encoder, void *arg),
	431	void *arg)
	432	{
	433	struct encoder_do_all_data_st data;
	434
	435	data.user_fn = (void ()(void , void *))fn;
	436	data.user_arg = arg;
	437
	438	/*
	439	* No pre- or post-condition for this call, as this only creates methods
	440	* temporarly and then promptly destroys them.
	441	*/
	442	ossl_algorithm_do_all(libctx, OSSL_OP_ENCODER, NULL, NULL,
	443	encoder_do_one, NULL, &data);
	444	}
	445
	446	void OSSL_ENCODER_names_do_all(const OSSL_ENCODER *encoder,
	447	void (fn)(const char name, void *data),
	448	void *data)
	449	{
	450	if (encoder == NULL)
	451	return;
	452
	453	if (encoder->base.prov != NULL) {
b4250010	454	OSSL_LIB_CTX *libctx = ossl_provider_library_context(encoder->base.prov);
ece9304c RL	455	OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
	456
	457	ossl_namemap_doall_names(namemap, encoder->base.id, fn, data);
	458	}
	459	}
	460
b8975c68 RL	461	const OSSL_PARAM *
	462	OSSL_ENCODER_gettable_params(OSSL_ENCODER *encoder)
	463	{
	464	if (encoder != NULL && encoder->gettable_params != NULL) {
	465	void *provctx = ossl_provider_ctx(OSSL_ENCODER_provider(encoder));
	466
	467	return encoder->gettable_params(provctx);
	468	}
	469	return NULL;
	470	}
	471
	472	int OSSL_ENCODER_get_params(OSSL_ENCODER *encoder, OSSL_PARAM params[])
	473	{
	474	if (encoder != NULL && encoder->get_params != NULL)
	475	return encoder->get_params(params);
	476	return 0;
	477	}
	478
ece9304c RL	479	const OSSL_PARAM OSSL_ENCODER_settable_ctx_params(OSSL_ENCODER encoder)
	480	{
	481	if (encoder != NULL && encoder->settable_ctx_params != NULL) {
	482	void *provctx = ossl_provider_ctx(OSSL_ENCODER_provider(encoder));
	483
	484	return encoder->settable_ctx_params(provctx);
	485	}
	486	return NULL;
	487	}
	488
	489	/*
	490	* Encoder context support
	491	*/
	492
b8975c68	493	OSSL_ENCODER_CTX *OSSL_ENCODER_CTX_new(void)
ece9304c RL	494	{
	495	OSSL_ENCODER_CTX *ctx;
	496
b8975c68	497	if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL)
ece9304c	498	ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_MALLOC_FAILURE);
ece9304c RL	499
	500	return ctx;
	501	}
	502
b8975c68 RL	503	int OSSL_ENCODER_CTX_set_params(OSSL_ENCODER_CTX *ctx,
b8975c68 RL	504	const OSSL_PARAM params[])
ece9304c	505	{
b8975c68 RL	506	size_t i;
	507	size_t l;
	508
ece9304c RL	509	if (!ossl_assert(ctx != NULL)) {
	510	ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
	511	return 0;
	512	}
	513
b8975c68 RL	514	if (ctx->encoder_insts == NULL)
b8975c68 RL	515	return 1;
ece9304c	516
b8975c68 RL	517	l = OSSL_ENCODER_CTX_get_num_encoders(ctx);
	518	for (i = 0; i < l; i++) {
	519	OSSL_ENCODER_INSTANCE *encoder_inst =
	520	sk_OSSL_ENCODER_INSTANCE_value(ctx->encoder_insts, i);
	521	OSSL_ENCODER *encoder = OSSL_ENCODER_INSTANCE_get_encoder(encoder_inst);
	522	void *encoderctx = OSSL_ENCODER_INSTANCE_get_encoder_ctx(encoder_inst);
ece9304c	523
b8975c68 RL	524	if (encoderctx == NULL \|\| encoder->set_ctx_params == NULL)
	525	continue;
	526	if (!encoder->set_ctx_params(encoderctx, params))
	527	return 0;
ece9304c	528	}
b8975c68	529	return 1;
ece9304c RL	530	}
	531
	532	void OSSL_ENCODER_CTX_free(OSSL_ENCODER_CTX *ctx)
	533	{
	534	if (ctx != NULL) {
b8975c68 RL	535	sk_OSSL_ENCODER_INSTANCE_pop_free(ctx->encoder_insts,
	536	ossl_encoder_instance_free);
	537	OPENSSL_free(ctx->construct_data);
a517edec	538	ossl_pw_clear_passphrase_data(&ctx->pwdata);
ece9304c RL	539	OPENSSL_free(ctx);
	540	}
	541	}