Administration & Sécurité des

Systèmes d’Exploitation UNIX

Année Universitaire
2021-2022
Chapitre1: Programmation
Shell
 Shell
Qu'est-ce qu'un shell ?
• Un shell est un programme qui
fournit une interface à l'utilisateur
pour utiliser les services du système
d'exploitation.
• Shell accepte les commandes par
l'utilisateur et les convertit en
quelque chose que le noyau peut
comprendre.
 Shell
• il existe différents types d’ interpréteurs de commandes « Shell » :
✓ sh: Bourne Shell
✓ bash: Bourne again ShelL
✓ ksh: Korn Shell
✓ csh: C Shell
• Pour lister tous les shells disponibles dans votre système:
$ cat /etc/shells
• Pour installer un nouveau shell:
#yum install ksh
#apt-get install ksh
• Pour changer le shell on execute commande:$chsh
 Script Shell
Les scripts Shell sont utilisés:

❖ Assembler des commandes simples pour réaliser des actions

complexes

❖ Regrouper des actions que l'on désire exécuter plus d'une fois

❖ Réaliser un outil à mettre à la disposition de plusieurs personnes

Remarque: un script est un programme interprété et non compilé.

 Script Shell

❖ Un script shell est un fichier qui contient:

✓ commandes shell
✓ variables
✓ structure de contrôle
✓ fonctions
❖ Ajout d’une ligne “ shebang” :
#! /bin/bash
#! /bin/sh
la ligne « shebang »indique au système d'exploitation que ce fichier
est un script et spécifie l'interpréteur utilisé pour exécuter ce script.
 Script Shell
• Ajouter le droit d’exécution : • Pour déboguer un script :

$ chmod +x your-script-name $ bash –x test.sh:

• Exécuter un script : • Pour exécuter un script depuis

bash your-script-name n’importe quel répertoire sans (./)

sh your-script-name devant, il faut le placer dans l’un

./your-script-name des répertoires du PATH

#echo $ PATH
 Déclaration des variables
❖ création un nouveau script variables.sh :
$ vim variables.sh

❖ indiquer le shell utilisé pour interpréter le script .

#!/bin/bash

❖ définition des variables.

➢ Créez une nouvelle variable en utilisant la syntaxe suivante

➢ Syntaxe : variable_nom= variable_valeur

#!/bin/bash
message='Bonjour ESPRIT '

❖ Exécution du script
$ ./variables.sh
 echo : affichage des variables
❖ La commande echo permet d'afficher une ligne.

$ echo Salut ESPRIT

Salut ESPRIT

➢ lors de l’insertion des retours à la ligne, il faut activer le paramètre -

e et utiliser le symbole \n :

$ echo -e "Message\n Autre ligne"

Message
Autre ligne

❖ Afficher une variable

#!/bin/bash
message='Bonjour ESPRIT‘
echo $message
 echo : affichage des variables
❖ Affichage du texte et variable.
#!/bin/bash
message='Bonjour Esprit'
echo 'Le message est : $message' Le message est : $message

Pourquoi la variable message n'est-il pas analysé ?

➢ Il existe trois types de quotes :

•les apostrophes ' ' (simples quotes)
•les guillemets " " (doubles quotes)
•les accents graves ` ` (back quotes)
 les « quotes »
❖ Avec de simples quotes, la variable n'est pas analysée :
#!/bin/bash
message='Bonjour Esprit' Le message est : $message
echo 'Le message est : $message'

❖ les doubles quotes demandent à bash d'analyser le contenu du message s'il

trouve des symboles spéciaux (comme des variables), il les interprète.

#!/bin/bash
message='Bonjour Esprit' Le message est : Bonjour Esprit
echo " Le message est : $message "

❖ les back quotes demandent à bash d'exécuter ce qui se trouve à l'intérieur.

#!/bin/bash
message=`pwd` Vous êtes dans /home/Esprit
echo "Vous êtes dans $message"
 read : saisie des variables
❖ La commande read lit son entrée standard et affecte les valeurs
saisies dans la ou les variables passées en argument.
#!/bin/bash
read nom
echo "Bonjour $nom "

❖ Affecter simultanément une valeur à plusieurs variables

