Espace d'Asher256

Script Linux: Trouver Facilement le Nom d’un Fichier Exécutable





Il vous arrive parfois d’oublier et de vouloir chercher le nom ou le chemin exact vers un fichier exécutable de votre système de fichiers GNU/Linux ?

showexe.py : script Python pour chercher et trouver des fichiers exécutable !

Plusieurs d’entre vous le savent, il est possible de chercher à coup de ls dans les chemins de la variable d’environnement $PATH, mais comme toujours, il serait intéressant d’avoir l’outil adéquat pour faire ce que vous souhaitez rapidement et facilement.

C’est ce que le script showexe.py, que vous pourrez télécharger à la fin de cet article, vous permettra de faire !

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

Si vous connaissez le nom exact du fichier exécutable, une simple utilisation de which sera suffisante :

which firefox

La commande ci-dessus vous donnera le chemin précis de Firefox. Chez moi par exemple, c’est /usr/bin/firefox.

Là où cela devient moins facile, c’est quand vous doutez un peu du nom du fichier l’exécutable (par exemple, est-ce t-firefox, remote-firefox ou autre chose ?).

C’est pour cette raison que j’ai développé le script showexe.py, un script  Python qui vous permettra de trouver instantanément le nom et le chemin complet d’un fichier exécutable, grâce à des filtres simples ou à des expressions rationnelles.

À télécharger et installer : showexe.py, le script pour trouver facilement les fichiers exécutables Linux dont vous doutez du nom

L’installation du script showexe.py est assez facile, si vous avez au moins une fois touché à la ligne de commande. Il suffit de copier (en tant que root) le script showexe.py dans le répertoire /usr/local/bin/, sous le nom showexe. Ceci étant fait, il ne vous restera qu’à le rendre exécutable et changer son utilisateur et groupe par root avec la commande :

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

(Il est aussi possible de faire cela avec des gestionnaires de fichiers graphiques, comme Thunar, Nautilus, Dolphin ou Konqueror. Il faut juste le lancer en tant que root, avec su ou sudo)

L’utilisation de showexe est très simple. Par exemple, pour trouver tous les programmes ayant « gimp » dans leur nom :

showexe --match gimp

Il est aussi possible d’utiliser les expressions rationnelles :

showexe --match 'fir.*x'

Cela vous donnera (à titre d’exemple) :

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

(‘fir.*x’ veut dire tout ce qui commence par fir et finit par x. Si vous vous intéressez aux expressions rationnelles, lisez cet article)

Information supplémentaire : si vous utilisez showexe sans arguments, tous les fichiers exécutables de votre système de fichiers seront affichés. Cela pourrait vous être utile pour utiliser un tube avec grep et filtrer grâce à ce dernier.

Vous pouvez télécharger directement showexe.py (ce que je vous recommande) ou le lire / copier / coller directement 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




