qfile(1)

NAME
qfile - list all pkgs owning files

SYNOPSIS
qfile [opts] <filename>

DESCRIPTION
qfile searches packages for files they provide. The searched packages must be installed, thus the search is for any file on the filesystem, to what package that file belongs. It allows to identify which package installed a certain file.

The arguments to qfile can be absolute or relative paths and individual files. By default arguments are interpreted as follows:

    absolute path
        The path is matched against directories, symlinks and objects.

    relative path
        The path is resolved against the current directory, and after that matched like an absolute path.

    -d option in use
        The basename (last component) of the argument path is matched to any directory, symlink or object whose basename matches. This effectively means it matches directories as well as symlinks and objects unlike when -d is not given and a basename is given as argument.

    basename
        The basename is first attempted to be located in the current directory. If an object exists by that name, it is matched like an absolute path. If no such object exists, the name is matched against the basename of any symlink or object. For matching directories, use -d.

After version 0.74 of portage-utils, the -b option was renamed to -d.

OPTIONS

-F <arg>, --format <arg>
    Print matched atom using given format string.

-S, --slots
    Display installed packages with slots.

-R, --root-prefix
    Assume arguments are already prefixed by $ROOT.

-d, --dir
    Only consider basename of argument and also match directories, this option makes qlist ignore any path component given in the arguments if present.

-o, --orphans
    List orphan files.

-x <arg>, --exclude <arg>
    Don't look in package <arg> (used with --orphans).

-P, --skip-plibreg
    Don't look in the prunelib registry.

--root <arg>
    Set the ROOT env var.

-v, --verbose
    Print package versions and symlink targets for matches, warn about problems with resolving symlinks or positioning packages under an alternative root.

-q, --quiet
    Don't print matching file for matches, just the package. Don't report about orphan files.

-C, --nocolor
    Don't output color.

--color
    Force color in output.

-h, --help
    Print this help and exit.

-V, --version
    Print version and exit.

FINDING FILE OWNERS

This is the default behavior of qfile. It will list the packages which own the files (or directories, or symlinks, or anything else Portage can install) you are querying. Query items may be file paths or simple file names. By default, output includes packages names and the complete paths to the matching files. If using --verbose, versions of the packages will also be shown. In contrast, when using --quiet, only package names are listed, without files paths. The return status of qfile will be 0 as soon as an owning package has been found for one of the query items.

Find names of package(s) owning "/bin/bash":
    $ qfile -q /bin/bash
    app-shells/bash

Find package(s) owning any file named "bash", and show paths of this files:
    $ qfile -d bash
    app-shells/bash: /bin/bash
    app-shells/bash: /etc/bash

Find packages(s) owning the file named "bash" in the current directory. Also display their exact version:
    $ cd /bin
    $ qfile -v ./bash
    app-shells/bash-3.1_p17: /bin/bash

