Envoi et réception de mails avec le framework 2.0

Je n'ai pas trouvé sur la MSDN de classe spécifique pour la réception de mail, mais il existe des composants tiers sur le net (payants) qui proposent des classes facilitant cette tâche. Nous allons voir comment se passer de ces classes tierces et comment recevoir les mails le plus simplement possible.

La récupération de mail en POP3 se fait à l'aide d'une communication client/serveur. En effet, le client(logiciel de messagerie) et le serveur s'envoient une suite bien définie de commandes et/ou de réponses correspondantes.

Notez que j'indique le serveur renvoie « +OK » ainsi qu'un message de réponse. Dans le cas d'une erreur, le serveur renverra « -ERR » et un message de réponse. Toutes ces commandes, ce fonctionnement, cette nomenclature de messages sont définis dans la norme rfc1939 ou la norme rfc1725.

Et dans la pratique ? Et bien, nous allons devoir suivre ces étapes une par une.

Commençons par nous connecter au serveur :

private TcpClient monSocket;
monSocket = new TcpClient("pop.developpez.com", 110); // 110 est le port par défaut pour les serveurs POP3

La communication client/serveur se fera à l'aide d'un flux (stream) :

private NetworkStream monStream;

Nous initialisons notre Stream à l'aide du stream de notre socket. Profitons-en pour créer un objet StreamReader qui nous permettra de lire le contenu de notre Stream, tout du long de la communication avec le serveur POP3. C'est dans ce dernier que nous recevrons les messages de réponse du serveur ainsi que les mails.

// initialisation du Stream
monStream = monSocket.GetStream();

// création du streamreader
private StreamReader monStreamReader;
monStreamReader = new StreamReader(monStream);

Maintenant que nous avons une « connexion » avec le serveur, nous allons nous y authentifier. Nous allons préparer les commandes et les envoyer au serveur.

// Préparation de la commande USER avec le nom d'utilisateur
String Commande = "user " + _Login + "\r\n";

// Envoi de la commande au serveur
Byte[] bCommande = System.Text.ASCIIEncoding.ASCII.GetBytes(Commande);
monStream.Write(bCommande, 0, bCommande.Length);

