\typeout{+==============================================+}
\typeout{|============ COMMUNIQUER =====================|}
\typeout{+==============================================+}
\chapter{Communiquer !}
\label{chap-communiquer}
\begin{epigraphe}{Extrait du manuel de \soft{groff}}
  Report  bugs to bug-groff@prep.ai.mit.edu.\\
  Include a complete, self-contained example\\
  that will allow the  bug  to be  reproduced,\\
  and  say  which  version of groff you are  using.
\end{epigraphe}

\begin{introchap}{Le protocole réseau}
  TCP/IP a été intégré au début des années 80, dans la branche
  BSD d'\unix. On trouve donc parmi les utilitaires standard des
  outils axés sur la communication entre utilisateurs, le transfert de
  fichiers, l'accès à des machines distantes, etc. Ce chapitre propose
  tout d'abord un aperçu du concept d'adresse IP et du système de
  nommage des machines sur Internet (DNS). Il présente ensuite les
  outils classiques de communication que sont \com{ftp}, \com{telnet},
  \com{rlogin} et \com{ssh}. Après que les outils réseaux propres à
  \unix{} ont été passés en revue, le chapitre est clos par la
  présentation des utilitaires de base pour envoyer des mails et pour
  accéder à des ressources localisées sur le Web.
\end{introchap}

%
%
% HISTORIQUE INTERNET 
%
%================================================================
%\section{historique internet}


%================================================================
%
% CONCEPTS DE BASE
%
%================================================================
\section{Concepts à connaître}

Pour comprendre de quoi il est question dans ce chapitre, il est
nécessaire de connaître quelques concepts liés à la technologie d'un
réseau.

%================================================================
% La notion d'adresse IP
%================================================================
\subsection{Notion d'adresse IP}
\label{sec-com-IP}
\index{adresse IP}
\index{IP}

L'adresse IP (pour \emph{Internet Protocol}) est un ensemble de quatre
nombres destiné à identifier de manière univoque une machine sur un
réseau local et sur Internet. Cette adresse se compose de quatre octets
de la forme :
\begin{center}
  \comarg{xxx}.\comarg{yyy}.\comarg{zzz}.\comarg{ttt}
\end{center}
Par exemple : 172.30.4.78 est une adresse IP. On peut donc
potentiellement référencer $256\times 256\times 256\times
256=256^4=4294967296$ soit plus de quatre milliards de
machines\footnote{En réalité une partie des ces adresses sont dites «
  privées » c'est-à-dire qu'elles sont réservées à un usage interne et ne
  sont donc pas visibles de l'extérieur.}.
\begin{note}
  Aujourd'hui les réseaux utilisent IP version~4 pour laquelle les
  adresses sont codées sur 4 octets comme expliqué
  ci-dessus. Cependant, bien que quatre milliards d'adresses peuvent
  paraître suffisants pour identifier chacune des machines, on arrive
  aujourd'hui à une pénurie. C'est la principale raison pour laquelle
  le protocole IP dispose aujourd'hui d'une version~6 dans laquelle
  les adresses sont codées sur 16 octets. On peut donc adresser :
  \begin{displaymath}
    256^{16}=340282366920938463463374607431768211456 \mbox{ machines}.
  \end{displaymath}
\end{note}

%================================================================
% La notion d'adresse de dns
%================================================================
\subsection{Notion de DNS}
\label{sec-com-dns}
\index{dns}
\index{domain name system}
\index{machine!adresse}
\index{machine!nom}
\index{nom de machine}

De manière à éviter aux utilisateurs d'un réseau de se souvenir des
adresses IP des machines, un système de nommage a été mis en place
depuis presque vingt ans.  Ce système s'appelle le \emph{Domain Name
  System} ou DNS. Il utilise un protocole qui assure la traduction
d'une adresse IP en un nom de machine (\texttt{ftp.lip6.fr} par
exemple) et inversement. Le protocole repose sur les idées suivantes :
\begin{itemize}
\item les machines du réseau sont regroupées en \emph{domaine} ;
\item ces domaines sont organisés en arborescence ;
\item chaque sous-domaine est géré par un serveur responsable des
  machines qu'il contient. On est donc en présence d'une base de
  données décentralisée ;
\item un système de cache est utilisé pour limiter le trafic réseau.
\end{itemize}
\index{arborescence!DNS}
Le domaine « racine » est noté «\texttt{.}» ; le point sert également
de séparateur de sous-domaine (à l'instar du \texttt{/} pour les
répertoires). Sous le domaine racine existe un certain nombre de
sous-domaines :
\begin{itemize}
\item un domaine pour chaque pays, par exemple \texttt{fr} pour la
  France, \texttt{de} pour l'Allemagne, \texttt{es} pour l'Espagne,
  etc.
\item le domaine \texttt{org} pour les organisations à but non
  lucratif (par exemple le célèbre \texttt{www.gnu.org}) ;
\item le domaine \texttt{edu} regroupant initialement les universités
  américaines (par exemple, le serveur web de l'université de Chicago
  est \texttt{www.uchicago.edu}) ;
\item le domaine \texttt{net} regroupant les machines dont le contenu
  est axé sur le réseau ;
\item le domaine \texttt{com} destiné à héberger les sites dont le but
  est de vous faire acheter des marchandises virtuelles ou
  non\footnote{Que penser alors d'un slogan d'une célèbre compagnie
    de téléphone française qui disait il y a quelques années :  «
    bienvenue dans un monde .com » ?} ;
\item ...
\end{itemize}
Chacun de ces domaines peut ensuite contenir des sous-domaines,
pouvant également contenir des sous-domaines, etc. L'ensemble forme
donc une arborescence dont la racine est le domaine~«\texttt{.}»,
chaque n\oe ud est un sous-domaine, et chaque feuille est une
machine\footnote{Ou plus rigoureusement l'interface d'une machine.} 
ayant une adresse IP donnée.
\begin{figure}[htbp]
  \begin{center}
    \includegraphics[width=.8\textwidth]{dns}
    \caption{Arborescence de domaine DNS.}
    \label{fig-dns}
  \end{center}
\end{figure}
Par exemple, sur la figure~\ref{fig-dns}, la machine \texttt{ayler}
appartient au domaine \texttt{freejazz}, lui-même sous-domaine
du domaine \texttt{fr}.

Lors d'une requête de connexion sur une machine un système complexe
d'interrogation de l'arborescence des serveurs de noms permet
d'obtenir la traduction d'un nom vers une adresse IP et inversement
(pour les lecteurs intéressés se référer au manuel de
\citet{dns_bind}).

%================================================================
% Quelques utilitaires réseau
%================================================================
\subsection{Quelques utilitaires réseau}
\label{sec-com-utils}
\index{réseau!utilitaires}
\index{utilitaires réseau}
Suivant les droits que vous auront donnés le ou les administrateurs du
site sur lequel vous travaillez, vous aurez la possibilité d'obtenir
des informations ayant trait aux adresses et aux noms des machines qui
vous entourent.


\subsubsection{ping}
\index{ICMP}

La commande \com{ping} permet, à l'aide d'un protocole
particulier\footnote{Le protocole ICMP pour \emph{Internet Control
    Message Protocol}.}, d'obtenir un écho d'une machine distante, et
ainsi de savoir si elle est susceptible de pouvoir échanger des
informations avec la vôtre. Sa syntaxe est la suivante :
\begin{flushleft}
  \quad\ttfamily ping \comarg{machine\_distante}
\end{flushleft}
Par exemple 
\begin{shellcom}
  ¢usercom«ping ftp.lip6.fr»
  ftp.lip6.fr is alive
\end{shellcom}


\subsubsection{host}


