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