Guide avancé d'écriture des scripts Bash:
PrécédentChapitre 34. DiversSuivant

34.3. Tests et comparaisons: Alternatives

Pour les tests, la construction [[ ]] peut être plus appropriée que [ ]. De même, les comparaisons arithmétiques pourraient bénéficier de la construction (( )). 
a=8

# Toutes les comparaisons ci-dessous sont équivalentes.
test "$a" -lt 16 && echo "oui, $a < 16"         # "liste et"
/bin/test "$a" -lt 16 && echo "oui, $a < 16" 
[ "$a" -lt 16 ] && echo "oui, $a < 16" 
[[ $a -lt 16 ]] && echo "oui, $a < 16"          # Placer les variables entre
(( a < 16 )) && echo "oui, $a < 16"             # [[ ]] et (( )) n'est pas
                                                # nécessaire.

cite="New York"
# Encore une fois, toutes les comparaisons ci-dessous sont équivalentes.
test "$cite" \< Paris && echo "Oui, Paris est plus grand que $cite"  # Greater ASCII order.
/bin/test "$cite" \< Paris && echo "Oui, Paris est plus grand que $cite" 
[ "$cite" \< Paris ] && echo "Oui, Paris est plus grand que $cite" 
[[ $cite < Paris ]] && echo "Oui, Paris est plus grand que $cite"    # Pas besoin de mettre $cite entre double quote.

# Merci, S.C.

PrécédentSommaireSuivant
Scripts d'invocationNiveau supérieurRécursion
>Constructions de tests WIDTH="90%" >
if cmp a b &> /dev/null  # Supprime la sortie.
then echo "Les fichiers a et b sont identiques."
else echo "Les fichiers a et b sont différents."
fi

if grep -q Bash fichier
then echo "fichier contient au moins une occurrence du mot Bash."
fi

if COMMANDE_DONT_LA_SORTIE_EST_0_EN_CAS_DE_SUCCES
then echo "Commande réussie."
else echo "Commande echouée."
fi

  • Une construction if/then peut contenir des comparaisons et des tests imbriqués. 
    if echo "Le *if* suivant fait partie de la
comparaison du premier *if*."

  if [[ $comparaison = "integer" ]]
    then (( a < b ))
  else
    [[ $a < $b ]]
  fi

then
  echo '$a est plus petit que $b'
fi

    L'explication détaillée du << if-test >> provient de Stephane Chazelas.

    • Exemple 7-1. Où est le vrai?

    #!/bin/bash

echo

echo "Test de \"0\""
if [ 0 ]      # zéro
then
  echo "0 est vrai."
else
  echo "0 est faux."
fi            # 0 est vrai.

echo

echo "Test de \"1\""
if [ 1 ]      # un
then
  echo "1 est vrai."
else
  echo "1 est faux."
fi            # 1 est vrai.

echo

echo "Test de \"-1\""
if [ -1 ]     # moins un
then
  echo "-1 est vrai."
else
  echo "-1 est faux."
fi            # -1 est vrai.

echo

echo "Test de \"NULL\""
if [ ]        # NULL (condition vide)
then
  echo "NULL est vrai."
else
  echo "NULL est faux."
fi            # NULL est faux.

echo

echo "Test de \"xyz\""
if [ xyz ]    # chaîne de caractères
then
  echo "Chaîne de caractères au hasard est vrai."
else
  echo "Chaîne de caractères au hasard est faux."
fi            # Chaîne de caractères au hasard est vrai.

echo

echo "Test de \"\$xyz\""
if [ $xyz ]   # Teste si $xyz est nul, mais...
              # c'ets seulement une variable non initialisée.
then
  echo "Une variable non initialisée est vrai."
else
  echo "Une variable non initialisée est faux."
fi            # Une variable non initialisée est faux.

echo

echo "Test de \"-n \$xyz\""
if [ -n "$xyz" ]            # Plus correct.
then
  echo "Une variable non initialisée est vrai."
else
  echo "Une variable non initialisée est faux."
fi            # Une variable non initialisée est faux.

echo


xyz=          # Initialisé, mais à une valeur nulle.

echo "Test de \"-n \$xyz\""
if [ -n "$xyz" ]
then
  echo "Une variable nulle est vrai."
else
  echo "Une variable nulle est faux."
fi            # Une variable nulle est faux.


echo


# Quand "faux" est-il vrai?

echo "Test de \"false\""
if [ "false" ]              #  Il semble que "false" ne soit qu'une chaîne de
	                    #+ caractères.
then
  echo "\"false\" est vrai." #+ et il est testé vrai.
else
  echo "\"false\" est faux."
fi                          # "false" est vrai.

echo

echo "Test de \"\$false\""  # De nouveau, une chaîne non initialisée.
if [ "$false" ]
then
  echo "\"\$false\" est vrai."
else
  echo "\"\$false\" est faux."
fi            # "$false" est faux.
              # Maintenant, nous obtenons le résultat attendu.


echo

exit 0

    Exercice. Expliquez le comportement de Exemple 7-1, ci-dessus. 

    if [ condition-vraie ]
then
   commande 1
   commande 2
   ...
else
   # Optionnel (peut être oublié si inutile).
   # Ajoute un code par défaut à exécuter si la condition originale se révèle
   # fausse.
   commande 3
   commande 4
   ...
fi

    Note

    Quand if et then sont sur la même ligne lors d'un test, un point-virgule doit finir l'expression if. if et then sont des mots clés. Les mots clés (et les commandes) commençant une expression doivent être terminés avant qu'une nouvelle expression sur la même ligne puisse commencer.

    if [ -x "$nom_fichier" ]; then

    Else if et elif

    elif

    elif est une contraction pour else if. Le but est de faire tenir une construction if/then dans une autre construction déjà commencée. 

    if [ condition1 ]
then
   commande1
   commande2
   commande3
elif [ condition2 ]
# Idem que else if
then
   commande4
   commande5
else
   commande_par_defaut
