Chapitre 4

Le Shell

1. Présentation

Il y a deux familles de shell :

le Bourne-shell (sh) :

z-shell (zsh).

Bash.

ksh.

le c-shell (csh) :

tcsh.

a. Fonctionnement
New Line correspond au retour à la ligne (généralement la touche Entrée).

b. Syntaxe

Exécution séquentielle :

% commande1 ; commande2

La suite de commande : % commande1 ; commande2 ; commande3 correspond à la séquence : % commande1

% commande2

% commande3

Exécution en tache de fond :

% commande &

Exécution asynchrone :

% commande1 & commande2

2. Scripts
Un script correspond à une suite de commandes écrite dans un fichier.

Exemple :

Prog

#! /bin/sh______# interpréteur
commande1
commande2___# même chose que : commande1; commande2

Si on ne veut pas que NL (New Line) soit interprète, il suffit de mettre un "\ ".

Exemple :

Prog

#! /bin/sh
commande\
Suite de la commande très longue

Pour exécuter le script (ici Prog), il suffit de taper son nom :: % Prog <NL>

3. Communication interprocessus aux moyens des entrées/sorties

a. | Tube (pipe en anglais)

commande1 | commande2
La sortie standard de commande1 est envoyée sur l'entrée standard de commande2 (par un tube). commande1 est exécutée de manière asynchrone par rapport à commande2.

Attention :

commande1 | commande2 | commande1 n'est pas une boucle. Ce sont trois processus distincts. C'est la même chose que commande1 | commande2 | commande3 avec commande3=commande1. C'est ce que l'on appelle un tuyau (pipeline).

b. Exécutions conditionnelles
&& et || sont des opérateurs binaires.

Remarque :

On peut obtenir le code de sortie d'un processus par le biais de la commande exit.

exit (n) en C

exit n en sh

Si n=0, alors le processus s'est déroulé sans erreur

Sinon il y a eu une erreur correspondant au code de sortie n.

% commande1 && commande2 && commande3

commande2s'exécute ssi le code de sortie de commande1 vaut 0. De même commande3 s'exécute ssi le code de sortie de commande2 vaut 0.

% commande1 || commande2 || commande3

commande2 s'exécute ssi le code de sortie de commande1 est diffèrent de 0. De même commande3 s'exécute ssi le code de sortie de commande2 est diffèrent de 0.

c. Liste

Commandes ou pipelines séparées par |, &, ;, &&, || :

|
& ;
&& ||

Ordre
de priorité
décroissante.

Exemple :
Pour % commande1 & commande2 | commande3 && commande4, on aura :: commande1 exécutée de manière asynchrone (&); commande2 exécutée de manière asynchrone aussi (propriété du tube); commande3 reçoit la sortie de commande2; commande4 est exécutée si commande3 s'est bien passée. Son entrée standard est commande2 (elle est la sortie standard de commande2).

d. Groupement : { liste;}

Permet de "choisir" les priorités, comme les parenthèses en mathématiques.

La ligne : % commande1 & { commande2|commande3;} && commande4 correspond à :

commande1 & (commande2|commande3) && commande4

e. Substitution de commandes
% ...`......`...
Le shell interprète d'abord la partie entre ``.

Exemple :

Truc

% `cat Truc` correspond à : % ls
% nis `cat Truc` passwd.org_dir correspond à : % nisls passwd.org_dir

Pour avoir des substitutions de commandes imbriquées :

% ...`...\`.....\`.....`...

La partie entre "\ " sera interprétée d'abord puis la partie entre ``.

Exemple : % which ls

/bin/ls

% which `cat Truc` /bin/ls

% rm `which \`cat truc \`` correspond à : % rm /bin/ls

f. Substitution de paramètres (ou variables)

Syntaxe :

%var=qcq # affectation et création, si la variable n'existe pas

Remarque :

`` et " " correspondent à la chaîne vide.

La commande unset permet de détruire une variable :
% unset var

Utilisation d'une variable (substitution) :
% ... $var ... # var est remplacée par sa valeur

Exemple : % var=debut

% echo $var

debut

% echo $varant

(aucun résultat) % echo ${var}ant

debutant