#!/bin/bash
read nom prenom
echo "Bonjour $nom $prenom"

❖ afficher un message de prompt

#!/bin/bash
read -p 'Entrez votre nom : ' nom
echo "Bonjour $nom "
Exemple
 Les variables d'environnement
❖ une variable définie dans un programme A ne sera pas utilisable
dans un programme B.
❖ Les variables d'environnement sont des variables que l'on peut
utiliser dans n'importe quel programme. On parle aussi parfois
de variables globales.
➢ la commande env : $ printenv
PATH=:/usr/share/glade3/pixmaps
TERM=xterm
SHELL=/bin/bash
USER=ESPRIT
PATH=/home/esprit/bin:/usr/local/sbin:/usr/l
ocal/bin:/usr/sbin: PWD=/home/mateo21/bin
EDITOR=nano
HOME=/home/esprit
Les variables d'environnement
•SHELL : indique quel type de shell est en cours d'utilisation (sh,
bash, ksh…) ;
•PATH : une liste des répertoires qui contiennent des exécutables que
vous souhaitez pouvoir lancer sans indiquer leur répertoire.
•EDITOR : l'éditeur de texte par défaut qui s'ouvre lorsque cela est
nécessaire ;
•HOME : la position de votre dossier home ;
•PWD : le dossier dans lequel vous vous trouvez ;

#!/bin/bash
Votre éditeur par défaut est nano
echo "Votre éditeur par défaut est $EDITOR"
 Les variables d'environnement
❖ Création des variables d'environnement

❖ Utilisation des variables d'environnement

 Exercice 1
❖ Ecrire un programme shell mon_rep qui affiche le nom de
connexion de l'utilisateur et le chemin absolu de son répertoire
courant de la manière suivante :

Ex : $ mon_rep Mes paramètres:

mon nom de connexion est : xxxx
mon répertoire courant est:
/home/xxxx

❖ Lancer l’exécution du fichier: $bash mon_rep

 Les variables spéciales
❖ Le script shell récupère les arguments de la ligne de
commande dans des variables réservées appelées
paramètres positionnels
$# Nombre d’arguments reçus par le script
$0 Le nom du script lui-même
$1 $2 … $9 ${10} $1 est la valeur du premier argument, $2 la valeur
du second….
$* Liste des arguments

Le Nombre
$0 d’arguments
Le 1er argument $1
 Exercice 2
❖ Ecrire un programme shell test1 qui affiche le message "Entrez votre
prénom: ", lit le prénom saisi par l'utilisateur puis affiche ce mot deux fois
sur la même ligne.

❖ Par la suite demande à l'utilisateur de saisir une suite quelconque de mots

puis affiche le nombre de mots saisis.

❖ Ex : $ test1
Entrez votre prénom: toto toto toto
Entrez une suite de mots : un deux trois quatre cinq
Vous avez saisi 5 mots
 Tableaux
❖ Plusieurs méthodes pour créer un tableau

➢ Directement :
nom-tableau=(valeur0 valeur1 ...)

➢ Autre syntaxe :
nom-tableau=([indice0]=valeur0 [indice1]=valeur1 ...)

❖ Assigner un élément
nomtableau[indice]=valeur
$ tab[0]=10 $ tab[2]=12

❖ Affichage de les éléments d’indice 0 et d’indice 2:

$ echo ${tab[0]}
10
$ echo ${tab[2]}
12
 Tableaux
❖ Valeurs de toutes les cases

➢ Tous les éléments d'un tableau sont accessibles avec chacune de

ces deux syntaxes :
${nom-tableau[*]} ${nom-tableau[@]}

❖ Nombre d'éléments d'un tableau

➢ Le nombre d'éléments d'un tableau est accessible par chacune de