\com{host} permet d'obtenir l'adresse IP d'une machine d'après son nom
et inversement. La syntaxe est :
\begin{comsyntax}
  host \comarg{nom\_machine\ {\normalfont ou} adr\_IP\_machine} 
\end{comsyntax}
Par exemple pour la résolution directe :
\begin{shellcom}
  ¢usercom«host ayler.freejazz.fr»
  ayler.freejazz.fr has address 145.23.6.5
\end{shellcom}
Et pour la résolution inverse :
\begin{shellcom}
  ¢usercom«host 145.23.6.5»
  5.6.23.145. IN-ADDR.ARPA domain name pointer ayler.freejazz.fr
\end{shellcom}
\begin{gnuposix}
  On trouvera dans les commandes \com{nslookup} et \com{dig} des
  fonctionnalités plus évoluées. La dernière est plus simple
  d'utilisation que la première et permet une meilleure intégration
  dans les scripts shell.
\end{gnuposix}

\subsubsection{traceroute}

\com{traceroute} est un utilitaire permettant d'obtenir la liste des
machines relais (passerelles) qui interviennent sur le trajet des
informations qui transitent de votre machine vers une machine
distante. Sa syntaxe est :
\begin{comsyntax}
  traceroute \comarg{machine\_distante}
\end{comsyntax}
Par  exemple :
\begin{shellcom}
  ¢usercom«traceroute www.mekanik.org»
  1  ghost-lan (182.16.1.254)  1.15 ms *  0.91 ms
  2  cisco (183.40.200.65)  2.96 ms  2.90 ms  2.85 ms
  3  all.jazz.net (183.38.56.245)  152.64 ms  21.48 ms  21.20 ms
  4  jazz.net (183.38.56.105)  25.12 ms  103.28 ms  247.98 ms
  5  jazz.net (183.38.56.105)  78.73 ms  25.23 ms  149.62 ms
  6  musik.fr (185.230.88.13)  192.93 ms 25.23 ms  149.62 ms
  7  intercon.musik.fr (124.57.254.123)  364.57 ms *  56.35 ms
  8  all.mekanik.org  (185.83.118.1)  144.20 ms  75.32 ms *
  9  www.mekanik.org (185.83.118.1) 52.02 ms 45.06 ms  49.07 ms
\end{shellcom}

\subsubsection{nslookup et dig}

La commande \com{nslookup} permet d'interroger un serveur de nom de
manière plus souple que la commande \com{host}. Un exemple succinct de
session avec \com{nslookup} serait :
\begin{shellcom}
  ¢usercom«nslookup»
  Default Server: dolphy.freejazz.fr  ¢comcomment«serveur de nom utilisé»
  Address:  145.23.65.13

  > ¢comans«ayler» ¢comcomment«qui est ¢texttt«ayler» ?»
  Default Server: dolphy.freejazz.fr  
  Address:  145.23.65.13
  ¢mbox«»
  Name:    ayler.freejazz.fr
  Address:  145.23.65.57
\end{shellcom}
Un aspect de \com{nslookup} qui peut être utile est qu'on peut obtenir
la liste des machines qui s'occupent du courrier pour un domaine donné
:
\begin{shellcom}
  > ¢comans«set query=MX»
  > ¢comans«zeuhl.org» ¢comcomment«demande d'info sur un domaine»
  Default Server: dolphy.freejazz.fr  
  Address:  145.23.65.13
  ¢mbox«»
  Non-authoritative answer:
  zeuhl.org      mail exchanger = zain.zeuhl.org
  ¢mbox«»
  Authoritative answers can be found from:
  zeuhl.org              nameserver = wortz.zeuhl.org
  wortz.zeuhl.org        internet address = 185.83.118.2
\end{shellcom}
\index{mail!machine relais (MX)}%
Ici on demande à \com{nslookup} de renvoyer des informations
concernant le \emph{mail exchanger} (MX). La réponse illustre le fait
que le DNS utilise un système de cache : il y a en effet une réponse «
qui ne fait pas autorité » (\anglais{non authoritative}), celle de
  \texttt{dolphy}, qui est dans le cache du serveur du domaine
  local. Il est d'autre part mentionné que l'on peut avoir une réponse
  « qui fait autorité » (c'est-à-dire digne de confiance) en utilisant
  expressément le serveur de nom du domaine \texttt{zeuhl.org} dont
  l'adresse est indiquée.

Le même type de requêtes peut être effectué à l'aide de la commande
\com{dig}. Par exemple :
\begin{shellcom}
  ¢usercom«dig dolphy.freejazz.fr»
  [...snipsnip...]
  ;; ANSWER SECTION:
  nephtys.lip6.fr.        21184   IN      A       195.83.118.1

  ;; Query time: 42 msec
  ;; SERVER: 212.27.53.252#53(212.27.53.252)
  [...snipsnip]
\end{shellcom}
Pour rendre \com{dig} moins bavarde on peut utiliser l'option
\texttt{+short} :
\begin{shellcom}
  ¢usercom«dig +short dolpy.freejazz.fr»
  145.23.65.13
\end{shellcom}
La résolution inverse se fait à l'aide de l'option \texttt{-x} :
\begin{shellcom}
  ¢usercom«dig +short -x 185.83.118.2»
  wortz.zeuhl.org
\end{shellcom}

%================================================================
%
% TROIS GRANDS CLASSIQUES 
%
%================================================================
\section{Quatre grands classiques}
\label{sec-com-4-class}


Comme toutes les applications réseau, les quatre grands classiques
que nous présentons dans cette section (\soft{ftp}, \soft{telnet},
\soft{rlogin} et \soft{ssh}) utilisent des protocoles d'échange de
données entre deux machines distantes,  basés sur l'architecture
suivante :
\begin{itemize}
\item le client est un programme tournant sur la machine locale. C'est
  l'utilitaire manipulé par l'utilisateur lui permettant d'effectuer
  des transferts de données ;
\item le serveur est un programme qui tourne sur la machine distante
  dont l'existence est généralement ignorée par l'utilisateur.
\end{itemize}

%================================================================
% ftp
%================================================================
\subsection{ftp}
\label{sec-com-ftp}
\index{fichier!transfert}
\index{transfert de fichier}

\soft{ftp} (\emph{file transfert protocol}) permet d'échanger des
fichiers entre deux machines du réseau.  L'application cliente permet
de se \emph{connecter} sur la machine distante et d'y déposer
(\emph{upload}) ou d'y récupérer (\emph{download}) des fichiers. Il
existe des clients graphiques pour effectuer les transferts, néanmoins
il est bon de connaître l'interface basique qui est une interface
texte. Sa syntaxe est la suivante :
\begin{comsyntax}
  ftp \comarg{machine\_distante}
\end{comsyntax}
Supposons qu'on dispose d'un compte \texttt{ftp} dont le login est
\texttt{albert} avec un mot de passe donné :
\begin{shellcom}
  ¢usercom«ftp ayler.freejazz.fr»
  Connected to ayler.freejazz.fr
  220- Salut garçon !
  Name (albert.freejazz.fr:stundher): ¢comans«albert» ¢comcomment«saisie du login»
  331 Password required for ayler.
  Password:¢comcomment«saisie du mot de passe»
  230 User albert logged in.
  Remote system type is UNIX.
  Using binary mode to transfer files.
\end{shellcom}
\index{arborescence!serveur ftp}
\index{connexion!ftp}
\begin{note}
  Dans l'échange entre le client et le serveur on notera qu'à chaque
  requête le serveur répond avec un code défini par le protocole (220
  : serveur prêt pour un nouvel utilisateur, 331 : utilisateur ok, mot
  de passe nécessaire, 230 : utilisateur connecté, etc.)
\end{note}
Une fois connecté on peut se déplacer dans l'arborescence du serveur
avec des commandes analogues à celle d'un shell \unix{} (\com{cd},
\com{ls}, \com{pwd}, etc.\footnote{Faire \com{help} pour avoir la
  liste des commandes disponibles.}) :
