RT4660: BIO_METHODs should be const.
[openssl.git] / crypto / bio / bss_file.c
1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
2  * All rights reserved.
3  *
4  * This package is an SSL implementation written
5  * by Eric Young (eay@cryptsoft.com).
6  * The implementation was written so as to conform with Netscapes SSL.
7  *
8  * This library is free for commercial and non-commercial use as long as
9  * the following conditions are aheared to.  The following conditions
10  * apply to all code found in this distribution, be it the RC4, RSA,
11  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
12  * included with this distribution is covered by the same copyright terms
13  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
14  *
15  * Copyright remains Eric Young's, and as such any Copyright notices in
16  * the code are not to be removed.
17  * If this package is used in a product, Eric Young should be given attribution
18  * as the author of the parts of the library used.
19  * This can be in the form of a textual message at program startup or
20  * in documentation (online or textual) provided with the package.
21  *
22  * Redistribution and use in source and binary forms, with or without
23  * modification, are permitted provided that the following conditions
24  * are met:
25  * 1. Redistributions of source code must retain the copyright
26  *    notice, this list of conditions and the following disclaimer.
27  * 2. Redistributions in binary form must reproduce the above copyright
28  *    notice, this list of conditions and the following disclaimer in the
29  *    documentation and/or other materials provided with the distribution.
30  * 3. All advertising materials mentioning features or use of this software
31  *    must display the following acknowledgement:
32  *    "This product includes cryptographic software written by
33  *     Eric Young (eay@cryptsoft.com)"
34  *    The word 'cryptographic' can be left out if the rouines from the library
35  *    being used are not cryptographic related :-).
36  * 4. If you include any Windows specific code (or a derivative thereof) from
37  *    the apps directory (application code) you must include an acknowledgement:
38  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
39  *
40  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50  * SUCH DAMAGE.
51  *
52  * The licence and distribution terms for any publically available version or
53  * derivative of this code cannot be changed.  i.e. this code cannot simply be
54  * copied and put under another distribution licence
55  * [including the GNU Public Licence.]
56  */
57
58 /*-
59  * 03-Dec-1997  rdenny@dc3.com  Fix bug preventing use of stdin/stdout
60  *              with binary data (e.g. asn1parse -inform DER < xxx) under
61  *              Windows
62  */
63
64 #ifndef HEADER_BSS_FILE_C
65 # define HEADER_BSS_FILE_C
66
67 # if defined(__linux) || defined(__sun) || defined(__hpux)
68 /*
69  * Following definition aliases fopen to fopen64 on above mentioned
70  * platforms. This makes it possible to open and sequentially access files
71  * larger than 2GB from 32-bit application. It does not allow to traverse
72  * them beyond 2GB with fseek/ftell, but on the other hand *no* 32-bit
73  * platform permits that, not with fseek/ftell. Not to mention that breaking
74  * 2GB limit for seeking would require surgery to *our* API. But sequential
75  * access suffices for practical cases when you can run into large files,
76  * such as fingerprinting, so we can let API alone. For reference, the list
77  * of 32-bit platforms which allow for sequential access of large files
78  * without extra "magic" comprise *BSD, Darwin, IRIX...
79  */
80 #  ifndef _FILE_OFFSET_BITS
81 #   define _FILE_OFFSET_BITS 64
82 #  endif
83 # endif
84
85 # include <stdio.h>
86 # include <errno.h>
87 # include "bio_lcl.h"
88 # include <openssl/err.h>
89
90 # if !defined(OPENSSL_NO_STDIO)
91
92 static int file_write(BIO *h, const char *buf, int num);
93 static int file_read(BIO *h, char *buf, int size);
94 static int file_puts(BIO *h, const char *str);
95 static int file_gets(BIO *h, char *str, int size);
96 static long file_ctrl(BIO *h, int cmd, long arg1, void *arg2);
97 static int file_new(BIO *h);
98 static int file_free(BIO *data);
99 static const BIO_METHOD methods_filep = {
100     BIO_TYPE_FILE,
101     "FILE pointer",
102     file_write,
103     file_read,
104     file_puts,
105     file_gets,
106     file_ctrl,
107     file_new,
108     file_free,
109     NULL,
110 };
111
112 static FILE *file_fopen(const char *filename, const char *mode)
113 {
114     FILE *file = NULL;
115
116 #  if defined(_WIN32) && defined(CP_UTF8)
117     int sz, len_0 = (int)strlen(filename) + 1;
118     DWORD flags;
119
120     /*
121      * Basically there are three cases to cover: a) filename is
122      * pure ASCII string; b) actual UTF-8 encoded string and
123      * c) locale-ized string, i.e. one containing 8-bit
124      * characters that are meaningful in current system locale.
125      * If filename is pure ASCII or real UTF-8 encoded string,
126      * MultiByteToWideChar succeeds and _wfopen works. If
127      * filename is locale-ized string, chances are that
128      * MultiByteToWideChar fails reporting
129      * ERROR_NO_UNICODE_TRANSLATION, in which case we fall
130      * back to fopen...
131      */
132     if ((sz = MultiByteToWideChar(CP_UTF8, (flags = MB_ERR_INVALID_CHARS),
133                                   filename, len_0, NULL, 0)) > 0 ||
134         (GetLastError() == ERROR_INVALID_FLAGS &&
135          (sz = MultiByteToWideChar(CP_UTF8, (flags = 0),
136                                    filename, len_0, NULL, 0)) > 0)
137         ) {
138         WCHAR wmode[8];
139         WCHAR *wfilename = _alloca(sz * sizeof(WCHAR));
140
141         if (MultiByteToWideChar(CP_UTF8, flags,
142                                 filename, len_0, wfilename, sz) &&
143             MultiByteToWideChar(CP_UTF8, 0, mode, strlen(mode) + 1,
144                                 wmode, OSSL_NELEM(wmode)) &&
145             (file = _wfopen(wfilename, wmode)) == NULL &&
146             (errno == ENOENT || errno == EBADF)
147             ) {
148             /*
149              * UTF-8 decode succeeded, but no file, filename
150              * could still have been locale-ized...
151              */
152             file = fopen(filename, mode);
153         }
154     } else if (GetLastError() == ERROR_NO_UNICODE_TRANSLATION) {
155         file = fopen(filename, mode);
156     }
157 #  else
158     file = fopen(filename, mode);
159 #  endif
160     return (file);
161 }
162
163 BIO *BIO_new_file(const char *filename, const char *mode)
164 {
165     BIO  *ret;
166     FILE *file = file_fopen(filename, mode);
167
168     if (file == NULL) {
169         SYSerr(SYS_F_FOPEN, get_last_sys_error());
170         ERR_add_error_data(5, "fopen('", filename, "','", mode, "')");
171         if (errno == ENOENT)
172             BIOerr(BIO_F_BIO_NEW_FILE, BIO_R_NO_SUCH_FILE);
173         else
174             BIOerr(BIO_F_BIO_NEW_FILE, ERR_R_SYS_LIB);
175         return (NULL);
176     }
177     if ((ret = BIO_new(BIO_s_file())) == NULL) {
178         fclose(file);
179         return (NULL);
180     }
181
182     BIO_clear_flags(ret, BIO_FLAGS_UPLINK); /* we did fopen -> we disengage
183                                              * UPLINK */
184     BIO_set_fp(ret, file, BIO_CLOSE);
185     return (ret);
186 }
187
188 BIO *BIO_new_fp(FILE *stream, int close_flag)
189 {
190     BIO *ret;
191
192     if ((ret = BIO_new(BIO_s_file())) == NULL)
193         return (NULL);
194
195     /* redundant flag, left for documentation purposes */
196     BIO_set_flags(ret, BIO_FLAGS_UPLINK);
197     BIO_set_fp(ret, stream, close_flag);
198     return (ret);
199 }
200
201 const BIO_METHOD *BIO_s_file(void)
202 {
203     return (&methods_filep);
204 }
205
206 static int file_new(BIO *bi)
207 {
208     bi->init = 0;
209     bi->num = 0;
210     bi->ptr = NULL;
211     bi->flags = BIO_FLAGS_UPLINK; /* default to UPLINK */
212     return (1);
213 }
214
215 static int file_free(BIO *a)
216 {
217     if (a == NULL)
218         return (0);
219     if (a->shutdown) {
220         if ((a->init) && (a->ptr != NULL)) {
221             if (a->flags & BIO_FLAGS_UPLINK)
222                 UP_fclose(a->ptr);
223             else
224                 fclose(a->ptr);
225             a->ptr = NULL;
226             a->flags = BIO_FLAGS_UPLINK;
227         }
228         a->init = 0;
229     }
230     return (1);
231 }
232
233 static int file_read(BIO *b, char *out, int outl)
234 {
235     int ret = 0;
236
237     if (b->init && (out != NULL)) {
238         if (b->flags & BIO_FLAGS_UPLINK)
239             ret = UP_fread(out, 1, (int)outl, b->ptr);
240         else
241             ret = fread(out, 1, (int)outl, (FILE *)b->ptr);
242         if (ret == 0
243             && (b->flags & BIO_FLAGS_UPLINK) ? UP_ferror((FILE *)b->ptr) :
244             ferror((FILE *)b->ptr)) {
245             SYSerr(SYS_F_FREAD, get_last_sys_error());
246             BIOerr(BIO_F_FILE_READ, ERR_R_SYS_LIB);
247             ret = -1;
248         }
249     }
250     return (ret);
251 }
252
253 static int file_write(BIO *b, const char *in, int inl)
254 {
255     int ret = 0;
256
257     if (b->init && (in != NULL)) {
258         if (b->flags & BIO_FLAGS_UPLINK)
259             ret = UP_fwrite(in, (int)inl, 1, b->ptr);
260         else
261             ret = fwrite(in, (int)inl, 1, (FILE *)b->ptr);
262         if (ret)
263             ret = inl;
264         /* ret=fwrite(in,1,(int)inl,(FILE *)b->ptr); */
265         /*
266          * according to Tim Hudson <tjh@cryptsoft.com>, the commented out
267          * version above can cause 'inl' write calls under some stupid stdio
268          * implementations (VMS)
269          */
270     }
271     return (ret);
272 }
273
274 static long file_ctrl(BIO *b, int cmd, long num, void *ptr)
275 {
276     long ret = 1;
277     FILE *fp = (FILE *)b->ptr;
278     FILE **fpp;
279     char p[4];
280
281     switch (cmd) {
282     case BIO_C_FILE_SEEK:
283     case BIO_CTRL_RESET:
284         if (b->flags & BIO_FLAGS_UPLINK)
285             ret = (long)UP_fseek(b->ptr, num, 0);
286         else
287             ret = (long)fseek(fp, num, 0);
288         break;
289     case BIO_CTRL_EOF:
290         if (b->flags & BIO_FLAGS_UPLINK)
291             ret = (long)UP_feof(fp);
292         else
293             ret = (long)feof(fp);
294         break;
295     case BIO_C_FILE_TELL:
296     case BIO_CTRL_INFO:
297         if (b->flags & BIO_FLAGS_UPLINK)
298             ret = UP_ftell(b->ptr);
299         else
300             ret = ftell(fp);
301         break;
302     case BIO_C_SET_FILE_PTR:
303         file_free(b);
304         b->shutdown = (int)num & BIO_CLOSE;
305         b->ptr = ptr;
306         b->init = 1;
307 #  if BIO_FLAGS_UPLINK!=0
308 #   if defined(__MINGW32__) && defined(__MSVCRT__) && !defined(_IOB_ENTRIES)
309 #    define _IOB_ENTRIES 20
310 #   endif
311 #   if defined(_IOB_ENTRIES)
312         /* Safety net to catch purely internal BIO_set_fp calls */
313         if ((size_t)ptr >= (size_t)stdin &&
314             (size_t)ptr < (size_t)(stdin + _IOB_ENTRIES))
315             BIO_clear_flags(b, BIO_FLAGS_UPLINK);
316 #   endif
317 #  endif
318 #  ifdef UP_fsetmod
319         if (b->flags & BIO_FLAGS_UPLINK)
320             UP_fsetmod(b->ptr, (char)((num & BIO_FP_TEXT) ? 't' : 'b'));
321         else
322 #  endif
323         {
324 #  if defined(OPENSSL_SYS_WINDOWS)
325             int fd = _fileno((FILE *)ptr);
326             if (num & BIO_FP_TEXT)
327                 _setmode(fd, _O_TEXT);
328             else
329                 _setmode(fd, _O_BINARY);
330 #  elif defined(OPENSSL_SYS_MSDOS)
331             int fd = fileno((FILE *)ptr);
332             /* Set correct text/binary mode */
333             if (num & BIO_FP_TEXT)
334                 _setmode(fd, _O_TEXT);
335             /* Dangerous to set stdin/stdout to raw (unless redirected) */
336             else {
337                 if (fd == STDIN_FILENO || fd == STDOUT_FILENO) {
338                     if (isatty(fd) <= 0)
339                         _setmode(fd, _O_BINARY);
340                 } else
341                     _setmode(fd, _O_BINARY);
342             }
343 #  elif defined(OPENSSL_SYS_WIN32_CYGWIN)
344             int fd = fileno((FILE *)ptr);
345             if (num & BIO_FP_TEXT)
346                 setmode(fd, O_TEXT);
347             else
348                 setmode(fd, O_BINARY);
349 #  endif
350         }
351         break;
352     case BIO_C_SET_FILENAME:
353         file_free(b);
354         b->shutdown = (int)num & BIO_CLOSE;
355         if (num & BIO_FP_APPEND) {
356             if (num & BIO_FP_READ)
357                 OPENSSL_strlcpy(p, "a+", sizeof p);
358             else
359                 OPENSSL_strlcpy(p, "a", sizeof p);
360         } else if ((num & BIO_FP_READ) && (num & BIO_FP_WRITE))
361             OPENSSL_strlcpy(p, "r+", sizeof p);
362         else if (num & BIO_FP_WRITE)
363             OPENSSL_strlcpy(p, "w", sizeof p);
364         else if (num & BIO_FP_READ)
365             OPENSSL_strlcpy(p, "r", sizeof p);
366         else {
367             BIOerr(BIO_F_FILE_CTRL, BIO_R_BAD_FOPEN_MODE);
368             ret = 0;
369             break;
370         }
371 #  if defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32_CYGWIN)
372         if (!(num & BIO_FP_TEXT))
373             strcat(p, "b");
374         else
375             strcat(p, "t");
376 #  endif
377         fp = file_fopen(ptr, p);
378         if (fp == NULL) {
379             SYSerr(SYS_F_FOPEN, get_last_sys_error());
380             ERR_add_error_data(5, "fopen('", ptr, "','", p, "')");
381             BIOerr(BIO_F_FILE_CTRL, ERR_R_SYS_LIB);
382             ret = 0;
383             break;
384         }
385         b->ptr = fp;
386         b->init = 1;
387         BIO_clear_flags(b, BIO_FLAGS_UPLINK); /* we did fopen -> we disengage
388                                                * UPLINK */
389         break;
390     case BIO_C_GET_FILE_PTR:
391         /* the ptr parameter is actually a FILE ** in this case. */
392         if (ptr != NULL) {
393             fpp = (FILE **)ptr;
394             *fpp = (FILE *)b->ptr;
395         }
396         break;
397     case BIO_CTRL_GET_CLOSE:
398         ret = (long)b->shutdown;
399         break;
400     case BIO_CTRL_SET_CLOSE:
401         b->shutdown = (int)num;
402         break;
403     case BIO_CTRL_FLUSH:
404         if (b->flags & BIO_FLAGS_UPLINK)
405             UP_fflush(b->ptr);
406         else
407             fflush((FILE *)b->ptr);
408         break;
409     case BIO_CTRL_DUP:
410         ret = 1;
411         break;
412
413     case BIO_CTRL_WPENDING:
414     case BIO_CTRL_PENDING:
415     case BIO_CTRL_PUSH:
416     case BIO_CTRL_POP:
417     default:
418         ret = 0;
419         break;
420     }
421     return (ret);
422 }
423
424 static int file_gets(BIO *bp, char *buf, int size)
425 {
426     int ret = 0;
427
428     buf[0] = '\0';
429     if (bp->flags & BIO_FLAGS_UPLINK) {
430         if (!UP_fgets(buf, size, bp->ptr))
431             goto err;
432     } else {
433         if (!fgets(buf, size, (FILE *)bp->ptr))
434             goto err;
435     }
436     if (buf[0] != '\0')
437         ret = strlen(buf);
438  err:
439     return (ret);
440 }
441
442 static int file_puts(BIO *bp, const char *str)
443 {
444     int n, ret;
445
446     n = strlen(str);
447     ret = file_write(bp, str, n);
448     return (ret);
449 }
450
451 #else
452
453 static int file_write(BIO *b, const char *in, int inl)
454 {
455     return -1;
456 }
457 static int file_read(BIO *b, char *out, int outl)
458 {
459     return -1;
460 }
461 static int file_puts(BIO *bp, const char *str)
462 {
463     return -1;
464 }
465 static int file_gets(BIO *bp, char *buf, int size)
466 {
467     return 0;
468 }
469 static long file_ctrl(BIO *b, int cmd, long num, void *ptr)
470 {
471     return 0;
472 }
473 static int file_new(BIO *bi)
474 {
475     return 0;
476 }
477 static int file_free(BIO *a)
478 {
479     return 0;
480 }
481
482 static const BIO_METHOD methods_filep = {
483     BIO_TYPE_FILE,
484     "FILE pointer",
485     file_write,
486     file_read,
487     file_puts,
488     file_gets,
489     file_ctrl,
490     file_new,
491     file_free,
492     NULL,
493 };
494
495 const BIO_METHOD *BIO_s_file(void)
496 {
497     return (&methods_filep);
498 }
499
500 BIO *BIO_new_file(const char *filename, const char *mode)
501 {
502     return NULL;
503 }
504
505 # endif                         /* OPENSSL_NO_STDIO */
506
507 #endif                          /* HEADER_BSS_FILE_C */