b9bb3b36c032b035511c7db2a6ceeda02f614a61
[openssl.git] / providers / implementations / storemgmt / file_store.c
1 /*
2  * Copyright 2020-2021 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 "e_os.h"                /* To get strncasecmp() on Windows */
11
12 #include <string.h>
13 #include <sys/stat.h>
14 #include <ctype.h>  /* isdigit */
15 #include <assert.h>
16
17 #include <openssl/core_dispatch.h>
18 #include <openssl/core_names.h>
19 #include <openssl/core_object.h>
20 #include <openssl/bio.h>
21 #include <openssl/err.h>
22 #include <openssl/params.h>
23 #include <openssl/decoder.h>
24 #include <openssl/proverr.h>
25 #include <openssl/store.h>       /* The OSSL_STORE_INFO type numbers */
26 #include "internal/cryptlib.h"
27 #include "internal/o_dir.h"
28 #include "crypto/decoder.h"
29 #include "prov/implementations.h"
30 #include "prov/bio.h"
31 #include "file_store_local.h"
32
33 DEFINE_STACK_OF(OSSL_STORE_INFO)
34
35 #ifdef _WIN32
36 # define stat _stat
37 #endif
38
39 #ifndef S_ISDIR
40 # define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
41 #endif
42
43 static OSSL_FUNC_store_open_fn file_open;
44 static OSSL_FUNC_store_attach_fn file_attach;
45 static OSSL_FUNC_store_settable_ctx_params_fn file_settable_ctx_params;
46 static OSSL_FUNC_store_set_ctx_params_fn file_set_ctx_params;
47 static OSSL_FUNC_store_load_fn file_load;
48 static OSSL_FUNC_store_eof_fn file_eof;
49 static OSSL_FUNC_store_close_fn file_close;
50
51 /*
52  * This implementation makes full use of OSSL_DECODER, and then some.
53  * It uses its own internal decoder implementation that reads DER and
54  * passes that on to the data callback; this decoder is created with
55  * internal OpenSSL functions, thereby bypassing the need for a surrounding
56  * provider.  This is ok, since this is a local decoder, not meant for
57  * public consumption.  It also uses the libcrypto internal decoder
58  * setup function ossl_decoder_ctx_setup_for_pkey(), to allow the
59  * last resort decoder to be added first (and thereby be executed last).
60  * Finally, it sets up its own construct and cleanup functions.
61  *
62  * Essentially, that makes this implementation a kind of glorified decoder.
63  */
64
65 struct file_ctx_st {
66     void *provctx;
67     char *uri;                   /* The URI we currently try to load */
68     enum {
69         IS_FILE = 0,             /* Read file and pass results */
70         IS_DIR                   /* Pass directory entry names */
71     } type;
72
73     union {
74         /* Used with |IS_FILE| */
75         struct {
76             BIO *file;
77
78             OSSL_DECODER_CTX *decoderctx;
79             char *input_type;
80             char *propq;    /* The properties we got as a parameter */
81         } file;
82
83         /* Used with |IS_DIR| */
84         struct {
85             OPENSSL_DIR_CTX *ctx;
86             int end_reached;
87
88             /*
89              * When a search expression is given, these are filled in.
90              * |search_name| contains the file basename to look for.
91              * The string is exactly 8 characters long.
92              */
93             char search_name[9];
94
95             /*
96              * The directory reading utility we have combines opening with
97              * reading the first name.  To make sure we can detect the end
98              * at the right time, we read early and cache the name.
99              */
100             const char *last_entry;
101             int last_errno;
102         } dir;
103     } _;
104
105     /* Expected object type.  May be unspecified */
106     int expected_type;
107 };
108
109 static void free_file_ctx(struct file_ctx_st *ctx)
110 {
111     if (ctx == NULL)
112         return;
113
114     OPENSSL_free(ctx->uri);
115     if (ctx->type != IS_DIR) {
116         OSSL_DECODER_CTX_free(ctx->_.file.decoderctx);
117         OPENSSL_free(ctx->_.file.propq);
118         OPENSSL_free(ctx->_.file.input_type);
119     }
120     OPENSSL_free(ctx);
121 }
122
123 static struct file_ctx_st *new_file_ctx(int type, const char *uri,
124                                         void *provctx)
125 {
126     struct file_ctx_st *ctx = NULL;
127
128     if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) != NULL
129         && (uri == NULL || (ctx->uri = OPENSSL_strdup(uri)) != NULL)) {
130         ctx->type = type;
131         ctx->provctx = provctx;
132         return ctx;
133     }
134     free_file_ctx(ctx);
135     return NULL;
136 }
137
138 static OSSL_DECODER_CONSTRUCT file_load_construct;
139 static OSSL_DECODER_CLEANUP file_load_cleanup;
140
141 /*-
142  *  Opening / attaching streams and directories
143  *  -------------------------------------------
144  */
145
146 /*
147  * Function to service both file_open() and file_attach()
148  *
149  *
150  */
151 static struct file_ctx_st *file_open_stream(BIO *source, const char *uri,
152                                             void *provctx)
153 {
154     struct file_ctx_st *ctx;
155
156     if ((ctx = new_file_ctx(IS_FILE, uri, provctx)) == NULL) {
157         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
158         goto err;
159     }
160
161     ctx->_.file.file = source;
162
163     return ctx;
164  err:
165     free_file_ctx(ctx);
166     return NULL;
167 }
168
169 static void *file_open_dir(const char *path, const char *uri, void *provctx)
170 {
171     struct file_ctx_st *ctx;
172
173     if ((ctx = new_file_ctx(IS_DIR, uri, provctx)) == NULL) {
174         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
175         goto err;
176     }
177
178     ctx->_.dir.last_entry = OPENSSL_DIR_read(&ctx->_.dir.ctx, path);
179     ctx->_.dir.last_errno = errno;
180     if (ctx->_.dir.last_entry == NULL) {
181         if (ctx->_.dir.last_errno != 0) {
182             ERR_raise_data(ERR_LIB_SYS, ctx->_.dir.last_errno,
183                            "Calling OPENSSL_DIR_read(\"%s\")", path);
184             goto err;
185         }
186         ctx->_.dir.end_reached = 1;
187     }
188     return ctx;
189  err:
190     file_close(ctx);
191     return NULL;
192 }
193
194 static void *file_open(void *provctx, const char *uri)
195 {
196     struct file_ctx_st *ctx = NULL;
197     struct stat st;
198     struct {
199         const char *path;
200         unsigned int check_absolute:1;
201     } path_data[2];
202     size_t path_data_n = 0, i;
203     const char *path;
204     BIO *bio;
205
206     ERR_set_mark();
207
208     /*
209      * First step, just take the URI as is.
210      */
211     path_data[path_data_n].check_absolute = 0;
212     path_data[path_data_n++].path = uri;
213
214     /*
215      * Second step, if the URI appears to start with the 'file' scheme,
216      * extract the path and make that the second path to check.
217      * There's a special case if the URI also contains an authority, then
218      * the full URI shouldn't be used as a path anywhere.
219      */
220     if (strncasecmp(uri, "file:", 5) == 0) {
221         const char *p = &uri[5];
222
223         if (strncmp(&uri[5], "//", 2) == 0) {
224             path_data_n--;           /* Invalidate using the full URI */
225             if (strncasecmp(&uri[7], "localhost/", 10) == 0) {
226                 p = &uri[16];
227             } else if (uri[7] == '/') {
228                 p = &uri[7];
229             } else {
230                 ERR_clear_last_mark();
231                 ERR_raise(ERR_LIB_PROV, PROV_R_URI_AUTHORITY_UNSUPPORTED);
232                 return NULL;
233             }
234         }
235
236         path_data[path_data_n].check_absolute = 1;
237 #ifdef _WIN32
238         /* Windows file: URIs with a drive letter start with a / */
239         if (p[0] == '/' && p[2] == ':' && p[3] == '/') {
240             char c = tolower(p[1]);
241
242             if (c >= 'a' && c <= 'z') {
243                 p++;
244                 /* We know it's absolute, so no need to check */
245                 path_data[path_data_n].check_absolute = 0;
246             }
247         }
248 #endif
249         path_data[path_data_n++].path = p;
250     }
251
252
253     for (i = 0, path = NULL; path == NULL && i < path_data_n; i++) {
254         /*
255          * If the scheme "file" was an explicit part of the URI, the path must
256          * be absolute.  So says RFC 8089
257          */
258         if (path_data[i].check_absolute && path_data[i].path[0] != '/') {
259             ERR_clear_last_mark();
260             ERR_raise_data(ERR_LIB_PROV, PROV_R_PATH_MUST_BE_ABSOLUTE,
261                            "Given path=%s", path_data[i].path);
262             return NULL;
263         }
264
265         if (stat(path_data[i].path, &st) < 0) {
266             ERR_raise_data(ERR_LIB_SYS, errno,
267                            "calling stat(%s)",
268                            path_data[i].path);
269         } else {
270             path = path_data[i].path;
271         }
272     }
273     if (path == NULL) {
274         ERR_clear_last_mark();
275         return NULL;
276     }
277
278     /* Successfully found a working path, clear possible collected errors */
279     ERR_pop_to_mark();
280
281     if (S_ISDIR(st.st_mode))
282         ctx = file_open_dir(path, uri, provctx);
283     else if ((bio = BIO_new_file(path, "rb")) == NULL
284              || (ctx = file_open_stream(bio, uri, provctx)) == NULL)
285         BIO_free_all(bio);
286
287     return ctx;
288 }
289
290 void *file_attach(void *provctx, OSSL_CORE_BIO *cin)
291 {
292     struct file_ctx_st *ctx;
293     BIO *new_bio = ossl_bio_new_from_core_bio(provctx, cin);
294
295     if (new_bio == NULL)
296         return NULL;
297
298     ctx = file_open_stream(new_bio, NULL, provctx);
299     if (ctx == NULL)
300         BIO_free(new_bio);
301     return ctx;
302 }
303
304 /*-
305  *  Setting parameters
306  *  ------------------
307  */
308
309 static const OSSL_PARAM *file_settable_ctx_params(void *provctx)
310 {
311     static const OSSL_PARAM known_settable_ctx_params[] = {
312         OSSL_PARAM_utf8_string(OSSL_STORE_PARAM_PROPERTIES, NULL, 0),
313         OSSL_PARAM_int(OSSL_STORE_PARAM_EXPECT, NULL),
314         OSSL_PARAM_octet_string(OSSL_STORE_PARAM_SUBJECT, NULL, 0),
315         OSSL_PARAM_utf8_string(OSSL_STORE_PARAM_INPUT_TYPE, NULL, 0),
316         OSSL_PARAM_END
317     };
318     return known_settable_ctx_params;
319 }
320
321 static int file_set_ctx_params(void *loaderctx, const OSSL_PARAM params[])
322 {
323     struct file_ctx_st *ctx = loaderctx;
324     const OSSL_PARAM *p;
325
326     if (params == NULL)
327         return 1;
328
329     if (ctx->type != IS_DIR) {
330         /* these parameters are ignored for directories */
331         p = OSSL_PARAM_locate_const(params, OSSL_STORE_PARAM_PROPERTIES);
332         if (p != NULL) {
333             OPENSSL_free(ctx->_.file.propq);
334             ctx->_.file.propq = NULL;
335             if (!OSSL_PARAM_get_utf8_string(p, &ctx->_.file.propq, 0))
336                 return 0;
337         }
338         p = OSSL_PARAM_locate_const(params, OSSL_STORE_PARAM_INPUT_TYPE);
339         if (p != NULL) {
340             OPENSSL_free(ctx->_.file.input_type);
341             ctx->_.file.input_type = NULL;
342             if (!OSSL_PARAM_get_utf8_string(p, &ctx->_.file.input_type, 0))
343                 return 0;
344         }
345     }
346     p = OSSL_PARAM_locate_const(params, OSSL_STORE_PARAM_EXPECT);
347     if (p != NULL && !OSSL_PARAM_get_int(p, &ctx->expected_type))
348         return 0;
349     p = OSSL_PARAM_locate_const(params, OSSL_STORE_PARAM_SUBJECT);
350     if (p != NULL) {
351         const unsigned char *der = NULL;
352         size_t der_len = 0;
353         X509_NAME *x509_name;
354         unsigned long hash;
355         int ok;
356
357         if (ctx->type != IS_DIR) {
358             ERR_raise(ERR_LIB_PROV,
359                       PROV_R_SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES);
360             return 0;
361         }
362
363         if (!OSSL_PARAM_get_octet_string_ptr(p, (const void **)&der, &der_len)
364             || (x509_name = d2i_X509_NAME(NULL, &der, der_len)) == NULL)
365             return 0;
366         hash = X509_NAME_hash_ex(x509_name,
367                                  ossl_prov_ctx_get0_libctx(ctx->provctx), NULL,
368                                  &ok);
369         BIO_snprintf(ctx->_.dir.search_name, sizeof(ctx->_.dir.search_name),
370                      "%08lx", hash);
371         X509_NAME_free(x509_name);
372         if (ok == 0)
373             return 0;
374     }
375     return 1;
376 }
377
378 /*-
379  *  Loading an object from a stream
380  *  -------------------------------
381  */
382
383 struct file_load_data_st {
384     OSSL_CALLBACK *object_cb;
385     void *object_cbarg;
386 };
387
388 static int file_load_construct(OSSL_DECODER_INSTANCE *decoder_inst,
389                                const OSSL_PARAM *params, void *construct_data)
390 {
391     struct file_load_data_st *data = construct_data;
392
393     /*
394      * At some point, we may find it justifiable to recognise PKCS#12 and
395      * handle it specially here, making |file_load()| return pass its
396      * contents one piece at ta time, like |e_loader_attic.c| does.
397      *
398      * However, that currently means parsing them out, which converts the
399      * DER encoded PKCS#12 into a bunch of EVP_PKEYs and X509s, just to
400      * have to re-encode them into DER to create an object abstraction for
401      * each of them.
402      * It's much simpler (less churn) to pass on the object abstraction we
403      * get to the load_result callback and leave it to that one to do the
404      * work.  If that's libcrypto code, we know that it has much better
405      * possibilities to handle the EVP_PKEYs and X509s without the extra
406      * churn.
407      */
408
409     return data->object_cb(params, data->object_cbarg);
410 }
411
412 void file_load_cleanup(void *construct_data)
413 {
414     /* Nothing to do */
415 }
416
417 static int file_setup_decoders(struct file_ctx_st *ctx)
418 {
419     EVP_PKEY *dummy; /* for ossl_decoder_ctx_setup_for_pkey() */
420     OSSL_LIB_CTX *libctx = ossl_prov_ctx_get0_libctx(ctx->provctx);
421     OSSL_DECODER *to_obj = NULL; /* Last resort decoder */
422     OSSL_DECODER_INSTANCE *to_obj_inst = NULL;
423     OSSL_DECODER_CLEANUP *old_cleanup = NULL;
424     void *old_construct_data = NULL;
425     int ok = 0, expect_evp_pkey = 0;
426
427     /* Setup for this session, so only if not already done */
428     if (ctx->_.file.decoderctx == NULL) {
429         if ((ctx->_.file.decoderctx = OSSL_DECODER_CTX_new()) == NULL) {
430             ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
431             goto err;
432         }
433
434         expect_evp_pkey = (ctx->expected_type == 0
435                            || ctx->expected_type == OSSL_STORE_INFO_PARAMS
436                            || ctx->expected_type == OSSL_STORE_INFO_PUBKEY
437                            || ctx->expected_type == OSSL_STORE_INFO_PKEY);
438
439         /* Make sure the input type is set */
440         if (!OSSL_DECODER_CTX_set_input_type(ctx->_.file.decoderctx,
441                                              ctx->_.file.input_type)) {
442             ERR_raise(ERR_LIB_PROV, ERR_R_OSSL_DECODER_LIB);
443             goto err;
444         }
445
446         /*
447          * Create the internal last resort decoder implementation together
448          * with a "decoder instance".
449          * The decoder doesn't need any identification or to be attached to
450          * any provider, since it's only used locally.
451          */
452         to_obj = ossl_decoder_from_algorithm(0, &ossl_der_to_obj_algorithm,
453                                              NULL);
454         if (to_obj == NULL)
455             goto err;
456         to_obj_inst = ossl_decoder_instance_new(to_obj, ctx->provctx);
457         if (to_obj_inst == NULL)
458             goto err;
459
460         if (!ossl_decoder_ctx_add_decoder_inst(ctx->_.file.decoderctx,
461                                                to_obj_inst)) {
462             ERR_raise(ERR_LIB_PROV, ERR_R_OSSL_DECODER_LIB);
463             goto err;
464         }
465
466         /*
467          * OSSL_DECODER_INSTANCE shouldn't be freed from this point on.
468          * That's going to happen whenever the OSSL_DECODER_CTX is freed.
469          */
470         to_obj_inst = NULL;
471
472         /*
473          * Add on the usual decoder context for keys, with a dummy object.
474          * Since we're setting up our own constructor, we don't need to care
475          * more than that...
476          */
477         if ((expect_evp_pkey
478              && !ossl_decoder_ctx_setup_for_pkey(ctx->_.file.decoderctx,
479                                                  &dummy, NULL,
480                                                  libctx, ctx->_.file.propq))
481             || !OSSL_DECODER_CTX_add_extra(ctx->_.file.decoderctx,
482                                            libctx, ctx->_.file.propq)) {
483             ERR_raise(ERR_LIB_PROV, ERR_R_OSSL_DECODER_LIB);
484             goto err;
485         }
486
487         /*
488          * Then we throw away the installed finalizer data, and install our
489          * own instead.
490          */
491         old_cleanup = OSSL_DECODER_CTX_get_cleanup(ctx->_.file.decoderctx);
492         old_construct_data =
493             OSSL_DECODER_CTX_get_construct_data(ctx->_.file.decoderctx);
494         if (old_cleanup != NULL)
495             old_cleanup(old_construct_data);
496
497         /*
498          * Set the hooks.
499          */
500         if (!OSSL_DECODER_CTX_set_construct(ctx->_.file.decoderctx,
501                                             file_load_construct)
502             || !OSSL_DECODER_CTX_set_cleanup(ctx->_.file.decoderctx,
503                                              file_load_cleanup)) {
504             ERR_raise(ERR_LIB_PROV, ERR_R_OSSL_DECODER_LIB);
505             goto err;
506         }
507     }
508
509     ok = 1;
510  err:
511     OSSL_DECODER_free(to_obj);
512     return ok;
513 }
514
515 static int file_load_file(struct file_ctx_st *ctx,
516                           OSSL_CALLBACK *object_cb, void *object_cbarg,
517                           OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg)
518 {
519     struct file_load_data_st data;
520
521     /* Setup the decoders (one time shot per session */
522
523     if (!file_setup_decoders(ctx))
524         return 0;
525
526     /* Setup for this object */
527
528     data.object_cb = object_cb;
529     data.object_cbarg = object_cbarg;
530     OSSL_DECODER_CTX_set_construct_data(ctx->_.file.decoderctx, &data);
531     OSSL_DECODER_CTX_set_passphrase_cb(ctx->_.file.decoderctx, pw_cb, pw_cbarg);
532
533     /* Launch */
534
535     return OSSL_DECODER_from_bio(ctx->_.file.decoderctx, ctx->_.file.file);
536 }
537
538 /*-
539  *  Loading a name object from a directory
540  *  --------------------------------------
541  */
542
543 static char *file_name_to_uri(struct file_ctx_st *ctx, const char *name)
544 {
545     char *data = NULL;
546
547     assert(name != NULL);
548     {
549         const char *pathsep = ossl_ends_with_dirsep(ctx->uri) ? "" : "/";
550         long calculated_length = strlen(ctx->uri) + strlen(pathsep)
551             + strlen(name) + 1 /* \0 */;
552
553         data = OPENSSL_zalloc(calculated_length);
554         if (data == NULL) {
555             ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
556             return NULL;
557         }
558
559         OPENSSL_strlcat(data, ctx->uri, calculated_length);
560         OPENSSL_strlcat(data, pathsep, calculated_length);
561         OPENSSL_strlcat(data, name, calculated_length);
562     }
563     return data;
564 }
565
566 static int file_name_check(struct file_ctx_st *ctx, const char *name)
567 {
568     const char *p = NULL;
569
570     /* If there are no search criteria, all names are accepted */
571     if (ctx->_.dir.search_name[0] == '\0')
572         return 1;
573
574     /* If the expected type isn't supported, no name is accepted */
575     if (ctx->expected_type != 0
576         && ctx->expected_type != OSSL_STORE_INFO_CERT
577         && ctx->expected_type != OSSL_STORE_INFO_CRL)
578         return 0;
579
580     /*
581      * First, check the basename
582      */
583     if (strncasecmp(name, ctx->_.dir.search_name,
584                     sizeof(ctx->_.dir.search_name) - 1) != 0
585         || name[sizeof(ctx->_.dir.search_name) - 1] != '.')
586         return 0;
587     p = &name[sizeof(ctx->_.dir.search_name)];
588
589     /*
590      * Then, if the expected type is a CRL, check that the extension starts
591      * with 'r'
592      */
593     if (*p == 'r') {
594         p++;
595         if (ctx->expected_type != 0
596             && ctx->expected_type != OSSL_STORE_INFO_CRL)
597             return 0;
598     } else if (ctx->expected_type == OSSL_STORE_INFO_CRL) {
599         return 0;
600     }
601
602     /*
603      * Last, check that the rest of the extension is a decimal number, at
604      * least one digit long.
605      */
606     if (!isdigit(*p))
607         return 0;
608     while (isdigit(*p))
609         p++;
610
611 #ifdef __VMS
612     /*
613      * One extra step here, check for a possible generation number.
614      */
615     if (*p == ';')
616         for (p++; *p != '\0'; p++)
617             if (!ossl_isdigit(*p))
618                 break;
619 #endif
620
621     /*
622      * If we've reached the end of the string at this point, we've successfully
623      * found a fitting file name.
624      */
625     return *p == '\0';
626 }
627
628 static int file_load_dir_entry(struct file_ctx_st *ctx,
629                                OSSL_CALLBACK *object_cb, void *object_cbarg,
630                                OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg)
631 {
632     /* Prepare as much as possible in advance */
633     static const int object_type = OSSL_OBJECT_NAME;
634     OSSL_PARAM object[] = {
635         OSSL_PARAM_int(OSSL_OBJECT_PARAM_TYPE, (int *)&object_type),
636         OSSL_PARAM_utf8_string(OSSL_OBJECT_PARAM_DATA, NULL, 0),
637         OSSL_PARAM_END
638     };
639     char *newname = NULL;
640     int ok;
641
642     /* Loop until we get an error or until we have a suitable name */
643     do {
644         if (ctx->_.dir.last_entry == NULL) {
645             if (!ctx->_.dir.end_reached) {
646                 assert(ctx->_.dir.last_errno != 0);
647                 ERR_raise(ERR_LIB_SYS, ctx->_.dir.last_errno);
648             }
649             /* file_eof() will tell if EOF was reached */
650             return 0;
651         }
652
653         /* flag acceptable names */
654         if (ctx->_.dir.last_entry[0] != '.'
655             && file_name_check(ctx, ctx->_.dir.last_entry)) {
656
657             /* If we can't allocate the new name, we fail */
658             if ((newname =
659                  file_name_to_uri(ctx, ctx->_.dir.last_entry)) == NULL)
660                 return 0;
661         }
662
663         /*
664          * On the first call (with a NULL context), OPENSSL_DIR_read()
665          * cares about the second argument.  On the following calls, it
666          * only cares that it isn't NULL.  Therefore, we can safely give
667          * it our URI here.
668          */
669         ctx->_.dir.last_entry = OPENSSL_DIR_read(&ctx->_.dir.ctx, ctx->uri);
670         ctx->_.dir.last_errno = errno;
671         if (ctx->_.dir.last_entry == NULL && ctx->_.dir.last_errno == 0)
672             ctx->_.dir.end_reached = 1;
673     } while (newname == NULL);
674
675     object[1].data = newname;
676     object[1].data_size = strlen(newname);
677     ok = object_cb(object, object_cbarg);
678     OPENSSL_free(newname);
679     return ok;
680 }
681
682 /*-
683  *  Loading, local dispatcher
684  *  -------------------------
685  */
686
687 static int file_load(void *loaderctx,
688                      OSSL_CALLBACK *object_cb, void *object_cbarg,
689                      OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg)
690 {
691     struct file_ctx_st *ctx = loaderctx;
692
693     switch (ctx->type) {
694     case IS_FILE:
695         return file_load_file(ctx, object_cb, object_cbarg, pw_cb, pw_cbarg);
696     case IS_DIR:
697         return
698             file_load_dir_entry(ctx, object_cb, object_cbarg, pw_cb, pw_cbarg);
699     default:
700         break;
701     }
702
703     /* ctx->type has an unexpected value */
704     assert(0);
705     return 0;
706 }
707
708 /*-
709  *  Eof detection and closing
710  *  -------------------------
711  */
712
713 static int file_eof(void *loaderctx)
714 {
715     struct file_ctx_st *ctx = loaderctx;
716
717     switch (ctx->type) {
718     case IS_DIR:
719         return ctx->_.dir.end_reached;
720     case IS_FILE:
721         /*
722          * BIO_pending() checks any filter BIO.
723          * BIO_eof() checks the source BIO.
724          */
725         return !BIO_pending(ctx->_.file.file)
726             && BIO_eof(ctx->_.file.file);
727     }
728
729     /* ctx->type has an unexpected value */
730     assert(0);
731     return 1;
732 }
733
734 static int file_close_dir(struct file_ctx_st *ctx)
735 {
736     if (ctx->_.dir.ctx != NULL)
737         OPENSSL_DIR_end(&ctx->_.dir.ctx);
738     free_file_ctx(ctx);
739     return 1;
740 }
741
742 static int file_close_stream(struct file_ctx_st *ctx)
743 {
744     /*
745      * This frees either the provider BIO filter (for file_attach()) OR
746      * the allocated file BIO (for file_open()).
747      */
748     BIO_free(ctx->_.file.file);
749     ctx->_.file.file = NULL;
750
751     free_file_ctx(ctx);
752     return 1;
753 }
754
755 static int file_close(void *loaderctx)
756 {
757     struct file_ctx_st *ctx = loaderctx;
758
759     switch (ctx->type) {
760     case IS_DIR:
761         return file_close_dir(ctx);
762     case IS_FILE:
763         return file_close_stream(ctx);
764     }
765
766     /* ctx->type has an unexpected value */
767     assert(0);
768     return 1;
769 }
770
771 const OSSL_DISPATCH ossl_file_store_functions[] = {
772     { OSSL_FUNC_STORE_OPEN, (void (*)(void))file_open },
773     { OSSL_FUNC_STORE_ATTACH, (void (*)(void))file_attach },
774     { OSSL_FUNC_STORE_SETTABLE_CTX_PARAMS,
775       (void (*)(void))file_settable_ctx_params },
776     { OSSL_FUNC_STORE_SET_CTX_PARAMS, (void (*)(void))file_set_ctx_params },
777     { OSSL_FUNC_STORE_LOAD, (void (*)(void))file_load },
778     { OSSL_FUNC_STORE_EOF, (void (*)(void))file_eof },
779     { OSSL_FUNC_STORE_CLOSE, (void (*)(void))file_close },
780     { 0, NULL },
781 };