daily update
[binutils.git] / bfd / bfdio.c
blobce92781d505a8f4ee0c5efb16232b71119cfc4e8
1 /* Low-level I/O routines for BFDs.
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.
7 Written by Cygnus Support.
9 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
26 #include "sysdep.h"
27 #include <limits.h>
28 #include "bfd.h"
29 #include "libbfd.h"
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
41 #ifndef FD_CLOEXEC
42 #define FD_CLOEXEC 1
43 #endif
45 file_ptr
46 real_ftell (FILE *file)
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
57 int
58 real_fseek (FILE *file, file_ptr offset, int whence)
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
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)
74 #if defined (HAVE_FILENO) && defined (F_GETFD)
75 if (file)
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);
82 #endif
83 return file;
86 FILE *
87 real_fopen (const char *filename, const char *modes)
89 #ifdef VMS
90 char vms_modes[4];
91 char *vms_attr;
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)
100 /* No attributes. */
101 return close_on_exec (fopen (filename, modes));
103 else
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;
111 memcpy (attrs, modes, modes_len);
112 at[0] = attrs;
113 for (i = 0; i < 2; i++)
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. */
119 return close_on_exec (fopen (filename, at[0], at[1], at[2]));
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 */
131 INTERNAL_DEFINITION
132 struct bfd_iovec
134 DESCRIPTION
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).
141 .struct bfd_iovec
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);
166 .extern const struct bfd_iovec _bfd_memory_iovec;
171 /* Return value is amount read. */
173 bfd_size_type
174 bfd_bread (void *ptr, bfd_size_type size, bfd *abfd)
176 size_t nread;
178 /* If this is an archive element, don't read past the end of
179 this element. */
180 if (abfd->arelt_data != NULL)
182 size_t maxbytes = ((struct areltdata *) abfd->arelt_data)->parsed_size;
183 if (abfd->where + size > maxbytes)
185 if (abfd->where >= maxbytes)
186 return 0;
187 size = maxbytes - abfd->where;
191 if (abfd->iovec)
192 nread = abfd->iovec->bread (abfd, ptr, size);
193 else
194 nread = 0;
195 if (nread != (size_t) -1)
196 abfd->where += nread;
198 return nread;
201 bfd_size_type
202 bfd_bwrite (const void *ptr, bfd_size_type size, bfd *abfd)
204 size_t nwrote;
206 if (abfd->iovec)
207 nwrote = abfd->iovec->bwrite (abfd, ptr, size);
208 else
209 nwrote = 0;
211 if (nwrote != (size_t) -1)
212 abfd->where += nwrote;
213 if (nwrote != size)
215 #ifdef ENOSPC
216 errno = ENOSPC;
217 #endif
218 bfd_set_error (bfd_error_system_call);
220 return nwrote;
223 file_ptr
224 bfd_tell (bfd *abfd)
226 file_ptr ptr;
228 if (abfd->iovec)
230 ptr = abfd->iovec->btell (abfd);
232 if (abfd->my_archive)
233 ptr -= abfd->origin;
235 else
236 ptr = 0;
238 abfd->where = ptr;
239 return ptr;
243 bfd_flush (bfd *abfd)
245 if (abfd->iovec)
246 return abfd->iovec->bflush (abfd);
247 return 0;
250 /* Returns 0 for success, negative value for failure (in which case
251 bfd_get_error can retrieve the error code). */
253 bfd_stat (bfd *abfd, struct stat *statbuf)
255 int result;
257 if (abfd->iovec)
258 result = abfd->iovec->bstat (abfd, statbuf);
259 else
260 result = -1;
262 if (result < 0)
263 bfd_set_error (bfd_error_system_call);
264 return result;
267 /* Returns 0 for success, nonzero for failure (in which case bfd_get_error
268 can retrieve the error code). */
271 bfd_seek (bfd *abfd, file_ptr position, int direction)
273 int result;
274 file_ptr file_position;
275 /* For the time being, a BFD may not seek to it's end. The problem
276 is that we don't easily have a way to recognize the end of an
277 element in an archive. */
279 BFD_ASSERT (direction == SEEK_SET || direction == SEEK_CUR);
281 if (direction == SEEK_CUR && position == 0)
282 return 0;
284 if (abfd->format != bfd_archive && abfd->my_archive == 0)
286 if (direction == SEEK_SET && (bfd_vma) position == abfd->where)
287 return 0;
289 else
291 /* We need something smarter to optimize access to archives.
292 Currently, anything inside an archive is read via the file
293 handle for the archive. Which means that a bfd_seek on one
294 component affects the `current position' in the archive, as
295 well as in any other component.
297 It might be sufficient to put a spike through the cache
298 abstraction, and look to the archive for the file position,
299 but I think we should try for something cleaner.
301 In the meantime, no optimization for archives. */
304 file_position = position;
305 if (direction == SEEK_SET && abfd->my_archive != NULL)
306 file_position += abfd->origin;
308 if (abfd->iovec)
309 result = abfd->iovec->bseek (abfd, file_position, direction);
310 else
311 result = -1;
313 if (result != 0)
315 int hold_errno = errno;
317 /* Force redetermination of `where' field. */
318 bfd_tell (abfd);
320 /* An EINVAL error probably means that the file offset was
321 absurd. */
322 if (hold_errno == EINVAL)
323 bfd_set_error (bfd_error_file_truncated);
324 else
326 bfd_set_error (bfd_error_system_call);
327 errno = hold_errno;
330 else
332 /* Adjust `where' field. */
333 if (direction == SEEK_SET)
334 abfd->where = position;
335 else
336 abfd->where += position;
338 return result;
342 FUNCTION
343 bfd_get_mtime
345 SYNOPSIS
346 long bfd_get_mtime (bfd *abfd);
348 DESCRIPTION
349 Return the file modification time (as read from the file system, or
350 from the archive header for archive members).
354 long
355 bfd_get_mtime (bfd *abfd)
357 struct stat buf;
359 if (abfd->mtime_set)
360 return abfd->mtime;
362 if (abfd->iovec == NULL)
363 return 0;
365 if (abfd->iovec->bstat (abfd, &buf) != 0)
366 return 0;
368 abfd->mtime = buf.st_mtime; /* Save value in case anyone wants it */
369 return buf.st_mtime;
373 FUNCTION
374 bfd_get_size
376 SYNOPSIS
377 file_ptr bfd_get_size (bfd *abfd);
379 DESCRIPTION
380 Return the file size (as read from file system) for the file
381 associated with BFD @var{abfd}.
383 The initial motivation for, and use of, this routine is not
384 so we can get the exact size of the object the BFD applies to, since
385 that might not be generally possible (archive members for example).
386 It would be ideal if someone could eventually modify
387 it so that such results were guaranteed.
389 Instead, we want to ask questions like "is this NNN byte sized
390 object I'm about to try read from file offset YYY reasonable?"
391 As as example of where we might do this, some object formats
392 use string tables for which the first <<sizeof (long)>> bytes of the
393 table contain the size of the table itself, including the size bytes.
394 If an application tries to read what it thinks is one of these
395 string tables, without some way to validate the size, and for
396 some reason the size is wrong (byte swapping error, wrong location
397 for the string table, etc.), the only clue is likely to be a read
398 error when it tries to read the table, or a "virtual memory
399 exhausted" error when it tries to allocate 15 bazillon bytes
400 of space for the 15 bazillon byte table it is about to read.
401 This function at least allows us to answer the question, "is the
402 size reasonable?".
405 file_ptr
406 bfd_get_size (bfd *abfd)
408 struct stat buf;
410 if (abfd->iovec == NULL)
411 return 0;
413 if (abfd->iovec->bstat (abfd, &buf) != 0)
414 return 0;
416 return buf.st_size;
421 FUNCTION
422 bfd_mmap
424 SYNOPSIS
425 void *bfd_mmap (bfd *abfd, void *addr, bfd_size_type len,
426 int prot, int flags, file_ptr offset);
428 DESCRIPTION
429 Return mmap()ed region of the file, if possible and implemented.
433 void *
434 bfd_mmap (bfd *abfd, void *addr, bfd_size_type len,
435 int prot, int flags, file_ptr offset)
437 void *ret = (void *)-1;
439 if (abfd->iovec == NULL)
440 return ret;
442 return abfd->iovec->bmmap (abfd, addr, len, prot, flags, offset);
445 /* Memory file I/O operations. */
447 static file_ptr
448 memory_bread (bfd *abfd, void *ptr, file_ptr size)
450 struct bfd_in_memory *bim;
451 bfd_size_type get;
453 bim = (struct bfd_in_memory *) abfd->iostream;
454 get = size;
455 if (abfd->where + get > bim->size)
457 if (bim->size < (bfd_size_type) abfd->where)
458 get = 0;
459 else
460 get = bim->size - abfd->where;
461 bfd_set_error (bfd_error_file_truncated);
463 memcpy (ptr, bim->buffer + abfd->where, (size_t) get);
464 return get;
467 static file_ptr
468 memory_bwrite (bfd *abfd, const void *ptr, file_ptr size)
470 struct bfd_in_memory *bim = (struct bfd_in_memory *) abfd->iostream;
472 if (abfd->where + size > bim->size)
474 bfd_size_type newsize, oldsize;
476 oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
477 bim->size = abfd->where + size;
478 /* Round up to cut down on memory fragmentation */
479 newsize = (bim->size + 127) & ~(bfd_size_type) 127;
480 if (newsize > oldsize)
482 bim->buffer = (bfd_byte *) bfd_realloc_or_free (bim->buffer, newsize);
483 if (bim->buffer == NULL)
485 bim->size = 0;
486 return 0;
488 if (newsize > bim->size)
489 memset (bim->buffer + bim->size, 0, newsize - bim->size);
492 memcpy (bim->buffer + abfd->where, ptr, (size_t) size);
493 return size;
496 static file_ptr
497 memory_btell (bfd *abfd)
499 return abfd->where;
502 static int
503 memory_bseek (bfd *abfd, file_ptr position, int direction)
505 file_ptr nwhere;
506 struct bfd_in_memory *bim;
508 bim = (struct bfd_in_memory *) abfd->iostream;
510 if (direction == SEEK_SET)
511 nwhere = position;
512 else
513 nwhere = abfd->where + position;
515 if (nwhere < 0)
517 abfd->where = 0;
518 errno = EINVAL;
519 return -1;
522 if ((bfd_size_type)nwhere > bim->size)
524 if (abfd->direction == write_direction
525 || abfd->direction == both_direction)
527 bfd_size_type newsize, oldsize;
529 oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
530 bim->size = nwhere;
531 /* Round up to cut down on memory fragmentation */
532 newsize = (bim->size + 127) & ~(bfd_size_type) 127;
533 if (newsize > oldsize)
535 bim->buffer = (bfd_byte *) bfd_realloc_or_free (bim->buffer, newsize);
536 if (bim->buffer == NULL)
538 errno = EINVAL;
539 bim->size = 0;
540 return -1;
542 memset (bim->buffer + oldsize, 0, newsize - oldsize);
545 else
547 abfd->where = bim->size;
548 errno = EINVAL;
549 bfd_set_error (bfd_error_file_truncated);
550 return -1;
553 return 0;
556 static int
557 memory_bclose (struct bfd *abfd)
559 struct bfd_in_memory *bim = (struct bfd_in_memory *) abfd->iostream;
561 if (bim->buffer != NULL)
562 free (bim->buffer);
563 free (bim);
564 abfd->iostream = NULL;
566 return TRUE;
569 static int
570 memory_bflush (bfd *abfd ATTRIBUTE_UNUSED)
572 return 0;
575 static int
576 memory_bstat (bfd *abfd, struct stat *statbuf)
578 struct bfd_in_memory *bim = (struct bfd_in_memory *) abfd->iostream;
580 memset (statbuf, 0, sizeof (statbuf));
581 statbuf->st_size = bim->size;
583 return 0;
586 static void *
587 memory_bmmap (bfd *abfd ATTRIBUTE_UNUSED, void *addr ATTRIBUTE_UNUSED,
588 bfd_size_type len ATTRIBUTE_UNUSED, int prot ATTRIBUTE_UNUSED,
589 int flags ATTRIBUTE_UNUSED, file_ptr offset ATTRIBUTE_UNUSED)
591 return (void *)-1;
594 const struct bfd_iovec _bfd_memory_iovec =
596 &memory_bread, &memory_bwrite, &memory_btell, &memory_bseek,
597 &memory_bclose, &memory_bflush, &memory_bstat, &memory_bmmap