Find the package(s) owning the libraries needed by the Bash binary:
    $ qfile $(scanelf -nq -F%n#F /bin/bash | tr , '\n')
    sys-libs/ncurses (/lib/libncurses.so.5)
    sys-libs/glibc (/lib/libdl.so.2)
    sys-libs/glibc (/lib/libc.so.6)

FINDING ORPHAN FILES

qfile can also, with the --orphans option, find files which are not owned by any package. This behaviour is the opposite of the usual file owner search: the output is the list of query items for which no reference has been found in your installed packages database. As for --quiet, it will completly turn off the output, leaving just a silent test command, which returns 0 if and only if there was no orphan in your query items.

Find the orphan libtool files of your system:
    $ qfile -o $(find /lib /usr/lib -name "*.la")
    /usr/lib/libGL.la

Find the libraries needed by the binary "foo" which have not been installed by any package:
    $ qfile -o $(scanelf -nq -F%n#F /path/to/foo | tr , '\n')
    libinstalledmanually.so.2

$ROOT HANDLING

By setting the ROOT environment variable, you can force qfile to work in the sytem of your choice. This example shows queries for owner of "/bin/sh", first on your main system, and then on a system mounted on "/mnt":
    $ qfile -q /bin/sh
    app-shells/bash
    $ ROOT=/mnt qfile -q /bin/sh
    sys-apps/busybox

Note that the query item is "/bin/sh" in both commands: by default, what qfile looks for is file paths as they are recorded in the packages database of the target system, and this paths don't include $ROOT. If, on the contrary, you want to query files with their current actual paths (including the mount point), you should add the --root-prefix (-R) option:
    $ ROOT=/mnt qfile -Rq /mnt/bin/sh
    sys-apps/busybox

The other difference between defaults and -R queries is the output of files paths. The former doesn't include the $ROOT prefix, and the latter does:
    $ ROOT=/mnt qfile sh
    sys-apps/busybox: /bin/sh
    $ ROOT=/mnt qfile -R sh
    sys-apps/busybox: /mnt/bin/sh

Sure, the same differences hold when querying for orphan files:
    $ ROOT=/mnt qfile -o $(ls /mnt/bin/ | sed 's:^/mnt::')
    /bin/dostuff.sh
    $ ROOT=/mnt qfile -Ro /mnt/bin/*
    /mnt/bin/dostuff.sh

SEARCHING FOR FILE COLLISIONS

A last option of qfile is --exclude (-x), which will makes it skip one particular package when doing its files owners search. This option takes one argument, which can be a package name (bash or app-shells/bash), or a versioned package (bash-3.2_p9-r1 or app-shells/bash-3.2_p9-r1), or a slotted package (bash:0 or app-shells/bash:0). It is useful for finding file collisions between packages (ie. comparing the contents of one package with the contents of all the others).

For example, the following script will search collisions between all your installed packages. Be careful, this will takes time:
    #!/bin/bash
    cd $(portageq vdb_path)
    for pkg in *-*/*-* ; do
        [[ -f ${pkg}/CONTENTS ]] || continue
        collisions=$(sed -n \
                '/^obj\|^sym/s:^... \([^ ]\+\).*:1:p' \
                ${pkg}/CONTENTS \
            | qfile -e -x ${pkg} -f -)
        [[ -n ${collisions} ]] \
            && echo ">>> ${pkg}:" \
            && echo "${collisions}"
    done

An other example is the following script, which can be used to check that a binary package (.tbz2) has no conflict with any of your installed packages, but the one it may replace (same name and slot), if any: #!/bin/bash pkgver=$(basename "${1}") pkgver=${pkgver%%.tbz2} pn=$(qatom ${pkgver} | cut -d\ -f2) tmpdir=$(mktemp -t -d) || exit 1 tarbz2=${tmpdir}/${pkgver}.tar.bz2 xpak=${tmpdir}/${pkgver}.xpak qtbz2 -s "${1}" "${tarbz2}" "${xpak}" categ=$(qxpak -O -x "${xpak}" CATEGORY) slot=$(qxpak -O -x "${xpak}" SLOT) tar tjf "${tarbz2}" \
    | sed -e 's:^\./:/:' -e '\:/$:d' \
    | qfile -e -f - -x ${categ}/${pn}:${slot} rm -rf "${tmpdir}"

REPORTING BUGS
Please report bugs via http://bugs.gentoo.org/
Product: Portage Development; Component: Tools

AUTHORS
Ned Ludd <solar@gentoo.org>
Mike Frysinger <vapier@gentoo.org>
Fabian Groffen <grobian@gentoo.org>
TGL <degrenier[at]easyconnect.fr>

SEE ALSO
q(1), qatom(1), qcheck(1), qdepends(1), qgrep(1), qkeyword(1), qlist(1), qlop(1), qmanifest(1), qmerge(1), qpkg(1), qsearch(1), qsize(1), qtbz2(1), qtegrity(1), quse(1), qwhich(1), qxpak(1)