Modify ossl_method_store_add() to handle reference counting
[thirdparty/openssl.git] / crypto / evp / evp_fetch.c
CommitLineData
c13d2ab4
RL
1/*
2 * Copyright 2019 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 <stddef.h>
11#include <openssl/ossl_typ.h>
12#include <openssl/evp.h>
13#include <openssl/core.h>
14#include "internal/cryptlib.h"
15#include "internal/thread_once.h"
c13d2ab4
RL
16#include "internal/property.h"
17#include "internal/core.h"
baff732d 18#include "internal/namemap.h"
c13d2ab4
RL
19#include "internal/evp_int.h" /* evp_locl.h needs it */
20#include "evp_locl.h"
21
c13d2ab4
RL
22static void default_method_store_free(void *vstore)
23{
24 ossl_method_store_free(vstore);
25}
26
1aedc35f 27static void *default_method_store_new(OPENSSL_CTX *ctx)
c13d2ab4 28{
1aedc35f 29 return ossl_method_store_new(ctx);
c13d2ab4
RL
30}
31
32
33static const OPENSSL_CTX_METHOD default_method_store_method = {
34 default_method_store_new,
35 default_method_store_free,
36};
37
c13d2ab4
RL
38/* Data to be passed through ossl_method_construct() */
39struct method_data_st {
baff732d 40 OPENSSL_CTX *libctx;
c13d2ab4 41 const char *name;
c13d2ab4 42 OSSL_METHOD_CONSTRUCT_METHOD *mcm;
6b9e3724
RL
43 void *(*method_from_dispatch)(const char *, const OSSL_DISPATCH *,
44 OSSL_PROVIDER *);
c13d2ab4
RL
45 int (*refcnt_up_method)(void *method);
46 void (*destruct_method)(void *method);
47};
48
49/*
50 * Generic routines to fetch / create EVP methods with ossl_method_construct()
51 */
1aedc35f 52static void *alloc_tmp_method_store(OPENSSL_CTX *ctx)
c13d2ab4 53{
1aedc35f 54 return ossl_method_store_new(ctx);
c13d2ab4
RL
55}
56
57 static void dealloc_tmp_method_store(void *store)
58{
59 if (store != NULL)
60 ossl_method_store_free(store);
61}
62
cb929645 63static OSSL_METHOD_STORE *get_default_method_store(OPENSSL_CTX *libctx)
c13d2ab4 64{
1aedc35f
MC
65 return openssl_ctx_get_data(libctx, OPENSSL_CTX_DEFAULT_METHOD_STORE_INDEX,
66 &default_method_store_method);
c13d2ab4
RL
67}
68
2ccb1b4e
RL
69/*
70 * To identity the method in the method store, we mix the name identity
71 * with the operation identity, with the assumption that we don't have
72 * more than 2^24 names or more than 2^8 operation types.
73 *
74 * The resulting identity is a 32-bit integer, composed like this:
75 *
76 * +---------24 bits--------+-8 bits-+
77 * | name identity | op id |
78 * +------------------------+--------+
79 */
80static uint32_t method_id(unsigned int operation_id, unsigned int name_id)
81{
82 if (!ossl_assert(name_id < (1 << 24) || operation_id < (1 << 8))
83 || !ossl_assert(name_id > 0 && operation_id > 0))
84 return 0;
85 return ((name_id << 8) & 0xFFFFFF00) | (operation_id & 0x000000FF);
86}
87
c13d2ab4 88static void *get_method_from_store(OPENSSL_CTX *libctx, void *store,
2ccb1b4e
RL
89 int operation_id, const char *name,
90 const char *propquery, void *data)
c13d2ab4
RL
91{
92 struct method_data_st *methdata = data;
93 void *method = NULL;
2e49c054 94 OSSL_NAMEMAP *namemap;
2ccb1b4e
RL
95 int nameid;
96 uint32_t methid;
c13d2ab4
RL
97
98 if (store == NULL
99 && (store = get_default_method_store(libctx)) == NULL)
100 return NULL;
101
2e49c054 102 if ((namemap = ossl_namemap_stored(libctx)) == NULL
651d4418 103 || (nameid = ossl_namemap_name2num(namemap, name)) == 0
2ccb1b4e 104 || (methid = method_id(operation_id, nameid)) == 0)
2e49c054
RL
105 return NULL;
106
2ccb1b4e 107 (void)ossl_method_store_fetch(store, methid, propquery, &method);
c13d2ab4
RL
108
109 if (method != NULL
110 && !methdata->refcnt_up_method(method)) {
111 method = NULL;
112 }
113 return method;
114}
115
116static int put_method_in_store(OPENSSL_CTX *libctx, void *store,
2ccb1b4e
RL
117 void *method, int operation_id,
118 const char *name, const char *propdef,
119 void *data)
c13d2ab4
RL
120{
121 struct method_data_st *methdata = data;
2e49c054 122 OSSL_NAMEMAP *namemap;
2ccb1b4e
RL
123 int nameid;
124 uint32_t methid;
dc46e3dd 125
2e49c054 126 if ((namemap = ossl_namemap_stored(methdata->libctx)) == NULL
651d4418 127 || (nameid = ossl_namemap_add(namemap, 0, name)) == 0
2ccb1b4e 128 || (methid = method_id(operation_id, nameid)) == 0)
dc46e3dd 129 return 0;
c13d2ab4
RL
130
131 if (store == NULL
132 && (store = get_default_method_store(libctx)) == NULL)
133 return 0;
134
b1d40ddf
RL
135 return ossl_method_store_add(store, methid, propdef, method,
136 methdata->refcnt_up_method,
137 methdata->destruct_method);
c13d2ab4
RL
138}
139
2e49c054
RL
140static void *construct_method(const char *name, const OSSL_DISPATCH *fns,
141 OSSL_PROVIDER *prov, void *data)
c13d2ab4
RL
142{
143 struct method_data_st *methdata = data;
c13d2ab4 144
6b9e3724 145 return methdata->method_from_dispatch(name, fns, prov);
c13d2ab4
RL
146}
147
148static void destruct_method(void *method, void *data)
149{
150 struct method_data_st *methdata = data;
151
152 methdata->destruct_method(method);
153}
154
155void *evp_generic_fetch(OPENSSL_CTX *libctx, int operation_id,
2e49c054 156 const char *name, const char *properties,
6b9e3724
RL
157 void *(*new_method)(const char *name,
158 const OSSL_DISPATCH *fns,
c13d2ab4 159 OSSL_PROVIDER *prov),
7c95390e 160 int (*up_ref_method)(void *),
0211740f 161 void (*free_method)(void *))
c13d2ab4 162{
e019da7b 163 OSSL_METHOD_STORE *store = get_default_method_store(libctx);
baff732d 164 OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
2ccb1b4e
RL
165 int nameid = 0;
166 uint32_t methid = 0;
c13d2ab4
RL
167 void *method = NULL;
168
baff732d 169 if (store == NULL || namemap == NULL)
e019da7b
RL
170 return NULL;
171
2ccb1b4e
RL
172 /*
173 * If there's ever an operation_id == 0 passed, we have an internal
174 * programming error.
175 */
176 if (!ossl_assert(operation_id > 0))
177 return NULL;
178
179 /*
180 * method_id returns 0 if we have too many operations (more than
181 * about 2^8) or too many names (more than about 2^24). In that
182 * case, we can't create any new method.
183 */
651d4418 184 if ((nameid = ossl_namemap_name2num(namemap, name)) != 0
2ccb1b4e
RL
185 && (methid = method_id(operation_id, nameid)) == 0)
186 return NULL;
187
188 if (nameid == 0
189 || !ossl_method_store_cache_get(store, methid, properties,
190 &method)) {
c13d2ab4
RL
191 OSSL_METHOD_CONSTRUCT_METHOD mcm = {
192 alloc_tmp_method_store,
193 dealloc_tmp_method_store,
194 get_method_from_store,
195 put_method_in_store,
196 construct_method,
197 destruct_method
198 };
199 struct method_data_st mcmdata;
200
c13d2ab4 201 mcmdata.mcm = &mcm;
baff732d 202 mcmdata.libctx = libctx;
d5e5e2ff 203 mcmdata.name = name;
c13d2ab4
RL
204 mcmdata.method_from_dispatch = new_method;
205 mcmdata.destruct_method = free_method;
7c95390e 206 mcmdata.refcnt_up_method = up_ref_method;
c13d2ab4 207 mcmdata.destruct_method = free_method;
2ccb1b4e
RL
208 if ((method = ossl_method_construct(libctx, operation_id, name,
209 properties, 0 /* !force_cache */,
08607613 210 &mcm, &mcmdata)) != NULL) {
2ccb1b4e
RL
211 /*
212 * If construction did create a method for us, we know that
213 * there is a correct nameid and methodid, since those have
214 * already been calculated in get_method_from_store() and
215 * put_method_in_store() above.
216 */
651d4418 217 nameid = ossl_namemap_name2num(namemap, name);
2ccb1b4e
RL
218 methid = method_id(operation_id, nameid);
219 ossl_method_store_cache_set(store, methid, properties, method);
220 }
e019da7b 221 } else {
7c95390e 222 up_ref_method(method);
c13d2ab4
RL
223 }
224
225 return method;
226}
cb929645
RL
227
228int EVP_set_default_properties(OPENSSL_CTX *libctx, const char *propq)
229{
230 OSSL_METHOD_STORE *store = get_default_method_store(libctx);
231
232 if (store != NULL)
233 return ossl_method_store_set_global_properties(store, propq);
234 EVPerr(EVP_F_EVP_SET_DEFAULT_PROPERTIES, ERR_R_INTERNAL_ERROR);
235 return 0;
236}
3d96a51c
RL
237
238struct do_all_data_st {
239 void (*user_fn)(void *method, void *arg);
240 void *user_arg;
241 void *(*new_method)(const char *name, const OSSL_DISPATCH *fns,
242 OSSL_PROVIDER *prov);
243 void (*free_method)(void *);
244};
245
246static void do_one(OSSL_PROVIDER *provider, const OSSL_ALGORITHM *algo,
247 int no_store, void *vdata)
248{
249 struct do_all_data_st *data = vdata;
250 void *method = data->new_method(algo->algorithm_name,
251 algo->implementation, provider);
252
253 if (method != NULL) {
254 data->user_fn(method, data->user_arg);
255 data->free_method(method);
256 }
257}
258
259void evp_generic_do_all(OPENSSL_CTX *libctx, int operation_id,
260 void (*user_fn)(void *method, void *arg),
261 void *user_arg,
262 void *(*new_method)(const char *name,
263 const OSSL_DISPATCH *fns,
264 OSSL_PROVIDER *prov),
265 void (*free_method)(void *))
266{
267 struct do_all_data_st data;
268
269 data.new_method = new_method;
270 data.free_method = free_method;
271 data.user_fn = user_fn;
272 data.user_arg = user_arg;
273 ossl_algorithm_do_all(libctx, operation_id, NULL, do_one, &data);
274}