\begin{shellcom}
  ftp> ¢comans«cd transfert» ¢comcomment«changement de répertoire»
  250 CWD command successful.
  ftp> ¢comans«dir» ¢comcomment«liste de ce répertoire»
  200 PORT command successful.
  150 Opening ASCII mode data connection for directory listing.
  -rw-r-----   1 208      200       20241 Nov 20  2000 data.gz
  -rw-r-----   1 208      200        2946 Apr  5  2000 data.txt
  226 Transfer complete.
\end{shellcom}
Le transfert de fichier peut se faire dans deux modes :
\begin{itemize}
\item \emph{ascii} utilisé pour transférer des fichiers « texte » (ne
  contenant que des caractères Ascii) ; \textbf{attention} c'est
  généralement le mode par défaut des clients \texttt{ftp} en ligne de
  commande ;
\item \emph{binaire} utilisé pour transférer tout autre type de
  fichier, dans le doute on utilisera ce mode.
\end{itemize}
\index{transfert!binaire}
\index{transfert!ascii}
\index{ascii (transfert ftp)}
\index{binaire (transfert ftp)}
\begin{nota}
  Les deux modes de transfert (binaire ou Ascii) permettent de
  transférer correctement un fichier texte \unix{} vers un système
  Windows ou MacOs, et inversement. En effet, sur ces trois familles de
  système (\unix{}, MacOs et Windows) le caractère de saut de ligne
  est codé différemment : le caractère 13 pour \unix{}, le caractère
  10 pour MacOs, et le couple 13 et 10 pour Windows. Le mode Ascii
  tient compte de ces différences, tandis que le mode binaire récupère
  chacun des octets sans traitement particulier.
\end{nota}
On peut donc transférer un fichier en mode \emph{ascii} comme suit :
\begin{shellcom}
  ftp> ¢comans«get data.txt» ¢comcomment«récupération du fichier ¢texttt«data.txt»»
  local: data.txt remote: data.txt
  150 Opening ASCII mode connection for data.txt (2946 bytes).
  226 Transfer complete.
  2946 bytes received in 2.9 seconds (0.98 Kbytes/s)
\end{shellcom}
ou en mode \emph{binaire} :
\begin{shellcom}
  ftp> ¢comans«bin» ¢comcomment«passage en mode binaire»
  200 Type set to I.
  ftp> ¢comans«get data.gz»
  local: data.gz remote: data.gz
  200 PORT command successful.
  150 Opening BINARY mode connection for data.gz (20241 bytes)
  226 Transfer complete.
  20241 bytes received in 8.4 seconds (2.35 Kbytes/s)
\end{shellcom}
On peut alors mettre poliment\footnote{Certains serveurs peuvent
  d'ailleurs vous reprocher votre manque de politesse, si vous
  utilisez une autre commande...} fin à la connexion :
\begin{shellcom}
  ftp> ¢comans«bye»
  221 Goodbye.
\end{shellcom}
Les clients \texttt{ftp} disposent généralement des commandes
suivantes :
\begin{fwlitemize}{1cm}
\item[\com{mget}]: pour récupérer plusieurs fichiers en même temps ;
\item[\com{prompt}]: désactive les confirmations demandées à
  l'utilisateur lors d'un \com{mget} ;
\item[\com{hash}]: affiche un «\texttt{\#}» tous les kilo-octets pour
  indiquer l'avancement du transfert ;
\item[\texttt{!}\comarg{cmd}]: exécute \comarg{cmd} sur la machine
  locale ;
\item[...]
\end{fwlitemize}
Notez enfin que toutes ces commandes peuvent être abrégées
(\emph{e.g.} \texttt{prom} à la place de \texttt{prompt}).

\begin{note}
  Il est courant que des serveurs proposent des fichiers de manière
  publique. On appelle souvent ces serveurs des « serveurs ftp anonymes
  », car il n'est pas nécessaire d'avoir un compte pour se connecter
  sur ces machines. Tous les serveurs distribuant des logiciels libres
  proposent un accès anonyme. Dans ce cas :
  \begin{itemize}
  \item le login est : \texttt{ftp} ou \texttt{anonymous}
  \item le mot de passe : votre adresse électronique de manière à ce
    que l'administrateur du site puisse faire des statistiques.
  \end{itemize}
\end{note}
%================================================================
% telnet et rlogin
%================================================================
\subsection{telnet et rlogin}
\label{sec-com-telnet-rlogin}
\index{connexion!telnet}
\index{connexion!rlogin}

\soft{telnet} et \soft{rlogin} sont également des protocoles
client/serveur et proposent un service de connexion pour utiliser les
ressources (processeurs, mémoire, disque, etc.) d'une machine
distante. Cette dernière doit exécuter un serveur \texttt{telnet} ou
\texttt{rlogin} pour pouvoir proposer le service. Une session se
présente alors sous cette forme :
\begin{shellcom}[noendprompt]
  ¢usercom«telnet mekanik.zeuhl.org» ¢comcomment«nom de la machine distante»
  Trying 123.45.67.89...
  Connected to mekanik.zeuhl.org (123.45.67.89).
  Escape character is '^]'.

  Green Hat Linux release 16.0 (Klimt)
  Kernel 5.2.5-15smp on an i986

  login: ¢comans«stundehr» 
  passwd: ¢comcomment«saisie du mot de passe»
  mekanik:~> ¢comcomment«prompt de la machine distante»
\end{shellcom}
Notez qu'il faut bien sûr avoir un compte utilisateur sur la machine
distante.  Une fois connecté on dispose d'un terminal exécutant un
shell particulier ; on peut donc passer des commandes au système
distant.  Pour effectuer des connexions en mode graphique on se
reportera au paragraphe \ref{sec-conf-X-net}.  \index{commande!à
  distance}

\soft{rlogin} fonctionne de manière identique à \soft{telnet} à la
différence près qu'il considère que par défaut le login sur la machine
distante est le même que celui de la machine locale. Il permet en
outre d'utiliser un mécanisme de « confiance » permettant d'éviter de
saisir le mot de passe. Ainsi, si le répertoire privé de
l'utilisateur \texttt{stundehr} sur \texttt{ayler.freejazz.org} (la
machine distante), contient un fichier \texttt{.rhosts} :
\begin{fichier}[label=\~{}/.rhosts]
  # stundehr de mekanik.zeuhl.org est le bienvenu
  mekanik.zeuhl.org stundehr 
\end{fichier}
\index{rhosts@\texttt{.rhosts}}
on pourra alors se connecter sur \texttt{ayler} depuis
\texttt{mekanik} en tant qu'utilisateur \texttt{stundehr} sans avoir à
saisir ni login name, ni mot de passe :
\begin{shellcom}¢renewcommand«¢shellprompt»«stundehr@mekanik:~>»
  ¢usercom«rlogin ayler.freejazz.org»¢renewcommand«¢shellprompt»«stundehr@ayler:~>»
\end{shellcom}
Notez que l'on peut préciser un utilisateur différent pour
\com{rlogin} avec l'option~\texttt{-l}. Ainsi en étant
\texttt{albert} sur \texttt{ayler.freejazz.org}, on peut exécuter :
\begin{shellcom}[noendprompt]
  ¢usercom«rlogin -l stundehr mekanik.zeuhl.org»
\end{shellcom}
pour préciser qu'on tente de se connecter en tant qu'utilisateur
\texttt{stundehr}.


\subsection{Secure shell (ssh)}
\label{sec-ssh}

