16.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 au choix de l'utilisateur.

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 16.54. 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 16.55. Compteur de lettres

#!/bin/bash
# letter-count.sh: Counting letter occurrences in a text file.
# Written by Stefano Palmeri.
# Used in ABS Guide with permission.
# Slightly modified by document author.

MINARGS=2          # Script requires at least two arguments.
E_BADARGS=65
FILE=$1

let LETTERS=$#-1   # How many letters specified (as command-line args).
                   # (Subtract 1 from number of command-line args.)


show_help(){
           echo
           echo Usage: `basename $0` file letters  
           echo Note: `basename $0` arguments are case sensitive.
           echo Example: `basename $0` foobar.txt G n U L i N U x.
           echo
}

# Checks number of arguments.
if [ $# -lt $MINARGS ]; then
   echo
   echo "Not enough arguments."
   echo
   show_help
   exit $E_BADARGS
fi  


# Checks if file exists.
if [ ! -f $FILE ]; then
    echo "File \"$FILE\" does not exist."
    exit $E_BADARGS
fi



# Counts letter occurrences .
for n in `seq $LETTERS`; do
      shift
      if [[ `echo -n "$1" | wc -c` -eq 1 ]]; then             #  Checks arg.
             echo "$1" -\> `cat $FILE | tr -cd  "$1" | wc -c` #  Counting.
      else
             echo "$1 is not a  single char."
      fi  
done

exit $?

#  This script has exactly the same functionality as letter-count2.sh,
#+ but executes faster.
#  Why?

Note

Avec plus de fonctionnalités que seq, jot est un outil classique UNIX qui n'est pas normalement 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 16.56. 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

Note

Peggy Russell indique :

Il est souvent nécessaire d'inclure un eval pour que les espaces et les guillements soient traités correctement.

args=$(getopt -o a:bc:d -- "$@")
eval set -- "$args"

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

run-parts

La commande run-parts ^[79] 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 le redirigeant 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

Soyez très prudent quand vous redirigez yes vers une commande potentiellement dangereuse pour votre système, comme fsck ou fdisk. De telles redirections peuvent générer des effets secondaires inattendus.

Note

La commande yes analyse les variables, plus précisément elle affiche les variables après les avoir analysées. 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é » particulière peut servir à fabriquer à la volée un fichier ASCII très gros :

bash$ yes $PATH > enorme_fichier.txt
Ctl-C              
              

Pensez à taper Ctl-C très vite, sans quoi vous risquez d'en avoir pour votre argent...

La commande yes peut être émulée à l'aide d'une function de script très simple.

yes ()
{ # Émulation simpliste de "yes" ...
  local TEXTE_PAR_DEFAUT="y"
  while [ true ]   # Boucle infinie.
  do
    if [ -z "$1" ]
    then
      echo "$TEXTE_PAR_DEFAUT"
    else           # S'il y a un argument ...
      echo "$1"    # ... le calculer et l'afficher.
    fi
  done             #  Seule chose qui manque :
}                  #+ les options --help et --version.

banner

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

NB : banner a été retirée de beaucoup de distributions GNU/Linux.

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. ^[80] 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 métiers de plomberie]

C'est un opérateur de redirection avec une petite différence : comme le « T » du plombier, cette commande permet de « siphonner » vers un fichier la sortie d'une commande ou de plusieurs commandes dans un tube, sans en affecter le résultat. Cela sert quand on veut envoyer le résultat du processus en cours vers un fichier ou vers une imprimante, par exemple en déboggage.

                               (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 des
#+ fichiers en "listefichiers", avant la suppression des lignes en
#+ double par 'uniq'.

mkfifo

Cette obscure commande 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). ^[81] Classiquement, un processus écrit dans le FIFO et un autre y lit. Voir l'Exemple A.14, « fifo: Faire des sauvegardes journalières, avec des tubes nommés ».

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

mkfifo pipe1   # Mais oui, les tubes peuvent porter des noms
mkfifo pipe2   # D'où l'appellation de "tube nommé"

(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

Cette commande un peu obscure et très crainte, duplication de données (data duplicator en anglais), bien qu'elle ait été à l'origine un outil d'échange de données entre les bandes magnétiques des mini-ordinateurs unix et les mainframes IBM, a toujours son utilité. dd copie simplement un fichier (ou stdin/stdout) mais en effectuant une conversion. ASCII/EBCDIC est une « conversion » possible ^[82] 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, normalement 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 16.57. Un script qui se copie lui-même

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

# This script copies itself.

file_subscript=copy

dd if=$0 of=$0.$file_subscript 2>/dev/null
# Suppress messages from dd:   ^^^^^^^^^^^

exit $?

#  A program whose only output is its own source code
#+ is called a "quine" per Willard Quine.
#  Does this script qualify as a quine?

Exemple 16.58. S'exercer à dd

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

# Script by Stephane Chazelas.
# Somewhat modified by ABS Guide author.

infile=$0       # This script.
outfile=log.txt # Output file left behind.
n=3
p=5

dd if=$infile of=$outfile bs=1 skip=$((n-1)) count=$((p-n+1)) 2> /dev/null
# Extracts characters n to p (3 to 5) from this script.

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

echo -n "hello world" | dd cbs=1 conv=unblock 2> /dev/null
# Echoes "hello world" vertically.
# Why? A newline follows each character dd emits.

exit 0

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

Exemple 16.59. 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 : Recopier 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

De même, dd est capable de créer des disques flash amorçables. dd if=image.iso of=/dev/sdb Voyez pour cela le site de Marlow sur les clés USB.

Comme autres exemples d'applications de dd, on peut citer l'initialisation d'un fichier swap temporaire (Exemple 31.2, « Créer un fichier de swap en utilisant /dev/zero ») ou d'un disque en mémoire (Exemple 31.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 16.60. 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ée en octal (base 8) ou dans une autre base. C'est très utile pour voir ou traiter des fichiers binaires ou sources de données illisibles du système -- par exemple /dev/urandom -- ou encore pour filtrer des données binaires.

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.16, « Réinitialiser RANDOM » et Exemple A.36, « 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 md5sum 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 16.61. 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 16.62. 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 ^[83]. Pratiquement un langage 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 16.63. 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

xmessage

Cette variante basée sur X de echo affiche un dialogue sur le bureau.

xmessage Clic gauche pour continuer -button okay

zenity

L'outil zenity permet d'afficher un dialogue utilisant les composants GTK+ et très intéressant pour l'écriture de scripts.

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 widgets X-Windows.

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.