| # Copyright 2013-2016 The Meson development team |
| |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| |
| import sys |
| import os |
| import stat |
| import struct |
| import shutil |
| import subprocess |
| import typing as T |
| |
| from ..mesonlib import OrderedSet |
| |
| SHT_STRTAB = 3 |
| DT_NEEDED = 1 |
| DT_RPATH = 15 |
| DT_RUNPATH = 29 |
| DT_STRTAB = 5 |
| DT_SONAME = 14 |
| DT_MIPS_RLD_MAP_REL = 1879048245 |
| |
| # Global cache for tools |
| INSTALL_NAME_TOOL = False |
| |
| class DataSizes: |
| def __init__(self, ptrsize: int, is_le: bool) -> None: |
| if is_le: |
| p = '<' |
| else: |
| p = '>' |
| self.Half = p + 'h' |
| self.HalfSize = 2 |
| self.Word = p + 'I' |
| self.WordSize = 4 |
| self.Sword = p + 'i' |
| self.SwordSize = 4 |
| if ptrsize == 64: |
| self.Addr = p + 'Q' |
| self.AddrSize = 8 |
| self.Off = p + 'Q' |
| self.OffSize = 8 |
| self.XWord = p + 'Q' |
| self.XWordSize = 8 |
| self.Sxword = p + 'q' |
| self.SxwordSize = 8 |
| else: |
| self.Addr = p + 'I' |
| self.AddrSize = 4 |
| self.Off = p + 'I' |
| self.OffSize = 4 |
| |
| class DynamicEntry(DataSizes): |
| def __init__(self, ifile: T.BinaryIO, ptrsize: int, is_le: bool) -> None: |
| super().__init__(ptrsize, is_le) |
| self.ptrsize = ptrsize |
| if ptrsize == 64: |
| self.d_tag = struct.unpack(self.Sxword, ifile.read(self.SxwordSize))[0] |
| self.val = struct.unpack(self.XWord, ifile.read(self.XWordSize))[0] |
| else: |
| self.d_tag = struct.unpack(self.Sword, ifile.read(self.SwordSize))[0] |
| self.val = struct.unpack(self.Word, ifile.read(self.WordSize))[0] |
| |
| def write(self, ofile: T.BinaryIO) -> None: |
| if self.ptrsize == 64: |
| ofile.write(struct.pack(self.Sxword, self.d_tag)) |
| ofile.write(struct.pack(self.XWord, self.val)) |
| else: |
| ofile.write(struct.pack(self.Sword, self.d_tag)) |
| ofile.write(struct.pack(self.Word, self.val)) |
| |
| class SectionHeader(DataSizes): |
| def __init__(self, ifile: T.BinaryIO, ptrsize: int, is_le: bool) -> None: |
| super().__init__(ptrsize, is_le) |
| if ptrsize == 64: |
| is_64 = True |
| else: |
| is_64 = False |
| # Elf64_Word |
| self.sh_name = struct.unpack(self.Word, ifile.read(self.WordSize))[0] |
| # Elf64_Word |
| self.sh_type = struct.unpack(self.Word, ifile.read(self.WordSize))[0] |
| # Elf64_Xword |
| if is_64: |
| self.sh_flags = struct.unpack(self.XWord, ifile.read(self.XWordSize))[0] |
| else: |
| self.sh_flags = struct.unpack(self.Word, ifile.read(self.WordSize))[0] |
| # Elf64_Addr |
| self.sh_addr = struct.unpack(self.Addr, ifile.read(self.AddrSize))[0] |
| # Elf64_Off |
| self.sh_offset = struct.unpack(self.Off, ifile.read(self.OffSize))[0] |
| # Elf64_Xword |
| if is_64: |
| self.sh_size = struct.unpack(self.XWord, ifile.read(self.XWordSize))[0] |
| else: |
| self.sh_size = struct.unpack(self.Word, ifile.read(self.WordSize))[0] |
| # Elf64_Word |
| self.sh_link = struct.unpack(self.Word, ifile.read(self.WordSize))[0] |
| # Elf64_Word |
| self.sh_info = struct.unpack(self.Word, ifile.read(self.WordSize))[0] |
| # Elf64_Xword |
| if is_64: |
| self.sh_addralign = struct.unpack(self.XWord, ifile.read(self.XWordSize))[0] |
| else: |
| self.sh_addralign = struct.unpack(self.Word, ifile.read(self.WordSize))[0] |
| # Elf64_Xword |
| if is_64: |
| self.sh_entsize = struct.unpack(self.XWord, ifile.read(self.XWordSize))[0] |
| else: |
| self.sh_entsize = struct.unpack(self.Word, ifile.read(self.WordSize))[0] |
| |
| class Elf(DataSizes): |
| def __init__(self, bfile: str, verbose: bool = True) -> None: |
| self.bfile = bfile |
| self.verbose = verbose |
| self.sections = [] # type: T.List[SectionHeader] |
| self.dynamic = [] # type: T.List[DynamicEntry] |
| self.open_bf(bfile) |
| try: |
| (self.ptrsize, self.is_le) = self.detect_elf_type() |
| super().__init__(self.ptrsize, self.is_le) |
| self.parse_header() |
| self.parse_sections() |
| self.parse_dynamic() |
| except (struct.error, RuntimeError): |
| self.close_bf() |
| raise |
| |
| def open_bf(self, bfile: str) -> None: |
| self.bf = None |
| self.bf_perms = None |
| try: |
| self.bf = open(bfile, 'r+b') |
| except PermissionError as e: |
| self.bf_perms = stat.S_IMODE(os.lstat(bfile).st_mode) |
| os.chmod(bfile, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC) |
| try: |
| self.bf = open(bfile, 'r+b') |
| except Exception: |
| os.chmod(bfile, self.bf_perms) |
| self.bf_perms = None |
| raise e |
| |
| def close_bf(self) -> None: |
| if self.bf is not None: |
| if self.bf_perms is not None: |
| os.fchmod(self.bf.fileno(), self.bf_perms) |
| self.bf_perms = None |
| self.bf.close() |
| self.bf = None |
| |
| def __enter__(self) -> 'Elf': |
| return self |
| |
| def __del__(self) -> None: |
| self.close_bf() |
| |
| def __exit__(self, exc_type: T.Any, exc_value: T.Any, traceback: T.Any) -> None: |
| self.close_bf() |
| |
| def detect_elf_type(self) -> T.Tuple[int, bool]: |
| data = self.bf.read(6) |
| if data[1:4] != b'ELF': |
| # This script gets called to non-elf targets too |
| # so just ignore them. |
| if self.verbose: |
| print('File "%s" is not an ELF file.' % self.bfile) |
| sys.exit(0) |
| if data[4] == 1: |
| ptrsize = 32 |
| elif data[4] == 2: |
| ptrsize = 64 |
| else: |
| sys.exit('File "%s" has unknown ELF class.' % self.bfile) |
| if data[5] == 1: |
| is_le = True |
| elif data[5] == 2: |
| is_le = False |
| else: |
| sys.exit('File "%s" has unknown ELF endianness.' % self.bfile) |
| return ptrsize, is_le |
| |
| def parse_header(self) -> None: |
| self.bf.seek(0) |
| self.e_ident = struct.unpack('16s', self.bf.read(16))[0] |
| self.e_type = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0] |
| self.e_machine = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0] |
| self.e_version = struct.unpack(self.Word, self.bf.read(self.WordSize))[0] |
| self.e_entry = struct.unpack(self.Addr, self.bf.read(self.AddrSize))[0] |
| self.e_phoff = struct.unpack(self.Off, self.bf.read(self.OffSize))[0] |
| self.e_shoff = struct.unpack(self.Off, self.bf.read(self.OffSize))[0] |
| self.e_flags = struct.unpack(self.Word, self.bf.read(self.WordSize))[0] |
| self.e_ehsize = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0] |
| self.e_phentsize = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0] |
| self.e_phnum = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0] |
| self.e_shentsize = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0] |
| self.e_shnum = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0] |
| self.e_shstrndx = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0] |
| |
| def parse_sections(self) -> None: |
| self.bf.seek(self.e_shoff) |
| for _ in range(self.e_shnum): |
| self.sections.append(SectionHeader(self.bf, self.ptrsize, self.is_le)) |
| |
| def read_str(self) -> bytes: |
| arr = [] |
| x = self.bf.read(1) |
| while x != b'\0': |
| arr.append(x) |
| x = self.bf.read(1) |
| if x == b'': |
| raise RuntimeError('Tried to read past the end of the file') |
| return b''.join(arr) |
| |
| def find_section(self, target_name: bytes) -> T.Optional[SectionHeader]: |
| section_names = self.sections[self.e_shstrndx] |
| for i in self.sections: |
| self.bf.seek(section_names.sh_offset + i.sh_name) |
| name = self.read_str() |
| if name == target_name: |
| return i |
| return None |
| |
| def parse_dynamic(self) -> None: |
| sec = self.find_section(b'.dynamic') |
| if sec is None: |
| return |
| self.bf.seek(sec.sh_offset) |
| while True: |
| e = DynamicEntry(self.bf, self.ptrsize, self.is_le) |
| self.dynamic.append(e) |
| if e.d_tag == 0: |
| break |
| |
| def print_section_names(self) -> None: |
| section_names = self.sections[self.e_shstrndx] |
| for i in self.sections: |
| self.bf.seek(section_names.sh_offset + i.sh_name) |
| name = self.read_str() |
| print(name.decode()) |
| |
| def print_soname(self) -> None: |
| soname = None |
| strtab = None |
| for i in self.dynamic: |
| if i.d_tag == DT_SONAME: |
| soname = i |
| if i.d_tag == DT_STRTAB: |
| strtab = i |
| if soname is None or strtab is None: |
| print("This file does not have a soname") |
| return |
| self.bf.seek(strtab.val + soname.val) |
| print(self.read_str()) |
| |
| def get_entry_offset(self, entrynum: int) -> T.Optional[int]: |
| sec = self.find_section(b'.dynstr') |
| for i in self.dynamic: |
| if i.d_tag == entrynum: |
| res = sec.sh_offset + i.val |
| assert isinstance(res, int) |
| return res |
| return None |
| |
| def print_rpath(self) -> None: |
| offset = self.get_entry_offset(DT_RPATH) |
| if offset is None: |
| print("This file does not have an rpath.") |
| else: |
| self.bf.seek(offset) |
| print(self.read_str()) |
| |
| def print_runpath(self) -> None: |
| offset = self.get_entry_offset(DT_RUNPATH) |
| if offset is None: |
| print("This file does not have a runpath.") |
| else: |
| self.bf.seek(offset) |
| print(self.read_str()) |
| |
| def print_deps(self) -> None: |
| sec = self.find_section(b'.dynstr') |
| deps = [] |
| for i in self.dynamic: |
| if i.d_tag == DT_NEEDED: |
| deps.append(i) |
| for i in deps: |
| offset = sec.sh_offset + i.val |
| self.bf.seek(offset) |
| name = self.read_str() |
| print(name) |
| |
| def fix_deps(self, prefix: bytes) -> None: |
| sec = self.find_section(b'.dynstr') |
| deps = [] |
| for i in self.dynamic: |
| if i.d_tag == DT_NEEDED: |
| deps.append(i) |
| for i in deps: |
| offset = sec.sh_offset + i.val |
| self.bf.seek(offset) |
| name = self.read_str() |
| if name.startswith(prefix): |
| basename = name.split(b'/')[-1] |
| padding = b'\0' * (len(name) - len(basename)) |
| newname = basename + padding |
| assert len(newname) == len(name) |
| self.bf.seek(offset) |
| self.bf.write(newname) |
| |
| def fix_rpath(self, rpath_dirs_to_remove: T.Set[bytes], new_rpath: bytes) -> None: |
| # The path to search for can be either rpath or runpath. |
| # Fix both of them to be sure. |
| self.fix_rpathtype_entry(rpath_dirs_to_remove, new_rpath, DT_RPATH) |
| self.fix_rpathtype_entry(rpath_dirs_to_remove, new_rpath, DT_RUNPATH) |
| |
| def fix_rpathtype_entry(self, rpath_dirs_to_remove: T.Set[bytes], new_rpath: bytes, entrynum: int) -> None: |
| rp_off = self.get_entry_offset(entrynum) |
| if rp_off is None: |
| if self.verbose: |
| print('File does not have rpath. It should be a fully static executable.') |
| return |
| self.bf.seek(rp_off) |
| |
| old_rpath = self.read_str() |
| # Some rpath entries may come from multiple sources. |
| # Only add each one once. |
| new_rpaths = OrderedSet() # type: OrderedSet[bytes] |
| if new_rpath: |
| new_rpaths.update(new_rpath.split(b':')) |
| if old_rpath: |
| # Filter out build-only rpath entries |
| # added by get_link_dep_subdirs() or |
| # specified by user with build_rpath. |
| for rpath_dir in old_rpath.split(b':'): |
| if not (rpath_dir in rpath_dirs_to_remove or |
| rpath_dir == (b'X' * len(rpath_dir))): |
| if rpath_dir: |
| new_rpaths.add(rpath_dir) |
| |
| # Prepend user-specified new entries while preserving the ones that came from pkgconfig etc. |
| new_rpath = b':'.join(new_rpaths) |
| |
| if len(old_rpath) < len(new_rpath): |
| msg = "New rpath must not be longer than the old one.\n Old: {}\n New: {}".format(old_rpath.decode('utf-8'), new_rpath.decode('utf-8')) |
| sys.exit(msg) |
| # The linker does read-only string deduplication. If there is a |
| # string that shares a suffix with the rpath, they might get |
| # dedupped. This means changing the rpath string might break something |
| # completely unrelated. This has already happened once with X.org. |
| # Thus we want to keep this change as small as possible to minimize |
| # the chance of obliterating other strings. It might still happen |
| # but our behavior is identical to what chrpath does and it has |
| # been in use for ages so based on that this should be rare. |
| if not new_rpath: |
| self.remove_rpath_entry(entrynum) |
| else: |
| self.bf.seek(rp_off) |
| self.bf.write(new_rpath) |
| self.bf.write(b'\0') |
| |
| def remove_rpath_entry(self, entrynum: int) -> None: |
| sec = self.find_section(b'.dynamic') |
| if sec is None: |
| return None |
| for (i, entry) in enumerate(self.dynamic): |
| if entry.d_tag == entrynum: |
| rpentry = self.dynamic[i] |
| rpentry.d_tag = 0 |
| self.dynamic = self.dynamic[:i] + self.dynamic[i + 1:] + [rpentry] |
| break |
| # DT_MIPS_RLD_MAP_REL is relative to the offset of the tag. Adjust it consequently. |
| for entry in self.dynamic[i:]: |
| if entry.d_tag == DT_MIPS_RLD_MAP_REL: |
| entry.val += 2 * (self.ptrsize // 8) |
| break |
| self.bf.seek(sec.sh_offset) |
| for entry in self.dynamic: |
| entry.write(self.bf) |
| return None |
| |
| def fix_elf(fname: str, rpath_dirs_to_remove: T.Set[bytes], new_rpath: T.Optional[bytes], verbose: bool = True) -> None: |
| with Elf(fname, verbose) as e: |
| if new_rpath is None: |
| e.print_rpath() |
| e.print_runpath() |
| else: |
| e.fix_rpath(rpath_dirs_to_remove, new_rpath) |
| |
| def get_darwin_rpaths_to_remove(fname: str) -> T.List[str]: |
| out = subprocess.check_output(['otool', '-l', fname], |
| universal_newlines=True, |
| stderr=subprocess.DEVNULL) |
| result = [] |
| current_cmd = 'FOOBAR' |
| for line in out.split('\n'): |
| line = line.strip() |
| if ' ' not in line: |
| continue |
| key, value = line.strip().split(' ', 1) |
| if key == 'cmd': |
| current_cmd = value |
| if key == 'path' and current_cmd == 'LC_RPATH': |
| rp = value.split('(', 1)[0].strip() |
| result.append(rp) |
| return result |
| |
| def fix_darwin(fname: str, new_rpath: str, final_path: str, install_name_mappings: T.Dict[str, str]) -> None: |
| try: |
| rpaths = get_darwin_rpaths_to_remove(fname) |
| except subprocess.CalledProcessError: |
| # Otool failed, which happens when invoked on a |
| # non-executable target. Just return. |
| return |
| try: |
| args = [] |
| if rpaths: |
| # TODO: fix this properly, not totally clear how |
| # |
| # removing rpaths from binaries on macOS has tons of |
| # weird edge cases. For instance, if the user provided |
| # a '-Wl,-rpath' argument in LDFLAGS that happens to |
| # coincide with an rpath generated from a dependency, |
| # this would cause installation failures, as meson would |
| # generate install_name_tool calls with two identical |
| # '-delete_rpath' arguments, which install_name_tool |
| # fails on. Because meson itself ensures that it never |
| # adds duplicate rpaths, duplicate rpaths necessarily |
| # come from user variables. The idea of using OrderedSet |
| # is to remove *at most one* duplicate RPATH entry. This |
| # is not optimal, as it only respects the user's choice |
| # partially: if they provided a non-duplicate '-Wl,-rpath' |
| # argument, it gets removed, if they provided a duplicate |
| # one, it remains in the final binary. A potentially optimal |
| # solution would split all user '-Wl,-rpath' arguments from |
| # LDFLAGS, and later add them back with '-add_rpath'. |
| for rp in OrderedSet(rpaths): |
| args += ['-delete_rpath', rp] |
| subprocess.check_call(['install_name_tool', fname] + args, |
| stdout=subprocess.DEVNULL, |
| stderr=subprocess.DEVNULL) |
| args = [] |
| if new_rpath: |
| args += ['-add_rpath', new_rpath] |
| # Rewrite -install_name @rpath/libfoo.dylib to /path/to/libfoo.dylib |
| if fname.endswith('dylib'): |
| args += ['-id', final_path] |
| if install_name_mappings: |
| for old, new in install_name_mappings.items(): |
| args += ['-change', old, new] |
| if args: |
| subprocess.check_call(['install_name_tool', fname] + args, |
| stdout=subprocess.DEVNULL, |
| stderr=subprocess.DEVNULL) |
| except Exception as err: |
| raise SystemExit(err) |
| |
| def fix_jar(fname: str) -> None: |
| subprocess.check_call(['jar', 'xfv', fname, 'META-INF/MANIFEST.MF']) |
| with open('META-INF/MANIFEST.MF', 'r+', encoding='utf-8') as f: |
| lines = f.readlines() |
| f.seek(0) |
| for line in lines: |
| if not line.startswith('Class-Path:'): |
| f.write(line) |
| f.truncate() |
| subprocess.check_call(['jar', 'ufm', fname, 'META-INF/MANIFEST.MF']) |
| |
| def fix_rpath(fname: str, rpath_dirs_to_remove: T.Set[bytes], new_rpath: T.Union[str, bytes], final_path: str, install_name_mappings: T.Dict[str, str], verbose: bool = True) -> None: |
| global INSTALL_NAME_TOOL |
| # Static libraries, import libraries, debug information, headers, etc |
| # never have rpaths |
| # DLLs and EXE currently do not need runtime path fixing |
| if fname.endswith(('.a', '.lib', '.pdb', '.h', '.hpp', '.dll', '.exe')): |
| return |
| try: |
| if fname.endswith('.jar'): |
| fix_jar(fname) |
| return |
| if isinstance(new_rpath, str): |
| new_rpath = new_rpath.encode('utf8') |
| fix_elf(fname, rpath_dirs_to_remove, new_rpath, verbose) |
| return |
| except SystemExit as e: |
| if isinstance(e.code, int) and e.code == 0: |
| pass |
| else: |
| raise |
| # We don't look for this on import because it will do a useless PATH lookup |
| # on non-mac platforms. That can be expensive on some Windows machines |
| # (up to 30ms), which is significant with --only-changed. For details, see: |
| # https://github.com/mesonbuild/meson/pull/6612#discussion_r378581401 |
| if INSTALL_NAME_TOOL is False: |
| INSTALL_NAME_TOOL = bool(shutil.which('install_name_tool')) |
| if INSTALL_NAME_TOOL: |
| if isinstance(new_rpath, bytes): |
| new_rpath = new_rpath.decode('utf8') |
| fix_darwin(fname, new_rpath, final_path, install_name_mappings) |
