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       archive_size = adata->parsed_size;
 497       /* If the archive is compressed we can't compare against file size.  */
 498       if (adata->arch_header != NULL
 499           && memcmp (((struct ar_hdr *) adata->arch_header)->ar_fmag,
 500                      "Z\012", 2) == 0)
 501         return archive_size;
 502       abfd = abfd->my_archive;
 503     }
 504
 505   file_size = bfd_get_size (abfd);
 506   if (archive_size < file_size)
 507     return archive_size;
 508   return file_size;
 509 }
 510
 511 /*
 512 FUNCTION
 513         bfd_mmap
 514
 515 SYNOPSIS
 516         void *bfd_mmap (bfd *abfd, void *addr, bfd_size_type len,
 517                         int prot, int flags, file_ptr offset,
 518                         void **map_addr, bfd_size_type *map_len);
 519
 520 DESCRIPTION
 521         Return mmap()ed region of the file, if possible and implemented.
 522         LEN and OFFSET do not need to be page aligned.  The page aligned
 523         address and length are written to MAP_ADDR and MAP_LEN.
 524
 525 */
 526
 527 void *
 528 bfd_mmap (bfd *abfd, void *addr, bfd_size_type len,
 529           int prot, int flags, file_ptr offset,
 530           void **map_addr, bfd_size_type *map_len)
 531 {
 532   while (abfd->my_archive != NULL
 533          && !bfd_is_thin_archive (abfd->my_archive))
 534     {
 535       offset += abfd->origin;
 536       abfd = abfd->my_archive;
 537     }
 538   offset += abfd->origin;
 539
 540   if (abfd->iovec == NULL)
 541     {
 542       bfd_set_error (bfd_error_invalid_operation);
 543       return (void *) -1;
 544     }
 545
 546   return abfd->iovec->bmmap (abfd, addr, len, prot, flags, offset,
 547                              map_addr, map_len);
 548 }
 549
 550 /* Memory file I/O operations.  */
 551
 552 static file_ptr
 553 memory_bread (bfd *abfd, void *ptr, file_ptr size)
 554 {
 555   struct bfd_in_memory *bim;
 556   bfd_size_type get;
 557
 558   bim = (struct bfd_in_memory *) abfd->iostream;
 559   get = size;
 560   if (abfd->where + get > bim->size)
 561     {
 562       if (bim->size < (bfd_size_type) abfd->where)
 563         get = 0;
 564       else
 565         get = bim->size - abfd->where;
 566       bfd_set_error (bfd_error_file_truncated);
 567     }
 568   memcpy (ptr, bim->buffer + abfd->where, (size_t) get);
 569   return get;
 570 }
 571
 572 static file_ptr
 573 memory_bwrite (bfd *abfd, const void *ptr, file_ptr size)
 574 {
 575   struct bfd_in_memory *bim = (struct bfd_in_memory *) abfd->iostream;
 576
 577   if (abfd->where + size > bim->size)
 578     {
 579       bfd_size_type newsize, oldsize;
 580
 581       oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
 582       bim->size = abfd->where + size;
 583       /* Round up to cut down on memory fragmentation */
 584       newsize = (bim->size + 127) & ~(bfd_size_type) 127;
 585       if (newsize > oldsize)
 586         {
 587           bim->buffer = (bfd_byte *) bfd_realloc_or_free (bim->buffer, newsize);
 588           if (bim->buffer == NULL)
 589             {
 590               bim->size = 0;
 591               return 0;
 592             }
 593           if (newsize > bim->size)
 594             memset (bim->buffer + bim->size, 0, newsize - bim->size);
 595         }
 596     }
 597   memcpy (bim->buffer + abfd->where, ptr, (size_t) size);
 598   return size;
 599 }
 600
 601 static file_ptr
 602 memory_btell (bfd *abfd)
 603 {
 604   return abfd->where;
 605 }
 606
 607 static int
 608 memory_bseek (bfd *abfd, file_ptr position, int direction)
 609 {
 610   file_ptr nwhere;
 611   struct bfd_in_memory *bim;
 612
 613   bim = (struct bfd_in_memory *) abfd->iostream;
 614
 615   if (direction == SEEK_SET)
 616     nwhere = position;
 617   else
 618     nwhere = abfd->where + position;
 619
 620   if (nwhere < 0)
 621     {
 622       abfd->where = 0;
 623       errno = EINVAL;
 624       return -1;
 625     }
 626
 627   if ((bfd_size_type)nwhere > bim->size)
 628     {
 629       if (abfd->direction == write_direction
 630           || abfd->direction == both_direction)
 631         {
 632           bfd_size_type newsize, oldsize;
 633
 634           oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
 635           bim->size = nwhere;
 636           /* Round up to cut down on memory fragmentation */
 637           newsize = (bim->size + 127) & ~(bfd_size_type) 127;
 638           if (newsize > oldsize)
 639             {
 640               bim->buffer = (bfd_byte *) bfd_realloc_or_free (bim->buffer, newsize);
 641               if (bim->buffer == NULL)
 642                 {
 643                   errno = EINVAL;
 644                   bim->size = 0;
 645                   return -1;
 646                 }
 647               memset (bim->buffer + oldsize, 0, newsize - oldsize);
 648             }
 649         }
 650       else
 651         {
 652           abfd->where = bim->size;
 653           errno = EINVAL;
 654           bfd_set_error (bfd_error_file_truncated);
 655           return -1;
 656         }
 657     }
 658   return 0;
 659 }
 660
 661 static int
 662 memory_bclose (struct bfd *abfd)
 663 {
 664   struct bfd_in_memory *bim = (struct bfd_in_memory *) abfd->iostream;
 665
 666   free (bim->buffer);
 667   free (bim);
 668   abfd->iostream = NULL;
 669
 670   return 0;
 671 }
 672
 673 static int
 674 memory_bflush (bfd *abfd ATTRIBUTE_UNUSED)
 675 {
 676   return 0;
 677 }
 678
 679 static int
 680 memory_bstat (bfd *abfd, struct stat *statbuf)
 681 {
 682   struct bfd_in_memory *bim = (struct bfd_in_memory *) abfd->iostream;
 683
 684   memset (statbuf, 0, sizeof (*statbuf));
 685   statbuf->st_size = bim->size;
 686
 687   return 0;
 688 }
 689
 690 static void *
 691 memory_bmmap (bfd *abfd ATTRIBUTE_UNUSED, void *addr ATTRIBUTE_UNUSED,
 692               bfd_size_type len ATTRIBUTE_UNUSED, int prot ATTRIBUTE_UNUSED,
 693               int flags ATTRIBUTE_UNUSED, file_ptr offset ATTRIBUTE_UNUSED,
 694               void **map_addr ATTRIBUTE_UNUSED,
 695               bfd_size_type *map_len ATTRIBUTE_UNUSED)
 696 {
 697   return (void *)-1;
 698 }
 699
 700 const struct bfd_iovec _bfd_memory_iovec =
 701 {
 702   &memory_bread, &memory_bwrite, &memory_btell, &memory_bseek,
 703   &memory_bclose, &memory_bflush, &memory_bstat, &memory_bmmap
 704 };