X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=bfd%2Fbfdio.c;h=e9fa5bb012c981e46a6e6f998aa0312929180d96;hb=d87bef3a7bc827fa36a69d2c334aa82f7d188d81;hp=bedebba87254116cd7d3dd7f905a67cad02d36dd;hpb=aa820537ead0135a7c38c619039dce8a6fc74ed1;p=binutils-gdb.git diff --git a/bfd/bfdio.c b/bfd/bfdio.c index bedebba8725..e9fa5bb012c 100644 --- a/bfd/bfdio.c +++ b/bfd/bfdio.c @@ -1,8 +1,6 @@ /* Low-level I/O routines for BFDs. - Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, - 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 - Free Software Foundation, Inc. + Copyright (C) 1990-2023 Free Software Foundation, Inc. Written by Cygnus Support. @@ -27,6 +25,11 @@ #include #include "bfd.h" #include "libbfd.h" +#include "aout/ar.h" +#if defined (_WIN32) +#include +#include +#endif #ifndef S_IXUSR #define S_IXUSR 0100 /* Execute by owner. */ @@ -43,7 +46,7 @@ #endif file_ptr -real_ftell (FILE *file) +_bfd_real_ftell (FILE *file) { #if defined (HAVE_FTELLO64) return ftello64 (file); @@ -55,7 +58,7 @@ real_ftell (FILE *file) } int -real_fseek (FILE *file, file_ptr offset, int whence) +_bfd_real_fseek (FILE *file, file_ptr offset, int whence) { #if defined (HAVE_FSEEKO64) return fseeko64 (file, offset, whence); @@ -84,23 +87,17 @@ close_on_exec (FILE *file) } FILE * -real_fopen (const char *filename, const char *modes) +_bfd_real_fopen (const char *filename, const char *modes) { #ifdef VMS - char vms_modes[4]; char *vms_attr; - /* On VMS, fopen allows file attributes as optionnal arguments. + /* On VMS, fopen allows file attributes as optional arguments. We need to use them but we'd better to use the common prototype. In fopen-vms.h, they are separated from the mode with a comma. Split here. */ vms_attr = strchr (modes, ','); - if (vms_attr == NULL) - { - /* No attributes. */ - return close_on_exec (fopen (filename, modes)); - } - else + if (vms_attr != NULL) { /* Attributes found. Split. */ size_t modes_len = strlen (modes) + 1; @@ -118,13 +115,66 @@ real_fopen (const char *filename, const char *modes) } return close_on_exec (fopen (filename, at[0], at[1], at[2])); } -#else /* !VMS */ -#if defined (HAVE_FOPEN64) + +#elif defined (_WIN32) + /* PR 25713: Handle extra long path names possibly containing '..' and '.'. */ + wchar_t ** lpFilePart = {NULL}; + const wchar_t prefix[] = L"\\\\?\\"; + const size_t partPathLen = strlen (filename) + 1; +#ifdef __MINGW32__ +#if !HAVE_DECL____LC_CODEPAGE_FUNC +/* This prototype was added to locale.h in version 9.0 of MinGW-w64. */ + _CRTIMP unsigned int __cdecl ___lc_codepage_func (void); +#endif + const unsigned int cp = ___lc_codepage_func (); +#else + const unsigned int cp = CP_UTF8; +#endif + + /* Converting the partial path from ascii to unicode. + 1) Get the length: Calling with lpWideCharStr set to null returns the length. + 2) Convert the string: Calling with cbMultiByte set to -1 includes the terminating null. */ + size_t partPathWSize = MultiByteToWideChar (cp, 0, filename, -1, NULL, 0); + wchar_t * partPath = calloc (partPathWSize, sizeof(wchar_t)); + size_t ix; + + MultiByteToWideChar (cp, 0, filename, -1, partPath, partPathWSize); + + /* Convert any UNIX style path separators into the DOS i.e. backslash separator. */ + for (ix = 0; ix < partPathLen; ix++) + if (IS_UNIX_DIR_SEPARATOR(filename[ix])) + partPath[ix] = '\\'; + + /* Getting the full path from the provided partial path. + 1) Get the length. + 2) Resolve the path. */ + long fullPathWSize = GetFullPathNameW (partPath, 0, NULL, lpFilePart); + wchar_t * fullPath = calloc (fullPathWSize + sizeof(prefix) + 1, sizeof(wchar_t)); + + wcscpy (fullPath, prefix); + + int prefixLen = sizeof(prefix) / sizeof(wchar_t); + wchar_t * fullPathOffset = fullPath + prefixLen - 1; + + GetFullPathNameW (partPath, fullPathWSize, fullPathOffset, lpFilePart); + free (partPath); + + /* It is non-standard for modes to exceed 16 characters. */ + wchar_t modesW[16]; + + MultiByteToWideChar (cp, 0, modes, -1, modesW, sizeof(modesW)); + + FILE * file = _wfopen (fullPath, modesW); + free (fullPath); + + return close_on_exec (file); + +#elif defined (HAVE_FOPEN64) return close_on_exec (fopen64 (filename, modes)); + #else return close_on_exec (fopen (filename, modes)); #endif -#endif /* !VMS */ } /* @@ -148,21 +198,29 @@ DESCRIPTION . or -1 (setting <>) if an error occurs. *} . file_ptr (*bread) (struct bfd *abfd, void *ptr, file_ptr nbytes); . file_ptr (*bwrite) (struct bfd *abfd, const void *ptr, -. file_ptr nbytes); +. file_ptr nbytes); . {* Return the current IOSTREAM file offset, or -1 (setting <> . if an error occurs. *} . file_ptr (*btell) (struct bfd *abfd); . {* For the following, on successful completion a value of 0 is returned. -. Otherwise, a value of -1 is returned (and <> is set). *} +. Otherwise, a value of -1 is returned (and <> is set). *} . int (*bseek) (struct bfd *abfd, file_ptr offset, int whence); . int (*bclose) (struct bfd *abfd); . int (*bflush) (struct bfd *abfd); . int (*bstat) (struct bfd *abfd, struct stat *sb); -. {* Just like mmap: (void*)-1 on failure, mmapped address on success. *} +. {* Mmap a part of the files. ADDR, LEN, PROT, FLAGS and OFFSET are the usual +. mmap parameter, except that LEN and OFFSET do not need to be page +. aligned. Returns (void *)-1 on failure, mmapped address on success. +. Also write in MAP_ADDR the address of the page aligned buffer and in +. MAP_LEN the size mapped (a page multiple). Use unmap with MAP_ADDR and +. MAP_LEN to unmap. *} . void *(*bmmap) (struct bfd *abfd, void *addr, bfd_size_type len, -. int prot, int flags, file_ptr offset); +. int prot, int flags, file_ptr offset, +. void **map_addr, bfd_size_type *map_len); .}; +.extern const struct bfd_iovec _bfd_memory_iovec; + */ @@ -171,42 +229,43 @@ DESCRIPTION bfd_size_type bfd_bread (void *ptr, bfd_size_type size, bfd *abfd) { - size_t nread; + file_ptr nread; + bfd *element_bfd = abfd; + ufile_ptr offset = 0; - /* If this is an archive element, don't read past the end of - this element. */ - if (abfd->arelt_data != NULL) + while (abfd->my_archive != NULL + && !bfd_is_thin_archive (abfd->my_archive)) { - size_t maxbytes = ((struct areltdata *) abfd->arelt_data)->parsed_size; - if (size > maxbytes) - size = maxbytes; + offset += abfd->origin; + abfd = abfd->my_archive; } + offset += abfd->origin; - if ((abfd->flags & BFD_IN_MEMORY) != 0) + /* If this is a non-thin archive element, don't read past the end of + this element. */ + if (element_bfd->arelt_data != NULL + && element_bfd->my_archive != NULL + && !bfd_is_thin_archive (element_bfd->my_archive)) { - struct bfd_in_memory *bim; - bfd_size_type get; + bfd_size_type maxbytes = arelt_size (element_bfd); - bim = abfd->iostream; - get = size; - if (abfd->where + get > bim->size) + if (abfd->where < offset || abfd->where - offset >= maxbytes) { - if (bim->size < (bfd_size_type) abfd->where) - get = 0; - else - get = bim->size - abfd->where; - bfd_set_error (bfd_error_file_truncated); + bfd_set_error (bfd_error_invalid_operation); + return -1; } - memcpy (ptr, bim->buffer + abfd->where, (size_t) get); - abfd->where += get; - return get; + if (abfd->where - offset + size > maxbytes) + size = maxbytes - (abfd->where - offset); } - if (abfd->iovec) - nread = abfd->iovec->bread (abfd, ptr, size); - else - nread = 0; - if (nread != (size_t) -1) + if (abfd->iovec == NULL) + { + bfd_set_error (bfd_error_invalid_operation); + return -1; + } + + nread = abfd->iovec->bread (abfd, ptr, size); + if (nread != -1) abfd->where += nread; return nread; @@ -215,46 +274,22 @@ bfd_bread (void *ptr, bfd_size_type size, bfd *abfd) bfd_size_type bfd_bwrite (const void *ptr, bfd_size_type size, bfd *abfd) { - size_t nwrote; + file_ptr nwrote; - if ((abfd->flags & BFD_IN_MEMORY) != 0) - { - struct bfd_in_memory *bim = abfd->iostream; - - size = (size_t) size; - if (abfd->where + size > bim->size) - { - bfd_size_type newsize, oldsize; + while (abfd->my_archive != NULL + && !bfd_is_thin_archive (abfd->my_archive)) + abfd = abfd->my_archive; - oldsize = (bim->size + 127) & ~(bfd_size_type) 127; - bim->size = abfd->where + size; - /* Round up to cut down on memory fragmentation */ - newsize = (bim->size + 127) & ~(bfd_size_type) 127; - if (newsize > oldsize) - { - bim->buffer = bfd_realloc_or_free (bim->buffer, newsize); - if (bim->buffer == NULL) - { - bim->size = 0; - return 0; - } - if (newsize > bim->size) - memset (bim->buffer + bim->size, 0, newsize - bim->size); - } - } - memcpy (bim->buffer + abfd->where, ptr, (size_t) size); - abfd->where += size; - return size; + if (abfd->iovec == NULL) + { + bfd_set_error (bfd_error_invalid_operation); + return -1; } - if (abfd->iovec) - nwrote = abfd->iovec->bwrite (abfd, ptr, size); - else - nwrote = 0; - - if (nwrote != (size_t) -1) + nwrote = abfd->iovec->bwrite (abfd, ptr, size); + if (nwrote != -1) abfd->where += nwrote; - if (nwrote != size) + if ((bfd_size_type) nwrote != size) { #ifdef ENOSPC errno = ENOSPC; @@ -267,34 +302,36 @@ bfd_bwrite (const void *ptr, bfd_size_type size, bfd *abfd) file_ptr bfd_tell (bfd *abfd) { + ufile_ptr offset = 0; file_ptr ptr; - if ((abfd->flags & BFD_IN_MEMORY) != 0) - return abfd->where; - - if (abfd->iovec) + while (abfd->my_archive != NULL + && !bfd_is_thin_archive (abfd->my_archive)) { - ptr = abfd->iovec->btell (abfd); - - if (abfd->my_archive) - ptr -= abfd->origin; + offset += abfd->origin; + abfd = abfd->my_archive; } - else - ptr = 0; + offset += abfd->origin; + + if (abfd->iovec == NULL) + return 0; + ptr = abfd->iovec->btell (abfd); abfd->where = ptr; - return ptr; + return ptr - offset; } int bfd_flush (bfd *abfd) { - if ((abfd->flags & BFD_IN_MEMORY) != 0) + while (abfd->my_archive != NULL + && !bfd_is_thin_archive (abfd->my_archive)) + abfd = abfd->my_archive; + + if (abfd->iovec == NULL) return 0; - if (abfd->iovec) - return abfd->iovec->bflush (abfd); - return 0; + return abfd->iovec->bflush (abfd); } /* Returns 0 for success, negative value for failure (in which case @@ -304,14 +341,17 @@ bfd_stat (bfd *abfd, struct stat *statbuf) { int result; - if ((abfd->flags & BFD_IN_MEMORY) != 0) - abort (); + while (abfd->my_archive != NULL + && !bfd_is_thin_archive (abfd->my_archive)) + abfd = abfd->my_archive; - if (abfd->iovec) - result = abfd->iovec->bstat (abfd, statbuf); - else - result = -1; + if (abfd->iovec == NULL) + { + bfd_set_error (bfd_error_invalid_operation); + return -1; + } + result = abfd->iovec->bstat (abfd, statbuf); if (result < 0) bfd_set_error (bfd_error_system_call); return result; @@ -324,113 +364,53 @@ int bfd_seek (bfd *abfd, file_ptr position, int direction) { int result; - file_ptr file_position; - /* For the time being, a BFD may not seek to it's end. The problem - is that we don't easily have a way to recognize the end of an - element in an archive. */ - - BFD_ASSERT (direction == SEEK_SET || direction == SEEK_CUR); + ufile_ptr offset = 0; - if (direction == SEEK_CUR && position == 0) - return 0; - - if ((abfd->flags & BFD_IN_MEMORY) != 0) + while (abfd->my_archive != NULL + && !bfd_is_thin_archive (abfd->my_archive)) { - struct bfd_in_memory *bim; - - bim = abfd->iostream; - - if (direction == SEEK_SET) - abfd->where = position; - else - abfd->where += position; - - if (abfd->where > bim->size) - { - if (abfd->direction == write_direction - || abfd->direction == both_direction) - { - bfd_size_type newsize, oldsize; - - oldsize = (bim->size + 127) & ~(bfd_size_type) 127; - bim->size = abfd->where; - /* Round up to cut down on memory fragmentation */ - newsize = (bim->size + 127) & ~(bfd_size_type) 127; - if (newsize > oldsize) - { - bim->buffer = bfd_realloc_or_free (bim->buffer, newsize); - if (bim->buffer == NULL) - { - bim->size = 0; - return -1; - } - memset (bim->buffer + oldsize, 0, newsize - oldsize); - } - } - else - { - abfd->where = bim->size; - bfd_set_error (bfd_error_file_truncated); - return -1; - } - } - return 0; + offset += abfd->origin; + abfd = abfd->my_archive; } + offset += abfd->origin; - if (abfd->format != bfd_archive && abfd->my_archive == 0) + if (abfd->iovec == NULL) { - if (direction == SEEK_SET && (bfd_vma) position == abfd->where) - return 0; + bfd_set_error (bfd_error_invalid_operation); + return -1; } - else - { - /* We need something smarter to optimize access to archives. - Currently, anything inside an archive is read via the file - handle for the archive. Which means that a bfd_seek on one - component affects the `current position' in the archive, as - well as in any other component. - - It might be sufficient to put a spike through the cache - abstraction, and look to the archive for the file position, - but I think we should try for something cleaner. - In the meantime, no optimization for archives. */ - } + /* For the time being, a BFD may not seek to it's end. The problem + is that we don't easily have a way to recognize the end of an + element in an archive. */ + BFD_ASSERT (direction == SEEK_SET || direction == SEEK_CUR); - file_position = position; - if (direction == SEEK_SET && abfd->my_archive != NULL) - file_position += abfd->origin; + if (direction != SEEK_CUR) + position += offset; - if (abfd->iovec) - result = abfd->iovec->bseek (abfd, file_position, direction); - else - result = -1; + if ((direction == SEEK_CUR && position == 0) + || (direction == SEEK_SET && (ufile_ptr) position == abfd->where)) + return 0; + result = abfd->iovec->bseek (abfd, position, direction); if (result != 0) { - int hold_errno = errno; - - /* Force redetermination of `where' field. */ - bfd_tell (abfd); - /* An EINVAL error probably means that the file offset was - absurd. */ - if (hold_errno == EINVAL) + absurd. */ + if (errno == EINVAL) bfd_set_error (bfd_error_file_truncated); else - { - bfd_set_error (bfd_error_system_call); - errno = hold_errno; - } + bfd_set_error (bfd_error_system_call); } else { /* Adjust `where' field. */ - if (direction == SEEK_SET) - abfd->where = position; - else + if (direction == SEEK_CUR) abfd->where += position; + else + abfd->where = position; } + return result; } @@ -455,10 +435,7 @@ bfd_get_mtime (bfd *abfd) if (abfd->mtime_set) return abfd->mtime; - if (abfd->iovec == NULL) - return 0; - - if (abfd->iovec->bstat (abfd, &buf) != 0) + if (bfd_stat (abfd, &buf) != 0) return 0; abfd->mtime = buf.st_mtime; /* Save value in case anyone wants it */ @@ -470,7 +447,7 @@ FUNCTION bfd_get_size SYNOPSIS - file_ptr bfd_get_size (bfd *abfd); + ufile_ptr bfd_get_size (bfd *abfd); DESCRIPTION Return the file size (as read from file system) for the file @@ -496,25 +473,75 @@ DESCRIPTION of space for the 15 bazillon byte table it is about to read. This function at least allows us to answer the question, "is the size reasonable?". + + A return value of zero indicates the file size is unknown. */ -file_ptr +ufile_ptr bfd_get_size (bfd *abfd) { - struct stat buf; + /* A size of 0 means we haven't yet called bfd_stat. A size of 1 + means we have a cached value of 0, ie. unknown. */ + if (abfd->size <= 1 || bfd_write_p (abfd)) + { + struct stat buf; - if ((abfd->flags & BFD_IN_MEMORY) != 0) - return ((struct bfd_in_memory *) abfd->iostream)->size; + if (abfd->size == 1 && !bfd_write_p (abfd)) + return 0; - if (abfd->iovec == NULL) - return 0; + if (bfd_stat (abfd, &buf) != 0 + || buf.st_size == 0 + || buf.st_size - (ufile_ptr) buf.st_size != 0) + { + abfd->size = 1; + return 0; + } + abfd->size = buf.st_size; + } + return abfd->size; +} - if (abfd->iovec->bstat (abfd, &buf) != 0) - return 0; +/* +FUNCTION + bfd_get_file_size - return buf.st_size; -} +SYNOPSIS + ufile_ptr bfd_get_file_size (bfd *abfd); + +DESCRIPTION + Return the file size (as read from file system) for the file + associated with BFD @var{abfd}. It supports both normal files + and archive elements. +*/ + +ufile_ptr +bfd_get_file_size (bfd *abfd) +{ + ufile_ptr file_size, archive_size = (ufile_ptr) -1; + + if (abfd->my_archive != NULL + && !bfd_is_thin_archive (abfd->my_archive)) + { + struct areltdata *adata = (struct areltdata *) abfd->arelt_data; + if (adata != NULL) + { + archive_size = adata->parsed_size; + /* If the archive is compressed we can't compare against + file size. */ + if (adata->arch_header != NULL + && memcmp (((struct ar_hdr *) adata->arch_header)->ar_fmag, + "Z\012", 2) == 0) + return archive_size; + abfd = abfd->my_archive; + } + } + + file_size = bfd_get_size (abfd); + if (archive_size < file_size) + return archive_size; + return file_size; +} /* FUNCTION @@ -522,23 +549,191 @@ FUNCTION SYNOPSIS void *bfd_mmap (bfd *abfd, void *addr, bfd_size_type len, - int prot, int flags, file_ptr offset); + int prot, int flags, file_ptr offset, + void **map_addr, bfd_size_type *map_len); DESCRIPTION Return mmap()ed region of the file, if possible and implemented. + LEN and OFFSET do not need to be page aligned. The page aligned + address and length are written to MAP_ADDR and MAP_LEN. */ void * bfd_mmap (bfd *abfd, void *addr, bfd_size_type len, - int prot, int flags, file_ptr offset) + int prot, int flags, file_ptr offset, + void **map_addr, bfd_size_type *map_len) { - void *ret = (void *)-1; - if ((abfd->flags & BFD_IN_MEMORY) != 0) - return ret; + while (abfd->my_archive != NULL + && !bfd_is_thin_archive (abfd->my_archive)) + { + offset += abfd->origin; + abfd = abfd->my_archive; + } + offset += abfd->origin; if (abfd->iovec == NULL) - return ret; + { + bfd_set_error (bfd_error_invalid_operation); + return (void *) -1; + } + + return abfd->iovec->bmmap (abfd, addr, len, prot, flags, offset, + map_addr, map_len); +} + +/* Memory file I/O operations. */ + +static file_ptr +memory_bread (bfd *abfd, void *ptr, file_ptr size) +{ + struct bfd_in_memory *bim; + bfd_size_type get; + + bim = (struct bfd_in_memory *) abfd->iostream; + get = size; + if (abfd->where + get > bim->size) + { + if (bim->size < (bfd_size_type) abfd->where) + get = 0; + else + get = bim->size - abfd->where; + bfd_set_error (bfd_error_file_truncated); + } + memcpy (ptr, bim->buffer + abfd->where, (size_t) get); + return get; +} + +static file_ptr +memory_bwrite (bfd *abfd, const void *ptr, file_ptr size) +{ + struct bfd_in_memory *bim = (struct bfd_in_memory *) abfd->iostream; + + if (abfd->where + size > bim->size) + { + bfd_size_type newsize, oldsize; + + oldsize = (bim->size + 127) & ~(bfd_size_type) 127; + bim->size = abfd->where + size; + /* Round up to cut down on memory fragmentation */ + newsize = (bim->size + 127) & ~(bfd_size_type) 127; + if (newsize > oldsize) + { + bim->buffer = (bfd_byte *) bfd_realloc_or_free (bim->buffer, newsize); + if (bim->buffer == NULL) + { + bim->size = 0; + return 0; + } + if (newsize > bim->size) + memset (bim->buffer + bim->size, 0, newsize - bim->size); + } + } + memcpy (bim->buffer + abfd->where, ptr, (size_t) size); + return size; +} - return abfd->iovec->bmmap (abfd, addr, len, prot, flags, offset); +static file_ptr +memory_btell (bfd *abfd) +{ + return abfd->where; } + +static int +memory_bseek (bfd *abfd, file_ptr position, int direction) +{ + file_ptr nwhere; + struct bfd_in_memory *bim; + + bim = (struct bfd_in_memory *) abfd->iostream; + + if (direction == SEEK_SET) + nwhere = position; + else + nwhere = abfd->where + position; + + if (nwhere < 0) + { + abfd->where = 0; + errno = EINVAL; + return -1; + } + + if ((bfd_size_type)nwhere > bim->size) + { + if (abfd->direction == write_direction + || abfd->direction == both_direction) + { + bfd_size_type newsize, oldsize; + + oldsize = (bim->size + 127) & ~(bfd_size_type) 127; + bim->size = nwhere; + /* Round up to cut down on memory fragmentation */ + newsize = (bim->size + 127) & ~(bfd_size_type) 127; + if (newsize > oldsize) + { + bim->buffer = (bfd_byte *) bfd_realloc_or_free (bim->buffer, newsize); + if (bim->buffer == NULL) + { + errno = EINVAL; + bim->size = 0; + return -1; + } + memset (bim->buffer + oldsize, 0, newsize - oldsize); + } + } + else + { + abfd->where = bim->size; + errno = EINVAL; + bfd_set_error (bfd_error_file_truncated); + return -1; + } + } + return 0; +} + +static int +memory_bclose (struct bfd *abfd) +{ + struct bfd_in_memory *bim = (struct bfd_in_memory *) abfd->iostream; + + free (bim->buffer); + free (bim); + abfd->iostream = NULL; + + return 0; +} + +static int +memory_bflush (bfd *abfd ATTRIBUTE_UNUSED) +{ + return 0; +} + +static int +memory_bstat (bfd *abfd, struct stat *statbuf) +{ + struct bfd_in_memory *bim = (struct bfd_in_memory *) abfd->iostream; + + memset (statbuf, 0, sizeof (*statbuf)); + statbuf->st_size = bim->size; + + return 0; +} + +static void * +memory_bmmap (bfd *abfd ATTRIBUTE_UNUSED, void *addr ATTRIBUTE_UNUSED, + bfd_size_type len ATTRIBUTE_UNUSED, int prot ATTRIBUTE_UNUSED, + int flags ATTRIBUTE_UNUSED, file_ptr offset ATTRIBUTE_UNUSED, + void **map_addr ATTRIBUTE_UNUSED, + bfd_size_type *map_len ATTRIBUTE_UNUSED) +{ + return (void *)-1; +} + +const struct bfd_iovec _bfd_memory_iovec = +{ + &memory_bread, &memory_bwrite, &memory_btell, &memory_bseek, + &memory_bclose, &memory_bflush, &memory_bstat, &memory_bmmap +};