#!/usr/bin/env python # PYTHON_ARGCOMPLETE_OK # Copyright 2012-2014 Gentoo Foundation # Copyright 2012-2014 Mike Frysinger # Copyright 2012-2014 The ChromiumOS Authors # Use of this source code is governed by a BSD-style license (BSD-3) """Read the ELF dependency tree and show it This does not work like `ldd` in that we do not execute/load code (only read files on disk), and we show the ELFs as a tree rather than a flat list. Paths may be globs that lddtree will take care of expanding. Useful when you want to glob a path under the ROOT path. When using the --root option, all paths are implicitly prefixed by that. e.g. lddtree -R /my/magic/root /bin/bash This will load up the ELF found at /my/magic/root/bin/bash and then resolve all libraries via that path. If you wish to actually read /bin/bash (and so use the ROOT path as an alternative library tree), you can specify the --no-auto-root option. When pairing --root with --copy-to-tree, the ROOT path will be stripped. e.g. lddtree -R /my/magic/root --copy-to-tree /foo /bin/bash You will see /foo/bin/bash and /foo/lib/libc.so.6 and not paths like /foo/my/magic/root/bin/bash. If you want that, you'll have to manually add the ROOT path to the output path. The --bindir and --libdir flags are used to normalize the output subdirs when used with --copy-to-tree. e.g. lddtree --copy-to-tree /foo /bin/bash /usr/sbin/lspci /usr/bin/lsof This will mirror the input paths in the output. So you will end up with /foo/bin/bash and /foo/usr/sbin/lspci and /foo/usr/bin/lsof. Similarly, the libraries needed will be scattered among /foo/lib/ and /foo/usr/lib/ and perhaps other paths (like /foo/lib64/ and /usr/lib/gcc/...). You can collapse all that down into nice directory structure. e.g. lddtree --copy-to-tree /foo /bin/bash /usr/sbin/lspci /usr/bin/lsof \\ --bindir /bin --libdir /lib This will place bash, lspci, and lsof into /foo/bin/. All the libraries they need will be placed into /foo/lib/ only. """ import argparse import errno import functools import glob import mmap import os import re import shutil import sys from typing import Any, cast, Iterable, Optional, Union assert sys.version_info >= (3, 6), f"Python 3.6+ required, but found {sys.version}" try: import argcomplete except ImportError: argcomplete = cast(Any, None) from elftools.common import exceptions from elftools.elf.elffile import ELFFile def warn(msg: Any, prefix: Optional[str] = "warning") -> None: """Write |msg| to stderr with a |prefix| before it""" print(f"{os.path.basename(sys.argv[0])}: {prefix}: {msg}", file=sys.stderr) def err(msg: Any, status: Optional[int] = 1) -> None: """Write |msg| to stderr and exit with |status|""" warn(msg, prefix="error") sys.exit(status) def dbg(debug: bool, *args, **kwargs) -> None: """Pass |args| and |kwargs| to print() when |debug| is True""" if debug: print(*args, **kwargs) def bstr(buf: Union[bytes, str]) -> str: """Decode the byte string into a string""" if isinstance(buf, str): return buf return buf.decode("utf-8") def normpath(path: str) -> str: """Normalize a path Python's os.path.normpath() doesn't handle some cases: // -> // //..// -> // //..//..// -> /// """ return os.path.normpath(path).replace("//", "/") @functools.lru_cache(maxsize=None) def readlink(path: str, root: str, prefixed: Optional[bool] = False) -> str: """Like os.readlink(), but relative to a |root| This does not currently handle the pathological case: /lib/foo.so -> ../../../../../../../foo.so This relies on the .. entries in / to point to itself. Args: path: The symlink to read root: The path to use for resolving absolute symlinks prefixed: When False, the |path| must not have |root| prefixed to it, nor will the return value have |root| prefixed. When True, |path| must have |root| prefixed, and the return value will have |root| added. Returns: A fully resolved symlink path """ root = root.rstrip("/") if prefixed: path = path[len(root) :] while os.path.islink(root + path): path = os.path.join(os.path.dirname(path), os.readlink(root + path)) return normpath((root + path) if prefixed else path) def dedupe(items: list[str]) -> list[str]: """Remove all duplicates from |items| (keeping order)""" seen: dict[str, str] = {} return [seen.setdefault(x, x) for x in items if x not in seen] @functools.lru_cache(maxsize=None) def interp_supports_argv0(interp: str) -> bool: """See whether |interp| supports the --argv0 option. Starting with glibc-2.33, the ldso supports --argv0 to override argv[0]. """ with open(interp, "rb") as fp: with mmap.mmap(fp.fileno(), 0, prot=mmap.PROT_READ) as mm: return mm.find(b"--argv0") >= 0 def GenerateLdsoWrapper( root: str, path: str, interp: str, libpaths: Iterable[str] = (), preload: Optional[str] = None, ) -> None: """Generate a shell script wrapper which uses local ldso to run the ELF Since we cannot rely on the host glibc (or other libraries), we need to execute the local packaged ldso directly and tell it where to find our copies of libraries. Args: root: The root tree to generate scripts inside of path: The full path (inside |root|) to the program to wrap interp: The ldso interpreter that we need to execute libpaths: Extra lib paths to search for libraries """ basedir = os.path.dirname(path) interp_dir, interp_name = os.path.split(interp) # Add ldso interpreter dir to end of libpaths as a fallback library path. libpaths = dedupe(list(libpaths) + [interp_dir]) if preload: # If preload is an absolute path, calculate it from basedir. preload_prefix = f'${{basedir}}/{os.path.relpath("/", basedir)}' preload = ":".join( f"{preload_prefix}{x}" if os.path.isabs(x) else x for x in re.split(r"[ :]", preload) ) replacements = { "interp": os.path.join(os.path.relpath(interp_dir, basedir), interp_name), "libpaths": ":".join( "${basedir}/" + os.path.relpath(p, basedir) for p in libpaths ), "argv0_arg": '--argv0 "$0"' if interp_supports_argv0(root + interp) else "", "preload_arg": f'--preload "{preload}"' if preload else "", } wrapper = """#!/bin/sh if ! base=$(realpath "$0" 2>/dev/null); then case $0 in /*) base=$0;; *) base=${PWD:-`pwd`}/$0;; esac fi basedir=${base%%/*} exec \\ "${basedir}/%(interp)s" \\ %(argv0_arg)s \\ %(preload_arg)s \\ --library-path "%(libpaths)s" \\ --inhibit-cache \\ --inhibit-rpath '' \\ "${base}.elf" \\ "$@" """ wrappath = root + path os.rename(wrappath, wrappath + ".elf") with open(wrappath, "w", encoding="utf-8") as f: f.write(wrapper % replacements) os.chmod(wrappath, 0o0755) @functools.lru_cache(maxsize=None) def ParseLdPaths( str_ldpaths: str, root: str = "", cwd: Optional[str] = None, path: str = "", ) -> list[str]: """Parse the colon-delimited list of paths and apply ldso rules to each Note the special handling as dictated by the ldso: - Empty paths are equivalent to $PWD - $ORIGIN is expanded to the path of the given file - (TODO) $LIB and friends Args: str_ldpaths: A colon-delimited string of paths root: The path to prepend to all paths found cwd: The path to resolve relative paths against (defaults to getcwd()). path: The object actively being parsed (used for $ORIGIN) Returns: list of processed paths """ if cwd is None: cwd = os.getcwd() ldpaths = [] for ldpath in str_ldpaths.split(":"): # Expand placeholders first. if "$ORIGIN" in ldpath: ldpath = ldpath.replace("$ORIGIN", os.path.dirname(path)) elif "${ORIGIN}" in ldpath: ldpath = ldpath.replace("${ORIGIN}", os.path.dirname(path)) # Expand relative paths if needed. These don't make sense in general, # but that doesn't stop people from using them. As such, root prefix # doesn't make sense with it either. if not ldpath.startswith("/"): # NB: The ldso treats "" paths as cwd too. ldpath = os.path.join(cwd, ldpath) else: ldpath = root + ldpath ldpaths.append(normpath(ldpath)) return dedupe(ldpaths) def ParseLdSoConf( ldso_conf: str, root: str = "/", debug: bool = False, _first: bool = True, ) -> list[str]: """Load all the paths from a given ldso config file This should handle comments, whitespace, and "include" statements. Args: ldso_conf: The file to scan root: The path to prepend to all paths found debug: Enable debug output _first: Recursive use only; is this the first ELF ? Returns: list of paths found """ paths = [] dbg_pfx = "" if _first else " " try: dbg(debug, f"{dbg_pfx}ParseLdSoConf({ldso_conf})") with open(ldso_conf, encoding="utf-8") as f: for line in f.readlines(): line = line.split("#", 1)[0].strip() if not line: continue if line.startswith("include "): line = line[8:] if line[0] == "/": line = root + line.lstrip("/") else: line = os.path.dirname(ldso_conf) + "/" + line dbg(debug, dbg_pfx, "glob:", line) # ldconfig in glibc uses glob() which returns entries sorted according # to LC_COLLATE. Further, ldconfig does not reset that but respects # the active env settings (which might be a mistake). Python does not # sort its results by default though, so do it ourselves. for path in sorted(glob.glob(line)): paths += ParseLdSoConf( path, root=root, debug=debug, _first=False ) else: paths += [normpath(root + line)] except IOError as e: if e.errno != errno.ENOENT: warn(e) if _first: # XXX: Load paths from ldso itself. # Remove duplicate entries to speed things up. paths = dedupe(paths) return paths def LoadLdpaths( root: str = "/", cwd: Optional[str] = None, prefix: str = "", debug: bool = False, ) -> dict[str, list[str]]: """Load linker paths from common locations This parses the ld.so.conf and LD_LIBRARY_PATH env var. Args: root: The root tree to prepend to paths cwd: The path to resolve relative paths against prefix: The path under |root| to search debug: Enable debug output Returns: dict containing library paths to search """ ldpaths: dict[str, list[str]] = { "conf": [], "env": [], "interp": [], } # Load up $LD_LIBRARY_PATH. ldpaths["env"] = [] env_ldpath = os.environ.get("LD_LIBRARY_PATH") if not env_ldpath is None: if root != "/": warn("ignoring LD_LIBRARY_PATH due to ROOT usage") else: # XXX: If this contains $ORIGIN, we probably have to parse this # on a per-ELF basis so it can get turned into the right thing. ldpaths["env"] = ParseLdPaths(env_ldpath, cwd=cwd, path="") # Load up /etc/ld.so.conf. ldpaths["conf"] = ParseLdSoConf( root + prefix + "/etc/ld.so.conf", root=root, debug=debug ) return ldpaths def CompatibleELFs(elf1: ELFFile, elf2: ELFFile) -> bool: """See if two ELFs are compatible This compares the aspects of the ELF to see if they're compatible: bit size, endianness, machine type, and operating system. Args: elf1: an ELFFile object elf2: an ELFFile object Returns: True if compatible, False otherwise """ osabis = frozenset([e.header["e_ident"]["EI_OSABI"] for e in (elf1, elf2)]) compat_sets = ( frozenset(f"ELFOSABI_{x}" for x in ("NONE", "SYSV", "GNU", "LINUX")), ) return ( (len(osabis) == 1 or any(osabis.issubset(x) for x in compat_sets)) and elf1.elfclass == elf2.elfclass and elf1.little_endian == elf2.little_endian and elf1.header["e_machine"] == elf2.header["e_machine"] ) def FindLib( elf: ELFFile, lib: str, ldpaths: list[str], root: str = "/", debug: bool = False, ) -> tuple[Optional[str], Optional[str]]: """Try to locate a |lib| that is compatible to |elf| in the given |ldpaths| Args: elf: The elf which the library should be compatible with (ELF wise) lib: The library (basename) to search for ldpaths: A list of paths to search root: The root path to resolve symlinks debug: Enable debug output Returns: Tuple of the full path to the desired library and the real path to it """ dbg(debug, f" FindLib({lib})") for ldpath in ldpaths: path = os.path.join(ldpath, lib) target = readlink(path, root, prefixed=True) if path != target: dbg(debug, " checking:", path, "->", target) else: dbg(debug, " checking:", path) if os.path.exists(target): with open(target, "rb") as f: try: libelf = ELFFile(f) if CompatibleELFs(elf, libelf): return (target, path) except exceptions.ELFError as e: warn(f"{target}: {e}") return (None, None) # We abuse the _all_libs state. We probably shouldn't, but we do currently. # pylint: disable=dangerous-default-value def ParseELF( path: str, root: str = "/", cwd: Optional[str] = None, prefix: str = "", ldpaths={"conf": [], "env": [], "interp": []}, display: Optional[str] = None, debug: bool = False, _first: bool = True, _all_libs={}, ) -> dict[str, Any]: """Parse the ELF dependency tree of the specified file Args: path: The ELF to scan root: The root tree to prepend to paths; this applies to interp and rpaths only as |path| and |ldpaths| are expected to be prefixed already cwd: The path to resolve relative paths against. prefix: The path under |root| to search ldpaths: dict containing library paths to search; should have the keys: conf, env, interp display: The path to show rather than |path| debug: Enable debug output _first: Recursive use only; is this the first ELF ? _all_libs: Recursive use only; dict of all libs we've seen Returns: a dict containing information about all the ELFs; e.g. { 'interp': '/lib64/ld-linux.so.2', 'needed': ['libc.so.6', 'libcurl.so.4',], 'libs': { 'libc.so.6': { 'path': '/lib64/libc.so.6', 'needed': [], }, 'libcurl.so.4': { 'path': '/usr/lib64/libcurl.so.4', 'needed': ['libc.so.6', 'librt.so.1',], }, }, } """ if _first: _all_libs = {} ldpaths = ldpaths.copy() ret = { "interp": None, "path": path if display is None else display, "realpath": path, "needed": [], "rpath": [], "runpath": [], "libs": _all_libs, } dbg(debug, f"ParseELF({path})") with open(path, "rb") as f: try: elf = ELFFile(f) except exceptions.ELFParseError: warn("ELFParser failed to parse", path) raise # If this is the first ELF, extract the interpreter. if _first: for segment in elf.iter_segments(): if segment.header.p_type != "PT_INTERP": continue interp = bstr(segment.get_interp_name()) dbg(debug, " interp =", interp) ret["interp"] = normpath(root + interp) real_interp = readlink(ret["interp"], root, prefixed=True) ret["libs"][os.path.basename(interp)] = { "path": ret["interp"], "realpath": real_interp, "needed": [], } # XXX: Could read it and scan for /lib paths. # If the interp is a symlink, lets follow it on the assumption that it # is in this path purely for ABI reasons, and the distro is using a # different (probably more correct) path. This can come up in some # multilib situations like s390x where /lib64/ contains all the native # libraries, but /lib/ld64.so.1 is the interp hardcoded in gcc, so the # ld64.so.1 is really a symlink to ../lib64/ld64.so.1. In the multiarch # setup, it'll be /lib/ld64.so.1 -> /lib/s390x-linux-gnu/ld64.so.1. # That is why we use |real_interp| here instead of |interp|. ldpaths["interp"] = [ os.path.dirname(real_interp), normpath( root + prefix + "/usr/" + os.path.dirname(real_interp)[len(root) + len(prefix) :] ), ] dbg(debug, " ldpaths[interp] =", ldpaths["interp"]) break # Parse the ELF's dynamic tags. libs = [] rpaths = [] runpaths = [] for segment in elf.iter_segments(): if segment.header.p_type != "PT_DYNAMIC": continue for t in segment.iter_tags(): if t.entry.d_tag == "DT_RPATH": rpaths = ParseLdPaths(bstr(t.rpath), root=root, cwd=cwd, path=path) elif t.entry.d_tag == "DT_RUNPATH": runpaths = ParseLdPaths( bstr(t.runpath), root=root, cwd=cwd, path=path ) elif t.entry.d_tag == "DT_NEEDED": libs.append(bstr(t.needed)) if runpaths: # If both RPATH and RUNPATH are set, only the latter is used. rpaths = [] # XXX: We assume there is only one PT_DYNAMIC. This is # probably fine since the runtime ldso does the same. break if _first: # Propagate the rpaths used by the main ELF since those will be # used at runtime to locate things. ldpaths["rpath"] = rpaths ldpaths["runpath"] = runpaths dbg(debug, " ldpaths[rpath] =", rpaths) dbg(debug, " ldpaths[runpath] =", runpaths) ret["rpath"] = rpaths ret["runpath"] = runpaths ret["needed"] = libs # Search for the libs this ELF uses. all_ldpaths = None for lib in libs: if lib in _all_libs: continue if all_ldpaths is None: all_ldpaths = ( rpaths + ldpaths["rpath"] + ldpaths["env"] + runpaths + ldpaths["runpath"] + ldpaths["conf"] + ldpaths["interp"] ) realpath, fullpath = FindLib(elf, lib, all_ldpaths, root, debug=debug) _all_libs[lib] = { "realpath": realpath, "path": fullpath, "needed": [], } if realpath is not None: try: lret = ParseELF( realpath, root, cwd, prefix, ldpaths, display=fullpath, debug=debug, _first=False, _all_libs=_all_libs, ) except exceptions.ELFError as e: warn(f"{realpath}: {e}") _all_libs[lib]["needed"] = lret["needed"] del elf return ret # pylint: enable=dangerous-default-value class _NormalizePathAction(argparse.Action): """Argparse action to normalize paths.""" def __call__(self, parser, namespace, values, option_string=None): setattr(namespace, self.dest, normpath(values)) def _ActionShow(options: argparse.Namespace, elf: dict): """Show the dependency tree for this ELF""" def _show(lib, depth): chain_libs.append(lib) fullpath = elf["libs"][lib]["path"] if options.list: print(fullpath or lib) else: indent = " " * depth print(f"{indent}{lib}", "=>", fullpath) new_libs = [] for nlib in elf["libs"][lib]["needed"]: if nlib in chain_libs: if not options.list: print(f"{indent}{nlib} => !!! circular loop !!!") continue if options.all or not nlib in shown_libs: shown_libs.add(nlib) new_libs.append(nlib) for nlib in new_libs: _show(nlib, depth + 1) chain_libs.pop() shown_libs = set(elf["needed"]) new_libs = elf["needed"][:] chain_libs: list[str] = [] interp = elf["interp"] if interp: lib = os.path.basename(interp) shown_libs.add(lib) # If we are in non-list mode, then we want to show the "duplicate" interp # lines -- first the header (interp=>xxx), and then the DT_NEEDED line to # show that the ELF is directly linked against the interp. # If we're in list mode though, we only want to show the interp once. # Unless of course we have the --all flag active, then we show everything. if not options.all and options.list and lib in new_libs: new_libs.remove(lib) if options.list: print(elf["path"]) if not interp is None: print(interp) else: print(elf["path"], f"(interpreter => {interp})") for lib in new_libs: _show(lib, 1) def _ActionCopy(options: argparse.Namespace, elf: dict): """Copy the ELF and its dependencies to a destination tree""" def _StripRoot(path: str) -> str: return path[len(options.root) - 1 :] def _copy( realsrc, src, striproot=True, wrapit=False, libpaths=(), outdir=None, preload=None, ): if realsrc is None: return if wrapit: # Static ELFs don't need to be wrapped. if not elf["interp"]: wrapit = False striproot = _StripRoot if striproot else lambda x: x if outdir: subdst = os.path.join(outdir, os.path.basename(src)) else: subdst = striproot(src) dst = options.dest + subdst try: # See if they're the same file. nstat = os.stat(dst + (".elf" if wrapit else "")) ostat = os.stat(realsrc) for field in ("mode", "mtime", "size"): if getattr(ostat, "st_" + field) != getattr(nstat, "st_" + field): break else: return except OSError as e: if e.errno != errno.ENOENT: raise if options.verbose: print(src, "->", dst) os.makedirs(os.path.dirname(dst), exist_ok=True) try: shutil.copy2(realsrc, dst) except FileNotFoundError as e: warn(f'{elf["path"]}: {e}') return except IOError: try: os.unlink(dst) except FileNotFoundError: pass shutil.copy2(realsrc, dst) if wrapit: if options.verbose: print("generate wrapper", dst) if options.libdir: interp = os.path.join(options.libdir, os.path.basename(elf["interp"])) else: interp = _StripRoot(elf["interp"]) GenerateLdsoWrapper(options.dest, subdst, interp, libpaths, preload) # XXX: We should automatically import libgcc_s.so whenever libpthread.so # is copied over (since we know it can be dlopen-ed by NPTL at runtime). # Similarly, we should provide an option for automatically copying over # the libnsl.so and libnss_*.so libraries, as well as an open ended list # for known libs that get loaded (e.g. curl will dlopen(libresolv)). uniq_libpaths = set() for lib in elf["libs"]: libdata = elf["libs"][lib] path = libdata["realpath"] if path is None: warn("could not locate library:", lib) continue if not options.libdir: uniq_libpaths.add(_StripRoot(os.path.dirname(path))) _copy(path, libdata["path"], outdir=options.libdir) if not options.libdir: libpaths = list(uniq_libpaths) if elf["runpath"]: libpaths = elf["runpath"] + libpaths else: libpaths = elf["rpath"] + libpaths else: uniq_libpaths.add(options.libdir) libpaths = list(uniq_libpaths) # We don't bother to copy this as ParseElf adds the interp to the 'libs', # so it was already copied in the libs loop above. # _copy(elf['interp'], outdir=options.libdir) _copy( elf["realpath"], elf["path"], striproot=options.auto_root, wrapit=options.generate_wrappers, libpaths=libpaths, outdir=options.bindir, preload=options.wrapper_preload, ) def GetParser() -> argparse.ArgumentParser: """Get a CLI parser.""" parser = argparse.ArgumentParser( description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter ) parser.add_argument( "-a", "--all", action="store_true", default=False, help="Show all duplicated dependencies", ) parser.add_argument( "-l", "--list", action="store_true", default=False, help="Display output in a simple list (easy for copying)", ) parser.add_argument( "-x", "--debug", action="store_true", default=False, help="Run with debugging" ) parser.add_argument( "-v", "--verbose", action="store_true", default=False, help="Be verbose" ) parser.add_argument( "--skip-non-elfs", action="store_true", default=False, help="Skip plain (non-ELF) files instead of warning", ) parser.add_argument( "--skip-missing", action="store_true", default=False, help="Skip missing files instead of failing", ) parser.add_argument( "-V", "--version", action="version", version="lddtree by Mike Frysinger ", help="Show version information", ) parser.add_argument("path", nargs="+") group = parser.add_argument_group("Path options") group.add_argument( "-R", "--root", default=os.environ.get("ROOT", ""), type=str, action=_NormalizePathAction, help="Search for all files/dependencies in ROOT", ) group.add_argument( "--no-auto-root", dest="auto_root", action="store_false", default=True, help="Do not automatically prefix input ELFs with ROOT", ) group.add_argument( "-C", "--cwd", default=os.getcwd(), type=str, action=_NormalizePathAction, help="Path to resolve relative paths against", ) group.add_argument( "-P", "--prefix", default=os.environ.get("EPREFIX", "@GENTOO_PORTAGE_EPREFIX@"), type=str, action=_NormalizePathAction, help="Specify EPREFIX for binaries (for Gentoo Prefix)", ) group = parser.add_argument_group("Copying options") group.add_argument( "--copy-to-tree", dest="dest", default=None, type=str, action=_NormalizePathAction, help="Copy all files to the specified tree", ) group.add_argument( "--bindir", default=None, type=str, action=_NormalizePathAction, help="Dir to store all ELFs specified on the command line", ) group.add_argument( "--libdir", default=None, type=str, action=_NormalizePathAction, help="Dir to store all ELF libs", ) group.add_argument( "--generate-wrappers", action="store_true", default=False, help="Wrap executable ELFs with scripts for local ldso", ) group.add_argument( "--copy-non-elfs", action="store_true", default=False, help="Copy over plain (non-ELF) files instead of warn+ignore", ) group.add_argument( "--wrapper-preload", default=None, type=str, help="Have wrapper add --preload to the ldso invocation", ) if argcomplete is not None: argcomplete.autocomplete(parser) return parser def main(argv: list[str]) -> Optional[int]: """The main entry point!""" parser = GetParser() options = parser.parse_args(argv) paths = options.path if options.root != "/": options.root += "/" if options.prefix == "@" "GENTOO_PORTAGE_EPREFIX" "@": options.prefix = "" if options.bindir and options.bindir[0] != "/": parser.error("--bindir accepts absolute paths only") if options.libdir and options.libdir[0] != "/": parser.error("--libdir accepts absolute paths only") if options.skip_non_elfs and options.copy_non_elfs: parser.error("pick one handler for non-ELFs: skip or copy") dbg(options.debug, "root =", options.root) dbg(options.debug, "cwd =", options.cwd) if options.dest: dbg(options.debug, "dest =", options.dest) if not paths: err("missing ELF files to scan") ldpaths = LoadLdpaths( options.root, cwd=options.cwd, prefix=options.prefix, debug=options.debug ) dbg(options.debug, "ldpaths[conf] =", ldpaths["conf"]) dbg(options.debug, "ldpaths[env] =", ldpaths["env"]) # Process all the files specified. ret = 0 for path in paths: dbg(options.debug, "argv[x] =", path) # Only auto-prefix the path if the ELF is absolute. # If it's a relative path, the user most likely wants # the local path. if options.auto_root and path.startswith("/"): path = options.root + path.lstrip("/") dbg(options.debug, " +auto-root =", path) matched = False for p in glob.iglob(path): # Once we've processed the globs, resolve the symlink. This way you can # operate on a path that is an absolute symlink itself. e.g.: # $ ln -sf /bin/bash $PWD/root/bin/sh # $ lddtree --root $PWD/root /bin/sh # First we'd turn /bin/sh into $PWD/root/bin/sh, then we want to resolve # the symlink to $PWD/root/bin/bash rather than a plain /bin/bash. dbg(options.debug, " globbed =", p) if not path.startswith("/"): realpath = os.path.realpath(path) elif options.auto_root: realpath = readlink(p, options.root, prefixed=True) else: realpath = path if path != realpath: dbg(options.debug, " resolved =", realpath) matched = True try: elf = ParseELF( realpath, options.root, options.cwd, options.prefix, ldpaths, display=p, debug=options.debug, ) except exceptions.ELFError as e: if options.skip_non_elfs: continue # XXX: Ugly. Should unify with _Action* somehow. if options.dest is not None and options.copy_non_elfs: if os.path.exists(p): elf = { "interp": None, "libs": [], "runpath": [], "rpath": [], "path": p, "realpath": realpath, } _ActionCopy(options, elf) continue ret = 1 warn(f"{p}: {e}") continue except IOError as e: ret = 1 warn(f"{p}: {e}") continue if options.dest is None: _ActionShow(options, elf) else: _ActionCopy(options, elf) if not matched: if not options.skip_missing: ret = 1 warn(f"{path}: did not match any paths") return ret if __name__ == "__main__": sys.exit(main(sys.argv[1:]))