Chapitre 32. Trucs et astuces

 

Turandot: Gli enigmi sono tre, la morte una!

Caleph: No, no! Gli enigmi sono tre, una la vita!

 Puccini

Affecter des mots réservés à des noms de variables.
case=value0       # Pose problème.
23skidoo=value1   # Et là-aussi.
# Les noms de variables avec un chiffre sont réservés par le shell.
# Essayez _23skidoo=value1. Commencer les variables avec un tiret bas est OK.

# Néanmoins...      n'utiliser que le tiret bas ne fonctionnera pas.
_=25
echo $_           # $_ est une variable spéciale initialisée comme étant le
                  # dernier argument de la dernière commande.

xyz((!*=value2    # Pose de sévères problèmes.

Utiliser un tiret ou d'autres caractères réservés dans un nom de variable.
var-1=23
# Utilisez 'var_1' à la place.

Utiliser le même nom pour une variable et une fonction. Ceci rend le script difficile à comprendre.
fais_quelquechose ()
{
  echo "Cette fonction fait quelque chose avec \"$1\"."
}

fais_quelquechose=fais_quelquechose

fais_quelquechose fais_quelquechose

# Tout ceci est légal, mais porte à confusion.

Utiliser des espaces blancs inappropriés (en contraste avec d'autres langages de programmation, Bash peut être assez chatouilleux avec les espaces blancs).
var1 = 23   # 'var1=23' est correct.
# Sur la ligne ci-dessus, Bash essaie d'exécuter la commande "var1"
# avec les arguments "=" et "23".
	
let c = $a - $b   # 'let c=$a-$b' et 'let "c = $a - $b"' sont corrects.

if [ $a -le 5]    # if [ $a -le 5 ]   est correct.
# if [ "$a" -le 5 ]   est encore mieux.
# [[ $a -le 5 ]] fonctionne aussi.

Supposer que des variables non initialisées (variables avant qu'une valeur leur soit affectée) sont << remplies de zéros >>. Une variable non initialisée a une valeur << null >>, et non pas zéro.

#!/bin/bash

echo "variable_non_initialisee = $variable_non_initialisee"
# variable_non_initialisee =

Mixer = et -eq dans un test. Rappelez-vous, = permet la comparaison de variables littérales et -eq d'entiers.
if [ "$a" = 273 ]      # $a est-il un entier ou une
                                               # chaîne?
if [ "$a" -eq 273 ]    # Si $a est un entier.

# Quelque fois vous pouvez mélanger -eq et = sans conséquences mauvaises.
# Néanmoins...


a=273.0   # pas un entier.
	   
if [ "$a" = 273 ]
then
  echo "La comparaison fonctionne."
else  
  echo "La comparison ne fonctionne pas."
fi    # La comparison ne fonctionne pas.

# Pareil avec   a=" 273"  et a="0273".


# De même, problèmes en essayant d'utiliser "-eq" avec des valeurs non entières.

if [ "$a" -eq 273.0 ]
then
  echo "a = $a'
fi  # Echoue avec un message d'erreur.  
# test.sh: [: 273.0: integer expression expected

Mélanger les opérateurs de comparaison d'entiers et de chaînes.
#!/bin/bash
# bad-op.sh	

nombre=1

while [ "$nombre" < 5 ]    # Mauvais! Devrait être   while [ "nombre" -lt 5 ]
do
  echo -n "$nombre "
  let "nombre += 1"
done  

# En lançant ceci, un message d'erreur :
# bad-op.sh: 5: No such file or directory

Quelque fois, des variables à l'intérieur des crochets de << test >> ([ ]) ont besoin d'être mis entre guillemets (doubles). Ne pas le faire risque de causer un comportement inattendu. Voir Exemple 7-6, Exemple 16-4 et Exemple 9-6.

Les commandes lancées à partir d'un script peuvent échouer parce que le propriétaire d'un script ne possède pas les droits d'exécution. Si un utilisateur ne peut exécuter une commande à partir de la ligne de commande, alors la placer dans un script échouera de la même façon. Essayer de changer les droits de la commande en question, peut-être même en initialisant le bit suid (en tant que root, bien sûr).

Essayer d'utiliser - comme opérateur de redirection (qu'il n'est pas) résultera habituellement en une surprise peu plaisante.
commande1 2> - | commande2  # Essayer de rediriger la
                                           # sortie d'erreurs dans un tube...
#    ...ne fonctionnera pas

commande1 2>& - | commande2  # Aussi futile.

Merci, S.C.

Utiliser les fonctionnalités de Bash version 2+ peut poser des soucis avec les messages d'erreur. Les anciennes machines Linux peuvent avoir une version 1.XX de Bash en installation par défaut.
#!/bin/bash

minimum_version=2
# Comme Chet Ramey ajoute constamment de nouvelles fonctionnalités à Bash,
# vous pourriez configurer $minimum_version à 2.XX, ou quoi que ce soit de plus
# approprié.
E_MAUVAISE_VERSION=80

if [ "$BASH_VERSION" \< "$minimum_version" ]
then
  echo "Ce script fonctionne seulement avec Bash, version $minimum ou ultérieure."
  echo "Une mise à jour est fortement recommendée."
  exit $E_MAUVAISE_VERSION
fi

...

Utiliser les fonctionnalités spécifiques à Bash dans un script shell Bourne (#!/bin/sh) sur une machine non Linux peut causer un comportement inattendu. Un système Linux crée habituellement un alias sh vers bash, mais ceci n'est pas nécessairement vrai pour une machine UNIX générique.

Un script avec des retours à la ligne DOS (\r\n) ne pourra pas s'exécuter car #!/bin/bash\r\n n'est pas reconnu, pas la même chose que l'attendu #!/bin/bash\n. La correction est de convertir le script en des retours chariots style UNIX.

#!/bin/bash

echo "Ici"

unix2dos $0    # Le script se modifie lui-même au format DOS.
chmod 755 $0   # et modifie son droit d'exécution.
               # La commande 'unix2dos' supprime le doit d'exécution.

./$0           # Le script essaie de se lancer de nouveau.
               # Mais cela ne fonctionnera pas en tant que format DOS.

echo "Là"

exit 0

Un script shell commenaçant par #!/bin/sh peut ne pas se lancer dans un mode de compatibilité complète avec Bash. Quelques fonctions spécifiques à Bash pourraient être désactivées. Les scripts qui ont besoin d'un accès complet à toutes les extensions spécifiques à Bash devraient se lancer avec #!/bin/bash.

Un script peut ne pas faire un export de ses variables à son processus parent, le shell ou à l'environnement. Comme nous l'avons appris en biologie, un processus fils peut hériter de son parent, mais le contraire n'est pas vrai.
NIMPORTEQUOI=/home/bozo
export NIMPORTEQUOI
exit 0
bash$ echo $NIMPORTEQUOI

bash$ 
De façon certaine, au retour à l'invite commande, $NIMPORTEQUOI reste sans valeur.

Initialiser et manipuler des variables dans un sous-shell, puis essayer d'utiliser ces mêmes variables en dehors du sous-shell résultera en une mauvaise surprise.

Exemple 32-1. Problèmes des sous-shell

#!/bin/bash
# Problèmes des variables dans un sous-shell.

variable_externe=outer
echo
echo "variable_externe = $variable_externe"
echo

(
# Début du sous-shell

echo "variable_externe à l'intérieur du sous-shell = $variable_externe"
variable_interne=interne  # Configure
echo "variable_interne à l'intérieur du sous-shell = $variable_interne"
variable_externe=interne  # Sa valeur va-t'elle changer globalement?
echo "variable_externe à l'intérieur du sous-shell = $variable_externe"

# Fin du sous-shell
)

echo
echo "variable_interne à l'extérieur du sous-shell = $variable_interne"  # Déinitialise.
echo "variable_externe à l'extérieur du sous-shell = $variable_externe"  # Non modifié.
echo

exit 0

Envoyer dans un tube la sortie de echo pour un read peut produire des résultats inattendus. Dans ce scénario, read agit comme si elle était lancée dans un sous-shell. A la place, utilisez la commande set (comme dans Exemple 11-14).

Exemple 32-2. Envoyer dans un tube la sortie de echo pour un read

#!/bin/bash
#  badread.sh:
#  Essai d'utiliser 'echo' et 'read'
#+ pour affecter non interactivement des variables.

a=aaa
b=bbb
c=ccc

echo "un deux trois" | read a b c
# Essaie d'affecter a, b et c.

echo
echo "a = $a"  # a = aaa
echo "b = $b"  # b = bbb
echo "c = $c"  # c = ccc
# L'affectation a échoué.

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

# Essaie l'alternative suivante.

var=`echo "un deux trois"`
set -- $var
a=$1; b=$2; c=$3

echo "-------"
echo "a = $a"  # a = un
echo "b = $b"  # b = deux
echo "c = $c"  # c = trois 
# Affectation réussie.

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

#  Notez aussi qu'un echo pour un 'read' fonctionne à l'intérieur d'un
#+ sous-shell.
#  Néanmoins, la valeur de la variable change *seulement* à l'intérieur du
#+ sous-shell.

a=aaa          # On recommence.
b=bbb
c=ccc

echo; echo
echo "un deux trois" | ( read a b c;
echo "A l'intérieur du sous-shell: "; echo "a = $a"; echo "b = $b"; echo "c = $c" )
# a = un
# b = deux
# c = trois
echo "-----------------"
echo "A l'extérieur du sous-shell: "
echo "a = $a"  # a = aaa
echo "b = $b"  # b = bbb
echo "c = $c"  # c = ccc
echo

exit 0

Utiliser les commandes << suid >> à l'intérieur de scripts est risqué et peut compromettre la sécurité de votre système. [1]

Utiliser des scripts shell en programmation CGI peut être assez problématique. Les variables des scripts shell ne sont pas << sûres >>, et ceci peut causer un comportement indésirable en ce qui concerne CGI. De plus, il est difficile de << sécuriser >> des scripts shell.

Les scripts Bash écrits pour Linux ou BSD peuvent nécessiter des corrections pour fonctionner sur une machine UNIX commerciale. De tels scripts emploient souvent des commandes et des filtres GNU qui ont plus de fonctionnalités que leur contrepartie UNIX. Ceci est particulièrement vrai pour les utilitaires texte comme tr.

 

Danger is near thee --

Beware, beware, beware, beware.

Many brave hearts are asleep in the deep.

So beware --

Beware.

 A.J. Lamb and H.W. Petrie

Notes

[1]

Ajouter le droit suid sur le script lui-même n'a aucun effet.

>

Utilitaire inter-plateforme d'archivage et de compression de fichiers compatible avec DOS pkzip.exe. Les archives << Zip >> semblent être un medium plus acceptable pour l'échange sur Internet que les << archives tar >>.

unarc, unarj, unrar

Ces utilitaires Linux permettent de déballer des archives compressées avec les programmes DOS arc.exe, arj.exe et rar.exe.

Informations sur les fichiers

file

Un utilitaire pour identifier le type des fichiers. La commande file nom-fichier renvoiera une spécification du fichier nom-fichier, telle que ascii text ou data. Il utilise les numéros magiques trouvés dans /usr/share/magic, /etc/magic ou /usr/lib/magic, suivant la distribution Linux/UNIX.

L'option -f fait que file tourne en mode batch, pour lire à partir d'un fichier désigné une liste de noms de fichiers à analyser. L'option -z, lorsqu'elle est utilisé sur un fichier compressé, essaie d'analyser le type du fichier décompressé.

bash$ file test.tar.gz
test.tar.gz: gzip compressed data, deflated, last modified: Sun Sep 16 13:34:51 2001, os: Unix

bash file -z test.tar.gz
test.tar.gz: GNU tar archive (gzip compressed data, deflated, last modified: Sun Sep 16 13:34:51 2001, os: Unix)
	      

Exemple 12-24. supprimer les commentaires de programmes C

#!/bin/bash
# strip-comment.sh: Supprime les commentaires (/* COMMENT */) d'un progamme C.

E_SANSARGS=65
E_ERREURARG=66
E_MAUVAIS_TYPE_FICHIER=67

if [ $# -eq "$E_SANSARGS" ]
then
  echo "Usage: `basename $0` fichier-C" >&2 # Message d'erreur vers stderr.
  exit $E_ERREURARG
fi  

# Test du type de fichier.
type=`eval file $1 | awk '{ print $2, $3, $4, $5 }'`
# "file $1" affiche le type du fichier...
# puis awk supprime le premier champ, le nom du fichier...
# enfin, le résultat remplit la variable "type".
type_correct="ASCII C program text"

if [ "$type" != "$type_correct" ]
then
  echo
  echo "Ce script fonctionne uniquement sur les fichiers C."
  echo
  exit $E_MAUVAIS_TYPE_FICHIER
fi  


# Script sed assez complexe:
#--------
sed '
/^\/\*/d
/.*\/\*/d
' $1
#--------
#  Facile à comprendre si vous prenez quelques heures pour apprendre les
#+ concepts de sed.


#  Il est possible d'ajouter une ligne supplémentaire au script sed pour gérer
#+ le cas où la ligne de code a un commentaire le suivant, sur la même ligne.
#  Ceci est laissé en exercice (difficile).

# De même, le code ci-dessus supprime les lignes avec un "*/" ou "/*",
# ce qui n'est pas un effet désirable.

exit 0


# ----------------------------------------------------------------
# Le code ci-dessous ne s'exécutera pas à cause du 'exit 0' ci-dessus.

# Stephane Chazelas suggère l'alternative suivante:

usage() {
  echo "Usage: `basename $0` fichier-C" >&2
  exit 1
}

BIZARRE=`echo -n -e '\377'`   # ou BIZARRE=$'\377'
[[ $# -eq 1 ]] || usage
case `file "$1"` in
  *"C program text"*) sed -e "s%/\*%${BIZARRE}%g;s%\*/%${BIZARRE}%g" "$1" \
     | tr '\377\n' '\n\377' \
     | sed -ne 'p;n' \
     | tr -d '\n' | tr '\377' '\n';;
  *) usage;;
esac

# Ceci ne fonctionne pas avec, par exemple:
# printf("/*");
# or
# /*  /* commentaire intégré bogué */
#
# Pour gérer tous les cas spécifiques (commentaires dans des chaînes,
# commentaires dans des chaînes où se trouve un \", \\" ...) la seule façon est
# d'écrire un analyseur C
# (lex ou yacc peut-être?).

exit 0
which

which commande-xxx donne le chemin complet vers << commande-xxx >>. C'est utile pour trouver si une commande ou un utilitaire particulier est installé sur le système.

$bash which rm
/usr/bin/rm

whereis

Similair à which, ci-dessus, whereis commande-xxx donne le chemin complet vers << commande-xxx >>, mais aussi sa page man.

$bash whereis rm
rm: /bin/rm /usr/share/man/man1/rm.1.bz2

whatis

whatis fichierxxx recherche << ficheirxxx >> dans la base de données whatis. C'est utile pour identifier les commandes système et les fichiers de configuration importants. Considérez-le en tant que commande man simplifiée.

$bash whatis whatis
whatis               (1)  - search the whatis database for complete words

Exemple 12-25. Explorer /usr/X11R6/bin

#!/bin/bash

# Que sont tous ces mystérieux binaires dans /usr/X11R6/bin?

REPERTOIRE="/usr/X11R6/bin"
# Essayez aussi "/bin", "/usr/bin", "/usr/local/bin", etc.

for fichier in $REPERTOIRE/*
do
  whatis `basename $fichier`   # affiche des informations sur le binaire.
done

exit 0
# Vous pouvez souhaiter rediriger la sortie de ce script, de cette façon:
# ./what.sh >>whatis.db
# ou la visualiser une page à la fois sur stdout,
# ./what.sh | less

Voir aussi Exemple 10-3.

vdir

Affiche une liste détaillée du contenu du répertoire. L'effet est similaire à ls -l.

Il fait partie de GNU fileutils.

bash$ vdir
total 10
 -rw-r--r--    1 bozo  bozo      4034 Jul 18 22:04 data1.xrolo
 -rw-r--r--    1 bozo  bozo      4602 May 25 13:58 data1.xrolo.bak
 -rw-r--r--    1 bozo  bozo       877 Dec 17  2000 employment.xrolo

bash ls -l
total 10
 -rw-r--r--    1 bozo  bozo      4034 Jul 18 22:04 data1.xrolo
 -rw-r--r--    1 bozo  bozo      4602 May 25 13:58 data1.xrolo.bak
 -rw-r--r--    1 bozo  bozo       877 Dec 17  2000 employment.xrolo
	      

locate, slocate

La commande locate cherche les fichiers en utilsant une base de données stockée pour ce seul but. La commande slocate est la version sécurisée de locate (qui pourrait être un alias de slocate).

$bash locate hickson
/usr/lib/xephem/catalogs/hickson.edb

readlink

Déréférence le fichier sur lequel pointe un lien symbolique.

bash$ readlink /usr/bin/awk
../../bin/gawk
	      

strings

Utiliser la commande strings pour trouver les chaînes de caractères affichables dans un fichier binaire ou de données. Elle listera les séquences de caractères affichables trouvées dans le fichier cible. C'est intéressant pour un examen rapide (et sale) d'un core dump ou pour regarder un fichier image inconnu (strings fichier-image | more pourrait afficher quelque chose comme JFIF, qui identifierait le fichier en tant que graphique jpeg). Dans un script, vous devriez probablement analyser la sortie de strings avec grep ou sed. Voir Exemple 10-7 et Exemple 10-9.

Exemple 12-26. Une commande strings << améliorée >>

#!/bin/bash
# wstrings.sh: "word-strings" (commande "strings" améliorée)
#
#  Ce script filtre la sortie de "strings" en la comparant avec une liste de
#+ mots communs.
#  Ceci élimine efficacement tout le bruit et n'affiche que les mots reconnus.

# =================================================================
#               Vérification standard de(s) argument(s) du script
ARGS=1
E_MAUVAISARGS=65
E_AUCUNFICHIER=66

if [ $# -ne $ARGS ]
then
  echo "Usage: `basename $0` nomfichier"
  exit $E_MAUVAISARGS
fi

if [ -f "$1" ]                        # Vérifie si le fichier existe.
then
    nom_fichier=$1
else
    echo "Le fichier \"$1\" n'existe pas."
    exit $E_AUCUNFICHIER
fi
# =================================================================


LONGUEUR_CHAINE_MINIMUM=3                 #  Longueur minimum d'une chaîne.
FICHIER_MOTS=/usr/share/dict/linux.words  #  Dictionnaire.
                                          #  Vous pouvez spécifier un autre
					  #+ fichier de mots, à condition que
					  #+ son format soit d'un mot par ligne.


listemots=`strings "$1" | tr A-Z a-z | tr '[:space:]' Z | \
tr -cs '[:alpha:]' Z | tr -s '\173-\377' Z | tr Z ' '`

# Traduit la sortie de la commande 'strings' avec de multiples passes de 'tr'.
#  "tr A-Z a-z" réalise une conversion en minuscule.
#  "tr '[:space:]'" change les espaces blancs par des Z.
#  "tr -cs '[:alpha:]' Z" change les caractères non alphabetiques en Z.
#+ et ne conserve qu'un seul Z pour les Z successifs.
#  "tr -s '\173-\377' Z" convertit tous les caractères après 'z' en Z
#+ et ne conserve qu'un seul Z pour les Z successifs
#+ ce qui supprime tous les caractères bizarres que la précédente passe aurait
#+ oublié de gérer.
#  Finalement, "tr Z ' '" convertit tous les Z en espaces blancs,
#+ ce qui sera vu comme des mots séparés dans la boucle ci-dessous.

#  Notez que la technique de remplissage de la sortie de 'tr' vers lui-même,
#+ mais avec different arguments et/ou options à chaque passe.


for mot in $listemots    # Important:
                         # $listemots ne doit pas être entre guillemets ici.
                         # "$listemots" ne fonctionne pas.
                         # Pourquoi?
do

  longueur_chaine=${#mot}                     # Longueur de la chaîne.
  if [ "$longueur_chaine" -lt "$LONGUEUR_CHAINE_MINIMUM" ]
  then   # Ne pas tenir compte des petites chaînes.
    continue
  fi

  grep -Fw $mot "$FICHIER_MOTS"       # Correspond seulement aux mots complets.

done  


exit 0

Comparaison

diff, patch

diff: utilitaire de comparaison de fichiers flexible. Il compare les fichiers cibles ligne par ligne, séquentiellement. Dans certaines applications, telles que la comparaison de dictionnaires de mots, il peut être utile pour filtrer les fichiers avec sort et uniq avant de les envoyer via un tube à diff. diff fichier-1 fichier-2 affiche en sortie les lignes qui différent des deux fichiers, avec des symbôles indiquant à quel fichier appartient la ligne en question.

L'option --side-by-side de diff affiche en sortie chaque fichier comparé, ligne pat ligne, dans des colonnes séparées, et avec les lignes ne correspondant pas marquées. Les options -c et -u rendent la sortie de la commande plus facile à interpréter.

Il existe de nombreuses interfaces agréables pour diff, comme spiff, wdiff, xdiff et mgdiff.

Astuce

La commande diff renvoie un état de sortie de 0 si les fichiers comparés sont identiques et 1 si ils ne le sont pas. Cela permet d'utiliser diff dans une construction de test à l'intérieur d'un script shell (voir ci-dessous).

Une utilisation commune de diff est de générer des fichiers de différence à utiliser avec patch. L'option -e permet la génération de tels fichiers, à utiliser avec des scripts ed ou ex.

patch: utilitaire de gestion de versions. Suivant un fichier de différences généré par diff, patch peut mettre à jour une version précédente d'un paquetage en une nouvelle version. Il est bien plus convenable de distribuer un fichier << diff >> sensiblement plus petit que le corps entier du paquetage revu. Les correctifs (<< patches >>) du noyau sont devenus la méthode préférée pour distribuer les fréquentes mises à jour du noyau Linux.

patch -p1 <correctif
# Prend toutes les modifications indiquées dans 'correctif'
# et les applique aux fichiers référencés.
# Ceci met à jour le paquetage en une nouvelle version.

Applicquer un correctif au noyau:

cd /usr/src
gzip -cd patchXX.gz | patch -p0
# Mettre à jour le source du noyau en utilisant 'patch'.
# De la documentation du noyau Linux, "README",
# par un auteur anonyme (Alan Cox?).

Note

La commande diff peut aussi comparer récursivement les répertoires (et les fichiers qui s'y trouvent).

bash$ diff -r ~/notes1 ~/notes2
Only in /home/bozo/notes1: fichier02
 Only in /home/bozo/notes1: fichier03
 Only in /home/bozo/notes2: fichier04
	      

Astuce

Utiliser zdiff pour comparer des fichiers gzipped.

diff3

Une version étendue de diff qui compare trois fichiers en une fois. Cette commande renvoie un état de sortie de 0 si l'exécution est réussie, mais malheureusement, cela ne donne aucune information sur le résultat de la comparaison.

bash$ diff3 fichier-1 fichier-2 fichier-3
====
 1:1c
   Ceci est la ligne 1 de "fichier-1"
 2:1c
   Ceci est la ligne 1 de "fichier-2"
 3:1c
   Ceci est la ligne 1 de "fichier-3"
	      

sdiff

Compare et/ou édite les deux fichiers pour les assembler dans un fichier de sortie. Dû à sa nature interactive, cette commande trouvera peut d'utilité dans un script.

cmp

La commande cmp est une version simplifiée de diff, ci-dessus. Alors que diff reporte les différences entre deux fichiers, cmp montre simplement à quel point ils diffèrent.

Note

Comme diff, cmp renvoie un état de sortie de 0 si les fichiers comparés sont identiques et de 1 si ils diffèrent. Ceci permet une utilisation dans une construction de test à l'intérieur d'un script shell.

Exemple 12-27. Utiliser cmp pour comparer deux fichiers à l'intérieur d'un script.

#!/bin/bash

ARGS=2  # Deux arguments attendus par le script.
E_MAUVAISARGS=65
E_ILLISIBLE=66

if [ $# -ne "$ARGS" ]
then
  echo "Usage: `basename $0` fichier1 fichier2"
  exit $E_MAUVAISARGS
fi

if [[ ! -r "$1" || ! -r "$2" ]]
then
  echo "Les deux fichiers à comparer doivent exister et être lisibles."
  exit $E_ILLISIBLE
fi

cmp $1 $2 &> /dev/null  # /dev/null enterre la sortie de la commande "cmp".
#   cmp -s $1 $2  a le même résultat ("-s" option de silence pour "cmp")
#   Merci à Anders Gustavsson pour nous l'avoir indiqué.
#
# Fonctionne aussi avec 'diff', c'est-à-dire   diff $1 $2 &> /dev/null

if [ $? -eq 0 ]         # Teste du code de sortie de la commande "cmp".
then
  echo "Le fichier \"$1\" est identique au fichier \"$2\"."
else  
  echo "Le fichier \"$1\" diffère du fichier \"$2\"."
fi

exit 0

Astuce

Utiliser zcmp sur des fichiers gzip.

comm

Utilitaire de comparaison de fichiers versatile. Les fichiers doivent être triés pour qu'il soit utile.

comm -options premier-fichier second-fichier

comm fichier-1 fichier-2 affiche trois colonnes:

  • colonne 1 = lignes uniques à fichier-1

  • colonne 2 = lignes uniques à fichier-2

  • colonne 3 = lignes communes aux deux.

Les options permettent la sortie d'une ou plusieurs colonnes.

  • -1 supprime la colonne 1

  • -2 supprime la colonne 2

  • -3 supprime la colonne 3

  • -12 supprime les deux colonnes 1 et 2, etc.

Utilitaires

basename

Supprime le chemin d'un nom de fichier, en affichant seulement le nom. La construction basename $0 permet au script de connaître son nom, c'est-à-dire le nom par lequel il a été invoqué. Ceci peut être utilisé pour les messages d'<< usage >> si, par exemple, un script est appelé sans ses arguments:
echo "Usage: `basename $0` arg1 arg2 ... argn"

dirname

Supprime le basename d'un nom de fichier, en affichant que le chemin.

Note

basename et dirname peuvent s'exécuter sur des chaînes de caractères arbitraires. L'argument n'a pas besoin de référer un fichier existant, voire même un fichier (voir Exemple A-8).

Exemple 12-28. basename et dirname

#!/bin/bash

a=/home/bozo/daily-journal.txt

echo "Nom de base       de /home/bozo/daily-journal.txt = `basename $a`"
echo "Nom du répertoire de /home/bozo/daily-journal.txt = `dirname $a`"
echo
echo "Mon répertoire personnel est `basename ~/`."   # Fonctionne aussi avec ~.
echo "Le chemin de mon répertoire personnel est `dirname ~/`."  # Fonctionne aussi avec ~.

exit 0
split

Utilitaire pour diviser un fichier en plusieurs petites parties. Habituellement utilisé pour diviser un gros fichier en fichiers tenant sur une disquette ou pour préparer un courrier électronique ou pour les télécharger.

sum, cksum, md5sum

Ces utilitaires ont pour but de vérifier une somme de contrôle. Une somme de dontrôle est un nombre calculé à partir du contenu d'un fichier, dans le but de vérifier son intégrité. Un script peut se référer à une liste de sommes de contrôle pour des raisons de sécurité, comme pour s'assurer que des fichiers clés du système n'ont pas été modifié ou corrompu. Pour les applications de sécurité, utilisez la commande md5sum en 128 bits (message digest checksum).

bash$ cksum /boot/vmlinuz
1670054224 804083 /boot/vmlinuz


bash$ md5sum /boot/vmlinuz
0f43eccea8f09e0a0b2b5cf1dcf333ba  /boot/vmlinuz
	      

Notez que cksum affiche aussi la taille, en octet, du fichier cible.

Exemple 12-29. Vérifier l'intégrité d'un fichier

#!/bin/bash
# file-integrity.sh: Vérifie si les fichiers d'un répertoire donné ont été
#                    modifié.

E_REP_INEXISTANT=70
E_MAUVAIS_FICHIER_BD=71

fichierdb=File_record.md5
# Fichier pour stocker les enregistrements.


init_base_donnees ()
{
  echo ""$repertoire"" > "$fichierdb"
  # Ecrit le nom du répertoire sur la première ligne du fichier.
  md5sum "$repertoire"/* >> "$fichierdb"
  # Ajoute les sommes de contrôle md5 et les noms de fichiers.
}

verifie_base_donnees ()
{
  local n=0
  local nomfichier
  local somme_controle

  # ------------------------------------------------- #
  #  Cette vérification du fichier ne devrait être
  #+ inutile mais c'est mieux d'être sain que désolé.

  if [ ! -r "$fichierdb" ]
  then
	  echo "Incapable de lire les somme de contrôle du fichier de base de données!"
    exit $E_MAUVAIS_FICHIER_BD
  fi
  # ------------------------------------------------- #

  while read enregistrement[n]
  do

    repertoire_verifie="${enregistrement[0]}"
    if [ "$repertoire_verifie" != "$repertoire" ]
    then
      echo "Les répertoires ne correspondent pas!"
      # Essaie d'utiliser un fichier d'un autre répertoire.
      exit $E_REP_INEXISTANT
    fi

    if [ "$n" -gt 0 ]   # Pas de nom de répertoire.
    then
      nomfichier[n]=$( echo ${enregistrement[$n]} | awk '{ print $2 }' )
      #  md5sum écrit les enregistrements après,
      #+ effectue un contrôle des sommes, puis du fichier.
      somme_controle[n]=$( md5sum "${nomfichier[n]}" )

      if [ "${enregistrement[n]}" = "${somme_controle[n]}" ]
      then
        echo "${nomfichier[n]} non modifié."
      else
        echo "${nomfichier[n]} : ERREUR DE SOMME DE CONTROLE!"
	# Le fichier a été changé depuis la dernière vérification.
      fi

    fi  


    let "n+=1"
  done <"$fichierdb"       #  Lit les sommes de contrôle à partir du fichier de
                           #+ base de données.

}  

# =================================================== #
# main ()

if [ -z  "$1" ]
then
  repertoire="$PWD"     #  Si non spécifi,;
else                    #+ utilise le répertoire courant.
  repertoire="$1"
fi  

clear                   # Efface l'écran.

# ------------------------------------------------------------------ #
if [ ! -r "$fichierdb" ] # Besoin de créer un fichier de base de données.
  then
	  echo "Configuration de la base de données, \""$repertoire"/"$fichierdb"\"."; echo
    init_base_donnees
  fi  
# ------------------------------------------------------------------ #

verifie_base_donnees          # Fait le vrai travail.

echo 

#  Vous pouvez souhaiter rediriger stdout vers un fichier spécialement si le
#+ répertoire vérifié a de nombreux fichiers.

#  Pour une explication sur la vérificaton d'intégrité.
#+ considérez le paquetage #+ http://sourceforge.net/projects/tripwire/.

exit 0
shred

Efface de façon sécurisé un fichier en l'écrasant (en écrivant dessus) plusieurs fois avec des octets aléatoires avant de le supprimer. Cette commande a le même effet que Exemple 12-42, mais le fait de façon plus élégante et plus approfondie.

Il fait partie des utilitaires GNU fileutils.

Attention

Des technologies avancées peuvent toujours retrouvées le contenu d'un fichier, même après l'utilisation de shred.

Coder et crypter

uuencode

Cet utilitaire code des fichiers binaires en caractères ASCII, leur permettant d'être transmis dans le corps de message email ou d'être envoyé dans un groupe de nouvelles.

uudecode

Ceci inverse le codage, décode des fichiers passés par uuencode et récupère les binaires originaux.

Exemple 12-30. Décoder des fichier codés avec uudecode

#!/bin/bash

lignes=35        # Permet 35 lignes pour l'entête (très généreux generous).

for Fichier in *   # Teste tous les fichiers du répertoire courant...
do
  recherche1=`head -$lignes $Fichier | grep begin | wc -w`
  recherche2=`tail -$lignes $Fichier | grep end | wc -w`
  #  Les fichiers uuencodés ont un "begin" près du début et un "end" près de
  #+ la fin.
  if [ "$recherche1" -gt 0 ]
  then
    if [ "$recherche2" -gt 0 ]
    then
      echo "uudecoding - $Fichier -"
      uudecode $Fichier
    fi  
  fi
done  

#  Notez que lancer ce script sur lui-même le trompe et croie qu'il est un
#+ fichier uuencodé, parce qu'il contient les mots "begin" et "end".

# Exercice:
# Modifier ce script pour vérifier un entête de newsgroup.

exit 0

Astuce

La commande fold -s est utile (parfois dans un tube) pour décoder de long messages téléchargés à partir des groupes de nouvelles Usenet.

mimencode, mmencode

Les commandes mimencode et mmencode s'occupent du codage des pièces-jointes des courriers éléctroniques. Bien que les clients mail (MUA tels que pine ou kmail) gèrent normalement ceci automatiquement, ces utilitaires particuliers permettent de manipuler de telles pièces-jointes manuellement à partir de la ligne de commande ou dans un script shell.

crypt

A un moment, il était l'utilitaire de cryptage standard sous UNIX. [2] Des régulations gouvernementales, basées sur la politique, ont interdit l'export de logiciels de cryptage, ce qui a résulté en la disparition de la commande crypt de la majeure partie du monde UNIX, et il est toujours manquant sur la plupart des distributions Linux. Heureusement, des programmeurs ont réalisé un certain nombre d'alternatives, dont celle de l'auteur cruft (voir Exemple A-5).

Divers

mktemp

Crée un fichier temporaire avec un nom << unique >>.

PREFIX=nom_fichier
fichier_temporaire=`mktemp $PREFIX.XXXXXX`
#                          ^^^^^^ A besoin d'au moins 6 emplacements
#+                                dans le modèle de nom de fichier.
echo "nom de fichier_temporaire = $fichier_temporaire"
# nom fichier_temporaire = nom_fichier.QA2ZpY
#                 ou quelque chose de similaire...

make

Utilitaire pour construire et compiler des paquetages binaires. Il peut aussi être utilisé pour tout type d'opérations qui seraient déclenchées par une modification des fichiers source.

La commande make vérifie le Makefile, une liste de dépendances de fichiers et les opérations à réaliser.

install

Commande de copie de fichier à but spécifique, similaire à cp, mais est capable de modifier les droits et attributs des fichiers copiés. Cette commande semble fait uniquement pour l'installation de paquetages, et en tant que tel, il fait souvent son apparition dans les Makefiles (dans la section make install :). Il pourrait aussi trouver une utilité dans les scripts d'installation.

ptx

La commande ptx [fichier_cible] affiche en sortie un index permutté (liste référencée) du fichier cible. Elle peut être encore filtrée et formattée dans untube, si nécessaire.

more, less

Programmes envoyant un fichier texte ou un flux sur stdout, un écran à la fois. Ils peuvent être utilisé pour filtrer la sortie d'un script.

Notes

[1]

Un tar czvf archive_name.tar.gz * incluera les fichiers commençant par un point pour les répertoires compris dans le répertoire courant. C'est une << fonctionnalité >> non documentée de GNU tar.

[2]

C'est un système de chiffrement symétrique de bloc, employé pour crypter des fichiers sur un seul système ou sur un réseau local, par opposition à la classe de chiffrement publique, dont pgp est un exemple bien connu.