]>
Commit | Line | Data |
---|---|---|
71a5516d | 1 | /* |
6738bf14 | 2 | * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved. |
71a5516d RL |
3 | * |
4 | * Licensed under the OpenSSL license (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 <string.h> | |
a1df06b3 | 11 | #include "internal/ctype.h" |
71a5516d RL |
12 | #include <assert.h> |
13 | ||
14 | #include <openssl/err.h> | |
15 | #include <openssl/lhash.h> | |
16 | #include "store_locl.h" | |
17 | ||
18 | static CRYPTO_RWLOCK *registry_lock; | |
19 | static CRYPTO_ONCE registry_init = CRYPTO_ONCE_STATIC_INIT; | |
20 | ||
21 | DEFINE_RUN_ONCE_STATIC(do_registry_init) | |
22 | { | |
63ab5ea1 | 23 | registry_lock = CRYPTO_THREAD_lock_new(); |
71a5516d RL |
24 | return registry_lock != NULL; |
25 | } | |
26 | ||
27 | /* | |
28 | * Functions for manipulating OSSL_STORE_LOADERs | |
29 | */ | |
30 | ||
f91ded1f | 31 | OSSL_STORE_LOADER *OSSL_STORE_LOADER_new(ENGINE *e, const char *scheme) |
71a5516d | 32 | { |
59099d6b | 33 | OSSL_STORE_LOADER *res = NULL; |
71a5516d RL |
34 | |
35 | /* | |
36 | * We usually don't check NULL arguments. For loaders, though, the | |
37 | * scheme is crucial and must never be NULL, or the user will get | |
38 | * mysterious errors when trying to register the created loader | |
39 | * later on. | |
40 | */ | |
41 | if (scheme == NULL) { | |
42 | OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_LOADER_NEW, | |
43 | OSSL_STORE_R_INVALID_SCHEME); | |
44 | return NULL; | |
45 | } | |
46 | ||
59099d6b RL |
47 | if ((res = OPENSSL_zalloc(sizeof(*res))) == NULL) { |
48 | OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_LOADER_NEW, ERR_R_MALLOC_FAILURE); | |
49 | return NULL; | |
50 | } | |
51 | ||
f91ded1f | 52 | res->engine = e; |
71a5516d RL |
53 | res->scheme = scheme; |
54 | return res; | |
55 | } | |
56 | ||
f91ded1f RL |
57 | const ENGINE *OSSL_STORE_LOADER_get0_engine(const OSSL_STORE_LOADER *loader) |
58 | { | |
59 | return loader->engine; | |
60 | } | |
61 | ||
71a5516d RL |
62 | const char *OSSL_STORE_LOADER_get0_scheme(const OSSL_STORE_LOADER *loader) |
63 | { | |
64 | return loader->scheme; | |
65 | } | |
66 | ||
67 | int OSSL_STORE_LOADER_set_open(OSSL_STORE_LOADER *loader, | |
68 | OSSL_STORE_open_fn open_function) | |
69 | { | |
70 | loader->open = open_function; | |
71 | return 1; | |
72 | } | |
73 | ||
74 | int OSSL_STORE_LOADER_set_ctrl(OSSL_STORE_LOADER *loader, | |
75 | OSSL_STORE_ctrl_fn ctrl_function) | |
76 | { | |
77 | loader->ctrl = ctrl_function; | |
78 | return 1; | |
79 | } | |
80 | ||
81 | int OSSL_STORE_LOADER_set_load(OSSL_STORE_LOADER *loader, | |
82 | OSSL_STORE_load_fn load_function) | |
83 | { | |
84 | loader->load = load_function; | |
85 | return 1; | |
86 | } | |
87 | ||
88 | int OSSL_STORE_LOADER_set_eof(OSSL_STORE_LOADER *loader, | |
89 | OSSL_STORE_eof_fn eof_function) | |
90 | { | |
91 | loader->eof = eof_function; | |
92 | return 1; | |
93 | } | |
94 | ||
95 | int OSSL_STORE_LOADER_set_error(OSSL_STORE_LOADER *loader, | |
96 | OSSL_STORE_error_fn error_function) | |
97 | { | |
98 | loader->error = error_function; | |
99 | return 1; | |
100 | } | |
101 | ||
102 | int OSSL_STORE_LOADER_set_close(OSSL_STORE_LOADER *loader, | |
103 | OSSL_STORE_close_fn close_function) | |
104 | { | |
105 | loader->close = close_function; | |
106 | return 1; | |
107 | } | |
108 | ||
109 | void OSSL_STORE_LOADER_free(OSSL_STORE_LOADER *loader) | |
110 | { | |
111 | OPENSSL_free(loader); | |
112 | } | |
113 | ||
114 | /* | |
115 | * Functions for registering OSSL_STORE_LOADERs | |
116 | */ | |
117 | ||
118 | static unsigned long store_loader_hash(const OSSL_STORE_LOADER *v) | |
119 | { | |
120 | return OPENSSL_LH_strhash(v->scheme); | |
121 | } | |
122 | ||
123 | static int store_loader_cmp(const OSSL_STORE_LOADER *a, | |
124 | const OSSL_STORE_LOADER *b) | |
125 | { | |
6f9c5062 RL |
126 | assert(a->scheme != NULL && b->scheme != NULL); |
127 | return strcmp(a->scheme, b->scheme); | |
71a5516d RL |
128 | } |
129 | ||
130 | static LHASH_OF(OSSL_STORE_LOADER) *loader_register = NULL; | |
131 | ||
132 | int ossl_store_register_loader_int(OSSL_STORE_LOADER *loader) | |
133 | { | |
134 | const char *scheme = loader->scheme; | |
135 | int ok = 0; | |
136 | ||
137 | /* | |
138 | * Check that the given scheme conforms to correct scheme syntax as per | |
139 | * RFC 3986: | |
140 | * | |
141 | * scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) | |
142 | */ | |
a1df06b3 | 143 | if (ossl_isalpha(*scheme)) |
71a5516d | 144 | while (*scheme != '\0' |
a1df06b3 P |
145 | && (ossl_isalpha(*scheme) |
146 | || ossl_isdigit(*scheme) | |
71a5516d RL |
147 | || strchr("+-.", *scheme) != NULL)) |
148 | scheme++; | |
149 | if (*scheme != '\0') { | |
150 | OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_REGISTER_LOADER_INT, | |
151 | OSSL_STORE_R_INVALID_SCHEME); | |
baa77e07 | 152 | ERR_add_error_data(2, "scheme=", loader->scheme); |
71a5516d RL |
153 | return 0; |
154 | } | |
155 | ||
5ee40746 RL |
156 | /* Check that functions we absolutely require are present */ |
157 | if (loader->open == NULL || loader->load == NULL || loader->eof == NULL | |
158 | || loader->error == NULL || loader->close == NULL) { | |
159 | OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_REGISTER_LOADER_INT, | |
160 | OSSL_STORE_R_LOADER_INCOMPLETE); | |
161 | return 0; | |
162 | } | |
163 | ||
71a5516d RL |
164 | if (!RUN_ONCE(®istry_init, do_registry_init)) { |
165 | OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_REGISTER_LOADER_INT, | |
166 | ERR_R_MALLOC_FAILURE); | |
167 | return 0; | |
168 | } | |
169 | CRYPTO_THREAD_write_lock(registry_lock); | |
170 | ||
171 | if (loader_register == NULL) { | |
172 | loader_register = lh_OSSL_STORE_LOADER_new(store_loader_hash, | |
173 | store_loader_cmp); | |
174 | } | |
175 | ||
176 | if (loader_register != NULL | |
177 | && (lh_OSSL_STORE_LOADER_insert(loader_register, loader) != NULL | |
178 | || lh_OSSL_STORE_LOADER_error(loader_register) == 0)) | |
179 | ok = 1; | |
180 | ||
181 | CRYPTO_THREAD_unlock(registry_lock); | |
182 | ||
183 | return ok; | |
184 | } | |
185 | int OSSL_STORE_register_loader(OSSL_STORE_LOADER *loader) | |
186 | { | |
187 | if (!ossl_store_init_once()) | |
188 | return 0; | |
189 | return ossl_store_register_loader_int(loader); | |
190 | } | |
191 | ||
192 | const OSSL_STORE_LOADER *ossl_store_get0_loader_int(const char *scheme) | |
193 | { | |
194 | OSSL_STORE_LOADER template; | |
195 | OSSL_STORE_LOADER *loader = NULL; | |
196 | ||
197 | template.scheme = scheme; | |
198 | template.open = NULL; | |
199 | template.load = NULL; | |
200 | template.eof = NULL; | |
201 | template.close = NULL; | |
202 | ||
203 | if (!ossl_store_init_once()) | |
204 | return NULL; | |
205 | ||
206 | if (!RUN_ONCE(®istry_init, do_registry_init)) { | |
207 | OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_GET0_LOADER_INT, | |
208 | ERR_R_MALLOC_FAILURE); | |
209 | return NULL; | |
210 | } | |
211 | CRYPTO_THREAD_write_lock(registry_lock); | |
212 | ||
213 | loader = lh_OSSL_STORE_LOADER_retrieve(loader_register, &template); | |
214 | ||
215 | if (loader == NULL) { | |
216 | OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_GET0_LOADER_INT, | |
217 | OSSL_STORE_R_UNREGISTERED_SCHEME); | |
218 | ERR_add_error_data(2, "scheme=", scheme); | |
219 | } | |
220 | ||
221 | CRYPTO_THREAD_unlock(registry_lock); | |
222 | ||
223 | return loader; | |
224 | } | |
225 | ||
226 | OSSL_STORE_LOADER *ossl_store_unregister_loader_int(const char *scheme) | |
227 | { | |
228 | OSSL_STORE_LOADER template; | |
229 | OSSL_STORE_LOADER *loader = NULL; | |
230 | ||
231 | template.scheme = scheme; | |
232 | template.open = NULL; | |
233 | template.load = NULL; | |
234 | template.eof = NULL; | |
235 | template.close = NULL; | |
236 | ||
237 | if (!RUN_ONCE(®istry_init, do_registry_init)) { | |
238 | OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_UNREGISTER_LOADER_INT, | |
239 | ERR_R_MALLOC_FAILURE); | |
240 | return NULL; | |
241 | } | |
242 | CRYPTO_THREAD_write_lock(registry_lock); | |
243 | ||
244 | loader = lh_OSSL_STORE_LOADER_delete(loader_register, &template); | |
245 | ||
246 | if (loader == NULL) { | |
247 | OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_UNREGISTER_LOADER_INT, | |
248 | OSSL_STORE_R_UNREGISTERED_SCHEME); | |
249 | ERR_add_error_data(2, "scheme=", scheme); | |
250 | } | |
251 | ||
252 | CRYPTO_THREAD_unlock(registry_lock); | |
253 | ||
254 | return loader; | |
255 | } | |
256 | OSSL_STORE_LOADER *OSSL_STORE_unregister_loader(const char *scheme) | |
257 | { | |
258 | if (!ossl_store_init_once()) | |
259 | return 0; | |
260 | return ossl_store_unregister_loader_int(scheme); | |
261 | } | |
262 | ||
263 | void ossl_store_destroy_loaders_int(void) | |
264 | { | |
265 | assert(lh_OSSL_STORE_LOADER_num_items(loader_register) == 0); | |
266 | lh_OSSL_STORE_LOADER_free(loader_register); | |
267 | loader_register = NULL; | |
268 | CRYPTO_THREAD_lock_free(registry_lock); | |
269 | registry_lock = NULL; | |
270 | } | |
f91ded1f RL |
271 | |
272 | /* | |
273 | * Functions to list OSSL_STORE loaders | |
274 | */ | |
275 | ||
276 | IMPLEMENT_LHASH_DOALL_ARG_CONST(OSSL_STORE_LOADER, void); | |
277 | int OSSL_STORE_do_all_loaders(void (*do_function) (const OSSL_STORE_LOADER | |
278 | *loader, void *do_arg), | |
279 | void *do_arg) | |
280 | { | |
281 | lh_OSSL_STORE_LOADER_doall_void(loader_register, do_function, do_arg); | |
282 | return 1; | |
283 | } |