Essentiels laboratoire Linux - Wiwishack

Transcription

Laboratoire-linux
Essentiel Administration Système
Prépa 1
Auteur : Labo-linux
Relecture : Marc Pybourdin et Hermantino Singodiwirjo
Version 1.0 – 26 novembre 2004
SUPINFO - Ecole Supérieure d’Informatique de Paris
23. rue de Château Landon 75010 Paris
Site Web : http://www.supinfo.com
Laboratoire SUPINFO des Technologies Linux
Site Web : www.labo-linux.org – E-mail : [email protected]
Ce document est la propriété de SUPINFO et est soumis aux règles de droits d’auteurs
Essentiel Administration Système - Prépa 1
2 / 81
Table des matières
1.
Préambule.........................................................................................................................................5
2.
Première approche du système.......................................................................................................6
2.1. Les terminaux .....................................................................................................................................................6
2.2. Le shell................................................................................................................................................................6
2.3. Utilisation de l'aide .............................................................................................................................................7
2.3.1. Les pages de manuel ou man pages..............................................................................................................7
2.3.2. Aide simplifiée .............................................................................................................................................7
3.
Commandes de base ........................................................................................................................8
3.1. Opérations sur les fichiers et répertoires.............................................................................................................8
3.2. Affichage du contenu d’un fichier ......................................................................................................................8
3.3. Noms, attributs des fichiers et globbing .............................................................................................................8
3.3.1. Noms des fichiers .........................................................................................................................................8
3.3.2. Attributs des fichiers ....................................................................................................................................9
3.4. Le globbing .........................................................................................................................................................9
3.5. L'éditeur Vim ....................................................................................................................................................10
3.5.1. Appel de l’éditeur.......................................................................................................................................10
3.5.2. Modes d’édition..........................................................................................................................................10
3.5.3. Mode Edition..............................................................................................................................................11
3.6. Archivage et compression avec tar, gzip et bzip2.............................................................................................11
3.6.1. Créer des archives avec tar.........................................................................................................................11
3.6.2. gzip .............................................................................................................................................................12
3.6.3. bzip2 ...........................................................................................................................................................13
3.7. Recherche de fichiers........................................................................................................................................13
3.7.1. find .............................................................................................................................................................13
3.7.2. slocate – locate ...........................................................................................................................................14
3.8. "Pipes" et Redirections .....................................................................................................................................14
3.8.1. Les flux standards.......................................................................................................................................14
3.8.2. Redirections................................................................................................................................................15
3.8.3. Pipes ...........................................................................................................................................................16
4.
Organisation du FHS.....................................................................................................................17
4.1. FHS ...................................................................................................................................................................17
4.1.1. Arborescence de "/"....................................................................................................................................17
4.1.2. Arborescence de /usr ..................................................................................................................................17
4.1.3. Arborescence de /var ..................................................................................................................................17
5.
Gestion des utilisateurs et groupes...............................................................................................19
5.1. Les utilisateurs ..................................................................................................................................................19
5.1.1. Le fichier /etc/passwd.................................................................................................................................19
5.1.2. Le fichier /etc/shadow ................................................................................................................................20
5.2. Les Groupes ......................................................................................................................................................20
5.3. Les commandes de gestion des utilsateurs........................................................................................................20
5.3.1. Ajouter un utilisateur..................................................................................................................................20
5.3.2. Suppression d'un utilisateur........................................................................................................................22
5.3.3. Changer le mot de passe d'un utilisateur ....................................................................................................22
5.3.4. Afficher des informations sur un utilisateur...............................................................................................22
5.4. Les commandes de gestion des groupes ...........................................................................................................23
5.4.1. Créer un groupe..........................................................................................................................................23
5.4.2. Suppression d'un groupe.............................................................................................................................23
5.4.3. Modifier les groupes secondaires d'un compte...........................................................................................23
3 / 81
5.4.4. Afficher des informations sur les groupes..................................................................................................23
5.5. Changer d'identité .............................................................................................................................................24
6.
Les permissions ..............................................................................................................................25
6.1. Propriétaire........................................................................................................................................................25
6.1.1. Changer l'appartenance d’un fichier...........................................................................................................25
6.1.2. Changer le groupe propriétaire...................................................................................................................25
6.2. Les droits ..........................................................................................................................................................26
6.2.1. Modifier les droits ......................................................................................................................................26
6.3. Umask ...............................................................................................................................................................27
6.4. Les droits spéciaux............................................................................................................................................28
6.4.1. Le bit SUID ................................................................................................................................................28
6.4.2. SGID ..........................................................................................................................................................28
6.4.3. Le Sticky bit ...............................................................................................................................................28
7.
Composants de base d’un système Linux ....................................................................................30
7.1. Configuration et compilation d’un noyau Linux...............................................................................................30
7.1.1. Préambule...................................................................................................................................................30
7.1.2. Pourquoi recompiler son noyau ?...............................................................................................................31
7.1.3. Note sur les modules ..................................................................................................................................31
7.1.4. Configuration et compilation......................................................................................................................31
Noyaux 2.4.x ...........................................................................................................................................................33
Noyaux 2.6.x ...........................................................................................................................................................33
7.1.5. Quelques compléments...............................................................................................................................33
7.2. Le boot loader ...................................................................................................................................................34
7.2.1. Lilo .............................................................................................................................................................35
7.2.2. GRUB.........................................................................................................................................................35
7.2.3. Boot loader sur disquette............................................................................................................................36
7.3. Schéma de lancement de services au démarrage ..............................................................................................37
7.3.1. Le fichier inittab .........................................................................................................................................37
7.3.2. Introduction à la notion des services ..........................................................................................................38
7.3.3. Gestion des services ...................................................................................................................................39
8.
Gestion des disques ........................................................................................................................43
8.1. Les disques durs sous Linux .............................................................................................................................43
8.1.1. Partitions.....................................................................................................................................................43
8.1.2. Accès aux périphériques de stockage .........................................................................................................45
9.
Gestion des processus ....................................................................................................................47
9.1. Introduction à la notion de processus................................................................................................................47
9.2. Envoi de signaux aux processus .......................................................................................................................48
9.3. Arrière-plan, premier plan et détachement .......................................................................................................49
9.4. Modification des priorités du Scheduler ...........................................................................................................49
9.5. Planification de tâches ......................................................................................................................................50
9.5.1. La commande crontab ................................................................................................................................50
9.5.2. Le fichier crontab système .........................................................................................................................51
9.5.3. La commande at .........................................................................................................................................51
10.
Gestion réseau ................................................................................................................................53
10.1. Configuration Automatique ..............................................................................................................................53
10.2. Configuration manuelle ....................................................................................................................................53
10.2.1. Les interfaces et la commande ifconfig......................................................................................................53
10.2.2. Les routes ...................................................................................................................................................54
10.2.3. La résolution de nom..................................................................................................................................55
4 / 81
10.3. Les outils de tests réseau...................................................................................................................................55
10.3.1. Ping ............................................................................................................................................................55
10.3.2. Traceroute...................................................................................................................................................56
10.3.3. Netstat.........................................................................................................................................................56
11.
Installation de programmes ..........................................................................................................57
11.1. L’approche Redhat............................................................................................................................................57
11.1.1. Comment obtenir ces Paquetages ? ............................................................................................................57
11.1.2. Installation, désinstallation de paquetage...................................................................................................57
11.1.3. Création d'un rpm à partir des sources rpm................................................................................................58
11.2. L’approche Debian ...........................................................................................................................................58
11.2.1. Installation, désinstallation, informations, mise à jour...............................................................................59
11.2.2. Création d'un fichier deb à partir des sources dsc ......................................................................................60
11.3. L’approche Gentoo ...........................................................................................................................................60
11.3.1. Installation, désinstallation, informations sur les paquetages ....................................................................61
11.4. Installation par les sources ................................................................................................................................61
12.
Scripting Bash ................................................................................................................................63
12.1. Introduction.......................................................................................................................................................63
12.2. Création et invocation d'un script .....................................................................................................................63
12.2.1. Création d'un script.....................................................................................................................................63
12.2.2. Invocation d'un script .................................................................................................................................63
12.3. Commentaires et taches de fond : .....................................................................................................................64
12.4. Valeur retournée par un script shell à la fin de son execution ..........................................................................65
12.5. Commandes d'un shell-script ............................................................................................................................65
12.5.1. Commandes simples...................................................................................................................................65
12.5.2. Commandes composées .............................................................................................................................65
12.6. Affichage à l'écran ............................................................................................................................................67
12.7. Lecture au clavier..............................................................................................................................................67
12.8. La commande select..........................................................................................................................................68
12.9. Redirections des entrées-sorties standard .........................................................................................................69
12.10.
Variables et paramètres .............................................................................................................................70
12.10.1.Variables.....................................................................................................................................................70
12.10.2.Paramètres ..................................................................................................................................................71
12.11.
Calcul mathématique.................................................................................................................................72
12.12.
Les structures conditionnelles ...................................................................................................................73
12.12.1.Les conditions ............................................................................................................................................73
12.12.2.Les tests ......................................................................................................................................................73
12.12.3.Tests sur les entiers ....................................................................................................................................74
12.12.4.Tests sur les chaînes ...................................................................................................................................74
12.12.5.Combinaison de tests..................................................................................................................................74
12.12.6.Structure Si...Alors...Sinon.........................................................................................................................74
12.12.7.Structure TantQue ......................................................................................................................................75
12.13.
Autres structures exécutives......................................................................................................................77
12.13.1.Structure Pour.............................................................................................................................................77
12.13.2.Structure Selon ...........................................................................................................................................77
12.13.3.Structure Lorsque .......................................................................................................................................79
12.14.
Fonctions ...................................................................................................................................................80
5 / 81
1. Préambule
Unix est né en 1969 de la volonté de Ken Thompson et Dennis
Ritchie, issus de Bell Labs, de faire un système d'exploitation à
la fois multitâches et Multi-Utilisateurs.
Il était également question de concevoir de petits programmes ne
faisant qu'un nombre limité de tâches, mais pouvant interagir
entre eux.
Depuis cette période, une grande quantité d'Unix ont vu le jour
dont, parmi eux des Unix gratuits, comme celui de l'université de
Berkeley dont sont dérivés les célèbres OpenBSD, NetBSD,
FreeBSD...
Fig 1. Ken Thompson et Dennis Ritchie
À partir des systèmes Unix fut développé le concept de GNU/Linux (GNU : Gnu is Not Unix) fut mis en place à
partir de 1991 par un étudiant finlandais, Linus Torvalds. Linux a su garder, au fil de ses évolutions, l'héritage des
tout premiers systèmes Unix
Parallèlement à cela, une philosophie nouvelle est apparue concernant le partage des connaissances, protégée par
une licence qui garantirait la transparence des fichiers sources et la possibilité de les modifier.
C'est la naissance de la GPL ("Gnu Public License") et de la FSF ("Free Software Foundation") toutes deux fondées
par Richard Stallman.
6 / 81
2. Première approche du système
2.1. Les terminaux
Les systèmes Unix/Linux furent à l'origine conçus pour fonctionner en mode texte, sans interface graphique.
Bien qu'aujourd'hui de nombreuses interfaces graphiques permettant de configurer le système ont été développées,
celui ci demeure totalement administrable en ligne de commande (CLI - Command Line Interface), cette méthode
restant la plus simple et la plus puissante.
Cette ligne de commande est accessible via les terminaux qui jouent le rôle d'interface utilisateur/machine. Dans ce
terminal, l’utilisateur interagit avec le système en utilisant un interpréteur de commandes : le shell.
Note :
Il est possible de se connecter sur plusieurs terminaux via la combinaison des touches Alt+Fn où Fn est une touche
de fonction (Ex : F1,F2...).
Depuis un environnement graphique, il est possible de revenir sur un terminal via la combinaison des touches
Ctrl+Alt+Fn. Pour revenir au mode graphique, il faut en général utiliser la combinaison Alt+F7.
Afin de pouvoir accéder au terminal, vous devez au préalable vous identifier grâce à un couple login/mot de passe.
En fonction de cela, vous aurez accès à plus ou moins de programmes sur le système.
On distingue principalement 2 types de comptes utilisables sur le système :
• Le compte utilisateur classique
• Le compte root (Administrateur)
Un symbole de l'invite de commande vous permet de determiner le type de compte que vous utilisez.
• Accés simple utilisateur :
user@localhost $
•
Accés root :
root@localhost #
2.2. Le shell
Le rôle du shell est d'assurer la correspondance entre ce que l'utilisateur tape et le système. Il en existe de
nombreuses versions. Le plus connu d'entre eux ; bash ; est celui que nous utiliserons pendant ce cours.
Chacun des shells existant dispose de ses propres spécificités. Le choix du shell dépend alors des fonctionnalités
offertes par celui-ci, et donc de l'utilisation que l'on souhaite en avoir.
Nom
bash
csh
ksh
sh
tcsh
zsh
7 / 81
Description
(Bourne Again Shell) Offre l'édition de la ligne de commande et le rappel des commandes
précédentes.
(C Shell) Développé à Berkeley, compatible avec le shell Bourne. Il n’offre pas d'édition
de la ligne de commande ni d'historique.
(Korn Shell) offre l'édition de la ligne de commande (touches compatibles Emacs)
Le shell original de Steve Bourne, pas d'édition de la ligne de commande.
Version améliorée du csh, avec un support de l'édition de la ligne de commande avec
correction des commandes tapées.
Shell similaire au Korn shell, avec plus de dynamisme lors des affichages et gère la non
redondance des commandes.
Fig 2. Les différents shells et leurs caractéristiques
Un système Unix/Linux fonctionne à l'aide d'une multitude de programmes qui assurent, en général, chacun une
fonction bien distincte et sont capables de communiquer au sein du shell.
2.3. Utilisation de l'aide
2.3.1. Les pages de manuel ou man pages
Sur un système Unix/Linux, la plupart des logiciels sont installés avec un manuel accessible par la commande man.
La syntaxe est la suivante :
man fonction_ou_commande
Note :
La commande : man man donne des informations sur l'utilisation du manuel en général.
La commande man peut également être utilisée pour rechercher un terme dans l'ensemble des pages de manuel,
grâce à l'option –k
user@localhost $ man -k "disk space"
Commande
Espace
Entrée
b
/mot
q
Description
Avance dans le manuel d'une page entière
Avance dans le manuel d'une ligne
Recule dans le manuel d'une page
Recherche mot dans le manuel. Ce peut être un nom ou une expression régulière
Quitte le manuel
Fig 3. Les commandes de navigation de man
2.3.2. Aide simplifiée
Il est également possible d'obtenir un résumé du manuel via l'option --help.
user@localhost $ df --help
Usage: df [OPTION]... [FILE]...
Show information about the filesystem on which each FILE resides,
-B, --block-size=SIZE use SIZE-byte blocks
Output truncated…
Celle-ci permet donc de voir rapidement ou encore de vérifier l'existence d'une option.
8 / 81
3.
Commandes de base
3.1. Opérations sur les fichiers et répertoires
Commande
cd rep
ls rep
cp source destination
mv source destination
mkdir rep
rm fichier
ln source destination
touch fichier ou repertoire
Description
Se déplace vers le répertoire rep
Liste le contenu d’un répertoire (ls -R rep pour un listage
récursif)
Copie un fichier source vers un fichier destination (cp -R
pour copier un répertoire)
Déplace un fichier source vers une destination (sert aussi à
renommer un fichier)
Crée un répertoire nommé rep
Efface un fichier (rm -rf rep pour effacer un répertoire)
Crée un lien destination qui va pointer sur une source (ln –s
source destination pour un lien symbolique)
Met à jour la date de modification du fichier, ou crée un
fichier vide si le fichier n’existe pas
MsDos
cd rep
dir
copy
move
mkdir rep
del / deltree fichier
non disponible
non disponible
Fig 4. Manipulations de base sur les fichiers
3.2. Affichage du contenu d’un fichier
Commande
cat fichier
more fichier
less fichier
tail fichier
head fichier
grep "chaine" fichier
Description
Affiche le contenu du fichier sur la sortie standard
Lit le contenu d’un fichier page par page. (Il doit lire l’intégralité du
fichier avant de l’afficher)
Equivalent à more sauf qu’il n’est pas obligé de lire l’intégralité du
fichier avant affichage et permet de remonter dans l'affichage
N’affiche que les dernières lignes d’un fichier (tail -n nombre fichier :
permet de spécifier le nombre de lignes à afficher)
Comme tail, mais affiche les N premières lignes d’un fichier (N=10 par
défaut, head –n nombre fichier pour préciser le nombre de lignes)
Recherche l’occurence de la chaine de caractères "chaine" dans un ou
plusieurs fichiers
Fig 5. Les commandes d’affichage de contenu de fichier
3.3. Noms, attributs des fichiers et globbing
3.3.1. Noms des fichiers
Les noms de fichiers sont "case sensitives", c’est à dire qu’ils tiennent compte des majuscules et des minuscules. Le
nom d’un fichier peut contenir jusqu’à 255 caractères.
Pour accéder à un fichier comportant des caractères spéciaux dans son nom, on doit placer le nom du fichier entre
guillemets (ou utiliser des backslash avant les caractères spéciaux) :
user@localhost $ ls –l "ceci est un test.txt"
user@localhost $ ls –l ceci\ est\ un\ test.txt
9 / 81
3.3.2. Attributs des fichiers
Note :
Pour lister le contenu d’un répertoire, nous utiliserons la commande ls
Afin de disposer de plus d'informations, nous ajouterons l’option –l
Un ensemble d’attributs sont ajoutés au nom du fichier afin de définir, entre autre, le type de fichier ainsi que les
permissions qui lui sont associées.
luser@localhost $ cd /tmp
luser@localhost $ mkdir un_repertoire
luser@localhost $ touch un_fichier
luser@localhost $ ln -s un_fichier un_lien
luser@localhost $ ls
un_fichier un_lien un_repertoire
luser@localhost $ ls -l
total 4
-rw-r--r-- 1 luser lgroup 10 Dec 3 00:42 un_fichier
lrwxrwxrwx 1 luser lgroup 10 Dec 3 00:43 un_lien -> un_fichier
drwxr-xr-x 2 luser lgroup 4096 Dec 3 00:42 un_repertoire
Attribut
d
l
Description
Fichier ordinaire
Répertoire
Lien symbolique
Fig 6. Les attributs de fichiers
Les caractères suivant celui définissant le type de l’objet (fichier, répertoire ou lien) montrent les permissions de cet
objet et seront expliqués plus tard dans ce cours.
Note :
Les fichiers cachés sont les fichiers dont le nom commence par un ".". Pour les afficher, utilisez l’option –a de la
commande ls. Par exemple le fichier nommé ".test" est un fichier caché. Cela marche de la même manière
pour les répertoires.
3.4. Le globbing
Au sein du shell, le globbing permet à l’utilisateur de désigner plus d’un motif à la fois grâce à l’utilisation de
caractères spéciaux tels que "*", "?".
• *: correspond à aucun ou plusieurs caractères
• ? : correspond à un caractère
• [a-z] : correspond à un ensemble de caractères. Ici ce sont tous les caractères alphabétiques entre la lettre "a" et
la lettre "z" minuscule.
• [^a-z] : correspond à tous les caractères sauf ceux de cet ensemble. Ici ce sera donc tous les caractères sauf
ceux entre la lettre "a" et la lettre "z" minuscule. La lettre "A" est donc comprise dans cet ensemble.
Voici la liste des fichiers utilisés pour l'exemple :
user@localhost $ ls
index.htm sommaire.htm
t0st.c
table.htm
test.c
On affiche tous les fichiers finissant par ".htm"
10 / 81
user@localhost $ ls *.htm
index.htm sommaire.htm table.htm
On affiche tous les fichiers sauf les fichiers finissant par la chaîne "htm".
user@localhost $ ls *[^htm]
t0st.c test.c
Exemple avec "?" qui signifie un caractère non vide :
user@localhost $ ls t?st.c
t0st.c test.c
On affiche tous les fichiers comportant "st" dans le nom :
luser@localhost $ ls *st*
t0st.c test.c
Note :
L’utilisation de ls * donne un affichage récursif sur un niveau
3.5. L'éditeur Vim
Nous avons choisi de vous présenter cet éditeur de texte car il s’agit du plus utilisé sur les systèmes UNIX. Vim est
une version améliorée de l'éditeur VI, possédant plus de commandes et d'options.
Note :
Le logiciel "vimtutor" permet d'apprendre les principales commandes très simplement, en vous les présentant pas à
pas.
3.5.1. Appel de l’éditeur
Éditer un fichier s’il existe, sinon, éditer un nouveau fichier vide :
luser@localhost $ vi fichier
Éditer chacun des fichiers à la suite :
luser@localhost $ vi fichier_1 fichier_2
3.5.2. Modes d’édition
Contrairement aux éditeurs wysiwyg (what you see is what you get) Vim fonctionne par mode. On distingue
principalement 2 modes bien distincts :
• Le mode insertion : Les caractères tapés s'insèrent directement dans le texte en cours
• Le mode commande : Les caractères tapés sont considérés comme des commandes pour l’éditeur
Le logiciel démarre par défaut en mode commande.
• i : permet de passer en mode insertion
•
•
11 / 81
ESC : permet de passer en mode commande
ESC permet d’interrompre une commande
Commande
:w
:q
:q!
:wq
:f file2
/hop
v
d
dd
y
yy
p
Description
Sauvegarde les changements
Quitte le document en cours
Quitte le document en cours sans sauvegarder les changements
Enregistre et quitte l'editeur
Enregistre le document sous le nom file2 (équivalent de enregistrer sous)
Recherche l'occurence hop et la met en surbrillance. Un appui sur la touche
"n" permet de se positionner sur la prochaine occurence
Permet de passer en mode visualisation pour faire une sélection par exemple
Equivalent de couper, aprés une sélection par exemple
Coupe la ligne entière
Equivalent de copier, après une sélection par exemple
Copie la ligne entière
Coller après le curseur
Fig 7. les principales commandes à utiliser en mode commande
3.5.3. Mode Edition
Après l'utilisation de ces commandes, l'éditeur passe en mode édition :
Commande
a
A
i
I
o
O
Description
Ajoute après le curseur
Ajoute après la ligne courante
Insère avant le curseur
Insère au debut de la ligne courante avant le premier caractère non-blanc
Ouvre une nouvelle ligne en-dessous de la ligne actuelle
Ouvre une nouvelle ligne au-dessus de la ligne actuelle
Fig 8. les principales commandes à utiliser pour passer en mode édition
3.6. Archivage et compression avec tar, gzip et bzip2
3.6.1. Créer des archives avec tar
tar [options] [fichiers]
La commande tar est une ancienne commande Unix qui permet aisément d’archiver, c’est-à-dire de réaliser la
sauvegarde d’un ensemble de fichiers en un seul fichier. Ce fichier peut être compressé après, mais tar ne
compresse pas les fichiers qu'il archive.
fichiers désigne un ensemble de fichiers ou toute une arborescence précédée d’un chemin absolu (à partir de /) ou
relatif.
Attention, si vous archivez des fichiers à partir d’un chemin absolu (précédé d’un "/") alors tar enlèvera ce premier
séparateur afin de ne pas remplacer des fichiers par des versions plus anciennes lors de la désarchivation. Par contre
l’arborescence des fichiers et répertoires est sauvée.
Option
-x
-c
-t
-f fichier
-v
-z
-j
-p
12 / 81
Description
Extraire le contenu d’une archive
Créer une nouvelle archive
Afficher seulement la liste du contenu de l’archive, sans l’extraire
Indiquer le nom du fichier archive
Mode verbeux, affiche le détail des opérations
Compresser ou décompresser en faisant appel à l’utilitaire gzip
Compresser ou décompresser avec l’utilitaire bzip2
Préserver les permissions des fichiers
Fig 9. Les options de la commande tar
Exemples :
Création d'archives
1 - Effectuer la sauvegarde de tous les fichiers du répertoire /home/toto dans le fichier sauve.toto.tar placé dans le
répertoire courant :
luser@localhost $ tar -cvf sauve.toto.tar /home/toto
2 - Effectue, en plus de l’archivage, une compression des fichiers :
luser@localhost $ tar -cvzf sauve.toto.tar.gz /home/toto
Listing
luser@localhost $ tar -tvf sauve.toto.tar
Extraction
1 – Extrait tout le contenu de l'archive dans le répertoire courant :
luser@localhost $ tar -xvf sauve.toto.tar
2 - Décompresse et extrait :
luser@localhost $ tar -xvfz sauve.tar.gz
3 – Extrait de l’archive le répertoire passé en argument :
luser@localhost $ tar -xvfz sauve.tar.gz home/toto/tmp
3.6.2. gzip
Cette commande est utilisée pour compresser un fichier quelconque, et en particulier une archive tar. L'extraction
se fait par la commande gunzip, ou de manière totalement équivalente par gzip -d.
gzip [options] [fichiers]
Elle peut décompresser les fichiers .gz, mais aussi les fichiers .z , .Z
Option
-1 à -9
-d
-c
-l
-r
Description
Fixe le niveau de compression -1 etant le plus faible
Décompresse l'archive passée en argument
Ecrit sur la sortie standard au lieu de remplacer le fichier d’origine
Affiche des infos sur les fichiers de l'archive (taux de compression...)
Gzip parcoure tous les répertoires de manière récursive lors de la dé/compression
Fig 10. Les options de la commande gzip
13 / 81
Exemples :
1 - Compresse backup.tar et le remplace par le fichier backup.tar.gz d’une taille beaucoup plus réduite :
luser@localhost$ gzip backup.tar /home/toto
2 - Compresse au maximum chaque fichier .txt séparément et les renomme en ajoutant le suffixe .gz :
luser@localhost $ gzip -9 *.txt
3.6.3. bzip2
Bzip2 admet la même syntaxe que gzip, mais effectue une compression plus efficace au détriment d'un besoin
accru de mémoire et temps processeur.
3.7. Recherche de fichiers
3.7.1. find
find [chemin] [options]
La commande find permet d’effectuer une recherche récursive à partir d’un certain répertoire spécifié par chemin
en fonction des options précisées.
Exemple : pour rechercher tous les fichiers textes contenus dans les répertoires personnels des utilisateurs :
user@localhost $ find /home/ -name "*.txt"
Option
-atime +n (-n)
-mtime +n (-n)
-name "toto*"
-maxdepth n
-type type
Description
Trouve les fichiers auxquels on a accédé il y a plus de n jours (ou moins de n jours)
Trouve les fichiers modifiés il y a plus de n jours (ou moins de n jours)
Trouve les fichiers dont le nom commence par toto
Définit le niveau maximum de sous-répertoire à explorer
Indique le type de fichier à rechercher. type peut être :
• d : pour les répertoires
• f : pour les fichiers
• l : pour les liens symboliques
Fig 11. Les options de la commande find
Exemple : nous voulons rechercher tous les répertoires du répertoire courant contenant "rep" dans leur nom, en ne
descendant pas dans les sous-répertoires
user@localhost $ find . -type d -maxdepth 0 "*rep*"
On peut utiliser find pour exécuter une commande sur certains fichiers :
find [chemin] [option] -exec cmd \{\} \;
•
•
•
Les fichiers trouvés sont passés à cmd comme des paramètres.
\{\} sera remplacé par le nom du fichier.
On est obligé de finir la ligne de la commande à l’aide du caractère ";". Ce caractère est échappé afin de ne pas
être interprété par le shell.
14 / 81
Exemple :
Pour effacer tous les fichiers ".exe" de mon répertoire personnel :
luser@localhost $ cd ~
luser@localhost $ find . -name "*.exe" -exec rm \{\} \;
3.7.2. slocate – locate
locate est un lien symbolique de la commande slocate. La commande slocate utilise une base de données que vous
devez mettre à jour régulièrement.
Des fichiers récemment créés ne sont donc pas forcément référencés. La base de données peut être mise à jour
manuellement par le super utilisateur (root) avec la commande slocate -u ou encore updatedb
L’avantage de slocate est de permettre une recherche beaucoup plus rapide qu’avec la commande find. En effet,
lors d'une recherche, la commande find parcoure à chaque lancement le contenu entier du disque tandis que locate
utilise sa base de données qui est bien plus rapide.
Exemple : recherche tous les fichiers dont le nom comporte la chaîne "toto" :
luser@localhost $ locate toto
3.8. "Pipes" et Redirections
Une des bases essentielles d'un système Unix/Linux est la redirection d'un flux émanant d'un programme en
direction d'un autre.
3.8.1. Les flux standards
Les flux standards sont au nombre de trois :
• STDIN (0) : STDIN n’est ni plus ni moins que l’entrée au clavier (dite "entrée standard"). Cela veut dire
que tout ce que vous tapez au clavier va passer par ce canal d’entrée/sortie.
• STDOUT (1) : STDOUT est ce que l’on appelle la "sortie standard". Les informations qui apparaissent à
l’écran passent par le canal STDOUT.
• STDERR (2) : STDERR est la "sortie d’erreur standard". L’utilité d’avoir deux flux de sortie permet de
séparer les messages d’erreurs et l’affichage normal du programme.
Les numéros 0, 1, 2 désignent respectivement STDIN, STDOUT et STDERR, et peuvent être utilisés dans les
commandes shell.
15 / 81
Fig 12. Représentation des flux entrants et sortants
3.8.2. Redirections
Si nous exécutons un programme tel que ls, le résultat sera affiché sur la sortie standard, c’est-à-dire l'écran par
défaut. Il est cependant possible de rediriger ces différents flux vers des fichiers ou d’autres flux.
Ceci peut être réalisé par le biais des signes "<" et ">". Une commande "command > file" va créer un fichier "file"
contenant le résultat de la commande "command".
De même, en utilisant le signe "<", le contenu du fichier "file" est utilisé comme entrée de la commande
"command" : "command < file".
Exemple :
luser@localhost $
luser@localhost $
total 4872
-rwxr-xr-x 1 root
-rwxr-xr-x 1 root
-rwxr-xr-x 1 root
...
cd /tmp
ls -l /bin
luser@localhost $
luser@localhost $
total 4872
-rwxr-xr-x 1 root
-rwxr-xr-x 1 root
-rwxr-xr-x 1 root
...
ls -l /bin > un_fichier
cat un_fichier
root 3180 Jan 22 2001 arch
bin 27380 May 18 2000 bzip2
bin 6708 May 18 2000 bzip2recover
root 3180 Jan 22 2001 arch
bin 27380 May 18 2000 bzip2
A chaque fois qu’un flux est redirigé avec ">" dans un fichier, celui-ci est écrasé. Afin de conserver le contenu et
d’ajouter notre sortie à la suite, il convient d’utiliser ">>".
luser@localhost $ ls linux-lfs/
linux-lfs-flat.vmdk
linux-lfs.vmx
linux-lfs.vmdk
linux-lfs.vmx.WRITELOCK
nvram
vmware.log
16 / 81
luser@localhost $ ls evolution/
addressbook-sources.xml
config
cache
gtkrc-mail-fonts
camel-cert.db
local
mail
meta
searches.xml
shortcuts.xml
vfolders.xml
views
luser@localhost $ ls linux-lfs/ >> fichier
luser@localhost $ ls evolution/ >> fichier
luser@localhost $ cat fichier
linux-lfs-flat.vmdk
linux-lfs.vmdk
shortcuts.xml
vfolders.xml
[…]
3.8.3. Pipes
Les "pipes" ("|") quant à eux sont "des voies de communication" d’un processus vers un autre.
Par exemple si nous faisons "command1 | command2", le résultat de la commande "command1" va être utilisé en
entrée de la commande "command2". L’utilisation d’un pipe est équivalent à la séquence suivante :
luser@localhost $
luser@localhost $
lrwxrwxrwx 1 root
-rwxr-xr-x 1 root
-rwxr-xr-x 1 root
ls –la /bin > un_fichier
grep "bzip" < un_fichier
root 5 Feb 12 2001 bunzip2 -> bzip2
bin 27380 May 18 2000 bzip2
Il est possible de chaîner ce type de commande autant que l’on veut :
user@localhost $ ls -la /bin | grep "bzip"
lrwxrwxrwx 1 root root 5 Feb 12 2001 bunzip2 -> bzip2
-rwxr-xr-x 1 root bin 27380 May 18 2000 bzip2
-rwxr-xr-x 1 root bin 6708 May 18 2000 bzip2recover
Fig 13. Représentation d’un tube (pipe) de communication
17 / 81
4. Organisation du FHS
4.1. FHS
Le FHS (Filesystem Hierachy Standard) est une convention qui organise l'arborescence des répertoires sous Linux.
Cette convention est aussi valable pour Unix et est primordiale. Grâce à lui, lorsque vous installez un programme
sous Linux, peu importe votre distribution, les fichiers iront toujours dans les mêmes répertoires.
4.1.1. Arborescence de "/"
Sous Linux, toute l'arborescence part de "/" appelé "root" ou racine. Ici se trouvent tous les dossiers élémentaires :
Répertoire
/bin
/boot
/dev
/etc
/home
/lib
/mnt
/proc
/root
/sbin
/tmp
/usr
/var
Contenu
les binaires (exécutables) vitaux pour l'utilisateur
les fichiers relatifs au bootloader
tous les périphériques
les fichiers de configuration et des fichiers nécessaires au démarrage (rc scripts)
les répertoires personnels des utilisateurs
les librairies partagées et les modules du noyau (/lib/modules)
les dossiers pour les points de montage temporaires
accès direct aux paramètres du noyau
répertoire personnel du super utilisateur (root)
les binaires vitaux pour l'administrateur (root)
les dossiers et fichiers temporaires. Le dossier est vidé à chaque démarrage
tout ce qui n'est pas vital au système (voir ci-dessous)
les fichiers qui changent fréquemment, tels que : les logs, les mails, queues d'impression
Fig 14. Structure du FHS
4.1.2. Arborescence de /usr
Le répertoire "/usr" contient certains dossiers déjà présents dans "/" (bin, sbin, lib, tmp). Mais ceux-ci ne sont pas
nécessaires au fonctionement minimal du système. On y trouve les fichiers relatifs aux programmes tierce partie,
par exemple le navigateur web ou les lecteurs multimédias.
Répertoire
/usr/bin
/usr/doc
/usr/lib
/usr/man
/usr/sbin
/usr/src
/usr/X11R6
Contenu
les binaires pour l'utilisateur
la documentation des programmes installés (hors manpages)
les librairies partagées
les manpages (pages de manuel)
les binaires pour l'administrateur
les sources du noyau
les fichiers du serveur X
Fig 15. Structure de /usr
4.1.3. Arborescence de /var
Un fichier variable est un fichier dont le contenu va changer fréquemment et sans l'intervention directe de
l'utilisateur (ex : fichiers de log). Ils sont opposés aux fichiers statiques, fichiers dont le contenu ne varie pas (ex :
fichier de configuration).
Le dossier "/var" contient tous les fichiers variables.
Répertoire
/var/log
/var/mail
/var/run
/var/spool
Contenu
tous les fichiers de log
les boites aux lettres de chaque utilisateur
les fichiers des PID des deamons
les queues en cours (envoi de mail, impression, crontab)
Fig 16. Structure de /var
18 / 81
19 / 81
5. Gestion des utilisateurs et groupes
5.1. Les utilisateurs
Unix est un système multi-utilisateurs. Plusieurs personnes peuvent l'utiliser de façon simultanée via différents
terminaux (via le réseau).
Pour le système, un utilisateur n'est pas obligatoirement une personne physique. Un utilisateur peut détenir des
fichiers, exécuter des programmes ou encore déclencher automatiquement des fonctions systèmes. Par exemple, un
utilisateur peut être créé dans le seul but de détenir des fichiers publics. On parle alors de « pseudo utilisateur ».
Un utilisateur possède un nom d'utilisateur appelé aussi login lui permettant de démarrer une session. Ce login est
associé à un mot de passe personnel. Pour accéder aux ressources du système, l'utilisateur doit entrer la bonne paire
login/mot de passe : c'est l'authentification.
Les utilisateurs sont identifiés par le système grâce à un UID (identifiant d'utilisateur) unique. Cet identifiant est
une valeur numérique.
5.1.1. Le fichier /etc/passwd
Le fichier /etc/passwd contient les informations relatives à tous les utilisateurs du système. On y trouve leur :
• login
• mot de passe (chiffré)
• UID
• GID principal
• nom complet et autres informations
• répertoire principal
• leur shell
La syntaxe de "/etc/passwd" est très simple, chaque ligne concerne un utilisateur. les différents champs sont séparés
par des ":" :
login:mot-de-passe:UID:GID:info-utilisateur:répertoire-principal:shell
•
•
•
•
•
•
Login : c'est l'identifiant que doit entrer l'utilisateur pour s'authentifier. Les caractères spéciaux ne sont pas
autorisés
Mot de passe : Chiffré en md5 par la commande passwd, ce champ peut prendre plusieurs significations :
• "*" : il est impossible de s'authentifier sur le système avec ce compte
• "!!" : Le compte est désactivé
• "x" ou "!" : le mot de passe est dans un fichier shadow (voir ci-après)
• champ vide : Il n'y a pas de mot de passe pour ce compte.
UID : il s'agit de l'identifiant unique de l'utilisateur.
• L'utilisateur root possède l'UID 0
• Par convention, les UID inférieurs à 100 sont réservés aux comptes système.
GID : l'identifiant du groupe principal de l'utilisateur
Info utilisateur : des informations sur l'utilisateur. chaque information est séparée par une virgule (le nom
complet, numéro de poste ...).
répertoire personnel : Il s'agit du répertoire dans lequel sont stockés les fichiers appartenant à l'utilisateur. En
général de la forme /home/login.
•
20 / 81
shell : c'est l'interpréteur de commandes qui sera lancé après l'authentification.
5.1.2. Le fichier /etc/shadow
Le fichier /etc/passwd est accessible en lecture par tout le monde. En effet, certaines commandes ont besoin de
connaître la liste des utilisateurs ou la correspondance login/UID.
La présence du mot de passe dans /etc/passwd, même crypté, pose un problème de sécurité. La solution à ce
problème est de stocker les mots de passe dans un fichier différent : /etc/shadow. Pour garantir la sécurité, seul
l'administrateur peut le lire.
Note :
Sous Linux, si le fichier /etc/shadow n'est pas utilisé, l'utilitaire pwconv permet, à partir d'un fichier /etc/passwd
unique, de créer le fichier /etc/shadow qui lui correspond.
5.2. Les Groupes
Le fichier /etc/group contient les information relatives au groupes présents sur le système.
Voici sa syntaxe :
groupe:*:GID:utilisateurs
•
•
•
•
groupe : le nom du groupe
* : la présence de ce champ est lié aux anciennes versions d'Unix et n'est plus utilisé. Il peut rester vide ou
contenir le caractère "*" ou "x".
GID : c'est l'identifiant unique du groupe sous la forme d'une valeur numérique.
utilisateur : il s'agit de la liste des utilisateurs appartenant au groupe. Ils sont séparés par des virgules :
compta:x:230:pierre,romain,jerome
5.3. Les commandes de gestion des utilsateurs
Afin de manipuler les fichiers /etc/passwd, /etc/shadow et /etc/group facilement, des commandes ont été crées.
Elles automatisent les vérifications (l'utilisateur à créer existe-t-il déja ? le mot de passe est-il assez compliqué ?...)
évitant ainsi toute erreur de saisie.
5.3.1. Ajouter un utilisateur
La commande useradd permet de créer un utilisateur :
useradd [options] login
Option
-c commentaire
-d répertoire
-e date
-f nombre de jours
-g groupe principal
-G groupes
supplémentaire
-m
-k [ répertoire ]
21 / 81
Explication
Informations concernant l'utilisateur (nom, poste)
Chemin du répertoire personnel de l'utilisateur
Date d'expiration du compte. Le format est AAAA-MM-JJ
C'est le nombre de jours suivant l'expiration du mot de passe après lequel le
compte est désactivé. La valeur 0 permet de désactiver le compte dès que le
mot de passe expire. La valeur -1 permet de désactiver cette caractéristique. La
valeur par défaut est -1
Le nom du groupe ou le numéro du groupe de connexion initial de l'utilisateur.
Le nom ou le numéro du groupe doivent exister. Le numéro de groupe par
défaut est 1
Les autres groupes auxquels appartient l'utilisateur (séparés par des virgules)
Le répertoire de l'utilisateur sera créé (par défaut, cela n'est pas fait)
A utiliser si et seulement si l'option -m est présente. Permet de copier les
fichiers et répertoires contenus dans le répertoire répertoire (/etc/skel si non
spécifié) dans le répertoire de l'utilisateur
Vous pouvez saisir le mot de passe en option. Il doit être chiffré (pour
récupérer la version cryptée d'un mot de passe il faut utliser la bibliothèque
crypt). Le comportement par défaut est de désactiver le compte
Shell lancé à la connexion de l'utilisateur
-p le mot de passe
chiffré
-s chemin vers un
exécutable
-u uid
L'identifiant unique de l'utilisateur
Fig 17. Les options de la commande useradd
Exemple : nous voulons créer l'utilisateur lambda :
• commentaire : "utilisateur lambda"
• son shell : /bin/zsh
• son répertoire personnel : /home/lambda
• nous recopions le contenu de /etc/skel dans son répertoire
• il appartient aux groupes "dev" et "final"
• le compte sera désactivé immédiatement après expiration du mot de passe
root@localhost # useradd -c "utilisateur lambda" -f 0 -G final,dev -m -k /etc/skel -s
/bin/zsh lambda
La commande useradd -D montre les options par défaut :
GROUP=100
HOME=/home
INACTIVE=-1
EXPIRE=
SHELL=
SKEL=/etc/skel
Il est possible de changer les valeurs par défaut grâce aux options suivantes :
Option
-h répertoire
-e date
-f nombre de jours
-g GID
Explication
Répertoire dans lequel créer les répertoires utilisateurs
La date d'expiration du compte
Délai de désactivation après expiration du mot de passe
Le groupe par défaut
-s chemin
22 / 81
Le shell par défaut
Fig 18. Options de la commande useradd (2)
5.3.2. Suppression d'un utilisateur
La commande userdel permet de supprimer un utilisateur :
root@localhost # userdel options login
Note :
L'option -r efface le répertoire personnel de l'utilisateur.
5.3.3. Changer le mot de passe d'un utilisateur
La commande passwd permet de changer le mot de passe d'un utilisateur. L'administrateur peut changer n'importe
quel mot de passe. Un utilisateur normal ne peut changer que son propre mot de passe.
passwd [ options ] [ login ]
Si l'argument login n'est pas spécifié, le changement de mot de passe s'applique sur l'utilisateur actuellement
connecté.
Option
-k
-l
--stdin
-u
-d
-S
Explication
Indique que seul le mot de passe doit être mis à jour sans toucher aux propriétés
d'expiration
Permet de verrouiller le compte spécifié en préfixant le mot de passe crypté par le
caractère "!". Seul l'utilisateur root peut utiliser cette option
Le mot de passe doit être lu à partir de l'entrée standard qui peut alors être un tube
(pipe)
Déverrouille le mot de passe du compte. Seul l'utilisateur root peut utiliser cette option
Supprime le mot de passe d'un compte. Le champ réservé au mot de passe crypté sera
supprimé dans le fichier de configuration. Seul l'utilisateur root peut utiliser cette
option
Affiche des informations sur le statut du mot de passe pour un compte donné. Seul
l'utilisateur root peut utiliser cette option
Fig 19. Options de la commande passwd
5.3.4. Afficher des informations sur un utilisateur
Pour connaître l'identité de l'utilisateur courant (bien que cela soit affiché dans la majorité des prompts par défaut)
on utilise la commande whoami.
Elle affiche le login de l'utilisateur courant. Les commandes who, users et w permettent de connaître les
utilisateurs actuellement connectés sur la machine.
23 / 81
5.4. Les commandes de gestion des groupes
5.4.1. Créer un groupe
La commande groupadd permet de créer un nouveau groupe :
root@localhost # groupadd option groupe
Option
-g
-r
-f
Explication
Permet de choisir la valeur numérique du GID du nouveau groupe. Cet identifiant doit être unique
Cette option permet d'ajouter un groupe système (dont le GID est inférieur à 500)
Permet de stopper la commande lorsque le groupe ou le GID du nouveau groupe existe déjà
Fig 20. Les options de la commande groupadd
5.4.2. Suppression d'un groupe
Pour supprimer un groupe, on utilise la commande groupdel :
groupdel GID
Note :
On ne peut pas supprimer un groupe si c'est le groupe principal d'un utilisateur.
5.4.3. Modifier les groupes secondaires d'un compte
Pour modifier les groupes secondaires d'un utilisateur, on utilise la commande usermod qui est similaire à useradd
et supporte les mêmes options :
root@localhost # usermod -G toto,users,fileshare,dev toto
Ceci permet d'ajouter l'utilisateur "toto" dans les groupes "toto", "users", "fileshare" et "dev".
5.4.4. Afficher des informations sur les groupes
Pour connaître les groupes auxquels appartient un utilisateur, on utilise la commande groups. Sans argument, elle
affiche les groupes de l'utilisateur courant. Pour connaître les groupes d'un utilisateur particulier, il suffit de passer
son login en argument de la commande :
root@localhost # groups
root wheel disk adm sys daemon bin
luser@localhost $ groups toto
toto users fileshare
Sur de très anciens SystemV, il n'était pas possible d'activer plusieurs groupes simultanément pour le même
utilisateur. La commande id permet de connaître les groupes actifs :
24 / 81
root@localhost # id
uid=0(root) gid=0(root) groupes=0(root),
10(wheel),6(disk),4(adm),3(sys),2(daemon),1(bin)
Pour changer le groupe actif sur un tel système, on utilise la commande newgrp. Lorsqu'elle est utilisée sans
argument, elle active le groupe principal de l'utilisateur (le groupe qui figure dans "/etc/passwd").
5.5. Changer d'identité
Il se peut qu'un utilisateur soit obligé d'effectuer des tâches avec une identité différente. La situation la plus
courante étant un utilisateur normal voulant effectuer quelques tâches en tant qu'administrateur.
La commande su (switch user), permet de changer d'identité :
Commande
su
su lambda
su - lambda
su -c "mount /dev/cdrom /mnt/cdrom"
Explication
Sans option, su permet de se connecter en tant qu'administrateur
Agir en tant qu'utilisateur lambda
Se connecter en tant que lambda. Avec "-" on récupère tout
l'environnement de l'utilisateur lambda
l'option -c permet simplement d'exécuter la commande entre guillemet
en tant que root (pas d'option). Une fois la commande terminée, on
reprend son identité
Fig 21. Les options de la commande su
25 / 81
6. Les permissions
Comme vu précédemment, la commande ls -l nous donne beaucoup d'informations sur un fichier.
root@localhost # ls -l
-r-xr-xr-x 1 root wheel
32464 27 May 09:35 /bin/ls
Nous allons nous intéresser aux parties : droits et propriétaire du fichier.
6.1. Propriétaire
Un fichier appartient à un utilisateur et un à un groupe, généralement le groupe principal de l'utilisateur. Dans
l'exemple ci-dessus, root est l'utilisateur propriétaire et wheel le groupe propriétaire.
6.1.1. Changer l'appartenance d’un fichier
Nous allons pouvoir changer l’appartenance d’un fichier grâce à la commande : chown. Cette commande ne peut
être utilisée que par root de la manière suivante :
chown [-R] user[:group] fichier
L'option -R est utilisée pour changer le propriétaire de façon récursive pour les dossiers.
Exemple :
root@localhost # ls -l fichier
-rw-r--r-- 1 andrew kernel 0 7 Sep 10:52 fichier
root@localhost # chown linus
-rw-r--r-- 1 linus kenrel 0 7 Sep 10:52 fichier
root@localhost # chown richard:gpl
-rw-r--r-- 1 richard gpl 0 7 Sep 10:52 fichier
Note :
les options entre crochets [ ] sont des options facultatives
6.1.2. Changer le groupe propriétaire
L’utilisateur n’ayant pas la possibilité d’utiliser la commande chown, il dispose de la commande chgrp pour
changer le groupe propriétaire du fichier.
Note :
L'utilisateur doit appartenir au nouveau groupe.
chgrp [-R] group fichier
26 / 81
Exemple :
user@localhost # ls -l fichier
-rw-r--r-- 1 user gpl 0 7 Sep 10:52 fichier
user@localhost # chgrp gnu fichier
-rw-r--r-- 1 user gnu 0 7 Sep 10:52 fichier
6.2. Les droits
Sous linux, on distingue 3 types de permissions attribuables à un fichier , ces permissions sont affichés à l’aide de
la commande ls -l
• r : lire (read)
• w : écrire (write)
• x : exécuter (execute)
Ces trois permissions vont être définies pour trois types de personnes :
• l'utilisateur propriétaire : User
• le groupe propriétaire : Group
• les autres : Others
Selon que l’élément soit un fichier ou un répertoire, ses permissions auront une portée différente. En effet dans le
cas d’un répertoire, le droit d’exécution correspond au droit de traverser ce répertoire.
6.2.1. Modifier les droits
Nous allons pouvoir modifier les droits avec la commande chmod. Cette commande peut être utilisée de deux
façons différentes :
chmod [–R] droits fichier
Il est possible d’utiliser des caractères alphabétiques :
lettre
u
g
o
a
signification
utilisateur
groupe
others
tous
lettre
r
w
x
signification
read
write
execute
Fig 22. Symbolisation des permissions avec chmod
Afin de définir ces permissions, il faut utiliser les opérateurs suivants :
+
=
Ajoute un droit
Supprime un droit
Définit un droit
Fig 23. Les opérateurs de chmod
27 / 81
Exemple :
-rw-r--r-- 1 root wheel 0 7 Sep 10:52
root@localhost # chmod u+x fichier
-rwxr--r-- 1 root wheel 0 7 Sep 10:52
root@localhost # chmod g+wx,o-r fichier
-rwxrwx--- 1 root wheel 0 7 Sep 10:52
root@lab# chmod a=r fichier
-r--r--r-- 1 root wheel 0 7 Sep 10:52
fichier
fichier
fichier
fichier
Il est également possible d’utiliser des valeurs numériques à la place des caractères, ces derniers ètant alors
transformés en valeurs octales :
chiffre
4
2
1
signification
read
write
execute
Fig 24. Equivalences octales
En additionnant ces chiffres, on arrive à un nombre à trois chiffres. Les centaines pour l'utilisateur, les dizaines
pour le groupe et les unités pour les autres.
Exemple :
Nous allons donner les droits de lecture, écriture et exécution à l'utilisateur. Les droits de lecture et exécution au
groupe et aux autres.
r+w+x Æ
r+x
Æ
4+2+1 = 7
4+1 = 5
-rw-r--r-- 1 root wheel 0 7 Sep 10:52 fichier
root@localhost # chmod 755 fichier
-rwxr-xr-x 1 root wheel 0 7 Sep 10:52 fichier
6.3. Umask
Le umask est un filtre permettant de définir les permissions par défaut lors de la création d’un fichier. Sans umask,
tous les fichiers créés ont comme droit 666 et les dossiers 777. Lors de la création d'un fichier, le système va
soustraitre l'umask aux droits par défaut. La valeur par défaut du umask est à 022. On a donc 666 - 022 = 644.
Exemple :
root@localhost # touch document
root@localhost # ls -l document
-rw-r--r-- 1 root wheel 0 7 Sep 11:02 document
On peut définir le umask grâce à la commande umask.
root@localhost # umask 077
En plus des permissions standards sont également disponibles des permissions spéciales.
28 / 81
6.4. Les droits spéciaux
En plus des permissions classiques que nous venons de traiter, il existe également un ensemble de permissions
spéciales permettant de contrôler de manière plus avancée la politique de sécurité sur les fichiers d’un système
GNU/Linux.
6.4.1. Le bit SUID
Lorsqu’une commande est exécutée, celle-ci hérite des droits inhérents à l’identité de l’utilisateur l’ayant invoquée,
elle se verra donc attribuer les mêmes restrictions d’accès au système de fichier que celui-ci.
Le bit suid permet de changer ce comportement, en donnant à la commande les droits de l’utilisateur propriétaire
du fichier, qui peut être différent de l’utilisateur exécutant la commande.
La commande ping par exemple à besoin d’accéder à l’interface réseau, opération que seul l’utilisateur root peut
réaliser. Afin de permettre à tous les utilisateurs du système d’utiliser cette commande, l’exécutable appartient à
root et possède le bit suid activé. Il faut bien entendu que la commande possède également les droits d’exécution.
Voici les permissions de la commande ping :
user@localhost$ ls -l /sbin/ping
-r-sr-xr-x 1 root wheel 24876 27 May 18:18 /sbin/ping
Le bit suid est représenté par la lettre "s" qui se situe à la place du droit d’exécution (x) de l’utilisateur propriétaire.
Pour activer le bit suid sur un fichier, il faut utiliser la commande chmod de la manière suivante :
user@localhost$ chmod u+s <fichier>
6.4.2. SGID
Le droit sgid fonctionne de la même façon que le suid mais concerne les droits du groupe propriétaire. Le sgid peut
aussi être attribué à un dossier, tout fichier créé dans un tel dossier aura comme groupe propriétaire le groupe du
dossier.
Pour activer le bit sgid sur un fichier, il faut utiliser la commande chmod de la manière suivante :
user@localhost$ chmod g+s <fichier>
6.4.3. Le Sticky bit
Lorsqu’un utilisateur posséde le droit d'écriture sur un dossier, il peut alors renommer ou supprimer tous les
fichiers qu'il contient. Ce fonctionnement n'est pas adéquat pour un dossier public, où tout le monde à accès en
écriture comme "/tmp" par exemple. Si le sticky bit est placé sur un dossier, seul le possesseur d'un fichier pourra le
renommer ou le supprimer.
29 / 81
Pour activer le sticky bit sur un répertoire, il faut utiliser la commande chmod de la manière suivante :
user@localhost$ chmod +t <repertoire>
Il est également possible d’inclure les droits spéciaux dans le umask et les chmod classiques en mode numérique.
Pour cela, il suffit d’ajouter un chiffre à gauche de la valeur initiale avec les valeurs suivantes :
Valeur
4
2
1
Description
SUID
SGID
Sticky Bit
Fig 25. Valeurs numériques des droits spéciaux
30 / 81
7. Composants de base d’un système Linux
Un système GNU/Linux est composé de trois éléments essentiels.
•
Un noyau
Le cœur même du système, appelé noyau Linux, se charge de la communication avec la partie matérielle. Les
processus des utilisateurs utilisent une interface d’appels systèmes afin de communiquer avec le noyau et ainsi
d’utiliser les ressources matérielles de votre ordinateur (disque dur, carte graphique etc .. ).
•
Un boot loader
Au démarrage de votre ordinateur, un noyau de système d’exploitation doit être chargé en mémoire, il peut s’agir
d’un noyau Linux, un noyau de système Windows ou encore un noyau de système MacOSX. Cette tâche est prise
en charge par un "boot loader".
•
Un schéma de lancement de services au démarrage
Une fois le noyau chargé en mémoire et initialisé, il est temps pour le système de lancer différents services
nécessaires à configurer votre environnent (configuration réseau, lancement de services), et éventuellement de
charger des modules additionnels dans le noyau. C’est le premier processus du système qui se charge de cela : init.
Une fois le noyau chargé par le boot loader et les différents services démarrés, votre système est prêt à recevoir vos
commandes.
Nous allons à présent voir de manière un peu plus détaillée la configuration de notre noyau, du boot loader et les
différentes phases du démarrage (boot) d’un système Linux.
7.1. Configuration et compilation d’un noyau Linux
7.1.1. Préambule
Comme nous l’avons présenté, le noyau Linux gère les communications avec la partie matérielle de votre
ordinateur. C’est donc au niveau du noyau que vous pouvez décider d’activer ou désactiver les pilotes de
périphériques. Ces pilotes peuvent être destinés à contrôler du matériel (carte graphique, carte son) ou bien à
contrôler des fonctionnalités logiques (systèmes de fichiers, gestion de la mémoire ..).
Le noyau Linux est monolithique et modulaire. Un noyau monolithique est caractérisé par le fait que tout le code
des différents pilotes est compilé puis lié en une seule image finale destinée à être chargée en mémoire. À l’opposé
on trouve les micro-noyaux qui eux sont composés d’un cœur de très petite taille faisant communiquer entre eux les
pilotes existants. (exemple : MacosX).
Afin d’offrir d’avantage de souplesse, le noyau Linux intègre depuis sa version 2.0 la possibilité d’utiliser des
modules dont le code objet compilé n’est pas directement inséré dans le noyau. Il est alors possible de charger et de
décharger des modules à chaud afin d’utiliser ponctuellement un certain matériel ou fonctionnalité compilée dans
ledit module, ceci peut réduire considérablement la taille du noyau en mémoire.
31 / 81
7.1.2. Pourquoi recompiler son noyau ?
Afin de simplifier la mise en place des systèmes Linux, de nombreuses distributions comme RedHat/Fedora ou
Mandrake proposent un noyau dit générique. Il s’agit simplement d’un noyau intégrant un maximum de
fonctionnalités et de pilotes de périphériques, l’avantage étant la réduction des incompatibilités matérielles et donc
de simplifier la prise en main du système.
La contrepartie étant la taille importante du noyau, qui comprend des pilotes inutiles au système, il est alors
pratique de pouvoir configurer son noyau afin de supprimer le superflu et de le rendre plus rapide.
L’intérêt de la recompilation de son noyau ne s’arrête pas là, il est également possible de recompiler le noyau afin
de combler des failles de sécurités, de l’optimiser pour le processeur ou pour y intégrer des nouvelles
fonctionnalités.
7.1.3. Note sur les modules
Les modules sont des fonctionnalités du noyau compilées de manières à pouvoir être chargés ultérieurement de
manière dynamique. Ceux-ci sont en théorie spécifiques à une version de noyau, il est toutefois possible que
certains modules s’adaptent à plusieurs versions de noyaux, comme c’est par exemple le cas des drivers NVIDIA.
Après la compilation, les modules sont stockés dans le répertoire /lib/modules/VERSION-DU-NOYAU/. Ceci
implique quelques contraintes, il n’est, bien entendu, pas possible de compiler en modules les pilotes de base du
système.
Il n’existe pas de règle absolue quant au choix des drivers à sélectionner en tant que modules ou à intégrer
directement dans le noyau. Généralement, il est conseillé d’insérer dans le noyau toutes les options utilisés en
permanence, comme par exemple le pilote du système de fichier, de la carte mère ou encore de la carte réseau.
7.1.4. Configuration et compilation
Nous allons dans cette section expliquer les étapes nécessaires à la construction d’un nouveau noyau pour un
système GNU/Linux.
Tout d’abord, il vous faut récupérer le code source du noyau de votre choix, ce dernier est disponible à l’adresse
ftp.kernel.org. Une fois l’archive récupérée, il faut la décompresser dans le répertoire /usr/src et créer un lien
symbolique /usr/src/linux pointant sur le répertoire nouvellement créé.
Il est maintenant temps de configurer le noyau, pour cela il faut se rendre dans le répertoire des sources puis lancer
le menu de configuration :
cd /usr/src/linux
make menuconfig (menus en mode texte, nécessite la librairie ncurses)
ou
make xconfig (menus graphiques, nécessite un environnement graphique)
Note :
Pour l’exemple on étudiera le cas de make menuconfig car il s’agit de la méthode de configuration la plus
couramment utilisée et reste valide sur un serveur ne possédant pas de serveur graphique.
32 / 81
Fig 26. Menu de configuration du noyau Linux
Il est possible de naviguer dans les menus afin de trouver l’option souhaitée.
Exemple : Activation du support bluetooth.
Il faut donc se déplacer dans la section adéquate et cocher la ligne voulue :
Puis dans le menu "Networking support" :
Enfin le support bluetooth :
Cocher la ligne en tant que module (touche m)
Note :
Nous aurions tout aussi bien pu sélectionner l’option en tant que partie intégrante du noyau (touche ‘y’) :
Une fois cela effectué, il ne reste plus qu’à sortir du menu de configuration en sélectionnant plusieurs fois Exit
grâce à la touche <TAB> et <Entrée> pour confirmer.
33 / 81
Le fichier de configuration doit alors être sauvegardé.
Selon la version du noyau téléchargée l’étape suivante diffère légèrement.
Noyaux 2.4.x
Pour compiler un noyau de cette famille, il faut :
•
•
•
•
Générer les dépendances
Créer l’image du noyau
Compiler les modules
Installer les modules dans /lib/modules
Toutes ces étapes peuvent être exécuté grâce à la ligne de commande suivante :
make dep bzImage modules modules_install
Noyaux 2.6.x
La compilation de ce type de noyaux est plus simple, les trois premières étapes se faisant automatiquement, il suffit
alors de saisir :
make && make modules_install
À la fin de cette étape, une image du nouveau noyau est disponible dans le répertoire : arch/i386/boot/bzImage
Note :
Si le noyau a été compilé sur une architecture de type ppc, le noyau se trouve directement dans le répertoire
courant sous le nom de vmlinux
Peu importe l’architecture utilisée les modules sont copiés dans : /lib/modules/VERSION-DU-NOYAU
Il ne reste plus qu’à faire en sorte que notre nouveau noyau soit chargé au démarrage à la place de l’ancien. Ceci est
le rôle d’un programme appelé boot loader que nous allons étudier ci-après.
7.1.5. Quelques compléments
La compilation du noyau ne présente pas de difficultés ou de risques particuliers. Il cependant quelques points
supplémentaires qui méritent d’être exposés.
Il est des cas ou il est inutile de compiler la partie des modules, car une fonctionnalité a juste été ajoutée ou
supprimée dans le noyau. Il suffit alors de spécifier au programme make de ne générer que l’image du noyau :
34 / 81
Noyaux 2.4.x
make bzImage
Noyaux 2.6.x
make
De même il est possible de ne traiter que la partie de la compilation concernant les modules :
Noyaux 2.4.x
make dep modules modules_install
Noyaux 2.6.x
Make modules_install
Dans le cas ou l’on ne compile pas le noyau et ses modules pour la première fois, il est plus prudent de garder la
précédente version du noyau ainsi que les modules qui lui sont associés. Pour cela il faut éditer le fichier appelé
Makefile et changer la valeur de sous version (EXTRAVERSION) situé au début du fichier :
Fig 27. Extrait du fichier Makefile
Dans ce cas là par exemple les nouveaux modules générés seront situés dans le répertoire /lib/modules/2.6.8-monnoyau/.
Après chacune des configurations sauvegardées (à la sortie du make menuconfig) un fichier appelé ".config" est
créé. Il contient l’ensemble des options sélectionnées dans la phase de configuration. Lorsque vous récupérez les
sources d’un nouveau noyau il est possible de copier ce fichier dans le répertoire de celle-ci. Il suffit ensuite de
lancer ensuite une fois la configuration et quitter en sauvegardant directement. Les nouvelles versions des pilotes
sont alors disponibles sans avoir à tout reconfigurer.
7.2. Le boot loader
Le boot loader est un programme lancé avant n’importe quel système d’exploitation par le BIOS. Son rôle est de
charger le noyau du système souhaité. Il peut également permettre une sélection interactive. Il en existe un certain
nombre parmis lesquelles on citera Grub et Lilo ou encore NTLDR pour architectures x86, Silo pour sparc ou
yaboot pour ppc.
Note :
Que se passe t'il entre le moment où l'on allume sa machine jusqu'au moment où l'on entre son login et mot de
passe :
-le BIOS effectue une série de tests sur le matériel (RAM, détection des disques, ...) nommé POST : Power On Self
Test. C'est pendant cette étape que l'utilisateur peut appuyer sur une touche pour entrer dans le BIOS.
-le bootloader est chargé en mémoire, l'utilisateur peut alors choisir le système à démarrer
-le noyau linux est chargé en mémoire par le bootloader, il s'initialise, détecte les périphériques, ...
-le noyau passe alors la main au programme sysvinit, souvent dénommé init, père de tous les processus. En effet
c'est ce programme ayant comme PID 1, qui va lancer tous les services au démarrage.
-init lance en dernier un terminal virtuel qui demande un login/password pour ouvrir un shell
35 / 81
Voici la présentation de Lilo et Grub deux boot loader couramment utilisés sur architecture x86.
7.2.1. Lilo
Probablement le boot loader le plus répandu sur les distributions à base GNU/Linux il est séparé en deux stages :
• le stage_1 est un petit programme (<= 512 octets) pouvant être placé dans le MBR (Master Boot Record) ou
une disquette. Ce stage fait appel au second qui possède plus d'espace mémoire
• le stage_2, appelée chargeur d'amorçage, est généralement placé sur le disque dur. Il offre un menu permettant
la sélection des systèmes d'exploitations et de charger le noyau en RAM
Voici un exemple de son fichier de configuration /etc/lilo.conf :
#Emplacement du secteur de boot
boot = /dev/hda
#Temps d’attente avant de démarrer sur l’image par défaut
delay = 10
#1 - Emplacement de l’image du noyau sur le disque
#2 - Nom qui sera affiché lors de la sélection interactive au démarrage
#3 - Partition à utiliser pour démarrer
image = /boot/vmlinuz-2.4.26
label = Ancien noyau
root = /dev/hda1
read-only
#La même chose mais pour un autre noyau
image = /boot/bzImage-2.6.8-mm4
label = Nouveau noyau
root = /dev/hda1
read-only
#Une entré pour un système d’exploitation alternatif, Windows par exemple :
other = /dev/hda3
label = Windows
tabe = /dev/hda
Une fois ce fichier modifié il est impératif de relancer la commande lilo pour que les changements prennent effet.
7.2.2. GRUB
GRUB (Grand Unified Bootloader) est également un standard pour les architectures x86. Son fichier de
configuration se trouve habituellement dans le répertoire /boot/grub/menu.lst (ou /boot/grub/grub.conf).
Comme lilo, grub fonctionne par stages. En plus des 2 stages évoqués dans lilo, grub intègre un stage intermédiaire,
le stage 1_5 qui permet de charger le stage 2 sur n'importe quel système de fichier.
Pour installer Grub il faut taper les commandes suivantes.
root@localhost # grub
grub> root (hd0,0)
grub> setup (hd0)
grub> quit
36 / 81
#partition où sont les fichiers de
#configuration de grub
#Emplacement du stage_1, ici le MBR
Voici le fichier de configuration de grub qui aboutit au même résultat que le fichier de configuration Lilo
précédemment exposé :
#Temps d’attente avant de démarrer sur l’image par défaut
timeout 10
#Nom de la configuration à utiliser par défaut
title Ancien Noyau
#Partition sur laquelle le noyau doit démarrer (/boot). Attention le comptage
commence à 0 et non à 1 !
root (hd0,0)
#Emplacement de l’image du noyau sur le disque
kernel /vmlinuz-2.4.26 root=/dev/hda1 ro
#La même chose pour un autre noyau
title Nouveau Noyau
root (hd0,0)
kernel /bzImage-2.6.8-mm4 root=/dev/hda1 ro
Une entrée pour un système windows
title Windows
rootnoverify (hd0,0)
makeactivz
chainloader+1
Dans le cas de GRUB pas besoin de relancer de commande, il suffit de redémarrer pour pouvoir sélectionner le
nouveau noyau.
7.2.3. Boot loader sur disquette
L'un des autres moyens de booter un système est de placer le boot loader sur disquette.
Ceci peut être très utile si on écrase le MBR, ou si une erreur dans un fichier de configuration empêche la machine
de redémarrer.
Le cas de Lilo
L'installation de lilo sur disquette se fait en modifiant l’option "boot" du fichier de configuration.
boot=/dev/fd0
Puis on exécute la commande lilo pour copier le stage_1 sur une disquette.
Le cas de Grub
37 / 81
Pour grub, pas besoin de modifier le fichier de configuration. On va simplement copier les deux stages sur deux
disquettes.
Il faut tout d’abord formater les deux disquettes :
roto@localhost # fdformat /dev/fd0
root@localhost # mke2fs /dev/fd0
Puis il suffit de copier les deux stages sur les disquettes nouvellement formatées. L’utilitaire dd est tout à fait
adapté à cette tâche :
root@localhost # dd if=/boot/grub/stage1 of=/dev/fd0 bs=512 count=1
root@localhost # dd if=/boot/grub/stage2 of=/dev/fd0 bs=512 count=1
Pour finir on utilise l’utilitaire grub pour rendre la disquette contenant le stage 1 "bootable" :
root@localhost # grub
grub> root(fd0)
grub> setup(fd0)
grub> quit
7.3. Schéma de lancement de services au démarrage
Une fois le noyau chargé en mémoire par le boot loader, il met en place un certain nombre de mécanismes de
protection de la mémoire et recherche ensuite ; sur la partition marquée comme root dans le fichier de configuration
du bootloader ; un programme appelé "init". Celui-ci va consulter le fichier de configuration /etc/inittab et en
exécuter le contenu. Le premier processus de votre système sera donc toujours init qui aura comme pid 1.
C’est à ce niveau que sont exécutés les scripts de démarrage pour la gestion du réseau, du montage des disques , de
la mise en place des terminaux etc ..
Il existe sous les systèmes Linux plusieurs niveaux d’initialisation (runlevels) symbolisés par des chiffres de 0 à 6.
Chacun de ces niveaux possède une vocation particulière, à chaque niveau d’exécution est associé un jeu de scripts
à exécuter.
Afin de changer de niveau d’exécution lors d’une session, il suffit de saisir :
init id (id = numéro du niveau d’exécution désiré).
Les différents niveaux d’exécution sont définis comme tels :
•
•
•
•
•
•
•
0 - halt : arrêt du système
1 - Single user mode : comparable à un mode « sans echec »
2 – Multi user, without NFS : même chose que le niveau 3 mais sans support réseau
3 - Full multi user mode : niveau par défaut, tout est activé sauf le mode graphique
4 – Unused : non utilisé
5 - X11 : comme le niveau 3 mais avec le mode graphique
6 - reboot
7.3.1. Le fichier inittab
Le fichier /etc/inittab, contient des directives qui vont être utilisées par le processus init. On trouvera généralement
des lignes au format suivant :
38 / 81
id :niveaux_init :action :commande_ou_script
•
•
•
id : Permet d’identifier la tâche à exécuter
niveaux_init : Identifiant du niveau d’exécution dans lesquels le script ou la commande devra s’exécuter
action : Permet de spécifier le comportement d’init après avoir exécuté sa commande (ex : attendre la fin de l’exécution de
la tâche, réexécuter la tâche après quelle se soit terminée etc ..)
Voici un exemple du fichier /etc/inittab :
id:3:initdefault:
# System initialization.
si::sysinit:/etc/rc.sysinit
l0:0:wait:/etc/rc
l1:1:wait:/etc/rc
l2:2:wait:/etc/rc
l3:3:wait:/etc/rc
l4:4:wait:/etc/rc
l5:5:wait:/etc/rc
l6:6:wait:/etc/rc
0
1
2
3
4
5
6
# Trap CTRL-ALT-DELETE
ca::ctrlaltdel:/sbin/shutdown -t3 -r now
# Run gettys in standard runlevels
1:2345:respawn:/sbin/agetty 38400 tty1
7.3.2. Introduction à la notion des services
La gestion des services sur un système Linux pose différents problèmes du fait de la dépendance entre les services.
Par exemple, il ne faudrait pas démarrer le service FTP avant l’activation du réseau. Un service ne doit donc pas
être inséré à n’importe quel moment du démarrage.
On parle notamment de différents niveaux d’exécution (runlevels) avec à chaque étape un ensemble de services.
Il existe différentes méthodes de gestion de ces services, en fonction des distributions. Avant de présenter les
différentes étapes en fonction des différentes déclinaisons de Linux, nous allons d’abord présenter les bases de la
gestion de services.
Linux provient de son ancêtre UNIX, disposant lui de 2 systèmes d’initialisation des services :
•
•
System V
BSD
Linux a adopté le principe de mise en place System V ou chaque service va être associé à un script placé dans un
répertoire commun /etc/init.d.
39 / 81
Fig 28. Exemple de contenu du répertoire /etc/init.d
Le démarrage et l’arrêt des services est réalisé par l’intermédiaire de liens symboliques placé dans différents
répertoires, de rc0.d à rc6.d, répertoires correspondant aux différents runlevels du système.
Fig 29. Exemple des scripts correspondant au niveau d’exécution 3
Lors du passage dans un runlevel spécifique, le processus init va exécuter tous les scripts commençant par K (Kill)
avec le paramètre stop et tous les scripts commençant par S (Start) avec le paramètre start
Convention de nommage des scripts et des liens symboliques
Les scripts présents dans /etc/init
Il n’existe pas de convention de noms spécifiques bien qu’il soit conseillé de nommer les scripts avec une
appellation relative au nom du processus démarré.
Les liens symboliques présents dans rcX.d
•
•
Première lettre : S (script de lancement) ou K (script d’arrêt)
Second et troisième caractères : un n° permettant d’indiquer l’ordre d’exécution des scripts dans le
répertoire
Afin de simplifier la saisie de tout cela, les différentes distributions proposent différents utilitaires de gestion des
services
7.3.3. Gestion des services
Selon la distribution utilisée, la gestion des services diffère légèrement, nous allons traiter les trois cas les plus
couramment rencontrés.
a) L’approche Debian
Debian fournit 2 utilitaires afin de simplifier la gestion des services :
•
•
Update-rc.d : Pour interroger la configuration des services et leur comportement au démarrage
Invoke–rc.d : Pour manipuler un service
L’utilitaire update-rc
Cet utilitaire permet de mettre en place ou de supprimer les liens présents dans les différents répertoires rcX.d
(System V)
Sous le système Debian, les informations telles que la priorité d’arrêt ou de démarrage ou encore les niveaux
d’exécution par type de lien sont précisés dans la ligne de commande
40 / 81
Exemple :
root@localhost # update-rc.d <service> start 20 3 5 . stop 15 0 1 2 4 6 .
<service> : nom du script présent dans /etc/init.d
20 3 5 . : priorité du service ainsi que les différents niveaux d’éxécution (un point à la fin) de démarrage (S)
15 0 1 2 4 6 : priorité des liens symboliques de type arrêt de services (K) avec les différents niveaux d’exécution
concernés
Pour supprimer le service, il suffit d’utiliser la commande update-rc.d <service> remove
L’utilitaire invoke-rc
Cette commande permet de démarrer ou d’arrêter un service en utilisant les mots-clé start, stop, restart ou status
Exemple :
invoke-rc.d sshd start
Note :
Cette commande est l’équivalent de la commande /etc.init.d/sshd start
b) L’approche RedHat et Mandrake
Ces deux distributions utilisent les commandes chkconfig et service.
chkconfig
La commande chkconfig permet de gérer les services ainsi que les démarrages automatiques du système.
Pour chaque service que l’on souhaite gérer avec chkconfig, il faut ajouter dans le script la liste des niveaux
d’éxecution par défaut ainsi que les priorités d’arrêt et de démarrage.
Voici comment utiliser chkconfig pour ajouter un service au démarrage :
root@localhost # chkconfig –add <nom>
root@localhost # chkconfig –level <niveaux> <nom> <on|off|reset>
Et voici comment faire pour supprimer un service :
chkconfig –del <nom>
Exemple :
Utilisation de la commande chkconfig :
chkconfig –del sshd
chkconfig –level 35 sshd on
chkconfig –list sshd
sshd
0:Arrêt 1:Arrêt 2:Arrêt 3:Marche 4:Arrêt 5:Marche 6:Arrêt
41 / 81
Service
Service est utilisé pour manipuler un service courant et permet notamment de gérer les services pris en charge par
inetd et xinetd de manière transparente
root@localhost # service ssh
I need an action
ssh is an inetd service
root@localhost # service ssh start
ssh is an inetd service
Rechargement de la configuration
[OK]
Si l’on utilise la commande service sur un service indépendant des superserveurs, on obtient la liste des options
disponibles
root@localhost # service ssh
Utilisation : ssh {start|stop|restart|reload|status}
c) L’approche Gentoo
Pour ajouter ou supprimer un script d’un certain niveau d’exécution avec la distribution gentoo, on utilise la
commande rc-update.
Les trois opérations de bases traitées par la commande rc-update sont :
• Ajout d’un script :
rc-update add script <runlevels>
Si l’argument runlevels est "default" le script va être ajouté au niveau d’exécution par défaut spécifié dans
/etc/inittab.
•
Suppression d’un script :
rc-update del script [runlevels]
•
Lister les scripts d’un certain niveau d’exécution :
rc-update show [runlevels]
Contrairement à RedHat ou Mandrake, la distribution gentoo ne possède pas de script pour lancer ou arrêter les
services, pour cela, il faut utiliser ceux situés dans /etc/init.d/<nom_de_service>.
Exemple :
Pour arrêter le service ssh :
/etc/init.d/sshd stop
Pour finir, il est également possible de consulter l’état des services d’un certain niveau d’exécution. Attention,
Gentoo n’utilise pas des nombres mais nomme ces niveaux d’exécution afin de connaître le nom ceux-ci il faut
utiliser la commande rc-status :
Fig 30. Les différents niveaux d’execution avec Gentoo
42 / 81
Pour lister par exemple l’état des services du niveau d’exécution par défaut on pourra saisir :
Fig 31. Consultation de l’état des services avec Gentoo
d) L’approche BSD (Slackware)
L’approche BSD classe tous les scripts dans /etc/rc.d Dans ce répertoire, tous les scripts qui possèdent le droit
d’exécution sont lancés. Il est donc possible de gérer ses services grâce à la commande chmod.
Hierarchie des scripts d’initialisation
Nom
rc.S (Sysinit)
rc.K (single user) ou rc.M (multi user)
rc.inet1
rc.inet2
rc.apache
rc.mysql
rc.local
Description
montage des disques
config interfaces reseau, et autres services à lancer
Scripts personnels, lancés après tous les précédants
Fig 31. Les scripts d’initialisation avec l’approche BSD
43 / 81
8. Gestion des disques
8.1. Les disques durs sous Linux
"Sous un système Unix, tout est fichier"
Tous les éléments de votre système, qu’il s’agisse du processeur, de la carte réseau, d’un processus ou encore d’un
fichier texte, sont considérés comme des fichiers.
Les disques durs n'échappent pas à cette règle. Par convention tous les périphériques sont représentés dans le
dossier "/dev". On distingue deux types de disques : les disques IDE et les disques SCSI.
Ils sont nommés respectivement "hd" et "sd". Afin de distinguer les différentes partitions de ceux-ci on ajoute un
suffixe composé d'une lettre et d'un chiffre. La lettre représente la position du disque sur le bus et le chiffre
représente l'une des partitions de ce disque.
Par exemple, le disque maître du premier contrôleur IDE sera nommé "/dev/hda". La première partition de ce
disque sera "/dev/hda1", la seconde "/dev/hda2".
8.1.1. Partitions
Un disque ne peut contenir que 4 partitions primaires. Il est possible de remplacer une partition primaire par une
partition étendue, celle-ci peut contenir jusqu’à 12 partitions logiques. Notre disque pourra donc contenir 15
partitions utilisables soit 3 primaires plus les 12 partitions logiques.
Cette méthode est la plus utilisée, indépendemment du système d'exploitation. Il existe une autre méthode appelé
LVM (Logic Volume Manager) mais elle ne sera pas abordée dans ce cours.
Sous un système Linux, contrairement à un système Microsoft, chaque partition n'est pas représentée sous forme de
lecteur. Nous allons pouvoir monter, c’est-à-dire ajouter cet espace disponible à notre système de dossier
hiérarchique.
Par exemple si une machine fait office de serveur FTP, il est possible de créer une partition dédiée qui sera montée
dans "/var/ftp/". Ainsi le serveur FTP n'utilisera pas la place réservée aux utilisateurs ou aux fichiers de logs.
Note :
Il faudra aussi prévoir une partition réservée à la swap. La swap est utilisée comme complément à la mémoire vive
du système.
Partitionner un disque dur
Il existe plusieurs outils pour partitionner un disque dur sous linux. Les plus communs sont :
• fdisk : utilitaire en mode texte avec menu interactif
• cfdisk : utilitaire en mode curses (pseudo graphique) avec une liste des partitions.
Ces deux utilitaires se lancent de la même façon :
commande /dev/disk
44 / 81
Il est possible de modifier les partitions d'un disque dur en cours d'utilisation. Il faut cependant redémarrer pour que
les changements soient pris en compte.
Exemple avec fdisk
Nous allons ici créer une partition primaire contenant la swap (512Mo) et une partition logique contenant "/" (5Go)
root@localhost # fdisk /dev/hda
Command (m for help): n
Command action
e
extended
p
primary partition (1-4)
p
Partition number (1-4): 1
First cylinder (1-2434, default 1):
Using default value 1
Last cylinder or +size or +sizeM or +sizeK (1-2434, default 2434): +512M
Command (m for help): t
Selected partition 1
Hex code (type L to list codes): 82
Changed system type of partition 1 to 82 (Linux swap)
Command action
e
extended
p
e
Partition number (1-4): 2
Last cylinder or +size or +sizeM or +sizeK (64-2434, default 2434):
Command action
l
logical (5 or over)
p
l
Last cylinder or +size or +sizeM or +sizeK (64-2434, default 2434): +5000M
Command (m for help): p
Disk /dev/hda: 20.0 GB, 20020396032 bytes
255 heads, 63 sectors/track, 2434 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Device Boot
Start
End
Blocks
Id System
/dev/hda1
1
63
506016
82 Linux swap
/dev/hda2
64
2434
19045057+
5 Extended
/dev/hda5
64
672
4891761
83 Linux
Command (m for help): w
Writing table partition
Commande
m
p
n
d
t
w
q
Description
Aide
Affiche l'état du disque
Crée une nouvelle partition
Supprime une partition
Change le type de partition (82 : Linux Swap, 83 : Linux Native)
Sauver et quitter
Quitter sans sauver
Fig 32. Les commandes de fdisk
45 / 81
Formater une partition
Une fois les partitions définies, il faut à présent les formater afin de pouvoir créer un système de fichier dessus.
Le type de système de fichier indique, entre autres, comment organiser les données sur le disque dur.
Dans la majorité des cas, nous utiliserons la commande mkfs. Certains systèmes de fichiers utilisent leur propre
commande, nous les verrons ci-dessous.
Il existe deux moyens d'utiliser la commande mkfs :
mkfs -t type /dev/partition
mkfs.type /dev/partition
Voici un tableau des systèmes de fichiers utilisables sous linux avec la commande à utiliser.
Commande
swap
ext2
ext3
reiserfs
xfs
jfs
vfat
Description
mkswap
mke2fs, mkfs -t ext2, mkfs.ext2
mke2fs -j, mkfs -t ext3, mkfs.ext3
mkreiserfs
mkfs -t xfs, mkfs.xfs
mkfs -t jfs, mkfs.jfs
mkfs -t vfat, mkfs.vfat
Fig 33. Les commandes de formatage
8.1.2. Accès aux périphériques de stockage
Une fois le disque dur partitionné et formaté, il est à présent utilisable. Comme dit précedemment, pour accéder à
ce disque il est necessaire de le monter, c’est-à-dire de l’ajouter dans notre arborescence (le FHS).
Dans la pratique, cela consiste à ajouter un répertoire, appelé point de montage, qui va pointer vers la ressource
voulue. Par convention, les points de montage sont regroupés dans le dossier "/mnt".
commande mount / umount
La commande mount va permettre de monter un périphérique. Si l'on utilise la commande mount sans paramètres,
on obtiendra la liste des périphériques déjà montés.
mount -t type /dev/partition /mnt/dir
L'option -t renseigne le système de fichier utilisé. Il est également possible d’ajouter "auto" pour que mount essaie
de trouver le système de fichier lui-même.
Note :
Pour connaître tous les systèmes de fichier supportés par votre noyau, consultez le fichier "/proc/filesystems"
Il est possible de passer plus d'options grâce à l'argument -o (voir figure 34)
La commande umount va elle, au contraire, démonter un périphérique.
umount /mnt/dir
46 / 81
Le fichier /etc/fstab
Ce fichier a principalement deux utilisations :
• contenir toutes les partitions à monter automatiquement au démarrage.
• faciliter l'utilisation de la commande mount, en entrant toutes les options à utiliser pour chaque
périphérique.
Dans le fichier "/etc/fstab" chaque ligne représente un périphérique à monter. Chaque ligne est composée de six
parties :
• Le chemin du périphérique matériel (dans /dev)
• Le point de montage (dans le FHS)
• Le type de système de fichier
• Les options (argument -o de mount)
• Le mot clé "dump" : active ou non la sauvegarde du disque avec l'utilitaire dump (1 ou 0)
• Le mot clé "fsck" : active ou non la vérification du système de fichier avec l'utilitaire fsck (0, 1, 2 ou 3)
Exemple de fichier /etc/fstab
/dev/hda1
/dev/hda5
/dev/cdrom
none
/
/mnt/cdrom
swap sw
0 0
ext3 defaults
0 0
iso9660
noauto,users,ro 0 0
Grâce à ce fichier, maintenant les deux commandes suivantes sont équivalentes.
mount -t iso9660 -o noauto,users,ro /dev/cdrom /mnt/cdrom
mount /mnt/cdrom
Option
no/auto
defaults
no/exec
no/suid
ro
rw
nom d'utilisateur
no/users
Description
Monte automatiquement le périphérique
Active rw, suid, exec, auto, nouser
Autorise l'exécution de binaires
Autorise l'utilisation du suid et guid
Lecture seule
Lecture écriture
Autorise un utilisateur à monter et démonter un périphérique
Autorise tous les utilisateurs à monter ou démonter un périphérique
Fig 34. Les options de la commande mount et du fichier fstab
47 / 81
9. Gestion des processus
Un processus est l'instance d'un programme en cours d’execution. Le rôle du système d’exploitation est d'exécuter
l'ensemble des processus d'une ou plusieurs applications et ce de manière concurrentes en controlant l’attribution
du temps processeur à chacun d'eux. Il est, bien entendu, possible de définir des priorités sur ces processus.
Dans ce chapitre, nous verrons les commandes permettant de controler les processus au sein du système.
9.1. Introduction à la notion de processus
Un processus peut prendre différents états définissant son comportement. Les principaux états sont :
• l'état "actif" (running) : le processus est traité par le processeur.
• l'état "prêt" (sleeping) : le processus attend d’être traité par le processeur.
• l'état "attente" (idle) : le processus attend un signal qui le passera à l'état prêt.
Il existe beaucoup d'autres états qui seront mis en évidence par l'utilisation de certaines commandes.
Une fois un processus lancé, le système lui affecte non seulement une identification numérique unique portant le
nom de PID (Process Identifier) permettant de le reconnaître dans la masse des processus mais aussi un héritage.
En effet lorsqu'un processus est lancé celui-ci fait partie d'une descendance, tout processus est le "fils" ou le
"parent" d’un ou plusieurs processus.
Note :
Tous les processus sont hérités du premier processus executé par le système : init. Il prend en charge l'exécution
de l'ensemble des processus lancés par l'utilisateur par l'intermédiaire du shell (interpréteur de commande).
L’arreet d’un processus provoque l’arrêt de tous ses processus "fils"
Ainsi le processus init a un PID égal à 1. De même qu'il existe des commandes indiquant l'état d'un processus, des
commandes permettent de mettre en évidence les relations d’heritage entre les processus.
Commande
Description
ps
Permet de lister les processus suivant un certain nombre de critères
top
Permet d'avoir un suivi de l'évolution des processus et ce faisant, d'effectuer des
traitements comme on pourrait le faire avec ps, mais de façon interactive
pstree
Permet de lister les processus dans un arbre indiquant les liens de parentés entre eux
jobs
Permet de lister les processus lancés dans le shell courant
Fig 35. Les commandes de monitoring de processus
La commande ps peut être appellée avec différentes options, citons en exemple ps aux qui permet tous les
processus
48 / 81
Champ
PID
USER
PR
SIZE
RSS
SHARE
STAT
Description
Identifiant du processus
Le propriétaire du processus
Priorité de la tâche (plus le chiffre est petit plus la tâche est prioritaire)
Taille du processus en mémoire incluant la partie données et la pile
Quantité totale de mémoire occupée par la tâche
Quantité de mémoire partagée
Ce champ identifie par des lettres les différents états possibles pour un processus
• D : En sommeil imperturbable (ce qui arrive souvent à certain modules kernel)
• R : En cours d'exécution
• S : En sommeil
• T : Stoppé ou stracé (notamment pour le débugage)
• Z : Zombie (peut arriver lorsqu'un processus n'a pas attendu la fin de l'exécution
de l'un de ses fils)
LIB
Nombre de pages occupées par les bibliothèques
%CPU
Taux d'occupation du (des) processeur(s) par ce processus. Il peut être supérieur à
100% dans le cadre de machine ayant plusieurs processeurs
%MEM
Taux d'occupation de la mémoire physique du processus
TIME
Temps total d'exécution au sein du(des) processeur(s) depuis le lancement du
processus
COMMAND Affiche la ligne de commande qui a permis de lancer le processus
Fig 36. Les champs de ps et de top
9.2. Envoi de signaux aux processus
Afin de communiquer avec les processus, l’utilisateur ou le système leur envoi des signaux. Ceci est effectué par
l’intermédiaire de la commande kill.
L’option –l de la commande permet de lister les signaux disponibles.
Nom du SIGNAL
SIGHUP
SIGKINT
SIGKILL
SIGTERM
SIGTSTP
Description
Ce signal est envoyé directement lors de la déconnection à un modem ou
oblige un daemon à relire son fichier de configuration
Ce signal est équivalent au Ctrl-C et met fin à l'exécution d'un processus
Tue un processus de manière immédiate. Ce signal est à envoyé dans des
mesures drastiques et ne peut être ignoré par le processus
Termine un signal "proprement" si possible
Mets un processus en attente et , équivalent à Ctrl-Z
Fig 37. Les principaux signaux utilité
Note :
Chaque signal est également représenté par un nombre.
Attention : ce nombre peut varier d’un système à l’autre. C’est pour cela qu’il est préférable d’utiliser le nom
complet.
49 / 81
9.3. Arrière-plan, premier plan et détachement
Lorsqu’un programme est éxécuté, le shell prend en compte l'exécution du processus. Il faut donc attendre la fin de
celui-ci avant d'avoir à nouveau le prompt. On dit alors que le processus est au premier plan.
Il peut alors recevoir directement des signaux par les combinaisons de touches Ctrl-?.
Il existe cependant une autre possibilité ou le processus est dit en "Arrière plan". Le shell reprend alors la main sans
attendre la fin de l’éxecution du nouveau processus. Pour executer un processus en arrière plan, il suffit d’ajouter
un "&" à la fin de la commande.
Note :
Lorsqu’un processus est executé en arrière plan, aucun caractère de contrôle n’est disponible.
Il est possible d’arretter un processuss sans pour l’interrompre. Le processus est alors dit en sommeil (sleeping).
Il existe de plus d’autres commandes permettant de passer les processus en premier ou en arrière-plan. Il est
important de noter que les processus sont identifiés au niveau du shell bash par un "numéro de job" visible grâce à
la commande jobs
Commande
fg %N° de Job
bg %N° de Job
Ctrl-Z
Description
Permet de mettre un processus en avant plan
Permet de mettre un processus en arrière plan
Permet de mettre un processus en attente
Fig 38. Contrôle des processus sous le shell bash
Lorsque un shell est executé, ceci est fait au sein d’un terminal. Du fait de l’héritage, chaque processus initié par le
shell est donc "attaché" a son terminal d’origine (TTY). Il est cependant possible de "détacher" ce processus par le
biais de la commande disown suivi du PID du processus.
Cette action permet nottamment de pouvoir fermer une session sans pour autant arretter le processus.
Exemple :
disown 1394
9.4. Modification des priorités du Scheduler
Nous avons vu en introduction que les processus avaient des priorités et qu'elles étaient modifiables. En effet, les
propriétés évoluent sur une échelle de -20 à +19. Tout processus, au lancement, peut avoir une priorité quelconque
supérieure ou égale à zéro.
Note :
La prioritée la plus haute est représentée par -20, et la plus faible par +19
Cependant, un processus lancé par un utilisateur ne peut avoir une priorité négative. Seul l'administrateur système
possède ce droit. Par défaut un processus est lancé avec la priorité 10. Les commandes permettant de contrôler les
priorités des processus sont nice et renice.
Commande
nice priorité
renice priorité
Description
Permet d'affecter une priorité aux processus dès leur
lancement
Permet de modifier la priorité d'un processus alors que
celui-ci est déjà lancé
Options
-n N :permet d'ajuster la priorité par
défaut à N
-u "User" :change la priorité de tous
les processus d'un utilisateur
50 / 81
Fig 39. Les commandes nice et renice
Les 2 commandes utilisent l’option -p "PID" qui change la priorité d'un processus ayant un pid précis
9.5. Planification de tâches
Sur un système Linux, il est possible de planifier des tâches afin d’en démarrer l’execution à un instant précis, ou
de manière régulière.
Deux services (daemons) sont chargés de cette tâche :
• atd : pour les taches différées
• crond : pour les tâches répétées
Chacun de ces deux daemons possèdent une commande en premier plan : crontab pour crond et at pour atd.
Pour gérer les accès à ces commandes, l'administrateur dispose de fichiers de permissions situés dans le répertoire
/etc : cron.allow et at.allow qui definissent les autorisations et cron.deny et at.deny les refus.
Selon la présence ou l'absence de ces fichiers plusieurs règles rentrent en jeu :
• Aucun des fichiers n'existe : dans ce cas seul root à le droit d'utiliser les commandes
• Les fichiers cron.allow et at.allow existent : les utilisateurs dont les noms sont présents sont abilités à exécuter
les commandes
• Les fichiers cron.deny et at.deny existent : les utilisateurs dont les noms sont présents ne peuvent exécuter les
commandes.
9.5.1. La commande crontab
Il est important de ne pas faire l'amalgame entre la commande crontab et le fichier crontab. La commande crontab
permet de créer un fichier crontab possédant les différentes requêtes que l'utilisateur veut effectuer. Ce fichier porte
le nom de l'utilisateur et est stocké dans le répertoire /var/spool/cron avant d'être exécuté par crond. Cette
commande permet notament d'éditer le fichier et d'en supprimer le contenu.
Option
-u utilisateur
-e
-l
-r
Définition
Installation du fichier crontab pour utilisateur (nécessaire d'être root pour l'utiliser)
Modification du fichier crontab à l'aide de l'éditeur spécifié par les variables VISUAL ou EDITOR
Liste le contenu du fichier crontab courant
Élimination du fichier crontab courant
Fig 40. Les options de la commande crontab
Le fichier crontab créé par l'utilisateur est composé de cinq champs marquant la périodicitété et la commande à
effectuer. Ces champs sont ainsi définis:
Minute heure date mois "jour du mois" commande
La périodicité de chacun de ces 5 champs est représentée par des valeurs numériques comme ci dessous:
• minutes (0-59)
• heures (0-23)
• date (0-31)
• mois (1-12)
• jour de la semaine (0-7)ou (0 ou 7 indique le Dimanche)
Vous pouvez affiner la notion de périodicité par l'utilisation de:
51 / 81
•
•
•
•
, : sépare plusieurs valeurs
- : marque une période (exemple: 1-7,du lundi au dimanche)
* : représente l'ensemble des valeurs possibles
/ : permet de spécifier tous les x temps (exemple: */2 dans la colone des jours veut dire chaque 2 jours).
9.5.2. Le fichier crontab système
Le fichier /etc/crontab est également lu par le daemon crond et est différent du format d'un fichier crontab
ordinaire.
En effet, celui-ci possède des informations d'environnement qui précèdent généralement ses entrées (cela est aussi
permis pour les fichiers crontab ordinaires mais ce n'est pas souvent utilisé). Après les cinq champs initiaux se
trouve le nom d'un utilisateur pour lequel la commande doit être appelée.
Ce fichier est généralement utilisé pour appeler les scripts contenus dans les répertoires "cron.periode" se situant
dans le répertoire /etc :
• /etc/cron.hourly
• /etc/cron.daily
• /etc/cron.weekly
• /etc/cron.* répertoire contenant les exécutables
L'autre différence du fichier système crontab est qu'il fait appel à une commande particulière : run-parts. Cette
commande prend en argument un nom de répertoire et appelle tous les programmes compris dans ce répertoire
Voici un exemple de fichier /etc/crontab:
SHELL=/bin/bash
PATH=/sbin:/bin:/usr/bin:/usr/sbin
MAILTO=root
HOME=/
# run-parts
01
*
02
4
22
4
42
4
*
*
*
1
*
*
*
*
*
*
*
*
root
root
root
root
run-parts
run-parts
run-parts
run-parts
/etc/cron.hourly
/etc/cron.daily
/etc/cron.weekly
/etc/cron.monthly
Ainsi, chaque matin, à 4:02, tous les scripts (ou programmes du répertoire /etc/cron.daily sont exécutés. Le
répertoire cron.daily est créé lors de l'installation de votre distribution et contient des scripts servant à mettre à jour
les bases de données slocate et whatis, à nettoyer les répertoires temporaires et à exécuter d'autres tâches de
maintenance.
9.5.3. La commande at
La commande at permet de planifier un seul évènement futur de manière simple :
user@localhost $ at 6:00 ;
mail joe < joe.msg
Beaucoup d'autres commandes utilisent le daemon atd :
•
•
52 / 81
la commande atq (pour at queue, la file d'attente de at), fournit une liste des travaux at actuellement en cours.
Tout utilisateur privilégié (root) peut entrer un nom d'utilisateur comme argument pour obtenir les travaux en
cours d'autres utilisateurs.
la commande atrm est utilisée pour éliminer les travaux at en cours. L'atJobID s'affiche lorsque le travail est
soumis ainsi qu'à la demande de la commande atq. Tout utilisateur privilégié peut éliminer les travaux at
d'autres utilisateurs en fournissant le nom d'utilisateur (user ID) de ceux-ci.
Les commandes peuvent être indiquées (une par ligne), en terminant l'entrée par Ctrl-d seul, sur sa propre ligne.
53 / 81
10. Gestion réseau
Afin d'utiliser le réseau, il est tout d’abrd necessaire de disposer du support de la carte dans le noyau ou via un
module chargé au lancement du système.
Note :
Certaines distributions incluent des outils de détection automatique.
10.1. Configuration Automatique
Si le réseau dispose d’un serveur DHCP, la configuration se fait via la commande :
dhclient
Note :
la commande dhclient est la plus récente et la plus utilisée, mais il existe d'autres commandes tel que dhcpcd et
pump.
10.2. Configuration manuelle
10.2.1. Les interfaces et la commande ifconfig
Le noyau Linux attribue des noms d'interfaces composées d'un préfixe précis selon le type. Toutes les interfaces
Ethernet, par exemple, commençant par eth. Le préfixe est suivi d'un chiffre, le premier étant 0 (eth0, eth1, eth2...)
Type
Ethernet
Anneau à jeton
FDDI
Désignation
eth[01234...]
tr[01234...]
fddi[01234...]
Fig 41. Les différents types d’interface réseau
La commande ifconfig
La commande ifconfig permet de connaitre l'état des interfaces réseaux présentes et détectées par le système ainsi
que d’en faire la configuration.
L'option -a permet d'afficher toutes les interfaces actives ou non.
54 / 81
luser@localhost $ /sbin/ifconfig -a
eth0 Link encap:Ethernet HWaddr 00:04:AC:45:63:7E
inet addr:192.168.1.1 Bcast:192.168.1.255 Mask:255.255.255.0
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:164442 errors:0 dropped:0 overruns:0 frame:1
TX packets:133671 errors:0 dropped:0 overruns:72 carrier:0
collisions:0 txqueuelen:100
RX bytes:91115012 (86.8 Mb) TX bytes:33953990 (32.3 Mb)
Interrupt:10 Base address:0xc000
lo
Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
UP LOOPBACK RUNNING MTU:16436 Metric:1
RX packets:3431 errors:0 dropped:0 overruns:0 frame:0
TX packets:3431 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:197669 (193.0 Kb) TX bytes:197669 (193.0 Kb)
Pour la configuration d’une carte, il convient de respecter la syntaxe suivante :
ifconfig interface inet adresse_ip netsmask masque_ss_réseau broadcast adr_broadcast
ifup/ifdown
La commande ifup permet d'activer une carte réseau :
ifup <interface>
Exemple :
root@localhost # ifup eth0
La commande ifdown permet de désactiver une carte réseau :
ifdown <interface>
Exemple :
root@localhost # ifdown eth0
Note :
Attention les commandes ifup et ifdown ne sont pas présentes dans certaines distributions. Dans ce cas il faut
avoir recourt à la commande ifconfig :
root@localhost # ifconfig eth0 up
root@localhost # ifconfig eth0 down
10.2.2. Les routes
La commande route permet d'afficher la table de routage du système ainsi que la modification de celle ci :
root@localhost # route
Table de routage IP du noyau
Destination
Passerelle
Genmask
172.16.0.0
*
255.255.0.0
default
gate.esi-supinf 0.0.0.0
Indic Metric Ref
U
0
0
UG
0
0
Use Iface
0 eth0
0 eth0
55 / 81
Exemple de modification de la table de routage :
Pour attacher un sous réseau local à une interface :
root@localhost # /sbin/route add -net 172.16.1.0/25 dev eth0
Pour atteindre un sous réseau distant, il est nécessaire de spécifier une passerelle (gateway, en anglais) :
root@localhost # /sbin/route add -net 172.16.1.128/25 gw 172.16.1.125
Les communications ne correspondant à aucune des routes présentes utilisent la route par défaut (pour l'Internet
notamment) :
root@localhost # /sbin/route add default gw 172.16.1.1
10.2.3. La résolution de nom
Pour résoudre les noms sur le réseau, il faut stocker dans le fichier "/etc/resolv.conf" l'adresse IP de vos serveurs
DNS :
domain linux.net
nameserver 216.223.224.7
nameserver 216.223.224.6
Nous avons ici configuré le domaine du réseau (nux.net) et l'IP de deux serveurs DNS.
10.3. Les outils de tests réseau
10.3.1. Ping
La commande ping est la commande de base pour tester le réseau. Elle vérifie la connectivité entre 2 interfaces
réseau grâce au protocole ICMP.
user@localhost $ ping 127.0.0.1
127.0.0.1 est l'adresse loopback de votre interface réseau (lo). Si l’interface lo répond, c'est que le protocole
TCP/IP est supporté par le Kernel.
Pour tester la connectivité entre 2 interfaces, la syntaxe est la suivante :
ping <adresse_ip>
Note :
Il est également possible d’utiliser ping avec un nom de machine afin de tester le bon fonctionnement de la
résolution DNS
56 / 81
10.3.2. Traceroute
La commande traceroute vous permet de connaître le chemin des paquets émis par une interface.
La commande traceroute fonctionne au niveau réseau du modèle OSI. Elle ne détectera donc pas les passages par
des équipements réseau fonctionnant sur des couches inférieures ( hub,switchs).
Exemple :
user@localhost $ /usr/bin/traceroute mail.supinfo.com
traceroute to mail.supinfo.com (212.80.91.71), 30 hops max, 40 byte packets
1 gougniafier (192.168.1.1) 0.282 ms 0.147 ms 0.105 ms
2 193.253.160.3 (193.253.160.3) 55.493 ms 55.736 ms 58.933 ms
12 easy-interlan.router.easynet.fr (212.180.0.135) 55.892 ms 53.760 ms
13 easy-interlan-10.easynet.fr (212.180.93.42) 59.920 ms 56.677 ms 59.887
14 supinfo-2.supinfo.com (212.180.91.71) 57.182 ms 51.742 ms 53.876 ms
10.3.3. Netstat
Netstat permet d'afficher des détails sur les connexions actives de la machine (statistiques, ports...)
root@localhost # netstat -tlp
Active Internet connexions (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State
tcp
0
0
*:36167
*:*
LISTEN
tcp
0
0
*:6000
*:*
LISTEN
tcp
0
0
*:www
*:*
LISTEN
tcp
0
0
*:ssh
*:*
LISTEN
PID/Program name
20091/artsd
20032/X
17170/apache
8283/sshd
Pour afficher la liste des connexions actives :
root@localhost # netstat -top
Active Internet connexions (w/o servers)
Proto Recv-Q Send-Q Local Address
name
tcp
0
0
192.168.1.10:35514
7981/centericq
tcp
0
0
192.168.1.10:36240
28124/ncftp
tcp
0
0
192.168.1.10:33605
7981/centericq
tcp
0
0
192.168.1.10:35936
Foreign Address
State
PID/Program
205.188.9.63:5190
ESTABLISHED
nephtys.lip6.fr:45196
ESTABLISHED
207.46.106.47:1863
ESTABLISHED
gougniafier:ssh
ESTABLISHED 18543/ssh
La commande netstat dispose de nombreuses options accessibles depuis la man page de la commande.
57 / 81
11. Installation de programmes
Il existe de nombreuses distributions différentes de Linux. Les principales différences sont :
• Les utilitaires fournis avec le système pour l’administrer ou l’utiliser
• Le gestionnaire d’installation des programmes
• Des personnalisations au niveau du noyau
Nous allons à présent étudier les différentes méthodes de gestion d’installation des programmes pour différentes
distributions
11.1. L’approche Redhat
Les paquetages de la distribution Redhat sont présents sous deux formats :
• Un portant l'extension ".rpm" représentant l'application binaire (compilée)
• Un portant l'extension "src.rpm" représentant les sources (fichiers sources, documentation, fichiers
d'installation et de configuration) utilisées généralement pour créer des ".rpm".
Ces deux types de paquetages sont installés via la commande rpm.
11.1.1. Comment obtenir ces Paquetages ?
Redhat est une distribution commerciale destinée aux entreprises, elle est donc livrée avec un certain nombre de
paquetages de base, testés et approuvés par la société Redhat.
Toutes les applications autres que celles qui sont proposées doivent donc être téléchargées par l'utilisateur.
Généralement le téléchargement se fait en allant directement sur le site du paquetage après une recherche sur un
moteur de recherche. La difficulté de ce genre de méthode est la gestion des dépendances. En effet lorsque vous
installez un paquetage il est très rare que ce dernier ne dépende d'aucun autre paquetage ou d'aucune librairie. Il est
donc necessaire de télécharger l’ensemble des dépendances afin de pouvoir installer un logiciel
L'arrivée de Fedora a changé l'esprit de la distribution Redhat en se munissant d'une commande appelée "yum",
basée sur le rpm et permettant de télécharger des applications avec l'ensemble de leurs dépendances sur des miroirs
dont le but principal est l'hébergement d'applications (exemple: ftp://freshrpms.net).
11.1.2. Installation, désinstallation de paquetage
La commande rpm permet de gérer les programmes au travers des fichiers ".rpm" ainsi que de créer des fichiers
rpm à partir des rpm sources (src.rpm).
Option
-i fichier.rpm
-ql fichier.rpm
-e fichier.rpm
-qi fichier.rpm
-qa
-qf fichier
qpi
-V fichier
Description
Installation d’un paquetage rpm
Liste les dépendances d’un paquetage
Supprime un paquetage
Informations sur un paquet déjà installé
Liste de tous les paquets déjà installé
Donne le rpm d’appartenance du fichier
Informations sur les paquetages non installés
Vérifie le paquetage.
Fig 42. Les options de la commande rpm
58 / 81
Note :
L’option –V vérifie un paquetage. Si le paquetage est bon il n'y aura aucune sortie sinon nous verrons apparaître
des lettres indiquant les différents problèmes rencontrés. Voici donc ci-dessous un listing de ces différents
caractères :
5 : somme de contrôle md5
S : taille du fichier
L : lien symbolique
T : date de modification
D : fichier périphérique
U : l'utilisateur propriétaire du fichier
G : le groupe propriétaire du fichier
M : le mode du fichier
11.1.3. Création d'un rpm à partir des sources rpm
Tout fichier rpm est un fichier destiné à une architecture précise, par exemple : samba-2.2.5.i586.rpm est destiné
aux ordinateurs dotés d'un processeur de type i586.
Cependant il est intéressant d’utiliser les sources RPM afin de compiler une application de manière à ce qu'elle soit
optimisée pour notre processeur Bien sûr, il existe des paquetages génériques c'est à dire qui correspondent à toute
une famille de processeurs.
Exemple : samba-2.2.5-i386.rpm correspond à la famille x86.
Pour compiler un paquetage RPM source, il faut passer l'option --rebuild à la commande RPM comme ci-dessous:
root@localhost # rpm --rebuild samba-2.2.5.src.rpm
Après avoir compilé, le paquetage crée se retrouvera dans le répertoire /usr/src/redhat/RPMS/ dans lequel existe
d'autres répertoires portant le nom d'architecture comme i386,i586,etc... Tous les paquetages généralement créés de
cette manière placent le fichier compilé dans le répertoire i386.
11.2. L’approche Debian
Les paquetages debian existent comme ceux de Redhat sous deux formats, un format binaire identifié par
l'extension (.deb) et un format source indentifié lui par l'extension (.dsc). Les commandes généralement utilisées
pour les installer sont celles présentées ci-dessous :
dpkg : commande dite de bas niveau, en ligne de commande, elle permet l'installation , la désinstallation et la
gestion des informations des paquetages installés.
apt-get : cette commande est la commande la plus populaire du système débian.C'est une commande de haut
niveau, servant d'interface à la commande dpkg. Elle permet le téléchargement et l'installation automatique des
paquetages en gérant toutes les dépendances de celui-ci.
dselect : c'est une interface de la commande apt-get. Elle est exécutée lors de l'installation d'un système Débian.
Il est important de noter que chaque paquet provenant du monde libre est testé au maximum de ses possibilités, ceci
permettant de lever tous les bugs possibles afin de les corriger et ainsi de les faire migrer vers le niveau de stabilité
le plus sûr possible.
59 / 81
Ces paquetages ainsi testés évoluent d'une version à une autre de Débian. En effet on distingue trois distributions de
base chez Debian définie par le niveau de stabilité des logiciels :
•
•
•
Unstable ou "Sid" : cette distribution est la moins stable et la plus récente de Débian. Une fois certains bugs
corrigés, les paquets migrent en testing. Elle est utile pour les utilisateurs expérimentés voulant bénéficier des
dernières versions des applications.
Testing ou "Sarge" : cette distribution offre des paquetages stables mais dont l'ensemble des tests de sécurité
n'ont pas été effectués.
Stable ou "Woody" : cette distribution est la plus stable de Débian. Elle est utilisé pour les Serveurs et les
utilisateurs normaux.
Les paquetages Debian, quelque soit la version utilisée, sont généralement téléchargés via la commande apt-get. La
commande apt-get récupère les applications dans une arborescence bien définie appelée "pool" et présente sur
différents mirroirs Debian.
Cette arborescence est répartie en 3 grandes familles de répertoire.
• Main : contient uniquement des logiciels libres qui représentent la distribution officielle Débian.
• Contrib : c'est la que sont stockés des logiciels libres mais dépendant de paquetages propriétaires.
• Non free : c'est le répertoire des logiciels payant ou possédant des licences très restrictives.
11.2.1. Installation, désinstallation, informations, mise à jour
L'installation, d'une manière générale, est faite à l'aide de la commande apt-get, cependant la commande dpkg est
tout de même nécessaire.
dpkg -i samba-2.2.5.deb
apt-get install samba
Note :
Si l’on ne connait pas le nom exact du logiciel, il est possible d'avoir une description des différents logiciels
disponibles. En faisant apt-cache search "mot_clé" , on obtient un listing de tous les paquetages ayant soit
dans leurs descriptions le mot clé recherché soit dans leurs noms. Ce mot clé accepte les globbings.
Pour supprimer
dpkg -r samba
ou
dpkg --purge samba
apt-get remove samba
ou
apt-get --purge remove samba
Note :
L'option --purge indique ici de supprimer à la fois le paquetage mais aussi l'ensemble des fichiers de configurations
installés.
L'ensemble des informations d'un paquetage installé sont mises en évidence grâce à la commande dpkg. Voici
quelques options les plus souvent utilisées dans ce cas :
• dpkg -l : permet d'afficher l'ensemble des paquetages installés
• dpkg -L foobar : affiche l'ensemble des fichiers constituant un paquetage
• dpkg -s foobar : affiche l'état d'un processus
• dpkg -S fichier : permet de retrouver l'appartenance d'un fichier à un paquetage
60 / 81
De même que Redhat, il est possible d'afficher notamment des informations sur les paquetages non installés, mais
ce via la commande apt. L'option de la commande apt à utiliser fait appel à un cache ou est listé l'ensemble des
fichiers à jour pouvant être téléchargés sur Debian.
La commande est :
apt-cache show feh
Permet de visualiser les informations d'un paquetage installé ou pas sur la machine.
Afin de mettre à jour le cache une commande doit être utilisée qui est :
apt-get update.
11.2.2. Création d'un fichier deb à partir des sources dsc
Si vous êtes un féru de programmation et que vous vous intéressez d'étudier le code source ou éventuellement de
faire des corrections sur du code bogué avoir les sources d'une application serait intéressant.
Pour cela apt fournit des commandes permettant de télécharger les sources et des fichiers permettant la création
d'un fichier .deb .
Pour télécharger un paquet source :
apt-get source nomdupaquet
Cela va télécharger trois fichiers : un .orig.tar.gz, un .dsc et un .diff.gz. Dans le cas où les paquets sont faits
spécialement pour Debian, le dernier de ceux-ci n'est pas téléchargé et le premier n'a généralement pas « orig »
dans le nom.
Le fichier .dsc est utilisé par dpkg-source pour dépaqueter le paquet source dans le répertoire nomdupaquetversion. Avec chaque paquet source téléchargé, il y a un répertoire du nom de l'application qui contient les fichiers
nécessaires pour la création d'un paquet .deb.
Pour créer le .deb allez à l'intérieur du répertoire créé pour le paquet après le téléchargement et tapez la commande
suivante:
dpkg-buildpaquetage -rfakeroot -uc -b
11.3. L’approche Gentoo
Gentoo a été dévéloppée en intégrant diverses idées provenant du monde BSD et Linux, mais en essayant
d'automatiser un maximum de tâches.
Les paquetages fournis par gentoo ; les ebuild ; fournissent la procédure automatisée de la construction et de la
configuration du programme à partir des sources en incluant la gestion des dépendances.
L'ensemble de ces paquetages fait partie d'une d'une arborescence appelée portage qu'il est important de mettre à
jour régulièrement.
61 / 81
La commande de base utilisée pour installer des paquetages Gentoo est la commande emerge, cette commande
permet non seulement d'installer des paquetages mais aussi de supprimer , d'obtenir des informations et de mettre à
jour l'ensemble du Portage.
11.3.1. Installation, désinstallation, informations sur les paquetages
emerge samba
Note :
La commande emerge -s "mot_clé" permet de rechercher les paquetages faisant référence au mot clé spécifié.
Pour supprimer un paquetage :
emerge -C samba
Pour mettre à jour les portages :
emerge sync
11.4. Installation par les sources
Les paquetages installés par les sources sont présents sous la forme de fichier tar compréssé soit en bzip2 soit en
gzip2. Ces paquetages sont construits toujours de la même manière. On les appelle des "tarballs". Cette méthode
d’installation générique fonctionne sur toutes les distributions
La procédure d'installation d'un tarball suit toujours la même logique ainsi définie :
Prenons l'exemple d'un paquetage appelé packetage.tar.gz :
Etape 1 : Téléchargement de l’archive à l’aide de la commande wget
user@localhost $ wget http://www.foobar.com/Dowload/packetage.tar.gz
Etape 2 : Décompression de l’archive à l’aide de la commande tar
user@localhost $ tar xzf packetage.tar.gz
Etape 3 : Aller dans le répertoire créé par la décompression
user@localhost $ cd packetage
Etape 4 : Lancement du script shell configure
user@localhost $ ./configure
Cette étape aura pour but de créer un fichier Makefile à l'aide de l'utilitaire "autoconf", qui permettra la compilation
du logiciel.
Il est possible de passer des options à ce script, permettant par exemple de modifier le chemin d'installation, grâce à
--prefix=<répertoire> (défaut : /usr/local).
62 / 81
Etape 5 : Compilation de l’application
user@localhost $ make
Etape 6 : Installation
root@localhost # make install
Note :
Cette dernière étape doit être executée en tant que root car l’installation necessite la copie de fichiers dans les
répertoires systèmes.
63 / 81
12. Scripting Bash
12.1. Introduction
Le shell est un interpréteur de commande qui sert d'interface entre l'utilisateur et le système d'exploitation. Bash
est le plus utilisé des shells, c'est celui sur lequel nous nous baserons tout au long de ce chapitre. De plus, Bash est
aussi un language de programmation complet visant à simplifier et automatiser les taches quotidiennes des
administrateurs.
12.2. Création et invocation d'un script
12.2.1. Création d'un script
Un script est un ensemble de commandes placées dans un fichier texte. Chaque ligne de ce fichier correspond à une
ligne qui aurait pu être saisie par un utilisateur dans un terminal.
Un script est destiné à un interpréteur qui lit, analyse, et exécute les commandes qu'il contient. Dans le cas d'un
shell-script, l'interpréteur est un des shells d'Unix (bash, sh...). Dans ce document, nous allons apprendre à écrire un
script en Bourne-shell (bash ou sh).
La première ligne d'un script doit spécifier le programme à appeler pour l'interpréter. Elle doit commencer par la
séquence "#!".
Pour un shell-script écrit en Bourne-shell, elle sera :
#!/bin/bash
Pour un script Perl, la première ligne sera :
#!/usr/bin/perl
Le nom d'un shell-script peut être quelconque, mais on choisit généralement :
- soit "mon script" (sans extension), pour que son nom ait l'air d'une commande Unix comme une autre.
- soit "mon script.sh" pour indiquer explicitement qu'il s'agit d'un shell-script.
12.2.2. Invocation d'un script
On peut exécuter un script comme toute autre commande en l'appelant par son nom.
Pour cela, il faut d'une part que les droits d'exécution soient positionnés correctement :
chmod +x mon_script
et, d'autre part, que le chemin du fichier appartienne à la variable d'environnement PATH (sinon, vous devriez
systématiquement préciser le chemin de votre script pour l'exécuter.
64 / 81
Une autre façon d'exécuter un script, et qui aboutit au même résultat, est d'invoquer son interpréteur avec le nom du
script en paramètre (exemple : "bash mon script.sh").
Il faut savoir que, ainsi lancé, un script s'exécute dans un shell secondaire (sous-shell), totalement indépendant du
shell qui l'a appelé. Ceci aura pour effet d'annuler toute modification de l'environnement du script (changement de
chemin avec cd, création ou modification de variables, etc...) dès lors que le script sera terminé.
Pour éviter cela, et donc permettre à un shell-script de modifier l'environnement de votre shell, il suffit d'appeler ce
script grâce à la commande "source" (ou '.').
. mon_script
ou
source mon_script
Toutes les commandes du script sont alors exécutées dans le shell actuel.
Premier exemple de script :
#! /bin/bash
echo "hello world"
Execution de notre script :
$ ./hello.sh
Hello world
Une autre facon de le lancer, cette fois-ci en appelant le script par l'interpreteur :
$ bash hello.sh
Hello World
Enfin de cette facon le script est lancé dans le shell en cours :
$ . hello.sh ou source hello.sh
Hello World
12.3. Commentaires et taches de fond :
Chaque ligne commençant par un # ne sera pas traitée comme une commande mais comme un commentaire par le
shell.
#! /bin/bash
#debut du script
echo hello world
#fin du script
De plus, toute commande suivie du caractère '&' s'executera en tâche de fond (arrière plan).
65 / 81
12.4. Valeur retournée par un script shell à la fin de son execution
Par défaut un script renvoie en fin d’éxecution le code de retour de la dernière commande exécutée. Par convention,
une valeur de retour égale à 0 signifie que le script s'est bien déroulé. Inversement, toute autre valeur indique une
erreur. De plus, on peut fixer cette valeur par la commande :
exit n
Comme pour toute commande, la valeur de retour d'un script peut être récupérée dans la variable $?.
12.5. Commandes d'un shell-script
12.5.1. Commandes simples
Dans un script, on peut employer toute commande exécutable par l'utilisateur dans un terminal:
• un mot-clé appartenant au Bourne-shell (exemple : if, case, ...)
• une commande interne (builtin) au Bourne-shell (exemple : echo, umask,...)
• une fonction définie par l'utilisateur avec le mot-clé function
• une commande externe (commande appartenant aux chemins de la variable PATH).
Pour connaître le type une commande, on utilise type :
$ type while
while is a shell keyword
$ type cd
cd is a shell builtin
$ type lsc
lsc is aliased to 'ls -color=auto'
$ type mkdir
mkdir is /bin/mkdir
12.5.2. Commandes composées
Les exemples qui suivent sont donnés avec deux commandes mais peuvent être étendus à N commandes.
Commandes séquentielles
commande1 ; commande2
Exécute commande1 puis commande2.
Le point-virgule permet de réunir sur une seule ligne plusieurs instructions qui devraient être sur plusieurs lignes
séparées.
Note :
66 / 81
Attention à ne pas systématiquement utiliser cette mise en forme car elle peut nuire à la lisibilité.
Le pipe
commande1 | commande2
Exécute commande1 et envoi le résultat à commande2.
Grâce au tube, commande2 effectue son traitement sur le texte qu'aurait affiché commande1.
Attention, commande1 et commande2 s'exécutent dans deux shells secondaires (sous-shells) et, par conséquent,
toute modification qu'ils apportent à l'environnement (variables, chemin actuel,...) est perdue dès la fin de la
commande.
Commandes en parallèles
commande1 & commande2
Exécute commande1 et commande2 en parallèles. commande1 est exécutée en tâche de fond.
Commande sur erreur
commande1 || commande2
Exécute commande2 si et seulement si commande1 a échoué ; généralement utilisé dans les conditions de
structures de type if, while et until.
Commandes sur réussite
commande1 && commande2
Exécute commande2 si et seulement si commande1 s'est bien déroulée. Généralement utilisé dans les conditions
des structures if, while et until.
Commandes en paramètre
commande1 $(commande2) ou commande1 `commande2`
Cette combinaison exécute commande1 avec en paramètre le résultat de commande2.
Exemple :
#!/bin/sh
#
# Shell-script de mise en application de la récupération du résultat
# d une commande. Affiche l'heure en français.
heures=$(date +%H)
minutes=`date +%M`
echo "Il est $heures heures $minutes minutes et `date +%S` secondes"
user @ localhost $ ./script.sh
Il est 12 heures 29 minutes et 42 secondes
Les deux variantes proposées sont strictement identiques. On peut utiliser l'une ou l'autre pour des raisons de
commodités.
67 / 81
Utilisation des parenthèses et des accolades
{ commande1 ; commande2; }, ( commande1; commande2 )
Les parenthèses et accolades permettent d'encadrer une série de commandes séparées les unes des autres par "&",
"&&", "|", "||" ou " ;".
L'usage des parenthèses ou des accolades permet à l'ensemble des commandes qu'elles contiennent de subir une
redirection. En effet, avec la commande "ls src ; ls bin | lpr", seul le contenu du répertoire bin est imprimé car une
redirection ne s'applique qu'à la commande qui précède. Par contre, la commande " {ls src ; ls bin ; } | lpr"
provoque bien l'impression du contenu des répertoires src et bin.
On préférera généralement les accolades aux parenthèses car les instructions situées entre parenthèses s'exécutent
dans un shell secondaire indépendant du shell actuel (voir l'utilisation du tube, plus haut).
Note :
Attention, la dernière commande de la liste entre accolades doit être terminée par un point-virgule.
12.6. Affichage à l'écran
La commande "echo texte" permet d'écrire un texte à l'écran. Bien que ce ne soit pas nécessaire, pour éviter tout
problème il est vivement conseillé d'encadrer le texte à afficher par des guillemets.
Si le texte à afficher est une chaîne vide, la commande provoque un saut de ligne. L'option -n évite le saut de ligne
automatique à la fin du texte.
Tout le texte situé entre les guillemets est interprété comme une chaine standard (à l’exception des variables).
L'option -e permet l'interprétation des caractères spéciaux utilisés avec printf() en langage C{, tels l'alarme, le
retour à la ligne, la tabulation, ou autre.
Exemples :
echo "Texte à
afficher"
echo ""
echo -n "Ce texte ne sera pas suivi d'un saut de ligne"
echo -e "\t\aCe texte commence par une tabulation et émet un signal sonore."
12.7. Lecture au clavier
La commande read utilisée seule permet de récuperer une entrée faite au clavier et terminée par un retour chariot
(touche entrée). La phrase lue est stockée dans la variable REPLY (attention a bien respecter la casse).
La commande "read mot1 mot2 reste" permet aussi de lire une phrase au clavier mais son premier mot est affecté à
la variable mot1, son deuxième mot est affecté à mot2 et le reste de la phrase est affecté à la variable reste.
Exemple :
68 / 81
user@localhost$ echo -n "Entrez votre nom de login et votre nom civil: "; read log
nom
Entrez votre nom de login et votre nom civil: moliere Jean-Baptiste Poquelin
luser@localhost$ echo "$log est le login de $nom"
moliere est le login de Jean-Baptiste Poquelin
Attention : une opération comme "cat fichier | read ligne" ne fonctionnera pas car l'instruction read (tout comme
l'instruction cat) sera exécutée dans un shell indépendant et le contenu de la variable ligne sera perdu dès la fin de
l'opération.
Par contre "read ligne < fichier" fonctionnera.
12.8. La commande select
La commande select permet d'offrir un menu à l'utilisateur. Sa syntaxe est :
select variable in "choix1" "choix2" ... "choixN"
do
liste d'instructions
done
Le menu présenté comporte l'ensemble des choix proposés précédés d'un numéro.
Une invite est affichée et le shell attend une entrée au clavier. La variable PS3 doit contenir la chaîne d'invite ("# ?
" par défaut).
Lorsque l'utilisateur a entré son choix, le corps de la boucle est exécuté. La variable REPLY contient alors ce que
l'utilisateur a rentré (un numéro normalement). Si le choix de l'utilisateur correspond à l'une des propositions qui lui
sont faites, la variable "variable" contient aussi la chaîne correspondante ("choix1", "choix2", ... ou "choixN").
Exemple :
#!/bin/bash
echo "Faites un choix"
select rep in "rep1" "rep2" "rep3" "rep4";
do
if [ -z "$rep" ];
then
echo "Erreur, veuillez saisir une autre valeur"
else
echo $rep
break
fi
done
Test:
user@localhost$ ./test.sh
Faites un choix
1) rep1
2) rep2
69 / 81
3) rep3
4) rep4
#?
12.9. Redirections des entrées-sorties standard
Avant tout, il faut savoir que toute redirection ne s'applique qu'à la dernière commande.
Dans le cas d'une série de commandes séparées par "&", "&&", "|", "||" ou " ;", si l'on veut que la redirection
s'applique à l'ensemble des commandes, il faut employer des parenthèses (voir la partie "commandes composées").
L'entrée standard (stdin) peut être redirigée afin de lire dans un fichier plutôt qu'au clavier. Pour cela, placez "<
fichier" en fin de commande. Exemple : pour lire la première ligne d'un fichier
user@localhost$ read < mon_script; echo $REPLY
#! /bin/sh
La sortie standard (stdout) peut être redirigée afin d'écrire dans un fichier plutôt qu'à l'écran. Pour cela, placez ">
fichier" ou ">> fichier" en fin de commande. Si l'opérateur ">>" est utilisé, le contenu actuel du fichier est conservé
et le texte est ajouté en fin de fichier.
Exemple :
toto> echo "FIN DU FICHIER" >> fichier
La sortie standard d'erreur (stderr) peut être redirigée afin d'écrire dans un fichier plutôt qu'à l'écran. Pour cela,
placez "2> fichier" en fin de commande.
Exemple :
Pour supprimer les messages d'erreur de l'affichage :
./ma_commande 2> /dev/null
La sortie standard et la sortie standard d'erreur peuvent être redirigées ensemble afin d'écrire dans un fichier plutôt
qu'à l'écran. Pour cela, placez "&> fichier" en fin de commande.
Exemple :
Pour qu'une commande n'affiche rien, même pas les erreurs
ma_commande &> /dev/null
La sortie standard peut être redirigée vers la sortie standard d'erreur en ajoutant "1>&2" à la fin de la commande.
Exemple :
Pour afficher un message sur stderr plutôt que sur stdout :
echo "Erreur fatale, le disque est plein!" 1>&2
en ajoutant "2>&1" à la fin de la commande.
Exemple :
70 / 81
Pour afficher le résultat d'une commande page par page, y compris les erreurs :
ma_commande 2>&1 | more
L'entrée standard peut être lue depuis le shell-script en ajoutant "<<FIN DU TEXTE" à la fin de la commande.
Toutes les lignes comprises entre la commande et la ligne "FIN DU TEXTE" seront interprétées comme si elles
avaient été lues au clavier. Le texte à afficher peut contenir des variables voire même l'expression "$(commande)".
Exemple :
Pour afficher plusieurs lignes de texte sans utiliser echo à chaque fois :
cat << FIN_DU_TEXTE
Vous êtes l'utilisateur $USER.
Vous êtes situé dans le répertoire $(pwd).
Merci de votre visite.
FIN_DU_TEXTE
La redirection par tube et l'emploi de l'expression "$(xxx)" ont déjà été décrits dans la partie "Commandes
composées".
12.10.
Variables et paramètres
12.10.1.
Variables
Contrairement au DOS qui ne connaît que les variables d'environnement, les shells d'Unix font la distinction entre
variables simples et variables d'environnement.
Seules les variables d'environnement sont transmises aux programmes lancés depuis le shell.
(exception : lorsqu'on utilise le tube ou les parenthèses dans une commande composée, toutes les variables sont
communiquées aux sous-shells qui sont lancés implicitement - par contre, ce qui suit reste valable).
La modification d'une variable n'est perçue que par le shell qui la modifie et par ses descendants (c'est-à-dire les
commandes qu'il exécute) lorsque c'est une variable d'environnement.
Il s'ensuit qu'un script ne pourra jamais modifier les variables du shell courant, sauf s'il est appelé avec la
commande source (voir plus haut "Invocation d'un script").
En Bourne-shell, définir une variable se fait par la commande : variable="valeur". Il est important que valeur soit
spécifiée entre guillemets ou apostrophes, et qu'il n'y ait d'espaces ni avant ni après le signe '='. Si valeur est
absente, la variable est créée mais contient une chaîne vide.
L'utilisation d'une variable se fait grâce à l'expression $variable ou ${variable}.
La deuxième notation est nécessaire si la variable est suivie d'un texte qui pourrait être interprété comme faisant
partie du nom de la variable.
Exemple :
user@localhost$ jour=10; mois=11; an=1997; heures=19; minutes=30
71 / 81
user@localhost$ echo "Nous sommes le $jour/$mois/$an"
Nous sommes le 10/11/1997
user@localhost$ echo "Il est ${heures}h ${minutes}mn"
Il est 19h 30mn
Définir une variable d'environnement se fait par la commande "export variable=valeur".
Transformer une variable en variable d'environnement se fait par la commande "export variable". Afficher la liste
des variables d'environnement se fait par la commande "export". Afficher la liste complète des variables se fait par
la commande "set". La commande "unset var" permet de détruire définitivement la variable var.
Au lancement du shell, beaucoup de variables sont prédéfinies, qu'elle soient d'environnement ou non. Par exemple,
USER contient le nom de l'utilisateur, HOME contient le chemin de son répertoire personnel, etc... Pour en avoir la
liste complète, on utilise les commandes "set" ou "export". D’avantage d’informations sont disponibles sur le
manuel en ligne : man bash
Sous Bourne-shell, certaines variables ont un sens spécial :
• $$ donne le numéro de processus (pid) du shell.
• $! donne le numéro de processus (pid) de la dernière commande lancée en tâche de fond (c'est-àdire avec l'opérateur '&').
• $? donne la valeur retournée par la dernière commande.
• $ donne la liste des options avec lesquelles le shell a été appelé.
12.10.2.
Paramètres
La variable $# donne le nombre de paramètres accompagnant l'appel du shell-script.
Les variables $@ et $* donnent l'ensemble des paramètres. La différence entre les deux termes ne s'observe que
lorsqu'ils sont donnés entre guillemets. En effet, "$*" correspond à une seule valeur contenant tous les paramètres
alors que "$@" correspond à autant de valeurs qu'il y a de paramètres.
On peut accéder à chaque paramètre en spécifiant son numéro après le signe $. Si le numéro tient sur deux chiffres
ou plus, il doit être donné entre accolades.
Exemples :
$1, ..., $9, ${10}, ${11}, ...\ Le paramètre $0 correspond au nom complet (avec le chemin) du shell- script.
La commande "shift N" élimine les N premiers paramètres de la liste des paramètres (N ne doit pas être supérieur
au nombre de paramètres). La variable $# est diminuée d'autant.
La commande shift permet de décaler les paramètres, c'est à dire que $1 prend la valeur de $2, $2 prend la valeur
de $3, etc...
#! /bin/sh
#
# params
#
# Shell-script de mise en application des paramètres d'un script.
# Affiche l'ensemble des paramètres passés au script.
echo "Vous avez lancé le shell-script $0"
echo "Vous lui avez fourni $# paramètres qui sont: $*"
echo ""
echo "Liste des paramètres :"
72 / 81
echo "----------------------"
numParam=1
for parametre in "$@"; do
echo "Paramètre $numParam = $parametre"
let $[numParam += 1]
done
echo ""
echo -n "Après la commande 'shift $#', "
shift $#
echo "il reste $# paramètres"
Test :
user@localhost$ ./params A BC DEF "GH IJ"
Le shell-script est executé en fournissant les 4 paramètres suivants : A BC DEF GHIJ:
luser@localhost$./params A BC DEF GHIJ
Liste des paramètres:
--------------------Paramètre 1 = A
Paramètre 2 = BC
Paramètre 3 = DEF
Paramètre 4 = GH IJ
Après la commande 'shift 4', il reste 0 paramètres
12.11.
Calcul mathématique
Le shell permet d'effectuer des calculs mathématiques mais uniquement sur des entiers. Il y a deux syntaxes
possibles :
• let $[ expression mathématique ]
• let $(( expression mathématique ))
L'expression mathématique peut faire intervenir n'importe quelle variable (pas forcément précédée du signe $) ainsi
que n'importe quel nombre entier décimal (219), hexadécimal (0xDB ou 16#DB), octal (0333 ou 8#333) ou binaire
(2#011011011). Tous les opérateurs du langage C sont autorisés (+, -, *, %, ||, >>, =, +=, ^=, ==, !=, etc...), y
compris les parenthèses.
On peut aussi utiliser la formulation "commande $[ expression mathématique ]". Dans ce cas, l'expression
mathématique est remplacée par sa valeur puis la commande est exécutée.
Exemple :
user@localhost$
3
user@localhost$
1
user@localhost$
0
user@localhost$
user@localhost$
144
echo $[ b % a ]
echo $[ a != 0 ]
echo $[ b > 20 ]
let $[ c = ( ( b + a ) << 4 ) & 0xFF ]
echo $c
12.12.
73 / 81
Les structures conditionnelles
12.12.1.
Les conditions
La condition d'exécution des structures conditionnelles qui suivent est qu'une commande aboutisse, c'est à dire que
sa valeur de retour soit 0.
La commande qui sert de condition peut être une commande composée, en particulier on utilise souvent une
formule du type "commande1 && commande2" ou "commande1 || commande2".
La condition peut donc être inversée si on fait précéder la commande d'un point d'exclamation.
" ! commande" signifie que la condition est vraie si la commande échoue.
Note :
Attention, le point d'exclamation s'applique uniquement à la commande qui le suit ; pour qu'il s'applique à une
commande composée, il faut l'encadrer avec des accolades (ou des parenthèses).
Exemples :
if commande; then echo "La commande a fonctionné"; fi
if ! commande; then echo "La commande a échoué"; fi
if commande1 && ! commande2; then \\
echo "commande1 a fonctionné mais pas commande2"; fi
if ! { commande1 || commande2; } ; then \
echo "Ni commande1 ni commande2 n'ont fonctionné"; fi
12.12.2.
Les tests
La condition d'exécution devant être une commande, les tests s'effectuent par l'intermédiaire de la commande "test
expression" qui peut être abrégée par la formule "[expression ]".
Les tests possibles peuvent porter sur des entiers, des chaînes de caractères ou des fichiers / répertoires :
Test
-e fichier
-s fichier
-r fichier
-w fichier
-x fichier
-O fichier
-G fichier
-b nom
-c nom
-d nom
-f nom
-L nom
-p nom
fichier1 -nt fichier2
fichier1 -ot fichier2"
fichier1 -ef fichier2
Description
Vrai si le fichier/répertoire existe.
Vrai si le fichier à une taille supérieure à 0.
Vrai si le fichier/répertoire est lisible.
Vrai si le fichier/répertoire est modifiable
Vrai si le fichier est exécutable ou si le répertoire est accessible.
Vrai si le fichier/répertoire appartient à l'utilisateur.
Vrai si le fichier/répertoire appartient au groupe de l'utilisateur
Vrai si nom représente un périphérique (pseudo-fichier) de type bloc
(disques et partitions de disques généralement).
Vrai si nom représente un périphérique (pseudo-fichier) de type caractère
(terminaux, modems et port parallèles par exemple).
Vrai si nom représente un répertoire.
Vrai si nom représente un fichier.
Vrai si nom représente un lien symbolique.
Vrai si nom représente un tube nommé.
Vrai si les deux fichiers existent et si fichier1 est plus récent que fichier2.
Vrai si les deux fichiers existent et si fichier1 est plus ancien que fichier2.
Vrai si les deux fichiers représentent un seul et même fichier.
Fig 43. Les tests sur fichiers et répertoires
74 / 81
12.12.3.
Tests sur les entiers
Test
entier1 -eq entier2
entier1 -ge entier2
entier1 -gt entier2
entier1 -le entier2
entier1 -lt entier2
entier1 -ne entier2
Description
vrai si entier1 est égal à entier2
vrai si entier1 est supérieur ou égal à entier2
vrai si entier1 est strictement supérieur à entier2.
vrai si entier1 est inférieur ou égal à entier2.
vrai si entier1 est strictement inférieur à entier2.
vrai si entier1 est différent de entier2.
Fig 44. Les tests sur entiers
12.12.4.
Tests sur les chaînes
Test
-n "chaîne"
-z "chaîne »
"chaine1" ="chaine2"
"chaine1" != "chaine2 »
Description
vrai si la chaîne n'est pas vide.
vrai si la chaîne est vide.
vrai si les deux chaînes sont identiques.
vrai si les deux chaînes sont différentes.
Fig 45. Les tests sur entiers
12.12.5.
Combinaison de tests
Lorsqu'un test doit être inversé ou lorsque plusieurs tests doivent être combinés par des ET et des OU, deux
notations sont possibles.
- La première a été présentée dans la partie précédente ("Les conditions") ; préférable car plus lisible.
- La deuxième fait partie de la syntaxe de la commande test :
"NON expr" se traduit par "test ! expr" ou "[ ! expr ]"
"expr1 OU expr2" se traduit par "test expr1 -o expr2" ou "[ expr1 -o expr2 ]"
"expr1 ET expr2" se traduit par "test expr1 -a expr2" ou "[ expr1 -a expr2 ]"
12.12.6.
Structure Si...Alors...Sinon
Il existe différentes manières d’effectuer un test et de déclencher une action en fonction du résultat de ce test :
Algorithme :
Si [TEST]
Action
Sinon si :
Action
Sinon :
Action
Exemple :
if y = 3
then
echo « y est égal à 3 »
elif y = 4
then
echo "y est égal à 4 »
else
echo « valeur inconnue »
Note :
Les sections "elif" et "else" sont optionnelles. D'autre part les actions à effectuer peuvent être composées de
plusieurs commandes sur une ou plusieurs lignes.
75 / 81
Exemple :
#! /bin/sh
# Shell-script de mise en application de l'instruction if...then...else.
# Affiche le signe d'un nombre et de son opposé.
#
# Saisie de n
#
echo -n "Entrez un nombre: "
read n
if test $n -lt 0; then # n < 0 ?
echo "Le nombre $n est négatif"
elif test $n -gt 0; then # n > 0 ?
echo "Le nombre $n est positif"
else # n = 0
echo "Le nombre $n est nul"
fi
let $[ n = -n ]
echo "Le nombre choisi devient $n"
if [ $n -le 0 ]; then # n <= 0 ?
if [ ! $n -eq 0 ]; then # n != 0 ? C'est à
dire n < 0 ?
echo "Le nombre $n est négatif"
else # n = 0
echo "Le nombre $n est nul"
fi
else # n > 0
echo "Le nombre $n est positif"
fi
Test :
user@localhost$ ./signe
Entrez un nombre: 3
Le nombre 3 est positif
Le nombre choisi devient -3
Le nombre -3 est négatif
user@localhost$ ./signe
Entrez un nombre: 0
Le nombre 0 est nul
Le nombre choisi devient 0
Le nombre 0 est nul
12.12.7.
Structure TantQue
En Bourne-shell, la structure algorithmique se traduit par :
TantQue commande aboutie
action
FinTQ
while [y –lt 5 ]; do
echo "hello world" ; let $[ y+=1 ]
done
TantQue commande échoue
action
FinTQ
until [y –gt 5 ]; do
echo "hello world" ; let $[ y+=1 ]
done
L'action à effectuer peut être composée de plusieurs commandes sur une ou plusieurs lignes.
Exemple :
#! /bin/sh
#
# factorielle
#
# Shell-script de mise en application de l'instruction while.
# Affiche la factorielle du nombre donné en paramètre.
if [ $# -ne 1 ] || [ $1 -lt 0 ]; then
echo "Usage: factorielle n (avec n >= 0)" 1>&2
else
resultat=1
n=$1
while [ $n -gt 1 ]; do
let $[ resultat *= n]
let $[ n -= 1]
done
echo "$resultat"
fi
Test:
user@localhost$ factorielle 3
6
user@localhost$ factorielle 6
720
user@localhost$ factorielle $(factorielle 3)
720
Exemple :
#! /bin/sh
#
# testfact
#
# Shell-script de mise en application de l'instruction until.
# Teste le shell-script de calcul de factorielles.
n=0
until [ $n -eq 14 ]; do
resultat=$(factorielle $n)
echo "$n! = $resultat"
let $[ n += 1 ]
done
Test:
user@localhost$ ./testfact
0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
[…]
11! = 39916800
12! = 479001600
13! = 1932053504
76 / 81
77 / 81
12.13.
Autres structures exécutives
12.13.1.
Structure Pour
Pour chaque élément de l'ensemble (element1, element2, ..., elementN), on effectue une action sur element. En
Bourne-shell, cette structure algorithmique se traduit par :
for element in element1 element2 ... elementN; do
action $element
done
Exemple :
#! /bin/sh
#
# fichier_ou_repertoire
#
# Shell-script de mise en application de l'instruction for.
# Affiche le type (fichier ou répertoire) de chaque paramètre.
for param in "$@"; do # Pour chaque paramètre...
if [ -f "$param" ]; then # C'est un fichier?
echo "$param est un fichier."
elif [ -d "$param" ]; then # C'est un répertoire?
echo "$param est un répertoire."
elif ! [ -e "$param" ]; then # N'existe pas
echo "$param n'existe pas."
else # C'est autre chose?
echo "$param n'est ni un fichier, ni un répertoire."
fi
done
Test :
user@localhost$ ./fic_ou_rep XXX /etc "./un rep/" /etc/hosts "./un rep/un fic"
/dev/lp0
XXX n'existe pas.
/etc est un répertoire.
./un rep/ est un répertoire.
/etc/hosts est un fichier.
./un rep/un fic est un fichier.
/dev/lp0 n'est ni un fichier, ni un répertoire.
luser@localhost$
Note :
Sous Unix, les espaces sont des caractères légaux dans les noms de fichiers et de répertoires. Sans les guillemets
dans le script et sur la ligne de commande, "./un rep/" aurait été interprété comme deux mots distincts : "./un"
et "rep/".
12.13.2.
Structure Selon
Selon valeur
Cas X : action 1
case $VALUE in
X) echo "Value est égale a X";;
78 / 81
cas Y : action 2
cas Z : action 3
defaut :
FinSelon
Y) echo "Value est égale a Y";;
Z) echo "Value est égale a Z";;
*) echo "Value est différent »
esac
Les actions à effectuer peuvent être composées de plusieurs commandes sur une ou plusieurs lignes. Pour chaque
cas, la série de commandes à exécuter doit être terminée par deux points-virgules que l'on placera de préférence sur
une seule ligne.
Les cas à tester peuvent employer les caractères génériques autorisés pour les fichiers.
Par exemple, les cas "a ? ? ?b", "A*B*C" et [a-z]*[0-9] sont tout à fait valides. Si toutefois un caractère fait partie
d'un cas à tester, il faudra l'encadrer par des guillemets pour qu'il ne soit pas interprété.
Exemple :
#! /bin/sh
#
# question
#
# Shell-script de mise en application de l'instruction case.
# Pose une question et attend une réponse par oui ou non.
# La valeur retournée est 0 pour oui et 1 pour non.
retour=X
while [ "$retour" = "X" ]; do
echo -n "On continue (O/N) ? "
read reponse
case "$reponse" in
o* | O* )
retour=0
;;
[nN]* )
retour=1
;;
"?"* )
echo "Il n'y a pas d'aide disponible"
;;
* )
echo "Erreur : entrez [O]ui ou [N]on."
;;
esac
echo ""
done
exit $retour
Test :
user@localhost$ question ; echo "Retour = $?"
On continue (O/N) ? bof
Erreur: entrez [O]ui ou [N]on.
On continue (O/N) ? oui, je veux bien
Retour = 0
user@localhost$ question ; echo "Retour = $?"
On continue (O/N) ? ???
Il n'y a pas d'aide disponible
On continue (O/N) ? Non, merci
Retour = 1
user@localhost$
12.13.3.
79 / 81
Structure Lorsque
Grâce à la commande trap, on peut déclencher une action sur un événement particulier. La contrainte est que cet
événement soit un signal que l'on peut intercepter
Note :
En utilisant trap –l, il est possible d’obtenir la liste des signaux. Enfin man 7 signal donne des détails
supplémentaires sur ces signaux.
Lorsque le signal SIGNAL survient trap "action" SIGNAL action FinLorsque
L'action peut être une commande composée. Dès qu'elle ne se limite pas à un seul mot, elle doit être précisée entre
guillemets. Les guillemets et apostrophes situés à l'intérieur doivent être précédés par un anti-slash.
- La commande trap utilisée seule donne la liste des actions exécutées pour chaque signal.
- La commande "trap SIGNAL" annule l'action à exécuter à l'arrivée du signal SIGNAL.
Exemple :
#! /bin/sh
# exTrap
# Shell-script de mise en application de l'instruction case.
trap "echo Le script s\'est terminé" EXIT
trap "echo Vous avez appuyé
sur Ctrl-C" SIGINT
trap "echo Vous avez fait: kill $$" SIGTERM
trap "echo J\'ai été
stoppé
et je continue" SIGCONT
trap "echo J\'ai rec?u SIGUSR1 ou SIGUSR2" SIGUSR1 SIGUSR2
echo "Processus $$: J'attend un signal..."
#
# Compte à rebours
#
i=10
while [ $i -gt 0 ]; do
echo -n "$i "
sleep 1
let $[ i -= 1 ]
done
echo "0"
Test :
user@localhost$ ./exTrap
Processus 1658: J'attend un signal...
10 9 Vous avez appuyé sur Ctrl-C
8 7
[1]+ Stopped exTrap
user@localhost$ kill -SIGUSR1 1658
user@localhost$ fg
exTrap
J'ai reçu SIGUSR1 ou SIGUSR2
J'ai été stoppé et je continue
6 5 4
[1]+ Stopped exTrap
80 / 81
user@localhost$ kill -SIGUSR2 1658
user@localhost$ kill 1658
user@localhost$ fg
exTrap
J'ai reçu SIGUSR1 ou SIGUSR2
Vous avez fait: kill 1658
J'ai été stoppé et je continue
3 2 1 0
Le script s'est terminé
user@localhost$
12.14.
Fonctions
Le Bourne-shell offre la possibilité de définir ses propres fonctions. Bien qu'elles soient internes à un shell, elles
s'emploient comme un script externe. Mais leur appel ne provoque pas le lancement d'un sous-shell, donc une
fonction a accès à toutes les variables, pas seulement celles d'environnement, et leur modification reste prise en
compte lorsque la fonction se termine.
Syntaxe :
function maFonction()
{
local var1
local var2="valeur"
commande1
commande2
return val;
}
Le mot-clé "local" permet de définir des variables locales à la fonction.
La dernière commande doit être terminée par un point-virgule.
On accède aux paramètres d'une fonction comme à ceux d'un script : grâce aux variables $*, $@, $#, $1, $2, ... qui
sont temporairement modifiées pendant toute la durée de la fonction. En revanche, $0 ne change pas.
Le retour d'une valeur s'effectue grâce au mot-clé return. Si return n'est pas employé, la valeur de retour est celle
de la dernière commande exécutée.
Attention, l'emploi de la commande exit termine non seulement la fonction mais aussi le script.
Une fonction peut être récursive, c'est à dire qu'elle peut s'appeler elle-même.
Une fois définie, une fonction apparaît dans la liste des variables. On peut l'exporter vers les autres shells grâce à la
commande "export -f maFonction".
Exemple :
#! /bin/sh
# signe2
# Shell-script de mise en application des fonctions.
# Affiche le signe d'un nombre et de son carré.
# carré(nombre)
# Retourne le carré du nombre donné en paramètre.
#
# Paramètres: $1 -> Le nombre dont on veut le carré
#
function carré()
{
return $[ $1 * $1 ]
}
# affSigne(nombre)
#
# Affiche le signe du nombre donné
en paramètre.
#
# Paramètres: $1 -> Le nombre dont on teste le signe.
#
function affSigne()
{
local signe
if [ $n -lt 0 ]; then # n < 0 ?
signe=négatif
elif [ $n -gt 0 ]; then # n > 0 ?
signe=positif
else # n = 0
signe=nul
fi
echo "Le nombre $1 est $signe"
}
#
# Programme principal
#
echo -n "Entrez un nombre: "
read n # Saisie de n
affSigne $n # Affichage du signe de n
carré
$n # Calcul du carré
de n
n=$? # Récupération du résultat
echo "Le carré
du nombre choisi est $n"
affSigne $n # Affichage du signe de n
Test :
user@localhost$ ./signe2
Entrez un nombre: -5
Le nombre -5 est négatif
Le carré du nombre choisi est 25
Le nombre 25 est positif
user@localhost$ ./signe2
Entrez un nombre: 0
Le nombre 0 est nul
Le carré du nombre choisi est 0
Le nombre 0 est nul
81 / 81

Essentiels laboratoire Linux - Wiwishack

Transcription

Documents pareils

Essentiels laboratoire Cisco

Administrateur Système Diplômé de SUPINFO Titre d`expert en

Ecole Supérieure d`Informatique SUPINFO

Dalleau Thierry - Direct Best Invest Excellence SCA

École Supérieure d`Informatique SUPINFO

Une nouvelle école d`ingénieurs à Casablanca

Élève Ingénieur en Informat

Page 1 sur 1 supinfo lance son programme de formation

CV : Consultant, développeur - Decompiler