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=`commandè
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

echo "usage: `basename $0` '$DISPLAY'"

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=`lognamè 
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/{zshrçashrc} dans ~/.{zshrçashrc} dans le but de les modifier .