OSSL_STORE: Make it possible to attach an OSSL_STORE to an opened BIO
[openssl.git] / crypto / store / store_register.c
1 /*
2  * Copyright 2016-2018 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 <string.h>
11 #include "crypto/ctype.h"
12 #include <assert.h>
13
14 #include <openssl/err.h>
15 #include <openssl/lhash.h>
16 #include "store_local.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 {
23     registry_lock = CRYPTO_THREAD_lock_new();
24     return registry_lock != NULL;
25 }
26
27 /*
28  *  Functions for manipulating OSSL_STORE_LOADERs
29  */
30
31 OSSL_STORE_LOADER *OSSL_STORE_LOADER_new(ENGINE *e, const char *scheme)
32 {
33     OSSL_STORE_LOADER *res = NULL;
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
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
52     res->engine = e;
53     res->scheme = scheme;
54     return res;
55 }
56
57 const ENGINE *OSSL_STORE_LOADER_get0_engine(const OSSL_STORE_LOADER *loader)
58 {
59     return loader->engine;
60 }
61
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_attach(OSSL_STORE_LOADER *loader,
75                                  OSSL_STORE_attach_fn attach_function)
76 {
77     loader->attach = attach_function;
78     return 1;
79 }
80
81 int OSSL_STORE_LOADER_set_ctrl(OSSL_STORE_LOADER *loader,
82                                OSSL_STORE_ctrl_fn ctrl_function)
83 {
84     loader->ctrl = ctrl_function;
85     return 1;
86 }
87
88 int OSSL_STORE_LOADER_set_expect(OSSL_STORE_LOADER *loader,
89                                  OSSL_STORE_expect_fn expect_function)
90 {
91     loader->expect = expect_function;
92     return 1;
93 }
94
95 int OSSL_STORE_LOADER_set_find(OSSL_STORE_LOADER *loader,
96                                OSSL_STORE_find_fn find_function)
97 {
98     loader->find = find_function;
99     return 1;
100 }
101
102 int OSSL_STORE_LOADER_set_load(OSSL_STORE_LOADER *loader,
103                                OSSL_STORE_load_fn load_function)
104 {
105     loader->load = load_function;
106     return 1;
107 }
108
109 int OSSL_STORE_LOADER_set_eof(OSSL_STORE_LOADER *loader,
110                               OSSL_STORE_eof_fn eof_function)
111 {
112     loader->eof = eof_function;
113     return 1;
114 }
115
116 int OSSL_STORE_LOADER_set_error(OSSL_STORE_LOADER *loader,
117                                 OSSL_STORE_error_fn error_function)
118 {
119     loader->error = error_function;
120     return 1;
121 }
122
123 int OSSL_STORE_LOADER_set_close(OSSL_STORE_LOADER *loader,
124                                 OSSL_STORE_close_fn close_function)
125 {
126     loader->close = close_function;
127     return 1;
128 }
129
130 void OSSL_STORE_LOADER_free(OSSL_STORE_LOADER *loader)
131 {
132     OPENSSL_free(loader);
133 }
134
135 /*
136  *  Functions for registering OSSL_STORE_LOADERs
137  */
138
139 static unsigned long store_loader_hash(const OSSL_STORE_LOADER *v)
140 {
141     return OPENSSL_LH_strhash(v->scheme);
142 }
143
144 static int store_loader_cmp(const OSSL_STORE_LOADER *a,
145                             const OSSL_STORE_LOADER *b)
146 {
147     assert(a->scheme != NULL && b->scheme != NULL);
148     return strcmp(a->scheme, b->scheme);
149 }
150
151 static LHASH_OF(OSSL_STORE_LOADER) *loader_register = NULL;
152
153 int ossl_store_register_loader_int(OSSL_STORE_LOADER *loader)
154 {
155     const char *scheme = loader->scheme;
156     int ok = 0;
157
158     /*
159      * Check that the given scheme conforms to correct scheme syntax as per
160      * RFC 3986:
161      *
162      * scheme        = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
163      */
164     if (ossl_isalpha(*scheme))
165         while (*scheme != '\0'
166                && (ossl_isalpha(*scheme)
167                    || ossl_isdigit(*scheme)
168                    || strchr("+-.", *scheme) != NULL))
169             scheme++;
170     if (*scheme != '\0') {
171         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_REGISTER_LOADER_INT,
172                       OSSL_STORE_R_INVALID_SCHEME);
173         ERR_add_error_data(2, "scheme=", loader->scheme);
174         return 0;
175     }
176
177     /* Check that functions we absolutely require are present */
178     if (loader->open == NULL || loader->load == NULL || loader->eof == NULL
179         || loader->error == NULL || loader->close == NULL) {
180         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_REGISTER_LOADER_INT,
181                       OSSL_STORE_R_LOADER_INCOMPLETE);
182         return 0;
183     }
184
185     if (!RUN_ONCE(&registry_init, do_registry_init)) {
186         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_REGISTER_LOADER_INT,
187                       ERR_R_MALLOC_FAILURE);
188         return 0;
189     }
190     CRYPTO_THREAD_write_lock(registry_lock);
191
192     if (loader_register == NULL) {
193         loader_register = lh_OSSL_STORE_LOADER_new(store_loader_hash,
194                                                    store_loader_cmp);
195     }
196
197     if (loader_register != NULL
198         && (lh_OSSL_STORE_LOADER_insert(loader_register, loader) != NULL
199             || lh_OSSL_STORE_LOADER_error(loader_register) == 0))
200         ok = 1;
201
202     CRYPTO_THREAD_unlock(registry_lock);
203
204     return ok;
205 }
206 int OSSL_STORE_register_loader(OSSL_STORE_LOADER *loader)
207 {
208     if (!ossl_store_init_once())
209         return 0;
210     return ossl_store_register_loader_int(loader);
211 }
212
213 const OSSL_STORE_LOADER *ossl_store_get0_loader_int(const char *scheme)
214 {
215     OSSL_STORE_LOADER template;
216     OSSL_STORE_LOADER *loader = NULL;
217
218     template.scheme = scheme;
219     template.open = NULL;
220     template.load = NULL;
221     template.eof = NULL;
222     template.close = NULL;
223
224     if (!ossl_store_init_once())
225         return NULL;
226
227     if (!RUN_ONCE(&registry_init, do_registry_init)) {
228         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_GET0_LOADER_INT,
229                       ERR_R_MALLOC_FAILURE);
230         return NULL;
231     }
232     CRYPTO_THREAD_write_lock(registry_lock);
233
234     loader = lh_OSSL_STORE_LOADER_retrieve(loader_register, &template);
235
236     if (loader == NULL) {
237         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_GET0_LOADER_INT,
238                       OSSL_STORE_R_UNREGISTERED_SCHEME);
239         ERR_add_error_data(2, "scheme=", scheme);
240     }
241
242     CRYPTO_THREAD_unlock(registry_lock);
243
244     return loader;
245 }
246
247 OSSL_STORE_LOADER *ossl_store_unregister_loader_int(const char *scheme)
248 {
249     OSSL_STORE_LOADER template;
250     OSSL_STORE_LOADER *loader = NULL;
251
252     template.scheme = scheme;
253     template.open = NULL;
254     template.load = NULL;
255     template.eof = NULL;
256     template.close = NULL;
257
258     if (!RUN_ONCE(&registry_init, do_registry_init)) {
259         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_UNREGISTER_LOADER_INT,
260                       ERR_R_MALLOC_FAILURE);
261         return NULL;
262     }
263     CRYPTO_THREAD_write_lock(registry_lock);
264
265     loader = lh_OSSL_STORE_LOADER_delete(loader_register, &template);
266
267     if (loader == NULL) {
268         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_UNREGISTER_LOADER_INT,
269                       OSSL_STORE_R_UNREGISTERED_SCHEME);
270         ERR_add_error_data(2, "scheme=", scheme);
271     }
272
273     CRYPTO_THREAD_unlock(registry_lock);
274
275     return loader;
276 }
277 OSSL_STORE_LOADER *OSSL_STORE_unregister_loader(const char *scheme)
278 {
279     if (!ossl_store_init_once())
280         return 0;
281     return ossl_store_unregister_loader_int(scheme);
282 }
283
284 void ossl_store_destroy_loaders_int(void)
285 {
286     assert(lh_OSSL_STORE_LOADER_num_items(loader_register) == 0);
287     lh_OSSL_STORE_LOADER_free(loader_register);
288     loader_register = NULL;
289     CRYPTO_THREAD_lock_free(registry_lock);
290     registry_lock = NULL;
291 }
292
293 /*
294  *  Functions to list OSSL_STORE loaders
295  */
296
297 IMPLEMENT_LHASH_DOALL_ARG_CONST(OSSL_STORE_LOADER, void);
298 int OSSL_STORE_do_all_loaders(void (*do_function) (const OSSL_STORE_LOADER
299                                                    *loader, void *do_arg),
300                               void *do_arg)
301 {
302     lh_OSSL_STORE_LOADER_doall_void(loader_register, do_function, do_arg);
303     return 1;
304 }