Page 1 sur 63

UNIX / LINUX

Page 2 sur 63

Table des matières

LE BOURNE SHELL - Cours/TP N°l 5

1.1. PRESENTATION 5

1.1.1 Que fait le shell ? 5

1.1.2 Les scripts 6

1.1.3 Un premier script 6

1.2 CREER ET UTILISER DES VARIABLES 7

1.2. 1 Création d’une variable utilisateur 7

1.2.2 Affichage d'une variable avec la commande echo 8

1.2.3 Saisie au clavier avec la commande read 9

1.2.4 Affectation du résultat d'une commande à une variable 10

lère

possibilité 10

2ème

possibilité (Bash et K-Shell) 11

1.2.5 Autres commandes 11

La commande unset 11

La commande readonly 11

Création d'un tableau avec la commande set (seulement le K-Shell !! ) 12

1.3. LES VARIABLES PREDEFINIES (ÉCRIRE EN MAJUSCULE) 12

1.3.1 Quelques variables système 13

1.3.2 Comment modifier la variable PATH 14

1.3.3 La commande env 14

1.3.4 La commande set 14

1.4 LES VARIABLES INTERNES AU SHELL 15

1.4.1 La variable ? 15

1.4.2 Les paramètres de position ou arguments d'un script 15

4.3 La commande shift 16

Page 3 sur 63

1.4.4 Initialisation des arguments à l’intérieur d’un script 17

1.4.5. Les variables $, ! et - 17

1.5.EXERCICES 17

LE BOURNE SHELL - Cours/TP N°2 20

2.1. LA COMMANDE TEST 20

2.1.1 Test sur les chaînes de caractères 20

2.1.2 Comparaison arithmétique (sur les entiers) 21

2.1.3 Tests sur les fichiers 22

2.1.4 Autre écriture de la commande test 23

2.1.5 Association de test 24

2.2. LES COMMANDES EXECUTION CONDITIONNELLE 24

2.2.1 La commande && 24

2.2.2 La commande || 25

2.2.3 La commande if 25

2.2.4 la commande exit [n] 27

LE BOURNE SHELL – Cours TP N°3 30

3.1COMPLEMENTS SUR L’OPERATEUR $ 30

Extraction d’une sous chaîne. 30

3.2. LA COMMANDE case 31

3.2.1 Syntaxe 31

3.2.2 Exemples 33

3.2.3 Exercices 34

3.3 LA BOUCLE for 35

3.3.1 Syntaxe 35

3.3.2 Examples 36

3.3 Exercices 36

3.4 LA BOUCLE while 37

Page 4 sur 63

3.4.1 Syntaxe 37

3.4.2 Exemple 37

3.5. LA BOUCLE until 37

3.5.1 Syntaxe 37

3.5.2 Exemple 38

3.6 CREATION DE MENUS (K-Shell et bash) 38

3.6.1 Syntaxe 38

3.6.2 Exemple 39

3.7. INTERRUPTION DES BOUCLES 40

3.8 LA COMMANDE expr 41

3.9. LA COMMANDE let (bash et K-shell) 43

3.10. AUTRE POSSIBILITE POUR LES CALCULS ARITHMETIQUE (K-Shell et bash2) 43

3.11 LES FONCTIONS 45

3.12 EXERCICES 47

TP Gestion des processus 49

TP Gestion des utilisateurs 51

TP initiation au shell 53

Commandes Linux Aide Mémoire 57

Page 5 sur 63

LE BOURNE SHELL - Cours/TP N°l

1.1. PRESENTATION

Le terme de shell désigne l’interpréteur de commandes d'Unix. Le shell est un programme

automatiquement lancé par le système à la connexion (login) de chaque utilisateur. Chaque personne

connectée dispose de son propre shell. On rappelle que le système Unix est multitâches et multi

utilisateurs ; chaque shell représente un processus et il y a au minimum autant de processus shell qui

s'exécutent que d'utilisateurs connectés.

Le processus shell d'un utilisateur se termine normalement lorsqu'il se déconnecte.

1.1.1 Que fait le shell ?

- Le shell affiche le prompt indiquant à l'utilisateur que le système est prêt.

- L'utilisateur tape des caractères sur le clavier puis les valide par un appui sur la touche Entrée ◄┘, ce

qui correspond à une ligne de commande. Le shell analyse alors la syntaxe de la ligne tapée, vérifie

sa validité puis lance l'exécution de la commande demandée.

- Si la ligne semble correcte mais incomplète, il affiche le prompt secondaire qui est le signe supérieur >

indiquant ainsi qu'il attend la suite.

- Il affiche un message d'erreur s'il détecte une erreur de syntaxe.

De plus, le shell offre toutes les possibilités d'un langage de programmation. Le shell permet de définir

des variables, il dispose des instructions nécessaires pour effectuer des saisis, des tests ; des boucles ...

Il existe plusieurs shells. Le Bourne Shell qui fait l'objet de ce cours est le plus répandu et le plus ancien.

Les autres shells sont le C-Shell, le Korn Shell, et le Bash (Bourne Another shell) lequel englobe le

Bourne Shell et une partie des fonctionnalités du K-Shell.

Ecrire un programme en shell peut s'effectuer de 2 manières : on tape les instructions en ligne de

commande ou on les place dans un fichier texte dont on lancera par la suite l'exécution.

Page 6 sur 63

1.1.2 Les scripts

Un script est un fichier texte contenant un programme constitué de commandes Unix et

d'instructions qui respectent la syntaxe du langage shell.

Un script est créé avec un éditeur de texte. Ce script doit alors être rendu exécutable (droit x)

si ce droit ne lui a pas été donné lors de sa création.

Un script est rendu exécutable grâce à la commande : chmod +x NomFichierScript.

On l'exécute alors comme une commande Unix en tapant NomFichierScript ou en tapant./

NomFichierScript si le chemin de recherche ne contient pas le répertoire courant.

Un script peut être aussi exécuté avec la commande sh NomFichierScript.

Un script peut contenir des commentaires, une ligne commentaire doit toujours débuter avec

le signe dièse #.

Remarque : il existe 2 types de commande sur un système Unix :

• Les commandes qui sont des fichiers exécutables (fichiers binaires) créés par exemple

après une compilation.

• Les commandes qui sont des scripts, c.a.d. des fichiers textes écrits en langage shell.

1.1.3 Un premier script

Utiliser un éditeur de texte, créer un fichier s1 contenant les lignes suivantes :

Rendre s1 exécutable par

chmod +x sl

Lancer son exécution par

./s1

echo Test 1er script

echo Contenu du répertoire courant :

ls -l

echo Fin du script

Ce script très simple se limite à contenir quelques instructions d'Unix.

Page 7 sur 63

1.2 CREER ET UTILISER DES VARIABLES

L'utilisateur peut créer des variables. Ces variables sont non typées et il est inutile de les

déclarer avant de les utiliser.

Une variable utilisateur créée pendant une session est détruite lorsque l'utilisateur se

déconnecte.

1.2. 1 Création d‟une variable utilisateur

La variable var contient le texte Bonjour

var= Bonjour

Il ne faut pas d'espace de part et d'autre du signe = .

num=42

La variables num contient le caractère 2 (et non la valeur numérique 2 !).

Si le texte contient plusieurs mots séparés par des espaces, il faut mettre le texte entre guillemets ou

entre apostrophes.

nom="Jean Aimar"

La variable ch contient la chaîne de caractères Jean Aimar.

La commande ch=" Jean Aimar " est équivalente à ch=' Jean Aimar'.

Page 8 sur 63

1.2.2 Affichage d'une variable avec la commande echo

On récupère le contenu d'une variable en faisant précéder son nom du signe $.

var=Bonjour

echo Svar

Bonjour

num=42

echo $num

42

ch="Attention espace"

echo $ch

Attention espace

L'affichage de plusieurs variables est possible.

a=Monsieur

echo Bonjour $a

Bonjour Monsieur

echo "Bonjour $a"

Bonjour Monsieur

b= bonjour écho

$b $a

bonjour Monsieur

echo '$a $b' $a$b

Comme le montre le dernier exemple, il faut mettre la chaîne entre apostrophes pour éviter

l'interprétation des caractères spéciaux du shell, ici le caractère $.

Les caractères spéciaux $, \, ‘ et " conservent leur signification quand la chaîne est placée

entre guillemets. On peut afficher des guillemets si on les place entre apostrophes.

On peut, dans une chaine placée entre guillemets, afficher un caractère spécial du shell en le

faisant précéder d'un antislash.

Page 9 sur 63

echo „ ”‟

”

echo "\""

”

a=Monsieur

echo 'Bonjour $a'

Bonjour $a

a=l

b=2

c=$a+$b

echo $c

1+2

On constate que l'addition n'a pas été effectuée, c'est normal car a et b contiennent les

caractères 1 et 2 et non pas les chiffres 1 et 2, il y ici « concaténation » des chaînes à

l'affichage.

La commande echo -n arg affiche son argument sans retour au début de la ligne suivante.

La commande echo -e toto \\t titi affiche toto titi séparés par une tabulation horizontale.