g. Génération de noms de fichiers

Pour cela on utilise les caractères suivants :
* [ ] ! - pour les noms de fichiers ou chemins.

* correspond à toute chaîne
[...] correspond à un ensemble de caractères

Exemple :
[%ab] correspond à {%, a, b}
[a-z] correspond à {a, b, c, ...,z}
[0-9] correspond à {0,1, ...,9}
[A-Z] correspond à {A, B, C, ...,Z}

[ !....] correspond au complément (d'un ensemble de caractères donné).
Exemple :
[ !A-Za-z0-9] correspond à tout caractère qui n'est ni une lettre, ni un chiffre.

Des combinaisons sont possibles.
Exemple :
[c-fAX-Z] correspond à {c, d, e, f, A, X, Y, Z}
*[0-9]* toute chaîne qui contient au moins un chiffre.
* au début d'une expression ne représente pas de chaîne commençant par . ou /

Exemple d'utilisation avec des commandes :
% echo /b*

/bin/boot

% rm /b* suppression des fichiers commençant par b ou des répertoires vides commençant par b

% ls

prog.c prog.o .nfs0715 .nfs0716 .pp

% rm [/.]p* supprime les fichiers commençant par .p ou les répertoires vides commençant par /p. Ici seul le fichier .pp est concerné.

4. Les variables

Paramètres (variables) Variables d'environnement
(généralement en majuscules)
Ex : PATH

a. Variables d'environnement
Marquer une variable permet de l'ajouter aux variables d'environnements (pour transmission au fils).

Commande pour marquer une variable : export.
% MA_VARIABLE=valeur

Exemple de variables d'environnement :

HOME : Chemin d'accès de votre répertoire d'accueil.

PATH : liste des répertoires a parcourir pour trouver un programme.

Habituellement on a PATH=.:/usr/dt/bin:/usr/openwin/bin:/usr/local/X11RS: /soft/SUNW/Spro/bin:/usr/... Les différents répertoires sont séparés par :. Ce sont les répertoires du PATH ,ordonnés.

SHELL : chemin d'accès du programme shell (zsh par exemple).

USER : identifiant de l'utilisateur connecté.

b. Paramètres internes d'un shell
Elles ne peuvent pas être exportées, ce ne sont pas des variables d'environnement. L'affectation "= " ne marche pas.

Paramètres positionnels :
Pour l'écriture d'un script

Exemple :

Prog

#! /bin/sh
...
...

0	1	2	:paramètres positionnels
% prog	argument1	argument2

#! /bin/sh
echo $0 # affiche le mot prog
echo $1 # affiche l'argument1

Pour modifier les paramètres positionnels on utilise la commande set.

Exemple :

	1	2	3
%set	mot1	mot2	mot3	...

Attention : ne marche pas pour 0.

Commande interne pour modifier les paramètres positionnels : shift.

Autres :
- # :nombre de paramètres positionnels ($# pour avoir la valeur du paramètre).
- -:options données a l'appel du shell ($- pour avoir la valeur du paramètre). Modifiables par la commande set.
  
  Exemple :
  
  Commandes
#! /bin/sh
echo Bonjour

% sh commandes

(exécution du ficher commandes)

% sh -x commandes

(rien)

Prog

#! /bin/sh
set -x # active l'option x
echo Bonjour
...
set +x # désactive l'option x
- ! :pid des derniers fils exécutés de manières asynchrones ($! pour avoir la valeur du paramètre).
- ? :code de retour de la dernière commande ($? pour avoir la valeur du paramètre).
- $ :pid du shell courant ($$ pour avoir la valeur du paramètre).
- * :les paramètres positionnels séparés par des espaces.

5. Redirections d'entrées/sorties

Généralement le shell a trois fichiers ouverts, correspondants à trois descripteurs (parfois appelés canaux) :

Le descripteur 0 : entrée standard

Le descripteur 1 : sortie standard

Le descripteur 2 : sortie d'erreur

Remarque :

Il existe toutefois sept canaux supplémentaires configurables en entrée ou en sortie (de 3 à 9).

Quelles que soient leurs positions dans la ligne de commande, les redirections sont traitées en premier par le shell.
Exemple :
% prog >fichier bonjour
est identique a :
% prog bonjour >fichier

a. Les différents types de redirections

>fichier : redirection de sortie vers fichier. Le fichier est créé s'il n'existe pas, sinon il est écrasé.

>>fichier : redirection de sortie vers fichier. Le fichier est créé s'il n'existe pas, sinon les données sont ajoutées à la fin du fichier existant.

<fichier : la lecture éventuelle de l'entrée standard (i.e. sur le descripteur 0) interviendra sur fichier.

<<mot : lecture de l'entrée standard jusqu'à la première occurrence de "mot ". C'est ce que l'on appelle un herescript. Les caractères spéciaux doivent être verrouillés par des "\ " et dans ce cas aucun traitement des caractères spéciaux ne pourra avoir lieu. On peut faire la substitution de paramètres mais pas la génération de noms de fichier.
Exemple :
% cat <<fin
>Ceci est la première ligne
>Celle ci la seconde
>Et celle-ci la dernière
>Fin
Ceci est la première ligne
Celle ci la seconde
Et celle ci la dernière
%

2>fichier et/ou 2>>fichier : pour rediriger la sortie d'erreur standard vers fichier.

>&2 : redirige la sortie standard vers la sortie d'erreur.

2>&1 : redirige la sortie d'erreur standard vers la sortie standard.

n>&m : tout ce qui écrit sur le descripteur n sera envoyé vers le descripteur m.
Exemple :
On veut afficher un message d'erreur, donc utiliser la sortie d'erreur.
echo "$0 : vous n'avez pas le droit d'écrire dans le fichier $1">$2

b. Instructions

If...then...elseif...else...fi :
if liste1 ; then
commandes1
elseif liste ; then
...
...
else
...
...
fi

Le new line est équivalent au " ; ".
Si le code de retour de liste1 est 0,le bloc de commandes1 est exécuté, sinon on passe à la suite. On peut aussi l'utiliser sous sa forme la plus simple :
if liste ; then
...
...
fi

while...do...done :
while liste ; do
...
...
done

Exemple :
while [ $# -ge 1 ] ; do
... # traitement de $1
shift
done

for...in...do...done :
for var in mot1 mot2 mot3 ;do ...
...
done

Exemple :

Prog

For var in 1 2 3 4 ;do
echo $var
done

% prog
1
2
3
4
%

ensemble="element1 element2 element3"
...
...
for var in $ensemble ; do
...
...
done

Remarque :

for var in $* ;do
... # traitement de $var
done

est équivalent à

for var ;do
...
done

case...in...)...esac :
case mot in
motif1)
...
... ;;
motif2)
...
... ;;
esac

