Cours Unix-Shell

Année 2007
Cours Unix-Shell
par
Karam ALLALI
Ecole Spéciale d’Informatique
Table des matières
1 Introduction.
5
1.1
Historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
1.2
Système d’exploitation . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
1.3
Composition du système d’exploitation Unix . . . . . . . . . . . . . . . . .
9
1.3.1
Le noyau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
1.3.2
Le Shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2 Système de fichiers et droits d’accès.
11
2.1
Système de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2
Droits d’accès . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2.1
Droits d’accès sous Unix . . . . . . . . . . . . . . . . . . . . . . . . 14
2
2.2.2
Type de fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3 Commandes de base et gestion des processus.
18
3.1
Le manuel en ligne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2
Commandes de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.3
3.2.1
Créer un répertoire . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.2.2
Supprimer un répertoire . . . . . . . . . . . . . . . . . . . . . . . . 20
3.2.3
Déplacer, changer le nom d’un répertoire . . . . . . . . . . . . . . . 20
3.2.4
Copier tous les fichiers d’un répertoire . . . . . . . . . . . . . . . . 21
3.2.5
Occupation de l’espace disque . . . . . . . . . . . . . . . . . . . . . 21
3.2.6
Autres commandes utiles . . . . . . . . . . . . . . . . . . . . . . . . 22
Processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4 VI et Quelques notions sur le Shell.
26
4.1
L’éditeur de texte Shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.2
Le Shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.3
Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3
4.4
Lancement de l’exécution d’un shellscript . . . . . . . . . . . . . . . . . . . 29
A Exercices.
31
4
Chapitre 1
Introduction.
5
1.1
Historique
L’histoire du système d’exploitation Unix commence en 1969 aux Bell Labs (laboratoires de recherche en informatique d’A.T.&T.). C’est pour répondre aux besoins des
ingénieurs de la société que Ken Thompson écrit un système interactif, qui met l’accent
sur les utilitaires de développement de logiciels, le partage de fichiers et les outils de documentation qui allait devenir Unix. Ce nom d’Unix a été attribué par opposition au système
Multics (vaste projet du M.I.T.). La première évolution interne marquante d’Unix a été sa
ré-écriture (par Ken Thompson et Denis Ritchie) en langage C, lequel a été inventé pour la
cause en 1971. En 1975, le système Unix (v6) est distribué aux universités et aux centres de
recherches. La principale université qui va travailler sur Unix est l’université de Berkeley,
qui va produire ses propres versions appelées BSD pour Berkeley Software Distribution.
En 1979, les Bell Labs sortent leur version appelée v7, avec en particulier, l’ajout de nouveaux utilitaires et un effort en matière de portabilité. Cette version est la première à être
diffusée dans le monde industriel. On peut dire qu’elle est à l’origine du développement
du marché Unix. Au début des années 80, une modification de la législation américaine
autorise A.T.&T. à commercialiser lui-même ses propres produits qui sont alors appelés
System. C’est à cette époque que Microsoft propose sa propre version d’Unix appelée
Xenix et destinée aux microordinateurs. A Berkeley, les efforts portent sur l’intégration
des protocoles réseaux TCP/IP, la gestion de la mémoire avec l’introduction de la pagination (alors qu’A.T.&T. reste fidèle quand à lui à la segmentation), la modification de
certains paramètres du système (taille des blocs, nombre des signaux...) et l’ajout d’outils (l’éditeur vi, un interpréteur de commandes csh...). Cette prolifération des systèmes
6
UnixÀ a engendré un certain nombre de problèmes de compatibilité car chacun allant
¿
dans sa propre direction, il y avait alors plusieurs systèmes Unix. Plusieurs facteurs vont
alors jouer pour canaliser et recentrer l’offre Unix: la complexité croissante des systèmes
et l’action des utilisateurs. En 1983, A.T.&T. sort la version System V, qui est issue de
la v7 et qui sera enrichie au fur et à mesure par de nouvelles versions (releases). Dans le
même temps, Berkeley, propose sa version 4.2 BSD (avec les fonctionnalités réseau) qui va
servir de base pour de nombreux constructeurs (Sun Microsystems, Digital...) et lui permettre d’entrer dans le monde industriel. Ces deux produits marquent la fin des systèmes
Unix-like en raison de leur importance par rapport à la version de référence, la v7. La
fin des années 80 est marquée par une croissance sans précédent du nombre de systèmes
Unix dans le domaine des systèmes d’exploitation. Tous les constructeurs proposent une
solution Unix à leur catalogue (on trouve alors trois grandes familles: les versions basées
sur System V, celles issues de BSD et les versions Xenix sur micro). Le début des années
90 est marqué par le regroupement des constructeurs au sein de deux organisations: l’U.I.
(Unix International) créée à partir de l’accord entre A.T.&T. et Sun Microsystems d’une
part et l’O.S.F. d’autre part. Le premier accord a comme objectif la convergence entre
les versions System V et 4.2 BSD. La première réalisation est la version System VR4
(System V release 4) qui réalise la synthèse entre SunOS (version Unix de Sun conçue
sur la base BSD), Xenix et System V. L’O.S.F., quand à lui s’est fixé comme objectif de
réaliser un système, appelé OSF/1, construit sur un noyau Unix et intégrant les fonctionnalités apportées par ses membres (multifenêtrages, graphismes, bases de données...) de
manière à disposer d’un environnement ouvert commun aux différentes architectures des
constructeurs. La principale réalisation à l’heure actuelle de l’O.S.F. est Motif qui définit
7
un ensemble de normes au niveau de la présentation sur un environnement multifenêtré.
1.2
Système d’exploitation
L’ensemble de programmes permettant l’utilisation d’une machine s’appelle le système
d’exploitation. C’est lui qui doit prendre en charge toute la gamme de complexité trouvé
dans des systèmes d’ordinateurs : quelques parties interagissent directement avec le matériel,
où des événements peuvent se dérouler à des vitesses autour de 1/107 secondes (tels que le
changement d’état d’une porte logique), d’autres parties ont en charge l’interaction avec
les utilisateurs (où les vitesses sont plutôt de l’ordre des secondes). Une simple frappe
sur le clavier peut résulter en 10 appels à des programmes du système opératoire, en
1000 instructions machines et en 1000000 changements d’état des portes logiques. La
stratégie adaptée, comme souvent en informatique est d’organiser cette complexité en une
hiérarchie d’abstractions, de manière telle que chaque niveau peut ignorer les détails des
autres niveaux.
8
1.3
1.3.1
Composition du système d’exploitation Unix
Le noyau
Le noyau est la partie centrale d’Unix. Il est résident, il se charge en mémoire au
démarrage. Sa structure est modulaire, ce qui rend aisées ses manipulations en termes de
portabilité et l’utilisation des services qu’il offre via les primitives (ou appels systèmes).
Ce fonctionnement par primitives permet de résoudre les problèmes d’accès concurrents
aux informations du système. En effet, les appels systèmes font entrer l’exécution en
mode noyau. Dans ce mode, le processus est assuré de garder le processeur jusqu’au
retour au mode utilisateur lorsque l’appel système est terminé. Les différents noyaux
Unix ont été réécrits afin de pouvoir s’adapter aux nouvelles machines multi-processeurs
et de supporter le travail en temps réel. Ils sont le plus souvent réécrits en couches: les
différentes fonctions du noyau sont implémentées dans des couches logicielles différentes
qui communiquent entre elles par messages. La tendance actuelle est également de garder
le moins de fonctions possibles dans le noyau afin de constituer un micro-noyau. Les
fonctions écartées sont rejetées dans les modules exécutés en mode utilisateur. L’interface
entre le noyau Unix et les applications est définit par une bibliothèque (libc.a pour le
langage C par exemple). Elle contient les modules permettant d’utiliser les primitives mais
aussi des fonctions plus évoluées combinant plusieurs primitives. D’autres bibliothèques
sont utilisées pour des services spécialisés (fonctions graphiques,...).
9
1.3.2
Le Shell
L’interface utilisateur sous Unix est appelée shell. Lorsqu’un utilisateur tape des commandes Unix, ces commandes sont reçues par le shell qui les interprète avant de lancer
l’exécution de cette commande. Le shell est une couche logicielle bien séparée du noyau.
Il joue un double rôle celui d’interpréteur de commandes et celui de langage de programmation. Ce dernier rôle semblant parfois hermétique à des néophytes. Il existe plusieurs
shells dont les plus répandus sont:
– le Bourne Shell (sh): le shell de base sous Unix A.T.&T., le C-shell (csh): le shell
Unix BSD,
– le Korn-Shell (ksh) qui est une extension du Bourne shell. Il possède toutes les
commandes de son prédécesseur, ainsi que des commandes qui facilitent le travail
de l’utilisateur comme des outils de gestion des historiques des commandes tapées...
– le Z-shell (zsh): extension de ksh, qui offre en particulier des modules de complétions
des nom de programme, de fichiers, de variables utilisateur et système, l’envoie de
message à l’utilisateur de correction en cas d’erreur de frappe.
L’utilisateur, à l’aide des commandes qu’il a à sa disposition, peut écrire ses propres
fonctions et programmes en langage shell, ce sont alors des shellscripts. Une fois ceux-ci
réalisés, ils peuvent être utilisés par l’utilisateur comme n’importe quelle commande du
shell lui même.
10
Chapitre 2
Système de fichiers et droits d’accès.
11
2.1
Système de fichiers
Sous UNIX, les fichiers sont enregistrés dans une structure hiérarchisée en arbre. Ce
système de fichiers est donc composé d’une racine et de noeuds qui sont des répertoires et
des feuilles qui sont des fichiers ordinaires qui contiennent les données et les programmes.
Au niveau de l’utilisateur, les entrées-sorties sont vues de façon uniforme c’est-à-dire
avec les mêmes commandes, la même syntaxe et les mêmes attributs qu’il s’agisse d’un
fichier ou d’un périphérique. Par exemple, la redirection d’une commande sur un fichier ou
sur un périphérique utilise la même syntaxe: commande > sortie où sortie est le nom du
fichier (ordinaire ou spécial) de redirection. Mais au niveau du noyau, ce dernier effectuera
l’opération de redirection soit sur le système de fichiers, soit sur le périphérique selon le
type du fichier sortie. Cette vision uniforme des entrées-sorties est caractérisée par un
descripteur commun à tous ces éléments, qui est appelé inode. De fait, chaque fichier
Unix à un inode comprenant les attributs suivants:
• un propriétaire: celui qui a créé le fichier,
• un groupe: le groupe auquel appartient le créateur au moment où il créé le fichier,
• des droits d’accès: (voir paragraphe s’y rapportant),
• des informations générales sur la taille, la date de la dernière opération effectuée sur
le fichier, le nombre de liens sur ce fichier,...
L’arborescence unix est unique, quel que soit le nombre des disques, partitions... La
racine de l’arborescence est ¿ / À. Au dessous de cette racine se trouvent différents
12
répertoires. On trouve sous unix en général les répertoires suivants : /bin (exécutables),
/tmp (fichiers temporaires), /dev (périphériques), /etc (paramétrages généraux du système),
/usr (ressources du système), /users (données utilisateurs). Cette arborescence est légèrement
différente suivant les systèmes (et notamment sous linux) pour lequel on trouve cette
structure générale :
/ : racine du système de fichiers (appelée aussi root)
/boot : contient le noyau linux
/root : répertoire des données de l’administrateur (root)
/home : répertoire des données des utilisateurs (contient autant de sous-répertoires
que d’utilisateurs)
/etc (editing text config) : répertoire contenant les fichiers de configuration généraux
du système (fichiers de type texte) correspond approximativement à la branche HKLM
du registre windows
/bin (binaries) : contient les binaires de base liés à une librairie /lib (libraries) : contient
13
les librairies nécessaires aux binaires de /bin /lib/modules : contient les modules du noyau
/sbin (static binaries) : contient les binaires statiques (non liées à une librairie)
/usr (unix system ressources) : contient toutes les ressources du système
/usr/bin : contient les binaires liés à une librairie /usr/lib : contient les librairies
nécessaires aux binaires de /usr/bin /usr/sbin : contient les binaires statiques (non liées
à une librairie) /usr/share : contient les ressources partagées par les logiciels de /usr/bin
/usr/local : contient les programmes installés par une compilation locale ou un script
d’installation
/tmp : contient les fichiers temporaires généraux du système
/dev (device) : contient les périphériques du système
/proc : contient les processus en cours d’exécution, les paramètres courants (dynamiques) du système /var : répertoire de données (courrier, logs, spool..) /mnt : répertoire
servant au montage des système de fichiers
2.2
2.2.1
¿
externes
À
(disquette, cdrom, réseau...)
Droits d’accès
Droits d’accès sous Unix
Les autorisations d’accès sous UNIX sont de trois ordres: accès en lecture (r), en
écriture (w) et en exécution (x). A partir de ces trois options, on pourra effectuer toutes
14
les opérations de base sur les fichiers (création, copie, destruction,...). Ces droits vont être
donnés pour trois niveaux d’utilisateurs: pour le propriétaire, pour le groupe auquel appartient le propriétaire et pour le reste des utilisateurs. En ce qui concerne les répertoires,
l’attribut x est nécessaire pour pouvoir se déplacer dans ce répertoire ou pour y rechercher
un fichier.
Plus précisément, Chaque fichier bénéficie de droits, définis en trois catégories : les
droits du propriétaire (u : User), les droits du groupe (g : Group) et les droits des autres
(o : Other). Ces droits peuvent être la lecture, l’écriture et l’exécution. Pour chaque fichier,
on a donc trois groupes de trois attributs. On désigne symboliquement les droits par r
(Read : lecture), w (Write : ecriture), x (eXecute : exécution). Ces droits étant définis
pour trois catégories : propriétaire, groupe et autres, on note symboliquement les droits
sur les fichiers par trois groupes de trois lettres. Aucun droit est symbolisé par un tiret
- Par exemple, un fichier ayant les droits de lecture, d’écriture et d’exécution pour le
propriétaire, le groupe et les autres aura les attributs rwxrwxrwx. Le même fichier sans
aucun droit d’exécution sera noté rw-rw-rw-. Si le propriétaire a seul le droit d’exécution,
on aura rwxrw-rw-. Si le propriétaire a le droit de lecture/écriture, le groupe le droit
de lecture seul et les autres aucun droit, on aura rw-r—– Cette notation est la notation
symbolique. Cette notation a le mérite d’être explicite et simplement compréhensible, mais
elle est plus longue à mettre en oeuvre que la notation octale. Celle-ci utilise la conversion
en base 8 (sur trois bits) des trois attributs de droits. Le premier bit (en partant de la
gauche) correspond au droit de lecture. Le second au droit d’écriture, le troisième au droit
d’exécution. Comment convertir : le bit de gauche vaut 4, celui du milieu vaut 2, celui de
droite vaut 1. Ajouter simplement ces valeurs : vous aurez un nombre octal (de 0 à 7)
15
correspondant aux droits. Par exemple 7 = 4 + 2 + 1 − > droits de lecture, écriture et
exécution 4 = 4 + 0 + 0 − > droits de lecture 5 = 4 + 0 + 1 − > droits de lecture
et d’exécution Ceci pour chaque catégorie d’utilisateurs (propriétaire, groupe et autres).
Exemples : rwxrwxrwx correspond à 777 rw-r–r– correspond à 644 rw-r—– correspond à
640 Ces droits peuvent être changés avec la commande chmod Par exemple chmod 640
nom-fichier donnera les droits de lecture/écriture au propriétaire, lecture seule au groupe
et aucun droit pour les autres. La commande chmod permet également le changement
des droits sous forme symbolique. Bien entendu, il est possible de changer les attributs
avec un programme graphique ! Les droits sont en fait notés sur 12 bits. Les neufs bits
de droite correspondent aux droits cidessus, les trois bits de gauche correspondent aux
attributs spéciaux décrits ci-dessous. Si ces trois bits sont omis, ils sont considérés comme
égaux à 0 (de manière générale, les chiffres omis sur la gauche sont considérés comme
nuls : 7 équivaut à 0007, 45 à 0045, 644 à 0644).
2.2.2
Type de fichier
Chaque fichier contient également l’information de son type :
d pour un répertoire, - pour un fichier normal, b pour un périphérique en mode bloc
(exemple : disque dur), c pour un périphérique en mode caractère (exemple : imprimante),
l pour un lien symbolique (voir plus loin), p pour un tube nommé (fifo), s pour une socket.
• Ces informations apparaissent avec la commande ls −l Exemple pour un répertoire :
ls −dl test (le d signifie que l’on veut l’info sur le répertoire et non sur son contenu)
16
drwxr-xr-x ....
Le premier d signifie qu’il s’agit d’un répertoire. On note le x (exécution) : pour un
répertoire, cela signifie que l’on peut entrer dans le répertoire ou lister son contenu.
17
Chapitre 3
Commandes de base et gestion des
processus.
18
3.1
Le manuel en ligne
Une aide en ligne est disponible sous Unix et la plupart des commandes sont présentes
dans ce manuel. La commande man permet de consulter ce manuel. La syntaxe générale
est la suivante:
man [section] nom-de-la-commande
Si la page existe (si elle est trouvée dans l’une des arborescences définies dans la
variable MANPATH), le système la formate et l’affiche à l’écran. En règle générale, la
réponse a beaucoup de problèmes se trouve dans ces pages. N’hésitez donc jamais à les
consulter. Attention toutefois, certaines commandes peuvent apparaı̂tre plusieurs fois dans
la liste des pages de manuel. En effet, certaines fonctions sont utilisées dans plusieurs cas
de figures; par exemple, la commande if..then..else peut être aussi bien une commande
Unix, qu’une commande C, ou C++ ou Perl... dans ce cas, il existe donc plusieurs pages
se référant à cette commande (plusieurs sections contiennent des informations sur cette
fonction), il faut faire donc attention à appeler la bonne page de manuel. Pour cela, il
existe un moyen de connaı̂tre toutes les pages de manuel se référant à un mot clé donné:
man -k mot-clé
l’utilisateur verra une ligne pour chaque entrée du manuel concernant ce mot-clé. Par
exemple
man -k file
19
3.2
3.2.1
Commandes de base
Créer un répertoire
La commande servant à créer des répertoires sous Unix est:
mkdir [options] répertoires...
Il suffit d’avoir le droit d’écriture dans le répertoire père. Si on veut créer une arborescence directement, il faut utiliser l’option −p. Par exemple pour créer l’arborescence
/tp − unix/td1, taper mkdir −p tp − unix/td1.
3.2.2
Supprimer un répertoire
Comme pour les fichiers, la commande rm (avec l’option -r) permet de supprimer des
répertoires. Il existe une autre commande:
rmdir répertoires...
qui elle permet de supprimer les répertoires indiqués si ceux-ci sont déjà vides.
3.2.3
Déplacer, changer le nom d’un répertoire
Comme pour les fichiers, il s’agit de la commande mv. Ceci n’est possible sous System
V que si les deux répertoires ont le même parent, et sous BSD que si les deux répertoires
20
sont dans le même système de fichiers.
3.2.4
Copier tous les fichiers d’un répertoire
La commande à utiliser est:
cp − r repertoire source repertoire destination Toute l’arborescence du répertoire
source est copié dans le répertoire destination. Les nouveaux fichiers se retrouvent dans
le répertoire répertoire-destination/répertoire-source.
3.2.5
Occupation de l’espace disque
Parfois, il arrive que vous receviez des messages du système ou même de l’administrateur système vous indiquant que vous occupez trop de place sur le disque. Il existe
deux commandes qui permettent de savoir la place occupée par une arborescence, ou de
connaı̂tre la place disponible dans un système de fichiers. La commande:
du [options] [fichiers...]
affiche le nombre de kilo-octets occupés par les fichiers (ou répertoires) passés en
paramètre. La commande:
df [options] [file-system] [fichier]
Si aucun renseignement n’est spécifié, la commande df retourne les informations sur
tous les systèmes de fichiers.
21
3.2.6
Autres commandes utiles
cd : Change Directory Permet de changer de répertoire courant Syntaxe : cd chemindu-répertoire Le chemin peut être absolu (il commence par le caractère /) ou relatif : il
s’applique alors à partir du répertoire courant. Si aucun chemin n’est fourni, se positionne
dans le répertoire de travail de l’utilisateur (voir pwd ci-dessous, voir variable $HOME)
Exemple : se positionner dans le répertoire /usr cd /usr
echo affiche sur l’écran syntaxe : echo chose-à-afficher chose à afficher peut être une
variable, une chaine, le résultat d’une commande... exemple : afficher
¿
hello word
À
sur
l’écran : echo ”hello word”
exit quitte le shell courant. Raccourci : Ctrl-D syntaxe : exit export exporte une variable dans l’environnement courant et permet de la définir syntaxe : export VARIABLE
ou export VARIABLE=valeur exemple : rajouter au path courant un path vers /usr/local/bin
export PATH=$PATH : /usr/local/bin
pwd (Print Working Directory) affiche le répertoire de travail de l’utilisateur courant
syntaxe : pwd exemple 1 : affiche le répertoire de travail (pour le superutilisateur) pwd
(renvoie /root) exemple 2 : définit la variable REPUTIL avec le contenu du répertoire
de travail courant : export REPUTIL=‘ pwd‘ (utilisation de l’antiquote pour renvoyer le
résultat de la commande)
test permet de tester une condition (existence ou type d’un fichier, comparaison de
chaı̂nes, comparaison de nombres. Renvoie un statut égal à 0 si l’expression est vraie,
22
1 si elle est fausse. Est utilisé dans les expressions conditionnelles, le plus souvent dans
les scripts. Il est souvent remplacé par une autre syntaxe [ <expression> ] Syntaxe : test
<expressions> Exemple : efface un fichier <fichier> s’il existe if test −e <fichier> ; then
rm <fichier> ; fi Avec la seconde syntaxe, on aurait If [ -e <fichier> ] ; then rm <fichier> ;
fi
umask définit l’umask (masque des droits par défaut lors de la création de fichier).
Ne positionne jamais le bit de fichier exécutable sur les fichiers normaux. Syntaxe : umask
<masque> Exemple : positionne le mode de création par défaut à 644 umask 022
Chown : changement de propriétaire d’un fichier Syntaxe : chown user[ :group] fichier
Option -R : changement récursif de propriétaire
Mount : montage d’un système de fichiers dans l’arborescence unix Syntaxe : mount
-t type périphérique répertoire Où type est le type du système de fichiers, périphérique
le nom du périphérique, répertoire le répertoire de montage. Exemple : monter le système
de fichiers windows se trouvant sur la première partition du disque maitre sur la nappe
ide 1 au point de montage /mnt/windows
Umount : démontage d’un système de fichiers Syntaxe : umount <périphérique> ou
umount <point de montage> On ne peut pas démonter un périphérique s’il est occupé (pas
exemple si on utilise des fichiers sur ce périphérique) Ln : création d’un lien physique ou
symbolique Syntaxe : ln -option <source> <destination> Pour créer un lien symbolique,
utiliser l’option -s Tar : archivage - désarchivage Syntaxe : voir man tar
Grep : recherche d’expression régulières Syntaxe : grep -options <motif> [<fichier>]
23
Cherche le motif <motif> dans le fichier <fichier> (<motif> étant une expression régulière)
Grep est souvent utilisé à la suite d’un tube (voir redirections et tubes)
Find : recherche de fichier Syntaxe extrêmement simplifiée : find <chemin> -name
<motif> Il y a beaucoup d’autres options. Voir man find Exemple : trouver dans le
répertoire courant les fichiers dont le nom commence par c : find . -name ’c*’
Nice : définition de la priorité d’exécution d’un processus Syntaxe :nice -n <valeur>
<commande> Lance la commande <commande> avec la priorité <valeur> La priorité
va de -20 (le plus prioritaire) à 19 (le moins prioritaire). Les priorités négatives (c’est à
dire plus prioritaires) ne peuvent être définies que par le superutilisateur (root)
More : affichage page par page Syntaxe :more <fichier> Souvent utilisé à la suite d’un
tube, auquel cas <fichier> n’est pas indiqué. Less : affichage par page évolué Syntaxe :
less <fichier> Souvent utilisé à la suite d’un tube, auquel cas <fichier> n’est pas indiqué.
Beaucoup d’option : voir man less
3.3
Processus
Tout programme tournant en mémoire s’appelle un processus. Chaque processus possède
un numéro d’identification unique, des ressources propres (espace mémoire, espace d’entréessortie...). Un processus hérite de l’environnement du processus qui l’a lancé (variables).
Chaque processus peut être supprimé (tué) par la commande kill.
Syntaxe : kill numéro-de-processus, kill -s <signal>
24
numéro-de-processus Exemple : tuer un processus récalcitrant :
kill -s 9 1590 (envoie le signal KILL au processus 1590)
Les ressources utilisées par le processus sont alors restituées au système. Chaque processus est à l’écoute de signaux. Ces signaux peuvent être envoyés à un processus par un
autre, mais aussi avec la commande kill. Le signal le plus courant est le signal SIGTERM,
qui demande au programme de s’arrêter. Lors de l’arrêt du système, un signal SIGTERM
est envoyé en broadcast à tous les processus pour qu’ils s’arrêtent correctement.
On ajoute que pour connaı̂tre les processus qui tournent, on fait appel à la commande
ps
Syntaxe : ps options
25
Chapitre 4
VI et Quelques notions sur le Shell.
26
4.1
L’éditeur de texte Shell
L’éditeur vi est l’éditeur standard du système d’exploitation UNIX. Vous pouvez utiliser l’éditeur vi dans une fenêtre xterm .
Pour utiliser l’éditeur vi, vous n’avez qu’à entrer à votre terminal (ou dans une fenêtre
Command Tool) vi, suivi d’une espace puis du nom du fichier que vous voulez éditer. Si
le fichier n’existe pas, vi le créera automatiquement (l’exemple qui suit éditera le fichier
prog.c) :
station% vi prog.c
On distingue deux modes :
• Mode d’insertion Les caractères entrés sont enregistrés directement dans le fichier
en cours d’édition;
• Mode de commandes Les caractères entrés sont interprétés en tant que commandes
servant au positionnement du curseur (pour bouger le curseur, faire défiler le texte, etc.),
à l’édition du texte (pour effacer des caractères, des mots ou des lignes, etc.), au passage
au mode d’insertion (pour entrer du texte dans le fichier) et à l’entrée de commandes
globales (commandes plus complexes qui renvoient le curseur au bas de la fenêtre).
27
4.2
Le Shell
Le shell est l’interface homme/machine. Il permet de taper des commandes transmises
au système (noyau et processus). Il y a en fait plusieurs shells. Historiquement, c’est le
shell sh qui était utilisé sous unix. Plusieurs version sont ensuite apparues, apportant
une évolution des fonctionnalités (par exemple shell bourne : bash - shell korn : zsh et
d’autres encore). Ce document se réfère au shell bourne (bash). Le shell est un interpréteur
de commandes de la même manière que command.com ou cmd sous msdos/windows.
Ceux qui ont connu msdos ne seront pas trop dépaysés. Ils apprécieront certainement les
fonctionnalités avancées du shell, qui en fait une interface souvent plus rapide et efficace
qu’un environnement graphique, mais qui nécessite cependant de connaı̂tre les commandes
du shell. Tel est le but du présent paragraphe. Rappel important : sous unix/linux, la casse
des commandes et des noms de fichiers est importante. En règle générale, les commandes
sont en minuscules, les noms de fichiers le sont souvent, les variables sont souvent en
majuscules. Ce ne sont que des habitudes, pas des obligations. Fichier est différent de
fichier ou FICHIER. Il faut s’en souvenir ! Les options des commandes sont spécifiées par
un tiret suivi d’une lettre, ou un double tiret suivi de nom de l’option. Le tiret doit être
séparé de la commande par un espace.
4.3
Les variables
La notion de variable sous linux est la même que sous msdos. Les variables sont propres
à un environnement. Si vous ouvrez deux consoles différentes, chacune bénéficie de son
28
environnement propre. Les commandes lancées à partir d’un environnement héritent de
cet environnement. Souvent, les noms de variables sont en majuscules, mais ce n’est pas
une obligation. Le contenu de la variable est référencé en faisant précéder le nom de la
variable du signe $.
Exemple : je crée la variable TRUC et je lui donne la valeur
¿
texte de truc
À
:
TRUC=”texte de truc” J’affiche le contenu de la variable TRUC : echo $ TRUC (affiche :
texte de truc) par contre, echo TRUC affiche TRUC
Pour afficher l’environnement courant et ses variables : printenv Les variables définies
lors d’une session ne sont pas conservées. Pour que les variables restent définies, il faut
les redéfinir à chaque fois. C’est le rôle des fichiers de configuration.
4.4
Lancement de l’exécution d’un shellscript
On appelle shellscript un fichier qui contient des noms de commandes et des instructions internes au shell. L’utilisateur peut lancer un shellscript commande une commande.
Les commandes contenues dans le shellscript sont alors lancées comme si l’utilisateur les
tapait sur la ligne de commande. On peut lancer l’exécution d’un shellscript de trois
manières différentes
• Lancement par le nom du shellscript: Si l’utilisateur a le droit de lecture et d’exécution
sur le shellscript, il peut le lancer en tapant simplement son nom. Il se comporte alors
comme n’importe quelle commande. En particulier, il peut être utilisé par un autre shells-
29
cript. On peut construire ainsi de nouvelles commandes adaptées à ses propres besoins.
Lors de l’appel, le shell parcours la variable PATH pour trouver le fichier, donc par prudence, il est bon de lancer le script comme suit: ./shellscript, ceci évitera le temps de
recherche du script dans les arborescences de répertoires et surtout l’exécution d’un autre
script portant le même nom.
• Lancement par appel explicite du shell: Si le script porte un attribut de lecture, on
peut le lancer par appel explicite du shell: /bin/ksh nom-script Dans ce cas, un nouveau
shell est lancé, celui-ci lit les commandes du script et les fait exécuter comme si elles
avaient été tapées au clavier.
• Lancement par appel de la commande interne
à faire précéder le nom du fichier par un
. : La dernière solution consiste
¿ À
. : . shellscript Dans ce cas, il n’y a pas de
¿ À
création d’un nouveau processus, les modifications de l’environnement sont conservées.
En fait, ¿.À est une commande interne au shell qui lit toutes les commandes contenues
dans le shellscript et les exécute comme si elles avaient été tapées au clavier. De la même
façon, la variable PATH est parcourue pour déterminer l’emplacement dans le système de
fichiers du script.
30
Annexe A
Exercices.
31
Exercices
Exercice 1
En utilisant la commande cat, créer un fichier appelé V illes et contenant
les lignes suivantes :
Casablanca
Rabat
F ez
Terminer la saisie par 0 Ctrl − d0
Ajouter les lignes suivantes :
M ohammedia
M arakech
Terminer la saisie par 0 Ctrl − d0
En utilisant la commande sort, créer un fichier appelé V illesT rie qui
contient les noms des villes du fichier V illes mais dans l’ordre alphabétique.
Utiliser le même principe pour créer un fichier qui contient les noms de
trois éudiants, après, vous en ajoutez deux, ensuite, vous trier les noms
dans l’ordre alphabétique.
Exercice 2
Créer un fichier appelé liste contenant la liste des fichiers du répertoire
et de ses sous-repértoire.
Afficher la liste des fichiers présents dans le répertoire dans l’ordre alphabétique en tapant une ligne.
Exercice 3
Taper une ligne de commande qui affiche le message
00
Le f ichier est bien present sur le disque dur 00 seulement lorsqu’un fichier
00
toto00 est présent dans le répertoire courant.
N.B. Commandes à utiliser : ls, echo
Exercice 4
Afficher tous les fichiers contenants la lettre p.
Afficher les fichiers commencants par un l.
Exercice 5
Aller dans le répertoire de connexion de votre voisin en utilisant les
chemins absolus.
Retourner dans votre répertoire de connexion. Créer un répertoire 0 rep10 .
Aller dans le répertoire d’un autre voisin en utilisant les chemins relatifs.
Créer un répertoire 0 rep20 . Conclure.
Exercice 6
Dans votre répertoire, recréer le fichier 0 liste0 auquel vous attribuerez
les droits suivants 444. Expliquez les droits que vous avez accordez à votre
fichier. Donner une commande équivalente.
Changer le propriétaire du fichier.
32
Ajouter les droits en écriture pour tout le monde sur ce fichier. Conclure.
Exercice 7
Rechercher à partir de /home tous les fichiers contenants au moins un
chiffre dans leur nom et les afficher.
Exercice 8
On veut que les fichiers créés à compter de maintenant soient accessibles
uniquement à leur propriétaire rw − − − − − −−.
Exercice 9
Calculer le résultat de la multiplication de 8745 et de 4512 et stocker le
résultat dans la variable multip
Exercice 10
1. En tant que user1, pouvez vous créer le rép. temporaire /home/temp?
essayer! pourquoi?
2. Effectuer cette création comme root (pensez à la commande su).
3. Accorder les permissions maximales sur /home/temp, vérifier.
4. totox, toujours lui, tout content d’avoir enfin un droit d’écriture, dans
/home/temp eesaie de copier les 2 fichiers /ets/hosts et /ets/passwd dans
/home/temp? y parrviendra t-il? pourquoi? que donne ll /home/tmp?
5. totox, essaie maintenant de supprimer ces 2 fichiers de /etc. Réussitil? 6. Effrayé à l’idée de se faire pincer par le (ou la) redoutable root, totox
veut masquer sa faute tout en faisant punir user1 à sa place ! Pour cela,
il veut que user1 devienne propriétaire du fichier copié passwd. Comment
s’y prend t-il? Réussit-il? Et vous comment auriez vous fait?
Exercice 11
1. Comparer les permissions de /ets/passwd et /etc/shadow. Pourquoi
a t-on nommé ainsi ce dernier fichier ? user1 peut-il le lire? et voir sa
présence? L’examiner pour savoir son rôle.
2. Par précaution, en faire une copie sous le nom de shadow.bak dans
/home/temp ! vérifier les droits de /home/temp/shadow.bak
3. Pensez-vous tout de même pouvoir supprimer le fichier précédent?
Concluez!
4. root fait maintenant une copie de shadow chez vous, dans /home/user1,
sous le nom de shadow.bak et vous accorde la propriété de la copie. Comment fait-il? user1 vérifie le résultat.
5. Avec un éditeur de texte, vous modifiez ce fichier, par exemple en
supprimant des lignes, et vous faites une mise à jour. Cette mise à jour
sera t-elle réalisée? pourquoi?
6. Pensez vous que user1 puisse supprimer ce fichier? Essayez et expliquez!
Exercice 12
33
1. Afficher la quantité d’espace occupé des systèmes de fichiers.
2. Afficher l’espace-disque occupé par tous vos répertoires.
3. La même chose, mais en triant les répertoires selon leur taille dans
l’ordre inverse (les plus gros répertoires d’abord, les plus petits finalement).
4. La place totale occupée correspond-elle à ce qu’indique la commande
quata?
Exercice 13
1. Afficher la liste de tous les processus qui vous appartiennent.
2. Ouvrez une fenêtre horloge avec la commande xclock − update 2
(vous constatez que l’horloge tourne mais que le shell est suspendu), puis
suspendez-la (vous constatez que le processus horloge ne tourne plus, mais
que le shell est revenu en avant-plan)
3. Voyez l’état de ce processus avec la commande jobs, relancez-le en
arrière-plan (les aiguilles tournent à nouveau). Vérifiez avec la commande
jobs, puis tuez-le.
4. Relancez cette horloge, mais cette fois-ci directement en arrière-plan
(c’est-à-dire de façon détachée du shell). Comment tuer ce processus horloge depuis une autre fenêtre terminal (depuis un autre shell, où la commande jobs ne voit pas le processus en question)
Exercice 14
Faites un alias qui affiche avec la commande more la taille occupée par
tous vos répertoires. Testez cet alias.
Exercice 15
Tapez une commande, 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 16
Extraire les noms de login et UID puis triez suivant les UID, le tout en
une seule commande, vous redirigerez le tout vers un fichier.
Exercice 17
1. Vous avez chez vous un répertoire tmp/ qui contient un fichier bidon.
Créez un lien physique sur tmp/bidon appelé blo, dans votre répertoire
d’acceuil (HOME). Comparez les contenus de tmp/bidon et de blo?
2. Même question avec un lien symbolique.
3. Quelles sont les différences entre les liens durs et les liens symboliques?
4. Dans quel cas ne peut-on pas faire de lien physique? Que faut-il faire?
Quel est l’effet de chmod sur un lien?
34
Exercice 18
Pour les nostalgiques du dos, il s’agit de taper a : en ligne de commande
et d’obtenir le contenu du répertoire principale de la disquette. Taper c :
pour démonter la disquette et obtenir la liste de /. Pour ceci il faut ecrire
un petit script!
Exercice 19
Ecrire un script de vérification si un utilisateur est connecté.
Exercice 20
Ecrire un script (en utilisant la boucle “for”) qui affiche tous les fichier
qui se termine par ∗.c
Exercice 21
L’objectif de cette exercice est de savoir que le Shell, peut être un vrai
language de programmation.
1. Ecrire un script, qui teste un nombre entier naturel donné s’il est pair
ou impair, puis affiche le résultat.
2. Ecrire un script pour multiplier deux nombres et afficher le résultat.
3. Ecrire un script qui transforme un nombre donné en écriture binaire,
octale ou décimale.
Exercice 22
Ecrire un script illustrant le passage des arguments en Shell.
Exercice 23
Avec la boucle while ecrire un petit script qui affiche tous les nombres
pairs inférieurs à 100.
Exercice 24
1. Prérequis: while, les paramètres positionnels, set–
Conseil : utiliser la construction :
cat ¡ user.text — while true
do read ligne
if [ “$ligne” = “ “ ]; then break; fi
...
fi
2. Créer un fichier texte user.txt contenant quelques lignes au format
suivant login mot-de-passe nom groupes-secondaires
Par exemple : toto moiletoto M. Toto profs
3. Ecrire le script essai − comptes.sh qui parcourt ce fichier ligne par
ligne, récupère les champs de chaque ligne dans les paramètres positionnels,
et les affiche.
35
Remarque Dans le prochaine exercice, on verra commet créer un script
capable de générer des comptes à partir d’un fichier!
Exercice 25
• Obtenir la liste de tous les utilisateurs (nom, uid, gid, répertoire personnel) possédant un compte créé sur le serveur, autrement dit ayant un
uid supérieur à 500 (uid se trouve au 3ème champ de /etc/passwd)
Indication
• Se servir du dernier exercice du TP5 avec les conseils suivant
1. Extraire les champs 1, 3 et 4 du fichier /etc/passwd avec la commande
cat /etc/passwd — cut -d: -f 1,3,4
2. envoyer les lignes précédents vers l’entrée de la commande tr, de façon
à remplacer le séparateur : par des espaces cat /etc/passwd — cut -d: -f
1,3,4 — tr “:” “”
3. Puis on envoie la sortie dans une boucle while qui permet d’en extraire
chaque ligne, dont on affectera chaque champ aux paramètres positionnels
grâce à set –
4. Il suffira alors de comparer la valeur uid à 500 et d’afficher si uid ¿=
500
Exercice 26
• Il s’agit de créer le script test-fichier, qui précidera le type du fichier
passé en paramètre, ses permissions d’accèes pour l’utilisateur
• prérequis : passage de paramètres, instructions : test et if .. then .. else
• Appel : ./test-fichier nomFichier
• Exemple de résultats attendus
Le Fichier /ets est un répertoire
“/etc” est eccessible par root en lecture écriture exécution
Le fichier /etc/smb.conf est un fichier ordinaire qui n’est pas vide
“/etc/smb.conf” est accessible par jean en lecture.
Exercice 27
• Il s’agit de créer un ensemble de comptes constituant un nouveau
groupe.
• Les noms doivent s’écrire comme un nom générique (par ex. stage,
eleve ..) suivit d’un numéro.
• Le script demande d’abord le nom générique et celui du groupe secondaire dans lequel tous les comptes sont créés. Par defaut le nom du groupe
sera le nom générique.
36