Le Shell

Philippe Dax

Description générale
L'interpréteur de commandes
- lancement d'une commande
- redirection des entrées/sorties
- enchaînement des commandes et pipelines
- méta-caractères d'expansion
- variables prédéfinies
Programmation en shell
- fichier de commandes, shell-script
- variables formelles
- variables utilisateur, exportation et héritage
- instructions de contrôle
- substitutions
- quotage et évaluation
- déroutements
- commandes internes
- arithmétique en shell
- fonctions
- fichiers d'environnement et spécificités ENST

Fonctionnalités Générales

Processus premier d'une session
- user:password:uid:gid:comment:homedir:shell
- attaché au terminal console (login) ou à un pseudo-terminal (remote login, activation d'une fenêtre)
- xterm (X11), cmdtool et shelltool (openwin)
Interpréteur de commandes
- lecture et exécution de commandes
- redirection des entrées/sorties
- expansion des noms de fichiers
- interface utilisateur (historique, aliasing, contrôle des jobs, complétion, édition de lignes de commandes.
Langage de programmation
- programmation interactive (en ligne)
- programmation non-interactive (fichier de commandes)
- intructions conditionnelles et itératives, fonctions
- variables prédéfinies et variables utilisateur
- mécanismes de substitution de paramètres
- commandes internes (builtin)

Les Shells

sh ("Bourne shell", Steve Bourne)
- shell historique (disponible sur tous les Unix)
csh ("C-shell", Bill Joy)
- shell BSD (disponible sur tous les Unix)
ksh ("Korn shell")
- shell normalisé POSIX (P1003.2) et ISO (HP, Solaris)
bash ("Bourne again shell" de Brian Fox et Chet Ramey)
- Ksh du domaine public (installé sur toutes les machines)
zsh ("Zero shell")
- Ksh du domaine public (installé sur toutes les machines)
tcsh ("Toronto C-shell")
rc (Plan9, Tom Duff)

Comparaison des Shells


Shell       progr       jobs        histo       aliases     édition     flèche      extens    
                                                            ligne 
                  POSIX 
       
sh          std         non         non         non         non         non         non         
csh         non std     oui         oui         oui         non         non         non         
tcsh        non std     oui         oui         oui         oui         oui         non         
ksh         norme       oui         oui         oui         oui         non         non         
bash        norme       oui         oui         oui         oui         oui         non         
zsh         norme       oui         oui         oui         oui         oui         oui         
                                                                                          

Shell           interface utilisateur                programmation
                        
sh              inexistante                          sûre (standard)                      
csh             moyenne                              à déconseiller                       
tcsh            bonne                                à déconseiller                       
ksh             bonne                                normalisée                           
bash            bonne                                normalisée                           
zsh             excellente                           normalisée + extensions

Algorithme du shell

Ouverture initiale de 3 fichiers standard
- entrée standard (stdin, fd=0), par défaut le clavier
- sortie standard (stdout, fd=1), par défaut l'écran
- sortie erreur standard (stderr, fd=2), par défaut l'écran
Le shell lit sur son entrée standard
- lecture de la commande jusqu'à la fin de ligne (\n) et interprétation des métacaractères et opérateurs
- lecture des lignes de commandes jusqu'à la fin de fichier (^D)
Lancement d'une commande
- recherche du nom de la commande à l'aide du PATH (path)
- en premier plan : fork() exec(commande) wait() prompt
- en arrière plan : fork() exec(commande) prompt

Caractères de contrôle au clavier

Caractères de contrôle non gérés par le shell
- <cr> fin de ligne (retour chariot) mappé en <cr><lf>
- <lf> fin de ligne (nouvelle ligne) mappé en <cr><lf>
- <tab> tabulation
- <bs> ^H, backspace, effacement du caractère précédent
- <del> ^?, souvent identique à <bs>
- <^C> interruption d'un processus attaché au terminal
- <^\> arrêt d'un processus avec vidage mémoire (core)
- <^Z> suspension d'un processus en premier plan
- <^U> effacement de la ligne complète
- <^W> effacement du mot qui précède
- <^D> fin de fichier => si le shell lit, fin d'un shell
- <^S> suspension de l'affichage écran (Xoff)
- <^Q> reprise de l'affichage écran (Xon)
Gestion des caractères de contrôle par stty
- stty erase ^H kill ^U intr ^C susp ^Z quit ^\ eof ^D

Format d'une commande

Métacaractères
- | & ; ( ) < > <espace> <tab>
Opérateurs de contrôle
- || & && ; ;; ( ) | <newline>

Format d'une commande

Invite (le prompt) principale
- $ en mode utilisateur
- # en mode super-utilisateur
- <user@host: num> défini tel quel à l'ENST
- variable PS1
Invite secondaire
- > en mode interactif
- variable PS2
Commande simple
- une commande simple est une séquence de mots séparés par un séparateur blanc et de redirections. Le premier mot désigne le nom de la commande à exécuter, les mots suivants sont passés en arguments à la commande.
- la valeur retournée d'une commande est celle de son exit.
Chemin de recherche du nom d'une commande : PATH ou path (csh)
- PATH=/usr/ucb:/bin:/usr/bin:/usr/local/bin:~/bin:.

Pipelines, Listes

Pipeline
- un pipeline est une séquence d'une ou plusieurs commandes séparées par le caractère |.
- format : [!] command1 [ | command2 ... ]
- la sortie standard de la première commande est connectée à l'entrée standard de la commande suivante, et ainsi de suite.
Liste
- une liste est une séquence d'un ou plusieurs pipelines séparés par un des opérateurs : ;, &, &&, ||.
- une liste est optionnellement terminée par un ;, &, <newline>.
- précédences des opérateurs: && > || > ; = &
- si une commande est terminée par l'opérateur &, ls shell exécute la commande un arrière plan (backgroud)dans un sous-shell.
- les commandes séparées par un ; sont exécutées séquentiellement, le shell attend la fin de chaque commande.

Enchaînement de commandes

Commande simple (en premier plan)
- $ commande [ arg ... ]
Commande simple (en arrière plan)
- $ commande [ arg ... ] &
Pipeline (tube de communication)
- $ commande1 [ arg ... ] | commande2 [ arg ...] | ...
Séquencement de commandes (en premier plan)
- $ commande1 [ arg ... ]; commande2 [ arg ... ]; commande3 ...
Exécution par un nouveau shell ()
- $ sh commande [ arg ... ]
- $ (commande [ arg ... ])
- $ (commande [ arg ... ]) &
Regroupement de commandes
- $ (com1 [ arg ... ]; com2 [ arg ... ]; com3 ...)
- $ (com1 [ arg ... ]; com2 [ arg ... ]; com3 ...)&

Les entrées-sorties

Interruptions clavier
- <^C> interruption d'un processus attaché au terminal
- <^\> arrêt d'un processus avec vidage mémoire (core)
- <^Z> suspension d'un processus en premier plan

Redirection des entrées-sorties

Fichiers standard
- entrée standard (stdin, fd=0), par défaut le clavier
- sortie standard (stdout, fd=1), par défaut l'écran
- sortie erreur standard (stderr, fd=1), par défaut l'écran
Redirection de l'entrée standard
- < fichier ou périphérique
- <<marque texte qui suit jusqu'à la marque (here documents)
Redirection de la sortie standard
- > fichier ou périphérique
- 1> fichier ou périphérique
- >> fichier ou périphérique (en ralongement)
Redirection de la sortie erreur standard
- >& &> fichier ou périphérique
- 2> fichier ou périphérique
Autres redirections
- <> fichier ou périphérique (en mise à jour)

Redirection des entrées-sorties

Exemples
- cat fichier1 >fichier2 copie
- cat fichier3 >>fichier2 ajout
- cat >fichier4 saisie de texte
- cat <fichier4 listage
- cat <fichier4 >fichier5 copie
- cat <fichier6 >>fichier5 ajout
- cat <<!EOF >fichier7 copie
  ligne1
  ligne2
  ...
  autres lignes
  !EOF
- rm *.o *% *~ core >& /dev/null nettoyage silencieux
- appli 1>/dev/null 2>&1 & silence total en background

Méta-caractères d'expansion

Expansion des noms de fichiers
- Ne pas confondre avec les caractères spéciaux des expressionsrégulières. Ne sont concernées que les chaînes de caractères des noms de fichiers.
- * remplace n'importe quelle chaîne de caractères
```
micro*
microprocesseur micro-ordinateur microcosme
? remplace n'importe quel caractère
m?cro
micro macro
```
- [...] établit une coïncidence avec l'un des caractères mis entre crochets m[ai]* mail macro micro mini
- [.-.] établit une coïncidence avec tous les caractères compris entre les 2 bornes
  ls [A-Z]*.[hc1-8] Prog.c Include.h Data.1 Text.6
- {...,...} remplace successivement les chaînes intérieures
  ls *.{C,cc}
- ~ remplace par le $HOME ou celui d'un autre login (csh, bash).
  cd ~username

Variables d'environnement prédéfinies

HOME chemin d'accès au répertoire initial de l'utilisateur
PATH suite de chemins d'accès aux répertoires des exécutables
PS1 invite principale du shell en mode interpréteur
PS2 invite secondaire du shell en mode programmation
IFS séparateurs de champ des arguments
MAIL chemin d'accès à la boîte aux lettres utilisateur
MAILCHECK intervale en sec au bout duquel le mail est contrôlé
CDPATH liste de chemins d'accès pour la commande cd
ENV nom du fichier des variables d'environnement
TERM nom du type de terminal

Variables de substitution prédéfinies

$0 nom du script (pathname)
$1, ..., $9 arguments (du 1er au 9ème)
$# nombre d'arguments
$* liste de tous les arguments
$@ liste de tous les arguments
$? code retourné par la dernière commande
$$ numéro de processus de ce shell
$! numéro du dermier processus en arrière plan
$- drapeaux fournis au shell par set

Variables utilisateur

Déclaration
- variable=valeur
Utilisation
- variable2=$variable
- variable2=${variable}
Exportation
- export variable
- variable=valeur export variable (sh)
- export variable=valeur (bash, zsh)

Exemple

EXINIT='set nu ai ic' 
export EXINIT 
EXINIT='set nu ai ic' export EXINIT

Instructions conditionnelles

Condition simple: if then ... fi
if commande ; then
liste de commandes
fi
Condition avec alternative: if then ... else ... fi
if commande ; then
liste de commandes
else
liste de commandes
fi
Condition multiple: if then ... elif then ... fi
if commande ; then
liste de commandes
elif commande ; then
liste de commandes
else
liste de commandes
fi

Instructions de boucle

Boucle for: for in do ... done
for variable [ in liste d'arguments ]
do
liste de commandes
done
Boucle while: while do ... done
while commande
do
liste de commandes
done
Boucle until: until do ... done
until commande
do
liste de commandes
done

Instructions de rupture de boucle

continuation de boucle: continue [n]
- revenir au début de la boucle for, while, until
- n = niveau de boucle à partir de la boucle la plus externe
```
for var1 in ${liste1} 
do
    for var2 in ${liste2}
    do
        if cmd2 ; then
            continue 2
        fi
    done 
done
```
Sortie de boucle : break [n]
- sortir d'une ou n boucles for, while, until
- n = niveau de boucle à partir de la boucle la plus externe
Sortie de programme: exit n
- sortir d'un script-shell avec un code de retour (n)

Instructions d'aiguillage

Aiguillage case: case in ... esac
case $variable in
motif1) liste de commandes ;;
motif2) liste de commandes ;;
*) liste de commandes ;;
esac

