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   if (abfd->iovec)
 129     nread = abfd->iovec->bread (abfd, ptr, size);
 130   else
 131     nread = 0;
 132   if (nread != (size_t) -1)
 133     abfd->where += nread;
 134
 135   return nread;
 136 }
 137
 138 bfd_size_type
 139 bfd_bwrite (const void *ptr, bfd_size_type size, bfd *abfd)
 140 {
 141   size_t nwrote;
 142
 143   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 144     {
 145       struct bfd_in_memory *bim = abfd->iostream;
 146
 147       size = (size_t) size;
 148       if (abfd->where + size > bim->size)
 149         {
 150           bfd_size_type newsize, oldsize;
 151
 152           oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
 153           bim->size = abfd->where + size;
 154           /* Round up to cut down on memory fragmentation */
 155           newsize = (bim->size + 127) & ~(bfd_size_type) 127;
 156           if (newsize > oldsize)
 157             {
 158               bim->buffer = bfd_realloc (bim->buffer, newsize);
 159               if (bim->buffer == 0)
 160                 {
 161                   bim->size = 0;
 162                   return 0;
 163                 }
 164             }
 165         }
 166       memcpy (bim->buffer + abfd->where, ptr, (size_t) size);
 167       abfd->where += size;
 168       return size;
 169     }
 170
 171   if (abfd->iovec)
 172     nwrote = abfd->iovec->bwrite (abfd, ptr, size);
 173   else
 174     nwrote = 0;
 175
 176   if (nwrote != (size_t) -1)
 177     abfd->where += nwrote;
 178   if (nwrote != size)
 179     {
 180 #ifdef ENOSPC
 181       errno = ENOSPC;
 182 #endif
 183       bfd_set_error (bfd_error_system_call);
 184     }
 185   return nwrote;
 186 }
 187
 188 file_ptr
 189 bfd_tell (bfd *abfd)
 190 {
 191   file_ptr ptr;
 192
 193   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 194     return abfd->where;
 195
 196   if (abfd->iovec)
 197     {
 198       ptr = abfd->iovec->btell (abfd);
 199
 200       if (abfd->my_archive)
 201         ptr -= abfd->origin;
 202     }
 203   else
 204     ptr = 0;
 205
 206   abfd->where = ptr;
 207   return ptr;
 208 }
 209
 210 int
 211 bfd_flush (bfd *abfd)
 212 {
 213   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 214     return 0;
 215
 216   if (abfd->iovec)
 217     return abfd->iovec->bflush (abfd);
 218   return 0;
 219 }
 220
 221 /* Returns 0 for success, negative value for failure (in which case
 222    bfd_get_error can retrieve the error code).  */
 223 int
 224 bfd_stat (bfd *abfd, struct stat *statbuf)
 225 {
 226   int result;
 227
 228   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 229     abort ();
 230
 231   if (abfd->iovec)
 232     result = abfd->iovec->bstat (abfd, statbuf);
 233   else
 234     result = -1;
 235
 236   if (result < 0)
 237     bfd_set_error (bfd_error_system_call);
 238   return result;
 239 }
 240
 241 /* Returns 0 for success, nonzero for failure (in which case bfd_get_error
 242    can retrieve the error code).  */
 243
 244 int
 245 bfd_seek (bfd *abfd, file_ptr position, int direction)
 246 {
 247   int result;
 248   file_ptr file_position;
 249   /* For the time being, a BFD may not seek to it's end.  The problem
 250      is that we don't easily have a way to recognize the end of an
 251      element in an archive.  */
 252
 253   BFD_ASSERT (direction == SEEK_SET || direction == SEEK_CUR);
 254
 255   if (direction == SEEK_CUR && position == 0)
 256     return 0;
 257
 258   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 259     {
 260       struct bfd_in_memory *bim;
 261
 262       bim = abfd->iostream;
 263
 264       if (direction == SEEK_SET)
 265         abfd->where = position;
 266       else
 267         abfd->where += position;
 268
 269       if (abfd->where > bim->size)
 270         {
 271           if ((abfd->direction == write_direction) ||
 272               (abfd->direction == both_direction))
 273             {
 274               bfd_size_type newsize, oldsize;
 275
 276               oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
 277               bim->size = abfd->where;
 278               /* Round up to cut down on memory fragmentation */
 279               newsize = (bim->size + 127) & ~(bfd_size_type) 127;
 280               if (newsize > oldsize)
 281                 {
 282                   bim->buffer = bfd_realloc (bim->buffer, newsize);
 283                   if (bim->buffer == 0)
 284                     {
 285                       bim->size = 0;
 286                       return -1;
 287                     }
 288                 }
 289             }
 290           else
 291             {
 292               abfd->where = bim->size;
 293               bfd_set_error (bfd_error_file_truncated);
 294               return -1;
 295             }
 296         }
 297       return 0;
 298     }
 299
 300   if (abfd->format != bfd_archive && abfd->my_archive == 0)
 301     {
 302       if (direction == SEEK_SET && (bfd_vma) position == abfd->where)
 303         return 0;
 304     }
 305   else
 306     {
 307       /* We need something smarter to optimize access to archives.
 308          Currently, anything inside an archive is read via the file
 309          handle for the archive.  Which means that a bfd_seek on one
 310          component affects the `current position' in the archive, as
 311          well as in any other component.
 312
 313          It might be sufficient to put a spike through the cache
 314          abstraction, and look to the archive for the file position,
 315          but I think we should try for something cleaner.
 316
 317          In the meantime, no optimization for archives.  */
 318     }
 319
 320   file_position = position;
 321   if (direction == SEEK_SET && abfd->my_archive != NULL)
 322     file_position += abfd->origin;
 323
 324   if (abfd->iovec)
 325     result = abfd->iovec->bseek (abfd, file_position, direction);
 326   else
 327     result = -1;
 328
 329   if (result != 0)
 330     {
 331       int hold_errno = errno;
 332
 333       /* Force redetermination of `where' field.  */
 334       bfd_tell (abfd);
 335
 336       /* An EINVAL error probably means that the file offset was
 337          absurd.  */
 338       if (hold_errno == EINVAL)
 339         bfd_set_error (bfd_error_file_truncated);
 340       else
 341         {
 342           bfd_set_error (bfd_error_system_call);
 343           errno = hold_errno;
 344         }
 345     }
 346   else
 347     {
 348       /* Adjust `where' field.  */
 349       if (direction == SEEK_SET)
 350         abfd->where = position;
 351       else
 352         abfd->where += position;
 353     }
 354   return result;
 355 }
 356
 357 /*
 358 FUNCTION
 359         bfd_get_mtime
 360
 361 SYNOPSIS
 362         long bfd_get_mtime (bfd *abfd);
 363
 364 DESCRIPTION
 365         Return the file modification time (as read from the file system, or
 366         from the archive header for archive members).
 367
 368 */
 369
 370 long
 371 bfd_get_mtime (bfd *abfd)
 372 {
 373   struct stat buf;
 374
 375   if (abfd->mtime_set)
 376     return abfd->mtime;
 377
 378   if (abfd->iovec == NULL)
 379     return 0;
 380
 381   if (abfd->iovec->bstat (abfd, &buf) != 0)
 382     return 0;
 383
 384   abfd->mtime = buf.st_mtime;           /* Save value in case anyone wants it */
 385   return buf.st_mtime;
 386 }
 387
 388 /*
 389 FUNCTION
 390         bfd_get_size
 391
 392 SYNOPSIS
 393         long bfd_get_size (bfd *abfd);
 394
 395 DESCRIPTION
 396         Return the file size (as read from file system) for the file
 397         associated with BFD @var{abfd}.
 398
 399         The initial motivation for, and use of, this routine is not
 400         so we can get the exact size of the object the BFD applies to, since
 401         that might not be generally possible (archive members for example).
 402         It would be ideal if someone could eventually modify
 403         it so that such results were guaranteed.
 404
 405         Instead, we want to ask questions like "is this NNN byte sized
 406         object I'm about to try read from file offset YYY reasonable?"
 407         As as example of where we might do this, some object formats
 408         use string tables for which the first <<sizeof (long)>> bytes of the
 409         table contain the size of the table itself, including the size bytes.
 410         If an application tries to read what it thinks is one of these
 411         string tables, without some way to validate the size, and for
 412         some reason the size is wrong (byte swapping error, wrong location
 413         for the string table, etc.), the only clue is likely to be a read
 414         error when it tries to read the table, or a "virtual memory
 415         exhausted" error when it tries to allocate 15 bazillon bytes
 416         of space for the 15 bazillon byte table it is about to read.
 417         This function at least allows us to answer the question, "is the
 418         size reasonable?".
 419 */
 420
 421 long
 422 bfd_get_size (bfd *abfd)
 423 {
 424   struct stat buf;
 425
 426   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 427     return ((struct bfd_in_memory *) abfd->iostream)->size;
 428
 429   if (abfd->iovec == NULL)
 430     return 0;
 431
 432   if (abfd->iovec->bstat (abfd, &buf) != 0)
 433     return 0;
 434
 435   return buf.st_size;
 436 }