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