bfd/bfdio.c

   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
   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 file_ptr
  42 real_ftell (FILE *file)
  43 {
  44 #if defined (HAVE_FTELLO64)
  45   return ftello64 (file);
  46 #elif defined (HAVE_FTELLO)
  47   return ftello (file);
  48 #else
  49   return ftell (file);
  50 #endif
  51 }
  52
  53 int
  54 real_fseek (FILE *file, file_ptr offset, int whence)
  55 {
  56 #if defined (HAVE_FSEEKO64)
  57   return fseeko64 (file, offset, whence);
  58 #elif defined (HAVE_FSEEKO)
  59   return fseeko (file, offset, whence);
  60 #else
  61   return fseek (file, offset, whence);
  62 #endif
  63 }
  64
  65 FILE *
  66 real_fopen (const char *filename, const char *modes)
  67 {
  68 #if defined (HAVE_FOPEN64)
  69   return fopen64 (filename, modes);
  70 #else
  71   return fopen (filename, modes);
  72 #endif
  73 }
  74
  75 /*
  76 INTERNAL_DEFINITION
  77         struct bfd_iovec
  78
  79 DESCRIPTION
  80
  81         The <<struct bfd_iovec>> contains the internal file I/O class.
  82         Each <<BFD>> has an instance of this class and all file I/O is
  83         routed through it (it is assumed that the instance implements
  84         all methods listed below).
  85
  86 .struct bfd_iovec
  87 .{
  88 .  {* To avoid problems with macros, a "b" rather than "f"
  89 .     prefix is prepended to each method name.  *}
  90 .  {* Attempt to read/write NBYTES on ABFD's IOSTREAM storing/fetching
  91 .     bytes starting at PTR.  Return the number of bytes actually
  92 .     transfered (a read past end-of-file returns less than NBYTES),
  93 .     or -1 (setting <<bfd_error>>) if an error occurs.  *}
  94 .  file_ptr (*bread) (struct bfd *abfd, void *ptr, file_ptr nbytes);
  95 .  file_ptr (*bwrite) (struct bfd *abfd, const void *ptr,
  96 .                      file_ptr nbytes);
  97 .  {* Return the current IOSTREAM file offset, or -1 (setting <<bfd_error>>
  98 .     if an error occurs.  *}
  99 .  file_ptr (*btell) (struct bfd *abfd);
 100 .  {* For the following, on successful completion a value of 0 is returned.
 101 .     Otherwise, a value of -1 is returned (and  <<bfd_error>> is set).  *}
 102 .  int (*bseek) (struct bfd *abfd, file_ptr offset, int whence);
 103 .  int (*bclose) (struct bfd *abfd);
 104 .  int (*bflush) (struct bfd *abfd);
 105 .  int (*bstat) (struct bfd *abfd, struct stat *sb);
 106 .};
 107
 108 */
 109
 110
 111 /* Return value is amount read.  */
 112
 113 bfd_size_type
 114 bfd_bread (void *ptr, bfd_size_type size, bfd *abfd)
 115 {
 116   size_t nread;
 117
 118   /* If this is an archive element, don't read past the end of
 119      this element.  */
 120   if (abfd->arelt_data != NULL)
 121     {
 122       size_t maxbytes = ((struct areltdata *) abfd->arelt_data)->parsed_size;
 123       if (size > maxbytes)
 124         size = maxbytes;
 125     }
 126
 127   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 128     {
 129       struct bfd_in_memory *bim;
 130       bfd_size_type get;
 131
 132       bim = abfd->iostream;
 133       get = size;
 134       if (abfd->where + get > bim->size)
 135         {
 136           if (bim->size < (bfd_size_type) abfd->where)
 137             get = 0;
 138           else
 139             get = bim->size - abfd->where;
 140           bfd_set_error (bfd_error_file_truncated);
 141         }
 142       memcpy (ptr, bim->buffer + abfd->where, (size_t) get);
 143       abfd->where += get;
 144       return get;
 145     }
 146
 147   if (abfd->iovec)
 148     nread = abfd->iovec->bread (abfd, ptr, size);
 149   else
 150     nread = 0;
 151   if (nread != (size_t) -1)
 152     abfd->where += nread;
 153
 154   return nread;
 155 }
 156
 157 bfd_size_type
 158 bfd_bwrite (const void *ptr, bfd_size_type size, bfd *abfd)
 159 {
 160   size_t nwrote;
 161
 162   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 163     {
 164       struct bfd_in_memory *bim = abfd->iostream;
 165
 166       size = (size_t) size;
 167       if (abfd->where + size > bim->size)
 168         {
 169           bfd_size_type newsize, oldsize;
 170
 171           oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
 172           bim->size = abfd->where + size;
 173           /* Round up to cut down on memory fragmentation */
 174           newsize = (bim->size + 127) & ~(bfd_size_type) 127;
 175           if (newsize > oldsize)
 176             {
 177               bim->buffer = bfd_realloc_or_free (bim->buffer, newsize);
 178               if (bim->buffer == NULL)
 179                 {
 180                   bim->size = 0;
 181                   return 0;
 182                 }
 183             }
 184         }
 185       memcpy (bim->buffer + abfd->where, ptr, (size_t) size);
 186       abfd->where += size;
 187       return size;
 188     }
 189
 190   if (abfd->iovec)
 191     nwrote = abfd->iovec->bwrite (abfd, ptr, size);
 192   else
 193     nwrote = 0;
 194
 195   if (nwrote != (size_t) -1)
 196     abfd->where += nwrote;
 197   if (nwrote != size)
 198     {
 199 #ifdef ENOSPC
 200       errno = ENOSPC;
 201 #endif
 202       bfd_set_error (bfd_error_system_call);
 203     }
 204   return nwrote;
 205 }
 206
 207 file_ptr
 208 bfd_tell (bfd *abfd)
 209 {
 210   file_ptr ptr;
 211
 212   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 213     return abfd->where;
 214
 215   if (abfd->iovec)
 216     {
 217       ptr = abfd->iovec->btell (abfd);
 218
 219       if (abfd->my_archive)
 220         ptr -= abfd->origin;
 221     }
 222   else
 223     ptr = 0;
 224
 225   abfd->where = ptr;
 226   return ptr;
 227 }
 228
 229 int
 230 bfd_flush (bfd *abfd)
 231 {
 232   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 233     return 0;
 234
 235   if (abfd->iovec)
 236     return abfd->iovec->bflush (abfd);
 237   return 0;
 238 }
 239
 240 /* Returns 0 for success, negative value for failure (in which case
 241    bfd_get_error can retrieve the error code).  */
 242 int
 243 bfd_stat (bfd *abfd, struct stat *statbuf)
 244 {
 245   int result;
 246
 247   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 248     abort ();
 249
 250   if (abfd->iovec)
 251     result = abfd->iovec->bstat (abfd, statbuf);
 252   else
 253     result = -1;
 254
 255   if (result < 0)
 256     bfd_set_error (bfd_error_system_call);
 257   return result;
 258 }
 259
 260 /* Returns 0 for success, nonzero for failure (in which case bfd_get_error
 261    can retrieve the error code).  */
 262
 263 int
 264 bfd_seek (bfd *abfd, file_ptr position, int direction)
 265 {
 266   int result;
 267   file_ptr file_position;
 268   /* For the time being, a BFD may not seek to it's end.  The problem
 269      is that we don't easily have a way to recognize the end of an
 270      element in an archive.  */
 271
 272   BFD_ASSERT (direction == SEEK_SET || direction == SEEK_CUR);
 273
 274   if (direction == SEEK_CUR && position == 0)
 275     return 0;
 276
 277   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 278     {
 279       struct bfd_in_memory *bim;
 280
 281       bim = abfd->iostream;
 282
 283       if (direction == SEEK_SET)
 284         abfd->where = position;
 285       else
 286         abfd->where += position;
 287
 288       if (abfd->where > bim->size)
 289         {
 290           if ((abfd->direction == write_direction) ||
 291               (abfd->direction == both_direction))
 292             {
 293               bfd_size_type newsize, oldsize;
 294
 295               oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
 296               bim->size = abfd->where;
 297               /* Round up to cut down on memory fragmentation */
 298               newsize = (bim->size + 127) & ~(bfd_size_type) 127;
 299               if (newsize > oldsize)
 300                 {
 301                   bim->buffer = bfd_realloc_or_free (bim->buffer, newsize);
 302                   if (bim->buffer == NULL)
 303                     {
 304                       bim->size = 0;
 305                       return -1;
 306                     }
 307                 }
 308             }
 309           else
 310             {
 311               abfd->where = bim->size;
 312               bfd_set_error (bfd_error_file_truncated);
 313               return -1;
 314             }
 315         }
 316       return 0;
 317     }
 318
 319   if (abfd->format != bfd_archive && abfd->my_archive == 0)
 320     {
 321       if (direction == SEEK_SET && (bfd_vma) position == abfd->where)
 322         return 0;
 323     }
 324   else
 325     {
 326       /* We need something smarter to optimize access to archives.
 327          Currently, anything inside an archive is read via the file
 328          handle for the archive.  Which means that a bfd_seek on one
 329          component affects the `current position' in the archive, as
 330          well as in any other component.
 331
 332          It might be sufficient to put a spike through the cache
 333          abstraction, and look to the archive for the file position,
 334          but I think we should try for something cleaner.
 335
 336          In the meantime, no optimization for archives.  */
 337     }
 338
 339   file_position = position;
 340   if (direction == SEEK_SET && abfd->my_archive != NULL)
 341     file_position += abfd->origin;
 342
 343   if (abfd->iovec)
 344     result = abfd->iovec->bseek (abfd, file_position, direction);
 345   else
 346     result = -1;
 347
 348   if (result != 0)
 349     {
 350       int hold_errno = errno;
 351
 352       /* Force redetermination of `where' field.  */
 353       bfd_tell (abfd);
 354
 355       /* An EINVAL error probably means that the file offset was
 356          absurd.  */
 357       if (hold_errno == EINVAL)
 358         bfd_set_error (bfd_error_file_truncated);
 359       else
 360         {
 361           bfd_set_error (bfd_error_system_call);
 362           errno = hold_errno;
 363         }
 364     }
 365   else
 366     {
 367       /* Adjust `where' field.  */
 368       if (direction == SEEK_SET)
 369         abfd->where = position;
 370       else
 371         abfd->where += position;
 372     }
 373   return result;
 374 }
 375
 376 /*
 377 FUNCTION
 378         bfd_get_mtime
 379
 380 SYNOPSIS
 381         long bfd_get_mtime (bfd *abfd);
 382
 383 DESCRIPTION
 384         Return the file modification time (as read from the file system, or
 385         from the archive header for archive members).
 386
 387 */
 388
 389 long
 390 bfd_get_mtime (bfd *abfd)
 391 {
 392   struct stat buf;
 393
 394   if (abfd->mtime_set)
 395     return abfd->mtime;
 396
 397   if (abfd->iovec == NULL)
 398     return 0;
 399
 400   if (abfd->iovec->bstat (abfd, &buf) != 0)
 401     return 0;
 402
 403   abfd->mtime = buf.st_mtime;           /* Save value in case anyone wants it */
 404   return buf.st_mtime;
 405 }
 406
 407 /*
 408 FUNCTION
 409         bfd_get_size
 410
 411 SYNOPSIS
 412         file_ptr bfd_get_size (bfd *abfd);
 413
 414 DESCRIPTION
 415         Return the file size (as read from file system) for the file
 416         associated with BFD @var{abfd}.
 417
 418         The initial motivation for, and use of, this routine is not
 419         so we can get the exact size of the object the BFD applies to, since
 420         that might not be generally possible (archive members for example).
 421         It would be ideal if someone could eventually modify
 422         it so that such results were guaranteed.
 423
 424         Instead, we want to ask questions like "is this NNN byte sized
 425         object I'm about to try read from file offset YYY reasonable?"
 426         As as example of where we might do this, some object formats
 427         use string tables for which the first <<sizeof (long)>> bytes of the
 428         table contain the size of the table itself, including the size bytes.
 429         If an application tries to read what it thinks is one of these
 430         string tables, without some way to validate the size, and for
 431         some reason the size is wrong (byte swapping error, wrong location
 432         for the string table, etc.), the only clue is likely to be a read
 433         error when it tries to read the table, or a "virtual memory
 434         exhausted" error when it tries to allocate 15 bazillon bytes
 435         of space for the 15 bazillon byte table it is about to read.
 436         This function at least allows us to answer the question, "is the
 437         size reasonable?".
 438 */
 439
 440 file_ptr
 441 bfd_get_size (bfd *abfd)
 442 {
 443   struct stat buf;
 444
 445   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 446     return ((struct bfd_in_memory *) abfd->iostream)->size;
 447
 448   if (abfd->iovec == NULL)
 449     return 0;
 450
 451   if (abfd->iovec->bstat (abfd, &buf) != 0)
 452     return 0;
 453
 454   return buf.st_size;
 455 }