ces deux syntaxes :
${#nomtableau[*]} ${#nomtableau[@]}
 Tableaux
❖ Ajout d’un élément à un tableau:
tableau[${#tableau[*]}]=élément
 Tableaux
❖ Ajout d’un élément au début d'un tableau :
tableau=( element ${tableau[*]} )

unset nom-tableau
❖ supprimer un tableau :

❖ supprimer la case d'un tableau : unset nom-tableau[indice] …

 Expr : arithmétique
❖ expr :permet d'évaluer des expressions, notamment pour faire des
opérations arithmétiques ou des comparaisons de chaînes de
caractères .

❖ Les opérateurs arithmétiques sont :

❖ + : addition ;

❖ - : soustraction ;

❖ \* : multiplication ;

❖ / : division entière ;

❖ % : reste de la division ;

❖ \( et \) : parenthèses.
 Expr : manipulation des chaînes
❖ Longueur de chaînes de caractères

➢ ${#chaine}

➢ expr length $chaine

❖ Longueur de sous-chaînes correspondant à un motif au début d'une

chaîne

➢ expr match "$chaine" '$souschaine‘

➢ expr "$chaine" : '$souschaine'

 Expr : manipulation des chaînes
❖ Extraction d'une sous-chaîne

➢ expr substr $chaine $position $longueur

➢ Extrait $longueur caractères à partir de $chaine en commençant à

$position.
 Expr : manipulation des chaînes
❖ Remplacement de sous-chaîne

➢ ${chaine/souschaine/remplacement}

➢ Remplace la première correspondance de $souschaine par $remplacement.

➢ ${chaine//souschaine/remplacement}

➢ Remplace toutes les correspondances de $souschaine avec $remplacement.

 Les structures conditionnelles test

La fonction test permet d’exprimer une condition ou

plusieurs:
➢ Sur des fichiers

➢ Sur des nombres

➢ Sur des chaînes de caractères

Les structures conditionnelles test sur
les fichiers 1/2
test -e <nom_fichier> : vrai si l’argument existe

test -f <nom_fichier> : vrai si l’argument est un fichier ordinaire

test -d <nom_fichier> : vrai si l’argument est un répertoire

test -L <nom_fichier> : vrai si l’argument est un lien symbolique

test -r <nom_fichier> : vrai si on a le droit de lire le fichier

test -x <nom_ficher> : vrai si on a le droit d’exécuter le fichier

test -w <nom_ficher> : vrai si on a le droit d’écrire dans le fichier

test -s <nom_fichier> : vrai si l’argument existe et non vide

Les structures conditionnelles test sur
les fichiers 2/2

Afficher le code de retour de

la fonction test
0: test vrai
1: test faux
 Les structures conditionnelles test sur les
nombres 1/2
Pour les expressions arithmétiques, les opérateurs sont:
- eq , -ne, - lt, -le, -gt ,-ge
équivalent, différent, inférieur strictement, inférieur ou égale, supérieur
strictement, supérieur ou égale
test "i1" -eq "i2": Teste si i1 est égal à i2
test "i1" -ne "i2": Teste si i1 n'est pas égal à i2
test "i1" -gt "i2": Teste si i1 est plus grand que i2
test "i1" -lt "i2": Teste si i1 est inférieur à i2
test "i1" -ge "i2": Teste si i1 est plus grand ou égal à i2
test "i1" -le "i2": Teste si i1 est inférieur ou égal à i2
Les structures conditionnelles test sur les
nombres 2/2
Les structures conditionnelles test sur les
chaînes de caractères 1/2

test -n "string" : Teste si la longueur de la chaîne string est

différente de zéro

test -z "string": Teste si la chaîne string est égale à zéro

test "s1" = "s2": Teste si la chaîne s1 est égale à s2

test "s1" != "s2": Teste si la chaîne s1 n'est pas égale à s2

Les structures conditionnelles test sur les
chaînes de caractères 2/2
 Les structures conditionnelles test vs [ ]

test –e fichier [ –e fichier ]

test $v1 –eq $v2 [ $v1 –eq $v2 ]
test $chaine1 = $chaine2 [ $chaine1 = $chaine2 ]
 Combinaison de conditions

! : Condition Not [ ! –d /etc/group ]

-a : Condition AND [ -f script.sh -a -x script.sh ]

-o : Condition OR [ -d script.sh -o -x script.sh ]

\( \) : pour traiter un groupe d’expressions

[ -w script.sh -a \( -e fich -o -e fich7 \) ]

 Effectuer plusieurs tests à la fois

OR = || test –f file || echo « le fichier file n’existe pas »

[ -f file ] || echo « le fichier file n’existe pas »

AND = && test -f file && echo « le fichier file existe »

 Les structures conditionnelles if 1/2
Syntaxe 2
if condition 1
Syntaxe 1 Syntaxe 3 Syntaxe 4
then
if condition if condition 1 if condition ; then
Traitement 1
then
then Traitement
Traitement 1 else if condition 2
else Traitement 1 fi
then
Traitement 2 If condition 2
Traitement 2
fi then
else if condition 3
Traitement 2
then
else Traitement 3
traitement 3
fi
fi
fi
fi
Les structures conditionnelles if 2/2
Les structures conditionnelles case 1/2

case $variable in
expr1) commandes ;;
expr2) commandes ;;
.
.
.
.
*) par_défault ;;
esac
Les structures conditionnelles case 2/2
Les structures itératives for 1/3

for variable [in liste]

do
commandes (utilisant $variable)
done
Les structures itératives for 2/3
Les structures itératives for 3/3
 Commande seq 1/2
for i in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
do
echo $i
done

Très pénible ! Pour itérer par exemple 250 fois,

vous devez saisir tout cela au clavier !
Heureusement, il y a un « raccourci », la
commande seq, qui affiche une séquence de
nombres allant de 1 jusqu'au maximum
indiqué
Commande seq 2/2
 Les structures itératives while, until
while commande 1

do

commandes

done

La boucle while permet d'exécuter les commandes présentes entre le do et le done tant que

la commande1 placée à droite du while retourne un code vrai.

until commande1

do

commandes

done

la commande until exécute les commandes situées entre le do et le done tant que la

commande1 située à droite du until retourne un code faux.

 les fonctions
Une fonction est un bloc de code qui implémente un ensemble
d'opérations.
function nom_fonction {
commande...
}
Ou
nom_fonction () {
commande...
}
❖ Les fonctions sont appelées, lancées, simplement en invoquant leur
noms.
 Fonctions(2)

❖ Les fonctions peuvent récupérer des arguments qui leur sont

passés et renvoyer un code de sortie au script pour utilisation
ultérieure.

nom_fonction $arg1 $arg2

❖ La fonction se réfère aux arguments passés par leur position
(comme s'ils étaient des paramètres positionnels), c'est-à-
dire $1, $2 et ainsi de suite.
 Fonction avec des paramètres
#!/bin/bash
usage() {
echo "Usage: $0 filename"
exit 1
}
file_exits() {
test -f "$1" && return 0 || return 1
}
test $# -eq 0 && usage
if file_exits "$1"
then
echo "File found"
else
echo "File not found
fi
 Code de retour d’une fonction

❖ code de retour: Les fonctions renvoient une valeur, appelée

un code (ou état) de retour . Le code de retour peut être
explicitement spécifié par une instruction return, sinon, il s'agit
du code de retour de la dernière commande de la fonction (0 en
cas de succès et une valeur non nulle comprise entre 1 et 255).

❖ le code retourné par une fonction est récupérable grâce à la

variable $?.
 Terminaisons

❖ un script : exit n (n = code de retour indiquant succès ou

échec).
❖ une fonction : return n (n = code de retour indiquant
succès ou échec).
❖ une boucle : break
 Exemple :
#!/bin/bash
E_PARAM_ERR=250 # Si moins de deux paramètres passés à la fonction.
EGAL=251 # Code de retour si les deux paramètres sont égaux.
max () # Envoie le plus important des deux entiers.
{
if [ -z "$2" –o –z "$1" ]
then
return $E_PARAM_ERR
fi

if [ "$1" -eq "$2" ]

then
return $EGAL
else
if [ "$1" -gt "$2" ]
then
return $1
else
 Exemple (suite)

Max 33 34 #appel de la fonction.

return_val=$?

if [ "$return_val" -eq $E_PARAM_ERR ]

then
echo "Vous devez donner deux arguments à la fonction."
elif [ "$return_val" -eq $EGAL ]
then
echo "Les deux nombres sont identiques."
else
echo "Le plus grand des deux nombres est $return_val."
fi

exit 0