15.9. Commandes diverses

Commandes qui ne peuvent être classées

jot, seq

Ces outils génèrent des séquences de nombres entiers avec une incrémentation que l'utilisateur choisit.

Le retour à la ligne qui sépare par défaut les entiers peut être modifié avec l'option -s.

 bash$ seq 5
 1
 2
 3
 4
 5



 bash$ seq -s : 5
 1:2:3:4:5
 

jot et seq sont fort pratiques pour les boucles.

Exemple 15.51. Utiliser seq pour générer l'incrément d'une boucle

#!/bin/bash
# Utiliser "seq"

echo

for a in `seq 80`  # ou   for a in $( seq 80 )
# Identique à   for a in 1 2 3 4 5 ... 80   (évite beaucoup de frappe !).
# Pourrait aussi utiliser 'jot' (si présent sur le système).
do
  echo -n "$a "
done      # 1 2 3 4 5 ... 80
# Exemple d'utilisation de la sortie d'une commande pour générer la [liste]
# dans une boucle "for".

echo; echo


COMPTEUR=80  # Oui, 'seq' accepte aussi un compteur remplaçable.

for a in `seq $COMPTEUR`  # ou   for a in $( seq $COMPTEUR )
do
  echo -n "$a "
done      # 1 2 3 4 5 ... 80

echo; echo

DEBUT=75
FIN=80

for a in `seq $DEBUT $FIN`
#  Donner à "seq" deux arguments permet de commencer le comptage au premier et
#+ de le terminer au second.
do
  echo -n "$a "
done      # 75 76 77 78 79 80

echo; echo

DEBUT=45
INTERVALLE=5
FIN=80

for a in `seq $DEBUT $INTERVALLE $FIN`
#  Donner à "seq" trois arguments permet de commencer le comptage au premier,
#+ d'utiliser le deuxième comme intervalle et de le terminer au troisième.
do
  echo -n "$a "
done      # 45 50 55 60 65 70 75 80

echo; echo

exit 0

Un exemple plus simple :

#  Crée un ensemble de dix fichiers,
#+ nommés fichier.1, fichier.2 . . . fichier.10.
NOMBRE=10
PREFIXE=fichier

for fichier in `seq $NOMBRE`
do
  touch $PREFIXE.$fichier
  #  Ou vous pouvez réaliser d'autres opérations,
  #+ comme rm, grep, etc.
done

Exemple 15.52. Compteur de lettres

#!/bin/bash
# letter-count.sh : Compte les occurrences de lettres dans un fichier texte.
# Écrit par Stefano Palmeri.
# Utilisé dans le guide ABS avec sa permission.
# Légèrement modifié et reformaté par l'auteur du guide ABS.

MINARGS=2          # Le script requiert au moins deux arguments.
E_MAUVAISARGS=65
FICHIER=$1

let LETTRES=$#-1   # Nombre de lettres spécifiées (comme argument en ligne de commande).
                   # (Soustrait 1 du nombre d'arguments en ligne de commande.)


affiche_aide(){
           echo
           echo Usage: `basename $0` fichier LETTRES  
           echo Note: les arguments de `basename $0` sont sensibles à la casse.
           echo Exemple: `basename $0` foobar.txt G n U L i N U x.
           echo
}

