Chapitre 1 - IPNL - IN2P3

Initiation linux
juin 2010
M. Mommey & Y. Giraud Institut de Physique Nucléaire de Lyon
- 1 -

Chapitre 1 : Historique, concepts et préliminaires
Historique
UNIX est né en 1969 dans les laboratoires de la BELL, développé par Ken Thompson
pour les besoins internes tant des programmeurs que du service des brevets. Il s’appelle
alors UNICS.
UNIX avait à l'origine un but non commercial et se voulait très généraliste.
En 1973 D. Ritchie réécrit complètement UNIX en langage C, C étant considéré
facilement portable et donc « machine indépendant », rendant ainsi UNIX facilement
portable sur de multiples plateformes.
Cette portabilité a été une des raisons de la diffusion d'UNIX.
Pendant toutes les années 70 les fondateurs d’UNIX améliorent en profondeur leur
système, au sein des laboratoires BELL.
Mais ATT, propriétaire de BELL, ne misait pas alors sur la commercialisation d’UNIX et en
a délivré des licences à des universités.
Celles-ci ont travaillé sur une amélioration du système et de nombreux ajouts ont été
apportés. A la fin des années 70 une version nouvelle émerge portant le nom de
l'université l'ayant conçue : BSD (Berkeley System Development).
D'autre part le département de la défense américain a bâti sur UNIX le protocole réseau
TCP/IP et des constructeurs informatiques ont dès le début des années 80 apporté des
compléments tels que SUN avec NFS et NIS. Ces ajouts sont rapidement devenus des
standards de fait enrichissant UNIX.
Enfin citons au milieu des années 80 l’apparition du système XWINDOW d’interface
graphique pour stations UNIX, développé par le MIT.
Au début de ces années 80 ATT commence à trouver intéressant la commercialisation
d'UNIX, protège son système d'exploitation, et diffuse une version appelée SYSTEM V.
Le nom UNIX étant protégé, chaque UNIX livré par les constructeurs de matériel porte un
nom spécifique : HP-UX, IRIX, ULTRIX, AIX, SUNOS puis SOLARIS...
Les années 80 sont celles de la non unicité d’UNIX, certains systèmes se réclamant de
BSD et d’autres de SYSTEM V, avec des différences importantes. Heureusement cette
situation est révolue et les commandes sont unifiées. Les acteurs du monde UNIX ont
compris que la division favorisait des systèmes concurrents tel WINDOWS et ont multiplié
les consortiums et projets d’unification (OSF, CDE…).
La situation a encore évoluée en 1994-1995, ATT ayant vendu UNIX à NOVELL qui a luimême
cédé au groupe d'utilisateurs X-OPEN le label UNIX, les sources étant propriété de
SCO. Le but du consortium X-OPEN étant la définition et la promotion des systèmes
ouverts, le label UNIX peut maintenant être obtenu par tout système d'exploitation
respectant totalement les standards des systèmes ouverts.
En 1991 Linus Torvalds écrit de A à Z un clone d’UNIX, pour l’architecture X86. Il le
nomme LINUX. LINUX est compatible avec SYSTEM V et BSD, et implémente toutes les
fonctionnalités d’UNIX. LINUX a été immédiatement licencié sous forme licence GPL, ce
- 2 -

qui a permis qu’une communauté de développement se crée rapidement. Il est distribué
gratuitement. Une communauté toujours très active continue à travailler sur LINUX, et de
nombreux projets logiciels sont en cours ou achevés. Le travail fait autour de LINUX
dépasse probablement ce qui a été fait sur UNIX, avec notamment le développement de
logiciels orientés « grand public », ce qui n’existait pas sous UNIX.
Plusieurs distributions de LINUX ont vu le jour mais elles se différencient essentiellement
par les outils d’administration et les paquets supplémentaires.
On peut considérer que pour un utilisateur toutes les distributions de LINUX et toutes les
versions UNIX ont des comportements quasi-similaires en ce qui concerne les
commandes de bases, et nous parlerons indifféremment des 2 dans ce stage.
De ce cheminement chaotique, UNIX/LINUX sort avec l'avantage d’un système d’une très
grande richesse ; UNIX et LINUX sont de véritables boites à outils : des centaines
d'utilitaires (commandes) sont disponibles.
Concepts
Techniquement, UNIX est un système multi-tâches, multi-utilisateurs, avec gestion de
mémoire virtuelle, travaillant sur un système de fichiers hiérarchisé et qui, pour l'utilisateur
débutant, se caractérise par :
• La prépondérance de la notion de fichier, les périphériques étant par exemple vus
par l'utilisateur comme des fichiers.
• De même chaque commande UNIX correspond à un fichier exécutable
indépendant. Ce concept permet une vue totale du système, une personnalisation
facile. L'accès aux ressources de la machine est simplifié avec une gestion aisée des
entrées-sorties.
• L'importance de la notion de processus. Toute action génère en machine la création
d'un processus parfaitement identifiable. UNIX offre un mécanisme de communication
et d'héritage entre tous ces processus.
• La banalisation de l'interpréteur de commande, interface entre l'utilisateur et le
système et qui contrôle le déroulement de la session. Cet interpréteur de commandes,
qui est appelé shell sous UNIX, est un fichier exécutable standard et il en existe de
multiples versions. Ce shell est facilement paramétrable et offre de nombreuses
fonctions. Il occupera une part importante de notre programme.
Le shell
L’interpréteur de commande vous permet de lancer les commandes UNIX. Il vous fournit
l’invite vous permettant de rentrer la syntaxe de votre commande, analyse votre syntaxe
et fait appel à la commande UNIX spécifiée.
Il gère votre session et vous permet notamment :
• la gestion des entrées-sorties
• la définition de variables
• un mécanisme de rappel des commandes précédentes
• la création de synonymes
• la gestion de caractères de substitution
Le shell, outre l'interprétation des commandes système passées, fournit des commandes
internes dites 'built-in commands'.
- 3 -

Ces apports spécifiques liés au shell ont pour objet de simplifier la session UNIX et
également font du shell un langage de commande permettant l'écriture de procédures
complexes.
Ces 'built-in commands' permettent notamment des structures conditionnelles et de
répétition.
Il est possible de créer un fichier contenant une liste d'instructions shell. Une telle
procédure de commande est appelée SCRIPT sous UNIX.
Le shell n'étant qu'un exécutable ordinaire il est aisé d'en rajouter un nouveau à un
système UNIX. Ces shells vont différer par leurs fonctions internes, par exemple le
mécanisme d'historique des commandes ou les fonctions de programmation élaborées.
Il en découle une non unicité du déroulement de votre session UNIX en fonction du choix
de votre interpréteur de commande.
Le shell historique est celui de S. Bourne appelé le Bourne-shell (sh). Se sont rajoutés
deux shells importants le C-shell (csh) offrant un langage de programmation proche du C
et le Korn-shell (ksh) du nom de son créateur, plus de nombreux shell plus ou moins
marginaux et disponibles dans le domaine public. csh et ksh ne sont pas compatibles
entre eux. On classe les shells supplémentaires selon qu'il sont de la famille des C-shell
ou des k-shell. Citons notamment tcsh qui est un csh amélioré et bash dans la lignée de
ksh. bash est le shell utilisé par défaut sous LINUX.
Un shell est lancé automatiquement au login. Chaque utilisateur pourra donc choisir le
shell qu'il souhaite utiliser par défaut dès le début de sa session, sachant qu'à tout
moment il peut appeler un nouveau shell.
Préliminaires
Système d'exploitation
Comme nous l'avons indiqué au chapitre précédent, UNIX et LINUX ne sont pas uniques
mais les différences sont très mineures d’un point de vue d’un utilisateur. Nous utiliserons
pour ce stage des systèmes LINUX en version Scientific Linux 5.
Shell
Pour l'utilisateur UNIX, la différence majeure vient du choix de l'interpréteur de
commandes (shell). Les chapitres sur l'environnement de travail et l'écriture de scripts en
dépendent fortement. Comme nous avons choisi d’utiliser LINUX nous ferons le choix de
bash, qui est le choix par défaut.
Poste de travail
Pour être le plus général possible, nous considèrerons au maximum un poste de travail de
type terminal simple, sans utiliser les fonctionnalités complètes de l'environnement des
postes graphiques utilisés. Nous n’aborderons les interfaces graphiques de LINUX qu’en
fin de stage. Les concepts d'Xwindows seront également abordés.
- 4 -

Chapitre 2 : La prise de session
L'utilisateur
UNIX étant multi-utilisateurs chaque utilisateur doit être identifié par un nom bien défini
sous lequel il sera connu sur la machine (nom de login), et auquel est associé un mot de
passe non public assurant que seul cet utilisateur puisse utiliser le compte qui lui est
attribué.
Chaque utilisateur fait donc l'objet d'un enregistrement préalable dans un fichier base de
données utilisateurs (fichier /etc/passwd) maintenu par un responsable du système.
Celui-ci utilise un compte privilégié nommé root, seul login à pouvoir modifier les fichiers
systèmes.
De façon standard les noms d'utilisateurs comporte 8 caractères au maximum et les mots
de passe ont une longueur minimale de 6. Mais ces longueurs peuvent être différentes et
propres à chaque 'UNIX constructeur'.
Sont associés à chaque utilisateur et inscrit dans le fichier /etc/passwd, outre un nom de
login et un mot de passe :
• un numéro UID qui est un identificateur unique de l'utilisateur.
• un numéro GID qui est un identificateur commun à un groupe d'utilisateurs ayant
des intérêts à partager des ressources (fichiers notamment). A ce gid correspondra
(dans un fichier /etc/group) un nom symbolique de groupe au même titre qu'à l'uid
correspond un nom de login.
• le vrai nom de l'utilisateur.
• une zone logique (ou répertoire) du système de fichiers dans lequel seront par
défaut stockés les fichiers qui lui appartiendront.
• l'application qui sera lancée lorsque l'utilisateur se connectera. Celle-ci est de façon
générale un shell et on définit donc ici le shell par défaut que souhaite utiliser la
personne.
• éventuellement si le mécanisme de péremption du mot de passe est actif,
figureront les dates associées à celui-ci
Les uid et gid sont les vrais identificateurs de l'utilisateur et servent au mécanisme de
protection des fichiers.
Signalons qu'un utilisateur peut être connu de façon unique sur un ensemble de machine
en réseau si le mécanisme de NIS (Network Information Service) est mis en oeuvre. Ce
mécanisme exporte à partir d'une machine maître des bases de données du système, et
notamment passwd et group, vers les autres machines (dites esclaves) du réseau.
La connexion
Le mécanisme de connexion est différent dans sa forme selon que l’on se connecte sur
une session graphique ou bien en ligne de command depuis une connexion distante. Mais
dans tous les cas le système envoie à l'utilisateur une bannière spécifiant en général le
système d'exploitation, le nom affecté à la machine, et le terme login invitant à rentrer son
nom d’utilisateur puis passwd pour le mot de passe.
- 5 -

Signalons qu'UNIX est case-sensitive (sensible aux minuscules/majuscules) et
notamment pour le mot de passe. Une vieille compatibilité admet que pour le nom
d'utilisateur, si les majuscules sont utilisées, le terminal ne possède que celles-ci et donc
tout le reste de la session se déroulera en majuscules, ce qui peut être relativement
gênant.
Si la validation du login est correcte, le shell par défaut est lancé et les fichiers
d'initialisation généraux et de l’utilisateur sont interprétés. Le nom de ces fichiers est
dépendant du shell. Les fichiers permettant une personnalisation de sa session sont
situés dans le répertoire de base de l'utilisateur (home directory) et s'appellent par
exemple .bashrc pour bash, .cshrc et .login pour csh.
Le shell vous fournit alors le « prompt » ($ pour bash, % pour csh), vous invitant à taper
vos commandes.
A votre shell interactif est associé un pseudo-terminal (appelé tty sous UNIX). Un nombre
donné de pseudo-terminaux est disponible et chaque shell lancé sur le système est
associé au premier pseudo-terminal libre dans la liste. Quand le shell se termine il libère
son pseudo-terminal.
Sous LINUX ces terminaux sont notés pts/nn ou nn est le numéro du terminal.
Sous UNIX tous les processus tournant en machine sont numérotés de façon unique (pid)
et sont « fils » du processus qui les a généré. Le premier processus lancé au boot de la
machine a pour nom init et porte le pid 1.
Le shell lancé lors de votre connexion sera donc le père de tous les processus
(commandes) exécutés pendant votre session. Les processus fils héritent d’information de
leur processus père. Les processus lancés pendant votre session hériteront notamment
des fichiers ouverts et des variables dites « d’environnement » définies dans le shell
initial. Celui-ci ouvre notamment l'entrée standard (stdin) , la sortie standard (stdout), la
sortie-erreur standard (stderr).
La première est de façon générale le clavier, les 2 sorties sont le pseudo-terminal associé
à votre shell.
Les commandes que vous passerez lors de votre session afficheront donc par défaut sur
ce pseudo-terminal.
Une fois connecté, l'utilisateur peut modifier son mot de passe, et cette action est
recommandée de façon régulière lorsqu'un mécanisme obligatoire ne l'impose pas. La
commande passwd permet ce changement : elle demande le mot de passe en cours pour
validation de la personne et demande 2 fois le nouveau afin d'éviter les erreurs de frappe.
Les mots de passe sont bien sur tapés en aveugle pour éviter des regards indiscrets.
Tous les systèmes récents et notamment LINUX exigent que votre mot de passe est un
minimum d’en général 6 caractères et qu’on n’identifie pas des chaînes de caractères
correspondant à des mots de dictionnaires. Inutile donc d’essayer des prénoms simples
ou des séquences triviales. Pour compliquer, mixez des majuscules, minuscules, chiffres
ou caractères spéciaux.
Enfin si le mécanisme de NIS est mis en œuvre ce n’est pas passwd que vous devez
utiliser mais yppasswd. Le fonctionnement est le même. Mais la modification de votre mot
de passe se propagera sur tout le parc de machines LINUX.
En cours de connexion l’utilisateur peut « devenir » un autre utilisateur par la commande
su :
- 6 -

su
su [user] : basculer en l’utilisateur user ; le mot de passe de user sera bien sur demandé.
Quand on termine la session user, on revient dans sa session initiale. Si user est omis
c’est que l’on souhaite basculer vers l’utilisateur root.
La déconnexion d’une session terminal sera obtenue en tapant CTRL-D ou logout ou exit.
Les 3 mécanismes ne sont pas identiques, exit terminant une session shell, CTRL-D
fermant l’entrée standard ce qui pour un shell en phase d’attente (prompt) provoque sa
fin ; enfin logout est géré par certains shells comme un ordre de déconnexion avec
éventuellement exécution d’un fichier de sortie.
- 7 -

Chapitre 3 : Syntaxe générale d'une commande
Format
Une commande UNIX revient à taper le nom d'un exécutable qui est cherché dans un des
répertoires du système de fichiers figurant dans une liste de recherche que le shell
maintient dans une variable d'environnement nommée PATH.
Les commandes admettent des arguments, passés après le nom de commande, et
séparés entre eux par des blancs ou tout caractère qui aurait été défini comme
séparateur.
Une commande admet comme argument des options qui sont des modificateurs (ou
choix) vis-à-vis de l'action que doit exécuter la commande. Et des paramètres qui sont les
objets sur lesquels portent la commande.
Les arguments sont traités comme des options s'ils commencent par - ou comme des
paramètres sinon.
Ne pas oublier qu'UNIX est « case-sensitive ».
Format général : commande [-options [paramètres]] [paramètres]
Une option est en général une lettre, une même lettre ayant un sens souvent différent
pour deux commandes différentes, ou pour une même commande selon qu'elle est
majuscule ou minuscule. C'est ce dernier point qui fait souvent dire aux utilisateurs
qu'UNIX n'est pas convivial.
Plusieurs options peuvent être accolées derrière le -. Si pour une commande une option
au moins est nécessaire le - est optionnel.
Un paramètre peut s'adresser à une option ou à la commande même, sans ambiguïté car
si une option nécessite un paramètre, le paramètre qui suit est celui de l'option.
Il est possible de passer plusieurs commandes sur une même ligne en les séparant par
un « ; ». Si lors du passage d’une commande on veut aller à la ligne suivante pour
continuer la frappe, on termine la première ligne par \ qui inhibe l’action d’exécution de la
touche RETURN.
De façon générale une commande nécessitant un paramètre rentre en mode attente
dans l'entrée standard si le paramètre n'est pas spécifié sur la ligne de commande. C’està-dire
que le prompt va à la ligne suivante et attend que vous entriez les informations
nécessaires ; lorsque vous les avez fournies vous terminez l’entrée par CTRL-D sur une
ligne blanche.
Le résultat des commandes est affiché sur la sortie standard.
S’il n’est pas question dans ce stage de donner un catalogue de commandes, nous en
étudierons quelques unes de base dans ce chapitre. Puis nous verrons dans chaque
chapitre les commandes spécifiques.
Citons tout d’abord 3 commandes qui vont nous permettre de donner des exemples sur la
syntaxe et le fonctionnement des commandes. Nous en détaillerons pour chacune
quelques options, loin de les recouvrir toutes.
- 8 -

