Академический Документы
Профессиональный Документы
Культура Документы
Support du cours
SYSTEMES D'EXPLOITATION 2
LMD L2
Janvier 2018
Ce support de cours est mis à disposition selon les termes de la licence « Creative Commons
Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0
International ».
https://creativecommons.org/licenses/by-nc-sa/4.0/deed.fr
» Partager copier, distribuer et communiquer le matériel par tous moyens et sous tous
formats.
» Adapter remixer, transformer et créer à partir du matériel
» Attribution Vous devez créditer l'œuvre, intégrer un lien vers la licence et indiquer
si des modifications ont été effectuées à l'œuvre. Vous devez indiquer ces
informations par tous les moyens raisonnables, sans toutefois suggérer que l'offrant
vous soutient ou soutient la façon dont vous avez utilisé son œuvre.
» Pas d’utilisation commerciale Vous n'êtes pas autorisé à faire un usage commercial
de cette œuvre, tout ou partie du matériel la composant.
» Partage dans les mêmes conditions Dans le cas où vous effectuez un remix, que
vous transformez, ou créez à partir du matériel composant l'œuvre originale, vous
devez diffuser l'œuvre modifiée dans les même conditions, c'est à dire avec la même
licence avec laquelle l'œuvre originale a été diffusée.
Plan du cours
4.2. Modifier le propriétaire et le groupe sur les fichiers et les répertoires .......................... 47
5.4. Gestion des comptes et des options de création par défaut ........................................... 52
TD N° 1 ................................................................................................................................ 74
TD N° 2 ................................................................................................................................ 76
TD N° 3 ................................................................................................................................ 78
TD N° 4 ................................................................................................................................ 81
TD N° 5 ................................................................................................................................ 83
Correction du TD N° 1 ......................................................................................................... 86
Correction du TD N° 2 ......................................................................................................... 90
Correction du TD N° 3 ......................................................................................................... 94
Correction du TD N° 4 ......................................................................................................... 99
Plan du chapitre :
C’est le rôle du système d’exploitation de gérer la mémoire, les accès aux périphériques, les
données sur les disques, les programmes, la sécurité et la collecte des informations.
Le schéma précédent présente une synthèse simplifiée de la structure interne d’un système
d’exploitation Unix. En bas se trouve le matériel, en haut les programmes qu’on fait
fonctionner sur la machine. Entre les deux les divers composants du système assurent son bon
fonctionnement.
1.1.2. Historique
UNIX désigne une famille de systèmes d'exploitation dont le premier a été conçu aux
"laboratoires Bell".
1969 : Thompson et Ritchie produisent la première édition d'un système primitif qui
ne comporte qu'un assembleur et un chargeur.
1970 : La primitive « fork » est ajoutée pour permettre la création de processus et des
programmes utilitaires pour la gestion des fichiers sont produits (deuxième édition).
1971 : Un système de traitement de textes (roff) est produit. Thompson et Ritchie
publient la première documentation du système. C'est la troisième édition.
1972 : UNIX est amélioré en lui ajoutant la notion de relais (pipe). Il existe à l'époque
environ 20 sites utilisant le système UNIX.
1973 : UNIX est réécrit en langage C (quatrième édition).
1974 : La cinquième édition, conçue spécialement pour des fins académiques, est
introduite.
1975 : La sixième édition d’UNIX est produite et devient la première à être
commercialisée pour une somme modique par "AT&T".
1977 : Près de 500 sites utilisent UNIX. À partir de ce moment, les versions d’UNIX
vont se multiplier. C'est à cette époque que débute le problème de standard.
1980 : Il y a environ 100 000 sites UNIX.
1983 : "AT&T" annonce le System V.
1984 : Production de la version 2 de System V avec un support complet pour le
système d'exploitation et les utilitaires.
1986 : "AT&T" annonce la version 3 de System V qui supporte RFS (Remote File
Sharing).
1987 : Une nouvelle version d’UNIX est annoncée. C'est le System V version 4.0 qui
sera disponible à l'automne 1989. Donc deux versions vont subsister : System V 5.3
de "AT&T" et BSD 4.3 de "Berkeley".
Pour défendre le logiciel libre, Stallman a créé la FSF (Free Software Foundation) en 1985
qui diffuse les idées du logiciel libre. Parmi ses premiers travaux figure la rédaction d’une
licence spéciale pour ces logiciels appelée la GPL (General Public License). Un logiciel libre
garantit quatre libertés :
Liberté 0 : la liberté d’utiliser un logiciel quel que soit l’usage que vous en faites.
Liberté 1 : la liberté d’étudier le fonctionnement du programme et de l’adapter à votre
besoin.
Liberté 2 : la liberté de redistribuer des copies afin d’aider votre voisin (au sens large
du terme).
Liberté 3 : la liberté d’améliorer le programme et de diffuser les améliorations au
public à fin d’en faire bénéficier l’ensemble de la communauté.
1991 : Linus Torvalds a créé le système Linux (Linus' UNIX, l'UNIX de Linus). Il
lance un appel à contribution, et permet donc un libre accès au code source. Cette
version permet de faire tourner quelques applications GNU (logiciels libres)
essentielles comme le compilateur gcc ou le Shell bash. Linus prend la décision de
mettre le code source sous licence GPL : tout le monde peut alors participer au
développement de Linux.
1991-94 : Linux devient un système UNIX complet compatible avec les autres
systèmes UNIX, offrant toujours plus de services de qualité professionnelle au plus
grand nombre.
1994-97 : L’apparition des grandes distributions Linux : Red Hat, Debian, Suse et
Slackware. Durant ces années, Linux ne cesse de s’améliorer, avec l’arrivée notable
de la modularité et de la version 2.0. Les projets foisonnent, et déjà l’idée d’améliorer
le système et de l’ouvrir au monde du bureau (desktop) fait son bout de chemin avec le
début du développement de produits comme Gnome ou KDE.
1998~ : L’explosion de l’utilisation de Linux. Les salons Linux se multiplient et l'on
observe une multiplication des revues spécialisées. Le noyau 2.6 sort le 18 décembre
2003.
Aujourd’hui et demain : Aujourd’hui Linux est reconnu comme un système
d’exploitation stable, robuste et performant. Il est utilisé dans plus du tiers des
serveurs dans le monde et dans la moitié des serveurs Web. Il a conquis le monde de
l’entreprise, le monde universitaire. Il a surtout su conserver son indépendance,
garantie par la communauté et le nombre de contributeurs, face aux géants de
l’informatique. La prochaine grosse cible de Linux, c’est le poste de travail, et
pourquoi pas, l’usage familial en remplacement de Windows. Il reste encore un peu de
chemin, mais nombreux sont ceux qui ont déjà franchi le pas.
Linux est le plus souvent diffusé sous forme d’une distribution, un ensemble de programmes
(noyau, sources des utilitaires, commandes, applications) formant après installation un
système complet. Chacune des distributions a ses avantages et ses inconvénients. Débuter
avec Linux, c’est surtout choisir une distribution qui corresponde avec les usages qu’on attend
du système.
Parmi les distributions les plus utilisées, on trouve RedHat, Debian, Slackware (toutes trois
gratuites) et SuSE, Mandrake (toutes deux payantes).
֍ Durée : 2 heures.
֍ Mots clés : système de fichiers, ext2, ext3, ext4, reiserfs, xfs, vfat, fdisk, mkfs, fsck,
mount, umount, fstab, df, du.
Plan du chapitre :
Introduction
Un système de fichiers, appelé communément File System ou FS, définit l’organisation des
données sur un support de stockage, donc comment sont gérés et organisés les fichiers par le
système d’exploitation.
Linux est, comme tout Unix, un système d’exploitation entièrement orienté fichier. Tout (ou
presque) est représenté par un fichier, tant les données (fichiers de données de tout type
comme une image ou un programme), que les périphériques (terminaux, souris, clavier, carte
son, etc.) ou encore les moyens de communication (sockets, tubes nommés, etc.). On peut dire
que le système de fichiers est le cœur de tout système Unix.
/boot : contient principalement le fichier binaire du noyau ainsi que les ressources
nécessaires à son lancement au démarrage.
/dev : contient les fichiers des périphériques (devices) de la machine ainsi que des
fichiers spéciaux.
/home : répertoire où sont stockés par défaut les répertoires home des utilisateurs du
système.
/etc : répertoire très important où sont stockés tous les fichiers de configuration du
système en général et des différents démons en particulier. Il s’agit du répertoire à
sauvegarder pour pouvoir restaurer la configuration d'une machine.
/proc : contient les informations nécessaires au noyau. C'est une arborescence
virtuelle généralement en lecture seule sauf /proc/sys.
/root : répertoire home du super-utilisateur (root).
/tmp : permet aux applications et aux utilisateurs d'avoir un espace d'échange où ils
peuvent stocker leurs fichiers temporaires. Il est effacé à chaque redémarrage de la
machine (« reboot »).
/usr : contient les fichiers nécessaires aux applications, la documentation, les
manuels, les fichiers sources ainsi que des librairies généralement statiques et générées
à l'installation des logiciels standards de la distribution.
/usr/local : arborescence qui sert à installer les logiciels supplémentaires.
/var : contient les fichiers journaux des différents démons (donc variable) ainsi que
les spools de mail, d'impression, de cron, etc.
/bin et /sbin : contiennent l'ensemble des binaires indispensables au démarrage de la
machine et les commandes essentielles d’administration.
/lib et /usr/lib : contiennent les librairies nécessaires aux commandes précédentes.
L’action de « formater » un disque, une clé ou tout support de données consiste uniquement à
créer sur un support de mémoire secondaire l’organisation logique permettant d’y placer des
données. Le mot « formatage » n’est quasiment jamais utilisé sous Linux. On parle de
système de fichiers qui est à la fois l’organisation logique des supports au niveau le plus bas
comme au niveau de l’utilisateur.
Si les principes de base sont souvent les mêmes entre les divers systèmes présents sous Linux,
les implémentations et les organisations logiques des données sur le disque varient fortement.
Aussi il n’existe pas un type de système de fichiers, mais plusieurs, au choix de l’utilisateur,
administrateur ou ingénieur.
Le principe de base est d’associer un nom de fichier à son contenu et d’y permettre l’accès :
création, modification, suppression, déplacement, ouverture, lecture, écriture, fermeture.
Suivant ce principe, le système de fichiers doit gérer ce qui en découle : mécanismes de
protection des accès (les permissions, les propriétaires), les accès concurrents, etc.
Un fichier est décrit par des propriétés appelées les métadonnées. Sous Linux, il s’agit de
l’inode. Le contenu (les données) est placé dans d’autres blocs du support de stockage. Le
contenu des métadonnées diffère d’un système de fichiers à un autre.
2.1.2.2. ext3
L’ext3 « third extended filesystem » est le successeur d’ext2 depuis 1999. Il est
journalisé. Surtout, il est entièrement compatible avec ext2. Le journal est une extension
d’ext2. Il est possible d’utiliser un système de fichiers ext3 comme étant ext2, avec les
mêmes commandes, les mêmes manipulations. Il est possible de transformer en quelques
secondes un système ext2 en ext3, et vice versa. C’est l’un des systèmes de fichiers de choix
pour Linux, et le plus utilisé actuellement pour sa souplesse.
2.1.2.3. ext4
2.1.2.4. reiserfs
reiserfs a été le premier système de fichiers intégré à Linux, avant même ext3. Sa force
réside, outre dans son journal, dans l’organisation indexée des entrées des répertoires et la
manipulation des fichiers de petite taille. Ses performances sont exceptionnelles en présence
2.1.2.5. xfs
xfs est le plus ancien des systèmes de fichiers journalisés sous Unix, datant de 1993. Outre
ses capacités de stockages, il a un système de journalisation très performant et des
mécanismes avancés comme la défragmentation en ligne, la capacité d’effectuer des
snapshots, le dimensionnement à chaud, la réservation de bande passante pour les entrées et
sorties, etc.
2.1.2.6. vfat
vfat (Virtual File Allocation Table) est un terme générique regroupant les diverses
versions de FAT supportant les noms de fichiers longs (255 caractères) sous Windows. Ces
systèmes de fichiers sont conservés et continuent d’être utilisés pour des raisons à la fois
historiques et pratiques. La plupart des supports amovibles, disques externes, clefs USB et
lecteurs MP3 utilisent un système de fichiers de ce type.
Une partition est définie par son type, son emplacement de début de partition et enfin soit sa
taille, soit son emplacement de fin de partition. Un partitionnement est réversible (non
physique).
Une seule partition est activée à la fois au niveau du BIOS : cette activation indique où le
BIOS doit aller chercher le noyau du système d’exploitation pour le démarrage.
Les partitions principales : leur nombre est limité à quatre et elles supportent tous
types de systèmes de fichiers.
La partition étendue : elle ne peut contenir que des partitions logiques et ne peut pas
recevoir de systèmes de fichiers. Elle ne peut exister que s’il existe une partition
principale.
Les partitions logiques : elles sont contenues dans une partition étendue. Elles ne
sont pas limitées en nombre et acceptent tous types de systèmes de fichiers.
Les descripteurs de disques durs dans le répertoire /dev commencent par hd pour les
périphériques de type IDE ou par sd pour les périphériques de type SCSI. Une lettre
additionnelle est ajoutée au descripteur pour désigner le périphérique.
Il y a généralement deux contrôleurs IDE en standard sur un PC, chaque contrôleur supportant
deux périphériques (disques, lecteur de cédérom/DVD, lecteur ZIP, etc.).
Primaire Secondaire
Maître a c
Esclave b d
2.2.3. Formatage
Les commandes de création des principaux types de système de fichiers supportés par Linux
sont présentées dans le tableau suivant.
xfs mkfs.xfs
vfat mkfs.vfat
mkfs.ext3 /dev/hda1
mkfs -t ext3 /dev/hda1
mke2fs -j /dev/hda1 # création du journal spécifique.
Il est aussi très facile de transformer une partition ext2 en ext3 avec l'instruction
tune2fs pour créer le journal : tune2fs -j /dev/hda1.
Il existe des commandes équivalentes pour chaque type de système de fichiers, par
exemple fsck.ext3.
Une vérification de toutes les partitions est faite au démarrage du système par la
commande fsck.
La commande e2fsck est équivalente à fsck –t ext2.
L’utilitaire debugfs est utilisé pour examiner et modifier l’état d’un système de
fichiers formaté en ext2.
L’utilitaire dumpe2fs permet d’afficher les informations d’un système de fichiers
formaté en ext2.
Pour pouvoir utiliser un système de fichiers, celui-ci doit être monté sur un point de montage
de l'arborescence Linux : son contenu est alors accessible comme un simple répertoire.
Exemple : pour monter et démonter une clé USB de type « flashdisk » décrite par le
fichier device sda1, on utilise les commandes suivantes :
Le fichier /etc/fstab est utilisé pour le montage automatique des systèmes de fichiers au
moment du démarrage du système.
Les commandes mount et umount utilisent le fichier fstab. Il est important que les données
de ce fichier soient complètes et exactes.
La commande mount –a monte tous les systèmes de fichiers répertoriés dans le fichier fstab.
Cette commande est généralement exécutée au moment de démarrage du système.
La commande du (disk usage) est très pratique pour connaître l'espace occupé par une
arborescence. L'option -s permet d'afficher le total pour chaque élément et l'option -k de
l'afficher en kilo-octets : du -ks /usr/local.
֍ Durée : 3 heures.
֍ Mots clés : Shell, chemin relatif, chemin absolu, redirection, gestionnaire de paquets,
pwd, ls, lsattr, du, cd, mkdir, rmdir, chmod, chattr, touch, file, iconv, tr, cat, more, less,
head, tail, tac, nl, wc, uniq, grep, sort, cut, paste, cp, ln, mv, split, rm, comm, diff, cat,
tee, find, locate, tar, gzip, bzip2, gunzip, bunzip2, unzip, man, which, whereis, whatis,
apropos.
Plan du chapitre :
3.1. Le Shell
3.1.1. Présentation
interprète les commandes tapées au clavier par l'utilisateur et exécute les programmes.
fournit à l'utilisateur un langage de programmation interprété.
permet de modifier l'environnement de travail.
réalise les redirections des entrées-sorties.
Il en existe plusieurs versions : le Bourne Shell (sh), le C Shell (csh), le Korn Shell (ksh), le
bash, le tcsh, etc.
# introduit un commentaire.
$ introduit un nom de variable.
& lance la commande en background.
; sépare 2 commandes tapées sur une même ligne.
!! relance la commande précédente.
!ch relance la dernière commande commençant par ch.
!n relance la commande numéro n.
^ch1^ch2 remplace la chaîne ch1 par la chaîne ch2 dans la dernière commande.
<, <<, >, >> et | sont des caractères utilisés pour les redirections des entrées-sorties.
' délimite une chaîne de caractères contenant des espaces sans substitution de
variables.
" délimite une chaîne de caractères contenant des espaces avec substitution de
variables.
\ annule la signification du caractère spécial suivant.
( et ) font exécuter les commandes incluses dans un sous-Shell.
{ et } regroupent les commandes incluses en une liste.
Un nom de fichier (ou de répertoire) peut être constitué de lettres minuscules, majuscules, de
chiffres et de quelques autres caractères comme « . », « _ », « - ».
Le « . » n'a pas la notion d'extension que l'on trouve, par exemple, sous Windows. Un nom de
fichier peut d'ailleurs comporter plusieurs « . ».
Les noms de fichiers Unix sont limités à 255 caractères et les chemins absolus à 1024.
Pour spécifier un nom de fichier, il est possible de donner soit son chemin relatif, soit son
chemin absolu.
Le chemin absolu commence par la racine, notée / et indique le chemin à parcourir depuis
celle-ci jusqu'au répertoire ou fichier désiré.
Par exemple /home/user1/tp/tp1.f est le chemin absolu jusqu'au fichier tp1.f, lui-même
contenu dans le sous-répertoire tp de l'utilisateur user1.
Par exemple, le fichier désigné précédemment par son chemin absolu peut également être
désigné par son chemin relatif. En supposant que l'utilisateur user1 se trouve dans son
répertoire d'accueil on peut désigner le fichier par : tp/tp1.f ou ./tp/tp1.f ou
../user1/tp/tp1.f ou ~/tp/tp1.f.
Exemple : grep abc < essai, la chaîne abc est recherchée dans le fichier
essai.
Exemple : ls >> liste2, si le fichier liste2 n'existe pas, il est créé, sinon le
résultat de la commande ls est ajouté à la fin du fichier liste2.
Dans les distributions GNU/Linux, un paquet (package) est un fichier d'archives compressé
contenant l'ensemble des fichiers nécessaires au fonctionnement d'une application donnée.
Les paquets contiennent aussi la liste des autres paquets (dépendances) dont l'application a
besoin.
La distribution "Debian" et ses dérivées (Ubuntu, Mint, Linspire, Mepis, etc.) qui
utilisent le format .deb.
La distribution "RedHat" et ses dérivées (CentOS, Fedora, Mandriva, Scientific Linux,
etc.) ainsi que "openSUSE" qui utilisent le format .rpm.
Les options et arguments forment ce que l'on appelle les paramètres de la commande. Les
arguments présentent généralement un ou plusieurs noms de fichiers ou de répertoires.
GNU/Linux est sensible à la casse, c'est-à-dire qu’il fait la différence entre une majuscule et
une minuscule. Ainsi "essai", "Essai" ou "ESSAI" désignent des fichiers différents.
Changer de répertoire : cd
Créer un répertoire : mkdir
Supprimer un répertoire : rmdir
Changer les droits d'accès aux répertoires : chmod
Changer les attributs de répertoires : chattr
Syntaxe : pwd
3.5.1.2. La commande « ls »
Exemples :
3.5.1.4. La commande « du »
Exemples :
3.5.1.5. La commande « cd »
Syntaxe : cd répertoire
Exemples :
La commande rmdir supprime un répertoire si et seulement s’il est vide. Sinon, il faut utiliser
la commande rm.
La commande chmod change les droits d'accès aux répertoires ou aux fichiers. On ne peut
modifier les droits d'accès à un ou plusieurs répertoires ou fichiers que si l'on en est
propriétaire.
Type d'utilisateur :
u : propriétaire (user).
g : groupe du propriétaire (group).
o : les autres (other).
a : tous (all).
Type d'action :
Type d'accès :
en entier : cat
page par page : more, less
le début : head
la fin : tail
en ordre inverse : tac
précédé des numéros de lignes : nl
La commande file identifie le type d'un fichier (fichier texte ; fichier archivé, compressé ou
codé ; fichier non imprimable ; fichier image). Si file ne reconnaît pas le type d'un fichier, il
affiche data.
3.5.2.4. La commande « tr »
Exemples :
tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ
tr a-z A-Z
tr '[:lower:]' '[:upper:]'
Afficher chaque mot sur une ligne indépendante en convertissant tous les
caractères non alphanumériques en sauts de lignes, puis en regroupant les
lignes blanches successives en un seul saut de ligne : tr -cs '[a-zA-Z0-9]'
'[\n*]'.
La commande less affiche le contenu d'un fichier page par page. Elle peut être considérée
comme le successeur de more. Elle fait la même chose mais offre davantage de possibilités,
comme le retour en arrière.
La commande tac affiche le contenu d'un fichier en ordre inverse, c'est à dire en commençant
par la fin.
3.5.2.11. La commande « nl »
3.5.2.12. La commande « wc »
Exemples :
Syntaxe : sort [-fnru] [-t car] [+i] [-j] [-o sortie] fichier
Options principales :
Exemples :
sort +1 liste trie le fichier liste (liste de prénoms et noms, e.g. Robert
BIDOCHON) par ordre alphabétique des noms.
sort -n -t : +1 -2 adresses : trie le fichier adresses (liste de prénoms,
numéros de téléphone et villes, e.g. robert:0380234567:Dijon) par numéros de
téléphones.
Exemples :
3.5.2.18. La commande « cp »
La commande cp copie de fichier. Pour copier plusieurs fichiers d'un seul coup, il faut utiliser
les caractères spéciaux du Shell.
cp tp1/* tp2 : copie tous les fichiers du répertoire tp1 dans le répertoire tp2.
cp -ir tp1 tp2 : copie le répertoire tp1 dans le répertoire tp2 en demandant
confirmation à chaque fichier.
3.5.2.19. La commande « ln »
3.5.2.20. La commande « mv »
Syntaxe : mv [-fi] source cible. Si cible est un nom de fichier, source est
renommé en cible. Si cible est un nom de répertoire, source est déplacé dans le
répertoire cible.
Option principale : -f force la commande.
Exemples :
3.5.2.22. La commande « rm »
Exemples :
Syntaxe : comm [-123] fichier1 fichier2. Elle sépare les lignes en 3 groupes :
Options :
La commande tee copie l'entrée standard sur la sortie standard, et dans tous les fichiers
fournis en argument.
Si un fichier n'existe pas, il est créé. Si le fichier existe déjà, il est écrasé, à moins que l'option
-a soit précisée.
-a, --append : Ajouter l'entrée standard aux fichiers indiqués plutôt que de les
écraser.
--help : Afficher un message d'aide sur la sortie standard et se terminer
normalement.
-i, --ignore-interrupts : Ignorer les signaux d'interruption.
La commande find recherche un (ou plusieurs) fichier(s) dans un répertoire. Cette commande
est automatiquement récursive.
Pour les options -size, -amin, -atime, -cmin, et -ctime, on peut préciser :
n : exactement n.
-n : inférieur à n.
+n : supérieur à n.
Ces options peuvent être combinées aux moyens des opérateurs logiques :
-o : OU logique
-a : ET logique
! : NON logique
Exemples :
La commande locate liste des fichiers d’une base de données correspondant à un motif. On
peut mettre à jour manuellement la base de données en utilisant la commande updatedb.
tar
gzip
bzip2
gunzip
bunzip2
unzip pour les fichiers MS-DOS.
Options principales :
Exemples :
La commande man affiche les pages de manuel expliquant les différentes commandes, leurs
fonctionnements et leurs options.
La commande whereis fonctionne de façon similaire à which, peut aussi chercher dans les
pages de manuel (man) et les codes sources.
La commande whatis cherche des commandes dans l'intégralité des systèmes de fichiers
comme which mais utilise une base de données qui contient une courte description ainsi que
des mots clés.
La commande apropos utilise la même base de données que whatis, mais donne plus
d'informations.
֍ Mots clés : chmod, umask, SUID, SGID, Sticky Bit, chown, chgrp.
Plan du chapitre :
4.2. Modifier le propriétaire et le groupe sur les fichiers et les répertoires .......................... 47
Linux permet de spécifier les droits dont disposent les utilisateurs sur un fichier ou un
répertoire par la commande chmod.
u : le propriétaire (user).
g : le groupe.
o : les autres (others).
r : lecture (read).
w : écriture (write).
x : exécution.
- : aucun droit.
Exemples :
Les droits d'accès peuvent aussi s'exprimer en notation octale. Les correspondances sont
indiquées dans le tableau 4-1 suivant.
On peut utiliser la notation octale pour les droits avec la commande chmod, cela permet de
positionner plusieurs types de droits en une seule commande.
Exemples :
Tableau 4-1 : Expression des droits sur les fichiers en notation octale
Lorsqu’on crée un nouveau fichier, ce dernier possède certains droits par défaut. La
commande umask permet de changer ces droits par défaut. Les droits sont indiqués de façon
"inverse" en notation octale pour les droits de type r et w seulement.
Il existe trois droits spéciaux, SUID, SGID et Sticky Bit. Ils peuvent être positionnés par la
commande chmod (premier groupe de droits exprimés en octal) :
SUID (Set User ID) : Ce droit s'applique aux fichiers exécutables, il permet d'allouer
temporairement à un utilisateur les droits du propriétaire du fichier. Par exemple, la
commande /usr/bin/passwd permet d’acquérir les droits de root pour modifier le
fichier /etc/shadow.
SGID (Set Group Id) : ce droit fonctionne de la même façon que le droit SUID en ce
qui concerne les exécutables mais en donnant à l’utilisateur les droits du groupe
auquel appartient le propriétaire de l'exécutable.
Le SGID peut aussi être attribué à un répertoire : dans ce cas tout fichier créé dans un
répertoire portant le SGID aura comme groupe propriétaire le groupe du répertoire.
Sticky Bit : si le Sticky Bit est positionné sur un répertoire, seul le propriétaire
d'un fichier contenu dans ce répertoire pourra le renommer ou le supprimer, mais tous
les utilisateurs pourront y avoir accès. Le Sticky Bit est par exemple toujours
positionné sur les répertoires /tmp ou /var/mail/.
Linux permet de spécifier le groupe d’un fichier ou d’un répertoire par la commande chgrp :
֍ Mots clés : useradd, usermod, userdel, id, newgrp, groups, groupadd, groupmod,
groupdel, passwd, gpasswd, /etc/passwd, /etc/shadow, /etc/group, /etc/login.defs,
chage.
Plan du chapitre :
5.4. Gestion des comptes et des options de création par défaut ........................................... 52
-c : commentaire.
-g : groupe.
-s : Shell.
Pour ajouter un utilisateur « user1 » dans le groupe « chefs » avec le Shell « tcsh » :
Les options par défaut se trouvent dans le fichier /etc/default/useradd, ou bien sont
listées par l’option -D de la commande useradd.
Pour activer le compte, l’administrateur doit définir un mot de passe pour le compte par la
commande /usr/bin/passwd :
Cette commande permet également à l’utilisateur de changer lui-même son mot de passe.
Un utilisateur appartient toujours au moins à un groupe dit groupe primaire (primary group).
Si le groupe n’est pas spécifié au moment de la création du compte deux stratégies générales
sont employées pour assigner un groupe par défaut :
Le groupe par défaut est le même pour tous. Il s’appelle par exemple « users » ;
La distribution Red Hat a introduit la notion de groupe privé par utilisateur ou UPG
(User Private Group). Le nom du groupe est identique à celui du login.
Selon la stratégie employée, le masque par défaut (umask) de création est initialisé à 022 dans
le premier cas (classique) et à 002 dans le deuxième cas (UPG).
Dans l’exemple qui suit, l’utilisateur « moi » appartient au groupe primaire « normal » et aux
groupes secondaires « compta » et « chefs ».
La commande groups permet elle aussi d’afficher les groupes auxquels appartient un
utilisateur.
Login.
Mot de passe ou « x » s’il existe un fichier /etc/shadow.
UID.
GID.
Description de l’utilisateur.
Répertoire par défaut de l’utilisateur.
Shell.
Les 7 champs sont présentés sur une ligne et séparés par le caractère « : ».
Une ligne extraite d’un fichier /etc/passwd avec utilisation d’un fichier /etc/shadow :
Le fichier /etc/group contient les informations sur les groupes, structurées en 4 champs :
Nom du groupe.
Mot de passe du groupe ou « x » s’il existe un fichier /etc/gshadow.
GID.
Liste des utilisateurs du groupe.
Les 4 champs sont présentés sur une ligne et séparés par le caractère « : ».
Le fichier /etc/login.defs contient les informations par défaut sur la validité des comptes
et des mots de passe des utilisateurs. Ces informations sont stockées dans le fichier
/etc/shadow lors de la création du compte.
Les options de configuration d’un compte peuvent être modifiées par la commande usermod :
Les options de configuration d’un groupe peuvent être modifiées par la commande groupmod:
Un moyen simple est de faire précéder le mot de passe par un « ! » dans les fichiers de
configuration. Lors de l’utilisation d'un fichier /etc/shadow, on peut remplacer également le
« x » dans le fichier /etc/passwd par un « * ».
passwd –l
usermod –L
passwd –u
usermod –U
On peut aussi détruire le mot de passe : passwd –d. Enfin, on peut affecter à un utilisateur le
Shell par défaut /bin/false, ce qui l’empêche de se connecter.
֍ Mots clés : PID, init, systemd, ps, top, pstree, kill, killall, nice, renice, job, nohup.
Plan du chapitre :
6.1. Introduction
Ce qui est désigné comme processus est une instance de programme s’exécutant à un instant
donné ainsi que son contexte (ou environnement). Ce dernier terme désigne l’ensemble des
ressources utilisées par le programme pour pouvoir se dérouler, comme par exemple la
mémoire, les fichiers ouverts, les droits associés, la priorité, etc.
Les processus sont identifiés par un numéro unique dans le système à un moment donné, le
PID. C'est à l’aide de ce nombre que l’on peut désigner une instance de programme et
interagir avec.
Les processus sont également caractérisés par un propriétaire. Il s’agit de l’utilisateur qui en a
demandé l’exécution. En général, seul ce propriétaire pourra entreprendre des actions sur le
processus.
Les processus sont créés par « clonage ». Le premier processus créé est le processus init
(systemd) qui est l’ancêtre de tous les autres.
La commande pstree affiche les processus sous forme d’arborescence. On peut donc
visualiser qui est le processus parent d’un autre. L’option –p affiche le PID de chaque
processus et l’option –u affiche le nom de l’utilisateur ayant lancé le processus.
6.2. La commande « ps »
Syntaxe : ps [-Aefl]
Options principales :
Dans la pratique, nous n'avons besoin que des champs UID, PID et éventuellement
TIME.
La commande top permet d’afficher des informations en continu sur l’activité du système.
Elle permet surtout de suivre les ressources que les processus utilisent (quantité de RAM,
pourcentage de CPU, durée d’exécution d’un processus depuis son démarrage).
Le processus 1759 correspondant au programme essai qui semble boucler (il tourne
depuis plus de 46 h). Pour le supprimer, on tape : kill -9 1759.
Si l’on ne connaît pas le PID du processus auquel on veut envoyer un signal, on peut le
désigner par son nom en utilisant la commande killall.
La priorité d’un processus peut être connue en examinant la colonne PRI du résultat des
commandes ps –l ou top. Plus la priorité est grande, plus de temps CPU est offert au
processus.
Le noyau gère la priorité moyennant une file d’attente de processus. Un utilisateur autorisé
peut modifier la priorité des processus à travers une valeur de gentillesse ou valeur nice
(colonne NI du résultat des commandes ps –l ou top).
La valeur nice varie de -20 à +19, plus elle est élevée, moins le processus est prioritaire.
Options :
-n : la nouvelle priorité.
-p : des identifiants de processus.
-g : des identifiants de groupes de processus. Utiliser renice sur un groupe de
processus implique que tous les processus de ce groupe auront leur priorité
modifiée.
-u : des noms d’utilisateurs. Lorsqu’un utilisateur est spécifié, tous les
processus appartenant à celui-ci auront leur priorité modifiée.
Exemples :
revient directement au prompt du Shell. Cette possibilité est surtout utile lorsqu’on travaille
en mode « console », ou à distance, et qu’on ne dispose que d’une seule fenêtre ouverte.
Dans l’exemple ci-dessous, le processus lancé en tâche de fond depuis le Shell est l’éditeur
emacs. La première valeur, entre crochets, est le numéro de job. La seconde valeur est le PID
de emacs.
emacs&
[1] 7522
Si plusieurs Shells sont utilisés simultanément – par exemple avec plusieurs fenêtres de
console – chacun aura ses propres processus fils et ne pourra agir sur ceux des autres Shells.
Le numéro de job identifie un processus de façon univoque par rapport au Shell à partir
duquel il a été lancé, mais plusieurs processus lancés à partir de Shells différents peuvent
avoir le même numéro de job.
On peut alors utiliser la commande jobs qui affichera la liste des processus s’exécutant en
arrière-plan.
La commande nohup permet de lancer un processus qui pourra rester actif aussi longtemps
que nécessaire, et ceci même après la déconnexion de l’utilisateur l’ayant initié.
Par défaut, quand un utilisateur se déconnecte, le Shell est quitté et un signal SIGHUP (signal
1) est envoyé aux processus enfants de ce Shell. L’action associée à ce signal est l’arrêt de ces
processus.
nohup ignore le signal SIGHUP (d’où son nom) puis exécute le programme indiqué en ligne de
commande, de sorte que celui-ci ignorera le signal SIGHUP.
Dans l’exemple qui suit, le script « mon_calcul_long » est lancé avec la commande nohup
pour que, si l’utilisateur se déconnecte avant que son exécution soit terminée, elle ne soit pas
interrompue. Notons qu’en plus d’utiliser la commande nohup pour ignorer le signal SGHUP,
on tape « & » en fin de ligne de commande pour que le script s’exécute en tâche de fond.
֍ Mots clés : /etc/shells, bash, variable, export, env, set, unset, script Shell, if, case, for,
while, function, expr, let, (()).
Plan du chapitre :
7.1. Introduction
Le Shell est un interpréteur de commandes. C'est un programme spécial qui joue le rôle
d'intermédiaire en interprétant les commandes passées par l'utilisateur.
Il existe plusieurs types de Shells, les plus connus depuis Unix ayant une version améliorée
sous Linux. Le fichier /etc/shells contient une liste de tous les Shells disponibles :
/bin/ash, /bin/bash, /bin/bash1, /bin/csh, /bin/false, /bin/passwd, /bin/sh,
Les plus connus sont bash (version améliorée du Shell Bourne sous Unix), ksh (version
améliorée du Shell Korn sous Unix) et tcsh (version améliorée du Shell C sous Unix). La
commande help affiche la liste des commandes internes du Shell. Par défaut, c'est le Shell
Bash qui est installé avec Linux. C'est aussi le plus puissant et le plus utilisé.
L'initialisation du Shell bash, à son ouverture, se fait à l'aide de plusieurs scripts, qui
représentent autant de possibilités de le personnaliser. Dans l'ordre, les fichiers suivants sont
lus et exécutés :
Les interpréteurs de commande Linux distinguent deux types de variables : les variables
simples et les variables d'environnement. Les variables d'environnement ont la particularité
d'être connues de toutes les commandes lancées depuis l'interpréteur de commande courant.
L’affectation de variables se fait comme suit : variable="valeur". Avec bash, il ne doit pas
y avoir d’espace avant et après le signe « = ». L’accès au contenu s’effectue en ajoutant le
caractère $ au début du nom de la variable ou par l'expression ${nom-de-la-variable} :
Nous venons de définir une variable simple. Pour la transformer en variable d’environnement,
on utilise la commande export :
La commande env seule, sans option ni argument, permet d'afficher toutes les variables
d'environnement définies :
La commande set affiche la liste complète des variables définies (variables simples ou
variables d'environnement).
Les scripts Shell sont des fichiers exécutables permettant de lancer successivement plusieurs
commandes. Pour créer un script Shell, il faut éditer un ficher, y entrer les commandes et le
rendre exécutable par une commande du type :
#!/bin/sh
# Un premier script Shell.
echo -n "Aujoud'hui, le "
date
7.5. Syntaxe
Le script Shell suivant montre entre autres comment lire les arguments passés par l'utilisateur
à la suite du script, sélectionner les arguments à traiter, redéfinir les arguments si il n'y en a
pas qui ont été passés par l'utilisateur, afficher une variable dont le contenu a été définit par le
script, lire une entrée clavier et l'affecter à une variable, utiliser les différentes variables
spécialement définies par le Shell, qui contiennent des informations sur les programmes ou
sur les utilisateurs.
#!/bin/sh
#--------------------#
# lire les arguments #
#--------------------#
#-------------------------#
# Redéfinir les arguments #
#-------------------------#
a=1
b=2
c=3
d=4
e=5
set a b c d e
shift
echo
echo "Et maintenant, après le passage de shift ..."
set a b c d e
echo
echo "On refait un petit coût de set"
echo "Tous les arguments : $* ($# arguments)"
shift 3
echo
echo "Et maintenant, après le passage de shift 3 ..."
#--------------#
# echo et read #
#--------------#
echo $moi
Deux syntaxes :
Condition Signification
-z chaîne vrai si la chaîne est vide
-n chaîne vrai si la chaîne est non vide
chaîne1 = chaîne2 vrai si les deux chaînes sont égales
chaîne1 != chaîne2 Vrai si les deux chaînes sont différentes
Condition Signification
num1 eq num2 Egalité
num1 ne num2 Inégalité
num1 lt num2 inférieur ( < )
num1 le num2 inférieur ou égal ( < =)
num1 gt num2 supérieur ( > )
num1 ge num2 supérieur ou égal ( > =)
Condition Signification
-e filename vrai si filename existe
-d filename vrai si filename est un répertoire
-f filename vrai si filename est un fichier ordinaire
-L filename vrai si filename est un lien symbolique
-r filename vrai si filename est lisible (r)
-w filename vrai si filename est modifiable (w)
-x filename vrai si filename est exécutable (x)
file1 -nt file2 vrai si file1 plus récent que file2
file1 -ot file2 vrai si file1 plus ancien que file2
7.5.2. L’instruction « if »
Syntaxe
if suite_de_commandes1
then
suite_de_commandes2
[ elif suite_de_commandes ; then suite_de_commandes ] ...
[ else suite_de_commandes ]
fi
Exemple
#!/bin/bash
if [ $1 = "Salah" ]
then echo "Salut Salah !"
else
echo "Je ne te connais pas !"
fi
Syntaxe
case Valeur in
Modele1) Commandes ;;
Modele2) Commandes ;;
*) action_defaut ;;
esac
for var
do
suite_de_commandes
done
Exemple 1
#!/bin/bash
for i in `seq 1 10`;
do
echo $i
done
Exemple 2
#!/bin/bash
for variable in 'valeur1' 'valeur2' 'valeur3'
do
echo "La variable vaut $variable"
done
L'instruction while permet de tester les arguments passés au programme, et de les traiter.
Cette instruction trouvera donc tout naturellement sa place au début d'un script Shell digne de
ce nom.
Syntaxe
while suite_cmd1
do
suite_cmd2
done
Exemple
#!/bin/bash
while
echo "tapez quelque chose : "
read mot
[ $mot != "fin" ];
do
echo "vous avez tapé $mot"
echo "tapez \"fin\" pour finir";
done
Syntaxe
function nom_fct
{
suite_de_commandes
}
Exemple
$ function f0
> {
> echo Bonjour tout le monde !
> }
$
Appel de la fonction f0
$ f0
Bonjour tout le monde !
Opérateurs arithmétiques
$ expr 2 + 3
$ expr 2 – 3
$ expr 2 + 3 \* 4
$ expr \( 2 + 3 \) \* 4
Opérateurs logiques
$ expr 2 = 2 # retourne 1
$ echo $? # retourne 0
$ expr 3 \> 6 # retourne 0
$ echo $? # retourne 1
$ expr 1 \& 0 # retourne 0
$ expr 1 \| 0 # retourne 1
La syntaxe est moins contraignante. Il n’est pas nécessaire de mettre les espaces entre chaque
élément, ni de préfixer avec un antislash certains opérateurs. La manipulation de variables est
simplifiée. Il existe un plus grand nombre d'opérateurs pour le calcul arithmétique.
Opérateurs arithmétiques
$ let var=2+3
$ echo $var # retourne 5
$ ((var=2**3))
$ echo $var # retourne 8
$ echo $((2*3)) # retourne 6
$ echo $((2*(4+(10/2))-1)) # retourne 17
$ echo $((7%3)) # retourne 1
$ a=1+2
$ echo $(($a)) # retourne 3
$ echo $((a)) # retourne 3
$ ((x=3))
$ while ((x>0))
> do
> echo $x
> ((x--))
> done
TD
(Travaux
dirigés)
TD N° 1
Exercice 1
1. Créer les fichiers suivants : annee1, Annee2, annee4, annee45, annee41, annee510,
annee_solaire, annee_tropique.
2. Créer le répertoire "Year".
3. Déplacer les fichiers précédemment créés dans le répertoire "Year".
4. Lister tous les fichiers
5. Copier les fichiers dont l'avant dernier caractère est le caractère 4 ou le caractère 1 dans le
répertoire /tmp.
Exercice 2
1. Dans le répertoire courant, créer en une commande les fichiers suivants : 3bananes,
3poires, 45pommes, aride, banane, paname, panorama, Paris, parti, parties,
pomme, programmer.
2. Créer le répertoire "Dictionnaire" dans le répertoire courant.
3. Déplacer les fichiers précédemment créés dans le répertoire "Dictionnaire".
4. À partir du répertoire "Dictionnaire" lister tous les fichiers
TD N° 2
a) Exécuter la commande ls. Taper ensuite ls > sorties, puis relister le contenu du
répertoire courant. Un nouveau fichier appelé sorties a été créé. Lire son contenu.
b) Exécuter maintenant la commande ls -l > sorties. Consulter à nouveau le contenu
de sorties.
c) Concaténer le résultat de la commande ls >> sorties à la fin du fichier sorties.
a) Exécuter la commande wc tutu. Comme le fichier "tutu" n’existe pas, wc renvoie une
erreur.
b) Exécuter maintenant wc tutu > sortie. Regarder le contenu de sortie.
c) Faire en sorte que le message d’erreur soit écrit dans un fichier nommé erreur.
Exercice 2 (grep)
4. Copier le fichier /etc/passwd dans le home directory. Afficher la ligne commençant par
le nom d’utilisateur user1.
5. Dans le nouveau fichier passwd, afficher les lignes commençant par des noms d’utilisateurs
ne contenant pas de chiffre.
6. Dans le même fichier passwd, afficher les lignes commençant par des noms d’utilisateurs de
3 ou 4 caractères.
Exercice 4 (find)
1. Chercher dans toute l'arborescence les fichiers qui répondent aux critères suivants. Rediriger
les erreurs vers le fichier poubelle /dev/null.
2. Chercher dans /usr les fichiers dont la taille dépasse 1Mo et dont les droits sont fixés à 755
(rwx r-x r-x).
3. Combien de fichiers y-a-t il dans toute l'arborescence appartenant à user1 et ayant les droits
fixés à 666 (rw- rw- rw-).
4. Trouver tous les fichiers core dans l'arborescence et les supprimer.
TD N° 3
Exercice 1
a) -u 600
b) -g 100
c) -c "Un Utilisateur"
d) -d /home/u1
e) -s /bin/sh u1
2. Une ligne dans le fichier /etc/shadow est composée de neuf champs séparés par le
caractère « : ».
a) Après combien de jours user1 recevra un avertissement sur la validité de son compte ?
b) Après combien de jours user1 doit contacter l’administrateur pour activer son compte ?
c) Est-ce que user1 peut changer son mot de passe quand il le souhaite ?
1. Dans le répertoire courant, créer un répertoire "essai_droit", par défaut ce répertoire est à 755
(rwxr-xr-x). Quelles sont les commandes (en notation symbolique et en base 8) pour lui
donner les droits suivants (on suppose qu'après chaque commande on remet le répertoire à
755) ?
2. Créer un fichier "droit" dans le répertoire "essai_droit", par défaut ce fichier est à 644 (rw-
r--r--). En partant du répertoire courant, pour chacune des commandes précédentes, essayer
d'accéder au répertoire "essai_droit" (commande cd), de faire un ls dans "essai_droit" et de
modifier le fichier avec un éditeur quelconque (vi par exemple). Expliquer les résultats
obtenus.
3. Taper la commande umask, de manière à ce que les fichiers lors de leur création aient par
défaut les droits 640 (rw-r-----), et les répertoires 750 (rwxr-x---).
Exercice 3
Déterminer les permissions d’un utilisateur sur un fichier en étudiant les informations fournies par la
commande ls, et assimiler les possibilités offertes par ces droits.
Quels sont les droits effectifs de l’utilisateur machin appartenant aussi au groupe machin sur rep
?
TD N° 4
Exercice 1
Crontab Signification
47 * * * * commande …………………………………………………………………………
0 0 * * 1 commande …………………………………………………………………………
0 4 1 * * commande …………………………………………………………………………
0 4 * 12 * commande …………………………………………………………………………
0 * 4 12 * commande …………………………………………………………………………
* * * * * commande …………………………………………………………………………
Exercice 2
Compléter le crontab suivant avec les valeurs correspondantes aux significations données.
Crontab Signification
Créer un script qui demande à l'utilisateur de saisir une note et qui affiche un message en fonction de
cette note (Appréciation de note) :
Exercice 4
Reprendre l’exercice précédent (Appréciation de note) et faire en sorte que le programme se répète
tant que l'utilisateur n'a pas saisi la lettre 'q' (pour quitter).
Le script doit calculer le nombre de notes saisies et en faire la moyenne tout à la fin.
Exercice 5
Créer un script, se basant sur la boucle for, qui prend un nombre en saisie et l'élève à sa propre
puissance.
Exemple d'exécution :
./NomDuScript.sh
Saisir une valeur :
2
2^2 = 4
Exercice 6
Reprendre l’exercice 3 (Appréciation de note). La note devra être donnée en paramètre ou bien saisie
en cas d'absences d'arguments. La comparaison de la note devra être faite dans une fonction
appreciation()
TD N° 5
Exercice 1
L'utilisateur devra être saisi, à l'aide d'une fonction. Son existence devra être vérifiée à l'aide d'une
autre fonction.
Exercice 2
Créer un script dans lequel deux nombres opérandes et un signe opérateur (+-*/) devront être donnés
en paramètres, ou saisis. Le script doit réaliser l'opération souhaitée.
Exemple :
./calculette.sh 7 + 4
Le résultat est : 11
Exercice 3
Créer un script qui permet de calculer et d'afficher la factorielle d'un nombre donné en paramètre (ou
saisi en cas d'absence de paramètres).
Exercice 4
Créer un script qui doit calculer le nombre de fichiers standard, de sous-répertoires, et d'exécutables
d'un répertoire quelconque qui sera donné en paramètre (ou saisis en cas d'absence du paramètre).
Créer un script qui devra enregistrer à l'aide d'un tableau, un nombre d'entiers donné en paramètre (ou
en saisie) puis trier ceux-ci dans l'ordre croissant dans ce même tableau (sans passer par un autre) et
enfin afficher le contenu du tableau (ordonné) sur la sortie standard.
Exercice 6
Créer un script qui renvoie la même sortie que la commande ls mais dans l'ordre décroissant
(autrement dit : le script devra lister le contenu d'un répertoire dans l'ordre décroissant). Il ne faut pas
utiliser ni la commande ls, ni la commande sort.
Exercice 7
Créer un script qui prend en paramètre ou en saisie le nom d'un fichier contenant le nom des élèves et
leurs trois notes. Le script devra afficher les noms des élèves, puis calculer et afficher la moyenne de
chaque élève.
Durand 12 9 14
Lucas 8 11 4
Martin 9 12 1
Correction
des TD
Correction du TD N° 1
Exercice 1
1. Créer les fichiers suivants : annee1, Annee2, annee4, annee45, annee41, annee510,
annee_solaire, annee_tropique.
mkdir Year
mv [aA]nnee* Year
ls Year/*5
find Year -name '*5'
ls Year/annee4*
find Year –name 'annee4*'
ls Year/annee4?
find Year –name 'annee4?'
ls Year/annee[!0-9]*
find Year –name 'annee[!0-9]*'
ls Year/*rop*
find Year –name '*rop*'
ls Year/[aA]*
find Year –name '[aA]*'
5. Copier les fichiers dont l'avant dernier caractère est le caractère 4 ou le caractère 1 dans le
répertoire /tmp.
cp Year/*[41]? /tmp
Exercice 2
1. Dans le répertoire courant, créer en une commande les fichiers suivants : 3bananes,
3poires, 45pommes, aride, banane, paname, panorama, Paris, parti, parties,
pomme, programmer.
mkdir Dictionnaire
ls *e
find . –name '*e'
ls pa*
find . –name 'pa*'
ls *ar*
find . –name '*ar*'
ls [0-9][a-z][a-z][a-z][a-z]*
find . –name '[0-9][a-z][a-z][a-z][a-z]*'
ls [0-9]*[a-z][a-z][aeiouy]*
find . –name '[0-9]*[a-z][a-z][aeiouy]*'
ls [0-9]*[a-z][a-z][b-df-hj-np-tv-xz]*
find . –name '[0-9]*[a-z][a-z][b-df-hj-np-tv-xz]*'
ls *ar[!i]*
find . –name '*ar[!i]*'
ls [pP]*
ls [!pP]*
find . ! –name 'p*' –a ! –name 'P*'
find . ! \( –name 'p*' –o –name 'P*' \)
ls *[!es]
find . ! –name '*e' –a ! –name '*s'
find . ! \( –name '*e' –o –name '*s' \)
ls ??[aeiouy]*
find . –name '??[aeiouy]*'
ls !(*me)
find . ! –name '*me'
ls !(*mes)
find . ! –name '*mes'
Correction du TD N° 2
a) Exécuter la commande ls. Taper ensuite ls > sorties, puis relister le contenu du
répertoire courant. Un nouveau fichier appelé sorties a été créé. Lire son contenu.
ls
ls > sorties
ls
cat sorties
ls -l > sorties
cat sorties
ls >> sorties
a) Exécuter la commande wc tutu. Comme le fichier "tutu" n’existe pas, wc renvoie une
erreur.
b) Exécuter maintenant wc tutu > sortie. Regarder le contenu de sortie.
cat sortie
le contenu de "sortie" est écrasé.
c) Faire en sorte que le message d’erreur soit écrit dans un fichier nommé erreur.
Exercice 2 (grep)
mkdir ~/essai-grep
2. Dans ce répertoire, créer les fichiers suivants : tomate, poire, pomme, cerise, Fraise,
fraise, courgette, POMME3, afraise.
cd ~/essai-grep
touch tomate poire pomme cerise Fraise fraise courgette POMME3
afraise
3. Lister les fichiers (sortie de la commande ls redirigée vers grep) avec les critères suivants
ls | grep "^[fF]raise$"
ls | grep "se$"
ls | grep "ai"
ls | grep "[mM]\{2\}"
4. Copier le fichier /etc/passwd dans le home directory. Afficher la ligne commençant par
le nom d’utilisateur user1.
cd
cp /etc/passwd ~
cat passwd | grep "^user1"
5. Dans le nouveau fichier passwd, afficher les lignes commençant par des noms d’utilisateurs
ne contenant pas de chiffre.
6. Dans le même fichier passwd, afficher les lignes commençant par des noms d’utilisateurs de
3 ou 4 caractères.
cd
cp /etc/passwd ~
cut -d: -f1,6 passwd
3. En une seule commande, extraire les noms d’utilisateurs et les UID, puis trier suivant les UID
et rediriger le tout vers un fichier file1.
head -5 file1
tail -5 file1
Exercice 4 (find)
1. Chercher dans toute l'arborescence les fichiers qui répondent aux critères suivants. Rediriger
les erreurs vers le fichier poubelle /dev/null.
2. Chercher dans /usr les fichiers dont la taille dépasse 1Mo (2000 blocs de 500Ko) et dont les
droits sont fixés à 755 (rwx r-x r-x).
3. Combien de fichiers y-a-t il dans toute l'arborescence appartenant à user1 et ayant les droits
fixés à 666 (rw- rw- rw-).
Correction du TD N° 3
Exercice 1
2. Une ligne dans le fichier /etc/shadow est composée de neuf champs séparés par le
caractère « : ».
a) Que signifie le caractère « ! » ? Le compte root est désactivé. Il n’a pas de mot de
passe. Au démarrage du système, il n’est pas possible de se connecter avec root.
b) Que signifie la valeur « 99999 » ? Indique que l'utilisateur peut garder son mot de
passe inchangé pendant une longue durée.
c) Que signifie la valeur « 7 » ? Pour une semaine entière.
Exercice 2
1. Dans le répertoire courant, créer un répertoire "essai_droit", par défaut ce répertoire est à 755
(rwxr-xr-x). Quelles sont les commandes (en notation symbolique et en base 8) pour lui
donner les droits suivants (on suppose qu'après chaque commande on remet le répertoire à
755) ?
mkdir essai_droit
3. Taper la commande umask, de manière à ce que les fichiers lors de leur création aient par
défaut les droits 640 (rw-r-----), et les répertoires 750 (rwxr-x---).
Pour un fichier
Pour un répertoire
Déterminer les permissions d’un utilisateur sur un fichier en étudiant les informations fournies par ls,
et assimiler les possibilités offertes par ces droits.
2. Quelles sont les permissions de l’utilisateur truc appartenant aux groupes machin et bidule
sur fic ?
3. Quelles sont les permissions de l’utilisateur bidule appartenant aux groupes machin et truc
sur fic ?
4. Quelles sont les permissions de l’utilisateur bidule appartenant aux groupes machin et truc
sur rep ?
Non, s’il n’y a pas eu intervention de root, rep n’a pu être créé
qu’avec des permissions différentes du répertoire de travail (ou
alors par déplacement mais ce n’est pas une création). En effet,
le propriétaire (et créateur) de rep est machin. Puisque le groupe
de rep est bidule et que seul machin (ou root) peut le changer, on
en déduit que machin est membre du groupe bidule. Or, pour créer
un fichier il faut les droits wx sur le répertoire mais machin a
les droits du groupe, soit uniquement r.
7. Quels sont les droits effectifs de l’utilisateur machin appartenant aussi au groupe machin sur
rep ?
Correction du TD N° 4
Exercice 1
Crontab Signification
Exercice 2
Compléter le crontab suivant avec les valeurs correspondantes aux significations données.
Crontab Signification
Créer un script qui demande à l'utilisateur de saisir une note et qui affiche un message en fonction de
cette note (Appréciation de note) :
Exercice 4
Reprendre l’exercice précédent (Appréciation de note) et faire en sorte que le programme se répète
tant que l'utilisateur n'a pas saisi la lettre 'q' (pour quitter).
Le script doit calculer le nombre de notes saisies et en faire la moyenne tout à la fin.
Créer un script, se basant sur la boucle for, qui prend un nombre en saisie et l'élève à sa propre
puissance.
Exemple d'exécution :
./NomDuScript.sh
Saisir une valeur :
2
2^2 = 4
Reprendre l’exercice 3 (Appréciation de note). La note devra être donnée en paramètre ou bien saisie
en cas d'absences d'arguments. La comparaison de la note devra être faite dans une fonction
appreciation()
Correction du TD N° 5
Exercice 1
L'utilisateur devra être saisi, à l'aide d'une fonction. Son existence devra être vérifiée à l'aide d'une
autre fonction.
Créer un script dans lequel deux nombres opérandes et un signe opérateur (+-*/) devront être donnés
en paramètres, ou saisis. Le script doit réaliser l'opération souhaitée.
Exemple :
./calculette.sh 7 + 4
Le résultat est : 11
Créer un script qui permet de calculer et d'afficher la factorielle d'un nombre donné en paramètre (ou
saisi en cas d'absence de paramètres).
Créer un script qui doit calculer le nombre de fichiers standard, de sous-répertoires, et d'exécutables
d'un répertoire quelconque qui sera donné en paramètre (ou saisis en cas d'absence du paramètre).
Exercice 5
Créer un script qui devra enregistrer à l'aide d'un tableau, un nombre d'entiers donné en paramètre (ou
en saisie) puis trier ceux-ci dans l'ordre croissant dans ce même tableau (sans passer par un autre) et
enfin afficher le contenu du tableau (ordonné) sur la sortie standard.
Créer un script qui renvoie la même sortie que la commande ls mais dans l'ordre décroissant
(autrement dit : le script devra lister le contenu d'un répertoire dans l'ordre décroissant). Il ne faut pas
utiliser ni la commande ls, ni la commande sort.
Créer un script qui prend en paramètre ou en saisie le nom d'un fichier contenant le nom des élèves et
leurs trois notes. Le script devra afficher les noms des élèves, puis calculer et afficher la moyenne de
chaque élève.
Durand 12 9 14
Lucas 8 11 4
Martin 9 12 1
[3] N. Drakos et R. Moore, « Historique de UNIX », 11-janv-2006. [En ligne]. Disponible sur:
http://www-etud.iro.umontreal.ca/~semunix/documentIRO/html/node43.html. [Consulté le:
22-déc-2017].
[6] P. Gentil, « Documentation Unix : les commandes relatives aux fichiers », 05-déc-2013.
[En ligne]. Disponible sur: https://perso.univ-rennes1.fr/pascal.gentil/unix/fichiers.html.
[Consulté le: 22-déc-2017].
[7] P. Gentil, « Documentation Unix : les commandes relatives aux répertoires », 06-avr-
2016. [En ligne]. Disponible sur: https://perso.univ-rennes1.fr/pascal.gentil/unix/rep.html.
[Consulté le: 22-déc-2017].
[9] M. Decore, « Gestion des processus », 03-nov-1999. [En ligne]. Disponible sur:
http://www.linux-france.org/article/memo/node13.html. [Consulté le: 22-déc-2017].
[11] O. Hoarau, « Cours et exercices UNIX », 27-janv-2017. [En ligne]. Disponible sur:
http://www.funix.org/fr/unix/. [Consulté le: 22-déc-2017].
[13] I. Neumann, « Exercices shell scripts », Developpez.com. [En ligne]. Disponible sur:
http://ineumann.developpez.com/tutoriels/linux/exercices-shell/. [Consulté le: 22-déc-2017].