Faire man echo pour connaître les possibilités de la commande echo.

1.2.3 Saisie au clavier avec la commande read

La commande read permet à l'utilisateur d'effectuer des saisies (au clavier) et de les affecter

à des variables.

Soit un script saisiel : echo Taper quelque chose:

read val

echo $val

chmod +x saisie1

./saisie1

Taper quelque chose :

Page 10 sur 63

bonjour

bonjour

On peut ainsi initialiser plusieurs variables

Soit un script saisie2 :

chmod +x saisie 2

./saisie2

Taper trois mots

bonjour les blaireaux

Tapé : bonjour les blaireaux

1.2.4 Affectation du résultat d'une commande à une variable

On appelle aussi cela substitution de commande.

lère

possibilité

Le résultat de la commande date est affecté à une variable today.

today= `date` (accent grave !)

echo $today

Tue Nov 26 16:01:09 EST 1992

La variable today contient le résultat de la commande date au moment où today est créée.

La commande doit être placée entre 2 apostrophes inversées ( ‟ ) obtenu habituellement

au clavier par AltGr 7 .

echo Taper trois mots

read vall val2 val3

echo Tapé : $val1 $vaI2 $val3

Page 11 sur 63

users= `who | wc -1`

echo $users

3

La variable users contient le nombre d'utilisateurs connectés à l'instant où cette variable

users est créée.

La commande suivante est aussi valable :

echo `who | wc -l`

Cette commande affiche le nombre d'utilisateurs connectés au moment où elle est exécutée.

2ème

possibilité (Bash et K-Shell)

La commande est placée entre parenthèses et précédée du signe $

var=$(pwd)

echo $var

/home/jean/essai

1.2.5 Autres commandes

La commande unset

La commande unset nom_variable permet de supprimer la variable dont le nom est

donné en argument.

La commande readonly

La commande readonly nom_variable permet de protéger la variable dont le nom

est

donné en argument. Cette variable ne pourra plus être supprimée par la commande unset

et son contenu ne pourra pas être modifié.

Une variable protégée sera toujours « visible » dans le shell où elle a été définie. Elle est

détruite avec la mort de ce shell.

La commande readonly sans paramètre liste les variables protégées.

Page 12 sur 63

Création d'un tableau avec la commande set (seulement le K-Shell !! )

set -A NomTabieau val1 val2 val3 ...

Exemple :

set -A tab aaa bbb cccc dddd eee

Affichage du 3ème

élément du tableau, les éléments sont indicés à partir de 0 :

écho ${tab[2]}

cccc

Modification du 1er élément :

tab[0]=new

La liste de tous les éléments est donnée par ${nom_tableau[*]}.

Le nombre d'éléments est donné par ${#nom_tableau[*]}.

Longueur d'une chaîne de caractères

var=toto

