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