Déjà 29 commentaires dans “Script Linux: Trouver Facilement le Nom d’un Fichier Exécutable”
  1. Samuel Ballé

    J’utilise
    man -k nom_partiel_de_la_commande
    qui me donne une liste de propositions et si de l’aide est disponible et dans quelle section.
    ça a l’avantage de marcher aussi pour nombre de fichiers de configuration.

  2. lamdauf

    Merci pour l’article, je l’ai pas encore testé mais je vois à partir du code que ça doit marcher.

  3. Laurent - CyberSDF

    Le mettre dans /usr/local/bin ne sert que si on a plusieurs utilisateurs de la machine (en plus c’est une faille de sécu au vu des permissions du fichier). Si on est tout seul ou si la commande ne sera utilisé que par un seul utilisateur, il suffit de créer un répertoire « bin » dans le répertoire utilisateur (/home/nom_user/bin), mettre ses exécutable à sois et roule ma poule.

  4. Remy

    Hello,

    Il y a aussi la commande which ?

    [remy@arrakis ~]$ which vim
    /usr/bin/vim

  5. Laurent - CyberSDF

    Précision : vérifier que le répertoire /home/user/bin est bien dans le path avec : echo $PATH

    Si il n’y est pas, il suffit de faire un simple : echo ‘export PATH=$PATH:/home/user/bin’ >> /home/user/.bashrc

  6. Asher256

    @Samuel Ballé: la commande -k de man est aussi une bonne alternative. Cela dit, elle ne remplace pas complètement showexe.py, ce dernier permet également de trouver les fichiers exécutables sans manpage ^_^ .

    @CyberSDF: pourquoi une faille de sécurité ? Je viens de changer +x par 755 dans l’article, si c’est à cela que tu fais allusion 😉 .

    @Rémy: j’ai expliqué dans l’article la différence avec which.

  7. 3po

    Moi j’utilise la complétion avec la touche tab pour chercher un nom d’executable. Bon c’est moins puissant mais c’est plus rapide 🙂

  8. Amine

    Sympa, mais find et locate font la même chose 🙂

  9. Amine

    debbie:~# find / -name *who* -perm 755
    /usr/share/doc/whois
    /usr/bin/whoami
    /usr/bin/ldapwhoami
    /usr/bin/who
    /usr/bin/whois

  10. Dworkin

    Bonjour,
    Bonne idée car c’est vrai qu’on galère souvent (surtout quand on travaille sur des OS différents)
    Une autre solution doit aussi exister avec find et l’option -acl qui va bien pour garder les seulement les exécutables.
    Mais c’est certain que ton script est utile pour les personnes comme moi qui oublient toujours les options de find.

  11. chickenzilla

    Il y a aussi la commande « whereis commande » qui renvoie le chemin vers l’exécutable, les sources et la page man de « commande ».

  12. Asher256

    @Amine: ouais, locate et find sont aussi assez utiles, mais ils ne sont pas faits seulement pour les exécutables dans $PATH ! « fir » peut très bien te sortir quelque chose dans /etc ou dans /usr/lib.

    @Dworkin: merci d’avoir mentionné la commande -acl. Je vais me documenter pour voir de quoi elle sert.

    @chickenzilla: oui, c’est une excellente commande aussi. Même si elle ne remplace pas showexe.py, elle fait partie des commandes les plus utiles pour ce genre d’utilisation ! Merci de l’avoir mentionnée, elle sera probablement utile à quelqu’un.

    @3po: une bonne alternative aussi, bien que pas aussi « puissante » comme tu l’as dit ^_^

  13. amine

    tu peux remarquer que je n’ai pas spécifie de path, juste root (le /) on peut spécifier les path que l’on veut même utiliser $PATH avec sed me sortir les :

  14. amine

    Ceci dit … Cool script et certes utile!

  15. Asher256

    Thanks Amine !

    (ok pour le root ^_^ )

  16. Simulation pret

    Merci beaucoup pour ce script! Vos tutoriaux sont très utiles.

  17. dominiko

    Utiliser ‘which’ est une mauvaise idée. Il vaut mieux utiliser ‘type’ qui est une commande interne du shell (bash). Étant un commande du shell, elle a plus d’information que ‘which’.

    Pourquoi ne pas utiliser ‘which’? Suppose qu’il y ait un alias pas example. ‘which’ ne fonctionnerait pas. Mais type fonctionne:

    $ alias ll=’ls -l’
    $ type ll
    ll is aliased to `ls -l’

    La commande ‘type’ connait les alias, fonctions shell, commandes internes, et commandes externes.

  18. Cram

    Hello !

    Est-ce bien

    « Options:

    -v, –vebose Affiche plus d’informations (les
    erreurs par exemple)
     »

    ou -v –verbose
    ?

  19. Asher256

    @dominiko: excellente cette commande, merci pour le partage. J’utilisais surtout whereis et which. J’adore ce partage d’idées dans les commentaires. Il y a eu trois commandes intéressantes postée en un journée ^_^ .

    @Cram: ?

  20. Orion

    Bonjour,

    je pense que Cram parlait d’une faute de frappe dans la fonction usage().

    Sinon, je propose une petite ligne de commande toute faite qui fait la même chose en donnant quelques détails :

    find `echo « $PATH » | sed -e ‘s/:/ /g’` -name ‘fir*x’ -executable \( -type f -or -type l \) -exec ls -hl –color=always {} \;

    On peut aussi utiliser type avant ou après et définir un alias sur le tout.

  21. Asher256

    C’est une bonne alternative aussi Orion. Merci à toi aussi d’avoir partagé avec nous ta vision des choses ^_^ .

    PS: sympa le tu « tu l’auras pas » :-p

  22. amine

    Orion: c’est exactement ce que je disais 😉

  23. Laurent - CyberSDF

    @dominico : chez moi je suis plus sioux 😉

    $ type which
    which est un alias vers « type -all »

  24. Asher256

    @Amine: ah ouais, c’est vrai en plus… 🙂

    @CyberSDF: chez moi cela donne « which is /usr/bin/which ». Tu es sous quelle distribution ? Tu as peut-être fait un alias pour te faciliter la vie et utilise tout le temps which ?

  25. Laurent - CyberSDF

    @Asher256 : oui c’est ça. J’ai fais un alias de wich vers type -all comme ça je n’utilise en fait jamais wich 🙂

  26. Apo351

    J’aurais utilisé optparse (http://docs.python.org/library/optparse.html) qui simplifie pas mal l’écriture d’un parser d’options.

  27. Asher256

    Ah l’habitude… Cela nous fait oublier d’aller voir ailleurs et chercher d’autres solutions.

    Sympa ta suggestion Apo351. Je lirai et découvrirai optparse le plus tôt que possible, vu que cela simplifie l’écriture du parser d’option (d’après ce que j’ai pu voir dans la documentation).

    Je l’utiliserai dans mon prochain programme Python !

  28. Dworkin

    @orion Exactement ce a quoi je pensais

    on peut aussi utiliser
    find `echo « $PATH » | sed -e ‘s/:/ /g’` -name ‘fir*x’ -perm /g+x,u+x,o+x
    ou -perm /111

    @Asher256
    en fait le find -acl est equivalent au find -perm mais ça dépend des versions de find et des OS (linux, Solaris, …)
    Ca n’existe pas dans la version sous Ubuntu

  29. Frédéric Remy

    Il y a aussi la commande whereis qui fait cela très bien.

    whereis firefox
    firefox: /usr/bin/firefox /usr/lib/firefox /usr/share/firefox