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