Le programme Shell UNIX interprète les ordres de contrôle, qu'ils soient donnés par l'utilisateur, ou qu'ils soient lus depuis un fichier appelé script Shell ou programme Shell. Les scripts Shell sont interprétés, et non pas compilés. Le Shell lit les commandes du script ligne par ligne et recherche ces commandes dans le système (voir Section 2, « Avantages du Bourne Again SHell »), tandis que le compilateur convertit un programme sous une forme exploitable par la machine, un fichier exécutable - lequel peut être alors à son tour utilisé dans un script.

A part de passer des commandes au noyau, la tâche principale du Shell est de mettre en place un environnement utilisateur qui peut être configuré individuellement par le biais de fichiers de configuration.

De même que les gens peuvent parler plusieurs langues, votre système UNIX offre en principe différents Shell.

Le fichier /etc/shells donne une vue d'ensemble des Shells connus sur un système Linux:

        mia:~>
        cat /etc/shells
        
/bin/bash
/bin/sh
/bin/tcsh
/bin/csh

Le Shell par défaut est déclaré dans le fichier /etc/passwd, comme cette ligne pour l'utilisateur mia:

mia:L2NOfqdlPrHwE:504:504:Mia Maya:/home/mia:/bin/bash

Pour activer un autre Shell, il suffit de taper le nom de ce Shell sur la ligne de commande. Le système localise le répertoire où apparaît le nom du nouveau Shell en utilisant la déclaration PATH, et comme le Shell est un fichier exécutable (un programme), le Shell courant le lance et rend actif le nouveau Shell. Une nouvelle invite est souvent affichée, du fait que chaque Shell a une interface propre:

        mia:~>
        tcsh
[mia@post21 ~]$

Le projet GNU (ne pas confondre GNU et UNIX) offre des outils pour l'administration de système de type UNIX qui sont libres et qui respectent les standards UNIX.

Bash est un Shell compatible avec sh qui incorpore des fonctionnalités pratiques du Korn shell (ksh) et du C shell (csh). Il est censé se conformer à la norme IEEE POSIX P1003.2/ISO 9945.2 Standards des Shell et Outils. Il offre des améliorations fonctionnelles par rapport à sh pour la programmation et l'utilisation interactive; ce qui inclut l'édition de commande en ligne, historique illimité des commandes, contrôle des travaux, fonctions Shell et alias, tableau indexé de taille illimitée, et l'arithmétique d'entiers dans toutes les bases depuis la base 2 jusqu'à la base 64. Bash peut exécuter la plupart des scripts sh sans modification.

Comme les autres projets GNU, le projet bash a été lancé pour préserver, protéger et promouvoir la liberté d'utiliser, étudier, copier, modifier et redistribuer les logiciels. Il est généralement admis que de telles conditions stimulent la créativité. Cela a été le cas avec le programme Bash, qui a beaucoup de fonctionnalités que les autres Shells n'offrent pas.

Bash détermine le type de programme qui est à exécuter. Les programmes standards sont les commandes système qui existent sous forme compilée dans le système. Quand un tel programme est exécuté, un nouveau processus est crée parce que Bash lance une copie exacte de lui-même. Ce processus fils a le même environnement que son parent, seul l'identifiant est différent. Cette procédure est appelée forking(NdT: fourcher).

Une fois que le processus a fourché, l'espace d'adresse du processus fils est renseigné avec ses propres informations. Ceci est fait grâce à un appel système par exec.

Le mécanisme fork-and-exec interrompt une commande en cours pour une autre, tandis que l'environnement dans lequel ce nouveau programme est exécuté reste le même, ce qui inclut la configuration des périphériques d'entrée/sortie, les variables d'environnement et les priorités. Ce mécanisme est utilisé pour créer tous les processus UNIX, donc il est appliqué aussi par le système d'exploitation de Linux. Même le premier processus, init, avec l'identifiant 1, fourche pendant le démarrage dans la procédure appelée bootstrapping.

