Unix de base

Ce document est accessible à l'URL : http://www.enseignement.polytechnique.fr/profs/informatique/Luc.Maranget/doc/unix.html

1 Premiers pas

Les TDs se dérouleront cette année sous le système d'exploitation (ou operating system) Unix. Celui-ci vous permettra de créer des fichiers, des répertoires, de lire une disquette, d'imprimer un document, c'est-à-dire d'accéder aux ressources de votre machine. La particularité d'Unix par rapport à Windows ou Mac OS est qu'il est muni d'interprètes de commandes (ou shells) fonctionnant en mode texte.

1.1 Commencement du monde

Commencez par vous loger (en anglais to log in), en tapant votre nom puis votre mot de passe sur la console qui est devant vous. En cas d'échec de cette opération :

Vous ne connaissez pas votre mot de passe, il est temps de passer au support logiciel ou à la scolarité.
Vous avez le papier avec votre mot de passe devant vous, mais cette machine ne veut rien comprendre. Recommencez, en faisant bien attention en particulier aux confusions entre zéro (`O'' barré) et la lettre ``O'', ou encore entre un et la lettre ``l'' minuscule.
Ensuite, venir nous voir.

Miracle, ça marche. Des fenêtres apparaissent toutes seules. Appuyez sur les boutons de la souris, des menus apparaissent.

Il sera rapidement nécessaire de changer votre mot de passe, car vous aurez du mal à mémoriser celui de départ !. Voir la section 4.1.

1.2 Le système de fichiers d'Unix

À partir d'un des menus (entrée xterm ou shell) créer une fenêtre de commande, s'il n'en existe pas déjà une et cliquer dedans. On reconnaît la fenêtre de commande à ce qu'elle propose une invite a taper des commandes. Par exemple, pour moi, sur manche :

maranget@manche ~ >

L'invite me rappelle que je m'appelle maranget que je suis sur manche, elle m'indique ensuite le répertoire courant. Ici ~ est un racourci pour dire que je suis dans mon répertoire personnel.

En effet, les fichiers Unix sont organisés selon une arborescence, un système qui est à peu près le même que celui des macs ou des PC. Les fichiers ordinaires sont les feuilles de l'arborescence, dont les répertoires (ou directories) sont les noeuds. La différence avec les macs ou les PC (sous windows) est que vous ne disposez que d'une interface texte pour voir tout ça.

Pour se situer et ce déplacer, on utilisera donc les commandes suivantes au lieu de cliquer dans des valises :

ls: Lister le contenu du répertoire courant.
cd dir: Aller en dir.
mkdir dir: Créer le répertoire dir.
touch name: Créer un fichier vide de nom name.

Un fichier (ou un répertoire, les répertoire sont des fichiers) peut être repéré de deux façons, de façon absolue ou relative. La commande pwd donne le répertoire courant de façon absolue :

maranget@manche ~ > pwd
/users/profs/info/maranget

C'est à dire que mon répertoire courant est maranget dans le répertoire info, dans ..., dans la racine du système de fichier.

Tous les répertoires contiennent un répertoire caché .. qui est le répertoire immédiatement au dessus dans l'arborescence des fichiers. On donc peut ``remonter'' vers la racine en utilisant ``cd ..''.

maranget@manche ~ > pwd
/users/profs/info/maranget
maranget@manche > cd ..
maranget@manche /users/profs/info> pwd
/users/profs/info

La commande ls sans argument donne le contenu du répertoire courant, de façon relative.

maranget@manche /users/profs/info > ls
TD          cori      georget   levy      pessaux   schmitta     verhoeve
abiteboul   corir     giusti    mackie    pgros     schost       viennot
ailleret    correnso  godarde   majifa    pin       sendrier     waller
amann       cousot    gogard    maranget  pinto     senellar     weinfeld
benoist     cridlig   gonthier  mauny     pointche  sillion      weis
bertin      deianov   goubault  mestre    poulalho  sillion.old  werner
bonniot     dias      granboul  morain    puech     stern        yrobert
bourdoncle  ehrlich   hanrot    nataf     queinnec  steyaert
brunet      fages     harley    odevil    remy      suraud
charron     fouquet   lebotlan  parigot   rey       tabaczny
chassignet  freya     lecerf    pecquet   roussel   vaillant
clergeri    gaudry    lefessan  perrin    salvy     vaudenay

Vous êtes maintenant prêts pour un premier exercice

Petit exercice 1 : À partir de votre répertoire de départ.

Créer un fichier vide bidon.
Créer un répertoire TD et un sous-répertoire TD-0. Positionnez vous dans ce dernier qui sera votre répertoire de travail pour ce TD.

solution

Petit exercice 2 : Retournez dans votre répertoire personnel (cd sans argument) et utilisez ls muni de l'option -F ou -l pour distinguer les répertoires des autres fichiers. Tentez d'interpréter le résultat, puis confirmez votre intuition en vous déplaçant dans un sous-répertoire. solution

Remarque : Il est impossible de se souvenir de toutes les options des commandes Unix. Heureusement, Unix fournit un manuel en ligne, accessible par la commande man. On obtient des informations en anglais sur une commande Unix commande par : man commande. Essayez man cd ou man ls pour avoir une idée du problème...Une introduction plus douce à Unix se fera en consultant, l'annexe idoine du poly ou la toujours utile trousse de survie du Guide des moyens informatiques.

2 Quelques trucs pour se faciliter la vie

2.1 Édition de la ligne de commande

On ne tape pas toujours très vite sur un clavier et on fait des erreurs. Si vous vous trompez, ou voulez recommencer une commande déjà exécutée, inutile de tout retaper, vous pouvez entrer les combinaisons de touches suivantes (Ô joie, ces combinaisons de touches ressemblent à celles comprises par Emacs) :

Ctrl-b: (Ou flèche arrière) Reculer dans la ligne de commande courante.
Ctrl-f: (Ou flèche avant) Avancer dans la ligne de commande courante.
Ctrl-a: Aller en début de ligne commande.
Ctrl-e: Aller en fin de ligne commande.
Ctrl-d: Effacer le caractère à droite du curseur.
Backspace: Effacer le caractère à gauche du curseur.
Tab: Complétion automatique des commandes et parfois des arguments.
Ctrl-p: Commande précédente dans l'historique de vos commandes.
Ctrl-n: Commande suivante dans l'historique.

Petit exercice 3 : Minimiser les touches tapées, pour aller à la racine de l'arborescence des fichiers. solution

2.2 Contrôle des tâches

Par ailleurs, la fenêtre de commande offre un système simple de contrôle des tâches.

On peut par exemple lancer netscape en arrière plan, c'est à dire que vous lancez le programme et disposez encore de la main dans la fenêtre de commande.

maranget@manche ~> netscape &
maranget@manche ~>

Si vous avez oublié le ``&'', pas de panique, les combinaisons de touches et commandes suivantes vous donnent accès au contrôle des tâches :

: Ctrl-z Interrompre la commande en cours.
: Ctrl-c Arrêter définitivement la commande en cours.
: fg Relancer la commande interrompue en avant-plan.
: bg Relancer la commande interrompue en arrière-plan.
: jobs Lister les tâches.

De sorte que la séquence netscape...Ctrl-Z...bg a le même effet que netscape &.

3 Le système d'exploitation Unix, compléments

3.1 Du déjà vu ou presque

Voici tout d'abord quelques précisions sur les commandes que nous connaissons déjà :

ls dir: Lister le contenu du répertoire dir. Si dir est omis, le répertoire courant est listé.
cd dir: Aller en dir. Si dir est omis, aller dans le répertoire de l'utilisateur.
mkdir dir: Créer le répertoire dir.

(Un moyen simple pour créer un fichier de texte est d'utiliser l'éditeur Emacs.)

Précisons aussi qu'un nom de fichier est une chose assez complexe. Les noms les plus généraux sont des chemins d'accès aux fichiers, ces chemins étant des suites de noms simples séparés par le caractère ``/''. Un chemin peut être absolu ou relatif. Les chemins absolus commencent par le caractère ``/'', ils donnent tout le chemin d'accès au fichier à partir de la racine. Les noms relatifs sont tous les autres, ils donnent un chemin d'accès à partir du répertoire courant. Par exemple, si le répertoire courant est mon répertoire utilisateur (/users/profs/info/maranget), que ce répertoire contient un répertoire TD, qui contient un répertoire TD-0, alors TD/TD-0/coucou et /users/profs/info/maranget/TD/TD-0/coucou sont deux chemins vers le même fichier, le premier étant relatif et le second absolu.

En outre, le dernier élément d'un chemin est le nom de base, tandis que tout le reste est le nom de répertoire. Ainsi, dans /users/profs/info/maranget/TD/TD-0/coucou le nom de répertoire est
/users/profs/info/maranget/TD/TD-0 et le nom de base est coucou. On peut décortiquer un chemin à l'aide des commandes basename et dirname.

Petit exercice 4 : A votre avis, dans le chemin simple ``coucou'', quels sont les noms de base et de répertoire. Contrôlez votre intuition à l'aide des commandes basename et dirname. Cherchez un peu avant de regarder la solution

Nous sommes maintenant équipés pour comprendre en détail de nouvelles commandes de fichiers:

cp name₁ name₂: Copier le contenu du fichier de nom name₁ dans le fichier de nom name₂. Si name₂ est un nom de répertoire, alors la cible est un fichier qui a le même nom de base que name₁ et situé dans name₂.
mv name₁ name₂: Changer le nom du fichier name₁ en name₂. Néanmoins, si name₂ est un nom de répertoire, alors la cible est comme pour la commande cp.
rm name...: Effacer tous les fichiers donnés en argument.
rmdir name...: Effacer tous les répertoires donnés en argument, ces répertoires doivent être vides.

Les commandes cp et rm n'agissent pas directement sur les répertoires. Pour ce faire, il faut leur donner l'option ``-r''. L'effet est alors de copier ou d'effacer un répertoire et son contenu.

Deux autres commandes sont utilisées fréquemment :

more name...: Visionner les fichiers donnés en arguments, page par page. On passe à la page suivante par la barre d'espacement et on quitte prématurément par ``q'' (Il y a d'autres sous-commandes, taper ``?'' pour l'aide).
cat name...: Afficher en une seule fois le contenu des fichiers donnés en arguments. La commande cat est souvent utilisée avec un seul argument pour voir rapidement le contenu d'un fichier court.

3.2 Droits des fichiers

Les fichiers ont des droits, ces droits sont de trois sortes, lecture (r), écriture (w) et exécution (x) ; et ils concernent quatre catégories de personnes, l'utilisateur propriétaire du fichier (u), le groupe propriétaire du fichier (g), les autres (o) et tout le monde (a). On visionne les propriétaires et droits d'un fichier avec ls -l. Par exemple, je suis positionné dans un répertoire initialement vide :

maranget@manche ~/TD/TD-0 > ls -l coucou
coucou not found
maranget@manche ~/TD/TD-0 > touch coucou
maranget@manche ~/TD/TD-0 > ls -l coucou
-rw-r--r--   1 maranget   profs            0 Oct 19 16:54 coucou

C'est à dire que l'utilisateur maranget peut lire et écrire dans le fichier, que les membres du groupe prof peuvent lire ainsi que tous les autres utilisateurs.

On modifie les droits par la commande chmod, on peut ajouter des droits avec ``+'' ou en enlever avec ``-''. Par exemple je décide de permettre aux professeurs d'écrire dans coucou :

maranget@manche ~/TD/TD-0 > chmod g+w coucou
maranget@manche ~/TD/TD-0 > ls -l coucou
-rw-rw-r--   1 maranget   profs            0 Oct 19 16:54 coucou

Puis j'interdis la lecture aux autres :

maranget@manche ~/TD/TD-0 > chmod o-r coucou
maranget@manche ~/TD/TD-0 > ls -l coucou
-rw-rw----   1 maranget   profs            0 Oct 19 16:54 coucou

Enfin, je décide d'autoriser lecture et exécution à tout le monde :

maranget@manche ~/TD/TD-0 > chmod a+rx coucou
maranget@manche ~/TD/TD-0 > ls -l coucou
-rwxrwxr-x   1 maranget   profs            0 Oct 19 16:54 coucou

3.3 Motifs

L'interpréteur de commande (le ``shell'') interprète certains caractères comme des motifs opérant sur les noms de fichiers :

*: Représente n'importe quelle suite de caractères (sauf ``.'' en tête et ``/'').
?: Représente n'importe quel caractère (sauf ``.'' en tête et ``/'').
[...]: Représente un caractère pris dans ``...'', où ``...'' peut être une suite de caractères ou d'intervalles de la forme ``c₁-c₂''.
[^...]: Représente un caractère qui n'est pas pris dans ``...''.

Considérons un répertoire qui contient les fichiers suivants :

maranget@manche ~/TD/TD-0 > ls
a       aa      ab      ac      ad      b       c       coucou  d

On liste facilement les fichiers dont le nom se compose d'un seul caractère :

maranget@manche ~/TD/TD-0 > ls ?
a  b  c  d

Ou encore les fichiers dont le nom commence par un ``a'' :

maranget@manche ~/TD/TD-0 > ls a*
a   aa  ab  ac  ad

Ou enfin les fichiers qui ne commencent ni par ``a'', ni par ``b'', ni par ``c'' :

maranget@manche ~/TD/TD-0 > ls [^a-c]*
d

Petit exercice 5 : Lorsque l'on édite un fichier name, l'éditeur Emacs sauve de temps en temps le contenu du buffer dans un fichier name~.

Comment faire le ménage sans trop se fatiguer ?
Quel est le danger de cette solution, en cas de faute de frappe ?

solution

Parfois on veut éviter le remplacement des motifs par les noms de fichiers. On appelle ça ``quoter''. On met alors les motifs entre guillemets (``"'') ou quotes (``''').

Petit exercice 6 :

Créer et effacer un fichier de nom ``*''.
Créer et effacer un fichier de nom ``"'' (Souvenez vous qu'il qui a deux façons de quoter).

solution

3.4 Redirections

Jusqu'ici nous avons vu des commandes qui affichent leur résultat sur la console. Unix permet de rediriger cette sortie dans un fichier à l'aide du caractère ``>'' :

> name: Rediriger la sortie vers le fichier name. Le fichier name ne doit pas exister et est créé.
>> name: Rediriger la sortie vers le fichier name. Si name existe déjà, la sortie est ajoutée en fin de fichier.

On aura donc par exemple :

maranget@manche ~/TD/TD-0 > ls
a  b  c  d
maranget@manche ~/TD/TD-0 > ls > liste
maranget@manche ~/TD/TD-0 > ls > liste
liste: File exists.
maranget@manche ~/TD/TD-0 > ls >> liste
maranget@manche ~/TD/TD-0 > cat liste
a
b
c
d
liste
a
b
c
d
liste

La commande cat sans arguments lit son entrée sur le clavier. On peut ainsi créer un fichier non-vide :

maranget@manche ~/TD/TD-0 > cat > coucou
Une ligne     
Encore une
On termine l'entrée en tapant Control-d
maranget@manche ~/TD/TD-0 > cat coucou
Une ligne
Encore une
On termine l'entrée en tapant Control-d

Petit exercice 7 :

Ajouter une ligne au fichier coucou.
Mettre deux fois le contenu de coucou dans coucou. (Ça risque de ne pas marcher du premier coup, ne pas se décourager tout de suite, mais pensez à utiliser les commandes de gestion de fichier).

solution

3.4.1 Complément

Les commandes qui lisent le clavier et affichent sur la console (on parle aussi d'entrée et de sortie standard) sont appelés des filtres. De nombreuse commandes Unix agissent comme des filtres quand on les utilise sans argument. C'est le cas de cat, mais aussi de sort (trier), wc (compter les lignes), etc. On peut rediriger l'entrée d'un filtre par ``< name'' Par exemple, on peut enlever les doublons du fichier coucou de l'exercice 4 ainsi (l'option ``-u'' de sort évite la répétition de la même ligne dans la sortie triée) :

maranget@manche ~/TD/TD-0 > sort -u < coucou > coucou.trie
maranget@manche ~/TD/TD-0 > cat coucou.trie 
Encore une
On termine l'entrée en tapant Control-d
Une ligne
Une ligne en plus

On peut ensuite compter les lignes de coucou.trie qui sont les lignes différentes de coucou par :

maranget@manche ~/TD/TD-0 > wc -l < coucou.trie
      4

Une des astuces majeures d'Unix est la possibilité de connecter deux filtres cmd₁ et cmd₂, par ``cmd₁|cmd₂''. C'est à dire que la sortie de cmd₁ est l'entrée de cmd₂. On peut donc, pour compter les lignes différentes de coucou, se passer du fichier coucou.trie :

maranget@manche ~/TD/TD-0 > sort -u < coucou | wc -l
      4

4 Le réseau

4.1 Connexion à distance

On se connecte à distance sur une machine sur laquelle on a un compte par la commande rlogin ou slogin si la machine vers laquelle on se loge utilise un protocole sécurisé.

maranget@manche ~ > slogin poly
Password:
Last login: Tue Sep 29 11:20:16 from mulet.polytechni
...
maranget@bilbo ~>

On vous redemande votre mot de passe. (Ce qui peut être évité si votre répertoire sur la machine cible contient un fichier .rhosts dont une ligne est le nom de la machine qui fait la demande de connexion.)

5 Un peu de programmation

L'interpréteur de commande (le shell) connaît, en plus des commandes Unix, un certain nombre de constructions qui en font un véritable langage de programmation orienté vers la manipulation de fichiers. Le shell est bien entendu lui même une commande Unix, ainsi que les programmes écrits en shell. Nous en profitons pour faire quelques petits exercices de programmation.

5.1 Commencements

Votre shell est normalement tcsh, il se trouve que l'on préfère un autre shell pour programmer : sh. Les différences sont mineures, mais autant le savoir. Voici un premier programme en sh, contenu dans un fichier args qui doit être exécutable :

maranget@manche ~/TD/TD-0 > ls -l args
-rwxr-xr-x   1 maranget   profs           36 Oct 19 18:59 args
maranget@manche ~/TD/TD-0 > cat args
#! /bin/sh

for i
do
  echo $i
done

Le programme args affiche ses arguments sur la console :

maranget@manche ~/TD/TD-0 > args coucou foo bof
coucou
foo
bof

Quelques explications :

La première ligne #! /bin/sh indique à Unix qu'il s'agit d'un programme sh.
La boucle for i do...done est répétée pour chaque argument. Dans le corps de la boucle $i permet d'accéder au contenu de la variable i qui est un argument de la commande.
La commande echo affiche son argument sur la console et saute une ligne.
Dans un programme shell, les retours à la ligne sont importants (c'est rarement le cas dans les langages modernes). Ainsi, do et done doivent apparaître seuls dans leur ligne.

Pour comprendre un programme shell on peut s'imaginer en train de taper les commandes exécutées...

Voici un autre exemple d'un programme tfile qui donne le type d'un fichier donné en argument dans le style de ls -F

maranget@manche ~/TD/TD-0 > cat tfile
#! /bin/sh
file=$1
if test -d $file
then
  echo $file/
elif test -x $file
then
  echo $file'*'
else
  echo $file
fi
maranget@manche ~/TD/TD-0 > tfile args
args*
maranget@manche ~/TD/TD-0 > tfile .
./

Quelques explications :

La construction file=$1 range le contenu de la variable 1 (le premier argument) dans la variable file. On accède ensuite au contenu de file par $file.
La construction if test₁ then cmds₁ elif test₂ then cmds₂ else cmds₃ fi exécute les commandes cmds₁ si test₁ est vrai, sinon cmds₂ si test₂ est vrai, sinon cmds₃. La clause elif peut être omise ou répétée, la clause else peut être omise. Le mot-clé de fermeture fi et les sauts de ligne tels qu'ils apparaissent dans le programme sont eux obligatoires.
La commande test teste certaines propriétés d'un fichier donné en argument. L'option -d sert à tester les répertoires, tandis que l'option -x teste les fichiers exécutables.

Petit exercice 8 : Écrire une commande tfiles qui liste tous ses arguments dans le style de tfiles, puis l'utiliser pour lister le répertoire courant. Avant de vous précipiter sur la solution, pensez qu'une commande shell peut en appeler une autre et aux motifs du shell. solution

5.2 Toujours plus loin

La boucle for des exemples précédents opérait sur les arguments de la commande. En fait cette boucle est plus générale elle peut opérer sur une liste donnée après le mot-clé in. Cette liste peut être générée à l'aide de motifs. Voici par exemple une commande tdir qui liste le contenu du répertoire donné en argument dans le style de tfiles :

#! /bin/sh

dir=$1
for i in $dir/*
do
  tfile $i
done

Petit exercice 9 : Écrire une commande liste qui fait la liste de l'arborescence des fichier à partir de son argument.

Pour vous donner une idée, liste dir réalise l'effet de la commande Unix find dir -print. Pensez qu'un programme shell peut s'appeler récursivement. En dernier recours, regardez la solution. solution

6 Configuration du shell

Lorsqu'il se lance, le shell lit un fichier de configuration .cshrc dans votre répertoire personnel. Cette particularité va permettre de personnaliser un peu le shell. Le .cshrc suivant annule les alias obligeamment fournis par la configuration par défaut :

maranget@thon ~ > cat .cshrc
unalias mv
unalias rm
unalias cp

Vous pouvez éventuellement compléter ce .cshrc, mais ça demande du travail (documentation par man tcsh ou en lisant les fichiers de configuration par défaut dans /usr/local/startup). Par exemple, pour permettre au shell de trouver des commandes cmd dans le répertoire courant sans préciser ./cmd. On peut ajouter la ligne suivante au .cshrc :

set path ($path .)

Ce document a été traduit de L^AT_EX par H^EV^EA.