\index{connexion!ssh} Les deux commandes précédentes présentent un
inconvénient majeur : les transactions entre le serveur et le client
ne sont pas chiffrées ; il est ainsi possible à l'aide d'outils
spécialisés de voir passer en clair sur le réseau les commandes
tapées par l'utilisateur, et, nettement plus inquitétant, le mot de
passe saisi lors de l'initialisation de la connexion. C'est pourquoi
on utilise aujourd'hui la commande \com{ssh} permettant de mettre en
\oe uvre des transactions cryptées. La syntaxe est identique à celle
de \com{rlogin}. La commande suivante, par exemple, permet de se
connecter en tant qu'utilisateur \texttt{stundehr}.
\begin{shellcom}[noendprompt]
  ¢usercom«ssh -l stundehr mekanik.zeuhl.org»
  Password: 
\end{shellcom}
L'autre forme est :
\begin{shellcom}[noendprompt]
  ¢usercom«ssh stundehr@mekanik.zeuhl.org»
  Password: 
\end{shellcom}

% On notera cependant que \com{ssh} n'utilise pas le système de
% d'utilisateurs « de confiance », un mot de passe est donc toujours
% demandé à l'utilisateur.
\begin{nota}
  Si, pour différentes raisons, vous acceptez le fait de saisir un mot
  de passe pour vous connecter sur une machine distante, vous pouvez
  passer directement à la section suivante
  (\vref{sec-comm-outils}). Si vous souhaitez utiliser un mécanisme de
  confiance avec \com{ssh} et ainsi \emph{éviter d'avoir à saisir
    systématiquement un mot de passe}, on aura recours au principe de
  chiffrement\footnote{Le chiffrement d'un message est une technique
    de cryptographie permettant de le « brouiller »  pour le rendre
    illisible. La \emph{cryptographie}, quant à elle, est la science
    de l'échange des messages protégés.}  par clé publique.
\end{nota}
\begin{note}
Dans cette technique de cryptographie, on génère deux clés : une
\emph{publique} accessible par tous et une \emph{privée} qui doit être
gardée secrète. On peut alors procéder à deux opérations génériques :
\begin{description}
\item[Le chiffrement d'un message :] pour envoyer un message à un
  destinataire~$D$ on le chiffre avec la clé publique de~$D$. Ce
  dernier et lui seul pourra déchiffrer le message avec sa clé privée.
\item[La signature électronique :] l'expéditeur d'un message peut le
  signer avec sa clé privée. N'importe quel destinataire pourra
  s'assurer de l'origine de ce message grâce à la clé publique de celui
  qui prétend être l'expéditeur.
\end{description}
\end{note}
Pour mettre en application le chiffrement par clé publique dans le
cadre de \com{ssh}, on procède comme suit :
\begin{enumerate}
\item création du couple de clés privée et publique ;
\item diffusion de la clé publique vers les machines sur lesquelles on
  veut se connecter.
\end{enumerate}

Par la suite, une connexion sur une machine distante sera établie
après les étapes suivantes :
\begin{enumerate}
\item le client contacte le serveur en envoyant la clé ;
  publique\footnote{Rappelez-vous qu'on a déposé la clé publique sur
    ledit serveur...}  ;
\item le serveur examine si cette clé fait partie des clés
  autorisées. Dans l'affirmative il génère un nombre
  aléatoire~$\mathcal{A}$ qu'il chiffre avec la clé publique et qu'il
  envoie au client ;
\item étant donné que ce dernier est en possession de la clé privée il
  est le seul à pouvoir déchiffrer le message contenant le nombre
  $\mathcal{A}$. L'accès à la clé privée est généralement verrouillée
  par une phrase secrète (cf. plus bas) connue par son
  propriétaire. Elle pourra lui être demandée  lors de
  cette étape.  Finalement le client renvoie ce qu'il a déchiffré (qui
  doit correspondre au nombre $\mathcal{A}$) au serveur ;
  \label{etape-ssh-dechiffre}
\item le serveur compare la réponse du client\footnote{En réalité ce
    sont les signatures MD5 qui sont comparées.} au nombre qu'il a
  lui-même généré. Si et seulement si les deux informations sont
  identiques l'accès est autorisé.
\end{enumerate}

\subsubsection{Création du couple de clés}

On crée la clé privée et la clé publique grâce à la commande suivante :
\begin{shellcom}
  ¢usercom«ssh-keygen»
  Generating public/private rsa key pair.
  Enter file in which to save the key (/home/lozano/.ssh/id_rsa):
  Enter passphrase (empty for no passphrase): 
  Enter same passphrase again: 
  Your identification has been saved in /home/lozano/.ssh/id_rsa.
  Your public key has been saved in /home/lozano/.ssh/id_rsa.pub.
  The key fingerprint is:
  e2:bb:3b:82:56:da:34:02:d4:85:f3:b3:4b:b9:7b:1e stundehr@mekanik
  [...]
\end{shellcom}
\begin{nota}
  Dans la séquence ci-dessus, on doit saisir une « pass phrase » qui
  vous sera demandée à l'étape~\ref{etape-ssh-dechiffre} pour que le
  client accède à la clé privée. Il est possible ici de laisser cette
  phrase vide ; le client \com{ssh} aura alors accès à votre clé privée
  sans qu'on vous demande de mot de passe. Si une phrase secrète est
  saisie, il sera nécessaire de passer par un « agent ssh »
  (cf. \vref{sec-ssh-passphrase}) qui vous évitera de saisir cette
  phrase à chaque connexion.
\end{nota}
Votre répertoire contient désormais deux fichiers (la clé privée ne
doit bien évidemment être lisible que par vous) :
\begin{shellcom}
  ¢usercom«ls -1 ~/.ssh/id*»
  /home/stundehr/.ssh/id_rsa     ¢comcomment«la clé privée»
  /home/stundehr/.ssh/id_rsa.pub ¢comcomment«la clé publique»
\end{shellcom}
On peut bien sûr créer plusieurs couples de clés en précisant le nom
du fichier au moment de l'exécution de la commande \com{ssh-keygen}.

\subsubsection{Diffusion de la clé publique}

La diffusion de la clé publique consiste à déposer le contenu du
fichier correspondant dans le fichier \verb+~/.ssh/authorized_keys+ du
serveur sur lequel on veut se connecter. Il existe plusieurs méthodes
pour faire cette opération.  En supposant la configuration suivante :
\begin{center}
  \begin{tabular}{|c|l|}
    \hline
    \textsf{machine locale} & free.jazz.org \\
    \hline
    \textsf{utilisateur}    & ayler\\
    \hline
  \end{tabular}\quad\quad
  \begin{tabular}{|c|l|}
    \hline
    \textsf{machine distante} & cool.jazz.org \\
    \hline
    \textsf{utilisateur}    & miles\\
    \hline
  \end{tabular}
\end{center}
voici une méthode\footnote{La commande \com{scp} est présentée plus
  loin à la section~\vref{sec-communiquer-remote}.} qui fonctionne si le
fichier n'existe pas encore sur la machine \texttt{cool.jazz.org} :
\begin{shellcom}
  ¢usercom«scp ~/.ssh/id_rsa.pub miles@cool.jazz.org:~/clef.pub»
  miles@cool.jazz.org's password : 
  id_rsa.pub                 100%   396     1KB/s   00:00    
\end{shellcom}
Puis \emph{après s'être connecté sur le serveur
  \texttt{cool.jazz.org}}, il faut créer le répertoire \verb+~/.ssh+
et un fichier \texttt{authorized\_keys}\footnote{On suppose ici, par
  souci de clarté, que \texttt{\~{}/} est le répertoire de travail.} : 
\begin{shellcom}
  ¢usercom«mkdir .ssh»
  ¢usercom«chmod go-rwx .ssh»
  ¢usercom«mv clef.pub .ssh/authorized_keys»
\end{shellcom}
Si le fichier existe déjà, on remplacera la dernière commande par :
\begin{shellcom}
  ¢usercom«cat clef.pub >> .ssh/authorized_keys»
  ¢usercom«rm clef.pub»
\end{shellcom}
qui \emph{ajoute} au fichier \texttt{authorized\_keys} le contenu de
la clé publique copiée sur le serveur. Pour les « r3b3lz », on peut aussi
exécuter la commande depuis le client :
\begin{shellcom}
  ¢usercom«ssh miles@... < ~/.ssh/id_rsa.pub "cat - >> ~/.ssh/autorized_keys"»
\end{shellcom}
Cette commande (dans laquelle j'ai remplacé le nom de la machine
distante par~«[...]») exécute sur le serveur distant la commande :
\begin{verbatim}
  cat - >> ~/.ssh/authorized_keys
\end{verbatim}
qui elle, attend sur son entrée des données qui seront ajoutées au
fichier situé à droite de l'opérateur « append »~\verb+>>+. Ces données
attendues sont envoyées sur l'entrée de la commande \com{ssh} qui les
transmet au serveur.
\begin{note}
  Au moins sur la distribution Ubuntu, toutes ces solutions peuvent
  être automatisées grâce à un script shell connu sous le nom
  \com{ssh-copy-id} qui prend en argument le login et la machine
  distante sur laquelle on veut copier la clé publique.
\end{note}
\subsubsection{Déverouillage de la phrase secrète}
\label{sec-ssh-passphrase}

Si vous avez suivi jusqu'ici, que vous \emph{avez saisi une « pass phrase »
non vide} au moment de la création des clés, alors lors d'une connexion
\com{ssh} sur la machine distante vous avez dû obtenir :
\begin{shellcom}
  ¢usercom«ssh miles@cool.jazz.org»
  Enter passphrase for key '/home/ayler/.ssh/id_rsa': 