# Vérification du nombre d'arguments.
if [ $# -lt $MINARGS ]; then
   echo
   echo "Pas assez d'arguments."
   echo
   affiche_aide
   exit $E_MAUVAISARGS
fi  


# Vérifie si le fichier existe.
if [ ! -f $FICHIER ]; then
    echo "Le fichier \"$FICHIER\" n'existe pas."
    exit $E_MAUVAISARGS
fi



# Compte l'occurence des lettres.
for n in `seq $LETTRES`; do
      shift
      if [[ `echo -n "$1" | wc -c` -eq 1 ]]; then                #  Vérifie l'argument.
             echo "$1" -\> `cat $FICHIER | tr -cd  "$1" | wc -c` #  Compte.
      else
             echo "$1 n'est pas un seul caractère."
      fi  
done

exit $?

#  Ce script a exactement les mêmes fonctionnalités que letter-count2.sh
#+ mais s'exécute plus rapidement.
#  Pourquoi ?

Note

Avec plus de fonctionnalités que seq, jot est un outil classique UNIX qui n'est pas habituellement inclus dans une distribution Linux. Néanmoins, le source rpm est disponible au téléchargement sur le dépôt du MIT.

Contrairement à seq, jot peut générer une séquence de nombres aléatoires en utilisant l'option -r.

bash$ jot -r 3 999
1069
 1272
 1428

getopt

La commande getopt analyse les options de la ligne de commande précédées par un tiret. Cette commande externe correspond à la commande intégrée Bash getopts. Utiliser getopt permet la gestion des options longues grâce à l'utilisation de l'option -l et cela permet aussi la réorganisation des paramètres.

Exemple 15.53. Utiliser getopt pour analyser les paramètres de la ligne de commande

#!/bin/bash
# Utiliser getopt.

# Essayez ce qui suit lors de l'appel à ce script.
#   sh ex33a.sh -a
#   sh ex33a.sh -abc
#   sh ex33a.sh -a -b -c
#   sh ex33a.sh -d
#   sh ex33a.sh -dXYZ
#   sh ex33a.sh -d XYZ
#   sh ex33a.sh -abcd
#   sh ex33a.sh -abcdZ
#   sh ex33a.sh -z
#   sh ex33a.sh a
# Expliquez les résultats de chacun.

E_OPTERR=65

if [ "$#" -eq 0 ]
then   # Le script a besoin d'au moins un argument en ligne de commande.
  echo "Usage $0 -[options a,b,c]"
  exit $E_OPTERR
fi  

set -- `getopt "abcd:" "$@"`
#  Positionne les paramètres de position par rapport aux arguments en ligne de
#+ commandes.
# Qu'arrive-t'il si vous utilisez "$*" au lieu de "$@" ?

while [ ! -z "$1" ]
do
  case "$1" in
    -a) echo "Option \"a\"";;
    -b) echo "Option \"b\"";;
    -c) echo "Option \"c\"";;
    -d) echo "Option \"d\" $2";;
     *) break;;
  esac

  shift
done

#  Il est généralement mieux d'utiliser la commande intégrée 'getopts'
#+ dans un script.
#  Voir "ex33.sh".

exit 0

Voir l'Exemple 9.14, « Émuler getopt » pour une émulation simplifiée de getopt.

run-parts

La commande run-parts ^[58] exécute tous les scripts d'un répertoire cible triés par ordre ASCII. Évidemment, ces scripts nécessitent les droits d'exécution.

Le démon cron lance run-parts pour exécuter les scripts du répertoire /etc/cron.*.

yes

Par défaut, la commande yes envoie une suite infinie de lettres y suivies de retours à la ligne sur stdout. Un ctrl+c arrête l'éxécution. Une chaîne différente peut être spécifiée en argument (yes chaine_differente affichera continuellement chaine_differente sur stdout).

On pourrait se demander l'intérêt de la chose. En pratique, yes peut être utilisé comme un expect minimaliste en étant redirigé vers un programme en attente d'une saisie expect.

yes | fsck /dev/hda1 confirme toutes les réparations à fsck (méfiance !).

yes | rm -r nom_repertoire aura le même effet que rm -rf nom_repertoire (toujours méfiance !).

Avertissement

La plus grande prudence est conseillée lorsque vous redirigez yes vers une commande potentiellement dangereuse pour votre système, comme fsck ou fdisk. Cela pourrait avoir des effets secondaires inattendus.

Note

La commande yes analyse les variables. Par exemple :

bash$ yes $BASH_VERSION
3.1.17(1)-release
 3.1.17(1)-release
 3.1.17(1)-release
 3.1.17(1)-release
 3.1.17(1)-release
 . . .
              