Exemple :

case $# in 
1)	 arg1=$1;; 
2)	 arg1=$1; arg2=$2 ;; 
0)	 echo "usage: $0 arg1 [ arg2 ]
		exit 1;; 
esac

Expansion de commande

Expansion de commande
- variable=`commande`
- variable=$(commande)

Exemple

date=`date +%d/%m/%y %H:%M` 
scriptname=$(basename $0)

Expansion de paramètre

Expansion de paramètre
- variable=${var:-val} si var est définie ou non nulle alors var sinon val
- variable=${var:=val} si var est définie ou non nulle alors var sinon affecte val
- variable=${var:?mess} si var est définie ou non nulle alors var sinon affichage du message mess
- variable=${var:+val} si var est définie ou non nulle alors val sinon rien n'est substitué
- variable=${#var} longueur en octet de la chaîne var
- variable=${var#str} supprime en début de var la plus petite chaîne parmi les 2
- variable=${var##str} supprime en début de var la plus grande chaîne parmi les 2
- variable=${var%str} supprime en fin de var la plus petite chaîne parmi les 2
- variable=${var%%str} supprime en fin de var la plus grande chaîne parmi les 2

Exemple

cd ${dir:-$HOME} 
for f in *.C		# renommage des *.C en *.cc 
do
    g=${f%.C}
    mv $f $g.cc 
done

Quotage

Rôle
- le quotage est utilisé pour supprimer les fonctionnalités de certains caractères spéciaux du shell, dont les métacaractères.
Méta-caractères
- \ $ * ` " '
Caractère d'échappement \
- le caractère \ préserve la valeur littérale du caractère qui le suit immédiatement.
Simples quotes '...'
- les caractères inclus entre 2 simples quotes ne sont pas évalués, ils conservent leur valeur littérale.
Doubles quotes "..."
- les caractères inclus entre 2 doubles quotes conservent leur valeur littérale à l'exception de $ ` et \.
Exemple

Déroutements

Séquence d'exception
- trap 'liste de commandes'liste de signaux
  Exemple :
  trap 'rm /tmp/appl.$$; exit 1' 2
Ignorance des signaux
- trap 'l' liste de signaux
  Exemple :
  trap '' 1 2 3 15
Réinitialisation
- trap liste de signaux
  Exemple :
  trap 2 3
Liste des signaux
- trap
  Exemple :
  trap

Commandes internes au Shell

:
. filename
alias [nom[=commande] ...]
bg [jobnum]
cd [dir]
echo [-ne] [arg ...]
eval [arg ...]
exec [[-] commande[arg ...]]
exit [n]
export [variable ...]
fg [jobnum]
job [jobnum]
kill [-signal] [pid|jobnum]
popd
pushd [dir]
pwd
read [variable ...]
readonly [variable ...]
return [n]
set [-aefhknotuvxldCH] [arg ...]
shift [n]
test expression
times
trap [arg] [signaux]
type [-all|-type|-path] [commande]
ulimit [-SHacdfmstpn [limite]]
umask [mode]
unalias [nom ...]
unset [variable ...]
wait [pid|jobnum]

Commandes de test

test sur les fichiers
- test -f fichier, test -d fichier, test -s fichier
- test -r fichier, test -w fichier, test -x fichier
  Exemple : if [ ! -d repert ]; then mkdir repert ; fi
Comparaisons alphanumériques
- test "$str1" = "chaine1"
- test "$str1" != "chaine1"
- test "$str1" > "chaine1"
- test "$str1" < "chaine1"
- test "$str1" >= "chaine1"
- test "$str1" <= "chaine1"
Comparaisons algébriques
- -eq -ne -gt -lt -ge -le
Comparaisons booléennes
- -z -n
Autres opérateurs
- ! -a -o

Arithmétique

Commande Unix expr
- expr val1 oper val2
- opérations : +, -, *, /, %
- utilisation : substitution de commande en sh
- peut performant : nécessite un fork()-exec()
Commande Shell (ksh, bash, zsh)
- $[expression]
- interne au shell -> performant

Exemple

#!/bin/sh 
while true; do
    compteur=`expr $compteur + 1` 
done

#!/usr/local/bin/zsh 
while true; do
    compteur=$[$compteur + 1] 
done

Fonctions

function
- syntaxe: [function] nom() {.........}
- appel de fonction: nom [arg ...]
- pas de déclaration d'arguments entre parenthèses ()
- les fonctions doivent être définies avant leur utilisation

Exemple

#!/bin/sh 
# 
# Exemple de script avec fonctions 
usage() 
{
  		echo "usage: $1 $2" 
} 
main() 
{
    if [ $# = 0 ]; then
        usage `basename $0` "fichier";
        exit 1
    fi 
} 
main $*

Fichier de commande, Script

Magic number
- première ligne : #! /bin/sh
Commentaires
- #

Exemple

#!/usr/local/bin/bash 
# 
# Essai de script 
# 
PATH=$PATH:/usr/local/bin; export PATH

usage() 
{
    echo "usage: $1 $2" 
} 
main() 
{
    if [ $# = 0 ]; then
        usage `basename $0` "fichier";
        exit 1
    fi 
} 
main $*

Fichiers d'initialisation

/etc/profile
.profile
.login
.cshrc
.logout
.bash_profile
.bashrc
.bash_alias
.inputrc
.zshrc
.tcshrc

/etc/profile (sous System V uniquement)

Initialisation commune à tous les login-shells
- point de passage obligé pour tous les login
- est remplacé à l'ENST par /usr/local/startup/profile
- variables d'environnement à très longue durée de vie
- fourni par le constructeur / adapté par l'administrateur
- non modifiable par l'utilisateur

Exemple

umask 027 
USER=`logname` 
PATH=/usr/local/bin:/usr/ucb:/bin:/usr/bin:/usr/X11/bin 
MANPATH=/usr/local/man:/usr/man:/usr/lang/man 
MAIL=/usr/spool/mail/$USER 
HOSTNAME=`uname -n` 
OS=`uname -s` 
REL=`uname -r` 
OSREL=${OS}${REL} 
export USER PATH MANPATH MAIL HOSTNAME OS REL OSREL

.profile

Initialisation propre à l'utilisateur
- situé dans le HOME de l'utilisateur : ~/.profile
- redéfinition des variables proposées par /etc/profile
- définition de nouvelles variables (var=valeur)
- détection si le shell est interactif ou non
- exécution ou non de scripts d'initialisation
- configuration des paramètres du terminal (stty)
- peut-être "ressourcé" (. ou source) . profile (sh, ksh, bash, zsh)
  source .profile (bash)

Exemple

EDITOR=emacs 
VISUAL=emacs 
SUNADAHOME=/inf/lang/ada 
LC_CTYPE=iso_8859_1 
EXPORT EDITOR VISUAL SUNADAHOME LC_CTYPE

.zshrc, .bashrc (en zsh ou bash)

Spécificité des shells zsh et bash
Initialisation propre à l'utilisateur
- situé dans le HOME de l'utilisateur : ~/.zshrc ~/.bashrc
- redéfinition du prompt PS1
- définition des aliases
- définition de fonctions
- peut-être "ressourcé" . ~/.bashrc ou source ~/.bashrc . ~/.zshrc ou source ~/.zshrc

Exemple

alias ls='ls -F' 
alias ll='ls -laF' 
alias a='alias' 
alias h='history' 
alias j='jobs -l' 
unalias=rm

.login, .cshrc, .tcshrc, .logout (en csh ou tcsh)

.login : Fichier d'initialisation d'un login C-shell
- interprété à chaque login
- définition de nouvelles variables
- peut-être "ressourcé" par source .login
.cshrc/.tcshrc : Fichier d'initialisation d'un Csh
- réinterprété à chaque invocation du csh/tcsh
- définition des aliases (shells interactifs)
- peut-être "ressourcé" par source .cshrc/.tcshrc
.logout : Fichier de clôture d'une session C-shell
- effacement des fichiers temporaires, clear écran

Exemple

setenv	EDITOR	emacs 
setenv	VISUAL	emacs 
setenv	SUNADAHOME	/inf/lang/ada 
setenv	LC_CTYPE=iso_8859_1

Fonctionnalités spécifiques ENST

Shell initial par défaut : /bin/sh
- interprète~/.profile chez l'utilisateur
- ~/.profile ressource /usr/local/startup/profile
- .profile déroule /usr/local/startup/shenv qui initialise les variables d'environnement par défaut
- .profile déroule ~./.shenv qui initialise les variables d'environnement privées de l'utilisateur
Shell de travail choisi (défaut ou préférence)
.profile détermine un shell de travail (par défaut: zsh), sinon prend le 1er de la variable SHELLPREF dans le fichier ~/.shenv.preload
Détermination du système de multifenêtrage
- .profile lance automatiquement(ou non) le système de multifenêtrage par défaut ou choisi avec les variables WINDOWSYSTEM et WINDOWMANAGER de ~/.shenv.preload

Schéma de fonctionnement

Personalisation de l'environnement

Procédure d'installation : install-startup
- menus proposés
- lire la FAQ (Frequently Asked Questions)
- choisir l'installation par défaut
- vérifier le contenu du fichier ~/.shenv.preload
Fichiers modèles
- .profile:/usr/local/startup/profile
- .shenv: /usr/local/startup/shenv
- .zshrc: /usr/local/startup/zshrc
- .bashrc: /usr/local/startup/bashrc
Modification des fichiers d'environnement
- éditer et compléter le fichier ~/.shenv
- selon le shell choisi, supprimer ~/.zshrc ou ~/.bashrc, recopier leur modèle /usr/local/startup/{zshrc,bashrc} dans ~/.{zshrc,bashrc} dans le but de les modifier

visitors since Dec 1995.