Introduction

En soi, le formatage d'un courriel et son envoi sont des plus triviaux avec Perl grâce aux couches logicielles successives ajoutées par différents contributeurs de la communauté Perl. La preuve en est le simplissime exemple de code qui suit :

    #!/usr/bin/perl -w

    use MIME::Lite;

    $msg = MIME::Lite->new(
             From     => 'moi@monchezmoi.org',
             To       => 'toi@toncheztoi.org',
             Cc       => 'lautre@sonchezlui.org',
             Subject  => "Hier soir !",
             Data     => "Alors, c'était bien ?\n\nMoi."
             );

    $msg->send;

Ce very-few-liner (cf. LinuxMag n°50 sur les « unelignes »), pour peu que vous ayez Perl et sendmail[2] installés sur votre système, sera véritablement suffisant et efficace pour demander à votre ami "toi" comment s'est passée sa soirée d'hier, tout en prenant à témoin votre autre ami "lautre".

La première ligne va chercher Perl où il se trouve (à modifier en fonction de votre système), en n'oubliant pas de positionner le switch -w (avertissements - grandement conseillé !). La deuxième charge le module MIME::Lite (qui va tout faire pour vous). Grâce à ce dernier, vous créez un message sous la forme d'un objet Perl avec les en-têtes et informations du courriel que vous souhaitez envoyer. La dernière ligne va envoyer le courriel avec la méthode send() (prosaïque, n'est-il pas ? ;-), qui va s'adresser par défaut à sendmail pour acheminer le courrier puisque rien d'autre n'a été précisé à ce sujet (à noter que lorsque le module MIME::Lite a besoin de s'adresser à un serveur SMTP[3] à travers le réseau, il utilise lui-même le module Net::SMTP que nous allons aborder un peu plus bas). Et voila déjà fini ce petit script, diablement efficace pour ce qu'il est simple.

La facilité avec laquelle le courriel précédent a été envoyé cache en fait un travail conséquent de l'auteur du module en pré-traitement et post-traitement des données. Afin de mieux comprendre ce travail et ce qu'est un courriel, il faut se tourner vers un module qui en fait moins, qui se contente (et c'est déjà bien pratique) de fournir une API au protocole SMTP : Net::SMTP.

Quelques notions : la trinité du courriel, du module et du protocole

Avant d'aborder le module à proprement dit, il est utile d'expliquer ce qu'est un courriel un peu plus précisément. Nous pourrions pour cela nous plonger dans les passionnantes RFC 2821 (SMTP) et 2822 (format des messages) mais pour le propos du présent article, il suffit de dire et savoir ce qui suit.

Un courriel est d'abord un ensemble de données formatées de telle façon que MTA[4] et MUA[5] sachent s'y retrouver (quoi acheminer, comment, à qui, ou encore savoir séparer le corps des en-têtes, isoler celles qui intéressent).

Il faut mentionner comme règles importantes de ce formatage la séparation du courriel en deux. Dans la première moitié, on trouve les en-têtes (From, To, etc...) formées elles-mêmes d'un intitulé que l'on pourrait décrire simplement en disant qu'il se compose d'une chaîne de caractères sans espace (même si la RFC autorise en fait un éventail de caractères assez large, on observe en pratique principalement des lettres, des chiffres et des tirets) séparée de la valeur par le caractère :. Vient ensuite la valeur qui peut être multi-ligne. On observe en général un espace entre le : et le texte de l'en-tête, mais il n'est pas imposé par la norme. Voici un exemple prélévé sur un spam :

    Received: from mx4.hotmail.com (vic-dial-196-30-233-65.mweb.co.za [196.30.233.65])
            by mendez.monisp.fr (Postfix) with ESMTP id 5559C57866
            for <moi@monisp.fr>; Mon, 10 Nov 2003 03:36:43 +0100 (CET)
    From: thmulato5@yahoo.co.in
    Subject: INVESTMENT PROPOSAL
    To: moi@monisp.fr
    Mime-Version: 1.0
    Content-Type: multipart/alternative;
        boundary="9707321637551929"                                             
    Date: Mon, 10 Nov 2003 04:32:08 +0200
    X-MSMail-Priority: Normal
    X-Mailer: Microsoft Outlook Express 6.00.2800.1106

Une ligne vide marque la fin des en-têtes et sépare les deux parties du courriel. La suite, le corps du message, est assez libre dans sa forme.

Il faut savoir que c'est le développeur (vous avec votre joli script maison d'envoi de courrier ou le développeur de votre MUA) qui formate ce texte et non pas les serveurs de courriel SMTP et POP3[6] ou IMAP[7], qui se contentent de transmettre les données telles qu'ils les ont reçues (ceci à l'exception de petits ajouts comme précisé plus bas).

Une fois ces données prêtes, il ne reste plus qu'à passer la main à un serveur SMTP qui se chargera de lancer le processus d'acheminement du courrier. Ce processus va commencer par une mise sous enveloppe de vos données et se poursuivre par la transmission de serveur SMTP en serveur SMTP (d'où le mot transfer dans le nom du protocole), jusqu'au serveur de courriel dépositaire du compte de votre destinataire.

À noter que ces différentes opérations (mise sous enveloppe, transfert) peuvent être retrouvées ou tracées à travers des en-têtes que les différents serveurs impliqués (MTA) vont rajouter (typiquement Delivered-To, Return-Path, Received).

Mais avant toute chose, pour initier tout ce processus, il faut connaître la langue du serveur et ce qu'il attend de vous. C'est là que le module intervient en vous servant de traducteur lorsque vous enverrez les commandes au serveur selon un ordre établi : le protocole SMTP.

Le module Net::SMTP

Net::SMTP est un module de la grande famille de la "libnet" Perl qui couvre tout le spectre de l'informatique en réseau (de Net::LDAP à Net::DNS en passant par Net::Whois et Net::HTTPServer). Cette bibliothèque fait partie de celles qui sont installées par défaut avec les versions les plus récentes de Perl. Elle a été développée par Graham Barr.

Le module Net::SMTP est orienté objet et il fournit une API qui reprend les commandes connues par un serveur SMTP de la façon la plus perlienne possible.

new()

L'objet Net::SMTP est construit de la façon classique :

    my $smtp = Net::SMTP->new('serveur');

serveur est l'adresse du serveur relais que vous allez charger d'acheminer votre courriel, ce peut être localhost si vous avez un sendmail ou un Postfix qui tourne sur votre machine ou encore n'importe quel serveur SMTP qui acceptera de faire transiter votre courrier (par défaut le serveur SMTP de votre fournisseur d'accès à internet). Ce constructeur accepte plusieurs options dont les plus utiles et courantes sont Debug et Timeout (positionnement du marqueur de débogage et d'une durée limite pour établir la connexion, respectivement).

    my $smtp = Net::SMTP->new('serveur',
                              Debug => 1,
                              Timeout => 30);

Les autres méthodes sont toutes des versions perliennes des commandes SMTP.

mail()

À noter la méthode mail() qui transmet au serveur l'adresse de l'expéditeur. Cette méthode correspond à la commande MAIL FROM du protocole SMTP.

    $smtp->mail('moi@monchezmoi.org');

to()

C'est la méthode to() qui renseigne l'adresse du destinataire : Cette méthode correspond à la commande RCPT TO du protocole SMTP.

    $smtp->to('toi@toncheztoi.org');

Ces deux méthodes prennent uniquement des adresses courriel comme argument. Si vous ajoutez d'autres choses (comme "moi" <moi@monchezmoi.org>), vous n'êtes pas assuré que le serveur comprendra. Certains accepteront, d'autres pas.

data() et dataend()

Ce sont les méthodes data() et dataend() qui, respectivement, initie et clôture la transmission des données (le courriel lui-même) :

    $smtp->data();
    $smtp->dataend();

Ces méthodes correspondent respectivement à la commande DATA du protocole SMTP et au . seul sur une ligne qui termine l'envoi du message.

datasend()

À noter aussi la méthode datasend() qui s'intercale entre les deux précédentes qui transmet le courriel. Cette méthode peut être utilisée le nombre de fois désiré pour envoyer le courriel en autant de morceaux que vous le souhaitez. Elle prend une chaîne en argument.

    $smtp->datasend('From: moi <moi@monchezmoi.org>');   # en-tête
    $smtp->datasend('To: toi <toi@toncheztoi.org>\n');   # en-tête
    $smtp->datasend("Subject: Hier soir !\n");           # en-tête
    $smtp->datasend("\n");                               # séparateur en-têtes - corps
    $smtp->datasend("Alors, c'était bien ?\n");          # corps du message
    $smtp->datasend("\n");                               # corps du message
    $smtp->datasend("Moi.");                             # corps du message

(bien entendu, vous pouvez ne faire qu'un seul appel de cette méthode en envoyant la concaténation des différentes chaînes composant le message).

quit()

Enfin la méthode quit() ferme la connexion avec le serveur :

    $smtp->quit();

Comme vous l'avez deviné, cette méthode correspond à la commande QUIT du protocole SMTP.

Séquence

En rétablissant l'ordre des commandes SMTP et en affinant un peu, la séquence des méthodes à utiliser pour envoyer un courriel ressemblerait à ceci :

    my $smtp = Net::SMTP->new('serveur',
                              Debug => 1,
                              Timeout => 30);
    $smtp->mail('moi@monchezmoi.org');
    $smtp->to('toi@toncheztoi.org');
    $smtp->data();
    $smtp->datasend( << 'EOM' );
    From: moi <moi@monchezmoi.org>
    To: toi <toi@toncheztoi.org>
    Subject: Hier soir !

    Alors, c'était bien ?

    Moi.
    EOM
    $smtp->dataend();
    $smtp->quit();

D'abord quelques mots sur un opérateur que vous ne connaissez peut-être pas : le here-document (<<'EOM' dans l'exemple). Cet opérateur fait partie de l'assez grande famille (en Perl) des équivalents des guillemets. Son utilisation est assez simple et vous permet une souplesse totale dans la rédaction de longues chaînes. Sa syntaxe vous demande de faire figurer << puis le nom du marqueur. Il ne faut pas oublier de terminer votre ligne de code pour qu'elle ait une syntaxe correcte (mettre par exemple le point virgule en fin d'instruction). Vous pouvez ensuite développer votre texte, tout ce qui se trouvera en dessous du marqueur sera pris comme une chaîne jusqu'à ce que l'interpréteur Perl rencontre le marqueur de nouveau.

Le type de guillemets qui entourent le marqueur va déterminer si les variables contenues dans le document sont interpolées ou non. Comme d'habitude, si vous utilisez " (double quotes), les variables présentes seront interpolées et ne le seront pas si vous utilisez '.

Revenons-en maintenant à notre explication. À la lecture de ces lignes, vous pouvez vous dire qu'il semble y avoir une redondance puisque je donne deux fois l'adresse de l'expéditeur et du destinataire. Du point de vue du serveur il n'y a pas de redondance : la seule façon pour lui de savoir qui envoie un courriel à qui d'autre sont les méthodes mail() et to() (qui à elle deux constituent la mise sous enveloppe et sont parfois matérialisées dans le courriel par les en-têtes Return-Path: et Delivered-To:). Le serveur ne s'occupe pas de la chaîne (donc ne la traite pas) que vous envoyez par datasend(). Ainsi, le courriel est bien la concaténation de votre message à proprement parler avec des en-têtes que vous allez remplir et formater vous-mêmes afin que le MUA de votre destinataire s'y retrouve. Si vous ne faites pas ce formatage, le courriel sera malgré tout acheminé mais votre destinataire ne saura pas qui lui envoie ce message.

Comme une adresse courriel peut provenir de sources que vous ne contrôlez pas ou d'un traitement, comme tout autre chose, exposé aux erreurs, il vous est possible de valider une adresse courriel avant de l'envoyer à un serveur avec des modules tels que Mail::Address (dont ça n'est pas la seule utilité mais ceci est une autre histoire).

Au demeurant, il faut savoir que toutes les méthodes du module Net::SMTP sont censées fournir des valeurs de retour booléennes ('vrai' ou 'faux'). Ainsi le contrôle de l'exécution d'un script est possible à l'appel de chaque méthode quelle que soit l'erreur provoquée.

Bien entendu, je vous engage à lire la documentation du module qui saura vous donner plus de détails sur les différentes options disponibles pour chaque méthode, vous détailler l'entièreté de l'API de ce module et préciser certains points que je n'ai fait qu'évoquer.

La lettre aux adhérents

À titre d'exemple d'application, je vous propose d'imaginer le cas suivant : je suis le président d'une petite association et j'ai un courriel d'information à envoyer régulièrement. Mon association est trop petite pour m'embêter à employer des outils plus précis mais trop grande pour faire cela à la main. De plus j'aimerais envoyer un courriel personnalisé à chacun de mes adhérents.

Voilà comment à partir d'un fichier de type CSV[8] recensant vos adhérents, je pourrais remettre les choses à leur place : prendre plus de temps et de soin à rédiger la lettre d'information qu'à l'envoyer.

Le fichier source des adhérents, liste.csv

C'est un fichier CSV avec le caractère tabulation (\t) comme séparateur.

    Mr	Dupont	Laurent	dlaurent@yahoo.fr
    Mme	Martin	Martine	m.martin@hotmail.com
    Melle	Lefebvre	Isabelle	isabelle.lefebvre@caramail.com
    ...

Le fichier message-20040124-corps.txt, le corps du message

    Mes chers amis de "Monassoce",
  
    voici la lettre d'information mensuelle.
  
    Ce mois-ci, je vais être bref tout autant que l'a été l'activité de notre 
    association.
  
    Rien de neuf sous le soleil !
  
    À bientôt.
  
    Votre président.
  
    -- 
    president@monassoce.org
    www.monassoce.org

Le script

Quelques mots d'explication

Ayant déjà un peu expliqué le module, il ne devrait pas y avoir grand'chose de nouveau dans ce script pour les bons élèves qui ont suivi et retenu nos leçons précédentes.

Dans les premières lignes, j'appelle Perl avec les avertissements (-w) et la pragma strict qui sont deux outils qui permettent de détecter rapidement les erreurs d'inattention (erreur de frappe, syntaxe de Perl...).

J'appelle aussi le chargement de deux modules : Getopt::Long pour la gestion des options (cf. LinuxMag n°49 pour l'utilisation de GetOptions() qui suit) et Net::SMTP pour le propos de cet article.

Dans la ligne suivante, je récupère des données brutes stockées dans le script lui-même, grâce au descripteur de fichier spécial DATA. Dans un script Perl, il est possible de stocker des données brutes ignorées au moment de la compilation en utilisant le marqueur __DATA__. Tout ce qui se trouve en dessous sera ignoré et récupérable lors de l'exécution du script comme les données de n'importe quel fichier (au moyen du descripteur de fichier DATA) à la seule différence qu'il n'est pas nécessaire de l'ouvrir ou le fermer avec les fonctions open et close. J'utilise ce moyen de stocker les données car, même si cette partie du courriel est la partie personnalisée (variable), c'est celle qui changera le moins souvent (ou pas du tout) d'un envoi de courriel à l'autre. Dans cette ligne de code, j'utilise donc ce descripteur de fichier dans un contexte de liste (avec join()) et concatène ainsi toutes les lignes sous __DATA__ en une seule chaîne dans la variable $head.

Je fais la même chose dans les lignes suivantes avec le fichier qui contient le corps du message concaténé et stocké dans la variable $body.

J'ouvre ensuite le fichier me servant de base de données de mes adhérents et boucle dessus. Dans cette boucle, à chaque nouvelle ligne du fichier :

• je supprime le caractère de fin de ligne ;

• je découpe la ligne et récupère ainsi les valeurs courantes ;

• j'initialise le hachage qui me servira à remplacer les valeurs génériques dans $head par les noms et prénoms respectifs des adhérents ;

• je mets à jour le hachage avec les valeurs courantes ;

• j'opère le remplacement dans $head;

• je concatène $head et $body pour obtenir le courriel dans sa version finale et complète ;

• j'envoie le courriel avec la séquence suivante détaillée plus haut dans l'article.

La dernière ligne du script ferme le fichier avant l'arrêt du script. Viennent ensuite les données qui seront lues à travers le descripteur DATA.

Sortie

Voilà ce que donne la sortie sur la console lorsqu'on lance notre script, lors de l'envoi de la lettre mensuelle.

    moi@lievre:/home/CvsTortue/Bin/devel$ ./moncourriel.pl --liste liste.csv --corps message-20040124-corps.txt
    Net::SMTP: Net::SMTP(2.19)
    Net::SMTP:   Net::Cmd(2.20)
    Net::SMTP:     Exporter(5.562)
    Net::SMTP:   IO::Socket::INET(1.25)
    Net::SMTP:     IO::Socket(1.26)
    Net::SMTP:       IO::Handle(1.21)
    
    Net::SMTP=GLOB(0x857f258)<<< 220 smtp.monfai.com ESMTP Postfix
    Net::SMTP=GLOB(0x857f258)>>> EHLO localhost.localdomain
    Net::SMTP=GLOB(0x857f258)<<< 250-smtp.monfai.com
    Net::SMTP=GLOB(0x857f258)<<< 250-PIPELINING
    Net::SMTP=GLOB(0x857f258)<<< 250-SIZE 16777216
    Net::SMTP=GLOB(0x857f258)<<< 250-VRFY
    Net::SMTP=GLOB(0x857f258)<<< 250-ETRN
    Net::SMTP=GLOB(0x857f258)<<< 250-XVERP
    Net::SMTP=GLOB(0x857f258)<<< 250 8BITMIME
    Net::SMTP=GLOB(0x857f258)>>> MAIL FROM:<president@monassoce.org>
    Net::SMTP=GLOB(0x857f258)<<< 250 Ok
    Net::SMTP=GLOB(0x857f258)>>> RCPT TO:<dlaurent@yahoo.fr>
    Net::SMTP=GLOB(0x857f258)<<< 250 Ok
    Net::SMTP=GLOB(0x857f258)>>> DATA
    Net::SMTP=GLOB(0x857f258)<<< 354 End data with <CR><LF>.<CR><LF>
    Net::SMTP=GLOB(0x857f258)>>> To: Dupont Laurent <dlaurent@yahoo.fr>
    Net::SMTP=GLOB(0x857f258)>>> From: La présidence <president@monassoce.org>
    Net::SMTP=GLOB(0x857f258)>>> Subject: lettre mensuelle d'information
    Net::SMTP=GLOB(0x857f258)>>> X-Mailer: moncourriel.pl v0.1
    Net::SMTP=GLOB(0x857f258)>>> Reply-To: La présidence <president@monassoce.org>
    Net::SMTP=GLOB(0x857f258)>>>
    Net::SMTP=GLOB(0x857f258)>>> Mes chers amis de "Monassoce",
    Net::SMTP=GLOB(0x857f258)>>>
    Net::SMTP=GLOB(0x857f258)>>> voici la lettre d'information mensuelle.
    Net::SMTP=GLOB(0x857f258)>>>
    Net::SMTP=GLOB(0x857f258)>>> Ce mois-ci, je vais être bref tout autant que l'a été l'activité de notre 
    Net::SMTP=GLOB(0x857f258)>>> association.
    Net::SMTP=GLOB(0x857f258)>>>
    Net::SMTP=GLOB(0x857f258)>>> Rien de neuf sous le soleil !
    Net::SMTP=GLOB(0x857f258)>>>
    Net::SMTP=GLOB(0x857f258)>>> À bientôt.
    Net::SMTP=GLOB(0x857f258)>>>
    Net::SMTP=GLOB(0x857f258)>>> Votre président.
    Net::SMTP=GLOB(0x857f258)>>>
    Net::SMTP=GLOB(0x857f258)>>> --
    Net::SMTP=GLOB(0x857f258)>>> president@monassoce.org
    Net::SMTP=GLOB(0x857f258)>>> www.monassoce.org
    
    Net::SMTP=GLOB(0x857f258)>>> .
    Net::SMTP=GLOB(0x857f258)<<< 250 Ok: queued as 00D2B418C6
    Net::SMTP=GLOB(0x857f258)>>> QUIT
    Net::SMTP=GLOB(0x857f258)<<< 221 Bye

Ici, comme spécifié dans le script comme option du constructeur, nous sommes en mode débogage. Ce mode est très verbeux (même quand tout se passe bien ;-) ce qui nous est bien utile pour comprendre ce qui se passe lors de l'exécution de ce script.

Les premières lignes, jusqu'au premier saut de ligne, ne font qu'énoncer ce dont Net::SMTP a besoin pour se mettre en place (dépendances d'autres modules). C'est avec les lignes suivantes que commence la conversation entre votre script et le serveur, avec le module comme décodeur. Dans les lignes suivantes Net::SMTP=GLOB(0x857f258) est l'objet Net::SMTP qui est une "référence bénie" à un GLOB par le paquetage Net::SMTP. Cet affichage correspond à la conversion en chaîne (stringification) de l'objet. Vous obtiendriez cette sortie en intercalant dans votre script un print "$smtp \n"; après la construction de l'objet. Les signes >>> ou <<< sont placés à la suite lorsque, respectivement, nous recevons des informations du serveur ou nous en envoyons. À partir de là ces lignes se comprennent aisément :

• Les machines se disent bonjour dans les deux premières lignes.

• Le serveur SMTP vous ayant trouvé suffisamment poli vous montre dans les lignes suivantes ce qu'il saura faire pour vous.

• Dans les quatre lignes qui suivent vous envoyez les adresses de l'expéditeur et du destinataire et le serveur les accepte (tour à tour).

• Vous le prévenez ensuite que vous allez envoyer le courriel et lui vous rappelle par quoi clore le flux de données.

• Vous voyez par la suite que le courriel est bien envoyé ligne à ligne (en référence à ce que j'ai dis sur la méthode datasend()).

• Vous terminez la transmission de données comme il vous a dit de le faire et il vous répond que c'est d'accord.

• Vous lui dites que vous partez et lui a la politesse de vous dire au revoir.

En plus de l'intérêt de comprendre d'un peu plus près un procédé qui nous est utile plusieurs fois par jour, nous pouvons remarquer ici qu'il s'agit véritablement d'une conversation entre deux machines et qu'il est donc possible, si nécessaire, d'en modifier certains aspects et termes. Notre exemple est suffisamment simple pour que nous n'ayons rien à attendre de spécial qu'un défaut de connexion ou une erreur de syntaxe dans les adresses. Cependant, l'utilisation en production peut s'avérer souvent plus complexe et vous avez la démonstration qu'il vous est possible, si besoin, de mettre en place une procédure interactive avec des contrôles d'exécution.

Conclusion

À présent, vous savez envoyer des courriels sans passer par un MUA, vous savez les formater mais les plus attentifs se demanderont à juste titre : « quid des pièces jointes ? ». Je ne les ai pas encore évoquées parce que Net::SMTP ne sait pas faire cela, et pour cause : ce n'est pas son boulot. En fait, Net::SMTP, ne sert qu'à envoyer le courrier et comme nous l'avons vu, ne s'occupe en aucune façon de son contenu. Cela peut être du texte simple ou une longue chaîne de caractères avec un encodage spécial qui permettra à l'autre bout, à votre correspondant, de récupérer une image ou un texte au format PDF.

En somme, Net::SMTP n'est que le convoyeur de votre pli et il ne s'occupe pas de le conditionner. Il ne lui importe pas de savoir quel contenant (message au format MIME, encodage) avec quel contenu (texte simple, HTML, fichier image) il transporte.

Malgré tout, la connaissance et la maîtrise relative de Net::SMTP restent intéressantes. Outre l'envoi de courriel, vous connaissez à présent en substance le travail de formatage des données qui est fait par MIME::Lite, montré en tout début d'article. Vous savez comment il permet d'expédier un courriel en très peu de lignes de code et pouvez donc choisir de lui confier cette tâche ou pas. De même, à ma connaissance, tous ces modules qui traitent du courriel et des pièces jointes utilisent Net::SMTP lorsqu'ils doivent s'adresser à un serveur SMTP sur une machine distante.

Ainsi, connaître notamment les options du constructeur de l'objet Net::SMTP peut alors vous être d'une utilité immédiate lors de l'utilisation d'un module comme MIME::Lite. Ce module est de ceux qui vous permettront d'inclure autre chose que du texte dans vos messages, comme nous le verrons dans le prochain article.

A propos des RFC

Un certain nombre de sites vous donnent accès à la liste presque complète des RFC. Voici les principaux :

Références de l'article

Notes de l'article :

Auteur

David Elbaz, <lacravate@mongueurs.net>.

David Elbaz est membre de l'association des mongueurs de Perl ainsi que de paris.pm. Il a découvert Perl dans Linux Magazine et l'utilise depuis pour à peu près tout (web, interfaces utilisateurs, sérialisation en tous genres) avec beaucoup de bonheur et de plaisir intellectuel.

Il remercie très chaudement les membres du groupe de relecture pour l'aide massive et productive qu'ils lui ont prodigué.