Les motifs sont les mêmes que pour la génération de noms de fichiers excepté qu'il n'y a pas de problème pour . ou / en début de chaîne.
Exemple :
case $user in linf[0-9]|linf[0-9][1-9]) ... ... ;; minf[0-9]|minf[0-9][1-9]) ... ... ;; *) ... ... ;; esac

Remarque :

*) correspond à sinon, c'est à dire tous les autres cas.

c. Fonctions
L'intérêt d'une fonction est que l'on peut en mettre plusieurs dans un script afin de gérer des répetitions de commandes (ou de groupes de commandes).

Déclaration :
nom(){
...
... ;
}
ou
nom(){.... ;}

A l'intérieur d'une fonction il est possible d'utiliser l'instruction return n : on quitte la fonction avec le code de retour n.

Appel :

%nom argument1 argument2 ... argumentn
$1 $2 ... $n

La commande test : ce n'est pas une commande interne du shell.
Syntaxe : test expression

Exemple :
if test $1 = qcq ; then
...
...
fi

Sous sh , au lieu de la commande test, on peut utiliser [ ].
Exemple :
if [ $1 = qcq ]; then
...
...
fi

%nom	argument1	argument2	...	argumentn
	$1	$2	...	$n

d. Test de fichiers

Si le fichier existe et... :

-r :est lisible

-w :l'écriture est possible

-x :exécutable
Exemple :
if [ -r $2 ] ;then
...
...
else
echo "$0 :vous n'avez pas le droit de lire le fichier $2">&2
fi