echo ${#var}

4

1.3. LES VARIABLES PREDEFINIES (ÉCRIRE EN MAJUSCULE)

Les variables sont dites prédéfinies car elles sont créées par le système et leur nom est connu.

Ces variables appelées aussi variables système dont le nom est prédéfini sont

utilisables à tout moment, leur nom est par convention en lettre majuscule.

Les variables systèmes permettent essentiellement de fixer l'environnement de travail de

Page 13 sur 63

chaque utilisateur. Certains programmes d'utilisation courante ont besoin des variables

système pour fonctionner correctement.

Les variables communes à tous les utilisateurs sont en général initialisées par le système dans

le fichier /etc/profile.

Les variables propres à chaque utilisateur sont elles initialisées dans un fichier de

configuration de nom .bash_profile ou .profile ou .bash_rc situé dans le répertoire de

connexion de chaque utilisateur.

Tous ces fichiers sont lus par le shell lors de la connexion de l'utilisateur. Chaque utilisateur

peut créer ses propres variables (chapitre 2) et les initialiser dans son fichier .bash_profile ou .bash_rc

ou .profil situé dans son répertoire de connexion.

L'utilisateur lui-même peut y modifier les variables système mais cela doit être fait avec

circonspection.

1.3.1 Quelques variables système

HOME : cette variable précise le répertoire d'accueil (connexion) au moment du login.

PATH : précise les répertoires de recherche pour les commandes.

Exemple :

PATH=/usr/biE:/bin:.:/usr/java/bin indique que la commande sera recherchée

dans /usr/bin, puis dans /bin, puis dans le répertoire courant

symbolisé par le point ( :.: est équivalent à :: ) et, enfin, dans /usr/java/bin. Le signe :

est le séparateur dans la liste des répertoires.

PSI : défini le « prompt » d'Unix, habituellement le signe $ pour les utilisateurs.

PS2 : précise le « prompt » secondaire d'Unix, affiché à chaque fois que la touche

« Entrée » a été appuyée alors que la ligne de commande est incomplète,

habituellement le signe >.

SHELL : contient par défaut le nom du shell de login.

TERM : spécifie le type de terminal utilisé, utile notamment à l'éditeur vi.

Page 14 sur 63

LOGNAME : initialisé avec le nom de l'utilisateur lors de la connexion.

MAIL : nom complet du fichier boîte aux lettres dans lequel sera déposé le courrier.

CDPATH : répertoires à examiner lors de la commande cd.

IFS : défini les caractères séparateurs de champs pour l'analyse d'une ligne de

commande par le shell ( espace, tabulation et retour à la ligne).

1.3.2 Comment modifier la variable PATH

La modification consiste à ajouter un nouveau chemin de recherche tout en gardant les

précédents.

Plusieurs situations sont possibles et à chacune correspond en général plusieurs solutions.

Prenons le cas d'un système Linux où un utilisateur jean crée dans son répertoire de connexion

un répertoire bin destiné à contenir ses propres commandes. Il veut maintenant

ajouter le chemin /home/jean/bin à la variable PATH . Il faut écrire pour cela :

PATH=$PATH:/home/jean/bin

On réinitialise ainsi la variable PATH en concatenant le contenu de l'ancien PATH et la

chaîne /home/jean/bin.

Cette instruction peut être placée dans le fichier /home/jean/.bashjprofile validant ainsi ce

nouveau chemin à chaque session.

1.3.3 La commande env

La commande env (comme environnement) affiche les variables système accessibles à

l'utilisateur.

1.3.4 La commande set

La commande set sans argument affiche l'ensemble des variables (système et utilisateur)

accessibles par l'utilisateur plus d'autres éléments.

Page 15 sur 63

1.4 LES VARIABLES INTERNES AU SHELL

Leur valeur est gérée par le shell.

1.4.1 La variable ?

Elle contient le code de retour de la dernière commande exécutée.

Le code de retour d'une commande qui s'est convenablement exécutée vaut toujours 0 ;

dans le cas contraire, sa valeur est différente de 0 mais non exactement définie pour tous les

Unix.

Supposons un fichier de nom faux qui n'existe pas et un fichier vrai qui lui existe..

cat faux

cat : faux : Aucun fichier ou répertoire de ce type

echo $?

1

cat vrai

je suis un fichier qui,

existe

echo $?

0

1.4.2 Les paramètres de position ou arguments d'un script

La forme générale d'une commande est cmd arg1 arg2 arg3 ... où cmd est le nom d'une

commande; par exemple 1s -1 /usr où le 1er argument est -1 et le 2

ème /usr .

Comme pour une commande Unix, un script peut recevoir et traiter des arguments.

La variable $0 représente le nom de la commande (ici ls), la variable $1 le 1er argument (ici -

I), la variable $2 le 2eme

argument (ici /usr) et ainsi de suite s'il y avait des arguments

supplémentaires.

Les paramètres de position sont les arguments d'un script qu'un utilisateur devra fournir

sur la ligne de commande.

Soit le script s3 très simple dont

Page 16 sur 63

l'exécution est lancée avec 3 arguments.

./s3 jean pierre paul

s3

un :jean

deux : pierre

trois : paul

Nombre : 3

jean pierre paul

echo $0

echo un : $1

echo deux : $2

echo trois : $3

echo Nombre : $#

echo $*

La variable # représente le nombre d'arguments transmis sur la ligne de commande.

La variable * est une chaîne de caractères constituée de tous les .arguments tapés sur la ligne

de commande.

4.3 La commande shift

Cette commande entraîne un décalage des arguments, le contenu de $1 est remplacé par celui

de $2, celui de $2 est remplacé par celui de $3 et ainsi de suite.

Soit le script s4 qui reçoit 3 arguments.

./s4 jean pierre paul

Avant shift

1 : jean 2 : pierre 3 : paul

Après shift

1 : pierre 2 : paul

Le 2ème

argument pierre se retrouve en $1, le 3ème

paul en $2. $0 n'est pas modifié, il contient toujours

le nom du script.

echo Avant shift

echo 1: $1 2 : $2 3 $3

Shift

echo Après shift

echo 1: $1 2 : $2

Page 17 sur 63

Avant shift $0 $1 $2 $3 $4

Après shift $0 $1 $2 $:

L'ancienne valeur de $1 est perdue. $0 n'est pas modifié, il contient toujours le nom du script.

1.4.4 Initialisation des arguments à l‟intérieur d‟un script

La commande set permet d'initialiser les paramètres de position à

l'intérieur d'un script comme le montre le script s5.

./s5

AAA Bbb CC

3

Il est aussi possible d'initialiser les paramètres de position avec les résultats d'une commande en

écrivant une ligne du type set `commande` ou set $(commande).

1.4.5. Les variables $, ! et -

La variable $ contient le numéro du processus en cours d'exécution. Le système affecte

automatiquement un numéro à chaque processus.

La commande echo $$ affiche, Le N° du processus courant. Taper cette instruction en ligne de

commande affiche le N° du processus shell.

> La variable ! contient le numéro du dernier processus lancé en arrière plan.

> La variable - contient la liste des options du shell.

1.5.EXERCICES

5.1 Tester les exemples du cours donné ci-dessus pour voir leur fonctionnement et vérifier les

résultats obtenus.

5.2 Taper la commande env et relever le contenu des variables PSI, PS2, PATH et HOME.

set AAA Bbb CC echo $1 $2

$3

echo $#

Page 18 sur 63

Vérifier avec la commande echo le contenu de chacune de ces variables.

5.3 Affecter la chaîne « Il dit » à une variable vl et la chaîne « bonjour » à une variable v2.

Vérifier les contenus de vl et v2 avec echo.

Taper la commande set et vérifier que les variables vl et v2 sont bien présentes.

Afficher la chaîne « Il dit bonjour ».

Supprimer v2. Taper écho $vl $v2, que peut-on observer ?

Taper set. Conclure.

5.4 Donner une solution pour afficher avec la commande écho le texte suivant.

Il dit " Tu prends ces $100 ?" et tout se passa bien.

5.5 Changer le prompt PS1 pour avoir le signe %.

Revenir au prompt normal.

5.6 Affecter à une variable ch la chaîne /usr.

Taper : 1s $ch

cd $ch

pwd

Revenir dans son répertoire de connexion.

5.7 Ecrire un script qui demande la lecture des 4 variables puis qui affiche ces variables.

5.8 Ecrire un script qui reçoit 4 arguments, les affiche ainsi que leur nombre, puis qui effectue

un décalage, affiche les variables restantes et leur nombre, et ainsi de suite jusqu'à qu'il n'y

ait plus de variable.

5.9 Que se passe t'il si on essaye de décaler plus d'arguments qu'il n'en existe à l'aide de la

commande shift (voir avec l'exercice 5.8) ?

5.10 Ecrire un script qui affiche « Ouel fichier voulez vous afficher ? », effectue la saisie du

nom du fichier concerné, puis affiche le fichier avec et enfin affiche le code de

retour après cette commande. Tester ce script dans les 2 cas de fonctionnement possibles.

Page 19 sur 63

5.11 Tester le mécanisme de substitution d'une commande avec les variables suivantes :

Monecho=`echo bonjour`

dir=`ls –l`

Tester l'utilisation de ces variables.

Faire des tests en utilisant la 2eme

possibilité de substitution présentée dans le cours.

5.12 Utiliser la commande set pour initialiser les arguments d'un script au résultat de la

commande date; puis afficher chacun des arguments ainsi obtenus.

5.13 La commande printf permet également d'afficher à l'écran. Utiliser l'aide man printf et

effectuer quelques essais de cette commande.

IMPORTANT : un script shell doit en toute rigueur commencer par une ligne

contenant uniquement

# !/bin/bash

pour indiquer quel est l'interpréteur de commandes utilisé pour exécuter le script.

Page 20 sur 63

LE BOURNE SHELL - Cours/TP N°2

2.1. LA COMMANDE TEST

La syntaxe générale de l'instruction est test expression .

La commande test permet d'évaluer une expression se rapportant à 3 types possibles de

données :

• Des chaînes de caractères.

• Des valeurs numériques.

• Des fichiers.

Un test vrai retourne la valeur 0 (récupérée dans $?).

2.1.1 Test sur les chaînes de caractères

test s1 = s2 vrai si s1 et s2 sont identiques ; par exemple : test $ch = "oui"

test s1 != s2 vrai si s1 et s2 sont différentes ; par exemple : test $chl != $ch2

test si vrai si s1 n'est pas une chaîne nulle (chaîne non vide) ; par exemple : test $ch

test -n s1 vrai si la longueur de s1 n'est pas nulle (chaîne non vide).

test -z si vrai si la longueur de s1 est nulle (chaîne vide).

Attention à l'espace de

part et d'autre du signe =

Page 21 sur 63

echo $var

test "$var"

echo $?

1

test-n "$var"

echo $?

1

test-z "$var"

écho $?

0

var=titi

test "$var" = titi

écho $?

0

test"$var" = tutu

écho $?

1

Attention : Il faut en toute rigueur, même si cela ne semble pas nécessaire, mettre entre

guillemets (double quote) l'expression $NomVariable quand on veut analyser la chaîne

decaractères contenue par cette variable. Les guillemets sont nécessaires dans le cas où la

variable rencontrée est vide.

2.1.2 Comparaison arithmétique (sur les entiers)

Ces tests comportent toujours 3 paramètres : le 1er et le 3

ème contiennent les variables/valeurs à

comparer, le 2ème

définit le type de la comparaison.

Les types de comparaison sont les suivants :

test n1 -eq n2 vrai si n1 et n2 sont égaux ; par exemple test $n -eq 10 .

test n1 -ne n2 vrai si n1 et n2 sont différents ; par exemple test $x -ne $y

Page 22 sur 63

test n1 -gt n2 vrai si n1 est supérieur à n2.

test n1 -ge n2 vrai si n1 est supérieur ou égal à n2.

test n1 -lt n2 vrai si n1 est inférieur à n2.

test n1 -le n2 vrai si n1 est inférieur ou égal à n2.

chiffre=10

test "$chiffre" -gt 9

écho $?

1

test "$chiffre" -gt 8

écho $?

0

Le shell considère les nombres n1 et n2 comme des chaînes de caractères mais comme chaque

nombre possède son code ASCII, la comparaison de nombres devient une comparaison de

chaînes.

2.1.3 Tests sur les fichiers

La syntaxe générale de la commande est la suivante :

test -condition nom_fichier

test -f nom_fichier vrai si nom_fichier est un fichier ordinaire.

test -d nom_fichier vrai si nom_fichier est un répertoire.

test -c nom_fichier vrai si nom_fichier est un fichier en mode caractère.

test -b nom_fichier vrai si nom_fichier est un fichier en mode bloc.

test -p nom_fichier vrai si nom_fichier est un tube nommé.

test -r nom_fichier vrai si on a l'autorisation en lecture sur nom_fichier.

test -w nom_fichier vrai si on a l'autorisation en écriture sur nom_fichier.

test -x nom_fichier vrai si on a l'autorisation d'exécution sur nom_fichier.

test -s nom_fichier vrai si le fichier nom_fichier n'est pas vide (taille >0).

Page 23 sur 63

ls-1

-rw-rw-rw- 1 P3 group 1150 Mai 13 23:15 essai

-rw-rw-rw- 1 P3 group 0 Mai 13 23:15 b

drwx-r-x-- 2 p3 group 1024 Mai 15:12:40 recettes

…

test -f essai

echo $?

0

test -x essai

echo $?

1

a=recettes

test -d $a

eho $?

0

test -s b

eho $?

1

2.1.4 Autre écriture de la commande test

La commande test expression peut être remplacée par [ expression ], ne pas oublier l'espace

entre chaque crochet et expression.

Exemples : test -n "$ch1" est équivalent de [ -n "$chl " ]

test "$nb" -eq 10 est équivalent de [ "$nb" -eq 10 ]

espace espace espace espace

Page 24 sur 63

2.1.5 Association de test

Divers tests peuvent être combinés sur une même ligne de commande pour effectuer un ET ou un

OU logique.

> L'option -a réalise un ET entre 2 tests.

Le test suivant est vrai si les chaînes chl et ch2 sont vides.

test –z "$chl" -a -z "$ch2" ou [ -z "$chl" -a -z "$ch2" ]

> L'option -o réalise un OU entre 2 tests.

La ligne suivante teste si f2 est un fichier dans le cas où fl n'est pas un fichier.

test -f f1 -o -f f2 ou [ -f fl -o -f f2 ]

> L'opérateur ! est utilisé pour retourner la négation d'une condition.

Le test suivant est vrai si dir n'est pas un répertoire.

test ! -d dir

2.2. LES COMMANDES EXECUTION CONDITIONNELLE

2.2.1 La commande &&

La syntaxe générale est la suivante : instruction1 && instruction2 && instruction3 ...

Si la commande instruction1 réussit (retourne ainsi une valeur vraie) alors la commande

instruction2 est exécutée, si instruction2 réussit alors instruction3 est exécutée ...

grep include exo.c && cat exo.c

Si le fichier exo.c contient la chaîne include alors on visualise exo.c.

L'opérateur && permet d'exécuter une suite de commandes, chacune n'étant exécutée que si la

précédente l'a été de façon satisfaisante.

Page 25 sur 63

2.2.2 La commande ||

La syntaxe générale est la suivante : instruction1 || instruction2 || Instruction3 ...

Si la commande instruction1 échoue (retourne ainur fausse) alors la commande

instruction2 est exécutée, si instruction2 échoue alors instruction3 est exécutée ...

grep include exo.c || cat exo.c

Si le fichier exo.c ne contient pas la chaîne include alors on visualise exo.c.

L'opérateur || permet d'exécuter une suite de commandes jusqu'au succès de l'une d'elles, après

quoi les instructions suivantes ne sont plus exécutées.

2.2.3 La commande if

La syntaxe de base est la suivante

if expression évaluable

then

liste de commandes

[ else

liste de commandes ]

fi

La section else marquée entre crochets [ ]

est optionnelle.

Soit le script s6 ci-contre :

./s6

Aimez-vous le shell ?

Expression évaluable peut être une

expression construite avec la

commande test ou bien une expression construite avec une commande qui retourne un résultat vrai ou faux.

echo Aimez vous le shell ?

read var

if test "$var" = oui

then eco $var! ,tant mieux.

else echo Partez en vacances !

fi

Page 26 sur 63

oui

oui !, tant mieux.

./s6

Aimez-vous le shell ?

bof

Partez en vacances !

Les autres syntaxes possibles sont : if expression évaluable

then

commandes

fi

Pour réaliser plusieurs conditions imbriquées on peut utiliser la forme suivante :

If … If …

then .... then ....

else if .... elif ....

then .... then ....

else .... else

fi fi

fi

La commande elif remplace avantageusement else if, il n'y a pas de fi pour terminer un

elif. ............ ... " . ........................................... ~ ~~ '

echo Aimez-vous le shell ?

read var

if test "$var" = oui

then echo $var tant mieux. elif test "$var" = bof then écho Persistez; ! else echo Partez en vacances !

fi

Soit le script s7 ci contre :

./s7

Aimez-vous le shell ?

Non

Partez en vacances !

Page 27 sur 63

2.2.4 la commande exit [n]

Elle permet de mettre fin à un script et de retourner une valeur. Retourne 0 si la valeur n n'est

pas précisée.

Elle permet de mettre fin à un script et

de retourner une valeur.

Retourne 0 si la valeur n n'est pas

précisée.

Soit le script s8 qui donne un exemple très simple d'utilisation d'exit : 2.3. EXERCICES

Quand on ne veut pas afficher le résultat d'une commande à l'écran, on doit

la rediriger vers le fichier spécial /dev/null.

Le rôle essentiel du fichier /dev/null est de recevoir des redirections de commandes dont

l'affichage n'a pas d'importance mais dont le résultat vrai ou faux est essentiel.

2.3.1 Tester avec soin les exemples du cours.

2.3.2 Ecrire un script qui attend une lettre tapée au clavier puis qui affiche :

• Légume si la lettre 1 est tapé.

• Viande si v est tapé.

• Pain si p est tapé.

• Poisson dans tous les autres cas.

2.3.3 Reprendre l'exercice ci-dessus afin qu'il fonctionne aussi avec des lettres majuscules.

2.3.4 Ecrire un script qui reçoit un nombre comme argument et qui affiche :

• Trop petit si le nombre est inférieur à 10.

• Correct si le nombre est dans l'intervalle [10 20].

• Trop grand si le nombre est supérieur à 20.

if [ -f .bash_profile ]

then echo Profil existant; ; exit 0 else echo Profil

inconnu

; exit 2

fi

Page 28 sur 63

2.3.5 Ecrire un script qui reçoit 1 argument, ce script doit déterminer et afficher si

l'argument donné est soit un fichier, soit un répertoire, soit ne correspond à rien de cela.

2.3.6 Ecrire un script qui reçoit 2 arguments, un nom de fichier en 1er, un répertoire(chemin

de recherche) en 2nd

, puis qui vérifie si le fichier donné en 1er existe dans le répertoire

donné en 2nd

. La recherche doit s'effectuer dans le répertoire courant si le 2nd

argument

est omis.

2.3.7 On montre ici une manière différente mais très utile pour construire l'expression

évaluée derrière le if: expression évaluable est ici une expression construite avec

une commande qui retourne un résultat vrai (0) ou faux (≠0).

Le scripts suivant reçoit un argument et vérifie si cet argument est bien le nom d'un objet

(fichier, répertoire ...) situé dans le répertoire courant.

a) Tester ce script.

b) Montrer que ce script présente un défaut

