bfd/bfdio.c

   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 };