Nous allons maintenant nous intéresser au flux d'informations qui se produit classiquement quand deux personnes communiquent par courrier électronique. Supposons qu'Alice, sur sa machine paysdesmerveilles.com veuille envoyer un courrier électronique à Bob, sur sa machine dobbs.com. Les deux machines sont connectées à l'Internet.
Tout d'abord il faut savoir qu'un courrier électronique est divisé en deux parties séparées par une ligne vide : les entêtes et le corps. Les entêtes contiennent la source et la destination du courrier, le sujet, la date d'envoi et d'autres informations utiles. Le corps est le contenu du message. Voici un exemple :
From: "Alice" <alice@paysdesmerveilles.com> Message-Id: <199711131704.MAA18447@paysdesmerveilles.com> Subject: Avez-vous vu mon lapin blanc ? To: bob@dobbs.com (Bob) Date: Thu, 13 Nov 1997 12:04:05 -0500 (EST) Content-Type: text Je suis extrêmement préoccupée. J'ai peur qu'il ait chuté dans un trou. -->>alice>>
La disposition et le sens des entêtes sont définis dans un standard Internet : RFC822.
Voici un diagramme du processus entier (j'en expliquerai ensuite toutes les étapes et la terminologie) :
+--------+ +--------+ +-------+ compose | | appelle | | | Alice |--------->| MUA |--------->| MTA |:::>::::: +-------+ |appelant| |appelant| :: sur la +--------+ +--------+ :: machine :: appelante ....................................................................... SMTP :: ::::::::::::::::::::::::::::<:::::::::::::::::::::::::::: :: :: +---------+ +-----+ +-------+ :: | | appelle | | distribue à | boîte | ::::>| MTA |--------->| LDA |===============>| de | sur la |recevant | | | | Bob | machine +---------+ +-----+ +-------+ recevante | | | | +----------------<-------------+ | | | +-----------+ +--------+ | | signaleur | | MUA de |<---------+ | de Bob | | Bob | +-----------+ +--------+ | | | +-----+ | +----->| Bob |<----+ +-----+
Pour envoyer un courrier, Alice se sert d'un programme appelé un agent d'utilisateur de courrier (ou MUA pour Mail User Agent). L'agent d'utilisateur de courrier est ce que l'utilisateur appellerait le « lecteur de courrier » ; il aide à composer le message, généralement en appelant l'éditeur de votre choix. Après avoir appuyé sur le bouton envoyer, Alice n'interviendra plus dans le processus. Plus tard dans ce HOWTO, nous examinerons les lecteurs de courriers les plus populaires.
L'agent utilisateur de courrier utilisé par Alice confie immédiatement son message à un programme appelé agent de transport de courrier (ou MTA pour mail transport agent)/. En général, ce programme sera sendmail, bien que quelques autres agents de transport deviennent de plus en plus populaire et puissent faire leur apparition dans de futures distributions Linux. Plus loin dans ce HOWTO, nous examinerons également le panorama des agents de transport.
Le travail de l'agent de transport est d'envoyer le courrier à l'agent de transport de la machine de Bob. Il trouve la machine de Bob en analysant l'entête To et en trouvant dobbs.com à la droite de l'adresse de Bob. Les mécanismes par lesquels s'effectue cette connexion sont un tout autre sujet ; dans le cadre de notre explication, retenez seulement que cette connexion est une manière pour l'agent de transport d'Alice d'envoyer des commandes textes à la machine de Bob et recevoir de réponses à ces commandes.
Les commandes de l'agent de transport ne vont pas dans un shell. À la place, elles sont dirigés vers un port de service sur la machine de Bob. Un port de service est une sorte de point de rendez-vous, une endroit fixe où un serveur écoute les requêtes entrantes. Les ports de service sont numérotés, et l'agent de transport de courrier d'Alice sait qu'il doit parler sur le port 25 de la machine de Bob pour envoyer le courrier.
Sur le port 25, la machine de Bob a son propre agent de transport qui écoute les commandes (probablement un autre sendmail). L'agent de transport d'Alice dialoguera avec celui de Bob en utilisant le protocole Simple Mail Transfer Protocol (ou SMTP). Voici à quoi un dialogue SMTP ressemble. Les lignes envoyées par la machine d'Alice sont marqués par un E:, celle de la machine de Bob par un R:.
E: MAIL FROM:<alice@paysdesmerveilles.com> R: 250 OK E: RCPT TO:<bob@dobbs.com> R: 250 OK E: DATA R: 354 Start mail input; end with <CRLF>.<CRLF> E: From: "Alice" <alice@paysdesmerveilles.com> E: Message-Id: <199711131704.MAA18447@paysdesmerveilles.com> E: Subject: Avez-vous vu mon lapin blanc ? E: To: bob@dobbs.org (Bob) E: Date: Thu, 13 Nov 1997 12:04:05 -0500 (EST) E: Content-Type: text E: E: Je suis extrêmement préoccupée. J'ai peur qu'il ait chuté dans un trou. E: -- E:>>alice>> E: . R: 250 OK
D'habitude, une commande SMTP est une simple ligne de texte, et il en va de même pour la réponse. La commande DATA est une exception : après avoir lu la commande DATA, le serveur SMTP accepte toutes les lignes jusqu'à qu'il voit une ligne ne contenant qu'un point. (SMTP est défini dans le RFC821.)
Arrivé à ce point, l'agent de transport de courrier de Bob a le message d'Alice. Il va ajouter un entête au message qui ressemble à quelque chose de ce genre :
Received: (from alice@paysdesmerveilles.com) by mail.dobbs.com (8.8.5/8.8.5) id MAA18447 for bob@dobbs.com; Thu, 13 Nov 1997 12:04:05 -0500
Cela permet de suivre les messages à la trace en cas d'erreur (parfois un message est relayé par plus d'un serveur et contiendra plusieurs entêtes de ce type). L'agent de transport de Bob enverra le message à un agent de distribution local (ou LDA pour local delivery agent). Sur les systèmes Linux, l'agent de distribution est souvent un programme appelé procmail, bien qu'il en existe d'autres.
Le travail de l'agent de distribution local est d'ajouter le message à la boîte aux lettres de Bob. Il est séparé de l'agent de transport pour que les deux programmes soient plus simples et pour que l'agent de transport puisse se concentrer sur la partie Internet du processus, sans avoir à se préoccuper des détails locaux comme de savoir où se trouvent les boîtes aux lettres des utilisateurs.
La boîte aux lettres de Bob sera normalement un fichier appelé
/usr/spool/mail/bob ou /var/mail/bob. Lorsque Bob lit
son courrier, il lance son propre agent d'utilisateur de courrier
qui regarde et édite ce fichier.
Un autre type de programme joue un rôle important dans la chaîne de distribution du courrier électronique, bien qu'il n'envoie pas ou ne lise pas de courrier. C'est le signaleur de courrier, un programme qui surveille votre boîte aux lettres et vous signale l'arrivée de chaque nouveau courrier électronique.
Le signaleur de courrier original était composé de deux programme Unix appelés biff(1) et comstat(8). Biff est une interface utilisateur de comstat qui vous permet d'activer le service comstat. Quand ce service est activé, l'entête des nouveaux courriers est redirigé vers votre terminal dès qu'ils arrivent. Cette commodité a été développée pour les utilisateurs de programmes orientés lignes sur écrans cathodiques ; ce n'est pas vraiment une bonne idée dans les environnements d'aujourd'hui.
La plupart des shells intègrent des facilitées équivalentes, mais de manière moins intrusive (en émettant un message juste avant l'invite lorsqu'un nouveau message est détecté). En général, on active cette fonction en définissant une variable d'environnement documentée dans la page de manuel du shell. Pour les shells de la famille sh/ksh/bash, regardez les variables MAIL et MAILPATH.
Les systèmes utilisant X sont livrés avec l'un des nombreux petits gadgets qui vérifient périodiquement si de nouveaux courriers sont arrivés, et vous le signale par des messages sonores et visuels. Le plus vieux et le plus utilisé est appelé xbiff ; si notre système Linux a un bureau X préconfiguré, xbiff est probablement dessus. Reportez-vous à la page de manuel xbiff(1) pour plus de détails.
Si vous avez lu attentivement, vous avez peut-être remarqué que les échanges d'informations que nous avons décrit ci-dessus dépendent du fait que la machine d'Alice peut immédiatement parler à la machine de Bob. Que se passe-t-il si la machine de Bob est en panne, ou si elle n'est pas connectée à Internet ?
Si l'agent de transport d'Alice ne peut pas atteindre celui de Bob immédiatement, il va stocker le message d'Alice dans une file d'attente sur paysdesmerveilles.com. Il essaiera ensuite de renvoyer le message à des intervalles de temps réguliers, jusqu'à ce qu'un temps d'expiration soit dépassé. À ce moment, il renverra son message à Alice en l'avertissant du problème. Dans la configuration par défaut de l'agent de transport le plus populaire (sendmail), l'intervalle entre chaque essai de transmission est de 15 minutes et la durée d'expiration de 4 jours.
Beaucoup d'utilisateurs de Linux sont connectés à Internet via un fournisseur d'accès Internet (FAI) et ne possèdent pas leur propre domaine. À la place, ils ont un compte sur une machine de leur FAI. Leurs courriers électroniques sont distribués dans une boîte aux lettres sur cette même machine. Cependant, généralement ces utilisateurs veulent lire et répondre à leurs courriers en utilisant leur propre machine qui est connecté à leur FAI de manière intermittente en utilisant SLIP ou PPP. Linux permet d'utiliser des protocoles de courrier distant qui permettent cela.
Remarquez comme ceci est différent du scénario que nous avons discuté dans la première partie. Le courrier était placé dans une file en attendant d'être envoyé, alors que dans le cas que nous venons de voir, le courrier est envoyé directement dans une boîte aux lettres sur un serveur. Le courrier dans une file n'est pas considéré comme ayant été distribué et peut expirer tandis que le courrier distribué dans la boîte aux lettres du serveur de courrier d'un FAI est considéré comme distribué et peut rester bloqué sur ce serveur indéfiniment.
Un protocole de courrier distant permet au courrier sur un serveur d'être récupéré au travers d'un lien réseau par un programme client (c'est le contraire d'une distribution normale au cours de laquelle un agent de transport envoie lui-même le courrier vers un autre agent de transport). Il existe deux protocoles communément utilisés de courrier à distance définis par les standards Internet : POP3 ( RFC1939) et IMAP ( RFC2060). Tous les FAI permettent d'utiliser POP3 et un nombre croissant permet également IMAP (qui est plus puissant).
Voilà à quoi ressemble une session POP3 :
S: <le client se connecte au port de service 110> R: +OK POP3 server ready <1896.697170952@mailgate.dobbs.org> S: USER bob R: +OK bob S: PASS redqueen R: +OK bob's maildrop has 2 messages (320 octets) S: STAT R: +OK 2 320 S: LIST R: +OK 2 messages (320 octets) R: 1 120 R: 2 200 R: . S: RETR 1 R: +OK 120 octets R: <le serveur POP3 envoie le message 1> R: . S: DELE 1 R: +OK message 1 deleted S: RETR 2 R: +OK 200 octets R: <le serveur POP3 envoie le message 2> R: . S: DELE 2 R: +OK message 2 deleted S: QUIT R: +OK dewey POP3 server signing off (maildrop empty) S: <le client se déconnecte>
Une session IMAP utilise des commandes et des réponses différentes, mais est très similaires.
Pour tirer parti de POP3 ou IMAP vous avez besoin d'un client de courrier à distance pour retirer votre courrier. Certains lecteurs de courrier offrent nativement ce genre de fonctionnalités. C'est le cas de Netscape Messenger qui permet d'utiliser POP et IMAP.
Le principal inconvénient des lecteurs de courrier implémentant ce genre de fonctionnalités est que vous devez explicitement dire à votre lecteur de retirer votre courrier sur le serveur ; vous ne pourrez pas, par exemple, être averti par xbiff(1) comme vous le seriez si le courrier était local ou distribué par un serveur SMTP. De plus, bien sûr, tous les MUA n'implémentent pas POP ou IMAP, et vous devrez vous rabattre sur d'autres fonctionnalités.
Votre distribution contient probablement un programme appelé fetchmail. Il a été écrit spécialement pour dialoguer avec des serveurs de courrier distant, récupérer le courrier, et le distribuer dans votre répertoire de réception de courrier, en dialoguant avec votre serveur SMTP.
Mis à part si vous avez besoin de laisser vos courriers sur le serveur (par exemple parce que vous changez souvent de machine) fetchmail est probablement une solution meilleure que n'importe quelle lecteur de courrier intégrant POP ou IMAP. Fetchmail peut se lancer en arrière plan et récupérer votre courrier périodiquement, et votre xbiff(1) ou tout autre signaleur de courrier marchera comme si tout se passait par SMTP. De plus, fetchmail est beaucoup plus tolérant que les lecteurs de courrier envers les différents particularismes et non respect des standards des serveurs de messagerie, et il gère mieux les erreurs.
Voici un diagramme schématisant les deux cas (avec et sans fetchmail) :
+--------+ +--------+ +-------+ compose | | appelle | | | Alice |--------->| MUA |--------->| MTA |:::>::::: +-------+ |appelant| |appelant| :: sur la +--------+ +--------+ :: machine :: appelante SMTP :: ::::::::::::::::::::::::::::<:::::::::::::::::::::::::::: :: .::....................................................................... :: :: +---------+ +-----+ +---------+ :: | | appelle | | distribue à |boîte du | ::::>| MTA |--------->| LDA |============>| serveur |::::>:::: |recevant | | | | de Bob | :: sur le +---------+ +-----+ +---------+ :: serveur de :: courrier POP ou IMAP :: ::::::::::::::::::::::::::::<::::::::::::::::::::::::::::::::::::: :: .::........................................................................ :: :: +-----------+ :: | | :::::::>::::::::::::| fetchmail |:::::::: sur la :: | | :: machine :: +-----------+ :: recevante, :: :: avec fetchmail :: ::::::::::::::::<::::::::::::::::::: :: :: :: :: +---------+ +-----+ +-------+ :: :: | | appelle | | distribue à | Boîte | :: ::::>| MTA |--------->| LDA |===============>| de | :: |recevant | | | | Bob | :: +---------+ +-----+ +-------+ :: | | :: | | :: +----------------<-------------+ | :: | | :: +-----------+ +--------+ | :: | signaleur | | MUA de |<--------+ :: | de Bob | | Bob | :: +-----------+ +--------+ :: | | .::........................................................................ :: . | | :: sans . | | :: fetchmail . | | :: . | +-----+ | :: +----------+ . +----->| |<----+ :: | MUA | . | Bob | :::::| POP/IMAP |----.--------->| | | de Bob | . +-----+ +----------+ .
Quand le courrier entrant est ajouté à une boîte aux lettres, il est du ressort de l'agent de transport de courrier d'ajouter des sortes de délimiteurs qui indiquent où un courrier s'arrête et où le suivant débute.
Sous Unix, que pratiquement tous les lecteurs de courrier suivent la même convention. Chaque ligne commençant par From (attention, il y a un espace après From) débute un nouveau courrier. Si un From apparaît dans une ligne de texte, un agent de transport de courrier d'Unix ajoutera généralement un signe supérieur-à au début de la ligne (>From ). Après cette ligne (qui continue généralement par le nom de l'envoyeur et la date de réception) on trouve l'entête RFC822 du courrier.
Cette convention date d'Unix Version 7, et donc on parle pour ce type de boîtes aux lettres de boîtes aux lettres V7 (V7 mailboxes). Sauf quand ce sera indiqué, tous les programmes mentionnés dans ce HOWTO utilisent ce format. Il n'est cependant pas universel et des outils attendant et générant des formats différents peuvent se placer mutuellement dans une situation de confusion catastrophique.
Les quatre autres formats à connaître (il faut s'en méfier !) sont BABYL, MMDF, MH et qmail maildir. De cela, MMDF est le plus simple : il utilise des délimiteurs (quatre fois le caractère ASCII 001 suivi par CR-LF). MMDF fût un des premiers formats de boîtes à lettres et il est plutôt cru. Un dérivé est encore utilisé sur les systèmes SCO.
BABYL est un autre survivant d'un vieux système de courrier du MIT. Il est encore utilisé par le mode lecteur de courrier d'Emacs.
Les formats MH et qmail maildir utilisent, pour stocker chaque message, un fichier séparé. Les boîtes aux lettres sont représentées par des répertoires. Faire une recherche dans une telle boîte aux lettres demandera l'utilisation d'un grep -r (grep récursif) afin d'accéder aux messages contenus dans la boîte aux lettres.
Les boîtes aux lettres .mbx de Microsoft Outlook Express peuvent être converties au format RFC822 grâce à mbx2mbox.