]>
Commit | Line | Data |
---|---|---|
9e11fe0d | 1 | /* |
4333b89f | 2 | * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved. |
9e11fe0d RL |
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 | ||
12 | #include <openssl/core.h> | |
13 | #include "internal/cryptlib.h" | |
14 | #include "internal/core.h" | |
15 | #include "internal/property.h" | |
16 | #include "internal/provider.h" | |
17 | ||
18 | struct construct_data_st { | |
b4250010 | 19 | OSSL_LIB_CTX *libctx; |
9e11fe0d RL |
20 | OSSL_METHOD_STORE *store; |
21 | int operation_id; | |
22 | int force_store; | |
23 | OSSL_METHOD_CONSTRUCT_METHOD *mcm; | |
24 | void *mcm_data; | |
25 | }; | |
26 | ||
10937d58 RL |
27 | static int is_temporary_method_store(int no_store, void *cbdata) |
28 | { | |
29 | struct construct_data_st *data = cbdata; | |
30 | ||
31 | return no_store && !data->force_store; | |
32 | } | |
33 | ||
e1eafe8c RL |
34 | static int ossl_method_construct_reserve_store(int no_store, void *cbdata) |
35 | { | |
36 | struct construct_data_st *data = cbdata; | |
37 | ||
38 | if (is_temporary_method_store(no_store, data) && data->store == NULL) { | |
39 | /* | |
40 | * If we have been told not to store the method "permanently", we | |
41 | * ask for a temporary store, and store the method there. | |
42 | * The owner of |data->mcm| is completely responsible for managing | |
43 | * that temporary store. | |
44 | */ | |
45 | if ((data->store = data->mcm->get_tmp_store(data->mcm_data)) == NULL) | |
46 | return 0; | |
47 | } | |
48 | ||
49 | return data->mcm->lock_store(data->store, data->mcm_data); | |
50 | } | |
51 | ||
52 | static int ossl_method_construct_unreserve_store(void *cbdata) | |
53 | { | |
54 | struct construct_data_st *data = cbdata; | |
55 | ||
56 | return data->mcm->unlock_store(data->store, data->mcm_data); | |
57 | } | |
58 | ||
5a29b628 | 59 | static int ossl_method_construct_precondition(OSSL_PROVIDER *provider, |
10937d58 RL |
60 | int operation_id, int no_store, |
61 | void *cbdata, int *result) | |
5a29b628 RL |
62 | { |
63 | if (!ossl_assert(result != NULL)) { | |
64 | ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_NULL_PARAMETER); | |
65 | return 0; | |
66 | } | |
67 | ||
10937d58 RL |
68 | /* Assume that no bits are set */ |
69 | *result = 0; | |
70 | ||
71 | /* No flag bits for temporary stores */ | |
72 | if (!is_temporary_method_store(no_store, cbdata) | |
73 | && !ossl_provider_test_operation_bit(provider, operation_id, result)) | |
5a29b628 RL |
74 | return 0; |
75 | ||
76 | /* | |
77 | * The result we get tells if methods have already been constructed. | |
78 | * However, we want to tell whether construction should happen (true) | |
79 | * or not (false), which is the opposite of what we got. | |
80 | */ | |
81 | *result = !*result; | |
82 | ||
83 | return 1; | |
84 | } | |
85 | ||
86 | static int ossl_method_construct_postcondition(OSSL_PROVIDER *provider, | |
87 | int operation_id, int no_store, | |
88 | void *cbdata, int *result) | |
89 | { | |
90 | if (!ossl_assert(result != NULL)) { | |
91 | ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_NULL_PARAMETER); | |
92 | return 0; | |
93 | } | |
94 | ||
95 | *result = 1; | |
10937d58 RL |
96 | |
97 | /* No flag bits for temporary stores */ | |
98 | return is_temporary_method_store(no_store, cbdata) | |
5a29b628 RL |
99 | || ossl_provider_set_operation_bit(provider, operation_id); |
100 | } | |
101 | ||
84d167f6 RL |
102 | static void ossl_method_construct_this(OSSL_PROVIDER *provider, |
103 | const OSSL_ALGORITHM *algo, | |
104 | int no_store, void *cbdata) | |
9e11fe0d RL |
105 | { |
106 | struct construct_data_st *data = cbdata; | |
84d167f6 | 107 | void *method = NULL; |
9e11fe0d | 108 | |
36fa4d8a RL |
109 | if ((method = data->mcm->construct(algo, provider, data->mcm_data)) |
110 | == NULL) | |
84d167f6 RL |
111 | return; |
112 | ||
113 | /* | |
114 | * Note regarding putting the method in stores: | |
115 | * | |
116 | * we don't need to care if it actually got in or not here. | |
117 | * If it didn't get in, it will simply not be available when | |
118 | * ossl_method_construct() tries to get it from the store. | |
119 | * | |
120 | * It is *expected* that the put function increments the refcnt | |
121 | * of the passed method. | |
122 | */ | |
e1eafe8c RL |
123 | data->mcm->put(data->store, method, provider, algo->algorithm_names, |
124 | algo->property_definition, data->mcm_data); | |
9e11fe0d | 125 | |
84d167f6 RL |
126 | /* refcnt-- because we're dropping the reference */ |
127 | data->mcm->destruct(method, data->mcm_data); | |
9e11fe0d RL |
128 | } |
129 | ||
b4250010 | 130 | void *ossl_method_construct(OSSL_LIB_CTX *libctx, int operation_id, |
dc010ca6 | 131 | OSSL_PROVIDER **provider_rw, int force_store, |
9e11fe0d RL |
132 | OSSL_METHOD_CONSTRUCT_METHOD *mcm, void *mcm_data) |
133 | { | |
134 | void *method = NULL; | |
4b1b6297 TM |
135 | OSSL_PROVIDER *provider = provider_rw != NULL ? *provider_rw : NULL; |
136 | struct construct_data_st cbdata; | |
9e11fe0d | 137 | |
4b1b6297 TM |
138 | /* |
139 | * We might be tempted to try to look into the method store without | |
140 | * constructing to see if we can find our method there already. | |
141 | * Unfortunately that does not work well if the query contains | |
142 | * optional properties as newly loaded providers can match them better. | |
143 | * We trust that ossl_method_construct_precondition() and | |
144 | * ossl_method_construct_postcondition() make sure that the | |
145 | * ossl_algorithm_do_all() does very little when methods from | |
146 | * a provider have already been constructed. | |
147 | */ | |
148 | ||
149 | cbdata.store = NULL; | |
150 | cbdata.force_store = force_store; | |
151 | cbdata.mcm = mcm; | |
152 | cbdata.mcm_data = mcm_data; | |
153 | ossl_algorithm_do_all(libctx, operation_id, provider, | |
154 | ossl_method_construct_precondition, | |
e1eafe8c | 155 | ossl_method_construct_reserve_store, |
4b1b6297 | 156 | ossl_method_construct_this, |
e1eafe8c | 157 | ossl_method_construct_unreserve_store, |
4b1b6297 TM |
158 | ossl_method_construct_postcondition, |
159 | &cbdata); | |
160 | ||
161 | /* If there is a temporary store, try there first */ | |
162 | if (cbdata.store != NULL) | |
163 | method = mcm->get(cbdata.store, (const OSSL_PROVIDER **)provider_rw, | |
164 | mcm_data); | |
165 | ||
166 | /* If no method was found yet, try the global store */ | |
167 | if (method == NULL) | |
168 | method = mcm->get(NULL, (const OSSL_PROVIDER **)provider_rw, mcm_data); | |
9e11fe0d | 169 | |
9e11fe0d RL |
170 | return method; |
171 | } |