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 Free Software Foundation, Inc.
   5
   6    Written by Cygnus Support.
   7
   8 This file is part of BFD, the Binary File Descriptor library.
   9
  10 This program is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 2 of the License, or
  13 (at your option) any later version.
  14
  15 This program is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with this program; if not, write to the Free Software
  22 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  23
  24 #include "sysdep.h"
  25
  26 #include "bfd.h"
  27 #include "libbfd.h"
  28
  29 #include <limits.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 /*
  66 INTERNAL_DEFINITION
  67         struct bfd_iovec
  68
  69 DESCRIPTION
  70
  71         The <<struct bfd_iovec>> contains the internal file I/O class.
  72         Each <<BFD>> has an instance of this class and all file I/O is
  73         routed through it (it is assumed that the instance implements
  74         all methods listed below).
  75
  76 .struct bfd_iovec
  77 .{
  78 .  {* To avoid problems with macros, a "b" rather than "f"
  79 .     prefix is prepended to each method name.  *}
  80 .  {* Attempt to read/write NBYTES on ABFD's IOSTREAM storing/fetching
  81 .     bytes starting at PTR.  Return the number of bytes actually
  82 .     transfered (a read past end-of-file returns less than NBYTES),
  83 .     or -1 (setting <<bfd_error>>) if an error occurs.  *}
  84 .  file_ptr (*bread) (struct bfd *abfd, void *ptr, file_ptr nbytes);
  85 .  file_ptr (*bwrite) (struct bfd *abfd, const void *ptr,
  86 .                      file_ptr nbytes);
  87 .  {* Return the current IOSTREAM file offset, or -1 (setting <<bfd_error>>
  88 .     if an error occurs.  *}
  89 .  file_ptr (*btell) (struct bfd *abfd);
  90 .  {* For the following, on successful completion a value of 0 is returned.
  91 .     Otherwise, a value of -1 is returned (and  <<bfd_error>> is set).  *}
  92 .  int (*bseek) (struct bfd *abfd, file_ptr offset, int whence);
  93 .  int (*bclose) (struct bfd *abfd);
  94 .  int (*bflush) (struct bfd *abfd);
  95 .  int (*bstat) (struct bfd *abfd, struct stat *sb);
  96 .};
  97
  98 */
  99
 100
 101 /* Return value is amount read.  */
 102
 103 bfd_size_type
 104 bfd_bread (void *ptr, bfd_size_type size, bfd *abfd)
 105 {
 106   size_t nread;
 107
 108   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 109     {
 110       struct bfd_in_memory *bim;
 111       bfd_size_type get;
 112
 113       bim = abfd->iostream;
 114       get = size;
 115       if (abfd->where + get > bim->size)
 116         {
 117           if (bim->size < (bfd_size_type) abfd->where)
 118             get = 0;
 119           else
 120             get = bim->size - abfd->where;
 121           bfd_set_error (bfd_error_file_truncated);
 122         }
 123       memcpy (ptr, bim->buffer + abfd->where, (size_t) get);
 124       abfd->where += get;
 125       return get;
 126     }
 127
 128   nread = abfd->iovec->bread (abfd, ptr, size);
 129   if (nread != (size_t) -1)
 130     abfd->where += nread;
 131
 132   return nread;
 133 }
 134
 135 bfd_size_type
 136 bfd_bwrite (const void *ptr, bfd_size_type size, bfd *abfd)
 137 {
 138   size_t nwrote;
 139
 140   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 141     {
 142       struct bfd_in_memory *bim = abfd->iostream;
 143       size = (size_t) size;
 144       if (abfd->where + size > bim->size)
 145         {
 146           bfd_size_type newsize, oldsize;
 147
 148           oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
 149           bim->size = abfd->where + size;
 150           /* Round up to cut down on memory fragmentation */
 151           newsize = (bim->size + 127) & ~(bfd_size_type) 127;
 152           if (newsize > oldsize)
 153             {
 154               bim->buffer = bfd_realloc (bim->buffer, newsize);
 155               if (bim->buffer == 0)
 156                 {
 157                   bim->size = 0;
 158                   return 0;
 159                 }
 160             }
 161         }
 162       memcpy (bim->buffer + abfd->where, ptr, (size_t) size);
 163       abfd->where += size;
 164       return size;
 165     }
 166
 167   nwrote = abfd->iovec->bwrite (abfd, ptr, size);
 168   if (nwrote != (size_t) -1)
 169     abfd->where += nwrote;
 170   if (nwrote != size)
 171     {
 172 #ifdef ENOSPC
 173       errno = ENOSPC;
 174 #endif
 175       bfd_set_error (bfd_error_system_call);
 176     }
 177   return nwrote;
 178 }
 179
 180 file_ptr
 181 bfd_tell (bfd *abfd)
 182 {
 183   file_ptr ptr;
 184
 185   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 186     return abfd->where;
 187
 188   ptr = abfd->iovec->btell (abfd);
 189
 190   if (abfd->my_archive)
 191     ptr -= abfd->origin;
 192   abfd->where = ptr;
 193   return ptr;
 194 }
 195
 196 int
 197 bfd_flush (bfd *abfd)
 198 {
 199   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 200     return 0;
 201   return abfd->iovec->bflush (abfd);
 202 }
 203
 204 /* Returns 0 for success, negative value for failure (in which case
 205    bfd_get_error can retrieve the error code).  */
 206 int
 207 bfd_stat (bfd *abfd, struct stat *statbuf)
 208 {
 209   int result;
 210
 211   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 212     abort ();
 213
 214   result = abfd->iovec->bstat (abfd, statbuf);
 215   if (result < 0)
 216     bfd_set_error (bfd_error_system_call);
 217   return result;
 218 }
 219
 220 /* Returns 0 for success, nonzero for failure (in which case bfd_get_error
 221    can retrieve the error code).  */
 222
 223 int
 224 bfd_seek (bfd *abfd, file_ptr position, int direction)
 225 {
 226   int result;
 227   file_ptr file_position;
 228   /* For the time being, a BFD may not seek to it's end.  The problem
 229      is that we don't easily have a way to recognize the end of an
 230      element in an archive.  */
 231
 232   BFD_ASSERT (direction == SEEK_SET || direction == SEEK_CUR);
 233
 234   if (direction == SEEK_CUR && position == 0)
 235     return 0;
 236
 237   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 238     {
 239       struct bfd_in_memory *bim;
 240
 241       bim = abfd->iostream;
 242
 243       if (direction == SEEK_SET)
 244         abfd->where = position;
 245       else
 246         abfd->where += position;
 247
 248       if (abfd->where > bim->size)
 249         {
 250           if ((abfd->direction == write_direction) ||
 251               (abfd->direction == both_direction))
 252             {
 253               bfd_size_type newsize, oldsize;
 254               oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
 255               bim->size = abfd->where;
 256               /* Round up to cut down on memory fragmentation */
 257               newsize = (bim->size + 127) & ~(bfd_size_type) 127;
 258               if (newsize > oldsize)
 259                 {
 260                   bim->buffer = bfd_realloc (bim->buffer, newsize);
 261                   if (bim->buffer == 0)
 262                     {
 263                       bim->size = 0;
 264                       return -1;
 265                     }
 266                 }
 267             }
 268           else
 269             {
 270               abfd->where = bim->size;
 271               bfd_set_error (bfd_error_file_truncated);
 272               return -1;
 273             }
 274         }
 275       return 0;
 276     }
 277
 278   if (abfd->format != bfd_archive && abfd->my_archive == 0)
 279     {
 280 #if 0
 281       /* Explanation for this code: I'm only about 95+% sure that the above
 282          conditions are sufficient and that all i/o calls are properly
 283          adjusting the `where' field.  So this is sort of an `assert'
 284          that the `where' field is correct.  If we can go a while without
 285          tripping the abort, we can probably safely disable this code,
 286          so that the real optimizations happen.  */
 287       file_ptr where_am_i_now;
 288       where_am_i_now = real_ftell (bfd_cache_lookup (abfd));
 289       if (abfd->my_archive)
 290         where_am_i_now -= abfd->origin;
 291       if (where_am_i_now != abfd->where)
 292         abort ();
 293 #endif
 294       if (direction == SEEK_SET && (bfd_vma) position == abfd->where)
 295         return 0;
 296     }
 297   else
 298     {
 299       /* We need something smarter to optimize access to archives.
 300          Currently, anything inside an archive is read via the file
 301          handle for the archive.  Which means that a bfd_seek on one
 302          component affects the `current position' in the archive, as
 303          well as in any other component.
 304
 305          It might be sufficient to put a spike through the cache
 306          abstraction, and look to the archive for the file position,
 307          but I think we should try for something cleaner.
 308
 309          In the meantime, no optimization for archives.  */
 310     }
 311
 312   file_position = position;
 313   if (direction == SEEK_SET && abfd->my_archive != NULL)
 314     file_position += abfd->origin;
 315
 316   result = abfd->iovec->bseek (abfd, file_position, direction);
 317   if (result != 0)
 318     {
 319       int hold_errno = errno;
 320
 321       /* Force redetermination of `where' field.  */
 322       bfd_tell (abfd);
 323
 324       /* An EINVAL error probably means that the file offset was
 325          absurd.  */
 326       if (hold_errno == EINVAL)
 327         bfd_set_error (bfd_error_file_truncated);
 328       else
 329         {
 330           bfd_set_error (bfd_error_system_call);
 331           errno = hold_errno;
 332         }
 333     }
 334   else
 335     {
 336       /* Adjust `where' field.  */
 337       if (direction == SEEK_SET)
 338         abfd->where = position;
 339       else
 340         abfd->where += position;
 341     }
 342   return result;
 343 }
 344
 345 /*
 346 FUNCTION
 347         bfd_get_mtime
 348
 349 SYNOPSIS
 350         long bfd_get_mtime (bfd *abfd);
 351
 352 DESCRIPTION
 353         Return the file modification time (as read from the file system, or
 354         from the archive header for archive members).
 355
 356 */
 357
 358 long
 359 bfd_get_mtime (bfd *abfd)
 360 {
 361   struct stat buf;
 362
 363   if (abfd->mtime_set)
 364     return abfd->mtime;
 365
 366   if (abfd->iovec->bstat (abfd, &buf) != 0)
 367     return 0;
 368
 369   abfd->mtime = buf.st_mtime;           /* Save value in case anyone wants it */
 370   return buf.st_mtime;
 371 }
 372
 373 /*
 374 FUNCTION
 375         bfd_get_size
 376
 377 SYNOPSIS
 378         long bfd_get_size (bfd *abfd);
 379
 380 DESCRIPTION
 381         Return the file size (as read from file system) for the file
 382         associated with BFD @var{abfd}.
 383
 384         The initial motivation for, and use of, this routine is not
 385         so we can get the exact size of the object the BFD applies to, since
 386         that might not be generally possible (archive members for example).
 387         It would be ideal if someone could eventually modify
 388         it so that such results were guaranteed.
 389
 390         Instead, we want to ask questions like "is this NNN byte sized
 391         object I'm about to try read from file offset YYY reasonable?"
 392         As as example of where we might do this, some object formats
 393         use string tables for which the first <<sizeof (long)>> bytes of the
 394         table contain the size of the table itself, including the size bytes.
 395         If an application tries to read what it thinks is one of these
 396         string tables, without some way to validate the size, and for
 397         some reason the size is wrong (byte swapping error, wrong location
 398         for the string table, etc.), the only clue is likely to be a read
 399         error when it tries to read the table, or a "virtual memory
 400         exhausted" error when it tries to allocate 15 bazillon bytes
 401         of space for the 15 bazillon byte table it is about to read.
 402         This function at least allows us to answer the question, "is the
 403         size reasonable?".
 404 */
 405
 406 long
 407 bfd_get_size (bfd *abfd)
 408 {
 409   struct stat buf;
 410
 411   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 412     return ((struct bfd_in_memory *) abfd->iostream)->size;
 413
 414   if (abfd->iovec->bstat (abfd, &buf) != 0)
 415     return 0;
 416
 417   return buf.st_size;
 418 }