ls
ls [-alF] [fichier]
permet d'afficher la liste des fichiers contenu dans un répertoire.
• -a : permet de visualiser également les fichiers cachés
• -l : affiche en format long
• -F : met derrière le nom de fichier un caractère indiquant le type : rien pour un
fichier ordinaire, / pour un répertoire, * pour un exécutable
cat
cat [-n] [fichier]
permet de lister le contenu d'un fichier. Si le paramètre fichier est omis stdin est pris
• -n : permet d’afficher devant chaque ligne le numéro de ligne
grep
grep [-cin] expression [fichier]
permet de rechercher une chaîne de caractères dans des fichiers ou répertoires. Si le
paramètre fichier est omis stdin est pris
• -c : affiche le nombre d'occurrences de l'expression
• -i : ne tient pas compte du case-sensitive
• -n : affiche le numéro des lignes ou apparaît l'occurrence
_______________________________________________________________________
exemple :
$ ls
test test.f titi
$ ls -a
. .. .init test test.f titi
$ ls -l
total 153
-rwxr-xr-x 1 ollivier 147456 Sep 16 10:18 test
-rw-r--r-- 1 ollivier 23 Sep 16 10:18 test.f
-rw-r--r-- 1 ollivier 0 Sep 16 10:19 titi
$ ls -alF
total 157
drwxr-sr-x 2 ollivier 512 Sep 16 10:20 ./
drwxr-sr-x 15 ollivier 2560 Sep 21 16:28 ../
-rw-r--r-- 1 ollivier 0 Sep 16 10:20 .init
-rwxr-xr-x 1 ollivier 147456 Sep 16 10:18 test*
-rw-r--r-- 1 ollivier 23 Sep 16 10:18 test.f
-rw-r--r-- 1 ollivier 0 Sep 16 10:19 titi
$ ls -l titi
-rw-r--r-- 1 ollivier 0 Sep 16 10:19 titi
_______________________________________________________________________
- 9 -

Le shell et les commandes
Le shell, par des commandes internes, offre des mécanismes de simplification pour
passer des commandes. Il permet par exemple :
• de rappeler et modifier une commande antérieure pour re-exécution. Les shells
historiques le permettait à travers des caractères de contrôle ; Ainsi en csh le
mécanisme d'history permettait le rappel de commandes à partir du caractère « ! ». La
commande history liste les commandes précédentes en leur attribuant un numéro
d'ordre. ! suivit d'une chaîne de caractères rappelle la dernière commande
commençant par cette chaîne et ! suivit d'un nombre rappelle la commande ayant ce
numéro dans la liste.
Mais tous les shells récents, et c’est le cas de bash, permettent le rappel de
commande par la flèche haute et la modification par les flèches droites et gauche.
• de créer des synonymes (alias) de commandes, dans un but d’en raccourcir ou
d’en simplifier certaines. Cette possibilité sera traitée dans le chapitre sur
l'environnement de travail.
• de compléter automatiquement des noms de commande en pressant la touche
« TAB ».
• d'utiliser des caractères de substitution dans les paramètres.Les paramètres s'ils
sont des noms de fichiers peuvent être utilisés avec substitution d'une partie du nom
par des métacaractères de remplacement afin de généraliser à un groupe donné de
paramètres l'action de la commande.
Ces métacaractères gérés par le shell sont :
* remplace un groupe de caractères
? remplace un caractère
[...] remplace un caractère par un de ceux de la liste
[.-.] remplace un caractère par un de ceux de l'intervalle
______________________________________________________________________
exemple :
$ ls
erreur liste test.f titi
$ ls t*
test.f titi
$ ls t[a-f]*
test.f
______________________________________________________________________
Redirections d'entrée-sortie
Du fait de la banalisation des entrées-sorties le shell permet de gérer des redirections
de celles-ci. Les notations utilisées sont :
< redirige l’entrée
> redirige la sortie
>& redirige la sortie et l’erreur
>> redirige en mode ajout
- 10 -

Dans les redirections de sortie, si le fichier de redirection n’existe pas il est créé. S’il existe
il est écrasé, sauf mode ajout, à moins qu’une variable (noclobber, voir chapitre
environnement) ne l’interdise.
Le shell permet également que la sortie d'une commande soit l'entrée d'une suivante :
c'est la notion de tube (pipe), noté « | ».
Il suffit simplement de séparer les commandes par le symbole | pour que la sortie de la
première commande soit l’entrée de la seconde. On peut empiler plusieurs « pipe »
successifs (cmd1 | cmd2 | cmd3 | …..). Cette notion permet en une seule ligne d'exécuter
des commandes complexes et puissantes.
exemple :
$ ls
test.f titi
$ ls > liste
$ ls
liste test.f titi
$ cat liste
liste
test.f
titi
$ ls toto
toto not found
$ ls toto >& erreur
$ ls
erreur liste test.f titi
$ cat erreur
toto not found
$ ls tata >>& erreur
$ cat erreur
toto not found
tata not found
$ ls | grep i
liste
titi
$ cat erreur | grep -c toto
1
________________________________________________________________
Le manuel
Comme nous l'avons signalé les commandes UNIX sont très nombreuses et en plus
relativement peut mnémotechniques. Un des attrait d'UNIX est en compensation de
disposer en standard de toute la documentation en ligne.
Par la commande man vous pouvez obtenir à l'écran pour chaque commande le
descriptif complet tel que vous l'auriez sur la documentation papier.
Cette documentation est découpée en section, la section 1 concernant la description
des commandes externes ; il est rarement utile de préciser la section à l'appel de man
mais cela peut arriver dans le cas ou plusieurs items portent le même nom et que l’on
veuille les pages d’un item spécifique.
- 11 -

man fournit, outre une explication et la liste détaillée des options, des exemples, les
fichiers concernés par la commande, des pré requis vis-à-vis de la commande, et surtout
des commandes agissant dans le même domaine ce qui permet de trouver des
commandes non connues initialement.
L’affichage dans man se fait page par page selon le format de la commande more : voir
paragraphe ci-dessous pour les détails.
Quelques autres commandes utiles
more
more [-num] [-ds] [+num] fichier : affiche le fichier passé en argument page par page.
more est une commande interactive qui permet d’avoir le contrôle sur le défilement du
fichier, par une série de caractères de commandes.
• -num : affiche des écrans de num lignes. Par défaut s’adapte à la taille de l’écran.
• -d : permet d’avoir en fin de page le message « Press space to continue, q to
abort »
• -s : concatène en une seule plusieurs lignes blanches consécutives
• +num : démarre l’affichage à la ligne num du fichier
Caractères de commandes dans more :
• space : avance d’une page
• return : avance d’une ligne
• b : revient en arrière d’une page
• h : help de more
• q : termine l’affichage et sort de la commande
• /chaine : se positionne à la première occurrence de la chaine de caractères
spécifiée
• v : lance un éditeur positionné à la ligne d’affichage en cours
• :f : affiche le nom de fichier et le numéro de la ligne en cours
who
who : indique le nom de login, le numéro de terminal, l’heure de connexion et la machine
de provenance, pour tous les utilisateurs connectés sur le système.
users
users : indique le nom de login des utilisateurs connectés sur le système
write
write user [term] : permet d’envoyer un message à l’utilisateur user. Si cet utilisateur est
connecté sur plusieurs sessions, le paramètre term permet de choisir sur quel numéro de
terminal on envoie le message. La commande entre en mode stdin et le message est tapé
ligne à ligne, en terminant par CTRL-D sur une ligne blanche. Un utilisateur peut se
protéger de la réception de message par la commande mesg.
date
date [mmddhhmm] : Renvoie la date du système. En mode superutilisateur permet de
changer la date en passant les informations en paramètre.
- 12 -

exemple :
$ users
belmir belmir caffari caffari combroux delsart distefan dmercier
donini giraud hansen jmeyer lecarpen lecarpen millet muanza muanza
muanza muanza ollivier ollivier pillot rafidiso rmoustab rmoustab
rmoustab rmoustab rmoustab rmoustab rmoustab root royole royole
royole smadja smadja smadja smgascon smgascon smgascon smgascon
smgascon smgascon soubane soubane trocme
$ who | grep ollivier
ollivier pts/26 Apr 22 08:40 (lyopc280.in2p3.fr)
ollivier pts/38 Apr 22 08:46 (lyodhc29.in2p3.fr)
$ write ollivier pts/38
Salut on va boire un café
Je te retrouve en bas
CTRL-D
$ date
Thu Apr 22 08:48:04 CEST 2004
$ date 04220855
date: cannot set date: Operation not permitted
Thu Apr 22 08:50:00 CEST 2004
$
- 13 -

Chapitre 4 : Le système de fichiers
On entend par système de fichiers l'ensemble des fichiers disponibles sur un ordinateur,
qu’ils soient locaux ou non.
L'arborescence
Le système de fichiers UNIX dans son ensemble est un système arborescent en arbre
inverse, c'est-à-dire que la racine est considérée être de plus haut niveau. Une
arborescence est une succession de zones logiques, ou répertoires, de niveau d'autant
plus bas qu'ils sont éloignés de la racine.
Chacun de ces répertoires est un 'tiroir' contenant des fichiers ayant une « certaine »
unité. Chaque répertoire peut servir de base à un nouveau répertoire dit sous-répertoire
par rapport à celui-ci. Créer un répertoire revient à définir le chemin par lequel il peut être
accédé depuis la racine.
Le séparateur entre les répertoires est noté « / » ; / tout seul représente le répertoire
de plus haut niveau (racine).
Un nom de répertoire commençant par / décrit l'accès à ce répertoire depuis la racine et
est dit chemin absolu. Un nom de répertoire ne commençant pas par / est dit relatif par
rapport au répertoire dans lequel on travaille.
Il n'y a pas de distinction de notation entre un répertoire et un fichier ordinaire.
Les fichiers sont étiquetés par le système par un numéro (inode) unique. Un répertoire
n’est qu’un fichier qui contient la correspondance entre inode et le nom logique des
fichiers qui lui sont attachés.
Dans une session un utilisateur est toujours « positionné » sur dans un des répertoire de
l'arborescence, qui est alors appelé le répertoire courant.
Toutes les commandes sont relatives aux fichiers contenus dans ce répertoire courant à
moins qu'il ne soit spécifié un chemin absolu pour les noms de fichiers.
Il est crée un répertoire spécifique pour chaque utilisateur (home directory) qui contiendra
ses propres fichiers et dans lequel il sera positionné par défaut après le login.
Des notations spécifiques repèrent certains répertoires :
Le répertoire courant est noté « . »
Le répertoire père du répertoire courant est noté « .. »
Le home directory est noté « ~ »
La figure suivante montre de façon très schématique les principaux répertoires de
l'arborescence LINUX et un exemple de quelques répertoires utilisateurs :
- 14 -

Le partitionnement
Un même disque peut être partitionné (découpé) en zone physique distinctes (un nombre
donné de cylindres) afin de séparer des parties de l'arborescence ayant des usages
Spécifiques ; trois partitions peuvent par exemple être créées : l'une pour /, une autre pour
le répertoire contenant les utilitaires LINUX (/usr et au-dessous), et une troisième pour les
fichiers utilisateurs (/home et au-dessous). La première contiendra donc tout sauf ce qui
est sous /usr et sous /home. Il n'y a ainsi pas recouvrement au niveau capacité entre ces
parties de l'arborescence, la place réservée à chaque branche étant bien définie et figée.
Les répertoires sont attachés sur les zones disques qui leur on été destinées : on parle de
montage. Si l'on dispose de plusieurs disques une même arborescence peut être répartie
sur ceux-ci. On peut également par NFS (Network File System) avoir une arborescence
étendue de façon transparente sur les disques de plusieurs machines en réseau.
La commande df donne une vue de la façon dont est découpée le système de fichier et
pour chaque partition donne le nombre de kilo-octets restant disponibles.
Commandes concernant le système de fichiers
Lorsque ces commandes utilisent des noms de répertoires en paramètre ils peuvent être
spécifiés soit en absolu soit en relatif.
cd
cd [répertoire] : positionne sur le répertoire en paramètre, qui devient le répertoire courant.
S'il est omis, cd positionne sur le home directory
pwd
pwd : affiche le répertoire courant, en absolu
- 15 -

mkdir
mkdir répertoire : crée le répertoire passé en argument
rmdir
rmdir répertoire : efface le répertoire en argument dans la mesure ou celui-ci est vide de
tout fichier
du
du [-as] [répertoire] : donne le nombre de k-octets occupés par les fichiers d'un répertoire,
ainsi que pour chacun de ses sous-répertoires
• -a donne également la place occupée par chaque fichier
• -s ne donne que le total pour l'ensemble de l'arborescence située sous le répertoire
- 16 -

Chapitre 5 : Les fichiers
Leur nom
Un nom de fichier peut comporter 256 caractères. Il faut exclure les caractères qui ont un
sens pour le shell et seraient donc interprétés ; exclure donc : $ { } [ ] | / \ < > * ? & !
Les noms de fichiers ne comportent ni extension ni numéro de version.
Les fichiers dont le nom commence par « . » sont dits fichiers cachés ou silencieux. Ils ne
sont pas visibles automatiquement par la commande ls mais en le spécifiant par ls -a.
Ce sont en fait par habitude des fichiers d'initialisation lus par des utilitaires et qui n'ont
pas à être visibles systématiquement.
Il existe un certains nombres d'habitudes voire obligation dans les noms de fichiers, tel
que mettre .f à la fin du nom d'une source fortran. Le compilateur fortran n'accepte pas de
traiter un fichier de nom ne terminant pas par .f.
Le mode des fichiers
Le mode d'un fichier est un champ de 10 caractères décomposé en un premier caractère
appelé type du fichier suivi de 9 caractères correspondant au champ de protection
appliqué au fichier.
Le mode d'un fichier est visible par ls en format long (ls -l).
Le type d'un fichier
UNIX traitant de façon identique fichier, répertoire, périphériques, un caractère indique à
quoi correspond un fichier.
• - indique un fichier ordinaire
• d indique que le fichier est un répertoire
• l indique que le fichier est un lien symbolique
• c indique un fichier de type caractère (tel bande magnétique)
• b indique un fichier de type bloc (tel disque)
Le champ de protection d'un fichier
Nous avons vu que l'identification d'un utilisateur reposait sur un UID personnel et un GID
commun à un groupe. La propriété d'un fichier dépend donc de ces deux notions.
Chaque fichier à un propriétaire et un groupe propriétaire. On définit donc une protection à
trois niveaux, vis-à-vis du propriétaire (noté u), du groupe (noté g) et des autres (noté o).
A noter qu'il n'y a pas de protection vis-à-vis de root qui outrepasse tous les droits.
Pour chacun, trois types de droits sur un fichier sont possibles : des droits en lecture (noté
r), en écriture (noté w) et en exécution (noté x).
Lecture pour un répertoire signifie possibilité d'en lister le contenu.
Ecriture pour un fichier ordinaire donne le droit d'effacer; pour un répertoire cela donne le
droit d'y créer des fichiers.
Exécution pour un répertoire signifie possibilité de s'y positionner.
- 17 -