Cette « fonctionnalité » pourrait ne pas être très utile.

banner

Affiche les paramètres sur stdout comme une grande bannière verticale en utilisant un symbole ASCII (# par défaut). On peut rediriger cette sortie vers l'imprimante pour obtenir une copie papier.

printenv

Montre toutes les variables d'environnement réglées pour un utilisateur donné.

bash$ printenv | grep HOME
 HOME=/home/bozo
 

lp

Les commandes lp et lpr envoient un (des) fichier(s) à la file d'impression. ^[59] Ces commandes tirent l'origine de leurs noms des imprimantes « ligne par ligne » d'un autre âge.

bash$ lp fichier1.txt ou bash lp <fichier1.txt

Il est souvent utile d'envoyer le résultat de la commande pr à lp.

bash$ pr -options fichier1.txt | lp

Les outils de mise en forme comme groff et Ghostscript peuvent directement envoyer leurs sorties à lp.

bash$ groff -Tascii fichier.tr | lp

bash$ gs -options | lp fichier.ps

Les commandes sont lpq pour visualiser la file d'impression et lprm pour retirer des documents de la file d'impression.

tee

[UNIX emprunte une idée aux commerces de tuyauterie]

C'est un opérateur de redirection avec une petite différence : comme le « T » du plombier, il permet de « soutirer » vers un fichier la sortie d'une commande ou de plusieurs commandes à l'intérieur d'un tube mais sans affecter le résultat. Ceci est utile pour envoyer le résultat du processus en cours vers un fichier ou un papier, par exemple pour des raisons de débogage.

                               (redirection)
                              |----> vers le fichier
                              |
  ============================|====================
  commande ---> commande ---> |tee ---> commande ---> ---> sortie du tube
  ===============================================
 

cat listefichiers* | sort | tee fichier.verif | uniq > fichier.resultat

(le fichier fichier.verif contient les contenus concaténés puis triés des fichiers « listefichiers » avant que les doublons ne soient supprimés par uniq).

mkfifo

Cette commande obscure crée un tube nommé, un tampon temporaire pour transférer les données entre les programmes sur le principe du first-in-first-out (FIFO : premier arrivé, premier sorti). ^[60] Classiquement, un processus écrit dans le FIFO et un autre y lit. Voir l'Exemple A.15, « fifo: Faire des sauvegardes journalières, en utilisant des tubes nommés ».

#!/bin/bash
# Petit script d'Omair Eshkenazi.
# Utilisé dans le guide ABS avec sa permission (merci !).

mkfifo pipe1
mkfifo pipe2

(cut -d' ' -f1 | tr "a-z" "A-Z") >pipe2 <pipe1 &
ls -l | tr -s ' ' | cut -d' ' -f3,9- | tee pipe1 |
cut -d' ' -f2 | paste - pipe2

rm -f pipe1
rm -f pipe2

#  Pas besoin de tuer les processus en tâche de fond quand le script se termine.
#+ (pourquoi ?).

exit $?

Maintenant, lancez le script et expliquez sa sortie :
sh mkfifo-example.sh

4830.tar.gz          BOZO
pipe1   BOZO
pipe2   BOZO
mkfifo-example.sh    BOZO
Mixed.msg BOZO

pathchk

Ce programme vérifie la validité d'un nom de fichier. Il renvoie un message d'erreur si le nom excède la taille maximale autorisée (255 caractères) ou si un des répertoires du chemin est inaccessible, alors un message d'erreur est affiché.

Malheureusement, pathchk ne renvoie pas un code d'erreur interprétable, ce qui le rend assez inutile dans un script. Cherchez du côté des opérateurs de tests sur les fichiers si besoin.

dd

C'est une commande légèrement obscure et l'une des plus craintes des commandes de duplication des données. À l'origine, c'était un outil d'échange de données entre les bandes magnétiques des mini-ordinateurs unix et les mainframes d'IBM. Cette commande est encore utilisée à cet effet. dd copie simplement un fichier (ou stdin/stdout) mais en effectuant une conversion. ASCII/EBCDIC est une « conversion » possible ^[61] minuscule/majuscule, permutation des paires d'octets entre l'entrée et la sortie, saut et troncature des en-têtes et queues du fichier d'entrées.

# Convertir un fichier en majuscule :

dd if=$fichier conv=ucase > $fichier.majuscule
#                    lcase   # pour une conversion en minuscule

Voici quelques options basiques de dd :

• if=INFILE

  INFILE est le fichier source.

• of=OUTFILE

  OUTFILE est le fichier cible, le fichier où les données seront écrites.

• bs=BLOCKSIZE

  Ceci est la taille de chaque bloc de données en cours de lecture et d'écriture, habituellement une puissance de 2.

• skip=BLOCKS

  Nombre de blocs à sauter dans INFILE avant de commencer la copie. Ceci est utile quand INFILE commence avec des données corrompues ou quand il est préférable de copier seulement une portion de INFILE.

• seek=BLOCKS

  Nombre de blocs à sauter dans INFILE avant de commencer la copie, laissant des données blanches au début de OUTFILE.

• count=BLOCKS

  Copie seulement ce nombre de blocs de données, plutôt que le fichier INFILE entier.

• conv=CONVERSION

  Type de conversion à appliquer aux données d'INFILE avant l'opération de copie.

dd --help liste toutes les options acceptées par cet outil puissant.

Exemple 15.54. Un script qui se copie lui-même

#!/bin/bash
# self-copy.sh

# Ce script se copie lui-même.

fichier_souscript=copy

dd if=$0 of=$0.$fichier_souscript 2>/dev/null
# Supprime les messages de dd:    ^^^^^^^^^^^

exit $?

Exemple 15.55. S'exercer à dd

#!/bin/bash
# exercising-dd.sh

# Script de Stephane Chazelas.
# Quelque peu modifié par l'auteur du guide ABS.

fichier_en_entree=$0   # Ce script.
fichier_en_sortie=traces.txt # Le fichier en sortie
n=3
p=5

dd if=$fichier_en_entree of=$fichier_en_sortie \
  bs=1 skip=$((n-1)) count=$((p-n+1)) 2> /dev/null
# Extrait les caractères de n à p (3 à 5) à partir de ce script.

# -------------------------------------------------------

echo -n "bonjour le monde" | dd cbs=1 conv=unblock 2> /dev/null
# Affiche "bonjour le monde" verticalement.
# Pourquoi ? un retour de ligne envoyé par dd après chaque caractère.

exit 0

Pour montrer à quel point dd est souple, utilisons-le pour capturer nos saisies.

Exemple 15.56. Capturer une saisie

#!/bin/bash
#  dd-keypress.sh
#+ Capture des touches clavier sans avoir besoin d'appuyer sur ENTER.


touches_appuyees=4                    # Nombre de touches à capturer.


ancien_parametrage_du_tty=$(stty -g)  # Sauve l'ancienne configuration du terminal.

echo "Appuyez sur $touches_appuyees touches."
stty -icanon -echo                    # Désactive le mode canonique.
                                      # Désactive l'echo local.
touches=$(dd bs=1 count=$touches_appuyees 2> /dev/null)
# 'dd' utilise stdin si "if" (input file, fichier en entrée) n'est pas spécifié.

stty "$ancien_parametrage_du_tty"     # Restaure l'ancien paramètrage du terminal.

echo "Vous avez appuyé sur les touches \"$touches\"."

# Merci, Stéphane Chazelas, pour avoir montré la façon.
exit 0

dd peut effectuer un accès aléatoire sur un flux de données.

echo -n . | dd bs=1 seek=4 of=fichier conv=notrunc
# l'option "conv=notrunc" signifie que la sortie ne sera pas tronquée.
# Merci, S.C.

dd peut copier les données brutes d'un périphérique (comme un lecteur de disquette ou de bande magnétique) vers une image et inversement (Exemple A.5, « copy-cd : Copier un CD de données »). On l'utilise couramment pour créer des disques de démarrage.

dd if=kernel-image of=/dev/fd0H1440

De la même manière, dd peut copier le contenu entier d'un disque (même formaté avec un autre OS) vers un fichier image.

dd if=/dev/fd0 of=/home/bozo/projects/floppy.img

Comme autres exemples d'applications de dd, on peut citer l'initialisation d'un fichier swap temporaire (Exemple 28.2, « Créer un fichier de swap en utilisant /dev/zero ») ou d'un disque en mémoire (Exemple 28.3, « Créer un disque ram »). dd peut même effectuer la copie bas-niveau d'une partition complète d'un disque dur même si la pratique n'est pas conseillée.

Les gens (qui n'ont probablement rien à faire de mieux de leur temps) pensent constamment à de nouvelles applications intéressantes de dd.

Exemple 15.57. Effacer les fichiers de façon sûre

#!/bin/bash
# blot-out.sh : Efface "toutes" les traces d'un fichier.

#  Ce script écrase un fichier cible avec des octets pris au hasard, puis avec
#+ des zéros, avant de le supprimer définitivement.
#  Après cela, même l'examen des secteurs du disque par des méthodes
#+ conventionnelles ne permet pas de retrouver
#+ les données du fichier d'origine.

PASSES=7         # Nombre d'écriture sur le fichier.
                 #  L'augmenter ralentit l'exécution du script,
                 #+ spécialement sur les gros fichiers.
TAILLEBLOC=1     #  Les entrées/sorties avec /dev/urandom requièrent la taille
                 #+ d'un bloc, sinon vous obtiendrez des résultats bizarres.
E_MAUVAISARGS=70 # Divers codes d'erreur
E_NON_TROUVE=71
E_CHANGE_D_AVIS=72

if [ -z "$1" ]   # Aucun nom de fichier spécifié.
then
  echo "Usage: `basename $0` nomfichier"
  exit $E_MAUVAISARGS
fi

fichier=$1

if [ ! -e "$fichier" ]
then
  echo "Le fichier \"$fichier\" est introuvable."
  exit $E_NON_TROUVE
fi  

echo
echo -n "Êtes-vous absolument sûr de vouloir complètement écraser \"$fichier\" (o/n) ?"
read reponse
case "$reponse" in
[nN]) echo "Vous avez changé d'idée, hum ?"
      exit $E_CHANGE_D_AVIS
      ;;
*)    echo "Écrasement du fichier \"$fichier\".";;
esac