Les commandes intégrées sont incorporées dans le Shell lui-même. Quand le nom d'une commande intégrée est employé comme le premier mot d'une commande simple, le Shell exécute la commande directement, sans créer un nouveau processus. Les commandes intégrées sont nécessaires pour implanter des fonctionnalités impossibles ou difficiles à mettre en oeuvre par des outils externes. (NdT: dans la suite de ce document nous parlerons de façon elliptique d'intégrée pour dire commande intégrée)

Bash possède 3 types de commandes intégrées:

La plupart de ces intégrées seront abordées dans les chapitres suivants. Pour les commandes qui ne le seront pas, se référer aux pages Info.

Quand le programme à exécuter est un script Shell, Bash crée un nouveau processus Bash en fourchant. Ce sous-Shell lit les lignes du script une par une. Les commandes de chaque ligne sont lues, interprétées et exécutées comme si elles avaient été entrées au clavier.

Tandis que le sous-Shell opère sur chaque ligne du script, le Shell parent attend que le processus fils ait fini. Quand il n'y a plus de ligne à lire dans le script, le sous-Shell se termine. Le Shell parent s'active et affiche l'invite de nouveau.

Ce guide porte principalement sur les scripts (la dernière construction de blocs évoquée précédemment). Voyons quelques considérations générales avant de continuer:

La structure d'un script Shell est vraiment adaptable. Même si Bash permet beaucoup de liberté, vous devez mettre en oeuvre une logique rigoureuse, un contrôle des données, une efficacité qui permet à l'utilisateur qui exécute le script de le faire facilement et correctement.

Au moment d'écrire un nouveau script, posez-vous les questions suivantes:

La table ci-dessous donne une vue générale des termes de programmation que vous avez besoin de connaître:

De façon à abréger l'étape de développement, l'enchaînement logique d'un programme devrait être pensé à l'avance. C'est votre première étape quand vous développez un script.

Diverses méthodes peuvent être utilisées; une des plus courantes est la constitution de listes. Lister les opérations nécessaires au programme vous permet de décrire chaque tâche. Les opérations unitaires peuvent être référencées par leur numéro dans la liste.

En utilisant vos propres mots pour déterminer les opérations à exécuter par votre programme il vous sera plus facile de créer un programme compréhensible. Ensuite, vous écrivez le langage compris par Bash.

L'exemple ci-dessous montre un tel enchaînement logique. Il décrit la rotation des fichiers journaux. Cet exemple montre la possible réitération d'une boucle, en fonction du nombre de fichiers journaux sur lesquels vous voulez paramétrer une rotation.

L'utilisateur va devoir saisir des données pour que le programme effectue quelque chose. La saisie de l'utilisateur doit être sollicitée et mémorisée. L'utilisateur devrait être informé que 'son' crontab va être changé.

Le script mysystem.sh ci-dessous exécute des commandes bien connues (date, w, uname, uptime) pour afficher des informations au sujet de la machine et sur vous.

        tom:~>
        cat -n
          mysystem.sh
        
     1  #!/bin/bash
     2  clear
     3  echo "Ce sont des informations fournies par mysystem.sh.  Le programme démarre maintenant."
     4
     5  echo "Bonjour, $USER"
     6  echo
     7
     8  echo "Nous sommes le `date`, semaine `date +"%V"`."
     9  echo
    10
    11  echo "Ces utilisateurs sont actuellement connectés:"
    12  w | cut -d " " -f 1 - | grep -v USER | sort -u
    13  echo
    14
    15  echo "`uname -s` est le système, `uname -m` le processeur."
    16  echo
    17
    18  echo "Le système fonctionne depuis:"
    19  uptime
    20  echo
    21
    22  echo "C'est pas plus compliqué!"

Un script commence toujours par ces 2 caractères: « #! ». Suit le nom du Shell qui exécutera les commandes suivant. Ce script commence en effaçant l'écran à la ligne 2. La ligne 3 fait afficher un message pour informer l'utilisateur de ce qui va se passer. La ligne 5 salue l'utilisateur. Les lignes 6, 9, 13, 16 et 20 ne sont là que pour aérer l'affichage des résultats. La ligne 8 affiche la date du jour et le numéro de la semaine. Ligne 11 encore un message informatif, ainsi que ligne 3, 18 et 22. La ligne 12 formate le résultat de la commande w; la ligne 15 affiche le nom du système d'exploitation et le type de processeur. La ligne 19 donne la durée de fonctionnement du système ainsi que sa charge.

echo et printf sont des commandes intégrées de Bash. La première retourne toujours un statut à 0, et affiche simplement ses arguments terminés par un caractère de fin de ligne sur la sortie standard, tandis que la deuxième autorise des options de formatage de la chaîne et renvoie un statut différent de 0 en cas d'échec.

Voici le même script avec l'intégrée printf:

        tom:~>
        cat mysystem.sh
        
#!/bin/bash
clear
printf "Ce sont des informations fournies par mysystem.sh.  Le programme démarre maintenant."

printf "Bonjour, $USER.\n\n"

printf "Nous sommes le `date`, semaine `date +"%V"`.\n\n"

printf "Ces utilisateurs sont actuellement connectés:\n"
w | cut -d " " -f 1 - | grep -v USER | sort -u
printf "\n"

printf "`uname -s` est le système, `uname -m` le processeur.\n\n"

printf "Le système fonctionne depuis:\n"
uptime
printf "\n"

printf "C'est pas plus compliqué\n"

L'écriture d'un script convivial en insérant des messages est traité au Chapitre 8, Ecrire des scripts interactifs.

Les chapitres suivants traiteront en détail les scripts ci-dessus.

Un init script démarre les services des systèmes UNIX et Linux. Les démons de journalisation du système, de gestion des ressources, de contrôle d'accès et de mails en sont des exemples. Ces scripts, appelés aussi scripts de démarrage, sont stockés à un endroit spécifique du système, tel que dans /etc/rc.d/init.d ou /etc/init.d. Init, le processus initial, lit ses fichiers de configuration et décide quels services il démarre ou arrête en fonction du niveau d'exécution système. Le niveau d'exécution est un état de configuration du système (NdT qui correspond à une utilisation particulière du système); chaque système a un niveau d'exécution qui autorise un unique utilisateur, par exemple, pour exécuter des tâches administratives, pour lesquelles le système doit être dans un état aussi stable que possible. Comme récupérer un fichier système important depuis une sauvegarde. Les niveaux d'exécution de démarrage et d'arrêt sont habituellement aussi configurés.

Les tâches à exécuter au démarrage ou à l'arrêt d'un service sont listées dans le script de lancement. C'est l'une des tâches de l'administrateur système de configurer init, de façon que les services soient lancés et stoppés au bon moment. Quand vous êtes confrontés à cette tâche, vous avez besoin d'une bonne compréhension des procédures de démarrage et d'arrêt du système. Nous vous conseillons donc de lire les pages man pour init et inittab avant de vous lancer dans les scripts d'initialisation.

Voici un très simple exemple, qui jouera un son au démarrage et à l'arrêt de votre machine:

#!/bin/bash

# This script is for /etc/rc.d/init.d
# Link in rc3.d/S99audio-greeting and rc0.d/K01audio-greeting

case "$1" in
'start')
  cat /usr/share/audio/at_your_service.au > /dev/audio
  ;;
'stop')
  cat /usr/share/audio/oh_no_not_again.au > /dev/audio
  ;;
esac
exit 0

L'instruction case souvent utilisée dans ce genre de script est décrite à la Section 2.5, « Emploi de l'instruction exit et du if ».