Il vous arrive parfois d’oublier le nom exact ou le chemin d’un fichier exécutable sur votre système GNU/Linux ?

Certains d’entre vous savent déjà qu’il est possible de chercher à l’aide de ls dans les répertoires listés dans la variable d’environnement $PATH. Cependant, il est bien plus pratique d’utiliser un outil dédié pour effectuer cette tâche rapidement et efficacement.

C’est précisément ce que permet le script showexe.py, que vous pourrez télécharger à la fin de cet article.

Vous connaissez le nom exact du fichier exécutable Linux ? Utilisez which

Si vous connaissez le nom exact du fichier exécutable, la commande which suffit :

which firefox

Cette commande vous retournera le chemin complet vers l’exécutable, par exemple /usr/bin/firefox.

La recherche devient plus complexe lorsque vous avez un doute sur le nom exact de l’exécutable (par exemple, s’agit-il de t-firefox, remote-firefox, ou d’un autre nom similaire ?).

C’est précisément pour répondre à ce besoin que j’ai conçu le script showexe.py, un utilitaire Python qui vous permet d’identifier instantanément le nom et le chemin complet d’un fichier exécutable, à l’aide de filtres simples ou d’expressions rationnelles.

Télécharger et installer showexe.py, le script pour trouver facilement les fichiers exécutables Linux

Son installation est triviale si vous avez un minimum d’expérience avec la ligne de commande. Il suffit de copier le script showexe.py dans /usr/local/bin/ sous le nom showexe, puis de le rendre exécutable :

chmod 755 /usr/local/bin/showexe
chown root:root /usr/local/bin/showexe

(Il est également possible d’accomplir cela avec un gestionnaire de fichiers graphique comme Thunar, Nautilus, Dolphin ou Konqueror, à condition de l’exécuter en tant que root via su ou sudo.)

L’utilisation du script est très simple. Par exemple, pour lister tous les exécutables contenant « gimp » dans leur nom :

showexe --match gimp

Vous pouvez aussi utiliser des expressions rationnelles :

showexe --match 'fir.*x'

Ce qui pourrait produire :

/usr/bin/firefox
/usr/bin/firefox-3.0
/usr/bin/firefox.debian

(L’expression régulière 'fir.*x' correspond à tout nom commençant par « fir » et se terminant par « x ». Pour en savoir plus, consultez notre article dédié aux expressions rationnelles.)

Si vous exécutez showexe sans argument, il affichera tous les exécutables accessibles via votre $PATH. Cela peut être utile en conjonction avec grep, pour filtrer les résultats :

Vous pouvez télécharger directement showexe.py (ce qui est recommandé) ou copier le contenu du script depuis cet article.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright (c) 2009, Asher256
# Site : https://www.asher256.com/
#
# License : GPL
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with This program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
#
"""
Affiche tous les fichiers exécutables du système.

Les fichier exécutables sont supposés exister dans les chemins
définis dans la variable d'environnement PATH. Ils sont séparés
avec le caractère ":".

Ce programme permet aussi de filtrer les fichiers à afficher.
"""

# Informations
__author__ = "Asher256 (contact at asher256 com)"
__copyright__ = "Copyright (c) Asher256, 2009"
__license__ = "GPL"
__version__ = "0.1"

# Bibliothèques
import os
import sys
import re
from getopt import gnu_getopt, GetoptError
from stat import ST_MODE, S_ISREG

try:
    import psyco
    psyco.full()
except ImportError:
    pass

def usage():
    "Afficher l'aide"
    print """Utilitaire pour afficher tous les fichiers exécutables du \
système.

Usage: %s [options]

Options:
        -h, --help                 Cette aide!
        -v, --vebose               Affiche plus d'informations (les
                                   erreurs par exemple)

        -m, --match    Appliquer un filtre sur la liste des
                                   fichiers. Ce filtre correspond à une
                                   expression rationnelle.

       --version                   Afficher la version
""" % sys.argv[0]

def handle_options():
    "Lecture de toutes les options passées dans les arguments"

    # Lecture des arguments
    try:
        args = sys.argv[1:]
        optlist = gnu_getopt(args,
                             'vh:m:',
                             ['verbose', 'help', 'version', 'match='])
    except GetoptError:
        print "Erreur dans les arguments."
        print "--help pour plus d'informations..."
        sys.exit(1)

    # Le dictionnaire qui contiendra les options activées
    options = {}
    options["verbose"] = False
    options["match"] = ""

    # Traitement des arguments
    for option, value in optlist[0]:
        if option == "-v" or option == "--verbose":
            options["verbose"] = True
        if option == "-m" or option == "--match":
            options["match"] = value
        elif option == "-h" or option == "--help":
            usage()
            sys.exit(0)
        elif option == "--version":
            print __version__
            sys.exit(0)

    return options

def show_executables(options):
    "Afficher tous les fichier exécutables qui existent dans le système"
    # On parcourt tous les chemins de la variable d'environnemnt PATH
    for directory in os.environ['PATH'].split(":"):
        # Il doit impérativement être un répertoire
        if not os.path.isdir(directory):
            continue

        # Le filtre
        filter_activated = options["match"] and True or False

        if filter_activated:
            file_filter = re.compile(options["match"])

        # Afficher les fichiers exécutables
        for filename in os.listdir(directory):
            # Application du filtre
            if filter_activated:
                if not file_filter.search(filename):
                    continue
            # Test si le fichier est bien exécutable
            path = os.path.join(directory, filename)
            try:
                if not S_ISREG(os.stat(path)[ST_MODE]):
                    continue
            except OSError:
                continue
            # Affichage du fichier
            print path

if __name__ == '__main__':
    try:
        show_executables(handle_options())
    except KeyboardInterrupt:
        sys.exit(1)

# vim:ai:et:sw=4:ts=4:sts=4:tw=78:fenc=utf-8