xref: /openbsd/lib/libcrypto/bio/bss_file.c (revision acf64401)
1 /* $OpenBSD: bss_file.c,v 1.35 2023/07/05 21:23:37 beck Exp $ */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  *
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  *
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  *
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  *
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  *
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58 
59 /*
60  * 03-Dec-1997	rdenny@dc3.com  Fix bug preventing use of stdin/stdout
61  *		with binary data (e.g. asn1parse -inform DER < xxx) under
62  *		Windows
63  */
64 
65 #ifndef HEADER_BSS_FILE_C
66 #define HEADER_BSS_FILE_C
67 
68 #if defined(__linux) || defined(__sun) || defined(__hpux)
69 /* Following definition aliases fopen to fopen64 on above mentioned
70  * platforms. This makes it possible to open and sequentially access
71  * files larger than 2GB from 32-bit application. It does not allow to
72  * traverse them beyond 2GB with fseek/ftell, but on the other hand *no*
73  * 32-bit platform permits that, not with fseek/ftell. Not to mention
74  * that breaking 2GB limit for seeking would require surgery to *our*
75  * API. But sequential access suffices for practical cases when you
76  * can run into large files, such as fingerprinting, so we can let API
77  * alone. For reference, the list of 32-bit platforms which allow for
78  * sequential access of large files without extra "magic" comprise *BSD,
79  * Darwin, IRIX...
80  */
81 #ifndef _FILE_OFFSET_BITS
82 #define _FILE_OFFSET_BITS 64
83 #endif
84 #endif
85 
86 #include <errno.h>
87 #include <stdio.h>
88 #include <string.h>
89 
90 #include <openssl/bio.h>
91 #include <openssl/err.h>
92 
93 #include "bio_local.h"
94 
95 static int file_write(BIO *h, const char *buf, int num);
96 static int file_read(BIO *h, char *buf, int size);
97 static int file_puts(BIO *h, const char *str);
98 static int file_gets(BIO *h, char *str, int size);
99 static long file_ctrl(BIO *h, int cmd, long arg1, void *arg2);
100 static int file_new(BIO *h);
101 static int file_free(BIO *data);
102 
103 static const BIO_METHOD methods_filep = {
104 	.type = BIO_TYPE_FILE,
105 	.name = "FILE pointer",
106 	.bwrite = file_write,
107 	.bread = file_read,
108 	.bputs = file_puts,
109 	.bgets = file_gets,
110 	.ctrl = file_ctrl,
111 	.create = file_new,
112 	.destroy = file_free
113 };
114 
115 BIO *
BIO_new_file(const char * filename,const char * mode)116 BIO_new_file(const char *filename, const char *mode)
117 {
118 	BIO  *ret;
119 	FILE *file = NULL;
120 
121 	file = fopen(filename, mode);
122 
123 	if (file == NULL) {
124 		SYSerror(errno);
125 		ERR_asprintf_error_data("fopen('%s', '%s')", filename, mode);
126 		if (errno == ENOENT)
127 			BIOerror(BIO_R_NO_SUCH_FILE);
128 		else
129 			BIOerror(ERR_R_SYS_LIB);
130 		return (NULL);
131 	}
132 	if ((ret = BIO_new(BIO_s_file())) == NULL) {
133 		fclose(file);
134 		return (NULL);
135 	}
136 
137 	BIO_set_fp(ret, file, BIO_CLOSE);
138 	return (ret);
139 }
140 LCRYPTO_ALIAS(BIO_new_file);
141 
142 BIO *
BIO_new_fp(FILE * stream,int close_flag)143 BIO_new_fp(FILE *stream, int close_flag)
144 {
145 	BIO *ret;
146 
147 	if ((ret = BIO_new(BIO_s_file())) == NULL)
148 		return (NULL);
149 
150 	BIO_set_fp(ret, stream, close_flag);
151 	return (ret);
152 }
153 LCRYPTO_ALIAS(BIO_new_fp);
154 
155 const BIO_METHOD *
BIO_s_file(void)156 BIO_s_file(void)
157 {
158 	return (&methods_filep);
159 }
160 LCRYPTO_ALIAS(BIO_s_file);
161 
162 static int
file_new(BIO * bi)163 file_new(BIO *bi)
164 {
165 	bi->init = 0;
166 	bi->num = 0;
167 	bi->ptr = NULL;
168 	bi->flags=0;
169 	return (1);
170 }
171 
172 static int
file_free(BIO * a)173 file_free(BIO *a)
174 {
175 	if (a == NULL)
176 		return (0);
177 	if (a->shutdown) {
178 		if ((a->init) && (a->ptr != NULL)) {
179 			fclose (a->ptr);
180 			a->ptr = NULL;
181 			a->flags = 0;
182 		}
183 		a->init = 0;
184 	}
185 	return (1);
186 }
187 
188 static int
file_read(BIO * b,char * out,int outl)189 file_read(BIO *b, char *out, int outl)
190 {
191 	int ret = 0;
192 
193 	if (b->init && out != NULL) {
194 		ret = fread(out, 1, outl, (FILE *)b->ptr);
195 		if (ret == 0 && ferror((FILE *)b->ptr)) {
196 			SYSerror(errno);
197 			BIOerror(ERR_R_SYS_LIB);
198 			ret = -1;
199 		}
200 	}
201 	return (ret);
202 }
203 
204 static int
file_write(BIO * b,const char * in,int inl)205 file_write(BIO *b, const char *in, int inl)
206 {
207 	int ret = 0;
208 
209 	if (b->init && in != NULL)
210 		ret = fwrite(in, 1, inl, (FILE *)b->ptr);
211 	return (ret);
212 }
213 
214 static long
file_ctrl(BIO * b,int cmd,long num,void * ptr)215 file_ctrl(BIO *b, int cmd, long num, void *ptr)
216 {
217 	long ret = 1;
218 	FILE *fp = (FILE *)b->ptr;
219 	FILE **fpp;
220 	char p[4];
221 
222 	switch (cmd) {
223 	case BIO_C_FILE_SEEK:
224 	case BIO_CTRL_RESET:
225 		ret = (long)fseek(fp, num, 0);
226 		break;
227 	case BIO_CTRL_EOF:
228 		ret = (long)feof(fp);
229 		break;
230 	case BIO_C_FILE_TELL:
231 	case BIO_CTRL_INFO:
232 		ret = ftell(fp);
233 		break;
234 	case BIO_C_SET_FILE_PTR:
235 		file_free(b);
236 		b->shutdown = (int)num&BIO_CLOSE;
237 		b->ptr = ptr;
238 		b->init = 1;
239 		break;
240 	case BIO_C_SET_FILENAME:
241 		file_free(b);
242 		b->shutdown = (int)num&BIO_CLOSE;
243 		if (num & BIO_FP_APPEND) {
244 			if (num & BIO_FP_READ)
245 				strlcpy(p, "a+", sizeof p);
246 			else	strlcpy(p, "a", sizeof p);
247 		} else if ((num & BIO_FP_READ) && (num & BIO_FP_WRITE))
248 			strlcpy(p, "r+", sizeof p);
249 		else if (num & BIO_FP_WRITE)
250 			strlcpy(p, "w", sizeof p);
251 		else if (num & BIO_FP_READ)
252 			strlcpy(p, "r", sizeof p);
253 		else {
254 			BIOerror(BIO_R_BAD_FOPEN_MODE);
255 			ret = 0;
256 			break;
257 		}
258 		fp = fopen(ptr, p);
259 		if (fp == NULL) {
260 			SYSerror(errno);
261 			ERR_asprintf_error_data("fopen('%s', '%s')", ptr, p);
262 			BIOerror(ERR_R_SYS_LIB);
263 			ret = 0;
264 			break;
265 		}
266 		b->ptr = fp;
267 		b->init = 1;
268 		break;
269 	case BIO_C_GET_FILE_PTR:
270 		/* the ptr parameter is actually a FILE ** in this case. */
271 		if (ptr != NULL) {
272 			fpp = (FILE **)ptr;
273 			*fpp = (FILE *)b->ptr;
274 		}
275 		break;
276 	case BIO_CTRL_GET_CLOSE:
277 		ret = (long)b->shutdown;
278 		break;
279 	case BIO_CTRL_SET_CLOSE:
280 		b->shutdown = (int)num;
281 		break;
282 	case BIO_CTRL_FLUSH:
283 		fflush((FILE *)b->ptr);
284 		break;
285 	case BIO_CTRL_DUP:
286 		ret = 1;
287 		break;
288 
289 	case BIO_CTRL_WPENDING:
290 	case BIO_CTRL_PENDING:
291 	case BIO_CTRL_PUSH:
292 	case BIO_CTRL_POP:
293 	default:
294 		ret = 0;
295 		break;
296 	}
297 	return (ret);
298 }
299 
300 static int
file_gets(BIO * bp,char * buf,int size)301 file_gets(BIO *bp, char *buf, int size)
302 {
303 	int ret = 0;
304 
305 	buf[0] = '\0';
306 	if (!fgets(buf, size,(FILE *)bp->ptr))
307 		goto err;
308 	if (buf[0] != '\0')
309 		ret = strlen(buf);
310 err:
311 	return (ret);
312 }
313 
314 static int
file_puts(BIO * bp,const char * str)315 file_puts(BIO *bp, const char *str)
316 {
317 	int n, ret;
318 
319 	n = strlen(str);
320 	ret = file_write(bp, str, n);
321 	return (ret);
322 }
323 
324 
325 #endif /* HEADER_BSS_FILE_C */
326