\end{shellcom}
Ce qui, je vous entends le dire \emph{in petto}, ne nous avance
guère... C'est vrai : nous étions censés simplifier la connexion
\soft{ssh} et « voilatipa » qu'on nous demande un mot de passe !
C'est ici qu'intervient la notion d'« agent ssh » un logiciel qui
garde trace des clés utilisées pendant une session.
\begin{gnuposix}
  Je ne rentrerai pas ici dans les détails de l'installation ou du
  lancement d'un agent ssh. La plupart des distributions en lance un
  (sous le nom \com{ssh-agent}) au moment du lancement de la
  session~X. L'environnement Gnome pour ne pas le citer, lance même
  son propre gestionnaire de clés (\soft{gnome-keyring-daemon}).
\end{gnuposix}
Lorsque l'agent ssh est actif, on peut lui demander gentiment d'ajouter dans son
« trousseau » notre clé privée :
\begin{shellcom}
  ¢usercom«ssh-add»
  Enter passphrase for /home/ayler/.ssh/id_rsa: 
  Identity added: /home/ayler/.ssh/id_rsa (/home/ayler/.ssh/id_rsa)
\end{shellcom}
Sans argument cette commande demande le déverrouillage de la clé
correspondant au fichier \verb+~/.ssh/id_rsa+.
\begin{center}\small\textit
  À partir de maintenant et jusqu'à la fin de la session,\\
  vous devriez pouvoir vous connecter sur votre serveur\\
  sans saisir de mot de passe {\tiny(ouf...)}
\end{center}
\framasautdepage
Quelques petites choses que vous aimeriez faire :
\begin{itemize}
\item lister les clés gérées par l'agent : \texttt{ssh-add -l} ;
\item effacer toutes les clés mémorisées par l'agent : \texttt{ssh-add -D} ;
\item changer la phrase secrète associée à une clé :
  \begin{flushleft}
    \ttfamily ssh-keygen -p -P\argument{ancienne} -N\argument{nouvelle}
    -f \argument{fichier}
  \end{flushleft}
  remplace l'\argument{ancienne} phrase par une \argument{nouvelle}
  pour la clé privée stockée dans le \argument{fichier}.
\end{itemize}
\begin{nota}
  Pour avoir accès à vos serveurs préférés par \com{ssh} sans avoir à
  saisir de mot de passe, il vous faudra :
  \begin{enumerate}
  \item distribuer votre clé publique sur chacun des serveurs ;
  \item déverrouiller votre clé secrète en début de chaque  session.
  \end{enumerate}
  \continuenota%
  Certains agents vous permettent de ne faire qu'une fois pour toute
  la deuxième opération, d'autres vous obligent à modifier le
  démarrage de votre session pour automatiser ce déverrouillage.
\end{nota}



% ================================================================
%
% OUTILS DE COMMUNICATION
%
% ================================================================

\section{Outils de communication d'Unix}
\label{sec-comm-outils}
Voici quelques outils qu'on retrouve sur un système \unix. Dans la
mesure où ces outils autorisent les utilisateurs à agir sur des machines
distantes, il est possible que certains de ces services ne soit pas
disponibles, pour des raisons de sécurité, sur les systèmes où le
lecteur les testera.

% ================================================================
% who
% ================================================================
\subsection{who}
\index{utilisateur!liste des}

\com{who} permet d'obtenir la liste des utilisateurs connectés sur le
système. Il s'agit des utilisateurs connectés sur la console (l'écran
situé physiquement à coté de la machine), ou par \soft{telnet}, ou par
\soft{rlogin}, etc.
\begin{shellcom}
  ¢usercom«who»
  albert       console      Mar 20 17:04
  albert       pts/0        Mar 20 17:04
  stundehr     ttyp1        Mar 20 17:28
\end{shellcom}
La deuxième colonne indique les terminaux où sont connectés les
utilisateurs \texttt{albert} et \texttt{stundehr}. Cette commande peut
aussi indiquer si l'utilisateur est connecté à distance sur le système
et le cas échéant la machine depuis laquelle il est connecté.
\begin{note}
  On trouve parfois la commande \com{rwho} qui indique quels
  utilisateurs sont connectés sur les machines \unix{} du réseau
  local. L'avantage de cette commande réside dans le fait qu'il n'est
  pas nécessaire de se connecter sur une machine pour savoir quels
  autres utilisateurs l'utilisent.
\end{note}