fondamental d'élaboration du nom de l'objet

testé. Pour cela, créer 1 fichier exo et tester

ce script avec l'argument ex, puis avec

l'argument xo. Conclure.

c) On supprime ce défaut en remplaçant $1 par " $l ". espace entre $1 et le " fermant

Vérifier le fonctionnement.

d) Améliorer ce script en supprimant l'affichage intempestif non désiré.

e) Que se passe-t-il si on ne donne pas d'argument ?

Proposer une solution pour corriger ce problème.

2.3.8 Ecrire un script qui reçoit comme argument le nom d'un utilisateur puis qui recherche

si

cet utilisateur est connecté. Les messages affichés indiqueront bien si l'utilisateur est

connecté ou non. Ce script doit impérativement vérifier qu'un argument a été transmis et

signalé une erreur si ce n'est pas le cas.

2.3.9 Le fichier /etc/passwd contient la liste des utilisateurs reconnus par le système

(utilisateurs autorisés à se connecter). Ce fichier est accessible en lecture. La structure

de chaque ligne de ce fichier est la suivante :

NomUtilisateur :Password :UDI :GID :Iibre :répertoire de connexion :shell

if ls | grep $1

then echo $1 existe

else echo $1 n\‟existe pas

fi

Page 29 sur 63

Le séparateur de champs est le caractère : (2 points), il y a une ligne par utilisateur.

• NomUtilisateur : Nom de l'utilisateur.

• Password : Mot de passe codé de l'utilisateur ou x.

• UID : Numéro d'identification de l'utilisateur (User IDentifier).

• GID : Numéro d'identification du groupe auquel appartient l'utilisateur.

• Libre : zone de commentaire.

• Répertoire de connexion : répertoire d'accueil de l'utilisateur lors de sa connexion.

• Shell : Nom complet du shell lancé à la connexion ( /bin/sh ou /bin/bash ou ...).

Copier le fichier /etc/passwd dans votre répertoire. Visualiser ce fichier.

Ecrire un script qui reçoit un nom comme argument et vérifie si ce nom est celui de l'un

des utilisateurs autorisés.

Page 30 sur 63

LE BOURNE SHELL – Cours TP N°3 3.1COMPLEMENTS SUR L‟OPERATEUR $

Extraction d‟une sous chaîne.

• On définit une variable adresse.

[root@iris ~]# adresse=toto.tutu@pipeau.bulle.fr

• Longueur de la variable adresse :

[root@iris ~]# echo ${#adresse}

30

• On ôte de la variable la partie la plus courte située derrière le caractére @.

[root@iris ~]# echo ${adresse%@*}

toto.tutu@tata

• On ôte de la variable la partie la plus longue située derrière le caractère @.

[root@iris ~]# echo ${adresse%%@*}

toto.tutu

• On ôte de la variable la partie la plus courte située devant le caractère point (.).

[root@iris ~]# echo $ {adresse#*.}

Page 31 sur 63

tutu@tata@pipeau.bulle.fr

• On ôte de la variable la partie la plus longue située devant le caractère point (.).

[root@iris ~]# echo $ {adresse##*.}

• On teste si une variable est vide on lui affecte une valeur si c’est le cas

[root@iris ~]# var=existe

[root@iris ~]# echo $ {echo ${var:-vide}

existe

[root@iris ~]# var1=

[root@iris ~]# echo ${var1 :-vide}

3.2. LA COMMANDE case

3.2.1 Syntaxe

Elle permet d’effectuer un choix multiple, sa syntaxe est la suivante :

case variable in

modèle11 [ |modèle12 …]) suite 1 de commandes ; ;

modèle 21 [ |modèle22 …]) suite 2 de commandes ; ;

…

*) suite de commandes ; ;

esac

Page 32 sur 63

Les règles de mises en correspondance de la variable avec chacun des modèles respectent les mêmes

règles que celles de correspondance des fichiers. Ou, plus exactement, les modèles modèle11,

modèle12, …, modèle21, … sont construits avec les mêmes règles que celles utilisées pour construire

les noms de fichiers.

La commande case essaye de trouver une correspondance entre la variable et les divers

modèles indiqués modèle11, modèle12, …, modèle21, … Quand la correspondance est

trouvée, la liste de commandes associée est executée.

Le modèle * au cas pas défaut quand aucune correspondance n’a été trouvée avec les modèles

précédents.

La dernière commande de chaque suite de commandes exécutée doit impérativement se

terminer par un double point virgule.

Rappel des règles de construction des noms de fichiers :

* correspond à n’importe quelle chaîne de caractères.

? correspond à un caractère quelconque.

[…] correspond à un des caractères de la liste mise entre mes crochets, par exemple :

[azer] : soit a, soit z, soit e, soit r.

