Documentation<Précédent | Table des matières | Suivant>
Pièges
Au chapitre 10, nous avons vu comment les programmes peuvent répondre aux signaux. Nous pouvons également ajouter cette capacité à nos scripts. Alors que les scripts que nous avons écrits jusqu'à présent n'ont pas eu besoin de cette capacité (car ils ont des temps d'exécution très courts et ne créent pas de fichiers temporaires), les scripts plus gros et plus compliqués peuvent bénéficier d'une routine de gestion des signaux.
Lorsque nous concevons un script volumineux et compliqué, il est important de considérer ce qui se passe si l'utilisateur se déconnecte ou éteint l'ordinateur pendant l'exécution du script. Lorsqu'un tel événement se produit, un signal sera envoyé à tous les processus concernés. À leur tour, les programmes représentant ces processus peuvent effectuer des actions pour assurer une terminaison correcte et ordonnée du programme. Disons, par exemple, que nous avons écrit un script qui a créé un fichier temporaire lors de son exécution. Dans le cadre d'une bonne conception, nous aurions le script supprimer le fichier lorsque le script a terminé son travail. Il serait également judicieux que le script supprime le fichier si un signal est reçu indiquant que le programme allait se terminer prématurément.
bash fournit un mécanisme à cette fin connu sous le nom de piège. Les pièges sont implémentés avec la commande intégrée nommée de manière appropriée, piège. piège utilise la syntaxe suivante :
piège signal d'argument [signal...]
De argument est une chaîne qui sera lue et traitée comme une commande et signal est la spécification d'un signal qui déclenchera l'exécution de la commande interprétée.
Voici un exemple simple:
#! / Bin / bash
# trap-demo : démo simple de gestion des signaux
#! / Bin / bash
# trap-demo : démo simple de gestion des signaux
trap "echo 'Je t'ignore.'" SIGINT SIGTERM for i in {1..5} ; faire
echo "Itération $i de 5" sleep 5
fait
trap "echo 'Je t'ignore.'" SIGINT SIGTERM for i in {1..5} ; faire
echo "Itération $i de 5" sleep 5
fait
Ce script définit un piège qui exécutera un echo commande chaque fois que le signal SIG-INT ou SIGTERM est reçu pendant l'exécution du script. L'exécution du programme ressemble à ceci lorsque l'utilisateur tente d'arrêter le script en appuyant sur Ctrl-c:
[moi@linuxbox ~]$ démo-piège
Itération 1 sur 5
Itération 2 sur 5 Je vous ignore. Itération 3 sur 5 Je vous ignore. Itération 4 sur 5
Itération 5 sur 5
[moi@linuxbox ~]$ démo-piège
Itération 1 sur 5
Itération 2 sur 5 Je vous ignore. Itération 3 sur 5 Je vous ignore. Itération 4 sur 5
Itération 5 sur 5
Comme nous pouvons le voir, chaque fois que l'utilisateur tente d'interrompre le programme, le message est imprimé à la place.
Construire une chaîne pour former une séquence utile de commandes peut être délicat, il est donc courant de spécifier une fonction shell comme commande. Dans cet exemple, une fonction shell distincte est spécifiée pour chaque signal à traiter :
#! / Bin / bash
# trap-demo2 : démo simple de gestion des signaux exit_on_signal_SIGINT () {
echo "Script interrompu." 2>&1 sortie 0
}
exit_on_signal_SIGTERM () {
echo "Script terminé." 2>&1 sortie 0
}
déroutement exit_on_signal_SIGINT SIGINT déroutement exit_on_signal_SIGTERM SIGTERM
#! / Bin / bash
# trap-demo2 : démo simple de gestion des signaux exit_on_signal_SIGINT () {
echo "Script interrompu." 2>&1 sortie 0
}
exit_on_signal_SIGTERM () {
echo "Script terminé." 2>&1 sortie 0
}
déroutement exit_on_signal_SIGINT SIGINT déroutement exit_on_signal_SIGTERM SIGTERM
pour i dans {1..5} ; faire
echo "Itération $i de 5" sleep 5
fait
pour i dans {1..5} ; faire
echo "Itération $i de 5" sleep 5
fait
Ce script comporte deux piège commandes, une pour chaque signal. Chaque trap, à son tour, spécifie une fonction shell à exécuter lorsque le signal particulier est reçu. Notez l'inclusion d'un sortie commande dans chacune des fonctions de traitement du signal. Sans un sortie, le script se poursuivrait une fois la fonction terminée.
Lorsque l'utilisateur appuie Ctrl-c lors de l'exécution de ce script, les résultats ressemblent à ceci :
[moi@linuxbox ~]$ piège-demo2
Itération 1 sur 5
Itération 2 sur 5 Script interrompu.
[moi@linuxbox ~]$ piège-demo2
Itération 1 sur 5
Itération 2 sur 5 Script interrompu.
Fichiers temporaires
L'une des raisons pour lesquelles les gestionnaires de signaux sont inclus dans les scripts est de supprimer les fichiers temporaires que le script peut créer pour conserver les résultats intermédiaires pendant l'exécution. Il y a quelque chose d'un art à nommer des fichiers temporaires. Traditionnellement, les programmes sur les systèmes de type Unix créent leurs fichiers temporaires dans le / Tmp répertoire, un répertoire partagé destiné à de tels fichiers. Cependant, étant donné que le répertoire est partagé, cela pose certains problèmes de sécurité, en particulier pour les programmes exécutés avec des privilèges de superutilisateur. Mis à part l'étape évidente consistant à définir les autorisations appropriées pour les fichiers exposés à tous les utilisateurs du système, il est important de donner aux fichiers temporaires des noms de fichiers non prévisibles. Cela évite un exploit connu sous le nom de attaque de course temporaire. Une façon de créer un nom non prévisible (mais toujours descriptif) est de faire quelque chose comme ceci :
fichier temporaire=/tmp/$(nom de base $0).$$.$RANDOM
Cela créera un nom de fichier composé du nom du programme, suivi de son ID de processus (PID), suivi d'un entier aléatoire. Notez cependant que le $RAN-DOM La variable shell ne renvoie qu'une valeur comprise entre 1 et 32767, ce qui n'est pas une plage très large en termes informatiques, donc une seule instance de la variable n'est pas suffisante pour vaincre un attaquant déterminé.
Une meilleure façon est d'utiliser le mktemp programme (à ne pas confondre avec le mktemp fonction de bibliothèque standard) pour nommer et créer le fichier temporaire. Les mk-temp programme accepte un modèle comme argument qui est utilisé pour construire le nom de fichier. Le modèle doit inclure une série de caractères « X », qui sont remplacés par un nombre correspondant de lettres et de chiffres aléatoires. Plus la série de caractères « X » est longue, plus la série de caractères aléatoires est longue. Voici un exemple:
fichier temporaire=$(mktemp /tmp/foobar.$$.XXXXXXXXXX)
Cela crée un fichier temporaire et attribue son nom à la variable fichier temporaire. Les caractères « X » dans le modèle sont remplacés par des lettres et des chiffres aléatoires afin que le nom de fichier final (qui, dans cet exemple, inclut également la valeur étendue du paramètre spécial $$ pour obtenir le PID) pourrait être quelque chose comme :
/tmp/foobar.6593.UOZuvM6654
Pour les scripts exécutés par des utilisateurs réguliers, il peut être judicieux d'éviter l'utilisation du / Tmp répertoire et créez un répertoire pour les fichiers temporaires dans le répertoire personnel de l'utilisateur, avec une ligne de code comme celle-ci :
[[ -d $HOME/tmp ]] || mkdir $HOME/tmp