\subsection{Changer d'identité}
\label{sec-su}
\index{utilisateur!changer d'}

La commande \com{su} permet de devenir un autre utilisateur. Il faut
bien sûr connaître son mot de passe :
\begin{comsyntax}
  su \comarg{user}
\end{comsyntax}
Par exemple en étant connecté en tant qu'utilisateur \texttt{albert}, on
peut faire :
\begin{shellcom}
  ¢usercom«su stundehr»
  Password: ¢comcomment«saisie du mot de passe de stundehr»
\end{shellcom}
on « devient » alors l'utilisateur \texttt{stundehr}. C'est-à-dire
qu'on lance un shell en tant que \texttt{stundehr}. Notez qu'en
faisant :
\begin{shellcom}
  ¢usercom«su - stundehr»
  Password:
\end{shellcom}
le shell lancé est alors un \voir{sec-shell-demarrage}{shell de
  connexion} (\emph{login shell}).

% ================================================================
% write
% ================================================================
\subsection{write}

\index{messages console}

\com{write} envoie un message particulier sur le terminal d'un
utilisateur :
\begin{shellcom}
  ¢usercom«write stundehr»
  bonjour mon gars
  ¢comcomment«Ctrl-d pour finir le message»
\end{shellcom}
Un utilisateur peut être spécifié sous la forme
\comarg{user}@\comarg{machine}, s'il est connec\-té sur une machine
distante. En outre tout utilisateur peut désactiver la réception de
message avec la commande :
\begin{shellcom}
  ¢usercom«mesg n»
\end{shellcom}
et :
\begin{shellcom}
  ¢usercom«mesg y»
\end{shellcom}
pour la réactiver.

% ================================================================
% finger
% ================================================================
\subsection{finger}
\index{utilisateur!informations}

\com{finger} renvoie les informations de connexion d'un utilisateur
donné sur une machine donnée. Ces informations concernent l'utilisateur
lui-même (nom d'état civil, répertoire de travail, shell de
connexion), ses dernières connexions, s'il a lu son mail, et plein
d'autres choses. La syntaxe est :
\begin{comsyntax}
  finger \comarg{utilisateur}@\comarg{machine}
\end{comsyntax}
Si \comarg{utilisateur} dispose dans son répertoire racine sur
\comarg{machine}, des fichiers \texttt{.plan} ou \texttt{.project}, leur
contenu est alors affiché par la commande \com{finger}. On peut donc
mettre dans ces fichiers des informations qu'on désire diffuser
(comme ses coordonnées par exemple). Si l'utilisateur utilise un
fichier  \voir{sec-com-forward}{\texttt{.forward}}, son contenu est
également affiché par \com{finger}. Voici un exemple :
\begin{shellcom}
  ¢usercom«finger bidule@machine.distante.fr»
  Login: bidule                    Name: Machin Bidule
  Directory: /home/bidule          Shell: /bin/bash
  On since Mon Apr 30 10:32 (CEST) on pts/1 from :0.0
     22 minutes 10 seconds idle
  On since Mon Apr 30 09:23 (CEST) on pts/2 from :0.0
  On since Mon Apr 30 10:55 (CEST) on pts/3 from :0.0
     2 minutes 50 seconds idle
  No mail.
  No Plan.
\end{shellcom}
Étant notoirement faible sur le plan de la sécurité, le serveur
\com{finger} est souvent désactivé sur les machines.

% ================================================================
% talk
% ================================================================

\subsection{talk}
\index{discussion en réseau}

\newcommand{\machineutil}[2]{%
  \begin{flushleft}\footnotesize
    \makebox[2cm][l]{Utilisateur }: \texttt{#1}\\
    \makebox[2cm][l]{Machine }: \texttt{#2}
  \end{flushleft}}

\com{talk} ---~comme son nom l'indique~--- permet de « parler » avec un
autre utilisateur sur la même machine ou sur une machine distante. Une
fois la commande lancée, la fenêtre du terminal est divisée en deux
parties, et chaque utilisateur voit ce que tape l'autre en temps
réel\footnote{Plus précisément, à la vitesse autorisée par le débit
  du réseau.}. Pour initier une discussion, il est nécessaire que les
deux protagonistes lancent la commande \com{talk}, dont la syntaxe est :
\begin{comsyntax}
  talk \comarg{utilisateur}@\comarg{machine}
\end{comsyntax}
Ainsi :
\begin{itemize}
\item \makebox[4cm][l]{l'un (\texttt{stundehr}) lance} : \texttt{talk
    albert@ayler.freejazz.org}
\item \makebox[4cm][l]{l'autre (\texttt{albert})} : \texttt{talk
    stundehr@mekanik.zeuhl.org}
\end{itemize}
Après quelques secondes, une fois la connexion établie, chacun des
utilisateurs a devant les yeux un écran où chacun voit le texte de
l'autre dans la partie inférieure :
\begin{center}
\begin{minipage}{.48\textwidth}
    \machineutil{albert}{ayler.freejazz.fr}
  \begin{center}
\begin{Verbatim}[commandchars=\\\{\},frame=single]
Salut stundehr !\rule{1ex}{1.65ex}



------------------------------




\end{Verbatim}
  \end{center}
\end{minipage}
\begin{minipage}{.48\textwidth}
\machineutil{stundehr}{mekanik.zeuhl.org}
\begin{center}
\begin{Verbatim}[commandchars=\\\{\},frame=single]




------------------------------
Salut stundehr !\rule{1ex}{1.65ex}



\end{Verbatim}
\end{center}
\end{minipage}
\end{center}
\texttt{stundehr} peut alors répondre à son tour :
\begin{center}
\begin{minipage}{.48\textwidth}
  \machineutil{albert}{ayler.freejazz.fr}
  \begin{center}
  \begin{Verbatim}[commandchars=\\\{\},frame=single]
Salut stundehr !



------------------------------
Salut albert !\rule{1ex}{1.65ex}



\end{Verbatim}
\end{center}
\end{minipage}
\begin{minipage}{.48\textwidth}
  \machineutil{stundehr}{mekanik.zeuhl.org}
\begin{center}
\begin{Verbatim}[commandchars=\\\{\},frame=single]
Salut albert !\rule{1ex}{1.65ex}



------------------------------
Salut stundehr !



\end{Verbatim}
\end{center}
\end{minipage}
\end{center}
Le caractère \texttt{EOF} (généralement \texttt{Ctrl-d}) met fin à la
session, et la combinaison \texttt{Ctrl-l} rafraîchit l'écran, ce qui
est parfois utile.  %\FrenchItemizeSpacingfalse \FrenchListSpacingfalse

%======================================================
% Les r commandes
%======================================================
\subsection{« remote » commandes}
\label{sec-communiquer-remote}

\index{commande!à distance}

Nous avons déjà vu une commande de la famille « \texttt{r} »
(\texttt{r} pour \emph{remote} c'est-à-dire « à distance ») :
\com{rlogin}.  Il existe deux autres commandes de ce type : \com{rcp}
permettant de copier un fichier sur (ou depuis) une machine et
\com{rsh} pour lancer un shell distant.
\begin{attention}
  Aujourd'hui il est vivement déconseillé d'utiliser ces commandes
  pour des raisons de sécurité car toutes les informations transitent
  en clair sur le réseau. Nous présenterons donc leurs équivalents
  sécurisés à savoir \com{scp} et \com{ssh}.
\end{attention}

\begin{itemize}
\item \com{scp} permet de copier un fichier d'une machine à une autre
  :
  \begin{comsyntax}
    \com{scp} \comarg{utilisateur}@\comarg{machine}:\comarg{fichier} \comarg{fichier\_dest}
  \end{comsyntax}
  Par exemple :
  \begin{shellcom}
    ¢usercom«rcp ayler@mekanik.zeuhl.org:/home/ayler/ghost.mp3 .» 
  \end{shellcom}
\item \com{ssh} permet ---~en plus de la connexion présentée au
  \S~\ref{sec-ssh}~--- de lancer une commande sur une machine
  distante. La syntaxe est :
  \begin{comsyntax}
    \com{ssh} \comarg{machine} \comarg{commande}
  \end{comsyntax}
  Par exemple :
  \begin{shellcom}
    ¢usercom«ssh mekanik.zeuhl.org ls -l»
    -rw-r-----   1 albert  sax    199 Sep  1  2000 ghost.mp3
    -rwxr-----   1 albert  sax     61 May  4  2000 
    -rwxr-----   1 albert  sax     77 May  4  2000 
  \end{shellcom}
\end{itemize}
On peut noter qu'à l'instar de la commande \com{rlogin}, les commandes
\com{ssh} et \com{scp} acceptent l'option~\texttt{-l} permettant de
spécifier un autre utilisateur pour la connexion.


%================================================================
%
% COURRIER ÉLECTRONIQUE
%
%================================================================
%\enlargethispage{30cm}
\section[Courrier électronique]{Le courrier
  électronique\footnotemark}
\footnotetext{Le mél comme disent les académiciens, le
  courriel comme disent les Québécois, l'e-mail comme disent les
  anglophones, le mail comme disent les Français.}
\label{sec-com-mail}
\index{courrier électronique|see{mail}}
\index{mail|(}

Bien qu'il existe de nombreux logiciels de lecture de mail sous
\unix{}\footnote{Pour s'en assurer, on peut faire une recherche sur
  le site \url{http://sourceforge.net}.}, il est
bon de connaître les outils de base que propose \unix{} pour pouvoir
lire son courrier simplement en lançant une session \com{ssh} sur
la machine sur laquelle vous recevez votre courrier.
%\clearpage
%=====================================================
% format des adresses
%=====================================================
\subsection{Format des adresses}
\label{sec-mail-adr}
\index{mail!adresses électroniques}
\index{adresse!électronique}

Une boîte aux lettres électronique est identifiée par une adresse de la
forme :
\begin{comsyntax}
  \comarg{nom}@\marg{domaine}
\end{comsyntax}
La partie \comarg{domaine} peut désigner une machine existante, mais la
plupart du temps désigne un domaine générique, comme par exemple dans
:
\begin{comsyntax}
  bart@uchicago.edu
\end{comsyntax}
\texttt{uchicago} est un nom de domaine et non de machine. De manière
analogue, la partie \comarg{nom} de l'adresse électronique ne
correspond pas nécessairement à un utilisateur du système distant,
ainsi l'utilisateur \texttt{zappa} qui a un compte \unix{} sur une
machine du domaine \texttt{uncleme.at} peut avoir l'adresse suivante :
\begin{comsyntax}
  frank@uncleme.at
\end{comsyntax}
On peut trouver également la forme :
\begin{comsyntax}
  Frank Zappa <franck@uncleme.at>
\end{comsyntax}
forme permettant de rajouter des fantaisies autour d'une adresse
existante, tant que les fantaisies en question se limitent à l'extérieur
des \texttt{<} et \texttt{>}.


%=====================================================
% mua
%=====================================================
\subsection{Mail user agents}
\label{sec-mail-user-agent}
\index{mail!mail user agent}
\index{mail!mail transport agent}
\index{mail!logiciel de}
\index{mail!MTA}
\index{mail!MUA}
\index{MTA}
\index{MUA}
Parmi l'ensemble des logiciels utilisés sous \unix{} pour acheminer le
courrier existent deux familles :
\begin{itemize}
\item les \emph{mail transport agents} (MTA) : les logiciels chargés
  d'acheminer le courrier d'une machine à une autre ; on peut faire
  l'analogie avec le facteur ou la poste qui délivre les courriers dans
  les boîtes ;
\item les \emph{mail user agents} (MUA) : logiciels destinés à l'utilisateur
  permettant à la fois de consulter sa boîte aux lettres, et d'envoyer
  des courriers (au mail transport agent qui fait suivre).
\end{itemize}
En tant qu'utilisateur \unix{}, on est confronté à la deuxième
catégorie, la première étant réservée aux tâches d'administration
système. Il existe sous \unix{} une multitude de logiciels de messagerie
utilisateur, le plus commun est \com{mail}. Ce \com{mail} existe
également sous d'autres variantes \com{Mail} et \com{mailx}. Tous ces
utilitaires ont des syntaxes généralement légèrement différentes selon
les systèmes\footnote{Nous vous invitons donc à compulser les pages
  de manuels traitant de ces utilitaires.}. Toujours est-il que le
principe est souvent le suivant, pour envoyer un mail à
\texttt{franck@uncleme.at} :
\begin{shellcom}
  ¢usercom«mail franck@uncleme.at»
  Subject: ¢comans«Dental floss»
  ¢usercomwop«Hi.»
  . ¢comcomment«Un point seul sur une ligne pour envoyer le message»
\end{shellcom}
En ayant déjà rédigé le message dans un éditeur de texte (\emacs{}
pour ne pas le nommer), on peut directement utiliser les
\voir{sec-pipe}{redirections}\footnote{Comme indiqué précédemment la
commande \com{mail} utilisée ici accepte l'option \texttt{-s} ce qui
n'est pas toujours le cas sur un système autre que \linux{}. On
s'orientera dans ce cas vers la commande \com{mailx}.} :
\begin{shellcom}
  ¢usercom«cat tofranck»
  Hi.
  Jazz is not dead,
  It just smells funny.
  ¢usercom«mail -s "Dental floss" franck@uncleme.at < tofranck»
\end{shellcom}
Certains logiciels proposent l'option \texttt{-c} pour positionner le
champ \texttt{CC:} (copie carbone), et bien d'autres encore. Par
exemple \soft{mutt} (\url{http://www.mutt.org}) utilise l'option
\texttt{-a} pour attacher un fichier. Et :
\begin{shellcom}
  ¢usercom«mutt -a arf.jpg -s "Blow j." franck@uncleme.at < tofranck»
\end{shellcom}
où \texttt{arf.jpg} est une image au format Jpeg qui sera envoyée sous
forme d'attachement.

\subsection{Faire suivre son courrier}
\label{sec-com-forward}
\index{mail!faire suivre}


Il arrive souvent d'avoir des comptes sur plusieurs machines \unix{}.
Dans ce cas on peut vouloir ne relever qu'une boîte aux lettres. Pour
ce faire il est nécessaire de faire suivre le courrier destiné aux
autres boîtes sur la seule boîte que l'on veut consulter. On utilise
alors un fichier nommé \texttt{.forward} qui doit se situer dans le
répertoire privé. Par exemple : \index{forward@\texttt{.forward}}
\begin{fichier}[label=\~{}/.forward]
  albert@ayler.freejazz.fr
\end{fichier}
permet de faire suivre tout courrier arrivant sur la machine concernée
à l'adresse \texttt{albert@ayler.freejazz.fr}. Si l'utilisateur
(\texttt{stundher}) utilisant ce \texttt{.forward} souhaite également
conserver une copie sur la machine, il peut ajouter une ligne à son
fichier :
\begin{fichier}[label=\~{}/.forward]
  \stundehr
  albert@ayler.freejazz.fr
\end{fichier}
Notez l'utilisation du \verb+\+ pour éviter une récursion sans fin.
%\verb+\+

\begin{attention}
  Tout ce qui est raconté ici au sujet de l'acheminement du courrier à
  l'aide du fichier \texttt{.forward} ne sera effectif que si la
  machine \unix{} du réseau local sur laquelle on crée le
  \texttt{.forward} est effectivement la machine qui reçoit le
  courrier et que le MTA de cette machine utilise le mécanisme du
  \texttt{.forward}.
\end{attention}

\index{mail|)}


%================================================================
%
% WWW
%
%================================================================
\section{Le ouèbe}
\index{World wide web|see{www}}
\index{www|(}

De manière analogue à ce qu'il a été dit précédemment sur le courrier
électronique, il existe de nombreux navigateurs web très intuitifs
comme \soft{Netscape}, \soft{Mozilla}, \soft{Opera}, pour ne citer que
les plus connus. Le but de ce paragraphe est la présentation d'outils
particuliers ne présentant pas d'interface graphique, mais ayant un
intérêt évident.

%================================================================
% format des adresses
%================================================================
\subsection{Format des adresses}
\label{sec-url}
\index{uniform resource locator}
\index{url}
\index{adresse!web (url)}
\index{www!adresse (url)}

Le standard pour localiser une ressource sur le réseau est
l'\emph{uniform resource locator} ou URL, ou encore « localiseur
uniforme de ressources », sa forme la plus simple est toujours :
\begin{comsyntax}
  \marg{protocole}://\comarg{machine}/\comarg{fichier}
\end{comsyntax}
Par exemple dans l'url :
\begin{comsyntax}
  http://www.freejazz.fr/dolphy/horns/bassclarinet.jpg
\end{comsyntax}
le protocole est \texttt{http} (\emph{hypertext transfert protocol}, le
protocole de transfert hypertexte utilisé sur le Web), la machine
est~\texttt{www.freejazz.fr}, et le fichier désigne une image
nommée~\texttt{bassclarinet.jpg} dans le répertoire~\texttt{dolpy/horns}.
De même :
\begin{comsyntax}
  ftp://ftp.lip6.fr/pub/Linux/Readme
\end{comsyntax}
désigne le fichier \texttt{Readme} stocké dans le répertoire
\texttt{pub/Linux} de la machine dont le nom est \texttt{ftp.lip6.fr}
et accessible via \texttt{ftp}.


%=====================================================
% wget
%=====================================================
\subsection{Wget l'aspirateur}
\label{sec-wget}
\index{aspirer un site web}
\index{www!aspirer un site}

\soft{wget} est un utilitaire du projet \gnu{} permettant le
téléchargement de fichiers en utilisant le protocole \texttt{ftp} ou
\texttt{http}.  \soft{wget} effectue ces téléchargements sans
intervention de l'utilisateur et en suivant éventuellement des liens
ou les sous-répertoires d'un serveur web ou ftp :
\begin{shellcom}[noendprompt]
  ¢usercom«wget http://www.freejazz.fr/dolphy/bassclarinet.jpg»
\end{shellcom}
téléchargera le fichier \verb+bassclarinet.jpg+.  Mais cet utilitaire
est particulièrement utile pour télécharger plusieurs fichiers. Par
exemple pour aspirer tout ou partie d'un site ouèbe, on pourra écrire
:
\begin{shellcom}[noendprompt]
  ¢usercom«wget -r -l1 http://www.bidule.fr/machin/chose»
\end{shellcom}
qui sauvera : 
\begin{enumerate}
\item le fichier \texttt{index.html} du répertoire
  \texttt{machin/chose} ;
\item tous les liens apparaissant dans ce fichier \texttt{index.html}
  ; c'est la signification des options \texttt{-r} (récursif) et
  \texttt{-l1} lien de « niveau~1 ».
\end{enumerate}
En lançant :
\begin{shellcom}[noendprompt]
  ¢usercom«wget -r -l2 http://www.bidule.fr/machin/chose»
\end{shellcom}
on télécharge également les liens apparaissant dans les pages
mentionnées dans le fichier \texttt{index.html} (liens de « niveau 2 »).
\begin{attention}
  Lors de l'utilisation de l'option \texttt{-r} pour suivre
  récursivement les liens jusqu'à un niveau donné, il est souvent utile
  de demander à \soft{wget} de ne pas remonter au répertoire
  parent. Dans l'exemple précédent, ceci permet de se cantonner au
  répertoire \texttt{machin/chose} et ses descendants. On formule ce
  souhait à l'aide de l'option~\texttt{-np} ou \verb+--no-parent+.
\end{attention}
Pour finir avec cette courte introduction à \soft{wget}, il n'est pas
inutile de noter l'usage qui suit. Supposons que la page désignée
par :
\begin{verbatim}
  http://www.truc.fr/machin/chose.html
\end{verbatim}
contient des liens sur des images au format Jpeg  portant
l'extension~\texttt{jpg}, alors la commande :
\begin{shellcom}
  ¢usercom«wget -r -l1 -Ajpg http://www.truc.fr/machin/chose.html»
\end{shellcom}
récupérera uniquement ces fichiers à l'exception de tous les autres
liens de la page nommée \texttt{chose.html}. 

Notons que pour les commandes transférant plusieurs fichiers,
\soft{wget} créera de lui-même sur la machine locale, un répertoire
pour la machine hôte contenant le cas échéant, d'autres répertoires
apparaissant dans l'url. Pour éviter cela, on pourra faire appel aux
options :
\begin{itemize}
\item \texttt{-nH} ou \verb+--no-host+ pour ne pas créer de répertoire
  correspondant à la machine hôte ;
\item \texttt{-nd} ou \verb+--no-directories+ pour ne pas créer de
  répertoire du tout ;
\item \verb+--cut-dirs+=\comarg{nombre} pour éviter de créer
  \comarg{nombre} niveaux dans l'arborescence de répertoires.
\end{itemize}
Par exemple :
\begin{shellcom}[noendprompt]
  ¢usercom«wget -nH --cut-dirs=1 -r -l1
     http://www.freejazz.fr/dolphy/horns/»
\end{shellcom}
créera le répertoire \verb+horns+ dans le répertoire courant pour y
sauver les fichiers aspirés.

Comme la plupart de ces utilitaires « ne faisant qu'une chose mais le
faisant bien », on trouvera une foultitude d'options diverses et variées
permettant d'arriver à ses fins quelle que soit l'exigence de la
requête.

\begin{note}
  D'autres utilitaires effectuant le même type de tâche
  existent. Parmi eux les logiciels \soft{curl} et \soft{lftp}
  disponibles chez votre crémier le plus proche.
\end{note}

%================================================================
% lynx
%================================================================
\subsection{Lynx l'extraterrestre}
\label{sec-lynx}
\index{www!naviguer en mode texte}

\soft{lynx} (jeu de mots d'informaticiens anglophones sur \emph{links},
les liens) est un butineur de la toile (\emph{web browser}) en mode
texte. Le propos de \soft{lynx} est de compulser des pages au format
html. Ce browser peut être utile dans les situations où l'utilisateur
veut éviter de lancer les logiciels habituels gourmands en ressources,
ou simplement lorsque l'environnement courant ne permet pas d'utiliser
le mode graphique.  L'utilisation de \soft{lynx} est simple :
\begin{itemize}
\item « flêche bas » : lien suivant dans la page ;
\item « flêche haut » : lien précédent ;
\item « flêche droit » : suivi du lien ;
\item « flêche gauche » : dernier lien dans l'historique  ;
\end{itemize}
En outre les touches :
\begin{itemize}
\item d : permet de télécharger (\emph{download}) un fichier désigné
  par le lien courant ;
\item z : permet d'interrompre le téléchargement ;
\item g : permet d'aller (\emph{go}) vers une autre url ;
\item q : permet de  quitter.
\end{itemize}
\soft{lynx} possède une aide en ligne très complète qu'on peut
consulter en pressant la touche ?, et un site web
\url{www.lynx.org}. Ainsi pour consulter le site
\url{www.opensource.org}, on tapera :\framaallongepage{2}
\begin{shellcom}[noendprompt]
  ¢usercom«lynx www.opensource.org»
\end{shellcom}
On peut également se connecter par ftp sur une machine en utilisant le
format particulier des url :
\begin{shellcom}[noendprompt]
  ¢usercom«lynx ftp://stundehr@mekanik.zeuhl.org»
\end{shellcom}
dans l'hypothèse où l'on dispose d'un compte dont le login est
\texttt{stundehr} sur la machine \texttt{mekanik.zeuhl.org}.
\index{www|)}

\begin{note}
  Stéphane \textsc{Chazelas} me souffle que \soft{lynx} est dépassé et
  lourd. D'autres programmes existent permettant de naviguer en mode
  texte sur le ouèbe, comme \soft{w3m} et plus particulièrement
  \soft{elinks} ou \soft{links2}...
\end{note}

\section*{Conclusion}
\label{sec-com-conclusion}

Ce (court) chapitre a eu pour but de présenter les utilitaires ayant
trait à la communication sous \unix{}. Il est intéressant de noter que
tous les outils autour du transfert de données, de messagerie
instantanée ou différée, d'accés aux systèmes à distance, etc.
existent depuis longtemps et sont utilisables en mode texte. Ce
deuxième aspect qui pourrait paraître curieux à l'heure d'aujourd'hui,
assure à l'utilisateur la possibilité de manipuler des outils réseaux
légers s'il le souhaite, et surtout lui permet \emph{d'automatiser}
ses requêtes ce qui est l'objet du chapitre suivant.




%%% Local Variables: 
%%% mode: latex
%%% TeX-master: "../framabook"
%%% End: 
