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