[a-d] : soit a, soit b, soit c, soit d : on précise ici un intervalle.

[ !a-d] : tous les caractères sauf ceux indiqués dans les crochets.

Page 33 sur 63

echo "Manger Boire ou Dormir ?"

echo Taper la 1ère lettre

read rep

case $rep in

[Mm]) echo On va manger

Echo J\’ai faim ;;

[Bb]) echo On va boire ;;

[Dd]) echo On va dormir ;;

*) echo "Vous ne voulez rien ?"

esac

3.2.2 Exemples

Voici un 1er script s9 proposant un choix, la

personne interrogée tape la 1ère

lettre de la

réponse.

./s9

Manger Boire ou Dormir ?

Taper la 1ère

lettre

B

On va boire script s9

On peut améliorer le programme ci-contre en laissant le choix à l’utilisateur de taper la 1ère

lettre en

majuscule ou en minuscule.

On propose ici les 2 solutions possibles.

Script s10 Script s11

echo "Manger Boire ou Dormir ?"

echo Taper la 1ère lettre

read rep

case $rep in

M) echo On va manger

echo J\’ai faim ;;

B) echo On va boire ;;

D) echo On va dormir ;;

*) echo "Vous ne voulez rien ?"

esac

echo "Manger Boire ou Dormir ?"

echo Taper la 1ère lettre

read rep

case $rep in

M|m) echo On va manger

echo J\’ai faim ;;

B|b) echo On va boire ;;

D|d) echo On va dormir ;;

*) echo "Vous ne voulez rien ?"

esac

Page 34 sur 63

3.2.3 Exercices

2.31 Tester les 3exemples du cours.

2.32 Modifier l’exemple du cours pour accepter en plus les réponses Manger, manger pour le 1er

cas, Boire, boire pour le 2ème

cas et enfin Dormir et dormir pour le dernier cas.

2.33 Ecrire un script attend un nombre et qui affiche :

La réponse est 1 si le nombre est 1.

La réponse est 2 si le nombre est 2.

La réponse est 3 si le nombre est 3.

La réponse est incorrecte dans tous les autres cas.

2.34 Ecrire un script qui effectue la saisie d’une chaîne au clavier et qui affiche un message différent

suivant que :

La chaîne commence par un chiffre.

La chaîne commence par une voyelle majuscule.

La chaîne commence par une voyelle minuscule.

La chaîne commence par tout autre caractère.

Page 35 sur 63

3.3 LA BOUCLE for

3.3.1 Syntaxe

La syntaxe est la suivante :

for variable in ListeDeValeurs

do

suite de commandes

done

La liste des valeurs peut être une suite de chaînes de caractères mais le plus souvent est le résultat

d’une expression issue d’une expansion des noms de fichiers.

Le corps de la boucle situé entre do et done est exécuté pour chaque valeur de la liste donnée.

La boucle for est normalement parcourue autant de fois qu’il y a de valeurs dans ListeDeValeurs,

variable prenant la 1ère

valeur de la liste pour le 1er parcours, la 2

ème valeur de la liste pour le 2

ème

parcours et ainsi de suite.

Si in ListeDeValeurs est omis alors les arguments du script constituent la liste de valeurs :

for i

do

….

done

Si on travaille sur les fichiers, on peut utiliser les règles de construction des noms de fichiers

Voici le squelette d’un script qui effectuerait un traitement pour

chaque fichier contenu dans le répertoire courant. La variable fich

contient alors le nom complet du nouveau fichier pour chaque

itération.

Voici une modification du squelette précédent qui effectuerait un

traitement pour chaque fichier d’extension .c situé dans le

répertoire courant.

for fich in *

do

…

done

for fich in *.c

do

…

done

Page 36 sur 63

3.3.2 Examples

Soit le script s12 suivant :

./s12

pop

pip

top

tip

hop

3.3 Exercices

3.31 Tester l’exemple donné dans le cours.

3.32 Ecrire un script qui affiche les noms de tous les répertoires courant.

L’affichage sera du type : Répertoire : « nom_du_répertoire »

3.33 Modifier le scipt ci-dessus afin qu’il affiche pour un répertoire : Répertoire :

« nom_du_répertoire » et pour un fichier trouvé : Ficher : « nom_du_fichier ».

3.34 Ecrire un script permettant de vérifier si plusieurs utilisateurs sont actuellement connectés.

Le nom de chaque utilisateur sera donné en argument, par exemple ./234 alain roger pierre .

3.35 Créer les fichiers t1, t2, t3, t4 (leur contenu importe peu). Proposer un script qui copie ces ces

fichiers t1, t2, t3, t4 dans respectivement p1, p2, p3 et p4. Il faut que le ce script fonctionne quelque

soit le nombre de fichiers t*.

Modifier le script précédent afin de lui donner en argument le préfixe commun aux fichiers

sources puis celui commun aux fichiers destinations ( exemple ../235 t p ).

for var in pop pip top hop

do

echo $var

done

Page 37 sur 63

3.4 LA BOUCLE while

3.4.1 Syntaxe

Le corps de la boucle est exécuté tant que la condition est vraie.

La syntaxe est la suivante :

while liste de commandes

do

…

Done

3.4.2 Exemple

Le script ci-contre s13 attend un nom de fichier,

on reste dans la boucle tant que le nom donné

n’est pas un nom de fichier.

3.5. LA BOUCLE until

3.5.1 Syntaxe

Le corps de la boucle est exécuté jusqu’à que la condition soit vraie.

La syntaxe est la suivante :

until liste de commandes

do

…

done

while [ ! –f "$nom" ]

do

echo Entrer un nom de fichier

read nom

done

cat $nom

Page 38 sur 63

3.5.2 Exemple

Le script ci-contre s14 attend un nom de fichier, on

reste dans la boucle jusqu’à que le nom donné soit

un nom de fichier

3.6 CREATION DE MENUS (K-Shell et bash)

3.6.1 Syntaxe

La commande select permet de créer des menus simples.

select variable in ListeDeChoix

do

Suite de commandes

done

La ListeDeChoix est affichée avec un choix par ligne, un N° est placé devant chaque choix et la

variable PS3 est affichée (prompt ternaire).

Le shell attend alors une saisie qui doit être un des N° affichés.

La Suite de Commandes est exécutée si l’entrée n’est pas nulle (appui sur ◄┘), la variable REPLY

contient le N° tapé et variable est initialisé à l’élément de ListeDeChoix dont l’indice correspond au

N° sélectionné.

until [ -f « $nom ]

do

echo Entrer un nom de fichier

read nom

done

cat $nom

Page 39 sur 63

3.6.2 Exemple

Soit le script s15 ci-contre qui

attend un choix, l’utilisateur doit

donner le N° correspondant à la

personne sélectionnée.

Le menu est affiché à nouveau si

l’utilisateur tape ◄┘ sans donner

un N°.

./s15

1) Alain

2) Jacques

3) Paul

4) Antoine

Lequel choisissez vous ? 3

3 choisi et Paul

Si l’utilisateur tape une valeur différente de 1, 2, 3 ou 4 le menu est affiché à nouveau grâce au

test if [ -n "$name" ] qui permet de vérifier que $name n’est pas nul donc que l’entier

sélectionné est un indice faisant correspondre à un élément dans la liste.

PS3= « Lequel choississez vous ? »

select name in Alain Jacques Paul Antoine

do

if [ -n "$name" ]

then echo $REPLY choisi et $name

break

fi

done

L’untilisateur tape3

Page 40 sur 63

3.7. INTERRUPTION DES BOUCLES

La commande break permet d’interrompre une boucle for, while ou until.

Syntaxe for…

do

if condition

then break

fi

…

Done

La boucle for est interrompue si la condition est vraie.

La commande continue interrompt en cours et l’exécution de la suivante est démarrée.

Syntaxe for…

do

if condition

then continue

fi

suitecommandes

done

Si la condition est vraie alors l’itération en cours est interrompue et on passe à la

suivante (suitecommandes n’est pas exécutée).

Page 41 sur 63

3.8 LA COMMANDE expr

La commande expr permet d’évaluer numériquement une expression et de

retourner le résultat sur la sortie standard par défaut (l’écran).

expr 5 + 3

8

