1 /* Copyright (C) 1995-1998 Eric Young (eay (at) cryptsoft.com) 2 * All rights reserved. 3 * 4 * This package is an SSL implementation written 5 * by Eric Young (eay (at) 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 (at) 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 (at) 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 (at) 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 #if defined(__linux) || defined(__sun) || defined(__hpux) 58 // Following definition aliases fopen to fopen64 on above mentioned 59 // platforms. This makes it possible to open and sequentially access 60 // files larger than 2GB from 32-bit application. It does not allow to 61 // traverse them beyond 2GB with fseek/ftell, but on the other hand *no* 62 // 32-bit platform permits that, not with fseek/ftell. Not to mention 63 // that breaking 2GB limit for seeking would require surgery to *our* 64 // API. But sequential access suffices for practical cases when you 65 // can run into large files, such as fingerprinting, so we can let API 66 // alone. For reference, the list of 32-bit platforms which allow for 67 // sequential access of large files without extra "magic" comprise *BSD, 68 // Darwin, IRIX... 69 #ifndef _FILE_OFFSET_BITS 70 #define _FILE_OFFSET_BITS 64 71 #endif 72 #endif 73 74 #include <openssl/bio.h> 75 76 #include <errno.h> 77 #include <stdio.h> 78 #include <string.h> 79 80 #include <openssl/buf.h> 81 #include <openssl/err.h> 82 #include <openssl/mem.h> 83 84 #include "../internal.h" 85 86 87 #define BIO_FP_READ 0x02 88 #define BIO_FP_WRITE 0x04 89 #define BIO_FP_APPEND 0x08 90 91 BIO *BIO_new_file(const char *filename, const char *mode) { 92 BIO *ret; 93 FILE *file; 94 95 file = fopen(filename, mode); 96 if (file == NULL) { 97 OPENSSL_PUT_SYSTEM_ERROR(); 98 99 ERR_add_error_data(5, "fopen('", filename, "','", mode, "')"); 100 if (errno == ENOENT) { 101 OPENSSL_PUT_ERROR(BIO, BIO_R_NO_SUCH_FILE); 102 } else { 103 OPENSSL_PUT_ERROR(BIO, BIO_R_SYS_LIB); 104 } 105 return NULL; 106 } 107 108 ret = BIO_new(BIO_s_file()); 109 if (ret == NULL) { 110 fclose(file); 111 return NULL; 112 } 113 114 BIO_set_fp(ret, file, BIO_CLOSE); 115 return ret; 116 } 117 118 BIO *BIO_new_fp(FILE *stream, int close_flag) { 119 BIO *ret = BIO_new(BIO_s_file()); 120 121 if (ret == NULL) { 122 return NULL; 123 } 124 125 BIO_set_fp(ret, stream, close_flag); 126 return ret; 127 } 128 129 static int file_new(BIO *bio) { return 1; } 130 131 static int file_free(BIO *bio) { 132 if (bio == NULL) { 133 return 0; 134 } 135 136 if (!bio->shutdown) { 137 return 1; 138 } 139 140 if (bio->init && bio->ptr != NULL) { 141 fclose(bio->ptr); 142 bio->ptr = NULL; 143 } 144 bio->init = 0; 145 146 return 1; 147 } 148 149 static int file_read(BIO *b, char *out, int outl) { 150 if (!b->init) { 151 return 0; 152 } 153 154 size_t ret = fread(out, 1, outl, (FILE *)b->ptr); 155 if (ret == 0 && ferror((FILE *)b->ptr)) { 156 OPENSSL_PUT_SYSTEM_ERROR(); 157 OPENSSL_PUT_ERROR(BIO, ERR_R_SYS_LIB); 158 return -1; 159 } 160 161 // fread reads at most |outl| bytes, so |ret| fits in an int. 162 return (int)ret; 163 } 164 165 static int file_write(BIO *b, const char *in, int inl) { 166 int ret = 0; 167 168 if (!b->init) { 169 return 0; 170 } 171 172 ret = fwrite(in, inl, 1, (FILE *)b->ptr); 173 if (ret > 0) { 174 ret = inl; 175 } 176 return ret; 177 } 178 179 static long file_ctrl(BIO *b, int cmd, long num, void *ptr) { 180 long ret = 1; 181 FILE *fp = (FILE *)b->ptr; 182 FILE **fpp; 183 char p[4]; 184 185 switch (cmd) { 186 case BIO_CTRL_RESET: 187 num = 0; 188 OPENSSL_FALLTHROUGH; 189 case BIO_C_FILE_SEEK: 190 ret = (long)fseek(fp, num, 0); 191 break; 192 case BIO_CTRL_EOF: 193 ret = (long)feof(fp); 194 break; 195 case BIO_C_FILE_TELL: 196 case BIO_CTRL_INFO: 197 ret = ftell(fp); 198 break; 199 case BIO_C_SET_FILE_PTR: 200 file_free(b); 201 b->shutdown = (int)num & BIO_CLOSE; 202 b->ptr = ptr; 203 b->init = 1; 204 break; 205 case BIO_C_SET_FILENAME: 206 file_free(b); 207 b->shutdown = (int)num & BIO_CLOSE; 208 if (num & BIO_FP_APPEND) { 209 if (num & BIO_FP_READ) { 210 BUF_strlcpy(p, "a+", sizeof(p)); 211 } else { 212 BUF_strlcpy(p, "a", sizeof(p)); 213 } 214 } else if ((num & BIO_FP_READ) && (num & BIO_FP_WRITE)) { 215 BUF_strlcpy(p, "r+", sizeof(p)); 216 } else if (num & BIO_FP_WRITE) { 217 BUF_strlcpy(p, "w", sizeof(p)); 218 } else if (num & BIO_FP_READ) { 219 BUF_strlcpy(p, "r", sizeof(p)); 220 } else { 221 OPENSSL_PUT_ERROR(BIO, BIO_R_BAD_FOPEN_MODE); 222 ret = 0; 223 break; 224 } 225 fp = fopen(ptr, p); 226 if (fp == NULL) { 227 OPENSSL_PUT_SYSTEM_ERROR(); 228 ERR_add_error_data(5, "fopen('", ptr, "','", p, "')"); 229 OPENSSL_PUT_ERROR(BIO, ERR_R_SYS_LIB); 230 ret = 0; 231 break; 232 } 233 b->ptr = fp; 234 b->init = 1; 235 break; 236 case BIO_C_GET_FILE_PTR: 237 // the ptr parameter is actually a FILE ** in this case. 238 if (ptr != NULL) { 239 fpp = (FILE **)ptr; 240 *fpp = (FILE *)b->ptr; 241 } 242 break; 243 case BIO_CTRL_GET_CLOSE: 244 ret = (long)b->shutdown; 245 break; 246 case BIO_CTRL_SET_CLOSE: 247 b->shutdown = (int)num; 248 break; 249 case BIO_CTRL_FLUSH: 250 ret = 0 == fflush((FILE *)b->ptr); 251 break; 252 case BIO_CTRL_WPENDING: 253 case BIO_CTRL_PENDING: 254 default: 255 ret = 0; 256 break; 257 } 258 return ret; 259 } 260 261 static int file_gets(BIO *bp, char *buf, int size) { 262 int ret = 0; 263 264 if (size == 0) { 265 return 0; 266 } 267 268 if (!fgets(buf, size, (FILE *)bp->ptr)) { 269 buf[0] = 0; 270 goto err; 271 } 272 ret = strlen(buf); 273 274 err: 275 return ret; 276 } 277 278 static const BIO_METHOD methods_filep = { 279 BIO_TYPE_FILE, "FILE pointer", 280 file_write, file_read, 281 NULL /* puts */, file_gets, 282 file_ctrl, file_new, 283 file_free, NULL /* callback_ctrl */, 284 }; 285 286 const BIO_METHOD *BIO_s_file(void) { return &methods_filep; } 287 288 289 int BIO_get_fp(BIO *bio, FILE **out_file) { 290 return BIO_ctrl(bio, BIO_C_GET_FILE_PTR, 0, (char*) out_file); 291 } 292 293 int BIO_set_fp(BIO *bio, FILE *file, int close_flag) { 294 return BIO_ctrl(bio, BIO_C_SET_FILE_PTR, close_flag, (char *) file); 295 } 296 297 int BIO_read_filename(BIO *bio, const char *filename) { 298 return BIO_ctrl(bio, BIO_C_SET_FILENAME, BIO_CLOSE | BIO_FP_READ, 299 (char *)filename); 300 } 301 302 int BIO_write_filename(BIO *bio, const char *filename) { 303 return BIO_ctrl(bio, BIO_C_SET_FILENAME, BIO_CLOSE | BIO_FP_WRITE, 304 (char *)filename); 305 } 306 307 int BIO_append_filename(BIO *bio, const char *filename) { 308 return BIO_ctrl(bio, BIO_C_SET_FILENAME, BIO_CLOSE | BIO_FP_APPEND, 309 (char *)filename); 310 } 311 312 int BIO_rw_filename(BIO *bio, const char *filename) { 313 return BIO_ctrl(bio, BIO_C_SET_FILENAME, 314 BIO_CLOSE | BIO_FP_READ | BIO_FP_WRITE, (char *)filename); 315 } 316
