blob: 40e38e75fe06cf261b8bf55ebfcf49a7aeaabeb0 [file] [log] [blame]
# Copyright 2012-2014 Gentoo Foundation
# Copyright 2012-2014 Mike Frysinger <>
# Copyright 2012-2014 The Chromium OS Authors
# Use of this source code is governed by a BSD-style license (BSD-3)
# pylint: disable=C0301
# $Header: /var/cvsroot/gentoo-projects/pax-utils/,v 1.53 2014/08/01 02:20:20 vapier Exp $
"""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 should the ELFs as a tree rather than a flat list.
from __future__ import print_function
import glob
import errno
import optparse
import os
import shutil
import sys
from elftools.elf.elffile import ELFFile
from elftools.common import exceptions
def warn(msg, prefix='warning'):
"""Write |msg| to stderr with a |prefix| before it"""
print('%s: %s: %s' % (os.path.basename(sys.argv[0]), prefix, msg), file=sys.stderr)
def err(msg, status=1):
"""Write |msg| to stderr and exit with |status|"""
warn(msg, prefix='error')
def dbg(debug, *args, **kwargs):
"""Pass |args| and |kwargs| to print() when |debug| is True"""
if debug:
print(*args, **kwargs)
def bstr(buf):
"""Decode the byte string into a string"""
return buf.decode('utf-8')
def normpath(path):
"""Normalize a path
Python's os.path.normpath() doesn't handle some cases:
// -> //
//..// -> //
//..//..// -> ///
return os.path.normpath(path).replace('//', '/')
def readlink(path, root, prefixed=False):
"""Like os.readlink(), but relative to a |root|
This does not currently handle the pathological case:
/lib/ -> ../../../../../../../
This relies on the .. entries in / to point to itself.
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|
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 makedirs(path):
"""Like os.makedirs(), but ignore EEXIST errors"""
except OSError as e:
if e.errno != os.errno.EEXIST:
def dedupe(items):
"""Remove all duplicates from |items| (keeping order)"""
seen = {}
return [seen.setdefault(x, x) for x in items if x not in seen]
def GenerateLdsoWrapper(root, path, interp, libpaths=(), elfsubdir=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.
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
elfsubdir: The sub-directory where the original ELF file lives. If not
provided, a '.elf' suffix will be added to the original file
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])
replacements = {
'interp': os.path.join(os.path.relpath(interp_dir, basedir),
'interp_rel': os.path.relpath(path, interp_dir),
'libpaths': ':'.join(['${basedir}/' + os.path.relpath(p, basedir)
for p in libpaths]),
wrappath = root + path
if elfsubdir:
elf_wrap_dir = os.path.join(os.path.dirname(wrappath), elfsubdir)
elf_wrappath = os.path.join(elf_wrap_dir, os.path.basename(wrappath))
replacements['elf_path'] = '${basedir}/%s/%s' % (elfsubdir,
elf_wrappath = wrappath + '.elf'
replacements['elf_path'] = '${base}.elf'
# Keep path relativeness of argv0. This allows to remove absolute path from
# build output and leads directory independent cache sharing in distributed
# build system.
wrapper = """#!/bin/sh
if base=$(readlink "$0" 2>/dev/null); then
case $base in
/*) base=$(readlink -f "$0" 2>/dev/null);; # if $0 is abspath symlink, make symlink fully resolved.
*) base=$(dirname "$0")/"${base}";;
case $0 in
/*) base=$0;;
*) base=${PWD:-`pwd`}/$0;;
# TODO(crbug/1003841): Remove LD_ARGV0 once
# supports forwarding the binary name.
LD_ARGV0="$0" LD_ARGV0_REL="%(interp_rel)s" exec \
"${basedir}/%(interp)s" \
--library-path "%(libpaths)s" \
--inhibit-rpath '' \
"%(elf_path)s" \
os.rename(wrappath, elf_wrappath)
with open(wrappath, 'w') as f:
f.write(wrapper % replacements)
os.chmod(wrappath, 0o0755)
def ParseLdPaths(str_ldpaths, root='', path=None):
"""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
str_ldpaths: A colon-delimited string of paths
root: The path to prepend to all paths found
path: The object actively being parsed (used for $ORIGIN)
list of processed paths
ldpaths = []
for ldpath in str_ldpaths.split(':'):
if ldpath == '':
# The ldso treats "" paths as $PWD.
ldpath = os.getcwd()
elif '$ORIGIN' in ldpath:
ldpath = ldpath.replace('$ORIGIN', os.path.dirname(path))
ldpath = root + ldpath
return dedupe(ldpaths)
def ParseLdSoConf(ldso_conf, root='/', _first=True):
"""Load all the paths from a given ldso config file
This should handle comments, whitespace, and "include" statements.
ldso_conf: The file to scan
root: The path to prepend to all paths found
_first: Recursive use only; is this the first ELF ?
list of paths found
paths = []
with open(ldso_conf) as f:
for line in f.readlines():
line = line.split('#', 1)[0].strip()
if not line:
if line.startswith('include '):
line = line[8:]
if line[0] == '/':
line = root + line.lstrip('/')
line = os.path.dirname(ldso_conf) + '/' + line
for path in glob.glob(line):
paths += ParseLdSoConf(path, root=root, _first=False)
paths += [normpath(root + line)]
except IOError as e:
if e.errno != errno.ENOENT:
if _first:
# XXX: Load paths from ldso itself.
# Remove duplicate entries to speed things up.
paths = dedupe(paths)
return paths
def LoadLdpaths(root='/', prefix=''):
"""Load linker paths from common locations
This parses the and LD_LIBRARY_PATH env var.
root: The root tree to prepend to paths
prefix: The path under |root| to search
dict containing library paths to search
ldpaths = {
'conf': [],
'env': [],
'interp': [],
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')
# 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, path='')
# Load up /etc/
ldpaths['conf'] = ParseLdSoConf(root + prefix + '/etc/', root=root)
return ldpaths
def CompatibleELFs(elf1, elf2):
"""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.
elf1: an ELFFile object
elf2: an ELFFile object
True if compatible, False otherwise
osabis = frozenset([e.header['e_ident']['EI_OSABI'] for e in (elf1, elf2)])
compat_sets = (
frozenset('ELFOSABI_%s' % 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, lib, ldpaths, root='/', debug=False):
"""Try to locate a |lib| that is compatible to |elf| in the given |ldpaths|
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
Tuple of the full path to the desired library and the real path to it
dbg(debug, ' FindLib(%s)' % lib)
for ldpath in ldpaths:
path = os.path.join(ldpath, lib)
target = readlink(path, root, prefixed=True)
if path != target:
dbg(debug, ' checking: %s -> %s' % (path, target))
dbg(debug, ' checking:', path)
if os.path.exists(target):
with open(target, 'rb') as f:
libelf = ELFFile(f)
if CompatibleELFs(elf, libelf):
return (target, path)
return (None, None)
def ParseELF(path, root='/', prefix='', ldpaths={'conf':[], 'env':[], 'interp':[]},
display=None, debug=False, _first=True, _all_libs={}):
"""Parse the ELF dependency tree of the specified file
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
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
a dict containing information about all the ELFs; e.g.
'interp': '/lib64/',
'needed': ['', '',],
'libs': {
'': {
'path': '/lib64/',
'needed': [],
'': {
'path': '/usr/lib64/',
'needed': ['', '',],
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, 'ParseELF(%s)' % path)
with open(path, 'rb') as f:
elf = ELFFile(f)
# If this is the first ELF, extract the interpreter.
if _first:
for segment in elf.iter_segments():
if segment.header.p_type != 'PT_INTERP':
interp = bstr(segment.get_interp_name())
dbg(debug, ' interp =', interp)
ret['interp'] = normpath(root + interp)
ret['libs'][os.path.basename(interp)] = {
'path': ret['interp'],
'realpath': readlink(ret['interp'], root, prefixed=True),
'needed': [],
# XXX: Should read it and scan for /lib paths.
ldpaths['interp'] = [
normpath(root + os.path.dirname(interp)),
normpath(root + prefix + '/usr' + os.path.dirname(interp).lstrip(prefix)),
dbg(debug, ' ldpaths[interp] =', ldpaths['interp'])
# Parse the ELF's dynamic tags.
libs = []
rpaths = []
runpaths = []
for segment in elf.iter_segments():
if segment.header.p_type != 'PT_DYNAMIC':
for t in segment.iter_tags():
if t.entry.d_tag == 'DT_RPATH':
rpaths = ParseLdPaths(bstr(t.rpath), root=root, path=path)
elif t.entry.d_tag == 'DT_RUNPATH':
runpaths = ParseLdPaths(bstr(t.runpath), root=root, path=path)
elif t.entry.d_tag == 'DT_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.
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:
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 fullpath:
lret = ParseELF(realpath, root, prefix, ldpaths, display=fullpath,
debug=debug, _first=False, _all_libs=_all_libs)
_all_libs[lib]['needed'] = lret['needed']
del elf
return ret
def _NormalizePath(option, _opt, value, parser):
setattr(parser.values, option.dest, normpath(value))
def _ShowVersion(_option, _opt, _value, _parser):
d = '$Id:,v 1.53 2014/08/01 02:20:20 vapier Exp $'.split()
print('%s-%s %s %s' % (d[1].split('.')[0], d[2], d[3], d[4]))
def _ActionShow(options, elf):
"""Show the dependency tree for this ELF"""
def _show(lib, depth):
fullpath = elf['libs'][lib]['path']
if options.list:
print(fullpath or lib)
print('%s%s => %s' % (' ' * depth, lib, fullpath))
new_libs = []
for lib in elf['libs'][lib]['needed']:
if lib in chain_libs:
if not options.list:
print('%s%s => !!! circular loop !!!' % (' ' * depth, lib))
if options.all or not lib in shown_libs:
for lib in new_libs:
_show(lib, depth + 1)
shown_libs = set(elf['needed'])
chain_libs = []
interp = elf['interp']
if interp:
if options.list:
if not interp is None:
print('%s (interpreter => %s)' % (elf['path'], interp))
for lib in elf['needed']:
_show(lib, 1)
def _ActionCopy(options, elf):
"""Copy the ELF and its dependencies to a destination tree"""
def _StripRoot(path):
return path[len(options.root) - 1:]
def _copy(realsrc, src, striproot=True, wrapit=False, libpaths=(),
if realsrc is None:
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))
subdst = striproot(src)
dst = options.dest + subdst
# 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):
except OSError as e:
if e.errno != errno.ENOENT:
if options.verbose:
print('%s -> %s' % (src, dst))
shutil.copy2(realsrc, dst)
except IOError:
shutil.copy2(realsrc, dst)
if wrapit:
if options.verbose:
print('generate wrapper %s' % (dst,))
if options.libdir:
interp = os.path.join(options.libdir, os.path.basename(elf['interp']))
interp = _StripRoot(elf['interp'])
GenerateLdsoWrapper(options.dest, subdst, interp, libpaths,
# XXX: We should automatically import whenever
# 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 and libnss_*.so libraries, as well as an open ended list
# for known libs that get loaded (e.g. curl will dlopen(libresolv)).
libpaths = set()
for lib in elf['libs']:
libdata = elf['libs'][lib]
path = libdata['realpath']
if not options.libdir:
_copy(path, libdata['path'], outdir=options.libdir)
if not options.libdir:
libpaths = list(libpaths)
if elf['runpath']:
libpaths = elf['runpath'] + libpaths
libpaths = elf['rpath'] + 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,
def main(argv):
parser = optparse.OptionParser("""%prog [options] <ELFs>
Display ELF dependencies as a tree
<ELFs> can 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/ 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.""")
parser.add_option('-a', '--all',
action='store_true', default=False,
help='Show all duplicated dependencies')
parser.add_option('-R', '--root',
default=os.environ.get('ROOT', ''), type='string',
action='callback', callback=_NormalizePath,
help='Search for all files/dependencies in ROOT')
parser.add_option('-P', '--prefix',
default=os.environ.get('EPREFIX', '@GENTOO_PORTAGE_EPREFIX@'), type='string',
action='callback', callback=_NormalizePath,
help='Specify EPREFIX for binaries (for Gentoo Prefix)')
dest='auto_root', action='store_false', default=True,
help='Do not automatically prefix input ELFs with ROOT')
parser.add_option('-l', '--list',
action='store_true', default=False,
help='Display output in a simple list (easy for copying)')
parser.add_option('-x', '--debug',
action='store_true', default=False,
help='Run with debugging')
parser.add_option('-v', '--verbose',
action='store_true', default=False,
help='Be verbose')
action='store_true', default=False,
help='Skip plain (non-ELF) files instead of warning')
parser.add_option('-V', '--version',
action='callback', callback=_ShowVersion,
help='Show version information')
group = optparse.OptionGroup(parser, 'Copying options')
dest='dest', default=None, type='string',
action='callback', callback=_NormalizePath,
help='Copy all files to the specified tree')
default=None, type='string',
action='callback', callback=_NormalizePath,
help='Dir to store all ELFs specified on the command line')
default=None, type='string',
action='callback', callback=_NormalizePath,
help='Dir to store all ELF libs')
action='store_true', default=False,
help='Wrap executable ELFs with scripts for local ldso')
default=None, type='string',
help='When wrapping executable ELFs, place the original file in this '
'sub-directory. By default, it appends a .elf suffix instead.')
action='store_true', default=False,
help='Copy over plain (non-ELF) files instead of warn+ignore')
(options, paths) = parser.parse_args(argv)
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)
if options.dest:
dbg(options.debug, 'dest =', options.dest)
if not paths:
err('missing ELF files to scan')
ldpaths = LoadLdpaths(options.root, options.prefix)
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)
realpath = path
if path != realpath:
dbg(options.debug, ' resolved =', realpath)
matched = True
elf = ParseELF(realpath, options.root, options.prefix, ldpaths,
display=p, debug=options.debug)
except exceptions.ELFError as e:
if options.skip_non_elfs:
# 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)
ret = 1
warn('%s: %s' % (p, e))
except IOError as e:
ret = 1
warn('%s: %s' % (p, e))
if options.dest is None:
_ActionShow(options, elf)
_ActionCopy(options, elf)
if not matched:
ret = 1
warn('%s: did not match any paths' % (path,))
return ret
if __name__ == '__main__':