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, 2009
   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 .  {* Just like mmap: (void*)-1 on failure, mmapped address on success.  *}
 162 .  void *(*bmmap) (struct bfd *abfd, void *addr, bfd_size_type len,
 163 .                  int prot, int flags, file_ptr offset);
 164 .};
 165
 166 .extern const struct bfd_iovec _bfd_memory_iovec;
 167
 168 */
 169
 170
 171 /* Return value is amount read.  */
 172
 173 bfd_size_type
 174 bfd_bread (void *ptr, bfd_size_type size, bfd *abfd)
 175 {
 176   size_t nread;
 177
 178   /* If this is an archive element, don't read past the end of
 179      this element.  */
 180   if (abfd->arelt_data != NULL)
 181     {
 182       size_t maxbytes = ((struct areltdata *) abfd->arelt_data)->parsed_size;
 183       if (size > maxbytes)
 184         size = maxbytes;
 185     }
 186
 187   if (abfd->iovec)
 188     nread = abfd->iovec->bread (abfd, ptr, size);
 189   else
 190     nread = 0;
 191   if (nread != (size_t) -1)
 192     abfd->where += nread;
 193
 194   return nread;
 195 }
 196
 197 bfd_size_type
 198 bfd_bwrite (const void *ptr, bfd_size_type size, bfd *abfd)
 199 {
 200   size_t nwrote;
 201
 202   if (abfd->iovec)
 203     nwrote = abfd->iovec->bwrite (abfd, ptr, size);
 204   else
 205     nwrote = 0;
 206
 207   if (nwrote != (size_t) -1)
 208     abfd->where += nwrote;
 209   if (nwrote != size)
 210     {
 211 #ifdef ENOSPC
 212       errno = ENOSPC;
 213 #endif
 214       bfd_set_error (bfd_error_system_call);
 215     }
 216   return nwrote;
 217 }
 218
 219 file_ptr
 220 bfd_tell (bfd *abfd)
 221 {
 222   file_ptr ptr;
 223
 224   if (abfd->iovec)
 225     {
 226       ptr = abfd->iovec->btell (abfd);
 227
 228       if (abfd->my_archive)
 229         ptr -= abfd->origin;
 230     }
 231   else
 232     ptr = 0;
 233
 234   abfd->where = ptr;
 235   return ptr;
 236 }
 237
 238 int
 239 bfd_flush (bfd *abfd)
 240 {
 241   if (abfd->iovec)
 242     return abfd->iovec->bflush (abfd);
 243   return 0;
 244 }
 245
 246 /* Returns 0 for success, negative value for failure (in which case
 247    bfd_get_error can retrieve the error code).  */
 248 int
 249 bfd_stat (bfd *abfd, struct stat *statbuf)
 250 {
 251   int result;
 252
 253   if (abfd->iovec)
 254     result = abfd->iovec->bstat (abfd, statbuf);
 255   else
 256     result = -1;
 257
 258   if (result < 0)
 259     bfd_set_error (bfd_error_system_call);
 260   return result;
 261 }
 262
 263 /* Returns 0 for success, nonzero for failure (in which case bfd_get_error
 264    can retrieve the error code).  */
 265
 266 int
 267 bfd_seek (bfd *abfd, file_ptr position, int direction)
 268 {
 269   int result;
 270   file_ptr file_position;
 271   /* For the time being, a BFD may not seek to it's end.  The problem
 272      is that we don't easily have a way to recognize the end of an
 273      element in an archive.  */
 274
 275   BFD_ASSERT (direction == SEEK_SET || direction == SEEK_CUR);
 276
 277   if (direction == SEEK_CUR && position == 0)
 278     return 0;
 279
 280   if (abfd->format != bfd_archive && abfd->my_archive == 0)
 281     {
 282       if (direction == SEEK_SET && (bfd_vma) position == abfd->where)
 283         return 0;
 284     }
 285   else
 286     {
 287       /* We need something smarter to optimize access to archives.
 288          Currently, anything inside an archive is read via the file
 289          handle for the archive.  Which means that a bfd_seek on one
 290          component affects the `current position' in the archive, as
 291          well as in any other component.
 292
 293          It might be sufficient to put a spike through the cache
 294          abstraction, and look to the archive for the file position,
 295          but I think we should try for something cleaner.
 296
 297          In the meantime, no optimization for archives.  */
 298     }
 299
 300   file_position = position;
 301   if (direction == SEEK_SET && abfd->my_archive != NULL)
 302     file_position += abfd->origin;
 303
 304   if (abfd->iovec)
 305     result = abfd->iovec->bseek (abfd, file_position, direction);
 306   else
 307     result = -1;
 308
 309   if (result != 0)
 310     {
 311       int hold_errno = errno;
 312
 313       /* Force redetermination of `where' field.  */
 314       bfd_tell (abfd);
 315
 316       /* An EINVAL error probably means that the file offset was
 317          absurd.  */
 318       if (hold_errno == EINVAL)
 319         bfd_set_error (bfd_error_file_truncated);
 320       else
 321         {
 322           bfd_set_error (bfd_error_system_call);
 323           errno = hold_errno;
 324         }
 325     }
 326   else
 327     {
 328       /* Adjust `where' field.  */
 329       if (direction == SEEK_SET)
 330         abfd->where = position;
 331       else
 332         abfd->where += position;
 333     }
 334   return result;
 335 }
 336
 337 /*
 338 FUNCTION
 339         bfd_get_mtime
 340
 341 SYNOPSIS
 342         long bfd_get_mtime (bfd *abfd);
 343
 344 DESCRIPTION
 345         Return the file modification time (as read from the file system, or
 346         from the archive header for archive members).
 347
 348 */
 349
 350 long
 351 bfd_get_mtime (bfd *abfd)
 352 {
 353   struct stat buf;
 354
 355   if (abfd->mtime_set)
 356     return abfd->mtime;
 357
 358   if (abfd->iovec == NULL)
 359     return 0;
 360
 361   if (abfd->iovec->bstat (abfd, &buf) != 0)
 362     return 0;
 363
 364   abfd->mtime = buf.st_mtime;           /* Save value in case anyone wants it */
 365   return buf.st_mtime;
 366 }
 367
 368 /*
 369 FUNCTION
 370         bfd_get_size
 371
 372 SYNOPSIS
 373         file_ptr bfd_get_size (bfd *abfd);
 374
 375 DESCRIPTION
 376         Return the file size (as read from file system) for the file
 377         associated with BFD @var{abfd}.
 378
 379         The initial motivation for, and use of, this routine is not
 380         so we can get the exact size of the object the BFD applies to, since
 381         that might not be generally possible (archive members for example).
 382         It would be ideal if someone could eventually modify
 383         it so that such results were guaranteed.
 384
 385         Instead, we want to ask questions like "is this NNN byte sized
 386         object I'm about to try read from file offset YYY reasonable?"
 387         As as example of where we might do this, some object formats
 388         use string tables for which the first <<sizeof (long)>> bytes of the
 389         table contain the size of the table itself, including the size bytes.
 390         If an application tries to read what it thinks is one of these
 391         string tables, without some way to validate the size, and for
 392         some reason the size is wrong (byte swapping error, wrong location
 393         for the string table, etc.), the only clue is likely to be a read
 394         error when it tries to read the table, or a "virtual memory
 395         exhausted" error when it tries to allocate 15 bazillon bytes
 396         of space for the 15 bazillon byte table it is about to read.
 397         This function at least allows us to answer the question, "is the
 398         size reasonable?".
 399 */
 400
 401 file_ptr
 402 bfd_get_size (bfd *abfd)
 403 {
 404   struct stat buf;
 405
 406   if (abfd->iovec == NULL)
 407     return 0;
 408
 409   if (abfd->iovec->bstat (abfd, &buf) != 0)
 410     return 0;
 411
 412   return buf.st_size;
 413 }
 414
 415
 416 /*
 417 FUNCTION
 418         bfd_mmap
 419
 420 SYNOPSIS
 421         void *bfd_mmap (bfd *abfd, void *addr, bfd_size_type len,
 422                         int prot, int flags, file_ptr offset);
 423
 424 DESCRIPTION
 425         Return mmap()ed region of the file, if possible and implemented.
 426
 427 */
 428
 429 void *
 430 bfd_mmap (bfd *abfd, void *addr, bfd_size_type len,
 431           int prot, int flags, file_ptr offset)
 432 {
 433   void *ret = (void *)-1;
 434
 435   if (abfd->iovec == NULL)
 436     return ret;
 437
 438   return abfd->iovec->bmmap (abfd, addr, len, prot, flags, offset);
 439 }
 440
 441 /* Memory file I/O operations.  */
 442
 443 static file_ptr
 444 memory_bread (bfd *abfd, void *ptr, file_ptr size)
 445 {
 446   struct bfd_in_memory *bim;
 447   bfd_size_type get;
 448
 449   bim = (struct bfd_in_memory *) abfd->iostream;
 450   get = size;
 451   if (abfd->where + get > bim->size)
 452     {
 453       if (bim->size < (bfd_size_type) abfd->where)
 454         get = 0;
 455       else
 456         get = bim->size - abfd->where;
 457       bfd_set_error (bfd_error_file_truncated);
 458     }
 459   memcpy (ptr, bim->buffer + abfd->where, (size_t) get);
 460   return get;
 461 }
 462
 463 static file_ptr
 464 memory_bwrite (bfd *abfd, const void *ptr, file_ptr size)
 465 {
 466   struct bfd_in_memory *bim = (struct bfd_in_memory *) abfd->iostream;
 467
 468   if (abfd->where + size > bim->size)
 469     {
 470       bfd_size_type newsize, oldsize;
 471
 472       oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
 473       bim->size = abfd->where + size;
 474       /* Round up to cut down on memory fragmentation */
 475       newsize = (bim->size + 127) & ~(bfd_size_type) 127;
 476       if (newsize > oldsize)
 477         {
 478           bim->buffer = (bfd_byte *) bfd_realloc_or_free (bim->buffer, newsize);
 479           if (bim->buffer == NULL)
 480             {
 481               bim->size = 0;
 482               return 0;
 483             }
 484           if (newsize > bim->size)
 485             memset (bim->buffer + bim->size, 0, newsize - bim->size);
 486         }
 487     }
 488   memcpy (bim->buffer + abfd->where, ptr, (size_t) size);
 489   return size;
 490 }
 491
 492 static file_ptr
 493 memory_btell (bfd *abfd)
 494 {
 495   return abfd->where;
 496 }
 497
 498 static int
 499 memory_bseek (bfd *abfd, file_ptr position, int direction)
 500 {
 501   file_ptr nwhere;
 502   struct bfd_in_memory *bim;
 503
 504   bim = (struct bfd_in_memory *) abfd->iostream;
 505
 506   if (direction == SEEK_SET)
 507     nwhere = position;
 508   else
 509     nwhere = abfd->where + position;
 510
 511   if (nwhere < 0)
 512     {
 513       abfd->where = 0;
 514       errno = EINVAL;
 515       return -1;
 516     }
 517
 518   if ((bfd_size_type)nwhere > bim->size)
 519     {
 520       if (abfd->direction == write_direction
 521           || abfd->direction == both_direction)
 522         {
 523           bfd_size_type newsize, oldsize;
 524
 525           oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
 526           bim->size = nwhere;
 527           /* Round up to cut down on memory fragmentation */
 528           newsize = (bim->size + 127) & ~(bfd_size_type) 127;
 529           if (newsize > oldsize)
 530             {
 531               bim->buffer = (bfd_byte *) bfd_realloc_or_free (bim->buffer, newsize);
 532               if (bim->buffer == NULL)
 533                 {
 534                   errno = EINVAL;
 535                   bim->size = 0;
 536                   return -1;
 537                 }
 538               memset (bim->buffer + oldsize, 0, newsize - oldsize);
 539             }
 540         }
 541       else
 542         {
 543           abfd->where = bim->size;
 544           errno = EINVAL;
 545           bfd_set_error (bfd_error_file_truncated);
 546           return -1;
 547         }
 548     }
 549   return 0;
 550 }
 551
 552 static int
 553 memory_bclose (struct bfd *abfd)
 554 {
 555   struct bfd_in_memory *bim = (struct bfd_in_memory *) abfd->iostream;
 556
 557   if (bim->buffer != NULL)
 558     free (bim->buffer);
 559   free (bim);
 560   abfd->iostream = NULL;
 561
 562   return TRUE;
 563 }
 564
 565 static int
 566 memory_bflush (bfd *abfd ATTRIBUTE_UNUSED)
 567 {
 568   return 0;
 569 }
 570
 571 static int
 572 memory_bstat (bfd *abfd, struct stat *statbuf)
 573 {
 574   struct bfd_in_memory *bim = (struct bfd_in_memory *) abfd->iostream;
 575
 576   memset (statbuf, 0, sizeof (statbuf));
 577   statbuf->st_size = bim->size;
 578
 579   return 0;
 580 }
 581
 582 static void *
 583 memory_bmmap (bfd *abfd ATTRIBUTE_UNUSED, void *addr ATTRIBUTE_UNUSED,
 584               bfd_size_type len ATTRIBUTE_UNUSED, int prot ATTRIBUTE_UNUSED,
 585               int flags ATTRIBUTE_UNUSED, file_ptr offset ATTRIBUTE_UNUSED)
 586 {
 587   return (void *)-1;
 588 }
 589
 590 const struct bfd_iovec _bfd_memory_iovec =
 591 {
 592   &memory_bread, &memory_bwrite, &memory_btell, &memory_bseek,
 593   &memory_bclose, &memory_bflush, &memory_bstat, &memory_bmmap
 594 };