UNIX et SHELL

Support de cours
UNIX et SHELL
Spécialité Electronique
Première année
Extrait du support de cours par Régis CLOUARD
Table des matières
I. Le langage shell..............................................................................................................................3
1. L'interpréteur de commandes.....................................................................................................3
2. Les fichiers de configuration..................................................................................................... 3
3. Éditeur de commandes...............................................................................................................4
4. Exécution des commandes.........................................................................................................4
5. Les entrées-sorties......................................................................................................................5
6. Les variables du shell.................................................................................................................6
7. Les fichiers scripts shell.............................................................................................................7
8. La commande test...................................................................................................................... 7
9. Les structures de contrôle.......................................................................................................... 8
10. Les fonctions............................................................................................................................9
11. Les méta-caractères shell......................................................................................................... 9
12. Les commandes spécifiques du shell..................................................................................... 10
13. Gestion des processus............................................................................................................ 10
II. Les commandes Unix..................................................................................................................12
1. Les dossiers de base................................................................................................................. 12
2. La documentation.................................................................................................................... 12
3. La gestion des dossiers et des fichiers..................................................................................... 12
4. La gestion des commandes...................................................................................................... 13
5. Gestion des disques..................................................................................................................14
6. La commande grep...................................................................................................................14
7. La commande find................................................................................................................... 14
8. Réseau...................................................................................................................................... 14
9. Les calculs en bash.................................................................................................................. 15
10. La commande expr.................................................................................................................15
III. Exemple 1 de script « shell ».....................................................................................................16
IV. Exemple 2 de script « shell »..................................................................................................... 17
2
I. Le langage shell
1. L'interpréteur de commandes
shell est un interpréteur de commandes pour le système d'exploitation. Il permet d'écrire des
programmes utilisant le système d'exploitation. Il repose un langage interprété et évolué : il possède
des variables, des commandes internes et des structures de contrôle.
Différentes familles (dialectes)
– Famille Bourne : sh, ksh, bash, zsh (famille utilisée ici)
– Famille csh (syntaxe du C) : csh, tcsh
Variable d'environnement associée SHELL : exemple echo $SHELL
– Lancement : $ sh ou bash
– Arrêt : $ exit (ou C-d)
2. Les fichiers de configuration
2.1 Les fichiers de connexion
Lus une fois à la connexion.
1.
2.
3.
4.
5.
Séquence de lecture
/etc/profile : commun à tous.
$HOME/.bash_profile : personnel
$HOME/.profile : personnel (si pas de bash-profile)
$HOME/.bash_login : personnel à chaque connexion (si pas de bash_profile)
$HOME/.bash_logout : personnel, à chaque déconnexion.
Conséquence : la redéfinition des variables.
2.2 Contenu du fichier .profile (ou bash_profile)
Les fichiers profile contiennent les configurations pour la session entière :
– PATH : dossiers où trouver les exécutables.
Montrer l'effet de PATH=$PATH:.
– LD_LIBRARY_PATH : dossiers où trouver les bibliothèques dynamiques.
– MANPATH : dossier où trouver les fichiers manuels.
– PS1 et PS2 : les prompts primaire et secondaire.
PS1="$ " ou PS1=`date` ou PS1="\w" chemin complet du dossier courant ou
PS1="\W" unique le nom du dossier courant.
– Ne pas oublier : export PATH LD_LIBRARY_PATH MANPATH PS1 PS2
– Gestion de la taille des core : ulimit -c unlimited
– xset -b (suprimer le son cloche).
3
2.3 Le fichier .bashrc (bash)
Exécuté à chaque invocation d'un shell.
Attention: surchage de qui a été défini dans les .profile.
Utilisé pour configurer le shell : les variables dépendantes du shell utilisé.
Exemples :
– aliases : alias ll='ls –la', alias rm 'rm –i', dir='ls -la" supprimer un alias (unalias)
– set ignoreof : supprime l'effet du C-D pour sortir.
– set noclobber : évite l'écrasement par redirection (cas ls > toto.txt)
Exécution de bash sans le fichier de ressource .bashrc : $ bash -norc
Remarque: chaque exécution de commande se fait dans un bash -norc.
3. Éditeur de commandes
Nom : readline
L'éditeur de commande conserve les commandes tapées dans un fichier historique. Commun à la
plupart des interpréteurs de commandes … et à emacs. Ce fichier peut être réutilisé par les
commandes : C-a, C-p, C-e, C-n, C-k, C-y, C-r…
Taille de l'historique : variable HISTSIZE. Par exemple HISTSIZE=100
– C-c : annule la commande en cours
– TAB sous bash : complétion des noms de fichiers (des commandes)
– C-s / C-q : xon / xoff
4. Exécution des commandes
Structure générale d’une commande :
commande [-options] [arguments] [< inputfile] [>outputfile] [&]
4.1 Exécution séquentielle
$ commande1
$ commande2
$ commande1 ; commande1
La commande1 doit être terminée avant d'exécuter commande2
4.2 Exécution parallèle
$ commande1 & commande2
La commande1 et la commande2 sont exécutées en parallèle
$ commande1 &
$ commande2
La commande1 est exécutée en parallèle avec le bash : le prompt revient immédiatement et l'on peut
taper des commandes, puis la commande2 est exécutée en même temps que commande1.
4.3 Exécution conditionnelle
$ commande1 && commande2
conjonction : ET est exécuté si commande1 retourne 0.
4
$ commande1 || commande2
disjonction : OU est exécuté si commande1 retourne une valeur !=0.
Exemple : (Rappel: La valeur de retour est la valeur retournée par le main()).
$ gcc io.c; ./a.out
$ gcc io.c && ./a.out
$ gcc io.c || echo "erreur"
$ nedit io.c &
5. Les entrées-sorties
Toute entrée ou sortie est un fichier (une caméra, un robot) en lecture ou en écriture.
Il y a 3 fichiers ouverts par défaut :
– clavier (en entrée nommé 0 en shell; nommée stdin en C;
– écran (en sortie nommé 1 en shell; nommée stdout en C.
– erreur (en sortie nommé 2 en shell; nommée stderr en C.
5.1 Les redirections
Exemple d'un fichier C compilé en programme a.out :
int main(int argc, char *argv[]) {
float f;
scanf("%f", &x);
printf("= %f\n",2.0f*x);
return 0;
}
Redirection des entrées-sorties de l'exécution d'un programme :
commandes > fichier # tout ce qui était affiché sur l'écran dans fichier.
commande < fichier
# tout ce qui était lu au clavier à partir de fichier.
commande >> fichier # tout ce qui était affiché sur l'écran est ajouté au fichier
En utilisant les numéros des sorties :
commande 1> fichier ⇔ commande > fichier
commande 0< fichier ⇔ commande < fichier
commande 2> fichier : rediriger la sortie erreur (make 2>erreur.txt)
Rappel d'un numéro de sortie : &x
$ commande fichier 1> toto.txt
$ commande 2>&1
Cas particuliers :
$ commande <<
substitution temporaire de l'entrée standard.
Affectation constante d'une entrée ou d'une sortie à un numéro :
$ exec n<fichier
$ exec n>fichier
$ exec > &n
$ exec 5<&o (lie 5 avec l'entrée standard)
$ exec 6>toto.txt (lie 6 avec le fichier toto.txt)
$ exec >toto.txt (lie la sortie standard avec toto.txt)
en général, on utilise des numéros >=3.
5.2 Les pipelines
Utiliser la sortie de l'un comme entrée de l'autre sans passer par un fichier :
commande1 | commande2
5
commande1 | tee fichier | commande2 (sauvegarde intermédiaire)
Exemples :
$
gcc io.c && ./a.out
$
$
$
make 2> error.log (récupérer les erreurs dans error.log)
echo "coucou"> toto.txt (met coucou dans toto.txt)
echo "ciao" >> toto.txt (ajoute ciao dans toto.txt)
$
$
$
$
cat > fichier_texte << EOF
<texte>
EOF
C-d
$
$ gcc 2>&1 | more (pour récupérer les erreurs dans un more)
6. Les variables du shell
6.1 Affectation
variable=valeur
Exemple : variable=12
En shell il n'y a que des valeurs de type chaîne de caractères.
Exemples:
$
$
variable=12+3 -> 12+3 (et non 15)
variable=`pwd` (voir eval)
6.2 Désaffectation
unset variable
6.3 Séparateur de nom
– $variable, ${variable}, mais pas $(variable), $variable, ${variable}xxx
! Ne pas confondre avec {commande}
6.4 Les variables système
– $? : le code retour de la commande exécutée
– $$ : le numéro du processus de la dernière commande exécutée.
Remarque: $$ souvent utilisé pour les fichiers temporaires - éviter les conflits
de nom.
6.5 Portée des variables :
Les variables d'environnement
Visibilité des variables : Les variables sont locales au shell sauf si elles sont explicitement
exportées. (Par convention, mises en majuscule)
export var (remarque on exporte var et $var qui est son contenu)
Variable d'environnement= variable exportée d'un shell à l'autre.
Variable d'environnement de base : PATH, LD_LIBRARY_PATH, MANPATH
6
6.6 Les substitutions
– ${var} identique à $var (sert à la concaténation)
– ${var-valeur} si var est définie rend var sinon rend valeur.
– ${var=valeur} : si var n'est pas définie affecte var à valeur. Dans tous les cas rend var.
– ${var?message} : si var est définie rend var sinon affiche le message.
– `commande` : exécution de la commande
Cas particulier de bash : $((1+2)) -> 3 uniquement des entiers.
7. Les fichiers scripts shell
Script shell est un fichier texte avec les droits d'exécution.
7.1 L'entête
Les commentaires en shell : #
Obligatoire : sur la 1er ligne doit être indiqué le choix de l'interpréteur :
#!/bin/sh, #!/bin/bash, #!/usr/bin/perl
Préférer sh pour la probabilité.
Ajouter –x pour lister les commandes au fur et la mesure de leur exécution..
7.2 Arguments (de script ou de fonction)
Les paramètres de position spécifiques au script shell
$# : le nombre d'arguments.
$* : la liste des toutes les valeurs de paramètre dans une seule chaîne.
$@ : la liste de toutes les valeurs de paramètres dans une seule chaîne. Différent de $* si on
utilise "$@" -> "$1", "$2" .. alors que "$*" -> "$1 $2 ..."
$0 :le nom du programme ou de la fonction.
$1,$2, $9 : la valeur de l'argument i.
La commande 'shift' décale la numérotation $2 devient $1,…
8. La commande test
C'est une commande shell nommée "test" ou par les méta-caractères [ ] : attention espace après
[ et avant ].
Elle retourne 0 (succès) ou >0 pour un erreur.
8.1 Tests numériques
Syntaxe : test valeur option valeur
option : -eq , -ne, –gt, -ge, -lt, -le
Exemple :
test 5 –lt 6
retourne 0
7
8.2 Tests sur les fichiers
Syntaxe : test option fichier
options :
– -s : le fichier n'est pas vide
– -d : le fichier est un dossier (différent de fichier)
– -f : le fichier est un fichier (différent de dossier)
– -w : le fichier a les droits d'écriture
– -r le fichier a les droits de lecture
– -x : le fichier a les droits d'exécution
8.3 Tests sur les chaînes de caractères
Syntaxe : test chaine option chaine*
option =, !=
Syntaxe : test option chaîne
option : -z longueur 0, -n longueur non nulle.
8.4 Les opérateurs logiques
– ! test : vrai si le test est faux.
– test -a test : et logique entre test
– test -o test : ou logique entre test
9. Les structures de contrôle
9.1 La structure if
if commande
then commande
else commande
fi
Attention : chaque partie de la structure est séparée par fin de ligne ou par un ';'.
if commande; then commande; else commande; fi
Le test du if porte sur le code de retour de la commande ($?).
Variante :
$
if then elif then fi
a=1; if [ $a -eq 1 ], then echo "a vaut 1"; else echo "a ne vaut pas 1"
9.2 La boucle while
while commande; do commande*; done
Exécuté tant que le code de retour de la dernière commande est 0.
Possibilité d'utiliser break et continue;
$
a=0; while [ $a -lt 10 ]; do echo $a; a=$(($a+1)); done
Remarque: boucle infinie : while : ; do … done
8
9.3 La structure case
case $variable in
cas1) commande* ;;
casn) commande* ;;
esac
casi : un motif correspond à une valeur pour l'entrée : une constante ou une expression construite
avec les méta-caractères, par exemple : [co]* : commence par c ou o puis n'importe quoi après.
9.4 La boucle for
for <var> in <liste>
do
<commandes>
done
liste est une liste de valeur que doit prendre la variable var.
$
for f in `ls`; do; echo $f; done
$
for i in 1 2 3 4 5; do; echo $i; done
ou
Possibilité d'utiliser break et continue;
Remarque: Uniquement en bash:
$
for ((i=0;i<5;i++)); do; f($i); done
10. Les fonctions
Rassembler une série de commandes dans le shell courant par un même nom.
Syntaxe de la déclaration
[function] nom_fonction(){
}
10.1 Les arguments
La récupération des arguments se fait par $*, $*1, $2, $#
Les variables ne sont que globales et leur portée limitée au shell qui exécute le script.
Exemples :
test1(){
echo "Nombre d'arguments $#"
echo "Les arguments sont $*"
}
test1 a1 a2 a3
if [ -f $x ]
then echo "Fichier"
else echo "Pas de fichier"
fi
return n -> permet à une fonction de retourner un résultat numérique donné, sinon c'est le résultat de
la dernier commande qui est retourné
Le résultat est accessible par la macro $? (echo $?).
11. Les méta-caractères shell
11.1 Spécifier des ensembles de fichiers
* : n'importe quelle suite de caractères même vide.
9
? : un caractère exactement
[abcde] : n'importe quel caractère à l'intérieur de l'ensemble.
Attention le méta-caractère est interprété avant l'appel de la commande.
ex : ls po*.c : tous les fichiers du dossier courant commençant par po et finissant par .c.
"xxx" : la chaîne de caractères avec évaluation de son contenu (les variables sont remplacées et les
* aussi).
'xxxx' : la chaîne de caractère sans évaluation du contenu :
Exemple : echo "$HOME" -> /users/eleves/promo08/toto; echo "$HOME' -> $HOME
\ empêche l'interprétation particulières du caractères qui suit \.
echo "\$HOME" -> $HOME echo "\"un guillemet\""
-> "guillemet"
11.2 Exécution de commandes
` ` : le résultat de l'exécution de la commande à l'intérieur. ex : PS1=`date $`
() : exécution des commandes dans un sur-shell.
{ } : exécution des commandes dans le même shell. Attention, ne pas confondre avec ${xx}
12. Les commandes spécifiques du shell
–
–
–
–
–
–
–
–
–
cd, pwd, echo, read, export, exit, ulimit, umask, set, unset.
type <commande> (ou which < commande>)
read <variable>
echo $<variable>
sleep [durée]
exec <commande> : exécution du commande à la place du shell
eval <commande> : évaluation de la commande (voir différence avec ``)
trap
(cat > toto.txt << EOF -> ^D.
13. Gestion des processus
Unix est un système multi-tâche multi-utilisateur, où une tâche est en fait un processus. Un
processus encapsule une commande en cours d'exécution. Plusieurs tâches (processus) peuvent être
lancées en même temps :
– Dans des fenêtres différentes
– Dans un même fenêtre avec l'opérateur &
Un processus peut être lancé :
– au premier plan (1 seul à la fois par fenêtre). Il dispose du clavier et de l'écran.
– en arrière plan (plusieurs à la fois) : il ne dispose ni du clavier ni de l'écran (tous les
affichages sont perdus).
Un processus peut être
– actif : en cours d'exécution.
10
– stoppé : momentanément stoppé.
– arrêté : définitivement arrêté.
13.1 Opérations de gestion des processus
C-c : arrête le processus au premier plan.
C-z : stoppe momentanément le processus au premier plan.
jobs : liste des programmes qui tournent dans un même shell avec leur numéro
bg %x : mettre en arrière plan un programme stoppé et reprendre l'exécution. (% indique le numéro
du processus. Si % est absent, considère le premier processus)
fg %x : mettre au premier plan un programme en arrière plan.
stop %x : stopper un processus en arrière plan
Remarque : la séquence <commande>, C-z, bg : correspond à <commande>&.
11
II. Les commandes Unix
1. Les dossiers de base
/bin : les utilitaires Unix de base
/lib : les bibliothèques des programmes dans /bin.
/etc : programme d'administration du système et tables.
/tmp : fichiers temporaires
/usr : les programmes utilisateurs en général.
/usr/local : les programmes rapatries par l'utilisateur
/usr/bin : autres utilitaires plutôt dédié utilisateurs.
/usr/lib : autres librairies plutôt dédié utilisateurs.
/dev : les périphériques (dev/lp, /dev/null , /dev/dsk/r0s0t0d0disque).
/dev/null : make 2> /dev/null
/media/nom : clé USB.
2. La documentation
Toute la documentation UNIX est généralement accessible en ligne :
$
$
$
$
$
man
man
man
man
man
commande
–Mdir commande
$ man -M/usr/local/bin gimp
–ssection commande $ man -s1 read
–k mot-clé = apropos mot-clé
-a printf
Toutes les pages printf.x s'il y en a plusieurs
La variable d’environnement MANPATH
$
$
apropos word : cherche toutes les commandes référant ce mot
info commande : gnu
3. La gestion des dossiers et des fichiers
3.1 La gestion des dossiers
mkdir, rmdir, cd, ls, chmod, pwd
3.2 La gestion des fichiers
file fichier : Permet de connaître le type d'un fichier
cat fichier : Affiche le contenu du fichier.
$
cat > fichier  C-d
Dans un script :
$
$
cat > toto.txt << EOF
EOF
more fichier : (less) Affiche le contenu du fichier page par page.
12
Options : h, b, !, q, n
tail [–x] fichier : affiche les x dernières lignes (défaut 10)
head [–x] fichier : affiche les x premières lignes (défaut 10)
touch [date] fichier : actualiser la date du fichier.
Manipulation du nom d’un fichier ou d’un dossier :
chmod droit fichiers
cp
$ cp f1 f2
$ cp f1 … fn d1
$ cp –R d1 .. dn-1 dn
mv
$ mv f1 f2
$ mv f1 … fn dir
$ mv dir1 dir2
mv files directory ; mv oldfile newfile
rm –i –f –R source
ln –s source destination
basename fichier [suffix] : Récupère le nom d'un fichier sans le dossier [et sans le suffixe]
$
basename /usr/tmp/exo.c .c
exo
dirname fichier : Récupère le nom du dossier d'un nom de fichier : dirname
dirname /usr/tmp/exo.c->/usr/tmp
Changer l’extension gif en jpg : for i in *; do; mv $i `basename $i .gif`.jpg; done
diff fichier1 fichier2 : uniquement sur les fichiers textes.
wc : compte le nombre de mots.
sort
3.3 Conversion de format
unix2dos ou $ dos2unix : conversion d'un fichier dos vers unix (vice et versa).
$
unix2dos -ascii ../NEWS.txt $DOSDIR/NEWS.txt
iconv : Convertir l'encodage de fichiers donnés à partir d'un encodage vers un autre
$
$
iconv –f ISO-8859-1 –t UTF-8 Ingles-2006.txt –o Ingles-2006.txt.utf
iconv -f ISO-8859-1 -t UTF-8 $fichier > $fichier.utf
4. La gestion des commandes
time <commande> : donne la durée de l’exécution d’une commande.
date : donne la date courante
ps -edf (ou -aux sur certains systèmes) : Visualise tous les numéros des processus en cours
d'exécution.
top : uniquement les 10 processus qui prennent le plus de temps CPU.
kill -9 noproc : Arrête un processus en cours. (il faut en être propriétaire)
13
$
$
kill -9 -1
kill -1 noproc {recharge le fichier init}
xkill puis pointage sur une fenêtre (ne fonctionne qu'en version graphique).
type commande ou which commande : afficher le nom (avec chemin) complet de la commande.
whereis commande: affiche le chemin des commandes dans les répertoires binaires standards.
5. Gestion des disques
df : disk space free
quota -v : disk quota.
du [–hs] directory : Disk Usage of directory
6. La commande grep
grep pattern fichiers
Recherche si la chaîne est présente dans le fichier.
$
$
grep "matrice.h" *.c
ps –edf | grep user
egrep expression_régulière fichiers
7. La commande find
find path expression : Recherche le fichier <fic> dans le dossier <path> et ses sous-dossiers et
application de l'expression donnée.
Exemples d'utilisation classiques
$
$
$
$
find
find
find
find
.
.
.
.
-name
-exec
-name
-name
"*toto*" -print
grep "chaine" {} \; -print
"toto*"-exec grep "chaine" {} \; -print
"*.o" -exec rm {} \; -print
8. Réseau
8.1 Connexion
– slogin, ssh -X, sftp
– ssh -X si les environnements graphiques sont compatibles.
– scp fichier host : copie le fichier fichier sur la machine host. (scp utilise ssh).
Pour copier ces fichiers localement dans un dossier on va utiliser :
$
scp [email protected]:* ~/.
Ou pour envoyer les fichiers du dossier local, vers le dossier tmp de la machine itane :
$
scp ~/* [email protected]:/tmp
– wget www.ecole.ensicaen.fr/~toto/adresse html: téléchargement non-interactif de fichiers sur le
web (supporte les protocoles http et ftp).
8.2 Communication
– finger user : donne les caractéristiques de l’utilisateur.
14
–
–
–
–
groups [user] : donne la liste des groupes auquel appartient l’utilisateur.
users liste des utilisateurs connectés.
who, rwho : sur toutes les machines du domaine.
whoami : qui suis-je.
9. Les calculs en bash
Bash ne connait que les chaînes de caractères.
Mais, bash propose aussi des extensions pour effectuer des calculs
9.1 Opérations sur des entiers
$
$
((1+2))
a=`expr $a + 1`
9.2 Opérations sur des entiers
Calculatrice en ligne (bc : basic calculator)
$
a=$(echo "1.0+2.0"|bc -l);
10. La commande expr
expr argument : appliquer une opération complexe.
Remarque : Toutes les variables Unix sont des chaînes de caractères.
Valeur de retour
0
1
2
>2
If the expression is neither NULL nor 0.
If the expression is either NULL or 0.
For invalid expressions.
An error occurred.
Exemple simple: ajoute 1 à la variable shell a:
$
a=`expr $a + 1`
15
III. Exemple 1 de script « shell »
#!/bin/sh -x
#
# examen.sh
#
# @author
Régis Clouard <[email protected]>
#
# ENSICAEN
# 6, boulevard Maréchal Juin
# F-14050 Caen cedex
#
# Script shell permettant de compiler un fichier C et tant qu'il y a
# des erreurs édite le fichier C pour le correction et relance la
compilation.
# Une fois le programme compilé exécute le fichier
# et retourne son code d'erreur.
if [ $# -ne 2]
then
echo "USAGE: $0 <fichier.c>"
exit 1
fi
# Construit le nom de l'exécutable à partir du nom
# du fichier auquel on retire le suffixe .c
nomexec=`basename $i .c`
# Boucle infinie (sortie par break)
while :
do
gcc -Wall -03 -pedantic $1 -o $nombase 2>error.log
if [ $? -ne 0 ]
then
more error.log
emacs $1
else
break;
fi
done
nomexec
# Retourne le code d'erreur de l'exécution du programme.
exit $?
16
IV. Exemple 2 de script « shell »
#!/bin/bash
#
# Exemple de l'utilisation de la commande "read"
# et de la structure de controle "case"
#
# Dossier courant
PWD=`pwd`
clear
# Recuperer la reponse de l'utilisateur
read -n 1 -p "Would you like a long list of $PWD? (Y/N/Q) " YesNo
clear
# Teste la valeur de la variable YesNo variable.
# Si la valeur est differente de Y, N ou Q alors affiche un message d'erreur.
case $YesNo in
y|Y)
ls -lhA --color
;;
n|N)
ls -A --color
;;
q|Q)
exit 0
;;
*)
echo -e "Please enter Y, N, or Q"
;;
esac
# Sortie avec le code d'erreur 0 (sans erreur)
exit 0
17