Le champ de protection est donc un champ de 3x3=9 caractères dans l'ordre suivant : rwx
pour u, rwx pour g, rwx pour o. Si un droit est présent la lettre est visible sinon un - figure.
Ainsi rwxr-xr-- signifie droits de lecture, écriture, exécution pour l'utilisateur propriétaire,
lecture et exécution pour les gens du même groupe, lecture pour tous les autres.
On peut également utiliser une notation octale du champ de protection, en considérant
rwx comme une valeur octale à partir de trois bits de valeurs potentielles 4 pour r, 2 pour
w, 1 pour x. Le champ de protection est donc noté comme 3 valeurs octales : par ex. 754
signifie rwxr-xr--
Signalons trois notions peut utilisées mais à connaitre. Il existe 3 bits supplémentaires
positionnables sur le champ de protection :
• Le bit setuid noté s à la place du x dans la partie u : il permet d'avoir les droits du
propriétaire le temps de l'exécution
• Le bit setgid noté s à la place du x dans la partie g : il permet d'avoir les droits du
groupe le temps de l'exécution
• Le sticky bit noté t à la place du x dans la partie o : seul root et le propriétaire
peuvent effacer le fichier même si les autres ont tous les droits sur le répertoire : cas
du répertoire commun /tmp par exemple.
En notation octale il faut rajouter un quatrième chiffre avec pour poids 4 pour le setuid, 2
pour le setgid et 1 pour le sticky bit.
________________________________________________________________
exemple :
$ ls -l
total 157
-rw-r--r-- 1 ollivier 30 Sep 22 10:23 erreur
lrwxrwxrwx 1 ollivier 10 Sep 23 18:18 hello.c -> ../hello.c
-rw-r--r-- 1 ollivier 18 Sep 22 10:07 liste
drwxr-sr-x 2 ollivier 512 Sep 23 18:17 subdir1
-rwxrwxrwx 1 ollivier147456 Sep 23 18:00 test
-rw-r--r-- 1 ollivier 23 Sep 16 10:18 test.f
-rw-r--r-- 1 ollivier 0 Sep 16 10:19 titi
$ ls -l /dev | more
crw-rw-rw- 1 root 18, 65 Apr 29 1991 rst5
crw-rw-rw- 1 root 18, 66 Apr 29 1991 rst6
crw-rw-rw- 1 root 18, 67 Apr 29 1991 rst7
crw-rw-rw- 1 root 18, 8 Apr 29 1991 rst8
crw-rw-rw- 1 root 18, 9 Apr 29 1991 rst9
crw------- 1 root 3, 32 Apr 29 1991 sbus0
crw------- 1 root 3, 33 Apr 29 1991 sbus1
crw------- 1 root 3, 34 Apr 29 1991 sbus2
crw------- 1 root 3, 35 Apr 29 1991 sbus3
brw-r----- 1 root 7, 0 Apr 29 1991 sd0a
brw-r----- 1 root 7, 1 Apr 29 1991 sd0b
brw-r----- 1 root 7, 2 Apr 29 1991 sd0c
--More—
________________________________________________________________
- 18 -

