1 /* 2 * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the OpenSSL license (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 #if defined(__linux) || defined(__sun) || defined(__hpux) 11 /* 12 * Following definition aliases fopen to fopen64 on above mentioned 13 * platforms. This makes it possible to open and sequentially access files 14 * larger than 2GB from 32-bit application. It does not allow to traverse 15 * them beyond 2GB with fseek/ftell, but on the other hand *no* 32-bit 16 * platform permits that, not with fseek/ftell. Not to mention that breaking 17 * 2GB limit for seeking would require surgery to *our* API. But sequential 18 * access suffices for practical cases when you can run into large files, 19 * such as fingerprinting, so we can let API alone. For reference, the list 20 * of 32-bit platforms which allow for sequential access of large files 21 * without extra "magic" comprise *BSD, Darwin, IRIX... 22 */ 23 # ifndef _FILE_OFFSET_BITS 24 # define _FILE_OFFSET_BITS 64 25 # endif 26 #endif 27 28 #include <stdio.h> 29 #include <errno.h> 30 #include "bio_local.h" 31 #include <openssl/err.h> 32 33 #if !defined(OPENSSL_NO_STDIO) 34 35 static int file_write(BIO *h, const char *buf, int num); 36 static int file_read(BIO *h, char *buf, int size); 37 static int file_puts(BIO *h, const char *str); 38 static int file_gets(BIO *h, char *str, int size); 39 static long file_ctrl(BIO *h, int cmd, long arg1, void *arg2); 40 static int file_new(BIO *h); 41 static int file_free(BIO *data); 42 static const BIO_METHOD methods_filep = { 43 BIO_TYPE_FILE, 44 "FILE pointer", 45 /* TODO: Convert to new style write function */ 46 bwrite_conv, 47 file_write, 48 /* TODO: Convert to new style read function */ 49 bread_conv, 50 file_read, 51 file_puts, 52 file_gets, 53 file_ctrl, 54 file_new, 55 file_free, 56 NULL, /* file_callback_ctrl */ 57 }; 58 59 BIO *BIO_new_file(const char *filename, const char *mode) 60 { 61 BIO *ret; 62 FILE *file = openssl_fopen(filename, mode); 63 int fp_flags = BIO_CLOSE; 64 65 if (strchr(mode, 'b') == NULL) 66 fp_flags |= BIO_FP_TEXT; 67 68 if (file == NULL) { 69 SYSerr(SYS_F_FOPEN, get_last_sys_error()); 70 ERR_add_error_data(5, "fopen('", filename, "','", mode, "')"); 71 if (errno == ENOENT 72 #ifdef ENXIO 73 || errno == ENXIO 74 #endif 75 ) 76 BIOerr(BIO_F_BIO_NEW_FILE, BIO_R_NO_SUCH_FILE); 77 else 78 BIOerr(BIO_F_BIO_NEW_FILE, ERR_R_SYS_LIB); 79 return NULL; 80 } 81 if ((ret = BIO_new(BIO_s_file())) == NULL) { 82 fclose(file); 83 return NULL; 84 } 85 86 BIO_clear_flags(ret, BIO_FLAGS_UPLINK); /* we did fopen -> we disengage 87 * UPLINK */ 88 BIO_set_fp(ret, file, fp_flags); 89 return ret; 90 } 91 92 BIO *BIO_new_fp(FILE *stream, int close_flag) 93 { 94 BIO *ret; 95 96 if ((ret = BIO_new(BIO_s_file())) == NULL) 97 return NULL; 98 99 /* redundant flag, left for documentation purposes */ 100 BIO_set_flags(ret, BIO_FLAGS_UPLINK); 101 BIO_set_fp(ret, stream, close_flag); 102 return ret; 103 } 104 105 const BIO_METHOD *BIO_s_file(void) 106 { 107 return &methods_filep; 108 } 109 110 static int file_new(BIO *bi) 111 { 112 bi->init = 0; 113 bi->num = 0; 114 bi->ptr = NULL; 115 bi->flags = BIO_FLAGS_UPLINK; /* default to UPLINK */ 116 return 1; 117 } 118 119 static int file_free(BIO *a) 120 { 121 if (a == NULL) 122 return 0; 123 if (a->shutdown) { 124 if ((a->init) && (a->ptr != NULL)) { 125 if (a->flags & BIO_FLAGS_UPLINK) 126 UP_fclose(a->ptr); 127 else 128 fclose(a->ptr); 129 a->ptr = NULL; 130 a->flags = BIO_FLAGS_UPLINK; 131 } 132 a->init = 0; 133 } 134 return 1; 135 } 136 137 static int file_read(BIO *b, char *out, int outl) 138 { 139 int ret = 0; 140 141 if (b->init && (out != NULL)) { 142 if (b->flags & BIO_FLAGS_UPLINK) 143 ret = UP_fread(out, 1, (int)outl, b->ptr); 144 else 145 ret = fread(out, 1, (int)outl, (FILE *)b->ptr); 146 if (ret == 0 147 && (b->flags & BIO_FLAGS_UPLINK) ? UP_ferror((FILE *)b->ptr) : 148 ferror((FILE *)b->ptr)) { 149 SYSerr(SYS_F_FREAD, get_last_sys_error()); 150 BIOerr(BIO_F_FILE_READ, ERR_R_SYS_LIB); 151 ret = -1; 152 } 153 } 154 return ret; 155 } 156 157 static int file_write(BIO *b, const char *in, int inl) 158 { 159 int ret = 0; 160 161 if (b->init && (in != NULL)) { 162 if (b->flags & BIO_FLAGS_UPLINK) 163 ret = UP_fwrite(in, (int)inl, 1, b->ptr); 164 else 165 ret = fwrite(in, (int)inl, 1, (FILE *)b->ptr); 166 if (ret) 167 ret = inl; 168 /* ret=fwrite(in,1,(int)inl,(FILE *)b->ptr); */ 169 /* 170 * according to Tim Hudson <tjh@openssl.org>, the commented out 171 * version above can cause 'inl' write calls under some stupid stdio 172 * implementations (VMS) 173 */ 174 } 175 return ret; 176 } 177 178 static long file_ctrl(BIO *b, int cmd, long num, void *ptr) 179 { 180 long ret = 1; 181 FILE *fp = (FILE *)b->ptr; 182 FILE **fpp; 183 char p[4]; 184 int st; 185 186 switch (cmd) { 187 case BIO_C_FILE_SEEK: 188 case BIO_CTRL_RESET: 189 if (b->flags & BIO_FLAGS_UPLINK) 190 ret = (long)UP_fseek(b->ptr, num, 0); 191 else 192 ret = (long)fseek(fp, num, 0); 193 break; 194 case BIO_CTRL_EOF: 195 if (b->flags & BIO_FLAGS_UPLINK) 196 ret = (long)UP_feof(fp); 197 else 198 ret = (long)feof(fp); 199 break; 200 case BIO_C_FILE_TELL: 201 case BIO_CTRL_INFO: 202 if (b->flags & BIO_FLAGS_UPLINK) 203 ret = UP_ftell(b->ptr); 204 else 205 ret = ftell(fp); 206 break; 207 case BIO_C_SET_FILE_PTR: 208 file_free(b); 209 b->shutdown = (int)num & BIO_CLOSE; 210 b->ptr = ptr; 211 b->init = 1; 212 # if BIO_FLAGS_UPLINK!=0 213 # if defined(__MINGW32__) && defined(__MSVCRT__) && !defined(_IOB_ENTRIES) 214 # define _IOB_ENTRIES 20 215 # endif 216 /* Safety net to catch purely internal BIO_set_fp calls */ 217 # if defined(_MSC_VER) && _MSC_VER>=1900 218 if (ptr == stdin || ptr == stdout || ptr == stderr) 219 BIO_clear_flags(b, BIO_FLAGS_UPLINK); 220 # elif defined(_IOB_ENTRIES) 221 if ((size_t)ptr >= (size_t)stdin && 222 (size_t)ptr < (size_t)(stdin + _IOB_ENTRIES)) 223 BIO_clear_flags(b, BIO_FLAGS_UPLINK); 224 # endif 225 # endif 226 # ifdef UP_fsetmod 227 if (b->flags & BIO_FLAGS_UPLINK) 228 UP_fsetmod(b->ptr, (char)((num & BIO_FP_TEXT) ? 't' : 'b')); 229 else 230 # endif 231 { 232 # if defined(OPENSSL_SYS_WINDOWS) 233 int fd = _fileno((FILE *)ptr); 234 if (num & BIO_FP_TEXT) 235 _setmode(fd, _O_TEXT); 236 else 237 _setmode(fd, _O_BINARY); 238 # elif defined(OPENSSL_SYS_MSDOS) 239 int fd = fileno((FILE *)ptr); 240 /* Set correct text/binary mode */ 241 if (num & BIO_FP_TEXT) 242 _setmode(fd, _O_TEXT); 243 /* Dangerous to set stdin/stdout to raw (unless redirected) */ 244 else { 245 if (fd == STDIN_FILENO || fd == STDOUT_FILENO) { 246 if (isatty(fd) <= 0) 247 _setmode(fd, _O_BINARY); 248 } else 249 _setmode(fd, _O_BINARY); 250 } 251 # elif defined(OPENSSL_SYS_WIN32_CYGWIN) 252 int fd = fileno((FILE *)ptr); 253 if (!(num & BIO_FP_TEXT)) 254 setmode(fd, O_BINARY); 255 # endif 256 } 257 break; 258 case BIO_C_SET_FILENAME: 259 file_free(b); 260 b->shutdown = (int)num & BIO_CLOSE; 261 if (num & BIO_FP_APPEND) { 262 if (num & BIO_FP_READ) 263 OPENSSL_strlcpy(p, "a+", sizeof(p)); 264 else 265 OPENSSL_strlcpy(p, "a", sizeof(p)); 266 } else if ((num & BIO_FP_READ) && (num & BIO_FP_WRITE)) 267 OPENSSL_strlcpy(p, "r+", sizeof(p)); 268 else if (num & BIO_FP_WRITE) 269 OPENSSL_strlcpy(p, "w", sizeof(p)); 270 else if (num & BIO_FP_READ) 271 OPENSSL_strlcpy(p, "r", sizeof(p)); 272 else { 273 BIOerr(BIO_F_FILE_CTRL, BIO_R_BAD_FOPEN_MODE); 274 ret = 0; 275 break; 276 } 277 # if defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_WINDOWS) 278 if (!(num & BIO_FP_TEXT)) 279 OPENSSL_strlcat(p, "b", sizeof(p)); 280 else 281 OPENSSL_strlcat(p, "t", sizeof(p)); 282 # elif defined(OPENSSL_SYS_WIN32_CYGWIN) 283 if (!(num & BIO_FP_TEXT)) 284 OPENSSL_strlcat(p, "b", sizeof(p)); 285 # endif 286 fp = openssl_fopen(ptr, p); 287 if (fp == NULL) { 288 SYSerr(SYS_F_FOPEN, get_last_sys_error()); 289 ERR_add_error_data(5, "fopen('", ptr, "','", p, "')"); 290 BIOerr(BIO_F_FILE_CTRL, ERR_R_SYS_LIB); 291 ret = 0; 292 break; 293 } 294 b->ptr = fp; 295 b->init = 1; 296 BIO_clear_flags(b, BIO_FLAGS_UPLINK); /* we did fopen -> we disengage 297 * UPLINK */ 298 break; 299 case BIO_C_GET_FILE_PTR: 300 /* the ptr parameter is actually a FILE ** in this case. */ 301 if (ptr != NULL) { 302 fpp = (FILE **)ptr; 303 *fpp = (FILE *)b->ptr; 304 } 305 break; 306 case BIO_CTRL_GET_CLOSE: 307 ret = (long)b->shutdown; 308 break; 309 case BIO_CTRL_SET_CLOSE: 310 b->shutdown = (int)num; 311 break; 312 case BIO_CTRL_FLUSH: 313 st = b->flags & BIO_FLAGS_UPLINK 314 ? UP_fflush(b->ptr) : fflush((FILE *)b->ptr); 315 if (st == EOF) { 316 SYSerr(SYS_F_FFLUSH, get_last_sys_error()); 317 ERR_add_error_data(1, "fflush()"); 318 BIOerr(BIO_F_FILE_CTRL, ERR_R_SYS_LIB); 319 ret = 0; 320 } 321 break; 322 case BIO_CTRL_DUP: 323 ret = 1; 324 break; 325 326 case BIO_CTRL_WPENDING: 327 case BIO_CTRL_PENDING: 328 case BIO_CTRL_PUSH: 329 case BIO_CTRL_POP: 330 default: 331 ret = 0; 332 break; 333 } 334 return ret; 335 } 336 337 static int file_gets(BIO *bp, char *buf, int size) 338 { 339 int ret = 0; 340 341 buf[0] = '\0'; 342 if (bp->flags & BIO_FLAGS_UPLINK) { 343 if (!UP_fgets(buf, size, bp->ptr)) 344 goto err; 345 } else { 346 if (!fgets(buf, size, (FILE *)bp->ptr)) 347 goto err; 348 } 349 if (buf[0] != '\0') 350 ret = strlen(buf); 351 err: 352 return ret; 353 } 354 355 static int file_puts(BIO *bp, const char *str) 356 { 357 int n, ret; 358 359 n = strlen(str); 360 ret = file_write(bp, str, n); 361 return ret; 362 } 363 364 #else 365 366 static int file_write(BIO *b, const char *in, int inl) 367 { 368 return -1; 369 } 370 static int file_read(BIO *b, char *out, int outl) 371 { 372 return -1; 373 } 374 static int file_puts(BIO *bp, const char *str) 375 { 376 return -1; 377 } 378 static int file_gets(BIO *bp, char *buf, int size) 379 { 380 return 0; 381 } 382 static long file_ctrl(BIO *b, int cmd, long num, void *ptr) 383 { 384 return 0; 385 } 386 static int file_new(BIO *bi) 387 { 388 return 0; 389 } 390 static int file_free(BIO *a) 391 { 392 return 0; 393 } 394 395 static const BIO_METHOD methods_filep = { 396 BIO_TYPE_FILE, 397 "FILE pointer", 398 /* TODO: Convert to new style write function */ 399 bwrite_conv, 400 file_write, 401 /* TODO: Convert to new style read function */ 402 bread_conv, 403 file_read, 404 file_puts, 405 file_gets, 406 file_ctrl, 407 file_new, 408 file_free, 409 NULL, /* file_callback_ctrl */ 410 }; 411 412 const BIO_METHOD *BIO_s_file(void) 413 { 414 return &methods_filep; 415 } 416 417 BIO *BIO_new_file(const char *filename, const char *mode) 418 { 419 return NULL; 420 } 421 422 #endif /* OPENSSL_NO_STDIO */ 423