1 /* Low-level I/O routines for BFDs. 2 3 Copyright (C) 1990-2020 Free Software Foundation, Inc. 4 5 Written by Cygnus Support. 6 7 This file is part of BFD, the Binary File Descriptor library. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 22 MA 02110-1301, USA. */ 23 24 #include "sysdep.h" 25 #include <limits.h> 26 #include "bfd.h" 27 #include "libbfd.h" 28 #include "aout/ar.h" 29 #if defined (_WIN32) 30 #include <windows.h> 31 #endif 32 33 #ifndef S_IXUSR 34 #define S_IXUSR 0100 /* Execute by owner. */ 35 #endif 36 #ifndef S_IXGRP 37 #define S_IXGRP 0010 /* Execute by group. */ 38 #endif 39 #ifndef S_IXOTH 40 #define S_IXOTH 0001 /* Execute by others. */ 41 #endif 42 43 #ifndef FD_CLOEXEC 44 #define FD_CLOEXEC 1 45 #endif 46 47 file_ptr 48 _bfd_real_ftell (FILE *file) 49 { 50 #if defined (HAVE_FTELLO64) 51 return ftello64 (file); 52 #elif defined (HAVE_FTELLO) 53 return ftello (file); 54 #else 55 return ftell (file); 56 #endif 57 } 58 59 int 60 _bfd_real_fseek (FILE *file, file_ptr offset, int whence) 61 { 62 #if defined (HAVE_FSEEKO64) 63 return fseeko64 (file, offset, whence); 64 #elif defined (HAVE_FSEEKO) 65 return fseeko (file, offset, whence); 66 #else 67 return fseek (file, offset, whence); 68 #endif 69 } 70 71 /* Mark FILE as close-on-exec. Return FILE. FILE may be NULL, in 72 which case nothing is done. */ 73 static FILE * 74 close_on_exec (FILE *file) 75 { 76 #if defined (HAVE_FILENO) && defined (F_GETFD) 77 if (file) 78 { 79 int fd = fileno (file); 80 int old = fcntl (fd, F_GETFD, 0); 81 if (old >= 0) 82 fcntl (fd, F_SETFD, old | FD_CLOEXEC); 83 } 84 #endif 85 return file; 86 } 87 88 FILE * 89 _bfd_real_fopen (const char *filename, const char *modes) 90 { 91 #ifdef VMS 92 char *vms_attr; 93 94 /* On VMS, fopen allows file attributes as optional arguments. 95 We need to use them but we'd better to use the common prototype. 96 In fopen-vms.h, they are separated from the mode with a comma. 97 Split here. */ 98 vms_attr = strchr (modes, ','); 99 if (vms_attr != NULL) 100 { 101 /* Attributes found. Split. */ 102 size_t modes_len = strlen (modes) + 1; 103 char attrs[modes_len + 1]; 104 char *at[3]; 105 int i; 106 107 memcpy (attrs, modes, modes_len); 108 at[0] = attrs; 109 for (i = 0; i < 2; i++) 110 { 111 at[i + 1] = strchr (at[i], ','); 112 BFD_ASSERT (at[i + 1] != NULL); 113 *(at[i + 1]++) = 0; /* Replace ',' with a nul, and skip it. */ 114 } 115 return close_on_exec (fopen (filename, at[0], at[1], at[2])); 116 } 117 118 #elif defined (_WIN32) 119 size_t filelen = strlen (filename) + 1; 120 121 if (filelen > MAX_PATH - 1) 122 { 123 FILE * file; 124 char * fullpath = (char *) malloc (filelen + 8); 125 int i; 126 127 /* Add a Microsoft recommended prefix that 128 will allow the extra-long path to work. */ 129 strcpy (fullpath, "\\\\?\\"); 130 strcat (fullpath, filename); 131 132 /* Convert any UNIX style path separators into the DOS form. */ 133 for (i = 0; fullpath[i]; i++) 134 { 135 if (IS_UNIX_DIR_SEPARATOR (fullpath[i])) 136 fullpath[i] = '\\'; 137 } 138 139 file = close_on_exec (fopen (fullpath, modes)); 140 free (fullpath); 141 return file; 142 } 143 144 #elif defined (HAVE_FOPEN64) 145 return close_on_exec (fopen64 (filename, modes)); 146 #endif 147 148 return close_on_exec (fopen (filename, modes)); 149 } 150 151 /* 152 INTERNAL_DEFINITION 153 struct bfd_iovec 154 155 DESCRIPTION 156 157 The <<struct bfd_iovec>> contains the internal file I/O class. 158 Each <<BFD>> has an instance of this class and all file I/O is 159 routed through it (it is assumed that the instance implements 160 all methods listed below). 161 162 .struct bfd_iovec 163 .{ 164 . {* To avoid problems with macros, a "b" rather than "f" 165 . prefix is prepended to each method name. *} 166 . {* Attempt to read/write NBYTES on ABFD's IOSTREAM storing/fetching 167 . bytes starting at PTR. Return the number of bytes actually 168 . transfered (a read past end-of-file returns less than NBYTES), 169 . or -1 (setting <<bfd_error>>) if an error occurs. *} 170 . file_ptr (*bread) (struct bfd *abfd, void *ptr, file_ptr nbytes); 171 . file_ptr (*bwrite) (struct bfd *abfd, const void *ptr, 172 . file_ptr nbytes); 173 . {* Return the current IOSTREAM file offset, or -1 (setting <<bfd_error>> 174 . if an error occurs. *} 175 . file_ptr (*btell) (struct bfd *abfd); 176 . {* For the following, on successful completion a value of 0 is returned. 177 . Otherwise, a value of -1 is returned (and <<bfd_error>> is set). *} 178 . int (*bseek) (struct bfd *abfd, file_ptr offset, int whence); 179 . int (*bclose) (struct bfd *abfd); 180 . int (*bflush) (struct bfd *abfd); 181 . int (*bstat) (struct bfd *abfd, struct stat *sb); 182 . {* Mmap a part of the files. ADDR, LEN, PROT, FLAGS and OFFSET are the usual 183 . mmap parameter, except that LEN and OFFSET do not need to be page 184 . aligned. Returns (void *)-1 on failure, mmapped address on success. 185 . Also write in MAP_ADDR the address of the page aligned buffer and in 186 . MAP_LEN the size mapped (a page multiple). Use unmap with MAP_ADDR and 187 . MAP_LEN to unmap. *} 188 . void *(*bmmap) (struct bfd *abfd, void *addr, bfd_size_type len, 189 . int prot, int flags, file_ptr offset, 190 . void **map_addr, bfd_size_type *map_len); 191 .}; 192 193 .extern const struct bfd_iovec _bfd_memory_iovec; 194 195 */ 196 197 198 /* Return value is amount read. */ 199 200 bfd_size_type 201 bfd_bread (void *ptr, bfd_size_type size, bfd *abfd) 202 { 203 file_ptr nread; 204 bfd *element_bfd = abfd; 205 ufile_ptr offset = 0; 206 207 while (abfd->my_archive != NULL 208 && !bfd_is_thin_archive (abfd->my_archive)) 209 { 210 offset += abfd->origin; 211 abfd = abfd->my_archive; 212 } 213 offset += abfd->origin; 214 215 /* If this is an archive element, don't read past the end of 216 this element. */ 217 if (element_bfd->arelt_data != NULL) 218 { 219 bfd_size_type maxbytes = arelt_size (element_bfd); 220 221 if (abfd->where < offset || abfd->where - offset >= maxbytes) 222 { 223 bfd_set_error (bfd_error_invalid_operation); 224 return -1; 225 } 226 if (abfd->where - offset + size > maxbytes) 227 size = maxbytes - (abfd->where - offset); 228 } 229 230 if (abfd->iovec == NULL) 231 { 232 bfd_set_error (bfd_error_invalid_operation); 233 return -1; 234 } 235 236 nread = abfd->iovec->bread (abfd, ptr, size); 237 if (nread != -1) 238 abfd->where += nread; 239 240 return nread; 241 } 242 243 bfd_size_type 244 bfd_bwrite (const void *ptr, bfd_size_type size, bfd *abfd) 245 { 246 file_ptr nwrote; 247 248 while (abfd->my_archive != NULL 249 && !bfd_is_thin_archive (abfd->my_archive)) 250 abfd = abfd->my_archive; 251 252 if (abfd->iovec == NULL) 253 { 254 bfd_set_error (bfd_error_invalid_operation); 255 return -1; 256 } 257 258 nwrote = abfd->iovec->bwrite (abfd, ptr, size); 259 if (nwrote != -1) 260 abfd->where += nwrote; 261 if ((bfd_size_type) nwrote != size) 262 { 263 #ifdef ENOSPC 264 errno = ENOSPC; 265 #endif 266 bfd_set_error (bfd_error_system_call); 267 } 268 return nwrote; 269 } 270 271 file_ptr 272 bfd_tell (bfd *abfd) 273 { 274 ufile_ptr offset = 0; 275 file_ptr ptr; 276 277 while (abfd->my_archive != NULL 278 && !bfd_is_thin_archive (abfd->my_archive)) 279 { 280 offset += abfd->origin; 281 abfd = abfd->my_archive; 282 } 283 offset += abfd->origin; 284 285 if (abfd->iovec == NULL) 286 return 0; 287 288 ptr = abfd->iovec->btell (abfd); 289 abfd->where = ptr; 290 return ptr - offset; 291 } 292 293 int 294 bfd_flush (bfd *abfd) 295 { 296 while (abfd->my_archive != NULL 297 && !bfd_is_thin_archive (abfd->my_archive)) 298 abfd = abfd->my_archive; 299 300 if (abfd->iovec == NULL) 301 return 0; 302 303 return abfd->iovec->bflush (abfd); 304 } 305 306 /* Returns 0 for success, negative value for failure (in which case 307 bfd_get_error can retrieve the error code). */ 308 int 309 bfd_stat (bfd *abfd, struct stat *statbuf) 310 { 311 int result; 312 313 while (abfd->my_archive != NULL 314 && !bfd_is_thin_archive (abfd->my_archive)) 315 abfd = abfd->my_archive; 316 317 if (abfd->iovec == NULL) 318 { 319 bfd_set_error (bfd_error_invalid_operation); 320 return -1; 321 } 322 323 result = abfd->iovec->bstat (abfd, statbuf); 324 if (result < 0) 325 bfd_set_error (bfd_error_system_call); 326 return result; 327 } 328 329 /* Returns 0 for success, nonzero for failure (in which case bfd_get_error 330 can retrieve the error code). */ 331 332 int 333 bfd_seek (bfd *abfd, file_ptr position, int direction) 334 { 335 int result; 336 ufile_ptr offset = 0; 337 338 while (abfd->my_archive != NULL 339 && !bfd_is_thin_archive (abfd->my_archive)) 340 { 341 offset += abfd->origin; 342 abfd = abfd->my_archive; 343 } 344 offset += abfd->origin; 345 346 if (abfd->iovec == NULL) 347 { 348 bfd_set_error (bfd_error_invalid_operation); 349 return -1; 350 } 351 352 /* For the time being, a BFD may not seek to it's end. The problem 353 is that we don't easily have a way to recognize the end of an 354 element in an archive. */ 355 BFD_ASSERT (direction == SEEK_SET || direction == SEEK_CUR); 356 357 if (direction != SEEK_CUR) 358 position += offset; 359 360 if ((direction == SEEK_CUR && position == 0) 361 || (direction == SEEK_SET && (ufile_ptr) position == abfd->where)) 362 return 0; 363 364 result = abfd->iovec->bseek (abfd, position, direction); 365 if (result != 0) 366 { 367 /* An EINVAL error probably means that the file offset was 368 absurd. */ 369 if (errno == EINVAL) 370 bfd_set_error (bfd_error_file_truncated); 371 else 372 bfd_set_error (bfd_error_system_call); 373 } 374 else 375 { 376 /* Adjust `where' field. */ 377 if (direction == SEEK_CUR) 378 abfd->where += position; 379 else 380 abfd->where = position; 381 } 382 383 return result; 384 } 385 386 /* 387 FUNCTION 388 bfd_get_mtime 389 390 SYNOPSIS 391 long bfd_get_mtime (bfd *abfd); 392 393 DESCRIPTION 394 Return the file modification time (as read from the file system, or 395 from the archive header for archive members). 396 397 */ 398 399 long 400 bfd_get_mtime (bfd *abfd) 401 { 402 struct stat buf; 403 404 if (abfd->mtime_set) 405 return abfd->mtime; 406 407 if (bfd_stat (abfd, &buf) != 0) 408 return 0; 409 410 abfd->mtime = buf.st_mtime; /* Save value in case anyone wants it */ 411 return buf.st_mtime; 412 } 413 414 /* 415 FUNCTION 416 bfd_get_size 417 418 SYNOPSIS 419 ufile_ptr bfd_get_size (bfd *abfd); 420 421 DESCRIPTION 422 Return the file size (as read from file system) for the file 423 associated with BFD @var{abfd}. 424 425 The initial motivation for, and use of, this routine is not 426 so we can get the exact size of the object the BFD applies to, since 427 that might not be generally possible (archive members for example). 428 It would be ideal if someone could eventually modify 429 it so that such results were guaranteed. 430 431 Instead, we want to ask questions like "is this NNN byte sized 432 object I'm about to try read from file offset YYY reasonable?" 433 As as example of where we might do this, some object formats 434 use string tables for which the first <<sizeof (long)>> bytes of the 435 table contain the size of the table itself, including the size bytes. 436 If an application tries to read what it thinks is one of these 437 string tables, without some way to validate the size, and for 438 some reason the size is wrong (byte swapping error, wrong location 439 for the string table, etc.), the only clue is likely to be a read 440 error when it tries to read the table, or a "virtual memory 441 exhausted" error when it tries to allocate 15 bazillon bytes 442 of space for the 15 bazillon byte table it is about to read. 443 This function at least allows us to answer the question, "is the 444 size reasonable?". 445 446 A return value of zero indicates the file size is unknown. 447 */ 448 449 ufile_ptr 450 bfd_get_size (bfd *abfd) 451 { 452 /* A size of 0 means we haven't yet called bfd_stat. A size of 1 453 means we have a cached value of 0, ie. unknown. */ 454 if (abfd->size <= 1 || bfd_write_p (abfd)) 455 { 456 struct stat buf; 457 458 if (abfd->size == 1 && !bfd_write_p (abfd)) 459 return 0; 460 461 if (bfd_stat (abfd, &buf) != 0 462 || buf.st_size == 0 463 || buf.st_size - (ufile_ptr) buf.st_size != 0) 464 { 465 abfd->size = 1; 466 return 0; 467 } 468 abfd->size = buf.st_size; 469 } 470 return abfd->size; 471 } 472 473 /* 474 FUNCTION 475 bfd_get_file_size 476 477 SYNOPSIS 478 ufile_ptr bfd_get_file_size (bfd *abfd); 479 480 DESCRIPTION 481 Return the file size (as read from file system) for the file 482 associated with BFD @var{abfd}. It supports both normal files 483 and archive elements. 484 485 */ 486 487 ufile_ptr 488 bfd_get_file_size (bfd *abfd) 489 { 490 ufile_ptr file_size, archive_size = (ufile_ptr) -1; 491 492 if (abfd->my_archive != NULL 493 && !bfd_is_thin_archive (abfd->my_archive)) 494 { 495 struct areltdata *adata = (struct areltdata *) abfd->arelt_data; 496 if (adata != NULL) 497 { 498 archive_size = adata->parsed_size; 499 /* If the archive is compressed we can't compare against 500 file size. */ 501 if (adata->arch_header != NULL 502 && memcmp (((struct ar_hdr *) adata->arch_header)->ar_fmag, 503 "Z\012", 2) == 0) 504 return archive_size; 505 abfd = abfd->my_archive; 506 } 507 } 508 509 file_size = bfd_get_size (abfd); 510 if (archive_size < file_size) 511 return archive_size; 512 return file_size; 513 } 514 515 /* 516 FUNCTION 517 bfd_mmap 518 519 SYNOPSIS 520 void *bfd_mmap (bfd *abfd, void *addr, bfd_size_type len, 521 int prot, int flags, file_ptr offset, 522 void **map_addr, bfd_size_type *map_len); 523 524 DESCRIPTION 525 Return mmap()ed region of the file, if possible and implemented. 526 LEN and OFFSET do not need to be page aligned. The page aligned 527 address and length are written to MAP_ADDR and MAP_LEN. 528 529 */ 530 531 void * 532 bfd_mmap (bfd *abfd, void *addr, bfd_size_type len, 533 int prot, int flags, file_ptr offset, 534 void **map_addr, bfd_size_type *map_len) 535 { 536 while (abfd->my_archive != NULL 537 && !bfd_is_thin_archive (abfd->my_archive)) 538 { 539 offset += abfd->origin; 540 abfd = abfd->my_archive; 541 } 542 offset += abfd->origin; 543 544 if (abfd->iovec == NULL) 545 { 546 bfd_set_error (bfd_error_invalid_operation); 547 return (void *) -1; 548 } 549 550 return abfd->iovec->bmmap (abfd, addr, len, prot, flags, offset, 551 map_addr, map_len); 552 } 553 554 /* Memory file I/O operations. */ 555 556 static file_ptr 557 memory_bread (bfd *abfd, void *ptr, file_ptr size) 558 { 559 struct bfd_in_memory *bim; 560 bfd_size_type get; 561 562 bim = (struct bfd_in_memory *) abfd->iostream; 563 get = size; 564 if (abfd->where + get > bim->size) 565 { 566 if (bim->size < (bfd_size_type) abfd->where) 567 get = 0; 568 else 569 get = bim->size - abfd->where; 570 bfd_set_error (bfd_error_file_truncated); 571 } 572 memcpy (ptr, bim->buffer + abfd->where, (size_t) get); 573 return get; 574 } 575 576 static file_ptr 577 memory_bwrite (bfd *abfd, const void *ptr, file_ptr size) 578 { 579 struct bfd_in_memory *bim = (struct bfd_in_memory *) abfd->iostream; 580 581 if (abfd->where + size > bim->size) 582 { 583 bfd_size_type newsize, oldsize; 584 585 oldsize = (bim->size + 127) & ~(bfd_size_type) 127; 586 bim->size = abfd->where + size; 587 /* Round up to cut down on memory fragmentation */ 588 newsize = (bim->size + 127) & ~(bfd_size_type) 127; 589 if (newsize > oldsize) 590 { 591 bim->buffer = (bfd_byte *) bfd_realloc_or_free (bim->buffer, newsize); 592 if (bim->buffer == NULL) 593 { 594 bim->size = 0; 595 return 0; 596 } 597 if (newsize > bim->size) 598 memset (bim->buffer + bim->size, 0, newsize - bim->size); 599 } 600 } 601 memcpy (bim->buffer + abfd->where, ptr, (size_t) size); 602 return size; 603 } 604 605 static file_ptr 606 memory_btell (bfd *abfd) 607 { 608 return abfd->where; 609 } 610 611 static int 612 memory_bseek (bfd *abfd, file_ptr position, int direction) 613 { 614 file_ptr nwhere; 615 struct bfd_in_memory *bim; 616 617 bim = (struct bfd_in_memory *) abfd->iostream; 618 619 if (direction == SEEK_SET) 620 nwhere = position; 621 else 622 nwhere = abfd->where + position; 623 624 if (nwhere < 0) 625 { 626 abfd->where = 0; 627 errno = EINVAL; 628 return -1; 629 } 630 631 if ((bfd_size_type)nwhere > bim->size) 632 { 633 if (abfd->direction == write_direction 634 || abfd->direction == both_direction) 635 { 636 bfd_size_type newsize, oldsize; 637 638 oldsize = (bim->size + 127) & ~(bfd_size_type) 127; 639 bim->size = nwhere; 640 /* Round up to cut down on memory fragmentation */ 641 newsize = (bim->size + 127) & ~(bfd_size_type) 127; 642 if (newsize > oldsize) 643 { 644 bim->buffer = (bfd_byte *) bfd_realloc_or_free (bim->buffer, newsize); 645 if (bim->buffer == NULL) 646 { 647 errno = EINVAL; 648 bim->size = 0; 649 return -1; 650 } 651 memset (bim->buffer + oldsize, 0, newsize - oldsize); 652 } 653 } 654 else 655 { 656 abfd->where = bim->size; 657 errno = EINVAL; 658 bfd_set_error (bfd_error_file_truncated); 659 return -1; 660 } 661 } 662 return 0; 663 } 664 665 static int 666 memory_bclose (struct bfd *abfd) 667 { 668 struct bfd_in_memory *bim = (struct bfd_in_memory *) abfd->iostream; 669 670 free (bim->buffer); 671 free (bim); 672 abfd->iostream = NULL; 673 674 return 0; 675 } 676 677 static int 678 memory_bflush (bfd *abfd ATTRIBUTE_UNUSED) 679 { 680 return 0; 681 } 682 683 static int 684 memory_bstat (bfd *abfd, struct stat *statbuf) 685 { 686 struct bfd_in_memory *bim = (struct bfd_in_memory *) abfd->iostream; 687 688 memset (statbuf, 0, sizeof (*statbuf)); 689 statbuf->st_size = bim->size; 690 691 return 0; 692 } 693 694 static void * 695 memory_bmmap (bfd *abfd ATTRIBUTE_UNUSED, void *addr ATTRIBUTE_UNUSED, 696 bfd_size_type len ATTRIBUTE_UNUSED, int prot ATTRIBUTE_UNUSED, 697 int flags ATTRIBUTE_UNUSED, file_ptr offset ATTRIBUTE_UNUSED, 698 void **map_addr ATTRIBUTE_UNUSED, 699 bfd_size_type *map_len ATTRIBUTE_UNUSED) 700 { 701 return (void *)-1; 702 } 703 704 const struct bfd_iovec _bfd_memory_iovec = 705 { 706 &memory_bread, &memory_bwrite, &memory_btell, &memory_bseek, 707 &memory_bclose, &memory_bflush, &memory_bstat, &memory_bmmap 708 }; 709