expr 2 /* 3 (le signe \ dévalide l’interprétation du caractère * par le shell)

6

a=10

expr $a + 1

11 espace

Attention aux espaces séparant les expressions ou les caractères significatifs : expr $x + 3

Il est très utile dans un script de pouvoir affecter le

résultat du calcul dans une variable, comme le montre le

script s16.

./s16

Taper un nombre

10

15

Les opérateurs arithmétiques autorisés sont : + pour l’addition,

- pour la soustraction, * pour la multiplication, / pour la division

et % pour le reste de la division. Voici le script s17 plus

sophistiqué qui calcule ∑n pour n variant de 0 à N.

echo Taper un nombre

read n

s=’expr $n + 5’

echo $s

echo Taper un nombre

read N

X=0

Som=0

while [ $X -lt $N ]

do

X=’expr $X + 1’

Som=’expr $Som + $X’

done

echo Somme=$Som

Page 42 sur 63

La commande expr permet d’effectuer des évaluations d’expression, voici les possibilités

offertes.

expr $a | &b : retourne $a si $a différent de 0 sinon retourne $b.

expr $a & $b : retourne $a si $a et $b ne sont pas nuls sinon retourne 0.

expr $a op $b : op est un opérateur de comparaison qui prend une des valeurs suivantes <,

<=, =, ==, >=, >, !=. Compare $a et $b et retourne 1 si le test est vrai

sinon 0.

La commande expr permet de travailler sur des chaînes de caractères grâce à l’opérateur : .

expr tomatetos : to

2

expr tomatetos : ".*"

9

expr tomatetos : „to\(.*\)tos‟

mate

echo $LOGNAME

hugo

expr “$LOGNAME” : “.*”

4

Le critère .* renvoie la longueur de la chaîne de caractères.

Page 43 sur 63

3.9. LA COMMANDE let (bash et K-shell)

Elle représente une alternative intéressante à l’utilisation de expr pour les calculs arithmétiques.

Exemple : a=2

let b=a*5

echo $b

10

Les opérateurs autorisés sont les classiques *, /, %, +, - .

3.10. AUTRE POSSIBILITE POUR LES CALCULS

ARITHMETIQUE (K-Shell et bash2) espace

Exemples de script élémentaires s18

./s18

Sup

Le script suivant s19 reçoit 2 arguments, il calcule le produit

Des 2 nombres, affiche si le résultat est compris dans l’intervalle [10, 20], puis calcule (1er

argument) puissance (2ème

argument).

s19

a=15

if (( a>12 ))

then echoSup

else echo Inf

fi

# !/bin/bash

x=$1

y=$2

res=$ ( ( x * y ) )

echo $res

if ( ( res <= 10 ) )

then echo INF

elif ( ( ( res >= 10 ) && ( res <=20 ) ) )

then echo Dans l\’intervalle 10-20

else echo SUP

fi

Page 44 sur 63

Opérateurs autorisés

La liste des opérateurs ci-dessous est constituée ci-dessous est constituée par des groupes de

précédence identique. Les niveaux sont classés en ordre de précédence décroissante.

- + plus ou moin unaire

! ~ négations logique et binaire

** exponentiation

* / % multiplication, division, reste

+ - addition, soustraction

< < > > décalage arithmétique à gauche et à droite

<= >= < >

Comparaisons

== ! = égalité et différence

& ET binaire

^ OU exclusif binaire

| OU binaire

&& ET logique

| | OU logique

expr?expr:expr évaluation conditionnelle

= *= /= %= += -= <<= >>= &= ^= |= assignations.

Page 45 sur 63

3.11 LES FONCTIONS

Le langage shell accepte l’écriture des fonctions.

La syntaxe de base est la suivante :

NomFonction () {

Instructions

}

Ou

Function NomFonction (){

Instruction

}

L’exemple ci-contre présente une

fonction chdir() qui reçoit un

paramètre, teste si cet argument est

un répertoire et se place dedans si

c’est le cas.

Cette fonction chdir() est utilisée

dans un script s20.

./s20

Quel est le répertoire à vérifier ?

/usr

drwxr-xr-x 8 root…..X11R6

drwxr-xr-x 8 root bin

drwxr-xr-x 8 root doc

chdir() {

if [ -d $1 ]

then cd $1

ls -1

else echo $1 n\’est pas un repertoire connu

fi

}

chdir() {

if [ -d $1 ]

then cd $1

ls -1

else echo $1 n\’est pas un repertoire connu

fi

}

echo Quel est le répertoire à vérifier ?

read rep

chdir $red

Page 46 sur 63

drwxr-xr-x 8 root etc

----

Il faut faire attention au passage de l’argument à la fonction lors de son appel.

Les fonctions peuvent être placées dans un fichier à part des fichiers contenant les scripts qui

les appellent.

Le fichier mafonction contient la

fonction précédente.

Voici le script s21 qui l’utilise

Le nom du fichier contenant les

fonctions doit être précisé en

respectant la syntaxe suivante : on

tape un point, un espace puis le

nom du fichier.

Le script s22 suivant effectue le calcul du cube d’un nombre à l’aide d’une fonction.

Si la commande interne return est exécutée dans une fonction, celle-ci se termine et l’exécution

reprend avec la commande suivant l’appel de fonction. Quand une fonction se termine, les

paramètres positionnels et le paramètre spécial # reprennent les valeurs qu’ils avaient avant l’appel

de fonction.

Chdir() {

if [ -d $1 ]

then cd $1

ls -1

else echo $1 n\’est pas un répertoire connu

fi

}

. mafonction

echo Quel est le répertoire à vérifier ?

read rep

chdir $rep

#!/bin/bash

cube ( ) {

#cube=$ ( ( $1 * $1 * $1 ) )

Cube=$ ( ( $1 * * 3 ) )

}

echo Entrer un nombre

read n

cube $n

echo $cube

La variable d’un cube est commune à la fonction et au script

appelant. Les variables locales d’une fonction peuvent être

déclarées avec la commande local.

Autrement, les variables et leurs valeurs sont partagées entre

la fonction et son appelant.

Une fonction peut retourner une valeur grâce à l’instruction

return n . Si n est omis, la valeur envoyée est celle de la

dernière commande exécutée.

Page 47 sur 63

3.12 EXERCICES

11.1 Tester les exemples du chapitre 1.

12.2 Tester les scripts s9, s10 et s11 du chapitre 2.

Faire les exercices du chapitre

12.3 Tester le script s12 du chapitre 3.

Faire les exercices du chapitre 3.3 page 4 et 5.

12.4 Tester les scripts s13 page 5, s14 page 6, s15 page 6 et s16 page7.

12.5 Ecrire un script effectuant la lecture du clavier jusqu’à que la réponse soit oui ou non.

12.6 Ecrire un script qui calcule la surface et le périmètre d’un rectangle dont la largeur et la

longueur sont données en argument, les calculs seront ensuite effectués en utilisant expr.

12.7 Ecrire un script qui calcule la factorielle d’un nombre donné en argument et qui calcule le

résultat en utilisant expr.

12.8 Tester les scripts s18 et s19 page 9.

12.9 Reprendre les exercices 12.6 et 12.7 en utilisant le mode d’évaluation indiqué au chapitre

10.

12.10 On demande de créer une commande del dont la syntaxe est la suivante :

Del fich1 [ fich2 …]

Cette commande doit effacer les fichiers donnés en argument, mais ceux-ci seront

auparavant sauvegardés dans le répertoire $HOME/poub avec l’extension .sav. Le script

devra vérifier que les arguments sont correctement donnés et que le répertoire

$HOME/.poub existe bien. Le script créera le répertoire $HOME/poub au cas où celui-ci

n’a pas été déjà créé, c'est-à-dire lors de l’utilisation de ce script.

Page 48 sur 63

Quelle solution proposez-vous pour rendre cette commande accessible à tous les

utilisateurs du système ?

12.11 Tester les exemples sur les fonctions page 10 et 11.

12.12 On veut pouvoir choisir parmi 4 types de terminaux pour diverses connexions au système.

Les 4 types sont : Televideo 925, VT100, Televideo 950, Wyse50.

Il n’y a que l’utilisateur qui sache le type de son terminal, la variable TERM doit prendre la

valeur tvi925 pour un terminal Televideo 925, vt100 pour un VT100, tvi950 pour un

Televideo 950 et enfin wyse50 pour un Wyse 50.

Ecrire le script qui propose un menu et permette à l’utilisateur de positionner la variable

TERM. On vérifiera le résultat en affichant la variable TERM à la fin du script.

12.13 Proposer un script tree qui affiche l’arborescence (les répertoires et sous répertoires). Le

paramètre donné indiquera le répertoire de départ pour l’analyse (utilisation de la

récursivité). Par défaut, la recherche s’effectuera dans le répertoire courant si l’argument

est omis.

Page 49 sur 63

TP Gestion des processus

Exercice 1

Tester la commande ps puis ps axl.

Relever le PID de votre shelle et le PID du père de ce shell.

Quel est le rôle des options a, x et l?

Quel est le rôle de l'option f? tester cette option.

Tester l'option u.

Exercice 2

Teser avec soin la commande pstree.

Exercice 3

Tester avec soin la commande top. Essayer ses commandes.

Exercice 4

Lister les signaux du système.

Exercice 5

Taper la comande sleep 200& et vérifier le PID du processus lancé avec ps. Tuer ce

processus.

Exercice 6

Tuer votre processus shell avec la commande kill

Exercice 7 (une initiation au script est obligatoire)

Taper le script s7 suivant :

echo pid = $$

n=1000; x=0

while ((x -lt n))

do

let x=x+1

z=0

while (( z -lt 100))

do

let z=z+1

sleep 1

Page 50 sur 63

echo $z > fich

done

done

Quelle est la durée d'exécution de ce script?

Exécuter en avant plan ce script : chmod +x s7; ./s7

Faire un cat de fich

Stopper maintenant el processus.

Redémarrer le en arrière plan. Replacer le en avant plan. Tuer le.

Exercice 8

Lancer s7. Faire Ctrl-c. Justifier ce qui s'est passé.

Exercice 9

Tuer le processus de la question 8 avec le signal SIGKILL.

Exercice 10

Modifier le script s7 afin de le rendre insensible aux signaux SIGINT, SIGQUIT et SIGTERM.

Vérifier le fonctionnement en envoyant au processus correspond t ces 3 signaux.

Page 51 sur 63

TP Gestion des utilisateurs

Exercice 1

A l'aide du manuel de useradd préciser le rôle des option -d, -g, -G, -m et -u

quelle est l'utilité de la commande id, faire des tests

Exercice 2

Créer 2 utilisateurs jean et paul de la manère la plus simple possible. Donner leur un mot de

passe.

Vérifier leur connexion au système. Quel est leur répertoire de login? que contient il ?

Justifier.

Observer les lignes correspondantes dans /etc/passwd et /etc/group.

Noter le gestion des valeurs de uid et de gid par la système.

Exercice 3

utiliser la commande su sous ses diverse forme (man). Passer de root a jean, puis à paul puis

à root...

Exercice 4

Créer l'utilisateur pierre avec comme seule contrainte d'être membre du groupe paul. Vérifier

sa connexion. Quel est son répertoire de login. Observer les ligne créeés dans /etc/group et

/etc/passwd.

Exercice 5

Effectuer et vérifier le fonctionnement des étapes suivante : interdire la connexion de jean,

autoriser à jean de se connecter à nouveau, modifier le mot e passe de jean, tester ce nouveau

mot de passe.

Exercice 6

Créer un groupe admin et le répertoire /home/admin

donner le répertoire /home/admin/ au groupe admin

créer 2 utilisateurs eric et lucien appartenant à ce groupe dont les répertoires de login sont

/home/admin/eric et /home/admin/lucien

vérifierr leur connexion, les répertoires de conexions, à qui appartiennent ces répertoires?

observer les lignes correspondantes dans /etc/.passwd/ et /etc/group

Exercice 7

On veut que lucien soit en plus membre du groupe paul. Taper la commande nécessaire.

Observer les modifications apportées dans le fichier /etc/group

Page 52 sur 63

Observer le résultat de la commande groups lucien

Vérifier la possibilité pour lucien de changer de groupe

Créer un utilisateur john avec son groupe par défaut john mais appartenent aussi au groupe

paul.

Observer les modifications des fichiers /etc/passwd et /etc/group.

Page 53 sur 63

TP initiation au shell

Exercice 1

Exécuter les commandes suivantes et analyser les résultats produits:

date

cal

cal 10 2001

cal 10 01

pwd

ls

ls -l

ls -al

ls /usr/include

ls -l /usr/include

ls -l /usr/include

ls -l /usr/include | more

ls -l /usr/include | less

ls -l /usr/include | wc -l

cd /usr/include

ls

cd

who

whoami

who am i

man who

date; who; pwd

ulimit man

ulimit

alias

Page 54 sur 63

unalias rm

alias

date > f1

cat f1

who >> f1

cat f1

(date; who) > f

cat f

Exercice 2

Noter les répertoires situés dans le répertoire racine avec la commande ls

Exercice 3

Dans le répertoire de connexion créer un fichier exo avec la commande cat > exo, et y taper

le texte suivant

un deux

trois quatre

cinq six sept

huit neuf dix

cent

mille

on termine la commande cat en tapanr ^d (controle-d)

taper en suite les commande :

ls

ls -l

ls -li

relever le numéro d'inode

taper ensuite ln exo exobis

taper cat exobis, puis relever le numéro d'inode et le nombre de référence du fichier exobis.

Conclure

taper rm exo, puis relever le nombre de référence du ficheir exobis. Conclure

taper mv exobis exo

Page 55 sur 63

Exercice 4

Taper les commandes suivante, observer et justifier les résultats

cp exo exo1

ls -l

cat exo1

cat exo1 > exo2

ls -l

cat exo2

rm exo2

ls -l

cat exo1 > exo2

cat exo1> exo2

cat exo2

ls -l

rm -i exo1 exo2

Exercice 5

Créer de la manière la plus courte l'arborescence suivante :

A - B

-D

-E

-C

-F

-G

-copier le fichier Un dans B en lui donnant le même nom

-copier le fichier Deux dans F en lui donnat le nom Trois

-renommer Trois en Quatre, vérifier avec la commande ls -l que vaut le nombre de référence

de Quatre

-Aller dans D et créer un lien dur Quatrebis sur Quatre, que vaut le nombre de référence de

Quatrebis? et de Quatre?

-Quels sont les numéros d'inode de Quatrebis et de Quatre ? Justifier

Page 56 sur 63

-Modifier Quatrebis afin qu'il contienne des caractères quelconques. Visualiser Quatre.

Conclure

Page 57 sur 63

Commandes Linux Aide Mémoire

1- Session de travail

Entrer en ligne

Au lancement du système taper votre identifiant "login" et le mot de passe "password".

Modifier le mot de passe

Taper passwd, suivi de votre ancien mot de passe à la requête "old password" et votre nouveau mot

de passe aux requêtes "new password" et "Retype new password".

Terminer une session

Taper la commande logout.

Pour obtenir de l'aide sur une commande

Taper la commande man nom de la commande désirée.

La commande man intro donne une liste des commandes disponibles sur le système.

Majuscules et minuscules

Dans Unix les caractères majuscules et minuscules sont considérés comme étant différents. Ce qui

implique que la commande man sera reconnue alors que MAN ou Man ne le sera pas. Il en est de

même avec le nom des fichiers.

Date et heure

La commande date permet d'obtenir la date et l'heure du système.

La commande cal année permet d'obtenir un calendrier annuel.

La commande cal mois année permet d'obtenir un calendrier mensuel.

2- Commandes pour gérer les fichiers et les répertoires

Se déplacer dans les répertoires

La commande cd ~ permet de retourner à votre répertoire initial ("home directory").

La commande cd nom-de-répertoire permet de changer de répertoire courant.

La commande pwd affiche le répertoire courant.

Page 58 sur 63

Abréviation des noms de répertoire

~ représente le répertoire initial ("home directory").

. représente le répertoire courant.

.. représente le parent du répertoire courant.

Affichage d'un fichier

cat fichier permet d'afficher le contenu du fichier (référence complète de cat).

more fichier permet d'afficher le contenu du fichier page par page.

tail fichier permet d'afficher les 10 dernières lignes du fichier (référence complète de tail).

head fichier permet d'afficher les 10 premières lignes du fichier (référence complète de head).

od fichier permet d'afficher le contenu du fichier au format octal (référence complète de od).

od -cx fichier permet d'afficher le contenu du fichier au format ASCII et en hexa.

Afficher le contenu de répertoires

ls permet de lister le nom des fichiers et des sous-répertoires présents dans le répertoire courant.

ls répertoire permet de lister le nom des fichiers et des sous-répertoires présents dans "répertoire".

ls -l affiche les résultats d'une façon plus complète.

ls -ld affiche les fichiers et les répertoires avec la même présentation que les fichiers, sans lister leur contenu.

ls -a affiche les fichiers cachés.

ls -F indique le type du fichier c.a.d ficher, répertoire ou lien symbolique.

ls -ltr affiche les fichiers en ordre de date inversée.

ls -l | grep ^d permet de lister uniquement les sous-répertoires présents dans le répertoire courant.

Copier des fichiers

cp fichier nouveau-fichier copie fichier sous le nom nouveau-fichier dans le même répertoire.

cp fichier répertoire/ copie fichier dans le répertoire "répertoire" en conservant le même nom.

cp -p fichier répertoire/ copie fichier dans le répertoire "répertoire" en conservant le même nom et les mêmes protections que le fichier d'origine.

cp -i permet au système de demander une confirmation si le fichier de destination existe déjà.

cp -r fichier répertoire/ copie fichier et les répertoires dans le répertoire "répertoire" en conservant la même structure.

Page 59 sur 63

Création d'un fichier et répertoire

touch fichier permet de changer la date du fichier et aussi de créer un fichier nommé "fichier" qui sera vide.

mkdir répertoire permet de créer un répertoire.

Il est possible de créer des fichiers avec un éditeur et/ou tout autre programme de votre choix.

Déplacer des fichiers

mv fichier nouveau-fichier renomme fichier sous le nom nouveau-fichier dans le même répertoire.

mv fichier répertoire/ déplace fichier dans le répertoire "répertoire".

mv -i permet au système de demander une confirmation si le fichier de destination existe déjà.

mv répertoire nouveau-répertoire renomme un répertoire dans un autre répertoire. (référence complète de mv)

Éditer un fichier

Pour éditer un fichier en mode pleine page, on utilise la commande vi fichier. Un excellent résumé des

commandes est disponible à l'adresse :

http://w3.uqah.uquebec.ca/doc/u_vi.html

Effacer des fichiers

rm fichiers permet d'effacer un ou plusieurs fichiers.

rmdir répertoires permet d'effacer un ou des répertoires vides.

rm -r répertoire permet d'effacer un répertoire et son contenu. À utiliser avec précaution.

Explorer des fichiers et autres commandes sur les fichiers

alias nom commande permet la création de raccourcis ou de synonymes de commandes (par ex.: alias dir ls -lagF).

df -k donne l'espace disque utilisé et libre sur les différentes partitions.

diff fichier1 fichier2 affiche les différences entre deux fichiers.

dos2unix fichier converti le format MS-DOS (\r\n) du fichier en format Unix (\n).

du ou du répertoire donne l'espace utilisé du répertoire et des sous-répertoires. du -s répertoire affiche seulement l'espace total utilisé pour chaque argument en ajoutant un suffixe correspondant à l'unité (K, M, G). (exemple pour Linux: du -sh client). (référence complète de du)

find racine -name 'mot' permet de trouver des fichiers depuis une racine spécifiée.

grep expression fichiers permet de rechercher toutes les occurences de "l'expression" dans "fichiers". grep -i expression fichier permet de faire une recherche sans se préoccuper des

Page 60 sur 63

majuscules/minuscules. Les expressions régulières sont utilisées par plusieurs commandes UNIX dont awk, ed, grep, ex, sed, vi et yacc pour localiser des arrangements de caractères afin d'agir sur ces arrangements. Plusieurs exemples sont disponibles à ce lien. (référence complète de grep)

gzip permet la compression de fichiers ainsi que la décompression d'archives gzip et compress . On reconnaît les archives gzip par leur extension .gz , et les archives compress par leur extension .Z . gzip fichier compresse fichier en fichier .gz . gzip -cf fichier compresse fichier en fichier .gz avec écrasement et conserve la copie originale. gzip -d fichier.gz décompresse fichier.gz en fichier (ou gunzip). référence complète de gzip (anglais)

ln -s fichier_à_lier lien_symbolique permet de lier un fichier distant à un lien symbolique (alias).

tar cvf fichier.tar fichiers rassemble plusieurs fichiers en une seule archive sans compression. tar tvf fichier.tar liste le contenu d'un fichier tar. tar oxvf fichier.tar extrait le contenu d'un fichier tar. tar zxvf fichier.tgz extrait le contenu d'un fichier tgz.

unix2dos fichier converti le format Unix (\n) du fichier en format MS-DOS (\r\n).

wc fichier calcule le nombre de lignes, de mots et de caractères dans le fichier. wc -l fichier calcule le nombre de lignes dans le fichier (référence complète de wc).

Imprimer un fichier

lp fichier permet d'imprimer sur l'imprimante par défaut (unix).

lpd -d imprimante fichier permet d'imprimer le fichier sur l'imprimante de son choix (unix).

lpr -P imprimante fichier permet d'imprimer le fichier sur l'imprimante de son choix. (référence complète de lpr) (Linux).

lpq examine la file d'attente des impressions (Linux). (référence complète de lpq)

Protection des fichiers

La protection des fichiers se décompose en trois parties et de 9 caractères "rw- | r-- | r--". La première partie

fixe les droits de propriété pour le propriétaire du fichier, la deuxième partie fixe les droits accordés aux

utilisateurs faisant partie du groupe auquel appartient le fichier, et la dernière partie fixe les droits des autres

utilisateurs. Dans chaque partie, le premier caractère correspond au droit de lecture ("r"), le deuxième

caractère correspond au droit d'écriture ("w"), le troisième caractère correspond au droit d'exécution ou

d'accès ("x"). Si à la place d'un des caractères nous ne voyons qu'un tiret "-", c'est que le droit n'est pas

autorisé.

Cas particulier l'option ("s") permet d'utiliser l'ID (identification) du propriétaire ou du groupe propriétaire du

fichier lors de la création d'un fichier.

La protection des fichiers s'effectue par la commande chmod protection fichiers. Pour identifier la catégorie de

l'usager :

la lettre "u" pour le propriétaire du fichier;

la lettre "g" pour le groupe d'utilisateur;

la lettre "o" pour les autres utilisateurs;

Page 61 sur 63

et la lettre "a" pour faire référence à tous les utilisateurs.

"+" signifie que c'est une permission supplémentaire et, pour en supprimer une, il suffit de remplacer le signe

"+" par "-". Exemples :

chmod a+w test ----> Tous les utilisateurs obtiennent le droit d'écrire pour le fichier test.

chmod go-wr test ----> Le groupe utilisateur et les autres (sauf le propriétaire) n'ont plus le droit d'écrire et de lire pour le fichier test.

(référence complète de chmod)

La commande chown permet de modifier le propriétaire d'un fichier. Sur la majorité des systèmes, son usage est

réservé au super-utilisateur.

chown utilisateur fichiers ou chown utilisateur:groupe fichiers (exemple: chown jacques test.dat --> Le

propriétaire du fichier test.dat est jacques)

La commande chgrp permet de changer le groupe propriétaire d'un fichier. Seuls le propriétaire et le super-

utilisateur peuvent changer le groupe d'un fichier.

chgrp option groupe fichiers (exemple: chgrp recherche test.dat --> le fichier test.dat appartient au groupe

recherche) (référence complète de chgrp).

Redirection des sorties

nom-de-commande > fichier

Le système dirige les résultats engendrés par la commande dans un fichier au lieu de les afficher à l'écran. Si le

fichier existe déjà, son contenu est remplacé.

nom-de-commande >> fichier Le système dirige les résultats engendrés par la commande dans un fichier au lieu de les afficher à l'écran. Si le

fichier existe déjà, les résultats sont ajoutés à la fin du fichier.

nom-de-commande1 | nom-de-commande2 Le système dirige les résultats engendrés par la commande 1 comme arguments de la commande 2.

Trier un fichier

sort -o fichier.trie fichier trie le fichier en ordre ascendant et place le résultat dans fichier.trie

sort -o fichier.trie +n -m fichier trie le fichier en utilisant +n -m comme clé de tri, ignore les n premiers champs (les champs sont délimités par 1 ou plusieurs espaces) et trie jusqu'au m-ème champ plutôt que jusqu'à la fin de la ligne (exemple d'un tri du fichier fich à partir du troisième champ : sort -o fich.out +2 fich ).

sort -o fichier.trie -r -u fichier trie le fichier en ordre descendant -r et place le résultat dans fichier.trie en enlevant les enregistrements en doubles -u.

3- Commandes pour la manipulation de processus et de jobs

Commande exécute une commande en avant-plan.

Commande & exécute une commande en arrière-plan, plutôt qu'en avant-plan comme on le fait

Page 62 sur 63

habituellement en tapant un & à la fin de la ligne de commande. L'usager peut taper d'autres commandes. Pour voir les travaux en arrière-plan taper la commande jobs.

La commande ps vous permet de voir les tâches exécutées présentement.

La commande kill permet d'arrêter ces mêmes tâches

La commande killall nom permet d'arrêter toutes les tâches portant le même nom

<ctrl-C> la touche <ctrl-C> avorte le job courant (celui qui s'exécute en avant-plan) et fait revenir le shell en avant-plan.

<ctrl-Z> la touche <ctrl-Z> avorte le job courant (celui qui s'exécute en avant-plan) et fait revenir le shell en avant-plan.

jobs liste les jobs du shell courant.

bg %jobID ou %jobID & continue en arrière-plan [background] le dernier job suspendu ou celui de jobID spécifié.

top affiche en continu les processus actifs et l'état de la mémoire.

4- Autres commandes

Commandes intéressantes

crontab -options permet d'effectuer des opérations à heures fixes (options: -l = liste, -e = éditer). Le format des champs de date et heure sont :

champs valeurs autorisées

----- --------------

minute 0-59

heure 0-23

jour du mois 0-31

mois 0-12 (ou noms, voir plus bas)

jour de semaine 0-7 (0 et 7 sont dimanche, ou 1=lundi, 2=mardi,

...)

Un champ peut contenir un astérisque (*), qui correspond

à l'intervalle du premier au dernier.

Les intervalles de nombres sont permis.

Ils se présentent sous forme de deux nombres séparés

par un tiret.

Les bornes sont incluses.

Par exemple, l'intervalle horaire 8-11 correspond

à une exécution aux heures 8, 9, 10, et 11.

Les listes sont permises.

Une liste est une série de nombres ou d'intervalles séparés

par des virgules.

Exemple ''1,2,5,9'', ''0-4,8-12''.

Exemple de fichier Crontab :

# on change l'image et les nouvelles toutes les 5 minutes

Page 63 sur 63

0,5,10,15,20,25,30,35,40,45,50,55 * * * * /Pr/Nouvelles

# on fait les statistiques mensuelles à 4 heures et 5 minutes

5 4 1 * * /data/www/Prog/stats

id retourne l'identification de l'usager.

who affiche la liste des utilisateurs connectés

Note: Ces commandes sont optimisées pour le système d'exploitation SOLARIS 2.X de SUN. Il peut y avoir de

petites incohérences si vous utilisez un autre système d'exploitation. Les commandes fonctionnent dans le

mode cshell d'Unix, certaines commandes (~, alias ...) ne fonctionnent pas dans les autres modes (Shell)

d'Unix .