longueur_fichier=$(ls -l "$fichier" | awk '{print $5}')
      # Le 5e champ correspond à la taille du fichier.

nb_passe=1

chmod u+w "$fichier"   # Autorise l'écrasement ou la suppression du fichier.

echo

while [ "$nb_passe" -le "$PASSES" ]
do
  echo "Passe #$nb_passe"
  sync         # Vider les tampons.
  dd if=/dev/urandom of=$fichier bs=$TAILLEBLOC count=$longueur_fichier
               # Remplir avec des octets pris au hasard.
  sync         # Vider de nouveau les tampons.
  dd if=/dev/zero of=$fichier bs=$TAILLEBLOC count=$longueur_fichier
               # Remplir avec des zéros.
  sync         # Vider encore une fois les tampons.
  let "nb_passe += 1"
  echo
done  


rm -f $fichier # Finalement, supprime le fichier brouillé et déchiqueté.
sync           # Vide les tampons une dernière fois.

echo "Le fichier \"$fichier\" a été complètement écrasé et supprimé."; echo


#  C'est une méthode assez sécurisée, mais inefficace et lente pour massacrer
#+ un fichier. La commande "shred", faisant partie du paquetage GNU "fileutils",
#+ fait la même chose mais de façon plus efficace.

#  Le fichier ne peut pas être récupéré par les méthodes habituelles.
#  Néanmoins...
#+ cette simple méthode ne pourra certainement *pas* résister à des méthodes
#+ d'analyse plus sophistiquées.