Modification du champ de protection
Cette modification se fait par la commande chmod :
chmod
chmod mode fichier : affecte le mode indiqué au fichier, avec le mode soit en notation
symbolique : (classe d'utilisateur)(opération)(droits) avec :
• classe d'utilisateur : (u g o a), avec a pour all
• opération : (= + -)
• droits : (r w x)
ou le mode en notation octale.
________________________________________________________________
exemple :
$ ls -l titi
-rw-r--r-- 1 ollivier 0 Sep 16 10:19 titi
$ chmod u+x,g+w,o-r titi
$ ls -l titi
-rwxrw---- 1 ollivier 0 Sep 16 10:19 titi
$ chmod a=rw titi
$ ls -l titi
-rw-rw-rw- 1 ollivier 0 Sep 16 10:19 titi
$ chmod 750 titi
$ ls -l titi
-rwxr-x--- 1 ollivier 0 Sep 16 10:19 titi
________________________________________________________________
Protection par défaut
Chaque utilitaire créant des fichiers leur affecte une protection spécifique, en général peut
restrictive. Ainsi l'éditeur vi affecte rw-rw-rw- et les compilateurs rwxrwxrwx. On peut
appliquer à la création un masque sur le champ de protection. Ce masque enlèvera
systématiquement tel ou tel droit sur le fichier.
La notation est de type octale. Ainsi le masque 022 masquera systématiquement w pour g
et o ; les fichiers exécutables résultats de compilateurs seront donc en rwxr-xr-x si un tel
masque est appliqué.
La commande pour définir ce masque est umask :
umask
umask [mask] : définit le masque qui sera appliqué à tout nouveau fichier crée. Si mask
est omis umask renvoie le masque existant.
Attention umask ne protège en rien les fichiers déjà créés avant la définition du masque.
Pour qu’elle soit permanente cette protection par défaut devra être indiquée dans un
fichier de personnalisation de la session (voir plus loin).
________________________________________________________________
- 19 -

exemple :
$ umask
0
$ f77 -o test1 test.f
test.f:
MAIN:
$ umask 077
$ umask
77
$ f77 -o test2 test.f
test.f:
MAIN:
$ ls -l test?
-rwxrwxrwx 1 ollivier 147456 Sep 23 18:31 test1
-rwx------ 1 ollivier 147456 Sep 23 18:31 test2
________________________________________________________________
Les mouvements de fichiers
Les fichiers affectés par les commandes suivantes sont aussi bien des fichiers ordinaires
que des répertoires. Tous les noms de fichiers peuvent comporter des métas caractères
de remplacement fournis par le shell.
cp
cp [-ir] fichier-source fichier-cible : copier un fichier. Le fichier source est laissé intact
• -i : demande confirmation avant d'écraser un fichier cible s'il existe déjà
• -r : permet de copier récursivement tout un répertoire
mv
mv [-i] fichier-source fichier-cible : déplacer un fichier. Revient donc à renommer le fichier
source.
• -i : demande confirmation avant d'écraser un fichier cible s'il existe déjà
rm
rm [-ir] fichier : effacer un fichier
• -i : demande confirmation avant d'effacer le fichier. Il est souvent créé un synonyme
de rm en rm -i de sorte que la demande soit systématique
• -r : permet d'effacer récursivement dans tout un répertoire ; danger !
________________________________________________________________
exemple :
$ ls -l
total 1
drwxr-sr-x 2 ollivier
-rwxr-x--- 1 ollivier
-rw------- 1 ollivier
$ ls subdir1
tata toto
512 Sep 24 09:20 subdir1
0 Sep 16 10:19 titi
0 Sep 24 09:19 toto
- 20 -

$ cp titi subdir1
$ ls subdir1
tata titi toto
$ cp -r subdir1 subdir2
$ ls -l
total 2
drwxr-sr-x 2 ollivier
drwxr-sr-x 2 ollivier
-rwxr-x--- 1 ollivier
-rw------- 1 ollivier
$ ls subdir2
tata titi toto
$ mv subdir2 subdir3
$ ls -l
total 2
drwxr-sr-x 2 ollivier
drwxr-sr-x 2 ollivier
-rwxr-x--- 1 ollivier
512 Sep 24 09:21 subdir1
512 Sep 24 09:21 subdir2
0 Sep 16 10:19 titi
0 Sep 24 09:19 toto
512 Sep 24 09:21 subdir1
512 Sep 24 09:21 subdir3
0 Sep 16 10:19 titi
-rw------- 1 ollivier 0 Sep 24 09:19 toto
$ cp -i toto subdir3
overwrite subdir3/toto? y
$ rm -i toto
rm: remove toto? y
$ ls
subdir1 subdir3 titi
$ rm -ir subdir3
rm: remove subdir3/toto? y
rm: remove subdir3/tata? y
rm: remove subdir3/titi? y
rm: remove subdir3? y
________________________________________________________________
Quelques autres commandes concernant les fichiers
touch
touch fichier : effectuer une mise à jour de la date d'un fichier. Ne modifie pas le contenu.
Si le fichier n'existe pas, crée un fichier vide.
ln
ln [–s] fichier-existant nom-du-lien : crée un fichier de nom nom-du-lien qui est un
pointage vers un fichier réel ; sert à voir en plusieurs points de l’arborescence un fichier
sans le dupliquer.
• -s : crée un lien symbolique. Si le lien est effacé le fichier réel n’est pas affecté.
C’est le mode le plus utilisé.
Recherche de fichiers
Plusieurs utilitaires permettent de rechercher un fichier dans une arborescence UNIX
relativement complexe.
- 21 -

which
which commande : cherche si la commande est présente dans la liste des répertoires
définie par la variable {\tt path}. Cette variable permet à l'utilisateur de maintenir
l'ensemble des répertoires ou un exécutable doit être cherché lorsqu'il est appelé. which
renvoie le chemin absolu du premier répertoire ou la commande est trouvée.
whereis
whereis nom : recherche dans une liste standard de répertoire système tout ce qui se
rapporte à une source, un exécutable, un manuel, de nom indiqué. Renvoie, en absolu,
les répertoires concernés.
locate
locate motclé : renvoie tous les fichiers dont le nom contient la racine motclé
find
find répertoire critères-de-recherche : recherche récursivement à partir du répertoire
spécifié et avec les critères indiqués.
find est une commande très puissante qui permet non seulement de rechercher mais
d'agir sur les objets trouvés.
critères :
• -name fichier : donne le critère de nom de recherche
• -print : affiche le répertoire ou le fichier est trouvé
• -user utilisateur : donne un critère d'appartenance pour la recherche
• -type type : donne un critère de type de fichier
• -exec action : effectue l'action indiquée sur les fichiers trouvés
________________________________________________________________
exemple :
$ cd
/home/lyosu1/ollivier
$ find . -name titi -print
./stage/subdir1/titi
./stage/titi
$ find . -name titi -exec ls -l {} \;
-rwx------ 1 ollivier 0 Sep 24 09:21 ./stage/subdir1/titi
-rwxr-x--- 1 ollivier 0 Sep 16 10:19 ./stage/titi
$ find . -name titi -exec rm {} \;
$ find . -name titi –print
$
________________________________________________________________
L’impression de fichiers
Il existe deux séries de commandes pour l'impression de fichiers :
Soit l'impression type BSD : lpr pour lancer l'impression, lpq pour interroger, lprm pour
annuler l'impression
Soit l'impression type SYSTEM V: lp, lpstat, cancel
- 22 -

Sous LINUX utilisez l’impression BSD. Cependant nous rappelerons les 2 jeux de
commandes car le second est encore présent sur pas mal de systèmes UNIX.
Signalons que les imprimantes ont un nom défini par l'administrateur système. Vous
devez connaitre ce nom pour lancer une impression.
Pour la partie BSD, les imprimantes sont définies dans un fichier /etc/printcap que vous
pouvez lister. D'autre part l'outil lpc permet de gèrer les imprimantes. lpc est un outil
interactif qui renvoie le prompt lpc> et comporte un help intégré. Certaines taches sont
privilégiées mais tout utilisateur peut notamment voir le nom des imprimantes et l'état des
queues d'impression.
Pour SYS V, la commande lpstat sans arguments vous donne l'état de l'ensemble des
queues d'impression et, de fait, leurs noms.
Commandes BSD :
lpr
lpr [-h -#n -Pimprimante] [fichier] : lance une impression. Si fichier n'est pas spécifié, sdtin
est pris; par exemple derrière un |
• -P imprimante : définit le choix de l'imprimante. Si omis l'imprimante définie dans
une variable PRINTER est utilisée ou en dernier lieu l'imprimante appelée lp
• -#n : imprimante n copies
• -h : suppression de la banière
lpq
lpq [-Pimprimante] [user ou jobnumber] : renvoie l'état de la queue d'impression pour
l'imprimante spécifiée (ou PRINTER ou lp). Permet de voir ou en est une impression et
également de connaitre le numéro unique de job qui a été attribué à l'impression par lpr.
On peut restreindre l'interrogation aux impressions d'un utilisateur ou à une impression
particulière si son jobnumber est déjà connu.
lprm
lprm [-Pimprimante] [user ou jobnumber] : tue un job dans la queue d'impression de
l'imprimante spécifiée (ou PRINTER ou lp). lprm teste que l'impression appartient bien à
l'utilisateur qui passe la commande. Si user est spécifié toutes les impressions de cet
utilisateur sont tuées. Si ni jobnumber ni user ne sont spécifiés, toute la queue
d'impression est vidée.
Commandes SYS V :
lp
lp [-w -ttitre -nnombre -dimprimante] [fichier] : lance une impression. Si fichier n'est pas
spécifié, sdtin est pris.
• -d imprimante : définit le choix de l'imprimante. Si omis l'imprimante définie dans
une variable LPDEST est utilisée ou en dernier lieu l'imprimante dite 'default printer'
• -n nombre : imprime nombre copies
• -t titre : La banière porte le titre précisé
• -w : envoie un message quand l'impression est finie
lpstat
lpstat [-d -s -uutilisateur-pimprimante] } : renvoie l'état de l'ensemble des queues
d'impression ou de l'imprimante spécifiée par -p.
• -d : donne l'imprimante par défaut si elle existe
• -s : donne un résumé d'informations sur les imprimantes
• -u utilisateur : limite l'interrogation aux requetes de l'utilisateur précisé
- 23 -

cancel
cancel [-a] [jobnumber ou imprimante] : tue le job spécifié ou le job dans la
queue d'impression de l'imprimante spécifiée. cancel teste que l'impression appartient
bien à l'utilisateur qui passe la commande.
• -a : toutes les impressions appartenant à l'utilisateur sont tuées.
- 24 -

Chapitre 6 : Interaction de l’utilisateur et du système
Une session Unix
Débuter une session
Il existe diverses possibilités pour se connecter à un système Unix. Tout dépend du
matériel dont on dispose et de sa connectivité réseau.
Dans tous les cas, vous passerez par un mécanisme d’identification et d’authentification,
en d’autres termes vous devrez fournir un couple d’informations (nom d’utilisateur, mot
de passe) pour accéder aux ressources logicielles disponibles sur le système.
Le mécanisme d’authentification (qu’il soit local à la machine ou commun à un ensemble
de machines) procède à la validation de votre accès pour le couple (nom d’utilisateur, mot
de passe). Si l’un des 2 éléments du couple n’est pas valide, vous obtiendrez un message
comme :
Login incorrect
Une fois l’authentification validée, le système exécute un ensemble de procédures
appelées profiles. Ces procédures s’exécutent à divers niveaux et dans l’ordre suivant :
o système. Procédure dépendant du système d’exploitation qui est systématiquement
exécutée quelque soit l’environnement applicatif disponible. Elle va, par exemple, définir
le langage national courant;
o
o
fournies par les administrateurs du système;
utilisateur. L’utilisateur peut personnaliser son environnement
Ensuite le système donne la main à l’utilisateur et affiche la première invite. Dès lors,
vous êtes à même d’interagir avec le système Unix cible. Cette invite est représentée par
une chaîne de 1 ou plusieurs caractères précédant le curseur sur la ligne de commande
courante.
Note : Convention d’écriture retenue dans ce document. Pour simplifier l’écriture,
l’invite choisie est l’invite par défaut des shells de la famille « sh » cad. le caractère $ .
Connexion sur un poste distant
Pour ce faire, parmi les protocoles possibles on trouve rsh, telnet ou ssh (qu’on préfèrera
car il offre un niveau de sécurité bien supérieur aux autres). On va pouvoir à partir un
- 25 -

poste local disposant d’une connectivité réseau d’établir une connexion avec une machine
distante. Par exemple :
__________________________________________________________________
$ ssh lyopc61.in2p3.fr
__________________________________________________________________
Les messages d’établissement de la connexion apparaissent suivis d’une mire de login;
on procède ensuite comme précédemment en fournissant son identification et
authentification.
Caractéristiques des terminaux
Selon le type de terminal (ou plutôt d’émulation de terminal) utilisé, certaines applications
peuvent présenter des comportement inhabituels. La plupart du temps positionner la
variable d’environnement TERM comme vt100 (la notion de variable d’environnement
sera développée ultérieurement dans ce chapitre), offre un mode de fonctionnement
confortable.
Cependant suivant le constructeur, il est parfois plus judicieux d’affecter à cette variable,
une valeur de terminal propriétaire (hpterm par exemple pour une machine HP).
D’autre part, en cas de connexion sur un site distant, un protocole comme telnet se
présente avec les attributs du terminal source; or si celui-ci n’est pas reconnu, le système
cible va considérer qu’il s’agit d’un terminal générique (appelé parfois dumb) lequel se
comportera rarement de façon satisfaisante.
- 26 -

Le shell et Unix
Unix : un système en couches
Le système Unix est un système organisé en couches qui communiquent entre elles et qui
ont chacune un rôle spécifique.
X window
Vous
Shell
Applications Commandes
Noyau
Matériel
La couche la plus basse est le noyau qui interagit directement avec le matériel et le gère.
Le support de nouveaux dispositifs matériels imposera généralement une génération du
dit noyau.
Les applications ou les commandes interagissent avec le noyau plutôt qu’avec le matériel.
Mais la mise en exécution de ces commandes résulte d’une action (ligne de commande)
saisie par l’utilisateur après interprétation de sa syntaxe par le shell.
C’est pourquoi, on trouve au dessus des applications et des commandes, l’interpréteur de
commandes (ou shell) en charge de l’interaction entre l’utilisateur et Unix.
Enfin dans le cas d’une station de travail ou d’un terminal X, la couche en charge du
système de fenétrage vient s’intercaler entre vous et le shell ou directement entre vous et
les applications.
Lorsque vous vous connectez à un système Unix via un terminal (login console en mode
non graphique) ou une émulation terminal (telnet), vous vous retrouvez sous le contrôle
d’un programme appelé shell de connexion.
Un shell est à la fois un programme exécutable (et en exécution!) et un interpréteur de
commandes qui lit chaque commande entrée au clavier et les transmet au noyau. Le
résultat des commandes suit le chemin inverse et sera généralement affiché à l’écran.
L’exécution du shell est lancée par un mécanisme complexe du type "fork/exec". Le shell
courant reste le shell de connexion tant qu’on n’exécute pas un autre shell sur la ligne de

commande.
Aujourd’hui, malgré l’existence d’interfaces graphiques de haut niveau, le shell reste la
principale interface entre l’utilisateur et le système Unix. La plupart des systèmes Unix
supportent plusieurs shells. Les shells les plus couramment employés sont:
le ✣✍▲❈❅●● ❏◆ ❃▲❈
le ✢❏◆❒■❅✍▲❈❅●● ❏◆ ▲❈
le ✫❏❒■✍▲❈❅●● ❏◆ ❋▲❈
le ✴✣✍▲❈❅●● ❏◆ ▼❃▲❈
Le ✢❏◆❒■❅✍✡❇❁❉■✍▲❈❅●● ❏◆ ❂❁▲❈
Le sh est disponible sur tous les systèmes et est l’ancêtre du ksh avec lequel il est
compatible arrière. Le tcsh et le bash se différencient du csh et du ksh par leur mécanisme
d’historique. Cependant contrairement au tcsh, le bash utilise des fichiers de configuration
différents du shell dont il est issu (sh) ainsi que quelques extensions de syntaxe.
Le fait que le tcsh et le zsh proviennent du domaine public et qu’ils soient supportés sur de
nombreuses plateformes matérielles, est à l’origine de leur succès.
Chaque shell dispose d’une grammaire et d’une sémantique qui lui est propre faisant de
lui un véritable langage de programmation. Aussi sur la ligne de commande, peut-on
saisir des constructions syntaxiques de ce shell qui seront immédiatement
interprétées dans le contexte du shell courant.
D’autres fonctionnalités existent dans les shells (pas dans tous, et pas mises en
oeuvre de la même manière); il s’agit :
• du mécanisme d’historique qui permet de gérer la liste des commandes
récemment exécutées;
• du mécanisme d’alias qui permet de personnaliser son environnement de
travail;
• et du mécanisme de contrôle des programmes en exécution.
Les caractères
La ligne de commande étant le mode privilégié de communication entre l’utilisateur et
Unix, il convient de préciser l’utilisation des caractères qui la constituent. Parmi la
totalité des caractères disponibles sur votre clavier, un certain nombre sont
interprétés par le shell avant que toute autre action n’ait lieu : ces sont les
caractères spéciaux. On distingue parmi ces caractères, deux catégories :
• les caractères génériques généralement utilisés pour constituer les noms de

fichiers ou de répertoires
• les caractères spéciaux
Les caractères génériques
* remplace n’importe quelle chaîne de caractères de même qu’une chaîne vide
? remplace un caractère unique quelconque
[] les crochets encadrent un jeu de caractères et chacun d’entre eux peut correspondre
à un caractère unique pour la position courante.
[bx] correspond aux caractères b ou x.
- utilisé au sein de [] correspond à une gamme de caractères. [b-x]
correspondant à un caractère compris entre b et x. On notera que gammes de
caractères, caractères individuels peuvent être spécifiés dans un même couple
de crochets. Par exemple [a-z0-9+-] correspond aux caractères + et - associés
aux minuscules et aux caractères numériques.
~ la tilde est interprétée comme le répertoire "home".
A titre d’exemples:
___________________________________________________________________
$ ls fi*
affiche la liste des fichiers dont le nom commence par fi
$ ls ?xy*
affiche tous les fichiers dont le 2ième et 3ième caractères sont xy
$ ls [ab]cd[h-k]
affiche tous les fichiers dont le nom commence par a ou b, suivi de la chaîne de
caractère cd et terminés par un caractère compris entre h et k
$ ls ~/.*.?
affiche tous les fichiers dans votre répertoire "home" dont le nom commence par un
point, disposant d’une extension d’un seul caractère.
______________________________________________________________
Les caractères spéciaux
Parmi les caractères qui sont sujets à une interprétation particulière par le shell, on
trouve:
\ est le caractère spécial qui permet de faire perdre sa signification à un caractère
spécial lorsqu’il le précède. Dans un script shell, il pourra être utilisé en tant que
caractère de continuation de ligne.
les symboles de redirection d’entrée/sortie.

$ précède le nom d’une variable
# ce qui le suit est traité comme un commentaire
’ ’ au sein des simples quotes tous les caractères spéciaux perdent leur signification
excepté ‘ (quote)
" " au sein des doubles quotes tous les caractères spéciaux perdent leur signification
à l’exception de \ $ " ’
() les commandes placées entre parenthèses sont exécutées dans un sous shell
du shell courant
‘ ‘ au sein d’anti-quotes une commande y est substituée par son résultat.
Exemples :
___________________________________________________________________
$ ls monprg.\*
monprg.*
* précédé d’un antislash perd son caractère générique.
$ echo "Mon répertoire home est $PATH"
Mon répertoire home est /home/tartempion
Entre double côtes $ est toujours interprété
$ echo \$PATH est identique à ’$PATH’
$PATH est identique à $PATH
Ici $PATH n’est pas interprété dans le premier cas à cause de l’antislash, dans le
second car il apparaît entre simples côtes.
___________________________________________________________________
Les redirections
Par défaut, Unix suit un certain nombre de conventions concernant l’endroit où un
programme lit ses données, écrit ses résultats et envoie ses erreurs. Ces entités sont
appelées :
• entrée standard ou stdin
• sortie standard ou stdout
• erreur standard ou stderr.
Par défaut, l’entrée standard est connectée au clavier, tandis que la sortie et l’erreur
standard sont associées au terminal. Il est cependant aisé de changer leur valeur; en

terminologie Unix ceci s’appelle la redirection.
Dans le ksh ou bash, on associe les descripteurs de fichiers 0, 1 et 2 à
respectivement stdin, stdout et stderr.
Les redirections vont s’effectuer sur la ligne de commande grâce à des combinaisons
de ces descripteurs et des caractères > , < et &.
Une commande qui requiert une entrée clavier pourra utiliser un fichier en guise
d’entrée standard ceci grâce au caractère < . Par exemple :
___________________________________________________________________
$ mail machin < document
___________________________________________________________________
Le résultat d’une commande qui normalement s’affiche sur le terminal, peut être
redirigé dans un fichier grâce au caractère > ou 1> :
___________________________________________________________________
$ ls >fichier-resultat
ou
$ ls 1>fichier-resultat
___________________________________________________________________
En doublant le caractère >, la sortie sera concaténée au fichier si ce fichier existe
déjà :
___________________________________________________________________
$ df >>fichier-resultat
___________________________________________________________________
Pour rediriger, l’erreur standard on utilise 2>
___________________________________________________________________
$ grep sed /etc/* 2>fichier-erreurs
___________________________________________________________________
On pourra également doubler ces chevrons, si l’on souhaite obtenir la concaténation
du résultat à un fichier existant.
L’environnement
L’utilisateur dispose dès son premier accès au système, d’un environnement de
travail. Cet environnement s’appuie sur l’utilisation de variables et d’alias.
On pourra affecter une valeur à ces variables dans les fichiers d’initialisation
dépendant du shell de connexion mais également sur la ligne de commande du shell.
La portée des variables dépend de leur nature (globales ou locales).
Quand aux alias, il s’agit d’un moyen d’abréger des commandes ou de leur définir

des synonymes.
Concept de variable
Les variables du shell ont un nom auquel on associe une valeur. Le nom est
constitué d’une chaine de caractères alpha-numérique. La déclaration se fait comme
suit :
___________________________________________________________________
$ nom_de_var=valeur
___________________________________________________________________
Un variable ainsi créée sera une variable locale, sa valeur n’est accessible que dans
le shell courant.
La suppression d’une variable se fait par :
___________________________________________________________________
$ unset nom_de_var
___________________________________________________________________
Pour accéder à la valeur d’une variable consiste à la faire précéder son nom par le
caractère $ :
___________________________________________________________________
$ aa=10
$ echo $aa
10
_________________________________________________________________________________
Si une variable n’a pas été définie, le shell retournera une ligne blanche en guise de
valeur.
Pour obtenir la liste des variables définies, utiliser la commande set :
_____________________________________________________________________
$ set
LOGNAME=larrieu
MAIL=/usr/spool/mail/larrieu
MAILCHECK=600
MAILMSG=[YOU HAVE NEW MAIL]
MANPATH=/usr/man:/usr/local/man:/home/larrieu/man
__________________________________________________________________________________
Portée des variables
La portée des variables dépend de leur nature. Elles peuvent être :
• Locales à l’application qui les a créées. Une variable est créée par défaut comme
variable locale
• Globales c’est à dire transmises à tout sous processus du processus courant. On
parle alors de variable d’environnement.

Les variables internes
Ces variables sont prédéfinies dans le shell en fonction de critères communs à l’ensemble
des utilisateurs. Comme précédemment pour accéder à la valeur de ces variables, il
faudra les préfixer du caractère $. Nous ne donnerons pas ici la liste complète de ces
variables mais voici quelques unes des plus couramment utilisées.
Les variables mono-caractère
? contient le code de retour de la dernière commande. Exemple :
__________________
$ vo toto
bash: vo: not found.
$ echo $?
1
___________________
# nombre décimal contenant le nombre de paramètres d’un script shell.
Les variables ayant à trait aux répertoires :
PWD
OLDPWD
HOME
Les variables d’édition
COLUMNS
LINE
EDITOR
Les variables de chemin
contient le répertoire courant
l’ancien répertoire courant (avant le dernière commande cd émise)
le répertoire home
nombre de colonnes du terminal utilisé
nombre de lignes
le chemin d’accès à votre éditeur préféré
PATH
MANPATH
le chemin de recherche des commandes
le chemin de recherche des pages de manuel
Et les autres

PS1 définit la chaine de caractères d’invite du shell. (par défaut le caractère $)
PS2
TERM
définit l’invite secondaire. Lorsqu’une commande n’est pas terminée sur une
ligne, le shell affiche un invite secondaire de continuation.
définit le type de terminal (p.e. vt100)

Les variables d’environnement
Ces variables sont appelées ainsi car elles caractérisent des paramètres de
l’environnement sous lequel une commande ou un programme s’exécute. Elles seront
transmise à tout type de sous processus du shell courant.
Pour les rendre accessibles, elles devront être définies comme une variable normale et
exportées. Ceci se fait par la commande export et c’est le seul moyen de transmettre des
variables à un sous shell :
__________________________________________________________________
$ envvar=abcd
$ export envvar
__________________________________________________________________
Ce mécanisme d’exportation est commun aux shells sh, ksh et bash. Cependant la commande
export du ksh et du bash accepte la forme suivante (définition et exportation):
___________________________________________________________________
$ export envvar=abcd
___________________________________________________________________
La commande env permet d’accéder à la définition des variables d’environnement:
___________________________________________________________________
$ env
TERM=aixterm
SHELL=/usr/local/bin/tcsh
HOME=/home/l/larrieu
PATH=/home/g/gnats/bin:/usr/local/bin:/usr/local/etc:/bin:/usr/ucb
:/usr/ bin/X11:/usr/local/oracle/bin:/usr/afs/bin:.
HARDWARE=RS6000/390
USER=larrieu
VENDOR=IBM
___________________________________________________________________
La valeur affectée à une variable d’environnement est aisément modifiable, cependant il
est vivement déconseillé de ne pas modifier certaines variables dites "système" où une
mauvaise affectation risquerait de perturber notablement votre session.
Il convient de s’attarder sur le contenu d’une variable d’environnement qui est la variable
PATH. En effet cette variable conditionne l’exécution des commandes dans votre
environnement. Elle a pour valeur un ensemble de chemins séparés par le caractère : ( 2
points).
___________________________________________________________________
$ echo $PATH
/

opt/ssh/bin:/usr/sbin:/usr/bin/X11:/cern/pro/bin:/usr/local/bin:/h
ome/l/larrieu:.
___________________________________________________________________
Avant d’être mise en exécution, la commande que vous entrez sur la ligne de commande
sera recherchée dans les répertoires spécifiés dans la variable PATH dans l’ordre de
lecture. La première occurrence sera mise en exécution.
Dans l’exemple précédent, la recherche s’effectue à partir de /opt/ssh/bin éventuellement
jusqu’au répertoire courant (noté .)
En cas d’échec dans la recherche d’une commande, vous obtiendrez quelque chose
comme :
___________________________________________________________________
$ tagada
tagada: Command not found.
___________________________________________________________________
Nous vous conseillons donc vivement de ne pas créer d’exécutables portant le
même nom que des procédures système. Si malgré tout, vous le souhaitez, évitez
de les déposer dans des répertoires qui seront accédés, via votre variable PATH,
avant les répertoires système (dans l’exemple précédent, éviter d’en créer dans
/home/l/larrieu ou .).
Les alias
Il s’agit d’un moyen d’abréger des commandes ou de leur définir des synonymes. La
définition d’alias peut être faite dans les fichiers de configuration (.kshrc) ou directement
sur la ligne de commande. La syntaxe est la suivante :
alias nouveau_nom=’definition’
Par exemple :
___________________________________________________________________
$ alias rm=’rm -i’
$ alias qui=’who | sort’
___________________________________________________________________
rm est un alias de la commande rm avec l’option -i. qui est une nouvelle commande qui
affiche la liste triée des utilisateurs connectés.
___________________________________________________________________
$ alias
false=let 0
functions=typeset -f
history=fc -l
integer=typeset -i

ls=/bin/ls
rm=/bin/rm
stop=kill -STOP
rm=/bin/rm -i
qui=who | sort
___________________________________________________________________
Il est toujours possible d’éviter occasionnellement d’utiliser la définition d’un alias. Pour ce
faire, il faut sur la ligne de commande faire précéder la commande par le caractère \
(antislash).
___________________________________________________________________
$ \rm toto
___________________________________________________________________
exécutera la commande rm de base sans la moindre option.
La suppression permanente d’un alias se fait par la commande unalias :
___________________________________________________________________
$ unalias qui
$ qui
bash: qui: not found.
___________________________________________________________________
Les fichiers de configuration
Ces fichiers contiennent un ensemble d’instructions qui respectent la syntaxe propre au
shell de connexion et sont modifiables par l’utilisateur. Tels qu’ils sont livrés initialement,
ces fichiers établissent un environnement de base minimum.
Il est souhaitable de ne pas supprimer les instructions existantes mais plutôt d’y ajouter
votre personnalisation.
Les fichiers de configuration pour le bash , s’appellent :
.bashrc
exécute à chaque démarrage du shell
.bash_profile exécuté une fois lors de votre connexion. L’exécution du .
bash_profile est précédée de celle du .bashrc
.bash_logout
exécuté une fois lors de la fermeture de connexion
En bash, c’est essentiellement dans .bashrc que vous serez amené à effectuer vos
modifications. En cours de session pour que ces modifications s’activent immédiatement,
il vous faudra faire :
_______________________________
$ . ~/.bashrc
___________________________________

Historique et rappel des commandes
L’ historique du shell
Les commandes passées sur la ligne de commande sont stockées dans un fichier
d’historique maintenu par le shell et qui porte par défaut le nom de .sh_history. Ce fichier
réside dans le répertoire home de l’utilisateur et par défaut contient les 128 dernières
commandes passées.
Les variables d’environnement HISTFILE et HISTSIZE permettent de modifier ces défauts
et doivent être définies dans le fichier .profile.
HISTFILE=~/.historique
HISTSIZE=50
Dans cette exemple, le fichier d’historique s’appellera .historique et sera limité à 50 lignes.
Edition de commandes
Le fichier d’historique ne doit pas être manipulé directement par un éditeur Unix, mais
c’est cependant grâce à des sous commandes d’un éditeur que pourront être rappelées et
modifiées les commandes précédemment émises sur la ligne de commandes.
En bash, un mode de rappel de commandes est défini par défaut. Il suffit d’utiliser les
touches flèches de votre clavier pour vous déplacer dans la pile des commandes déjà
passées.
Compléter les noms de fichiers
Le bash offre la possibilité de compléter sur la ligne de commande, le début du nom d’un
fichier. Cette possibilité existe également dans d’autres shells.
Le principe consiste à taper les premiers caractères d’un nom de fichier suivi d’une
combinaison de touches clavier propres à chaque mode. Le shell complètera alors le nom
du fichier s’il n’y a pas d’ambiguité ou une partie du nom s’il y a plusieurs choix
On tape une partie du nom suivi de la touche de tabulation (taper 2 fois consécutives sur
la touche fonctionne également). Supposons qu’il existe des fichiers appelés nomde-fichier,
fichier123 et fichier223 alors :
_______________________________________________________________________
$ ls nom
complètera la ligne de commande à « $ ls nom-de-fichier. »
Si le nom complété est celui d’un répertoire, un caractère / sera ajouté à la fin du nom,
ceci afin de pouvoir éventuellement compléter le nom d’un fichier de ce répertoire. Tandis

que
_______________________________________________________________________
$ ls fi
complètera la ligne à « $ ls fichier » car il y a ambiguïté sur le dernier caractère (1 ou 2)
_______________________________________________________________________
Pour afficher la liste des fichiers candidats au complément faire :
_______________________________________________________________________
$ ls fichier
fichier123
fichier223
_______________________________________________________________________
On complète ensuite à la main ou partiellement pour lever l’ambiguïté suivi d’un nouveau
:
_______________________________________________________________________
$ ls fichier1 sera alors complété à « $ ls fichier123 »

Chapitre 7 : Présentation du concept X11
Historique
Le besoin de faire cohabiter sur un même écran physique en plusieurs zones, chaque
zone (ou fenêtre) étant associée à une tâche (ou application) s’est fait sentir au début des
années des années 80. Il fallait trouver un moyen de garantir la cohérence de chaque
zone et ce fut le début de l’aventure X11 :
1983: Projet Athéna (MIT), Kerberos, AFS et X
1985: X10 (1ère version publique), 1987: X11R1
Il en ressortira le système X Window : un système distribué où une application peut
s’exécuter sur une machine et s’afficher sur une autre. X Window est une système de
multi-fenêtrage garantissant transparence réseau, hétérogénéité et portabilité.
C’est un modèle client/serveur où il y a séparation du traitement de l’algorithme
applicatif et de la gestion des interactions utilisateur sur l’écran, clavier, souris.
Fonctionnement de X
Sur chaque machine dotée d’une chaîne graphique (écran bitmap, clavier, souris),
l’environnement X se traduit par l’occurrence d’un processus serveur X (Xserver).
Les applications qui ont des besoins d’affichage (les clients ou Xclients) vont
interagir avec le processus serveur.
Dans un cadre plus général, Xclient et Xserver sont 2 processus indépendants
pouvant tourner sur une même machine ou sur 2 machines différentes.
Une voie de communication est nécessaire entre client et serveur : c’est le
protocole X11 qui permet ce dialogue. Sur un poste autonome, c’est le mécanisme
d’IPC (InterProcessCommunication) qui assure ce rôle. Dans le cas de machines en
réseau, le protocole sous-jacent est TCP/IP.

client
Xlib
Serveur
TCP/IP
Interaction client / serveur
Préalablement à l’établissement de la communication client/serveur, il faut
positionner la variable d’environnement DISPLAY. Cette variable définit sur quelle
chaîne graphique seront affichés les clients X. Par exemple :
$ export DISPLAY=lyofor05 :0
Une fois la communication établie, 4 catégories d’informations transitent entre
client et serveur:
o
o
o
o
Requêtes: client --> serveur. Créer une fenêtre, tracer une trait, etc...
Réponses: serveur --> client. Taille d’écran, couleur, etc...
Evènements: serveur --> client. Entrée clavier, mouvement souris
Erreurs: serveur --> client. Si problème...
Quelques clients X
Voici quelques clients X standards qui sont généralement installés dans le répertoire
/usr/bin/X11 :
mwm, twm
xterm
xclock
xv
xlsclients
xlsfonts
gestionnaires de fenêtres
émulation de terminal passif
une horloge
visualisateur d’images
affiche une liste des clients actif sur le serveur X
liste les polices de caractères connues par le serveur X

Gestionnaires de fenêtres
Les Gestionnaires de fenêtres ou "Window Managers" sont des applications qui
offrent une ergonomie supplémentaire à l’utilisateur (habillage de fenêtre, gestion
de menus déroulants, tableaux de bord, etc…).
Par exemple, /usr/bin/X11/fvwm2, /usr/bin/X11/mwm font partie des plus répandus.
Ce sont des clients X qui habillent avec de nouvelles fenêtres, les fenêtres des autres
clients afin de permettre une manipulation de celles-ci à la souris.
Fenêtre client
Fenêtre "root"
mise en icône
déplacement
changement de taille
Le chapitre 13 traitera plus en détail de ce sujet
Le graphisme sous X
X11 gère un graphisme en 2 dimensions dans le système de coordonnées de la
fenêtre racine (rootWindow)

X
Y
Concernant le gestion des dessins:
le serveur ne redessine pas le contenu des fenêtres
c’est au client de le faire s’il le souhaite
X11 contient un mécanisme qui permet d’écrire des applications telles que les
options (couleur, fontes, etc...) puissent être données à l’exécution. On parle alors
de ressource X. Une ressource X est une option re-configurable.
Les ressources
Les applications vont chercher les ressources :
o sur la ligne de commande: xclock -hands red
o dans le fichier .Xdefaults de l’utilisateur
o dans la propriété RESOURCE_MANAGER de la fenêtre root
o dans /usr/lib/X11/app-defaults
o codées dans l’application même
La forme générale d’une ressource est :
app.nom.sous-nom.attribut: valeur
mais on rencontre le plus souvent une écriture du type :

app*nom*attribut: valeur
où valeur est un booléen, un numérique, une chaine de caractères
La difficulté de l’exercice vient du fait qu’il faut connaître la hiérarchie des objets. Par
exemple : xterm.vt100.scrollBar: false .
Alors qu’en utilisant le caractère * , on désigne les attributs d’un objet quelque soit la place
de l’objet dans la hierarchie : xterm*scrollBar: true

Chapitre 8 : Commandes réseau
Rappel IP (Internet Protocol)
Les machines (ordinateurs, imprimantes, routeurs …) communiquent entre elles sur
Internet grâce au protocole TCP/IP (Transmission Control Protocol/Internet Protocol).
La communication se fait par l’acheminement de paquets de données.
Lorsqu’un paquet transite sur Internet, les routeurs grâce à des tables de routage,
aiguillent le paquet vers le réseau de destination. Puis la passerelle de ce réseau local
l’envoie vers la machine de destination.
La passerelle est une machine qui sert de point d’accès à l’extérieur du réseau local.
Chaque machine a une adresse IP qui s’écrit sous la forme de 4 nombres xxx.xxx.xxx.xxx
(xxx est un entier pouvant aller de 0 à 255).
ex. : 193.54.12.213
Il ne peut pas avoir 2 machines ayant la même adresse sur le même réseau.
On distingue 2 parties dans l’adresse IP :
Une partie des nombres à gauche désigne le réseau.
Les nombres de droite désignent les ordinateurs de ce réseau.
Plus la partie de nombres pour le réseau est petite, plus celui-ci peut contenir
de machines et inversement. C’est la notion de classe IP à laquelle appartient
la machine.
Les adresses IP xxx.xxx.xxx.xxx sont réparties en classes :
- Classe A : Le premier nombre xxx. représente le réseau (xxx de 1 à 126)
Un réseau de classe A peut contenir 16777214 ordinateurs
- Classe B : Les 2 premiers nombres xxx.xxx. représentent le réseau (xxx.xxx de 128.0 à
191.255)
Une classe B peut contenir 65534 ordinateurs
- Classe C : Les 3 premiers nombres xxx.xxx.xxx. représentent le réseau (xxx.xxx.xxx de
192.0.0 à 223.255.255)
Une classe C peut contenir 254 ordinateurs.
Remarque : dans un réseau, il y a 2 adresses réservées : l’adresse du réseau et celle de
diffusion générale (broadcast).
Remarque : l’adresse 127.0.0.1 est appelée adresse de boucle locale car elle désigne la
machine locale.

Remarque : il peut avoir un serveur DHCP (Dynamic Host Configuration Protocol) qui
alloue de façon dynamique une adresse IP à une machine du réseau local.
Notion de masque : il se présente sous la forme de 4 chiffres comme une adresse IP. Le
masque permet de connaître le réseau associé à une adresse IP et permet la définition de
sous-réseau.
Exemple : un masque pour un réseau de classe C s’écrit : 255.255.255.0
Un nom est en général associé à l’adresse IP de la machine.
Ce nom est composé de plusieurs parties séparées par un « . » :
La 1 ère partie (partie gauche) est le nom de la machine
Les autres parties restantes représentent le domaine auquel appartient la machine
exemple : lyonas2.in2p3.fr
lyonas2 = nom de la machine, in2p3.fr = domaine
Les serveurs DNS (Domain Name Service) permettent la résolution de nom de machines,
c’est à dire obtenir l’adresse IP à partir du nom.
Prise de session à distance
Ces sessions sont basées sur le modèle client-serveur. Le client envoie des ordres et le
serveur attend des requêtes pour effectuer les actions.
Coté serveur, sous linux, ce service est fourni par un démon qui est un processus tournant
en arrière-plan. Ces démons sont en attente et à l’écoute d’une requête.
Par exemple, le démon FTP s’appelle ftpd.
TELNET
Telnet permet une connexion sur une machine distante via la ligne de commande (depuis
un poste client).
Tout ce qui est tapé au clavier est envoyé à travers le réseau à l’interpréteur de
commande (shell) de la machine distante.
Telnet véhicule les données en clair (de manière non chiffrée) sur le réseau,
même ce qui ne se voit pas a l’écran (par exemple, les mots de passe).
syntaxe : telnet nom_machine
________________________________________________________________
exemple :
lyopcs1 17:14:16 0 /root $ telnet lyopcs9.in2p3.fr
Trying 134.158.138.13...
Connected to lyopcs9.in2p3.fr.

Escape character is '^]'.
Red Hat Linux release 7.3 (Valhalla)
Kernel 2.4.20-20.7smp on an i686
login: rafidiso
Password:
Last login: Mon Mar 22 09:36:00 from lyopc213.in2p3.fr
$ hostname
lyopcs9.in2p3.fr
$
$ ls -l
total 43
-rw-r--r-- 1 rafidiso infor 48640 Feb 16 09:50 courrier1.doc
drwxr-xr-x 2 rafidiso infor 4096 Dec 30 1997 bin/
-rwxr-xr-x 1 rafidiso infor 1499 Dec 30 1997 #.cshrc.dist*
-rw------- 1 rafidiso infor 419 Mar 22 10:08 dead.letter
-rw-r--r-- 1 rafidiso infor 8720 Feb 16 12:37 DEV-15332.pdf
-rw-r--r-- 1 rafidiso infor 49434 Feb 17 11:41 Diapositive1.JPG
-rw-r--r-- 1 rafidiso infor 10515 Jan 7 10:49 difop.pdf
-rw-r--r-- 1 rafidiso infor 353136 Dec 9 14:05 tableau2.pdf
-rw-r--r-- 1 rafidiso infor 3534336 Dec 9 12:34 presentation.ppt
$ logout
Connection closed by foreign host.
lyopcs1 17:19:00 1 /root #
________________________________________________________________
SSH
Telnet permet d’exécuter des commandes sur un hôte distant mais la communication n’est
pas sécurisée. Le protocole SSH (Secure Shell) permet d’accéder à une machine à
travers une communication chiffrée.
Il y a 2 versions majeures du protocole SSH, la version 2 n‘étant pas vulnérable
à un trou de sécurité particulier à la première version du protocole.
La version 2 propose aussi un moyen de transfert de fichier sécurisé.
L’établissement d’une connexion SSH se réalise en plusieurs étapes :
Le client et le serveur négocient tout d’abord l’algorithme de chiffrement.
Le serveur transmet sa clé publique au client. Le client génère ensuite une clé de session
qui est chiffrée grâce à la clé publique du serveur. La communication est cryptée en
utilisant cette clé de session.
A la première connexion ssh entre 2 machines, on a un message qui s’affiche sur le client
demandant d’accepter ou non la connexion.
Le message indique bien que l’authenticité de la machine ne peut être établie.
________________________________________________________________
exemple :
lyopcs1 17:31:30 0 /root $
lyopcs1 17:31:30 0 /root $ ssh rafidiso@lyopcs326.in2p3.fr
The authenticity of host 'lyopc326 (134.158.138.176)' can't be
established.
RSA key fingerprint is
a1:22:f4:9e:4f:cc:fa:10:a2:8d:9f:9a:17:ba:44:2f.
Are you sure you want to continue connecting (yes/no)? yes

Warning: Permanently added 'lyopc326,134.158.138.176' (RSA) to the
list of known hosts.
rafidiso@lyopcs326.in2p3.fr's password:
Last login: Mon Mar 22 17:14:29 2004 from lyopcs1
$
________________________________________________________________
Pour véritablement contrôler l’identification de la machine distante, il faudrait demander
auprès de l’administrateur de cette machine de valider la clé publique présentée.
Une fois la première connexion établie, le client enregistre la clé d’hôte du serveur. La
machine distante a également une liste de machines qui lui permettra de vérifier que le
client est bien celui qu’il prétend être.
exemple de syntaxe : ssh nom_machine
ssh ne demande pas un identifiant utilisateur (login) comme telnet. Il prend par défaut
l’identifiant utilisateur de la machine locale.
On peut préciser un login au niveau de la commande :
ssh login@nom_machine
________________________________________________________________
exemple 1: connexion simple
lyopcs1 17:30:52 0 /root $ ssh lyopcs9.in2p3.fr
root@lyopcs9.in2p3.fr's password:
Last login: Mon Mar 22 17:30:35 2004 from lyopcs1.in2p3.fr
[root@lyopcs9 root]#
[root@lyopcs9 root]$ hostname
lyopcs9.in2p3.fr
[root@lyopcs9 root]$
[root@lyopcs9 root]$ id
uid=0(root) gid=0(root)
groups=0(root),1(bin),2(daemon),3(sys),4(adm),6(disk),10(wheel)
[root@lyopcs9 root]$
[root@lyopcs9 root]$ logout
Connection to lyopcs9.in2p3.fr closed.
exemple 2: connexion avec un login différent
lyopcs1 17:31:30 0 /root $
lyopcs1 17:31:30 0 /root $ ssh rafidiso@lyopcs9.in2p3.fr
rafidiso@lyopcs9.in2p3.fr's password:
Last login: Mon Mar 22 17:14:29 2004 from lyopcs1
$ hostname
lyopcs9.in2p3.fr
$
$ id
uid=1900(rafidiso) gid=110(infor) groups=110(infor)
$
$logout

Connection to lyopcs9.in2p3.fr closed.
lyopcs1 17:35:17 0 /root $
________________________________________________________________
D’autres fonctionnalités avec ssh
- ssh permet d’exécuter une ou plusieurs commandes sur une machine distante. Le
résultat de la commande s’affiche en local.
exemple de syntaxe : ssh login@nom_machine commande
________________________________________________________________
exemple : passage de 2 commandes sur une machine distante
[ipn@lyopc325 ipn]$
[ipn@lyopc325 ipn]$ ssh lyopc326 ’’who;hostname’’
ipn@lyopc326's password:
dupont :0 Apr 20 14:08
durand pts/0 Apr 20 14:08
lyopc326
[ipn@lyopc325 ipn]$
________________________________________________________________
- ssh permet la redirection X11
Les programmes graphiques utilisent X Window pour s’afficher à l’écran. Avec un serveur
X, on peut exécuter un programme sur une machine distante et avoir son affichage en
local. Normalement, cette communication n’est pas cryptée.
Avec ssh, on peut chiffrer également la communication X Window.
exemple de syntaxe : ssh –X –f nom_machine commande
option ‘-X’ permet la redirection X11
option ‘-f’ met en ssh en arrière-plan après l’exécution de la commande.
- scp (secure copy) permet de copier des fichiers à travers le réseau et la communication
est chiffrée.
voir le paragraphe sur le transfert de fichiers.
Exemples de logiciels client ssh et telnet sur quelques plateformes :
Linux :
Windows :
MacOS 8 et 9 :
ssh et telnet en ligne de commande
putty, SSH secure shell, telnet en ligne de commande
Nifty telnet

MacOS X :
ssh et telnet en ligne de commande
Transfert de fichiers
FTP (File Transfert Protocol)
Le protocole ftp sert au transfert de fichiers.
Il faut s’authentifier pour accéder à un serveur.
Certains serveurs dit publiques acceptent des connexions anonymes. Il suffit alors de
rentrer comme identifiant « anonymous » et comme mot de passe son adresse
électronique (il n’y a pas de vérification).
Un compte sur un serveur ftp définit des privilèges d’accès (écriture/lecture).
Quelques commandes :
help : aide sur les commandes
ftp : connexion à un serveur ftp en ligne de commande
open : se connecte à un serveur ftp
get : récupération d’un fichier
mget : récupération de plusieurs fichiers
put : envoie d’un fichier
mput : envoie de plusieurs fichiers
hash : affichage d’un # pour une unité transférée
ascii/bin : mode de transfert texte ou binaire
prompt : session interactive ou pas
dir : liste le répertoire courant
cd : change de répertoire
pwd : affiche le répertoire courant sur la machine distante
lcd : change de répertoire en locale
close : termine la session ftp
bye, exit : termine la session ftp et quitte le mode interactif ftp.
Remarque : si le nom d’un fichier contient des espaces, il faut saisir le nom avec des
guillemets.
Exemple de logiciels client ftp :
Linux :
ftp, ncftp (en ligne de commande), gftp (graphique)
Windows : ftp (en ligne de commande), smartftp, cuteftp
MacOS : fetch
________________________________________________________________
exemple :
[ipn@lyopc325 ipn]$
[ipn@lyopc325 ipn]$ ftp lyonas1.in2p3.fr
Connected to lyonas1.in2p3.fr (134.158.138.111).
220 LYONAS1 Microsoft FTP Service (Version 5.0).

Name (lyonas1.in2p3.fr:ipn): rafidiso
331 Password required for rafidiso.
Password:
230 User rafidiso logged in.
Remote system type is Windows_NT.
ftp>
ftp> dir
227 Entering Passive Mode (134,158,138,111,16,210).
125 Data connection already open; Transfer starting.
03-17-04 12:44PM 2662400 etc.tar
06-25-02 10:00PM 5908 LICENSE
09-24-03 06:16AM 1049600 paris-24-01-b.jpg
06-25-02 10:00PM 13012 README
06-25-02 10:00PM 13012 README2
03-17-04 12:44PM 1587200 root.tar
03-17-04 01:18PM 2738647040 scratch.tar
03-17-04 12:44PM 105482240 tmp.tar
03-17-04 12:43PM 14653440 var.tar
226 Transfer complete.
ftp>
ftp> hash
Hash mark printing on (1024 bytes/hash mark).
ftp> prompt
Interactive mode off.
ftp> put commandes.doc
local: commandes.doc remote: commandes.doc
227 Entering Passive Mode (134,158,138,111,16,211).
125 Data connection already open; Transfer starting.
##########################################
226 Transfer complete.
44069 bytes sent in 0.0287 secs (1.5e+03 Kbytes/sec)
ftp>
ftp> bin
200 Type set to I.
ftp> lcd
Local directory now /home/ipn
ftp> mget READ*
local: README remote: README
227 Entering Passive Mode (134,158,138,111,16,213).
125 Data connection already open; Transfer starting.
############
226 Transfer complete.
13012 bytes received in 0.00439 secs (2.9e+03 Kbytes/sec)
local: README2 remote: README2
227 Entering Passive Mode (134,158,138,111,16,214).
125 Data connection already open; Transfer starting.
############
226 Transfer complete.
13012 bytes received in 0.00234 secs (5.4e+03 Kbytes/sec)
ftp>
ftp>
ftp> mkdir reptemp
257 "reptemp" directory created.
ftp> cd reptemp
250 CWD command successful.
ftp>

ftp> dir
227 Entering Passive Mode (134,158,138,111,16,216).
125 Data connection already open; Transfer starting.
226 Transfer complete.
ftp> put commandes.doc
local: commandes.doc remote: commandes.doc
227 Entering Passive Mode (134,158,138,111,16,217).
125 Data connection already open; Transfer starting.
###########################################
226 Transfer complete.
44032 bytes sent in 0.0154 secs (2.8e+03 Kbytes/sec)
ftp> pwd
257 "/reptemp" is current directory.
ftp> cd ..
250 CWD command successful.
ftp> pwd
257 "/" is current directory.
ftp> bye
221
________________________________________________________________
SCP (secure copy )
scp permet de copier des fichiers à travers le réseau et la communication est chiffrée.
Exemple de syntaxe pour l’envoie d ‘un fichier :
scp fichier1 nom_machine:/repertoire_destination/
Exemple de syntaxe pour le rapatriement d’un fichier :
scp nom_machine:/repertoire/fichier2 /repertoire_local/
________________________________________________________________
exemple : rapatriement d’un fichier et on le place dans le
répertoire locale /tmp/
[ipn@lyopc325 ipn]$
[ipn@lyopc325 ipn]$ scp root@lyopc326:/root/addnisuser /tmp/
root@lyopc326's password:
addnisuser 100% |
******************************************************************
***| 6367 00:00
[ipn@lyopc325 ipn]$
________________________________________________________________
Exemple de clients scp :
Linux :
scp, gftp (application graphique)
Windows : winscp
MacOS 8 et 9: Nifty telnet
WGET

wget est un logiciel qui permet de télécharger des fichiers de façon non interactive en http,
https, et ftp. Cette commande peut être utile dans des scripts.
________________________________________________________________
exemple 1: téléchargement d’un fichier sur un serveur ftp
[ipn@lyopc325 ipn]$
[ipn@lyopc325 ipn]$ wget ftp://rpmfind.net/redhat/9/i386/RPMS/lynx-2.8.5-11.i386.rpm
--17:39:08-- ftp://rpmfind.net/redhat/9/i386/RedHat/lynx-2.8.5-11.i386.rpm
=> `lynx-2.8.5-11.i386.rpm'
Resolution de rpmfind.net... complete.
Connexion vers rpmfind.net[195.220.108.108]:21...connecte.
Session debutant sous anonymous...Session etablie!
==> SYST ... complete. ==> PWD ... complete.
==> TYPE I ... complete. ==> CWD //redhat/9/i386/RPMS ... complete.
==> PORT ... complete. ==> RETR lynx-2.8.5-11.i386.rpm ... complete.
Longueur: 1,522,835 (non autorisee)
100%[============================================================================>]
1,522,835 4.00M/s ETA 00:00
17:39:08 (4.00 MB/s) - « lynx-2.8.5-11.i386.rpm » sauvegardee [1522835]
[ipn@lyopc325 ipn]$
exemple 2: téléchargement d’un fichier sur un serveur http
[ipn@lyopc325 ipn]$
[ipn@lyopc325 ipn]$ wget
http://the.earth.li/~sgtatham/putty/latest/x86/putty.exe
--17:47:06-- http://the.earth.li/%7Esgtatham/putty/latest/x86/putty.exe
=> `putty.exe'
Resolution de the.earth.li... complete.
Connexion vers the.earth.li[193.201.200.66]:80...connecte.
requete HTTP transmise, en attente de la reponse...302 Found
Location: http://the.earth.li/~sgtatham/putty/0.54/x86/putty.exe [suivant]
--17:47:11-- http://the.earth.li/%7Esgtatham/putty/0.54/x86/putty.exe
=> `putty.exe'
Connexion vers the.earth.li[193.201.200.66]:80...connecte
requete HTTP transmise, en attente de la reponse...200 OK
Longueur: 372,736 [application/x-msdos-program]
100%
[============================================================================>]
372,736 1.70M/s ETA 00:00
17:47:12 (1.70 MB/s) - « putty.exe » sauvegarde [372736/372736]
[ipn@lyopc325 ipn]$
[ipn@lyopc325 ipn]$
[ipn@lyopc325 ipn]$ ll
total 1916
-rwxr-xr-x 1 ipn ipn 8710 nov 9 2001 acroread
-rw-r--r-- 1 ipn ipn 44032 avr 16 20:49 commandes.doc
-rw-rw-r-- 1 ipn ipn 1522835 avr 20 17:39 lynx-2.8.5-11.i386.rpm
-rw-rw-r-- 1 ipn ipn 372736 fev 12 20:21 putty.exe
[ipn@lyopc325 ipn]$
________________________________________________________________
Points à retenir

* Prise de session distante, utiliser de préference ssh au lieu de telnet
La communication par ssh est chiffrée
exemple de commande : ssh login@nom_machine
* Transfert de fichier : commandes ftp, scp, wget
Un client ftp graphique est plus pratique
wget est pratique si l’on travaille qu’en ligne de commande.

Chapitre 9 : Les processus
Principes
Un algorithme d’ordonnancement des tâches permet de servir plusieurs utilisateurs en
leur allouant à chacun une "tranche de temps".
Tout programme ou commande s’exécutant sous Unix entraîne la création d’un
processus. Un processus est l’instance en exécution d’un programme. Un processus a la
possibilité, à son tour, de générer d’autres processus; on parle alors de "fork" : le
processus courant ou processus père crée un processus fils. Le processus père reste en
attente de la fin d’exécution de son fils.
Etant donné un processus, sa filiation (tout processus est fils d’un autre mais peut
également être père) est garantie grâce à des identificateurs numériques associés à
chaque processus que sont le :
• PID : qui identifie le processus courant
• PPID : qui identifie son père
Echappe à cette règle le processus initial (init) dont le PID est égal à 1 et qui est crée en
fin d’initialisation du système Unix. Ce processus est père d’un certain nombre de
processus de base tels que les processus de gestion de login, de gestion des fichiers,
etc...
Vous aurez accès à l’état de vos processus grâce à la commande ps. L’exemple suivant
est un retour de la commande ps utilisée sans option :
_______________________________________________________________________
$ ps
PID TTY TIME CMD
31156 pts/2 0:00 xcalc
38143 pts/2 0:00 ps
39071 pts/2 0:00 -tcsh
_______________________________________________________________________
Ici 3 processus sont actifs pendant l’exécution de ps. Il s’agit de tcsh (puisque vous êtes
en permanence sous le contrôle d’un shell de connexion), de la commande ps et d’une
autre application xcalc. La première colonne affiche le PID de chaque processus.
On obtiendra des informations plus détaillées (heure de démarrage et durée de vie du

processus, processus des autres utilisateurs, etc...) avec les options e et f de ps :
_______________________________________________________________________
$ ps -ef
USER PID PPID C STIME TTY TIME CMD
root 10078 1319 0 Oct 02 - 0:00 /usr/etc/rpc.lockd
root 10342 1319 0 Oct 02 - 0:00 /etc/writesrv
larrieu 11536 1 0 Oct 09 hft/1 1:33 netscape
larrieu 11917 15492 0 Oct 08 hft/1 0:00 xss
larrieu 13004 19602 4 13:20:46 pts/0 0:00 grep larrieu
larrieu 15492 14718 0 Oct 08 hft/1 2:15 mwm
____________________________________________________________________________________
Mode d’exécution
Deux modes d’exécution sont possibles pour un processus :
• Le premier plan (ou foreground). On tape le nom d’une commande suivi de
. Il faudra attendre la terminaison de ce processus pour lancer un nouveau
processus à partir de la ligne de commande.
• L’arrière plan (ou background). On tape la commande suivie de & puis .
On libére alors immédiatement l’entrée standard, permettant ainsi la saisie d’une
nouvelle commande.
Le shell maintient en permanence une table de tâches actives. Supposons que vous
lanciez une calculette en arrière plan par :
___________________________________________________________________
$ xcalc &
[1] 31156
___________________________________________________________________
Cette réponse vous indique qu’il s’agit de la tâche numéro 1 ayant pour PID 31156. Le
numéro de tâche est utilisé pour contrôler le mode d’exécution d’un processus :
___________________________________________________________________
$ fg %1
___________________________________________________________________
ramènera au premier plan, le processus initialement en arrière plan.
Si vous avez lancé un processus au premier plan, vous pourrez toujours le dérouter vers
l’arrière plan, sans l’interrompre par un signal "terminant", mais en suspendant son activité
par la séquence de touches ; vous obtiendrez alors une réponse du type :
___________________________________________________________________
$

^Z[2] + 31040 Stopped xclock
$ bg %2
___________________________________________________________________
La commande jobs permet de récupérer les numéros de tâches actives en arrière plan à
un instant donné.
___________________________________________________________________
$ jobs
[2] + Running xclock
[1] - Running xcalc
___________________________________________________________________
Indique que 1 et 2 sont les numéros de tâches associés respectivement aux processus
test et xcalc
Interruption des processus
Les processus communiquent entre eux à l’aide de signaux. C’est grâce à ces mêmes
signaux, que l’utilisateur interagira avec les processus dont il est propriétaire. Ainsi un
processus lancé sur la ligne de commande au premier plan est interruptible par un
ce qui correspond à l’émission d’un signal INTR.
Dans le cas général, c’est la commande kill qui permet de contrôler l’utilisation des
signaux.
Pour afficher la liste des signaux disponibles faites :
___________________________________________________________________
$ kill -list
HUP INT QUIT ILL TRAP IOT EMT FPE KILL BUS SEGV SYS PIPE ALRM TERM URG STOP
TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ MSG WINCH PWR USR1 USR2 PROF DANGER
VTALRM MIGRATE PRE GRANT RETRACT SOUND SAK
___________________________________________________________________
Pour envoyer une signal à un processus, on peut utiliser diverses formes de la commande
kill :
____________________________________________________________________
$ kill -SIG-NAME PID
ou
$ kill -SIG-INDEX PID
____________________________________________________________________
où SIG-NAME est le nom du signal (par exemple INT ou KILL)
SIG-INDEX est le numéro d’index du signal dans la liste des signaux (2 pour INT et 9

pour KILL par exemple)
ou bien encore
_____________________________________________________________________
$ kill -SIG-NAME %job
$ kill -SIG-INDEX %job
_____________________________________________________________________
on utilise ici le numéro de job plutôt que le PID.
Exemple : pour envoyer le signal TERM au processus de PID 1234, tapez :
_____________________________________________________________________
$ kill -TERM 1234
ou
$ kill -15 1234
_____________________________________________________________________
On peut également utiliser la commande stop pour suspendre un processus en le
désignant par son PID:
_____________________________________________________________________
$ stop 1234
_____________________________________________________________________
La commande cron
S’utilise pour effectuer une même tâche périodiquement. La commande /etc/cron
peut être activée au démarrage du système (dans un /etc/rc*). Sa configuration
s’appuie sur 3 fichiers :
/var/spool/cron/. Répertoire où sont stockés les tables cron. Un fichier par utilisateur
autorisé portant le même nom.
cron.allow (généralement dans /var/adm/cron). Fichier consignant les utilisateurs
autorisés à utiliser cron.
cron.deny (généralement dans /var/adm/cron). Fichier des interdits.
Liste les utilisateurs non-autorisés à utiliser cron. Ou interdiction temporaire pour ceux
listés dans cron.allow
Une table cron ou crontab
C’est un fichier que l’on construit dans son propre repertoire. Sur chaque ligne, on associe
une périodicité à une commande. Sa structure est
:___________________________________________________________________

Minutes ( 0 à 59)
Heures (0 à 23)
Jours (1 à 31)
Mois (1 à 12)
Jour de la semaine (0 à 6)
Commande
___________________________________________________________________
Autres paramètres
- signifie "de .... à"
10-20 = toutes les minutes de 10 à 20
, est un séparateur de plusieurs valeurs
0,2 = dimanche et mardi
* toutes les valeurs possibles d’un champ
% remplace l’entrée standard
Exemple d’utilisation de cron
On crée un fichier contenant :
______________________________________________________________
30 7 * * 1,3,5 /home/toto/rm_core
15 9,14 * 1-6,9-12 1-5 /etc/wall%News a lire%
______________________________________________________________
• Ligne 1
execute rm_core à 7h30, lundi, mercredi et vendredi
• Ligne 2
Envoie à tous le message News à lire à 9h15 et 14h15

du lundi au vendredi, chaque mois sauf juillet et août
Transférer le fichier que l’on a par exemple nommé crt, dans le répertoire de cron cad vers
/varr/spool/cron/
$ crontab crt
Vérifier ce qui sera exécuté par cron :
$ crontab –l
Edition des crontabs (attention! n’altère pas le fichier crt)
$ crontab –e
La commande at
Permet de démarrer une tâche à une date précise
Sa configuration s’appuie sur 3 fichiers :
/var/spool/at/ Répertoire où sont stockés les fichiers at.
at.allow Fichier consignant les utilisateurs autorisés à utiliser at.
at.deny Liste les utilisateurs non-autorisés à utiliser at.
at.allow n’existe pas
at.allow existe
at.deny n’existe pas Seul root peut faire at seuls ceux qui apparaissent
sont autorisés
at.deny existe Ceux qui ne sont pas interdits sont
autorisés
At.allow consulté en premier
Exemple d’utilisation de at
Effacer tous les fichiers core ce soir à 21h
___________________________________________________________________
$ at 2100 today
find / -name core -exec rm {} ’;’

Job 4 at 1998-02-10 22:0
Lister les tâches en queue
___________________________________________________________________
$ at -l
3 at 1998-02-10 22:00
4 at 1998-02-10 22:00 a
___________________________________________________________________
Affiche le contenu d’une tâche
______________________________________________________________
$ at -c 4
ici des variables d’environnement sont transmises.
....
find / -name core -exec rm {} ’;’
_______________________________________________________________
Supprimer une tâche
______________________________________________________________
$ at -r 4
______________________________________________________________

Chapitre 10 : Eléments de programmation Shell
Comme nous l’avons déjà évoqué, les shells sous Unix sont en général à la fois des outils
d’interaction entre l’utilisateur et le noyau du système mais également peuvent être
utilisés en tant que langage de programmation interprété.
Les commandes
Sur une ligne de commande vont apparaître une ou plusieurs commandes (commandes
Unix ou commandes intrinsèques au shell) ainsi qu’éventuellement des séparateurs et
des terminateurs.
Les caractères séparateurs et terminateurs
; permet de séparer plusieurs commandes sur une même ligne. Exemple :
&
&&
______________
$ date ; ls
______________
La commande date sera exécutée suivie par la commande ls
va créer un processus d’arrière plan de la commande qui le précède donc cela
détachera le processus du terminal.
Lorsque le caractère & est doublé ceci indique au shell de n’exécuter ce qui suit &&
qu’à condition que l’exécution de ce qui le précède ait réussie. Exemple :
____________________________________
$ grep bash toto && echo Bravo
#!/bin/bash
Bravo
____________________________________
Ayant trouvé la chaîne bash dans le fichier toto, on affiche Bravo
| le symbole pipe utilisé seul dans le cadre des redirections.
|| Lorsque ce caractère est doublé ceci indique au shell de n’exécuter ce qui suit || qu’à
condition que l’exécution de ce qui le précède ait échouée. Exemple:

__________________________________________
$ touch /etc/new || echo On doit être root pour ca
touch: 0652-046 Cannot create /etc/new.
__________________________________________
On doit être root pour ça. La création du fichier /etc/new a échoué alors on envoie
un message.
Exécution de commandes et substitution
Le Korn shell offre la possibilité des substituer le résultat d’une commande sur la ligne de
commande ou d’affecter ce résultat à une variable du shell.. La syntaxe pour aboutir à
cette substitution est $( commande ) . Par exemple :
_______________________________________________________________________
$ ls
bb cc param
$ echo "Liste des fichiers :" $(ls)
liste des fichiers : bb cc param
______________________________________________________________________________________
Va substituer la liste des fichiers sur la ligne des commande puis lui appliquer la
commande echo.
L’affectation d’une variable se fait de la même façon :
_______________________________________________________________________
$ var=$(id)
$ echo "je suis" $var
uid=311(larrieu) gid=102(ccnrs)
______________________________________________________________________________________
L’autre notation que l’on rencontre souvent pour la substitution des commandes consiste à
placer la commande entre anti-cotes :
var=‘id‘ est identique à var=$(id) , cette dernière étant la notation standardisée pour la
substitution de commandes.
La substitution de la tilde
Le shell utilise la tilde (~) pour représenter les répertoires "home" des utilisateurs. Il faut
noter cependant que la substitution ne pourra avoir lieu que si la tilde est le premier
caractère d’une chaine ( par exemple ab~c ne subira aucune substitution)
Utilisée seule ou suivie du caractère / , elle se réfère à votre propre répertoire "home". Le

shell lui substitue la valeur du chemin absolu du répertoire "home". L’utilisation de ~ et la
variable d’environnement $HOME sont équivalentes. Par exemple
_______________________________________________________________________
$ echo ~
/home/pierre
$ echo $HOME
/home/pierre
______________________________________________________________________________________
Concaténée avec un nom valide d’utilisateur, le shell lui substitue le chemin absolu du
répertoire home de cet utilisateur
_______________________________________________________________________
$ echo ~toto
/home/toto
_______________________________________________________________________
Si le nom d’utilisateur n’est pas valide (par exemple ubidon), aucune substitution n’aura
lieu.
_______________________________________________________________________
$ echo ~ubidon
~ubidon
______________________________________________________________________________________
Gestion des scripts shell
C’est grâce à son éditeur favori que l’utilisateur pourra créer le plus simple des scripts
shell qui contiendra une ou plusieurs commandes Unix. Outre les commandes système,
des constructions propre au shell (boucles, sélections, comparaisons, etc...) permettront
d’écrire des procédures plus complexes.
Un shell script est un ensemble de commandes et de commentaire non exécutables. Tout
ce qui suit sur une même ligne, le caractère # constitue un commentaire. Ce caractère
peut se trouver aussi bien en début de ligne qu’après une instruction.
Conventionnellement et pour être sûr que le script shell soit interprété à coup sur par le
"bon interpréteur" (ici en l’occurrence le bash), il faudra que la première ligne du fichier
commence par :
#!/bin/bash
L’ exécution de shell-scripts

Il existe plusieurs façons de mettre un script shell (que nous appellerons fichier) en
exécution.
La méthode "point" . On tape un point, un espace, le nom du fichier avec ses éventuels
arguments :
_______________________________________________________________________
$ . fichier
_______________________________________________________________________
Dans ce cas les commandes contenu dans le fichier seront exécutées par le shell courant
et sont traitées comme des commandes internes au shell. Il n’y a pas création d’un sous
shell.
Pour que cette méthode fonctionne, la variable PATH doit contenir le répertoire courant où
est localisé fichier ou bien fichier est un chemin absolu. Dans le cas contraire, on
obtiendra quelque chose comme :
bash: fichier: not found.
La méthode directe. On tape le nom du fichier suivi des ses arguments. Le nom pouvant
être simplement le nom du fichier ou un chemin absolu d’accès au fichier. Dans ce cas, le
script shell devra avoir les "mode bits" de lecture et d’exécution positionnés pour pouvoir
s’exécuter :
_______________________________________________________________________
$ fichier [ arg1 arg2 ..... argn ]
_______________________________________________________________________
Il y a la création d’un sous shell , fils du shell courant.
La création d’un shell fils du shell courant au sein duquel s’exécuteront les commandes du
fichier script shell :
_______________________________________________________________________
$ bash fichier [ arg1 arg2 ...... argn ]
L’exécution en arrière plan.
_______________________________________________________________________
$ fichier &
_______________________________________________________________________
Dans ce cas il y a également création d’un sous shell mais avec libération du terminal
attaché au shell courant.

Eléments syntaxiques
P aramètres positionnels
Une procédure peut recevoir des arguments. Ces paramètres sont positionnels sur la
ligne de commande. La façon de les référencer peut être décrite par la procédure suivante
que nous nommerons proc :
____________________________________________________________________
#!/bin/bash
echo $0 # Nom de la commande
echo $1 # Premier parametre
echo $2 # Second parametre
____________________________________________________________________
Appelons cette procédure comme suit :
___________________________________________________________________
$ proc aa bbb
proc
aa
bbb
___________________________________________________________________
La commande eval
Le shell dispose d’une commande unique : eval qui permet une double interprétation
d’une expression. Le shell interprète une fois la ligne de commande et passe ses
arguments à la commande eval qui effectue une seconde interprétation.
Cette commande permet de construire dynamiquement des variables ou encore permet
l’exécution de commandes préalablement construites qui n’auraient pu l’être sans son
utilisation. Exemple :
___________________________________________________________________
$ eval file=~$user/.rhosts
$ echo $file
/home/toto/.rhosts
_________________________________________________________________________________
Ici au premier passage $user est évalué et au deuxième passage l’expansion de la tilde a

lieu. Sans l’utilisation de la commande eval, file se serait vu affecter la chaîne
~toto/.rhosts et lors de l’utilisation de la variable file plus aucune autre substitution n’aurait
eu lieu.
Les tests
La plupart des langages de programmation disposent de constructions permettant
d’effectuer des test, il en va de même du Korn shell. La formulation d’expressions
conditionnelles qui entreront en jeu au sein de structures de contrôle est réalisée à l’aide
d’opérateurs de test ou de mots clé s’appliquant à des objets.
Pour évaluer une expression conditionnelle et retourner 1 ou 0, on utilise la syntaxe :
[[ instruction-conditionnelle ]]
L’instruction à évaluer sera donc soit :
Un test sur les fichiers ou les répertoires
-a fichier retourne 1 si fichier existe
-d fichier fichier est un répertoire
-x fichier fichier existe et est exécutable par le processus courant
Un test des dates de création
fic1 -nt fic2 retourne 1 si fic1 est plus récent que fic2
fic1 -ot fic2 retourne 1 si fic1 est plus vieux que fic2
Une comparaisons de chaines
str1 = str2 Vrai si str1 est identique à str2
str1 != str2 Vrai si str1 est différent de str2
-z str1 retourne 1 si str1 est de longueur nulle
Une comparaison de valeurs entières
val1 -eq val2 Vrai si val1 est identique à val2
val1 -ne val2 Vrai si val1 est différent de val2
val1 -lt val2 Vrai si val1 est plus petit que val2
Structures de contrôle
Les instructions " if/then/else"
Sa syntaxe est la suivante :

if condition de test
then expressions
[else instructions ]
fi
ce qui apparaît entre crochets est facultatif. Une application courante est le test des codes
de retour de commandes :
_______________________________________________________________________
# Exemple : test du code de retour de la commande "macmd"
#
macmd
if [[ $? -eq 0 ]]
then
echo Tout va bien
else
echo Il y a eu un problème
exit 3
fi
_______________________________________________________________________
Les boucles
On distinguera deux types de boucles :
la boucle for
for variable in liste-de-valeurs
do
liste-de-commandes
done
les boucles while et until.
while condition-satisfaite
do
liste-de-commandes
done
La boucle until a la même syntaxe que while mais à la différence de until, ce type de boucle
s’exécute jusqu’à ce que la condition exprimée soit satisfaite.
Exemples :
_______________________________________________________________________
# On supprime tous les fichiers dont le nom débute par "file"
# suivi d’un numérique compris entre 1 et 4

for ndx in 1 2 3 4
do
rm file.$ndx
done
_______________________________________________________________________
# Calcul d’une factorielle
#
n=$1
fact=1
while [ $n != 1 ]
do
let fact=fact*n
let n=n-1
done
echo factorielle $1 = $fact
_______________________________________________________________________
Les instructions d’entrée/sortie
Le Korn shell permet de lire des lignes à partir de l’entrée standard et de les éclater dans
des variables apparaissant sur la commande de lecture read. La syntaxe de base est :
read var1 var2 ...
Exemple :
_______________________________________________________________________
$ echo I/O error | read aa bb
$ echo $aa; echo $bb
I/O
error
_______________________________________________________________________
Outre la commande echo pour afficher sur la sortie standard, le shell offre la commande
print qui lui est similaire. print possède cependant quelques options additionnelles comme
_______________________________________________________________________
$ print -n "Entrer une valeur: " ; read val
Entrer une valeur :
______________________________________________________________________________________

n’émettra pas de retour chariot après l’affichage, c’est équivalent à utiliser le caractère \c
dans la ligne d’argument de la commande echo :
_______________________________________________________________________
$ echo "Entrer une valeur: \c"
_______________________________________________________________________

Chapitre 11 : Création d’applications
Les compilateurs
De façon générale sur UNIX le compilateur fortran s'appelle f77, le C cc, le C++ CC. Pour
LINUX les compilateurs sont g77, gcc et g++. Les options des compilateurs sont quasiidentiques
si bien que nous les citerons globalement.
Par défaut l'appel à un compilateur génère la compilation et l'édition de liens (ld), le fichier
intermédiaire objet (.o) étant automatiquement effacé.
Par défaut il n'y a pas de phase d'optimisation.
Si l'on ne précise pas de nom pour l'exécutable à créer, celui-ci s'appelle a.out.
L'appel étant unique pour le compilateur et l'editeur de liens, les options sont passées
simultanément, certaines s'adressant au compilateur d'autres à l'editeur de liens.
Options concernant le compilateur :
• -c : n'appelle pas ld et conserve le .o
• -On : appel de l'optimiseur niveau n
• -g : prépare pour le débogueur
• -temp=répertoire : définit un nouveau répertoire pour les fichiers temporaires
lorsque la place dans /tmp est insuffisante
Options concernant ld :
• -o nom : nom de l'exécutable de sortie
• -lnom : appel de la librairie nom
• -Lrépertoire : répertoire de recherche des librairies appelées si elles sont situées
ailleurs que dans /lib, /usr/lib, /usr/local/lib
Les librairies
Une librairie est un fichier archive qui contient une série de fichiers, en l’occurrence des
objets compilés (.o) qui correspondent à des fonctions programmées spécifiques et
auxquelles vous ferez appel dans vos programmes. Les librairies servent donc à éviter de
re-inclure dans vos sources des fonctions écrites une fois pour toutes. La fonction en
librairie utilisée sera incluse lors de la phase de création de l’exécutable (édition de liens).
Par défaut les librairies sont situées dans /lib ou /usr/lib mais vous pouvez bien sur créer
vos propres librairies chez vous. Il faudra alors signaler à l'éditeur de liens le chemin
d'accès à ces librairies (par l'option –L lors de la compilation), ou maintenir la liste des
chemins dans une variable d'environnement (différente selon le système UNIX).
L'option -l d'appel à une librairie est utilisée sous la forme –lnom et fait appel à une
librairie de nom libnom.a.
Ainsi on créera donc libmalib.a pour appeler -lmalib
L'outil de construction et maintenance de librairies s'appelle ar
ar [rxdtv] librairie [fichier]
• r : remplace ou ajoute un fichier dans la librairie; crée la librairie si elle n'existe pas

• x : extrait un fichier de la librairie
• d : efface un fichier dans la librairie
• t : liste le contenu de la librairie
• v : mode parlant
L’utilitaire make
Cet outil permet de construire un exécutable à partir de l'ensemble de ces dépendances. Il
n'est intéressant à mettre en oeuvre que si l'exécutable dépend de nombreuses sources.
La construction se fait par la commande make à partir des instructions indiquées dans un
fichier d'utilisation de make, appelé par défaut « Makefile » ou « makefile ».
Toute la difficulté réside pour le concepteur dans l’écriture du makefile qui doit décrire
astucieusement toutes les étapes de constructions de l’exécutable.
Les construction et reconstruction de l’exécutable final sont particulièrement facilitées
pour l’utilisateur, make travaillant par comparaison de date entre l'exécutable et ses
dépendances. make ne re-exécute que les actions dépendant de modules dont la date de
création est postérieure à la précédente date de construction de l'exécutable, et recrée cet
exécutable automatiquement.
make est très utilisé notamment pour diffuser des applications sous forme de sources, afin
que l’utilisateur n’ait pas à se poser de questions quand aux compilations mais ait juste à
taper make.
Un fichier makefile peut contenir plusieurs objectifs à construire, appelés cibles.
make
make [-f fichier] [cible] : construit la cible précisée ou la première décrite si cible est omis.
On décrira donc en général la cible totale en premier dans le makefile.
• -f fichier : précise un fichier d'utilisation si le nom est différent de Makefile ou
makefile
Ecriture du fichier makefile :
cible1:dépendances [cible2 cible3...]
action
cible2:dépendances
action
...
On peut définir des variables dans le fichier makefile, et mettre des commentaires
commençant par #.
(Dans l'exemple suivant le touch des fichiers sert uniquement à modifier leur date de mise
à jour et donc à simuler une édition avec modification de la source qui, aurait le même
effet sur la date de dernière modification.)
______________________________________________________________________
exemple :
$ cat makefile
# construit s1 a partir de s1.f s2.f s3.f

#
LIB=-L. -lmalib
#
s1:s1.o s2.o libmalib.a
g77 -o s1 s1.o s2.o \$(LIB)
s1.o:s1.f
g77 -c s1.f
s2.o:s2.f
g77 -c s2.f
libmalib.a:s3.o
ar r libmalib.a s3.o
s3.o:s3.f
g77 -c s3.f
$ make
g77 -c s1.f
s1.f:
MAIN:
g77 -c s2.f
s2.f:
sub1:
g77 -c s3.f
s3.f:
sub2:
ar r libmalib.a s3.o
g77 -o s1 s1.o s2.o -L. -lmalib
$ make
`s1' is up to date.
$ touch s1.f
$ make
g77 -c s1.f
s1.f:
MAIN:
g77 -o s1 s1.o s2.o -L. -lmalib
$ touch s3.f
$ make
g77 -c s3.f
s3.f:
sub2:
ar r libmalib.a s3.o
g77 -o s1 s1.o s2.o -L. -lmalib
______________________________________________________________________
Analyse en temps

2 commandes permettent une analyse en temps d’exécution de vos applications. La
première très simple mais grossière, la seconde plus lourde mais fournissant une analyse
fine, fonction par fonction.
time
time exécutable : exécute le programme et donne à la fin les 3 temps : écoulé total, cpu
pur, passé en tache système.
prof
prof [exécutable] : effectue une analyse fine, module par module, du temps consommé.
Nécessite que la source ait été compilée avec l'option -p
Le lancement de l'exécutable crée un rapport dans un fichier mon.out
prof exécutable analyse le rapport qui a été crée par le lancement de l'exécutable et
affiche à l'écran les résultats.
Utilise un exécutable a.out si aucun nom n'est spécifié en paramètre.
Des options permettent de n'avoir qu'un résumé des résultats.
Le debugger
Chaque système UNIX dispose en standard d’un debugger. Celui-ci est un outil interactif
qui va permettre de faire tourner votre programme pas à pas, en indiquant des points
d’arret, le suivi de variables, etc….
Le debugger standard UNIX s’appelle dbx mais sous LINUX c’est gdb.
Le principe est le suivant : on compile le programme avec l’option –g puis on lance ce
programme sous le contrôle du debugger : gdb monprogramme
Si le nom de programme n’est pas fourni, a.out est pris par défaut.
Lorsqu’une application UNIX « plante » pendant l’exécution, un fichier core est créé,
correspondant à l’image mémoire de l’application au moment de l’arret. Le debugger
permet également d’analyser ces « core » (gdb core) afin d’essayer de comprendre le
problème.
Une fois lancé, le debugger fournit alors un invite avec une aide intégrée. Nous n’irons
pas plus loin sur l’utilisation, qui est un domaine assez spécialisé, l’essentiel étant que
vous connaissiez l’existence de l’outil.

Chapitre 12 : Quelques outils sous linux
L’archivage et la compression de fichiers
Beaucoup de fichiers téléchargeables sur Internet sont compressés. Cela permet de
transférer un volume de données moins important tout en ayant la possibilité de restaurer
(décompresser) les fichiers tels qu’ils étaient au départ.
Une archive est un fichier qui peut contenir des répertoires et des fichiers.
- Le format .tar.gz
Un fichier ayant l’extension .tar.gz (ou .tgz) est un format très répandu. Cette extension
indique que le fichier est une archive tar qui a été compressée avec gzip.
La commande ‘tar’ permet notamment de créer et de restaurer une archive.
Exemples :
* pour créer et compresser une archive :
tar cfvz nom_archive.tar.gz /repertoire1
option ‘c’ : indique qu’on crée une nouvelle archive
option ‘v’ : visualise les fichiers traités par la commande tar
option ‘f’ : indique l’élément à archiver
option ‘z’ : compresse l’archive
* pour extraire et décompresser une archive :
tar xzvf nom_archive.tar.gz
option ‘x’ : extrait l’archive
option ‘z’ : ici, décompresse l’archive
* pour lister le contenu d’une archive :
tar –tvf nom_archive.tar
remarque : la commande ‘gunzip’ permet de décompresser les fichiers gzip.
- Le format bz2
Ce format de compression est plus performant que gzip.
Pour décompresser un fichier .tar.bz2, on peut utiliser la commande :
bzip2 –d nom_fichier.tar.bz2
ensuite, il faut extraire l’archive obtenue avec la commande :
tar xvf nom_fichier.tar

On peut également décompresser et extraire l’archive avec tar :
tar xjvf nom_fichier.tar.bz2
Installation d’un programme contenu dans une archive tar
Une grande partie des programmes à installer sont des archives tar compressées avec
gzip (extension .tar.gz ou .tgz) ou bzip2 (extension .tar.bz2)
Pour décompresser l’archive compressée avec gzip et extraire les fichiers, on utilise la
commande :
tar xzvf nom_fichier.tar.gz
option ‘x’ : extrait les fichiers de l’archive
option ‘z’ : décompresse l’archive (compressée avec gzip)
option ‘v’: visualise les fichiers en cours de traitement par la commande
option ‘f’ : indique le fichier traité par la commande
Pour décompresser l’archive compressée avec bzip2 et extraire les fichiers, on utilise la
commande :
tar xjvf nom_fichier.tar.bz2
option ‘j’ : décompresse l’archive (compressée avec bzip2)
Les fichiers obtenus sont soit un binaire directement exécutable,
soit il faut compiler le programme pour qu’il puisse fonctionner.
Pour compiler le programme, il faut se placer dans le répertoire qui a été extrait de
l’archive, puis passer les commandes :
./configure : construit le fichier ‘makefile’ qui servira pour la compilation et éventuellement
crée d’autres fichiers.
On peut passer des options à cette commande. Il faut lire le fichier texte relatif à
l’installation du programme (ce fichier s’appelle généralement INSTALL).
make : compile le programme
make install : installe le programme compilé.
Les paquetages RPM (Red Hat Package Manager)
RPM est un outil développé par RedHat pour gérer les paquetages.

Cet outil fonctionne sur les distributions Redhat mais également sur d’autres linux comme
Mandrake ou Suse.
Cet outil permet à l’utilisateur d’installer, de supprimer ou de mettre à jour facilement des
logiciels et cela avec de simples commandes.
Il existe des logiciels comme gnorpm et kpackage qui permettent de gérer les RPMs via
une interface graphique.
RPM maintient une base de données des paquetages installés et de leurs fichiers. Cela
permet de connaître simplement l’état du système sur les logiciels, leurs versions et les
fichiers installés.
Pour un paquetage, RPM vérifie les dépendances par rapport à d’autres paquetages.
Cela signifie par exemple que pour une installation d’un paquetage, RPM signale les
paquetages manquants pour que l’installation et le logiciel fonctionnent correctement.
Les noms des paquetages RPMS sont de la forme :
..>..rpm
: nom du logiciel
: version du logiciel
: version du paquetage
: identifie la plateforme pour lequel le paquetage est prévu (i386, alpha, …)
exemples :
- nedit-5.0.2-4.sparc.rpm : 4 ème version du paquetage ‘nedit’ version 5.0.2 pour une
plateforme Sun.
- nedit-5.3-1.i386.rpm : 1ère version du paquetage ‘nedit’ version 5.3 pour une plateforme
Intel.
Des liens pour chercher des paquetages rpms :
http://rpmfind.net
http://rpm.pbone.net/
Exemples de commandes :
* installation d’un paquetage rpm –i paquetage.rpm
remarque : on peut indiquer un lien d’un serveur web ou ftp sur lequel se trouve le
paquetage rpm
exemple :rpm -i ftp://rpmfind.net/linux/redhat/7.3/en/os/i386/RedHat/RPMS/nedit-5.2-2.i386.rpm
* suppression d’un paquetage rpm –e paquetage

emarque : pour la suppression, il ne faut pas indiquer les parties
..rpm du nom du paquetage
* mise à jour d’un paquetage rpm –Uvh paquetage.rpm
remarque : l’option ‘v’ et ’h’ permet d’avoir un mode verbose et de voir une progression de
l’installation
remarque : il existe une option ‘–nodeps‘ qui indique à RPM de ne pas tenir compte des
dépendances.
remarque : il existe l’option ‘—force’ qui force RPM à réaliser son action (installation,
désinstallation ..) …à utiliser avec prudence.
* affiche tous les paquetages installés rpm –qa
* recherche d’un paquetage rpm –qa | grep string
où on remplace « string » par le nom ou une partie du nom du paquetage recherché.
* liste les fichiers du paquetage installé rpm –ql paquetage
* affiche les informations sur un paquetage rpm –qi paquetage
* retrouve l’appartenance d’un fichier
à un paquetage
rpm –qf /chemin/fichier
* affiche le contenu d’un fichier rpm rpm –qpl paquetage.rpm
* affiche les informations d’un fichier rpm rpm –qpi paquetage.rpm
Il existe d’autres systèmes de gestion de paquetages comme APT.
Points à retenir
* une seule archive .tar.gz (ou bz2) peut servir à installer un programme quelque soit la
plateforme et le système linux de destination grâce à la création du makefile et la
compilation.
* gestion simplifiée des logiciels grâce aux paquetages RPM mais il faut récupérer le
paquetage spécifique à la plateforme et la version du système linux.

Chapitre 13 : Interfaces graphiques
Le système X Window
Ce système permet l’affichage d’objets graphiques sous linux.
Il fonctionne sur le principe client-serveur :
Le client est un programme qui demande au serveur d’afficher des objets graphiques.
Le serveur est le système X window (appelé aussi serveur X) qui réalise l’affichage.
Un client peut faire une requête d’affichage sur un serveur X d’une machine distante.
Il est donc possible d’exécuter un programme sur une machine distante et d’avoir un
affichage en local.
Xfree86 est une implémentation pour linux du système X Window.
Il existe des logiciels serveur X sous windows : cygwin, exceed, Xming, x-win 32…
Fig. : un serveur X sous Windows XP qui affiche le bureau d’une station Unix

Les Windows Managers (environnement de bureau)
Un Window Manager se charge de l’habillage des fenêtres sous X Window, gère la barre
de titre et les boutons des fenêtres. Il offre aussi les moyens à l’utilisateur d’interagir avec
l’interface graphique (menus, icones).
Ces environnements de bureau ont permis de rendre linux moins « austère » à utiliser par
rapport à la ligne de commande.
Exemples de Window manager :
FVmw : un des premiers environnements graphiques sous linux
Fig. : FVMW – Window Manager
Window maker : Son interface graphique vise à ressembler à celle de NeXTStep.

XFCE : C’est un window manager léger et rapide
Fig. : XFCE – Window manager
Les projets KDE et Gnome apportent un environnement de bureau complet :
- Une interface graphique dont l’utilisation est proche de celle de Windows (menu pour
lancer les applications, bureaux virtuels, barre des tâches, barre lanceurs d’application …)
- De multiples outils pour configurer le système, des outils de bureautique, internet et pour
le développement.
Site officiel de KDE : http://www.kde.org
Site officiel de Gnome : http://www.gnome.org/

Fig. : exemple d’un environnement KDE
Exemples d’applications KDE :
Konqueror : un navigateur internet
koffice : une suite bureautique avec un traitement de texte, un tableur …
KghostView : ce logiciel permet de visualiser des fichiers postscript et pdf
Konsole : un client terminal
Kinternet : pour configurer les connexions internet

Fig. : exemple d’un environnement Gnome
Exemples d’applications Gnome :
Evolution : un client courrier électronique, un carnet d’adresses et un agenda
Gnome system tools : gestion des utilisateurs et des groupes, gestion de la date et heure,
gestion de la configuration réseau, …
Nautilus : gestionnaire de fichiers
Gnome-terminal : un client terminal
Quelques logiciels du domaine publique utiles (en environnement interface
graphique)
* Gimp : C’est un logiciel de retouche d’images (l’équivalent de Photoshop). Il est porté
sur plusieurs plateformes (linux , windows, macintosh)
Site officiel : http://www.gimp.org
* Openoffice : C’est une suite bureautique qui inclue entre autre un traitement de texte,
un tableur, un logiciel de présentation. Il existe également sur plusieurs plateformes.

Site officiel : http://www.openoffice.org
Site francophone : http://fr.openoffice.org/
* Ekiga (ex Gnomemeeting) : c’est un logiciel de vidéo et audio conférence point à point.
Il permet de réaliser des appels audio et vidéo avec des utilisateurs distants utilisant un
client H.323 (comme Microsoft Netmeeting)
Site officiel : http://www.gnomemeeting.org/
* Rdesktop : C’est un client pour accéder à un environnement windows distant d’un
serveur Windows Terminal Server
Site officiel : http://www.rdesktop.org/