-f :est un fichier ordinaire

-d :est un répertoire

-p :est une représentation interne d'un dispositif de communication

-c :est un pseudo-fichier du type accès caractère par caractère

-b :est un pseudo-fichier du type accès par bloc

-L :est un lien symbolique

-u : son Set UID=1

-g :son Set GID=1

-k :son Sticky Bit=1

-S :est non-vide

e. Autres tests

-t descripteur: vraie si descripteur est associé à un terminal. Si descripteur est omis, le test fait référence au descripteur de sortie standard (c'est à dire au canal 1).

Exemple :

Prog

if [ -t 0 ] ;then
prompt="Ok>"
fi
...
...
echo$[prompt]\c
read ligne

% Prog fichier

test chaîne (ou [ chaîne ]) : vraie si chaîne est une chaîne vide
-z chaîne :vraie si chaîne est une chaîne vide
-w chaîne :vraie si chaîne est une chaîne non-vide

f. Tests binaires

chaine1 = chaine2 : vraie si chaine1 est égale a chaine2

chaine1 != chaine2 : vraie si chaine1 n'est pas égale à chaine2

n1 -eq n2 : vraie si n1 est égal a n2

n1 -ne n2 : vraie si n1 est diffèrent de n2

n1 -gt n2 : vraie si n1 est plus grand strictement a n2

n1 -ge n2 : vraie si n1 est plus grand ou égal à n2

n1 -lt n2 : vraie si n1 est plus petit strictement a n2

n1 -le n2 : vraie si n1 est plus petit ou égal à n2

6. Commandes internes de sh

a. Commandes importantes
return
shift
set
export
break
continue

Les quatre premières commandes ont déjà été présenté dans les chapitres précédents.

break n :

Permet de sortir d'une boucle en allant au niveau n.
Exemple :

for...

while...
...
...
break 2
...
...
done

...
done
... # on se retrouve alors ici

continue n :

Permet de passer à la prochaine occurrence d'une boucle au niveau n
Exemple :

while...

for...
...
...
continue 2 # Renvoie à la prochaine occurrence du while
...
...
done

...
done
...

b. Autres commandes a connaître

cd :

cd répertoire :permet de modifier le répertoire courant

cd :permet de revenir au répertoire personnel (habituellement celui indiqué par la variable HOME).

echo :

echo chaîne :affiche la chaîne par la sortie standard.

echo $variable :affiche la valeur de variable.

eval :

Permet l'évaluation d'une ligne de commande.
Exemple :
%a='Ceci est un exemple'
%b=a
%echo $b
a
%echo \$$b
$a
%eval echo \$$b
Ceci est un exemple

%c=\$$b
%echo $c
$a
%eval c=\$$b
%echo $c
Ceci est un exemple

read :

read variable1 variable2 ...variablen
Le premier mot lu sera associé à variable1
Le second mot lu sera associé à variable2
...
Le n-1éme mot lu sera associé à variable(n-1)
...et tous les mots lus après le n-1eme seront associés à la variable n.

pwd :affiche le répertoire courant.

type nom : affiche la commande détaillée liée a nom.

trap :

trap argument n₁ ...n_i :si les signaux n₁ ...n_i arrivent alors argument sera exécuté.
Exemple :
%trap '' INT # INT correspond à Ctrl-C
Après cette commande ,Ctrl-C n'aura plus aucune action.

trap n₁...n_i :remet les dispositions par défaut.
Exemple :
%trap INT

trap : affiche les dispositions associées aux signaux

umask :

umask xyz :permet de définir le masque pour tous les fichiers nouvellement créés. A l'origine les nouveaux fichiers sont dotés des droits : -rw-rw-rw- et les nouveaux répertoires des droits : -rwxrwxrwx. La valeur octale xyz associée à umask est soustraite de la valeur existante.
Exemple :
%umask 022
Après cette commande tous les fichiers nouvellement créés auront les droits suivants : -rw-r--r--et les nouveaux répertoires les droits : -rwxr-xr-x.

umask : permet de connaître le masque actif.

Pour modifier les droits des fichiers existants il faut utiliser la commande chmod.