fi

    La construction if test condition-vraie est l'exact équivalent de if [ condition-true ]. De cette façon, le crochet gauche, [, est un raccourci appelant la commande test. Le crochet droit fermant, ], ne devrait donc pas être nécessaire dans un test if , néanmoins, les dernières versions de Bash le requièrent.

    Note

    La commande test est une commande interne de Bash, permettant de tester les types de fichiers et de comparer des chaînes de caractères. Donc, dans un script Bash, test n'appelle pas le binaire externe /usr/bin/test, qui fait partie du paquet sh-utils. De même, [ n'appelle pas /usr/bin/[, qui est un lien vers /usr/bin/test.

    bash$ type test
test is a shell builtin
bash$ type '['
[ is a shell builtin
bash$ type '[['
[[ is a shell keyword
bash$ type ']]'
]] is a shell keyword
bash$ type ']'
bash: type: ]: not found

    Exemple 7-2. Equivalences de test, /usr/bin/test, [ ], et /usr/bin/[

    #!/bin/bash

echo

if test -z "$1"
then
  echo "Pas arguments sur la ligne de commande."
else
  echo "Le premier argument de la ligne de commande est $1."
fi

echo

if /usr/bin/test -z "$1"      # Même résultat que la commande intégrée "test".
then
  echo "Pas arguments sur la ligne de commande."
else
  echo "Le premier argument de la ligne de commande est $1."
fi

echo

if [ -z "$1" ]                # Identique fonctionnellement au bloc de code.
#   if [ -z "$1"                devrait fonctionner, mais...
#+  Bash répond qu'un crochet fermant manque.
then
  echo "Pas arguments sur la ligne de commande."
else
  echo "Le premier argument de la ligne de commande est $1."
fi

echo

if /usr/bin/[ -z "$1"         #  Encore une fois, fonctionnalité identique à
	                      #+ ci-dessus.
# if /usr/bin/[ -z "$1" ]     # Fonctionne, mais donne un message d'erreur.
then
  echo "Pas arguments sur la ligne de commande."
else
  echo "Le premier argument de la ligne de commande est $1."
fi

echo

exit 0

    La construction [[ ]] est l'équivalent shell de [ ]. C'est la commande étendue de test, venant de ksh88.

    Note

    Il n'est pas possible de faire de la complétion de noms de fichiers ou de la séparation de mots lorsqu'on se trouve entre [[ et ]], mais la complétion de paramètres et la substitution de commandes sont disponibles.

    fichier=/etc/passwd

if [[ -e $fichier ]]
then
  echo "Le fichier de mots de passe existe."
fi

    Astuce

    Utiliser la construction [[ ... ]], au lieu de [ ... ] peut vous permettre d'éviter des erreurs de logique dans vos scripts. Par exemple, les opérateurs &&, ||, < et > fonctionnent à l'intérieur d'un test [[ ]] bien qu'ils génèrent une erreur à l'intérieur d'une construction [ ].

    Note

    Après un if, ni la commande test ni les crochets de test ( [ ] ou [[ ]] ) ne sont nécessaires. 
    repertoire=/home/bozo

if cd "$repertoire" 2>/dev/null; then   # "2>/dev/null" cache les messages d'erreur
  echo "Je suis maintenant dans $repertoire."
else
  echo "Je ne peux pas aller dans $repertoire."
fi
    La construction "if COMMANDE" renvoie l'état de sortie de la COMMANDE.

    De manière identique, une condition à l'intérieur de crochets de test peut fonctionner sans if, si elle est utilisée avec une construction en liste. 
    var1=20
var2=22
[ "$var1" -ne "$var2" ] && echo "$var1 n'est pas égal à $var2"

home=/home/bozo
[ -d "$home" ] || echo "Le répertoire $home n'existe pas."

    La construction (( )) évalue une expression arithmétique. Si l'expression vaut 0, elle renvoie un code de sortie de 1, ou << false >>. Une expression différente de 0 renvoie 0, ou << true >>. Ceci est en totale contradiction avec l'utilisation des constructions test et [ ] évoquées précédemment.

    Exemple 7-3. Tests arithmétiques en utilisant (( ))

    #!/bin/bash
# Tests arithmétiques.

# La construction (( ... )) évalue et teste les exepressions numériques.
# Code de sortie opposé à la construction [ ... ] !

(( 0 ))
echo "Le code de sortie de \"(( 0 ))\" est $?."         # 1

(( 1 ))
echo "Le code de sortie de \"(( 1 ))\" est $?."         # 0

(( 5 > 4 ))                                             # vrai
echo "Le code de sortie de \"(( 5 > 4 ))\" est $?."     # 0

(( 5 > 9 ))                                             # faux
echo "Le code de sortie de \"(( 5 > 9 ))\" est $?."     # 1

(( 5 - 5 ))                                             # 0
echo "Le code de sortie de \"(( 5 - 5 ))\" est $?."     # 1

(( 5 / 4 ))                                             # Division OK.
echo "Le code de sortie de \"(( 5 / 4 ))\" est $?."     # 0

(( 1 / 2 ))                                             # Résultat de la division < 1.
echo "Le code de sortie de \"(( 1 / 2 ))\" est $?."     # Arrondie à 0.
                                                 	# 1

(( 1 / 0 )) 2>/dev/null                                 # Division par 0... illégale.
echo "Le code de sortie de \"(( 1 / 0 ))\" est $?."     # 1

# Quel effet a "2>/dev/null"?
# Qu'arriverait-t'il s'il était supprimé?
# Essayez de le supprimer, et relancer le script.

exit 0
    PrécédentSommaireSuivant
    TestsNiveau supérieurOpérateurs de test de fichiers
    >bash$ wc -c < file 13 Le processus contrôlant le terminal reçoit seulement 13 caractères (12 alphabétiques, plus le retour chariot), bien que l'utilisateur ait appuyé sur 26 touches.

    Dans un mode non canonique (<< raw >>), chaque appui sur une touche (y compris les touches spéciales d'édition telles que ctl-H) envoie un caractère immédiatement au processus de contrôle.

    L'invite Bash désactive à la fois icanon et echo, car il remplace l'éditeur ligne basique du terminal avec son propre éditeur plus élaboré. Par exemple, lorsque vous appuyez sur ctl-A à l'invite Bash, aucun ^A n'est affiché par le terminal mais Bash obtient un caractère \1, l'interprète et déplace le curseur en début de ligne.

    Stephane Chazelas

    tset

    Affiche ou initialise les paramètrages du terminal. C'est une version stty comprenant moins de fonctionnalités.

    bash$ tset -r
Terminal type is xterm-xfree86.
 Kill is control-U (^U).
 Interrupt is control-C (^C).

    setserial

    Initialise ou affiche les paramètres du port série. Cette commande doit être lancé par l'utilisateur root et est habituellement utilisée dans un script de configuration du système.

    # From /etc/pcmcia/serial script:

IRQ=`setserial /dev/$DEVICE | sed -e 's/.*IRQ: //'`
setserial /dev/$DEVICE irq 0 ; setserial /dev/$DEVICE irq $IRQ

    getty, agetty

    Le processus d'initialisation d'un terminal utilise getty ou agetty pour demander le nom de connexion d'un utilisateur. Ces commandes ne sont pas utilisées dans des scripts shell d'utilisateurs. Leur contre-partie script est stty.

    mesg

    Active ou désactive les droits d'écriture sur le terminal de l'utilisateur actuel. Désactiver l'accès empêcherait tout utilisateur sur le réseau d'écrire (write en anglais) sur le terminal.

    Astuce

    Il peut être très ennuyant de voir apparaître un message pour une commande de pizza au milieu du fichier texte en cours d'édition. Sur un réseau multi-utilisateur, vous pourriez du coup souhaiter désactiver les droits d'écriture sur votre terminal lorsque vous ne voulez pas être dérangé.

    wall

    C'est un acronyme pour << write all >>, c'est-à-dire écrire un message à tous les utilisateurs sur tous les terminaux connectés sur le réseau. C'est essentiellement un outil pour l'administrateur système, utile par exemple pour prévenir tout le monde que le système sera bientôt arrêté à cause d'un problème (voir Exemple 17-2).

    bash$ wall Système arrêté pour maintenance dans 5 minutes!
Broadcast message from bozo (pts/1) Sun Jul  8 13:53:27 2001...

 Système arrêté pour maintenance dans 5 minutes!

    Note

    Si le droit d'écriture sur un terminal particulier a été désactivé avec mesg, alors wall ne pourra pas lui envoyer un message.

    dmesg

    Affiche tous les messages de démarrage du système envoyés à stdout. Pratique pour déboguer, pour s'assurer des pilotes de périphériques qui ont été installés et des interruptions système utilisées. La sortie de dmesg pourrait, bien sûr, être analysée avec grep, sed, ou awk à l'intérieur d'un script.

    bash$ dmesg | grep hda
Kernel command line: ro root=/dev/hda2
 hda: IBM-DLGA-23080, ATA DISK drive
 hda: 6015744 sectors (3080 MB) w/96KiB Cache, CHS=746/128/63
 hda: hda1 hda2 hda3 < hda5 hda6 hda7 > hda4

    Informations et statistiques

    uname

    Affiche les spécifications du système (OS, version du noyau, etc.) sur stdout. Appelé avec l'option -a, donne plus d'informations sur le système (voir Exemple 12-4). L'option -s affiche seulement le type de l'OS.

    bash$ uname -a
Linux localhost.localdomain 2.2.15-2.5.0 #1 Sat Feb 5 00:13:43 EST 2000 i686 unknown

bash$ uname -s
Linux
    arch

    Affiche l'architecture du système. Equivalent à uname -m. Voir Exemple 10-26.

    bash$ arch
i686

bash$ uname -m
i686
    lastcomm

    Donne une information sur les dernières commandes, disponibles dans le fichier /var/account/pacct. Le nom de la commande et de l'utilisateur peuvent être spécifiés en options. Elle fait partie des utilitaires de comptage GNU.

    lastlog

    Affiche la dernière connexion de tous les utilisateurs système. Ceci prend comme référence le fichier /var/log/lastlog.

    bash$ lastlog
root          tty1                      Fri Dec  7 18:43:21 -0700 2001
 bin                                     **Never logged in**
 daemon                                  **Never logged in**
 ...
 bozo          tty1                      Sat Dec  8 21:14:29 -0700 2001



bash$ lastlog | grep root
root          tty1                      Fri Dec  7 18:43:21 -0700 2001

    Attention

    Cette commande échouera si l'utilisateur l'appellant n'a pas des droits de lecture sur le fichier /var/log/lastlog.

    lsof

    Affiche les fichiers ouverts. Cette commande affiche une table détaillée de tous les fichiers ouverts et donne de l'information sur leur propriétaire, taille, processus associés et bien plus encore. Bien sûr, lsof pourrait être redirigé avec un tube vers grep et/ou awk pour analyser ce résultat. 

    bash$ lsof
COMMAND    PID    USER   FD   TYPE     DEVICE    SIZE     NODE NAME
 init         1    root  mem    REG        3,5   30748    30303 /sbin/init
 init         1    root  mem    REG        3,5   73120     8069 /lib/ld-2.1.3.so
 init         1    root  mem    REG        3,5  931668     8075 /lib/libc-2.1.3.so
 cardmgr    213    root  mem    REG        3,5   36956    30357 /sbin/cardmgr
 ...

    strace

    Outil de diagnostique et de déboguage des appels systèmes et des signaux. La façon la plus simple de l'appeller est strace COMMANDE.

    bash$ strace df
execve("/bin/df", ["df"], [/* 45 vars */]) = 0
 uname({sys="Linux", node="bozo.localdomain", ...}) = 0
 brk(0)                                  = 0x804f5e4
 ...

    C'est l'équivalent Linux de truss.

    nmap

    Scanner de port réseau. Cette commande parcourt les ports d'un serveur pour localiser les ports ouverts et les services associés à ces ports. C'est un important outil de sécurité pour verrouiller un réseau contre les tentatives de pirates.

    #!/bin/bash

SERVEUR=$HOST                           # localhost.localdomain (127.0.0.1).
NUMERO_PORT=25                          # Port SMTP.

nmap $SERVEUR | grep -w "$NUMERO_PORT"  # Ce port particulier est-il ouvert ?
#              grep -w établit une correspondance avec des mots entiers
#+             seulement, donc cela permet d'éviter le port 1025 par exemple.

exit 0

# 25/tcp     open        smtp

    free

    Affiche l'utilisation de la mémoire et du cache sous forme de tableau. La sortie de cette commande tend à être analyser avec l'utilisation de grep, awk ou Perl. La commande procinfo affiche toute l'information dont dispose la commande free et bien plus encore.

    bash$ free
                total       used       free     shared    buffers     cached
   Mem:         30504      28624       1880      15820       1608       16376
   -/+ buffers/cache:      10640      19864
   Swap:        68540       3128      65412

    Pour afficher la mémoire RAM inutilisée:

    bash$ free | grep Mem | awk '{ print $4 }'
1880
    procinfo

    Extrait et affiche des informations et des statistiques à partir du pseudo système de fichiers /proc. Cela donne une liste très détaillée.

    bash$ procinfo | grep Bootup
Bootup: Wed Mar 21 15:15:50 2001    Load average: 0.04 0.21 0.34 3/47 6829
    lsdev

    Affiche les périphériques, c'est-à-dire le matériel installé.

    bash$ lsdev
Device            DMA   IRQ  I/O Ports
 ------------------------------------------------
 cascade             4     2 
 dma                          0080-008f
 dma1                         0000-001f
 dma2                         00c0-00df
 fpu                          00f0-00ff
 ide0                     14  01f0-01f7 03f6-03f6
 ...

    du

    Affiche l'utilisation du disque, de façon récursive. Par défaut, il prend en compte le répertoire courant.

    bash$ du -ach
1.0k    ./wi.sh
 1.0k    ./tst.sh
 1.0k    ./random.file
 6.0k    .
 6.0k    total
    df

    Affiche l'utilisation des systèmes de fichiers sous forme de tableau.

    bash$ df
Filesystem           1k-blocks      Used Available Use% Mounted on
 /dev/hda5               273262     92607    166547  36% /
 /dev/hda8               222525    123951     87085  59% /home
 /dev/hda7              1408796   1075744    261488  80% /usr
    stat

    Donnes des statistiques détaillées, voire verbeuses, sur un fichier donné (voire un répertoire ou un fichier périphérique) ou sur un ensemble de fichiers.

    bash$ stat test.cru
  File: "test.cru"
   Size: 49970        Allocated Blocks: 100          Filetype: Regular File
   Mode: (0664/-rw-rw-r--)         Uid: (  501/ bozo)  Gid: (  501/ bozo)
 Device:  3,8   Inode: 18185     Links: 1    
 Access: Sat Jun  2 16:40:24 2001
 Modify: Sat Jun  2 16:40:24 2001
 Change: Sat Jun  2 16:40:24 2001

    Si le fichier cible n'existe pas, stat renvoie un message d'erreur.

    bash$ stat fichier-inexistant
nonexistent-file: No such file or directory

    vmstat

    Affiche les statistiques concernant la mémoire virtuel.

    bash$ vmstat
   procs                      memory    swap          io system         cpu
 r  b  w   swpd   free   buff  cache  si  so    bi    bo   in    cs  us  sy id
 0  0  0      0  11040   2636  38952   0   0    33     7  271    88   8   3 89

    netstat

    Affiche des informations et des statistiques sur le réseau, telles que les tables de routage et les connexions actives. Cet utilitaire accède à l'information avec /proc/net (Chapitre 28). Voir Exemple 28-2.

    netstat -r est équivalent à route.

    uptime

    Affiche depuis quand le système est lancé ainsi que quelques autres statistiques.

    bash$ uptime
10:28pm  up  1:57,  3 users,  load average: 0.17, 0.34, 0.27
    hostname

    Affiche le nom d'hôte du système. Cette commande initialise le nom d'hôte dans un script de démarrage /etc/rc.d (/etc/rc.d/rc.sysinit ou similaire). C'est équivalent à uname -n, et une contrepartie de la variable interne $HOSTNAME. 

    bash$ hostname
localhost.localdomain

bash$ echo $HOSTNAME
localhost.localdomain
    hostid

    Affiche un identifiant numérique (hexadécimal) sur 32 bits pour la machine hôte.

    bash$ hostid
7f0100

    Note

    Cette commande récupère prétendument un numéro de série << unique >> pour un système particulier. Certaines procédures d'enregistrement d'un produit utilisent ce numéro pour indiquer une licence utilisateur particulière. Malheureusement, hostid ne fait que renvoyer l'adresse réseau en héxadécimal avec quelques octets transposés.

    L'adresse réseau d'une machine Linux typique ne se trouvant pas sur un réseau est disponible dans /etc/hosts.

    bash$ cat /etc/hosts
127.0.0.1               localhost.localdomain localhost

    Il arrive que la transposition de 127.0.0.1 soit 0.127.1.0, ce qui donne en hexadécimal 007f0100, l'équivalent exact de ce que renvoit hostid, ci-dessus. Il existe seulement quelques millions d'autres machines Linux avec ce même hostid.

    sar

    Appeller sar (system activity report) donne une indication minutée et très détaillée des statistiques système. Cette commande est disponible sur certains systèmes UNIX commerciaux mais ne fait pas partie de la distribution UNIX de base. Il appartient au package des utilitaires sysstat, écrit par Sébastien Godard.

    bash$ sar
Linux 2.4.7-10 (localhost.localdomain) 	12/31/2001

 10:30:01 AM       CPU     %user     %nice   %system     %idle
 10:40:00 AM       all      1.39      0.00      0.77     97.84
 10:50:00 AM       all     76.83      0.00      1.45     21.72
 11:00:00 AM       all      1.32      0.00      0.69     97.99
 11:10:00 AM       all      1.17      0.00      0.30     98.53
 11:20:00 AM       all      0.51      0.00      0.30     99.19
 06:30:00 PM       all    100.00      0.00    100.01      0.00
 Average:          all      1.39      0.00      0.66     97.95
    readelf

    Affiche des informations et des statistiques sur un binaire elf indiqué. Cela fait partie du package binutils.

    bash$ readelf -h /bin/bash
ELF Header:
   Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 
   Class:                             ELF32
   Data:                              2's complement, little endian
   Version:                           1 (current)
   OS/ABI:                            UNIX - System V
   ABI Version:                       0
   Type:                              EXEC (Executable file)
   . . .
    size

    La commande size [/chemin/vers/binaire] donne les tailles des segments d'un exécutable binaire ou d'un fichier archive. C'est utile principalement pour les programmeurs. 

    bash$ size /bin/bash
   text    data     bss     dec     hex filename
  495971   22496   17392  535859   82d33 /bin/bash

    Journal système

    logger

    Ajoute un message généré par l'utilisateur dans le journal système (/var/log/messages). Vous n'avez pas besoin d'être root pour appeler logger. 
    logger Instabilité en cours sur la connexion réseau à 23:10, le 21/05.
# Maintenant, lancez un 'tail /var/log/messages'.

    En embarquant une commande logger dans un script, il est possible d'écrire des informations de déboguage dans /var/log/messages. 
    logger -t $0 -i Trace sur la ligne "$LINENO".
# L'option "-t" spécifie la balise pour l'entrée du journal.
# L'option "-i" enregistre l'identifiant du processus.

# tail /var/log/message
# ...
# Jul  7 20:48:58 localhost ./test.sh[1712]: Trace sur la ligne 3.

    logrotate

    Cet utilitaire gère les journaux système, en utilisant une rotation, en les compressant, supprimant, et/ou en les envoyant par courrier électronique. Habituellement, crond lance quotidiennement logrotate.

    Ajouter une entrée appropriée dans /etc/logrotate.conf rend possible la gestion de journaux personnels, ainsi que des journaux système.

    Contrôle de job

    ps

    Statistiques sur les processus (Process Statistics): affiche les processus en cours d'exécution avec leur propriétaire et identifiant de processus (PID). Celui-ci est habituellement appelé avec les options ax et le résultat peut être envoyé via un tube à grep ou sed pour repérer un processus spécifique (voir Exemple 11-10 et Exemple 28-1).

    bash$  ps ax | grep sendmail
295 ?	   S	  0:00 sendmail: accepting connections on port 25
    pstree

    Affiche les processus en cours d'exécution avec le format << tree >> (arbre). L'option -p affiche les PID, ainsi que les noms des processus.

    top

    Affiche les processus les plus consomnateur de puissances avec un rafaichissement permanant. L'option -b affiche en mode texte de façon à ce que la sortie puisse être analysée ou tout simplement récupérée à partir d'un script.

    bash$ top -b
  8:30pm  up 3 min,  3 users,  load average: 0.49, 0.32, 0.13
 45 processes: 44 sleeping, 1 running, 0 zombie, 0 stopped
 CPU states: 13.6% user,  7.3% system,  0.0% nice, 78.9% idle
 Mem:    78396K av,   65468K used,   12928K free,       0K shrd,    2352K buff
 Swap:  157208K av,       0K used,  157208K free                   37244K cached

   PID USER     PRI  NI  SIZE  RSS SHARE STAT %CPU %MEM   TIME COMMAND
   848 bozo      17   0   996  996   800 R     5.6  1.2   0:00 top
     1 root       8   0   512  512   444 S     0.0  0.6   0:04 init
     2 root       9   0     0    0     0 SW    0.0  0.0   0:00 keventd
   ...

    nice

    Lance un job en tâche de fond avec une priorité modifiée. Les priorités vont de 19 (le plus bas) à -20 (le plus haut). Seul root peut configurer les priorités négatives (les plus hautes). Les commandes en relation sont renice, snice et skill.

    nohup

    Conserve l'exécution d'une commande même si l'utilisateur se déconnecte. La commande s'exécutera en tant que tâche de fond sauf si il est suivi d'un &. Si vous utilisez nohup à l'intérieur d'un script, considérez le fait de le placer avec un wait pour éviter la création d'un processus orphelin ou zombie.

    pidof

    Identifie l'identifiant du processus (pid) d'un job en cours d'exécution. Comme les commandes de contrôle de job, telles que kill et renice qui agissent sur le pid d'un processus (et non pas son nom), il est parfois nécessaire d'identifier ce pid. La commande pidof est la contrepartie approximative de la variable interne $PPID.

    bash$ pidof xclock
880

    Exemple 13-4. pidof aide à la suppression d'un processus

    #!/bin/bash
# kill-process.sh

SANSPROCESSUS=2

processus=xxxyyyzzz  # Utilise un processus inexistant.
# Pour les besoins de la démo seulement...
# ... je ne veux pas réellement tuer un processus courant avec ce script.
#
# Si, par exemple, vous voulez utiliser ce script pour vous déconnecter d'Internet,
#     processus=pppd

t=`pidof $processus`       # Trouve le pid (process id) de $processus.
#  Le pid est nécessaire pour 'kill' (vous ne pouvez pas lancer 'kill' sur un nom de
#+ programme).

if [ -z "$t" ]           # Si le processus n'est pas présent, 'pidof' renvoie null.
then
  echo "Le processus $processus n'est pas lancé."
  echo "Rien n'a été tué."
  exit $SANSPROCESSUS
fi  

kill $t              # Vous pouvez avoir besoin d'un 'kill -9' pour les processus fils.

# Une vérification sur l'existence du processus est nécessaire ici.
# Peut-être un autre " t=`pidof $processus` ".


# Ce script entier pourrait être remplacé par
#    kill $(pidof -x processus_name)
# mais cela ne serait pas aussi instructif.

exit 0
    fuser

    Identifie les processus (par pid) accédant à un fichier donné, à un ensemble de fichiers ou à un répertoire. Pourrait aussi être appelé avec l'option -k, qui tue ces processus. Ceci a des implications intéressantes pour la sécurité du système, spécialement avec des scripts empêchant des utilisateurs non autorisés d'accèder à certains services système.

    crond

    Plannificateur de programmes d'administration, réalisant des tâches comme le nettoyage et la suppression des journaux système ainsi que la mise à jour de la base de données slocate. C'est la version superutilisateur de at (bien que chaque utilisateur peut avoir son propre fichier crontab modifiable avec la commande crontab). Il s'exécute comme un démon et exécute les entrées plannifiées dans /etc/crontab.

    Contrôle de processus et démarrage

    init

    La commande init est le parent de tous les processus. Appelé à l'étape finale du démarrage, init détermine le niveau d'exécution du système à partir de /etc/inittab. Appellé par son alias telinit, et par root seulement.

    telinit

    Lien symbolique vers init, c'est un moyen de changer de niveau d'exécution, habituellement utilisé pour la maintenance système ou des réparations en urgence de systèmes de fichiers. Appelé uniquement par root. Cette commande peut être dangereuse - soyez certain de bien la comprendre avant de l'utiliser!

    runlevel

    Affiche le niveau d'exécution actuel et ancien, c'est-à-dire si le système a été arrêté (niveau 0), était en mode simple-utilisateur (1), en mode multi-utilisateur (2 ou 3), dans X Windows (5) ou en redémarrage (6). Cette commande accède au fichier /var/run/utmp.

    halt, shutdown, reboot

    Ensemble de commandes pour arrêter le système, habituellement juste avant un arrêt.

    Réseau

    ifconfig

    Configuration fine de l'interface réseau. Il est bien plus utilisé au démarrage lors de la configuration des interfaces, ou à l'arrêt lors d'un redémarrage. 
    # Code snippets from /etc/rc.d/init.d/network

# ...

# ECheck that networking is up.
[ ${NETWORKING} = "no" ] && exit 0

[ -x /sbin/ifconfig ] || exit 0

# ...

for i in $interfaces ; do
  if ifconfig $i 2>/dev/null | grep -q "UP" >/dev/null 2>&1 ; then
    action "Shutting down interface $i: " ./ifdown $i boot
  fi
# The GNU-specific "-q" option to "grep" means "quiet", i.e., producing no output.
# Redirecting output to /dev/null is therefore not strictly necessary.
       
# ...

echo "Currently active devices:"
echo `/sbin/ifconfig | grep ^[a-z] | awk '{print $1}'`
#                            ^^^^^  should be quoted to prevent globbing.
#  The following also work.
#    echo $(/sbin/ifconfig | awk '/^[a-z]/ { print $1 })'
#    echo $(/sbin/ifconfig | sed -e 's/ .*//')
#  Thanks, S.C., for additional comments.
    Voir aussi Exemple 30-6.

    route

    Affiche des informations sur la façon de modifier la table de routage du noyau.

    bash$ route
Destination     Gateway         Genmask         Flags   MSS Window  irtt Iface
 pm3-67.bozosisp *               255.255.255.255 UH       40 0          0 ppp0
 127.0.0.0       *               255.0.0.0       U        40 0          0 lo
 default         pm3-67.bozosisp 0.0.0.0         UG       40 0          0 ppp0

    chkconfig

    Vérifie la configuration du réseau. Cette commande affiche et gère les services réseau lancés au démarrage dans le répertoire /etc/rc?.d.

    Originellement un port d'IRIX vers Red Hat Linux, chkconfig pourrait ne pas faire partie de l'installation principale des différentes distributions Linux. 

    bash$ chkconfig --list
atd             0:off   1:off   2:off   3:on    4:on    5:on    6:off
 rwhod           0:off   1:off   2:off   3:off   4:off   5:off   6:off
 ...

    tcpdump

    << Reniffleur >> de paquets réseau. C'est un outil pour analyser et corriger le trafic sur un réseau par l'affichage des en-têtes de paquets correspondant à des critères précis.

    Affiche le trafic des paquets ip entre l'hôte bozoville et caduceus: 
    bash$ tcpdump ip host bozoville and caduceus

    Bien sûr, la sortie de tcpdump est analysable en utilisant certains utilitaires texte préalablement discutées.

    Filesystem

    mount

    Monte un système de fichier, généralement sur un périphérique externe, tel qu'un lecteur de disquette ou de CDROM. Le fichier /etc/fstab comprend tous les systèmes de fichiers, partitions et périphériques disponibles pouvant être montés manuellement ou automatiquement. Le fichier /etc/mtab affiche les systèmes de fichiers et partitions actuellement montés (en incluant les systèmes virtuels tels que /proc).

    mount -a monte tous les systèmes de fichiers et partitions indiqués dans /etc/fstab, à l'exception de ceux disposant de l'option noauto. Au démarrage, un script de /etc/rc.d (rc.sysinit ou un similaire) appelle cette commande pour monter tout ce qui doit l'être.

    mount -t iso9660 /dev/cdrom /mnt/cdrom
# Monte le CDROM
mount /mnt/cdrom
# Raccourci, à condition que /mnt/cdrom soit compris dans /etc/fstab

    Cette commande versatile peut même monter un fichier ordinaire sur un périphérique bloc et ce fichier agira comme si il était un système de fichiers. Mount accomplit cela en associant le fichier à un périphérique loopback. Une application de ceci est le montage et l'examen d'une image ISO9660 avant qu'elle ne soit gravée sur un CDR. [3]

    Exemple 13-5. Vérifier une image

    # En tant que root...

mkdir /mnt/cdtest  # Préparez un point de montage, s'il n'existe pas déjà.

mount -r -t iso9660 -o loop cd-image.iso /mnt/cdtest   # Montez l'image.
#                  l'option "-o loop" est équivalent à "losetup /dev/loop0"
cd /mnt/cdtest     # Maintenant, vérifiez l'image
ls -alR            # Listez les fichiers dans cette hiérarchie de répertoires.
                   # Et ainsi de suite.
    umount

    Démonte un système de fichiers actuellement montés. Avant de supprimer physiquement une disquette ou un CDROM monté au prélable, le périphérique doit être démonté (umount), sinon des corruptions du système de fichiers pourraient survenir. 
    umount /mnt/cdrom
# Vous pouvez maintenant appuyer sur le bouton d'éjection en toute sécurité.

    Note

    L'utilitaire automount, s'il est correctement installé, peut monter et démonter des disquettes et des CDROM s'ils sont utilisés ou enlevés. Sur des portables diposant de lecteurs de disquette et CDROM enlevables, ceci peut poser des problèmes.

    sync

    Force une écriture immédiate de toutes les données mises à jour à partir des tampons vers le disque dur (synchronisation des lecteurs avec les tampons). Bien que cela ne soit pas strictement nécessaire, sync assure à l'administrateur système et à l'utilisateur que les données tout juste modifiées survivront à une soudaine coupure de courant. Aux anciens temps, un sync; sync (deux fois, pour être absolument certain) était une mesure de précaution utile avant un redémarrage du système.

    Quelque fois, vous pouvez souhaiter forcer un vidage immédiat des tampons, comme lors de la suppression sécurisée d'un fichier (voir Exemple 12-42) ou lorsque les lumières commencent à clignotter.

    losetup

    Initialise et configure les périphériques loopback.

    Exemple 13-6. Création d'un système de fichiers dans un fichier

    TAILLE=1000000  # 1 Mo

head -c $TAILLE < /dev/zero > fichier  # Initialise un fichier de la taille indiquée.
losetup /dev/loop0 fichier             # Le configure en tant que périphérique loopback.
mke2fs /dev/loop0                      # Crée un système de fichiers.
mount -o loop /dev/loop0 /mnt          # Le monte.

# Merci, S.C.
    mkswap

    Crée une partition de swap ou un fichier. L'aire de swap doit être, du coup, activé avec swapon.

    swapon, swapoff

    Active/désactive la partition de swap ou le fichier. Ces commandes sont généralement utilisées au démarrage et à l'arrêt.

    mke2fs

    Crée un système de fichiers ext2 Linux. Cette commande doit être appelée en tant que root.

    Exemple 13-7. Ajoute un nouveau disque dur

    #!/bin/bash

# Ajouter un deuxième disque dur au système.
# Configuration logiciel. suppose que le matériel est déjà monté.
# A partir d'un article de l'auteur de ce document dans le numéro
# #38 de la "Linux Gazette", http://www.linuxgazette.com.

ROOT_UID=0     # Ce script doit être lancé en tant que root.
E_NOTROOT=67   # Erreur pour les utilisateurs non privilégiés.

if [ "$UID" -ne "$ROOT_UID" ]
then
  echo "Vous devez être root pour utiliser ce script."
  exit $E_NOTROOT
fi  

# A utiliser avec beaucoup de précautions!
# Si quelque chose se passe mal, vous pourriez supprimer votre système de
#+ fichiers complet.


NOUVEAUDISQUE=/dev/hdb    # Suppose que /dev/hdb est disponible. A vérifier!
POINTMONTAGE=/mnt/newdisk # Ou choisissez un autre point de montage.


fdisk $NOUVEAUDISQUE1
mke2fs -cv $NOUVEAUDISQUE1 # Vérifie les mauvais blocs et rend la sortie verbeuse.
#  Note:    /dev/hdb1, *pas* /dev/hdb!
mkdir $POINTMONTAGE
chmod 777 $POINTMONTAGE   # Rend le nouveau disque accessible à tous les utilisateurs.


# Maintenant, testez...
# mount -t ext2 /dev/hdb1 /mnt/newdisk
# Essayez de créer un répertoire.
# Si cela fonctionne, démontez-le et faites.

# Etape finale:
# Ajoutez la ligne suivante dans /etc/fstab.
# /dev/hdb1  /mnt/newdisk  ext2  defaults  1 1

exit 0

    Voir aussi Exemple 13-6 et Exemple 29-3.

    tune2fs

    Configure finement le système de fichiers ext2. Peut être utilisé pour modifier les paramètres du système de fichiers, tels que le nombre maximum de montage. Il doit être utilisé en tant que root.

    Avertissement

    Cette commande est extrêmement dangereuse. Utilisez-la à vos propres risques, car vous pourriez détruire par inavertance votre système de fichiers.

    dumpe2fs

    Affiche sur stdout énormément d'informations sur le système de fichiers. Elle doit aussi être appelée en tant que root.

    root# dumpe2fs /dev/hda7 | grep 'ount count'
dumpe2fs 1.19, 13-Jul-2000 for EXT2 FS 0.5b, 95/08/09
 Mount count:              6
 Maximum mount count:      20
    hdparm

    Liste ou modifie les paramètres des disques durs. Cette commande doit être appelée en tant que root et peut être dangereuse si elle est mal utilisée.

    fdisk

    Crée ou modifie une table des partitions sur un périphérique de stockage, habituellement un disque dur. Cette commande doit être appelée en tant que root.

    Avertissement

    Utilisez cette commande avec d'infinies précautions. Si quelque chose se passe mal, vous pouvez détruire un système de fichiers existant.

    fsck, e2fsck, debugfs

    Ensemble de commandes de vérification, réparation et déboguage des systèmes de fichiers.

    fsck: une interface pour vérifier un système de fichiers UNIX (peut appeler d'autres utilitaires). Le type de système de fichiers est par défaut ext2.

    e2fsck: vérificateur du système de fichiers ext2.

    debugfs: débogueur du système de fichiers ext2. Une des utilités de cette commande versatile, mais dangereuse, est de récupérer (ou plutôt d'essayer de récupérer) des fichiers supprimés. A réserver aux utilisateurs avancés !

    Attention

    Toutes ce commandes doivent être appelées en tant que root et peuvent endommager, voire détruire, un système de fichiers si elles sont mal utilisées.

    badblocks

    Vérifie les blocs défectueux (défauts physiques du média) sur un périphérique de stockage. Cette commande trouve son utilité lors du formattage d'un nouveau disque dur ou pour tester l'intégrité du média de sauvegarde. [4] Comme exemple, badblocks /dev/fd0 teste une disquette.

    La commande badblocks peut être appelé de façon destructive (écrasement de toutes les données) ou dans un mode lecture-seule non destructif. Si l'utilisateur root est le propriétaire du périphérique à tester, comme c'est le cas habituellement, alors root doit appeler cette commande.

    mkbootdisk

    Crée une disquette de démarrage pouvant être utilisée pour lancer le système si, par exemple, le MBR (master boot record) est corrumpu. La commande mkbootdisk est en fait un script Bash, écrit par Erik Troan, et disponible dans le répertoire /sbin.

    chroot

    CHange ROOT directory (modifie le répertoire racine). Habituellement, les commandes sont récupérées à partir de $PATH, depuis la racine /, le répertoire racine par défaut. Cette commande modifie le répertoire racine par un autre répertoire (et modifie aussi le répertoire de travail). Ceci est utile dans des buts de sécurité, par exemple lorsqu'un administrateur système souhaite restreindre certains utilisateurs notamment ceux utilisant telnet, pour sécuriser une partie du système de fichiers (c'est souvent assimilé à confiner un utilisateur invité dans une prison chroot (<< chroot jail >>)). Notez qu'après un chroot, le chemin d'exécution des binaires du système n'est plus valide.

    Un chroot /opt ferait que toutes les références à /usr/bin seraient traduites en /opt/usr/bin. De même, chroot /aaa/bbb /bin/ls redirigerait tous les futurs appels à ls en /aaa/bbb comme répertoire de base, plutôt que / comme c'est habituellement le cas. Un alias XX 'chroot /aaa/bbb ls' dans le ~/.bashrc d'un utilisateur restreint réllement la portion du système de fichiers où elle peut lancer des commandes.

    La commande chroot est aussi pratique lors du lancement du disquette d'urgence (chroot vers /dev/fd0), ou comme option de lilo lors de la récupération après un crash système. D'autres utilisations incluent l'installation à partir d'un autre système de fichiers (une option rpm) ou le lancement d'un système de fichiers en lecture-seule à partir d'un CDROM. Ne peut s'appeller qu'en tant que root, et à utiliser avec précaution.

    Attention

    Il pourrait être nécessaire de copier certains fichiers système vers un répertoire compris dans le répertoire de base du chroot, car le $PATH n'est plus fiable.

    lockfile

    Cet utilitaire fait partie du package procmail (www.procmail.org). Il crée un fichier de verrouillage, un fichier sémaphore qui contrôle l'accès à un fichier, périphérique ou ressource. Le fichier de verrouillage sert en tant qu'indicateur qu'un fichier, périphérique, ressource est utilisé par un processus particulier (<< occupé >>), et ne permet aux autres processus qu'un accès restreint (ou pas d'accès).

    Les fichiers de verrouillage sont utilisés par des applications pour protéger les répertoires de courriers électroniques des utilisateurs de modifications simultanées, pour indiquer qu'un port modem est utilisé ou pour montrer qu'une instance de Netscape utilise son cache. Les scripts peuvent vérifier l'existence d'un fichier de verrouillage créé par un certain processus pour vérifier si le processus existe. Notez que si un script essaie de créer un fichier de verrouillage déjà existant, le script a toutes les chances de se terminer précipitamment.

    Habituellement, les applications créent et vérifient les fichiers de verrouillage dans le répertoire /var/lock. Un script peut tester la présence d'un fichier de verrouillage de la façon suivante. 
    nomappl=xyzip
# L'application "xyzip" crée le fichier de verrouillage "/var/lock/xyzip.lock".

if [ -e "/var/lock/$nomappl.lock ]
then
  ...

    mknod

    Crée des fichiers de périphériques blocs ou caractères (peut être nécessaire lors de l'installation d'un nouveau matériel sur le système).

    tmpwatch

    Supprime automatiquement les fichiers qui n'ont pas été accédés depuis une certaine période. Appelé habituellement par crond pour supprimer les fichiers journaux.

    MAKEDEV

    Utilitaire pour la création des fichiers périphériques. Il doit être lancé en tant que root et dans le répertoire /dev. 
    root# ./MAKEDEV
    C'est une espèce de version avancée de mknod.

    Backup

    dump, restore

    La commande dump est un utilitaire élaboré de sauvegarde du système de fichiers, généralement utilisé sur des grosses installations et du réseau. [5] Il lit les partitions brutes du disque et écrit un fichier de sauvegarde dans un format binaire. Les fichiers à sauvegarder peuvent être enregistrés sur un grand nombre de média de stockage incluant les disques et lecteurs de cassettes. La commande restore restaure les sauvegardes faites avec dump.

    fdformat

    Réalise un formattage bas-niveau sur une disquette.

    Ressources système

    ulimit

    Initialise une limite supérieure sur l'utilisation des ressources système. Habituellement appelé avec l'option -f, qui intialise une limite sur la taille des fichiers (ulimit -f 1000 limite les fichiers à un mégaoctet maximum). L'option -t limite la taille du coredump (ulimit -c 0 élimine les coredumps). Normalement, la valeur de ulimit serait configurée dans /etc/profile et/ou ~/.bash_profile (voir Chapitre 27).

    Important

    Un emploi judicieux de ulimit peut protéger un système contre l'utilisation des bombes fork.

    #!/bin/bash

while 1     #  Boucle sans fin.
do
  $0 &      #  Ce script s'appelle lui-même . . .
            #+ un nombre infini de fois . . .
            #+ jusqu'à ce que le système se gèle à cause d'un manque de ressources.
done        #  C'est le scénario notoire de l'<< apprentissage du sorcier >>.

exit 0      #  Ne sortira pas ici, car ce script ne terminera jamais.

    Un ulimit -Hu XX (où XX est la limite du nombre de processus par utilisateur) dans /etc/profile annulerait ce script lorsqu'il dépassera cette limite.

    umask

    Masque pour la création d'un fichier utilisateur (User MASK). Limite les attributs par défaut d'un fichier pour un utilisateur particulier. Tous les fichiers créés par cet utilisateur prennent les attributs spécifiés avec umask. La valeur (octale) passée à umask définit les droits du fichiers non actifs. Par exemple, umask 022 nous assure que les nouveaux fichiers auront tout au plus le droit 0755 (777 NAND 022). [6] Bien sûr, l'utilisateur peut ensuite modifier les attributs de fichiers spécifiques avec chmod. La pratique habituelle est d'initialiser la valeur de umask dans /etc/profile et/ou ~/.bash_profile (voir Chapitre 27).

    rdev

    Obtenir des informations sur ou modifier le périphérique racine, l'espace swap ou le mode vidéo. La fonctionnalité de rdev a été principalement repris par lilo, mais rdev reste utile pour configurer un disque ram. C'est une autre commande dangereuse si elle est mal utilisée.

    Modules

    lsmod

    Affiche les modules noyau installés.

    bash$ lsmod
Module                  Size  Used by
 autofs                  9456   2 (autoclean)
 opl3                   11376   0
 serial_cs               5456   0 (unused)
 sb                     34752   0
 uart401                 6384   0 [sb]
 sound                  58368   0 [opl3 sb uart401]
 soundlow                 464   0 [sound]
 soundcore               2800   6 [sb sound]
 ds                      6448   2 [serial_cs]
 i82365                 22928   2
 pcmcia_core            45984   0 [serial_cs ds i82365]

    Note

    Faire un cat /proc/modules donne la même information.

    insmod

    Force l'installation d'un module du noyau (utilise modprobe à la place, lorsque c'est possible). Doit être appelé en tant que root.

    rmmod

    Force le déchargement d'un module du noyau. Doit être appelé en tant que root.

    modprobe

    Chargeur de modules normalement appelé à partir d'un script de démarrage. Doit être appelé en tant que root.

    depmod

    Crée un fichier de dépendances de module, appelé habituellement à partir d'un script de démarrage.

    Divers

    env

    Lance un programme ou un script avec certaines variables d'environnement initialisées ou modifiées (sans modifier l'environnement système complet). [nomvariable=xxx] permet la modification d'une variable d'environnement nomvariable pour la durée du script. Sans options spécifiées, cette command affiche tous les paramètrages de variables d'environnement.

    Note

    Dans Bash et d'autres dérivatifs du shell Bourne, il est possible d'initialiser des variables dans un environnement d'une seule commande. 
    var1=valeur1 var2=valeur2 commandeXXX
# $var1 et $var2 sont uniquement dans l'environnement de 'commandeXXX'.

    Astuce

    La première ligne d'un script (la ligne << #-! >>) peut utiliser env lorsque le chemin vers le shell ou l'interpréteur est inconnu. 
    #! /usr/bin/env perl

print "Ce script Perl tournera,\n";
print "même si je ne sais pas où se trouve Perl.\n";

# Bon pour les scripts portables entre les platformes,
# où les binaires Perl pourraient être à l'endroit attendu.
# Merci, S.C.

    ldd

    Affiche les dépendances des bibliothèques partagées d'un exécutables.

    bash$ ldd /bin/ls
libc.so.6 => /lib/libc.so.6 (0x4000c000)
/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x80000000)
    strip

    Supprime les références symboliques de déboguage à partir d'un exécutable. Ceci réduit sa taille mais rend le déboguage impossible.

    Cette commande est fréquente dans un Makefile mais bien plus rare dans un script shell.

    nm

    Affiche les symboles dans un binaire compilé sur lequel la commande strip n'a pas agi.

    rdist

    Client distant: synchronise, clone ou sauvegarde un système de fichiers sur un serveur distant.

    En utilisant notre connaissance des commandes administratives, examinons un script système. Une des façons les plus courtes et les plus simples de comprendre les scripts est killall, utilisée pour suspendre les processus en cours lors de l'arrêt du système.

    Exemple 13-8. killall, à partir de /etc/rc.d/init.d

    #!/bin/sh

# --> Commentiares ajoutés par l'auteur de ce document identifiés par "# -->".

# --> Ceci fait partie du paquetage de scripts 'rc'
# --> par Miquel van Smoorenburg, <miquels@drinkel.nl.mugnet.org>

# --> Ce script particulier semble être spécifique à Red Hat
# --> (il pourrait ne pas être présent dans d'autres distributions).

# Arrête tous les services inutiles qui sont en cours d'exécution (ils ne
# devraient pas, donc il s'agit juste d'un test)

for i in /var/lock/subsys/*; do
        # --> Boucle for/in standard, mais comme "do" se trouve sur la même
	# --> ligne, il est nécessaire d'ajouter ";".
	# Vérifie si le script existe.
	[ ! -f $i ] && continue
	# --> C'est une utilisation intelligente d'une "liste et", équivalente
	# --> à if [ ! -f "$i" ]; then continue

	# Obtient  le nom du sous-système.
	subsys=${i#/var/lock/subsys/}
	# --> Correspondance de nom de variable qui, dans ce cas, est le nom du
	# --> fichier. C'est l'équivalent exact à subsys=`basename $i`.
	
	# -->  Il l'obtient du nom du fichier de verrouillage (si il existe un
	# --> fichier de verrou, c'est la preuve que le processus est en cours
	# --> d'exécution).
	# -->  Voir l'entrée "lockfile", ci-dessus.


	# Arrête le sous-système.
	if [ -f /etc/rc.d/init.d/$subsys.init ]; then
	    /etc/rc.d/init.d/$subsys.init stop
	else
	    /etc/rc.d/init.d/$subsys stop
        # --> Suspend les jobs et démons en cours en utilisant la commande
	# --> intégrée 'stop'.
	fi
done

    Ce n'était pas si mal. En plus d'un léger travail avec la correspondance de variables, il n'y a rien de plus ici.

    Exercice 1. Dans /etc/rc.d/init.d, analyse le script halt. C'est un peu plus long que killall mais similaire dans le concept. Faite une copie de ce script quelque part dans votre répertoire personnel et expérimentez-le ainsi (ne le lancez pas en tant que root). Lancez-le simultanément avec les options -vn (sh -vn nomscript). Ajoutez des commentaires extensifs. Modifiez les commandes << action >> en << echos >>.

    Exercice 2. Regardez quelques-uns des scripts les plus complexes dans /etc/rc.d/init.d. Regardez si vous comprenez certaines parties d'entre eux. Suivez la procédure ci-dessus pour les analyser. Pour plus d'indications, vous pouvez aussi examiner le fichier sysvinitfiles dans /usr/share/doc/initscripts-?.??, faisant partie de la documentation d'<< initscripts >>.

    Notes

    [1]

    C'est le cas pour les machines Linux ou Unix disposant d'un système de gestion de quotas disque.

    [2]

    La commande userdel échouera si l'utilisateur en cours de suppression est connecté à ce moment.

    [3]

    Pour plus de détails sur la gravure de CDR, voir l'article d'Alex Withers, Créer des CDs, dans le numéro d'octobre 1999 du Linux Journal.

    [4]

    L'option -c de mke2fs demande aussi une vérification des blocs défectueux.

    [5]

    Les opérateurs de systèmes Linux simple utilisateur préfèrent généralement quelque chose de plus simple pour leur sauvegarde, comme tar.

    [6]

    NAND est l'opérateur logique << not-and >>. Son effet est similaire à la soustraction.

    PrécédentSommaireSuivant
    Commandes diversesNiveau supérieurSubstitution de commandes