#  Ce script pourrait ne pas fonctionner correctement avec un système de fichiers
#+ journalisé.
#  Exercice (difficile) : corrigez ce défaut.

#  Le paquetage de suppression de fichier "wipe" de Tom Vier fait un travail
#+ bien plus en profondeur pour massacrer un fichier que ce simple script.
#     http://www.ibiblio.org/pub/Linux/utils/file/wipe-2.0.0.tar.bz2

#  Pour une analyse en détail du thème de la suppression de fichier et de la
#+ sécurité, voir le papier de Peter Gutmann,
#+     "Secure Deletion of Data From Magnetic and Solid-State Memory".
#           http://www.cs.auckland.ac.nz/~pgut001/secure_del.html


exit 0

Voir aussi l'entrée dd thread dans la bibliographie.

od

Le filtre od (pour octal dump) convertit l'entré en octal (base 8) ou dans une autre base. C'est très utile pour voir ou traiter des fichiers binaires ou d'autres sources de données illisibles comme /dev/urandom.

head -c4 /dev/urandom | od -N4 -tu4 | sed -ne '1s/.* //p'
# Exemple d'affichage : 1324725719, 3918166450, 2989231420, etc.

# À partir du script exemple rnd.sh, par Stéphane Chazelas

Voir aussi Exemple 9.31, « Réinitialiser RANDOM » et Exemple A.38, « Tri d'insertion ».

