IV. Le Shell

1. Présentation

a. Fonctionnement

b. Syntaxe

2. Scripts

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

a. | Tube (pipe en anglais)

b. Exécutions conditionnelles

c. Liste

d. Groupement : { liste;}

e. Substitution de commandes

f. Substitution de paramètres (ou variables)

g. Génération de noms de fichiers

4. Les variables

a. Variables d'environnement

b. Paramètres internes d'un shell

5. Redirections d'entrées/sorties

a. Les différents types de redirections

b. Instructions

c. Fonctions

d. Test de fichiers

e. Autres tests

f. Tests binaires

6. Commandes internes de sh

a. Commandes importantes

b. Autres commandes

Il y a deux familles de shell :

• le Bourne-shell (sh) :
  • z-shell (zsh).
  • Bash.
  • ksh.
• le c-shell (csh) :
  • tcsh.

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

Exemple :

Prog

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

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>

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).

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

commande2 s'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.

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).

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

commande1 & (commande2|commande3) && commande4

Exemple :

Truc

ls

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

Syntaxe :

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

Remarque :

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

Exemple :

% var=debut

% echo $var

debut

% echo $varant

(aucun résultat)

% echo ${var}ant

debutant

Exemple d'utilisation avec des commandes :

% echo /b*

/bin/boot

% 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é.

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

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é.

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

  Exemple :

  Prog

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

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

  #! /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 :

  %set	mot1	mot2	mot3	...
  	1	2	3

  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.

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).

• >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

• 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.

• 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

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

• -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

• 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

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
...

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.

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.