Lorsque nous nous sommes connectés au serveur, celui-ci nous a renvoyé la réponse suivante : « +OK connected to pop3 on 1012 », puis nous lui avons envoyé la commande USER à laquelle il a répondu (car l'utilisateur existe vraiment) : +OK name is a valid mailbox.
L'étape suivante consiste à envoyer le mot de passe du compte pour être reconnu et authentifié sur le serveur :

// Préparation de la commande PASS avec le mot de passe utilisateur
String Commande = "pass " + _Pwd + "\r\n";

// Envoi de la commande au serveur
Byte[] bCommande = System.Text.ASCIIEncoding.ASCII.GetBytes(Commande);
monStream.Write(bCommande, 0, bCommande.Length);

Si le login et surtout le mot de passe sont corrects, alors vous recevrez le message : « +OK user exist with that password ». Vous pouvez dorénavant travailler comme bon vous semble avec le serveur.

Nous allons maintenant aborder la réception des mails. Celle-ci se fait en deux principales étapes. La première consiste à demander au serveur s'il contient des mails. Nous pouvons la réaliser à l'aide de la commande STAT, puis nous parserons la réponse du serveur

/// <summary>
/// Récupère le nombre de mails sur le serveur, en parsant la réponse du serveur du type "+OK Nbre Taille"
/// </summary>
/// <param name="mode"></param>
/// <param name="index"></param>
/// <returns></returns>
private int NombreDeMessages(int mode, params int[] index)
{
    String sOutStream = "";
    if (mode == 1)
        sOutStream = "stat\r\n";
    else if (mode == 2)
        sOutStream = "list " + index[0].ToString() + "\r\n";

    String[] tempS ={ "0" };
    try
    {
        EnvoiCommande(sOutStream);
        String tempLog = sr.ReadLine();
        tempS = tempLog.Split(' ');

    }
    catch (Exception e) {
        MessageBox.Show("erreur" + e);
    }
    return int.Parse(tempS[1]);
}

La méthode précédente nous renvoyait donc le nombre de mails qui se trouvent sur le serveur et la taille totale prise par ceux-ci, puis nous la parsions pour ne récupérer que le nombre de mails

Avant de démarrer, il faut bien prendre en compte le fait suivant : le traitement de réception peut-être assez complexe, pour les raisons suivantes :
- même s'il existe des normes, tous les mails ne les respectent pas forcément,
- les possibilités de contenu d'un mail sont très vastes.
Ne vous étonnez donc pas que votre réception de mail ne soit pas aussi parfaite que celle d'un client de messagerie comme Microsoft Outlook ou Thunderbird.

Dans cette partie, je vais donc vous présenter une manière simple de récupérer les mails et les informations associées. Il serait bien entendu possible de développer cette approche d'une manière beaucoup plus exhaustive, mais ce n'est pas le but de cette présentation.

Nous allons maintenant recevoir les mails. Cela ne se fait qu'en les recevant un par un, en les « appelant » par leur numéro.

#region Méthode : RecupereListeMessages
private void RecupereListeMessages()
{
    for (int i = 1; i <= inbMsg; i++)
    {
        lblStatus.Text = "Retrieve Message " + i.ToString() + " ...";
        int intSizeMsg = NombreDeMessages(2, i);
        EnvoiCommande("retr " + i.ToString() + "\r\n");
        parseMail(intSizeMsg);
    }
}
#endregion

Nous bouclons donc pour récupérer les mails les uns après les autres. Voyons maintenant comment récupérer chaque mail :

#region Méthode : ParseMail
/// <summary>
/// Rempli la listview listant la liste détaillée des mails
/// </summary>
/// <param name="size"></param>
private void parseMail(int size)
{
    string szTemp = sr.ReadLine();
    string szSubject = "";
    string szDate = "";
    int temp;

    if (szTemp != "-")
    {
        szTemp = sr.ReadLine();
        string szSender;
        if ((temp = szTemp.IndexOf("<")) != -1)
            szSender = szTemp.Substring(temp);
        else
            szSender = "Inconnu||Erreur";

        System.Windows.Forms.ListViewItem curItem = lvMails.Items.Add("");
        szTemp = sr.ReadLine();
        while (szTemp != ".")
        {
            if (szTemp.IndexOf("Date:") != -1)
                 szDate = szTemp.Substring(5, szTemp.Length - 5);
            if (szTemp.IndexOf("Subject:") != -1)
                szSubject = szTemp.Substring(8, szTemp.Length - 8);
            szTemp = sr.ReadLine();
        }
        curItem.SubItems.Add(szSender.Replace("<", "").Replace(">", ""));
        curItem.SubItems.Add(szSubject);
        curItem.SubItems.Add(Convert.ToDateTime(szDate).ToShortDateString());
        curItem.SubItems.Add(Convert.ToDateTime(szDate).ToShortTimeString());
    }
}
#endregion

Le code ci-dessus, appelé pour chaque rapatriement de mail (commande RETR), lit le mail ligne par ligne pour en ressortir certaines informations. Celles-ci sont contenues dans l'entête du mail. Or celui-ci est accolé au texte du mail lui-même. Nous devons donc détecter les mots clés (Subject, Date, etc.) afin d'en récupérer l'information correspondante.
Cette méthode permet simplement de remplir une listview, en affichant la liste des mails et quelques informations sur ceux-ci.

Dans ma source (fournie en fin de cet article), je ne « récupère » (et ne traite) les mails que lorsque l'utilisateur sélectionne un mail dans la liste des mails. En effet, n'ayant pas de base de données où les stocker, je dois les redemander au serveur mail, pour les traiter et les afficher dans la partie visualisation (une simple TextBox pour l'exemple) :

#region Méthode : RecupereMail
/// <summary>
/// Récupère le "source" de l'email sélectionné
/// </summary>
/// <param name="NumMail"></param>
private void RecupereMail(int NumMail)
{
    EnvoiCommande("retr " + NumMail.ToString() + "\r\n");
    string szTemp = sr.ReadLine();
    while (szTemp != ".")// fin du mail
    {
        if (szTemp.Length != 0)// on ne travaille pas sur les lignes vides (sauts de ligne)
        {
            // on ajoute la ligne dans la textbox d'affichage du mail.
            // Si le dernier caractère est le symbole "=" alors cela représente un saut de ligne que l'on doit rajouter.
            if (szTemp[szTemp.Length - 1].Equals('='))
                txtDetails.AppendText(szTemp.Substring(0, szTemp.Length - 1));
            else txtDetails.AppendText(szTemp + "\r\n");
        }
        szTemp = sr.ReadLine(); // lit la ligne suivante
    }
}

En utilisant la méthode précédente, vous afficherez tel quel le mail que vous renvoi le serveur mail. En regardant de plus près vous vous rendrez compte qu'il contient l'entête plus le contenu du mail plus les pièces jointes et dans certains cas, il contient une version HTML et une version Text du mail.
Les clients de messagerie comme Microsoft Outlook ou Mozilla Thunderbird doivent alors faire un gros traitement dessus pour ne vous afficher que le contenu du mail dans un seul format (html ou text), en vous séparant les informations d'entête et les pièces jointes. Dans la source que je vous propose, je fais la même chose sans avoir un résultat parfait, car le traitement de l'entête diffère selon le client messagerie de l'émetteur du mail.

Comme dit plus haut, un mail est contenu dans un seul flux, mais a une architecture bien particulière. Il contient l'entête et le contenu du mail sans séparation stricte, et il est donc difficile de ne récupérer que le corps du mail. Pis encore, un mail peut contenir plusieurs versions du contenu : la version texte et la version HTML. Et pour finir, les pièces jointes sont intégrées au mail, mais encodées en base-64. Autant dire que le traitement du mail peut être compliqué et que le traitement « à la volée » (en une seule fois pendant la récupération) peut devenir extrêmement lourd. C'est pourquoi je vous conseille de récupérer le mail, de le stocker en local (dans un fichier ou une base de données) et de « travailler » dessus pour en récupérer les informations importantes (contenu, pièce jointe, entête).