hexdump

Liste le contenu en hexadécimal, octal, décimal ou ASCII d'un fichier binaire. hexdump est un équivalent moins complet d'od, traité ci-dessus. Elle pourrait être utilisée pour visualiser le contenu d'un fichier binaire, en combinaison avec dd et less.

dd if=/bin/ls | hexdump -C | less
# L'option -C formate joliment la sortie sous forme d'un tableau.

objdump

Affiche des informations sur un objet ou un exécutable binaire sous sa forme hexadécimale ou en tant que code désassemblé (avec l'option -d).

bash$ objdump -d /bin/ls
 /bin/ls:     file format elf32-i386

 Disassembly of section .init:

 080490bc <.init>:
 80490bc:       55                      push   %ebp
 80490bd:       89 e5                   mov    %esp,%ebp
 . . .
 

mcookie

Cette commande génère un fichier témoin (« magic cookie »), un nombre hexadécimal pseudo-aléatoire de 128 bits (32 caractères) qui est habituellement utilisé par les serveurs X comme « signature » pour l'authentification. Elle peut être utilisée dans un script comme une solution sale mais rapide pour générer des nombres aléatoires.

random000=$(mcookie)

Évidemment, un script peut utiliser md5 pour obtenir le même résultat.

# Génère la somme de contrôle md5 du script lui-même.
 random001=`md5sum $0 | awk '{print $1}'`
# Utilise awk pour supprimer le nom du fichier

mcookie est aussi une autre facon de générer un nom de fichier « unique ».

Exemple 15.58. Générateur de nom de fichier

#!/bin/bash
# tempfile-name.sh :  générateur de fichier temporaire.

BASE_STR=`mcookie`   # Chaîne magique de 32 caractères.
POS=11               # Position arbitraire dans la chaîne magique.
LONG=5               # Pour obtenir $LONG caractères consécutifs.

prefixe=temp         #  C'est après tout un fichier "temp"oraire.
                     #  Pour que le nom soit encore plus "unique", génère le
                     #+ préfixe du nom du fichier en utilisant la même méthode
                     #+ que le suffixe ci-dessous.

suffixe=${BASE_STR:POS:LONG}
                     # Extrait une chaîne de cinq caractères, commençant à la
                     # position 11.

nomfichiertemporaire=$prefixe.$suffixe
                     # Construction du nom du fichier.

echo "Nom du fichier temporaire = "$nomfichiertemporaire""

# sh tempfile-name.sh
# Nom du fichier temporaire = temp.e19ea

#  Comparez cette méthode de création de noms de fichier uniques
#+ avec la méthode 'date' dans ex51.sh.

exit 0

units

Généralement appelé de façon interactive, cet utilitaire peut être utilisé dans un script. Il sert à convertir des mesures en différentes unités.

Exemple 15.59. Convertir des mètres en miles

#!/bin/bash
# unit-conversion.sh


convertir_unites ()  # Prend comme arguments les unités à convertir.
{
  cf=$(units "$1" "$2" | sed --silent -e '1p' | awk '{print $2}')
  # Supprime tout sauf le facteur conversion.
  echo "$cf"
}  

Unite1=miles
Unite2=meters
facteur_conversion=`convertir_unites $Unite1 $Unite2`
quantite=3.73

resultat=$(echo $quantite*$facteur_conversion | bc)

echo "Il existe $resultat $Unite2 dans $quantite $Unit1."

#  Que se passe-t'il si vous donnez des unités incompatibles, telles que
#+ "acres" et "miles" ?

exit 0

m4

Trésor caché, m4 est un puissant filtre de traitement des macros. ^[62] Langage pratiquement complet, m4 fut écrit comme pré-processeur pour RatFor avant de s'avérer être un outil autonome très utile. En plus de ses possibilités étendues d'interpolation de macros, m4 intègre les fonctionnalités d'eval, tr et awk.

Un très bon article sur m4 et ses utilisations a été écrit pour le numéro d'avril 2002 du Linux Journal.

Exemple 15.60. Utiliser m4

#!/bin/bash
# m4.sh : Utiliser le processeur de macros m4

# Chaîne de caractères
chaine=abcdA01
echo "len($chaine)" | m4                           # 7
echo "substr($chaine,4)" | m4                      # A01
echo "regexp($chaine,[0-1][0-1],\&Z)" | m4         # 01Z

# Arithmétique
echo "incr(22)" | m4                               # 23
echo "eval(99 / 3)" | m4                           # 33

exit 0

doexec

doexec permet de transmettre une liste quelconque d'arguments à un binaire exécutable. En particulier , le fait de transmettre argv[0] (qui correspond à $0 dans un script) permet à l'exécutable d'être invoqué avec des noms différents et d'agir en fonction de cette invocation. Ceci n'est qu'une autre façon de passer des options à un exécutable.

Par exemple , le répertoire /usr/local/bin peut contenir un binaire appelé « aaa ». doexec /usr/local/bin/aaa list affichera la liste de tous les fichiers du répertoire courant qui commencent par un « a ». Appeler le même binaire par doexec /usr/local/bin/aaa delete détruira ces fichiers.

Note

Les différentes actions d'un exécutable doivent être définies à l'intérieur du code exécutable lui-même. De façon similaire au script suivant :

case `basename $0` in
 "name1" ) faire_qqchose;;
 "name2" ) faire_qqchose_d_autre;;
 "name3" ) encore_autre_chose;;
 *       ) quitter;;
 esac

dialog

La famille d'outils dialog fournit une méthode pour appeler des fenêtres de « dialog »ues interactives à partir d'un script. Les variations plus élaborées de dialog -- gdialog, Xdialog, et kdialog -- appelle en fait les outils X-Windows. Voir l'Exemple 33.19, « Widgets appelés à partir d'un script shell ».

sox

La commande sox, ou « sound exchange » (échange de sons), joue et réalise des transformations sur des fichiers son. En fait, l'exécutable /usr/bin/play (maintenant obsolète) n'est rien de plus qu'un emballage shell pour sox.

Par exemple, sox fichierson.wav fichierson.au modifie un fichier son WAV en fichier son AU (format audio de Sun).

Les scripts shells correspondent parfaitement à des exécutions nombreuses comme les opérations de sox sur des fichiers son. Par exemple, voir le guide pratique « Linux Radio Timeshift » et le projet MP3do.