4. Utilisation avancée

4.1 Expressions Rationnelles

Toutes les chaînes de motifs de Mutt incluant des motifs plus complexes doivent être indiqués en utilisant des expressions rationnelles (regexp) de la norme ``POSIX étendue'' (qui est plus ou moins la syntaxe employée par egrep et GNU awk). Pour votre convenance, nous avons inclus ci-dessous une courte description de cette syntaxe.

La recherche est sensible à la casse si le motif contient au moins une lettre majuscule, sinon elle y est insensible. Notez que le ``\'' doit être protégé s'il est utilisé dans une expression rationnelle et dans une commande d'initialisation : ``\\''.

Une expression rationnelle est un motif qui décrit un ensemble de chaînes de caractères. Les expressions rationnelles sont construites de façon analogue aux expressions arithmétiques, en employant divers opérateurs pour combiner de plus petites expressions.

Notez qu'une expression rationnelle peut être incluse/délimitée par " ou ' qui est utile si l'expression rationnelle inclut un espace. Voir la syntaxe des dossiers d'initialisation pour plus d'information sur le traitement du délimiteur " et '. Pour qu'une expression rationnelle reconnaisse un " ou ' vous devez l'échapper avec \ (antislash).

Les modules fondamentaux sont les expressions rationnelles qui font correspondre un unique caractère. La plupart des caractères, y compris toutes les lettres et les chiffres, sont des expressions rationnelles qui se reconnaissent elle mêmes. N'importe quel méta-caractère avec une signification spéciale peut être échappé en le précédant d'un antislash. Le caractère ``.'' reconnaît n'importe quel caractère simple. L'accent circonflexe ``^'' et le symbole dollar ``$'' sont des méta-caractères qui font correspondre respectivement la chaîne vide au commencement et à la fin d'une ligne.

Une liste de caractères délimitée par ``['' et ``]'' reconnaît n'importe quel caractère dans cette liste ; si le premier caractère de la liste est un accent circonflexe ``^'' alors il fait correspondre n'importe quel caractère qui n'est pas dans cette liste. Par exemple, l'expression rationnelle [0123456789] reconnait n'importe quel chiffre. Une gamme de caractères ASCII peut être indiquée en donnant le premier et le dernier caractère, séparées par un trait d'union ``‐''. La plupart des méta-caractères perdent leur signification spéciale à l'intérieur des listes. Pour inclure un ``]'' placez-le en premier dans la liste. De même, pour inclure un ``^'' placez-le n'importe où mais pas en premier. En conclusion, pour inclure un trait d'union ``‐'' placez-le dernier.

Certaines classes de caractères sont prédéfinies. Les classes de caractères se composent de ``[:'', un mot-clé dénotant la classe, et ``:]''. Les classes suivantes sont définis par la norme POSIX :

[:alnum:]

Caractères alphanumériques.

[:alpha:]

Caractères alphabétiques.

[:blank:]

Espace ou tabulation.

[:cntrl:]

Caractères de contrôle.

[:digit:]

Chiffres.

[:graph:]

Caractères qui sont imprimables et visibles. (l'espace est imprimable, mais non visible, alors qu'un ``a'' est visible et imprimable.)

[:lower:]

Lettres minuscules.

[:print:]

Caractères imprimables (caractères qui ne sont pas les caractères de contrôle.)

[:punct:]

Caractères de ponctuation (caractères qui ne sont pas des lettres, des chiffres, des caractères de contrôle, ou des caractères d'espacement).

[:space:]

Caractères d'espacement (tels que l'espace, la tabulation, le chargement de page,..).

[:upper:]

Lettres majuscules.

[:xdigit:]

Caractères hexadécimaux.

Une classe de caractères est valide seulement dans une expression rationnelle à l'intérieur des parenthèses d'une liste de caractères. Notez que les parenthèses dans ces noms de classe font partie des noms symboliques, et doivent être inclus en plus des parenthèses délimitant cette liste. Par exemple [[:digit:]] est équivalent à [0-9].

Deux séquences supplémentaires peuvent apparaître dans les listes de caractères. Elles s'appliquent aux jeux de caractères non ASCII pouvant avoir des symboles simples (appelés éléments de collation, c'est-à-dire des ensembles de lettres formant un tout indissociable pour le classement alphabétique) qui sont représentés par plus d'un caractère, de même qu'à plusieurs caractères équivalents du point de vue du tri et de la comparaison :

Symboles de collation

Un symbole de collation est un élément de collation multi-caractères enfermé dans des ``[.'' et ``.]''. Par exemple, si ``ch'' est un élément de collation, alors [[.ch.]] est une expression rationnelle qui correspond à cet élément, alors que [ch] est une expression rationnelle qui correspond à ``c'' ou à ``h''.

Classes d'équivalence

Une classe d'équivalence est le nom (localement spécifique) d'une liste de caractères équivalents. Le nom est délimité par ``[='' et ``=]''. Par exemple, le ``e'' pourrait être employé pour représenter tous les ``è'', ``é'' et ``e''. Dans ce cas-ci, [[=e=]] est une regexp qui représente n'importe quel caractère ``è'', ``é'' et ``e''.

Une expression rationnelle reconnaissant un unique caractère peut être suivie d'un ou de plusieurs opérateurs de répétition :

?

Le caractère précédent est facultatif et est reconnu tout au plus une fois.

*

Le caractère précédent sera reconnu zéro fois ou plus.

+

Le caractère précédent sera reconnu une ou plusieurs fois.

{n}

Le caractère précédent est reconnu exactement n fois.

{n,}

Le caractère précédent est reconnu n fois ou plus.

{,m}

Le caractère précédent est reconnu entre 0 et n fois.

{n,m}

Le caractère précédent est reconnu au moins n fois et au plus m fois.

Deux expressions rationnelles peuvent être concaténées ; l'expression rationnelle résultante reconnaît n'importe quelle chaîne constituée en concaténant les deux sous-chaînes qui reconnaissent respectivement les sous-expressions concaténées.

Deux expressions rationnelles peuvent être jointes par le symbole ``|'' ; l'expression rationnelle résultante reconnaît n'importe quelle chaîne reconnaissant l'une ou l'autre des deux sous-expressions.

Les répétitions ont priorité sur la concaténation, qui ont priorité sur l'alternance. Une sous-expression entière peut être délimitée entre parenthèses pour changer ces priorités.

Note : Si vous compilez Mutt avec le paquet GNU rx, les opérateurs suivants peuvent également être employés dans des expressions rationnelles :

\\y

Reconnaît une chaîne vide au début ou à la fin d'un mot.

\\B

Reconnaît une chaîne vide dans un mot.

\\<

Reconnaît une chaîne vide au début d'un mot.

\\>

Reconnaît une chaîne vide à la fin d'un mot.

\\w

Reconnaît n'importe quel caractère pouvant être contenu dans un mot (lettre, chiffre, ou tiret bas (underscore)).

\\W

Reconnaît n'importe quel caractère qui ne fait par parti d'un mot.

\\`

Reconnaît une chaîne vide au début d'un tampon (chaîne).

\\'

Reconnaît une chaîne vide à la fin d'un tampon.

Notez cependant que ces opérateurs ne sont pas définis par POSIX, ainsi ils peuvent être disponibles ou pas dans les bibliothèques courantes sur de divers systèmes.

4.2 Motifs

Plusieurs des commandes de Mutt vous permettent d'indiquer un motif pour sélectionner des messages (limit, tag-pattern, delete-pattern, etc.). Il y a plusieurs manières de choisir des messages :

~A              tous les messages
~b EXPR         messages contenant EXPR dans leur corps
~B EXPR         messages contenant EXPR (intégralité du message)
~c USER         messages avec une copie carbone (cc:) pour USER
~C EXPR         message est destiné à (to:) ou en copie (cc:) pour EXPR
~D              messages effacés
~d [MIN]-[MAX]  messages avec ``date-d-envoi'' dans l'intervalle Date
~E              messages arrivés à expiration
~e EXPR         message contenant EXPR dans le champ `'Sender''
~F              messages marqués important
~f USER         messages provenant de USER
~g              messages signés (PGP)
~G              messages chiffrés (PGP)
~h EXPR         messages contenant EXPR dans leurs en-têtes
~k              message contenant une clé PGP
~i ID           message avec ID dans le champ ``Message-ID''
~L EXPR         message provenant de ou reçu par EXPR
~l              message adressé à une liste de diffusion connue
~m [MIN]-[MAX]  message dans l'intervalle MIN à MAX *)
~n [MIN]-[MAX]  messages avec un score dans l'intervalle MIN à MAX *)
~N              nouveaux messages
~O              anciens messages
~p              message qui vous est adressé (voir $alternates)
~P              message que vous avez envoyé (voir $alternates)
~Q              messages auxquels vous avez répondu
~R              messages lus
~r [MIN]-[MAX]  messages avec `'date-reception'' dans l'intervalle Date
~S              messages remplacés (supersede)
~s SUBJECT      messages ayant SUBJECT dans l'objet (champ ``Subject'').
~T              messages marqués (tag)
~t USER         messages adressés à USER
~U              messages non lus
~v              message faisant partie d'une enfilade repliée
~x EXPR         messages contenant EXPR dans le champ `References'
~y EXPR         messages contenant EXPR dans le champ `X-Label'
~z [MIN]-[MAX]  messages avec une taille dans l'intervalle MIN à MAX *)
~=              doublons (voir $duplicate_threads)

Où EXPR, USER, ID, et SUBJECT sont des expressions rationnelles.

*) Les expressions <[MAX], >[MIN], [MIN]- et -[MAX] sont aussi authorisées.

Modificateur de motifs

Notons que les motifs qui reconnaissent des 'listes' d'adresses (notamment c, C, p, P et t) les reconnaissent s'il y en a au moins une qui correspond dans la liste entière. Si vous voulez vous assurer que tous les éléments de cette liste correspondent, vous devez mettre en tête de votre motif le caractère ``^''. Cet exemple reconnaît tous les courriers qui sont seulement destinés à l'Allemagne.

^~C \.de$

Motifs Complexes

L'expression logique AND est appelée en indiquant plusieurs critères. Par exemple :

~t mutt ~f elkins

choisit les messages qui contiennent le mot ``mutt'' dans liste des destinataires et qui contiennent le mot ``elkins'' dans le champ ``From'' de l'en-tête.

Mutt reconnait également les opérateurs suivants pour créer des motifs de recherche plus complexes :

Voici un exemple illustrant un motif complexe de recherche. Ce motif va sélectionner tous les messages qui ne contiennent pas mutt dans les champs ``To'' ou ``Cc'' et qui proviennent de ``elkins''.

!(~t mutt|~c mutt) ~f elkins

Voici un exemple utilisant des espaces dans les expressions rationnelles. (notez les délimiteurs ' et "). Pour que ceci corresponde, le sujet du courrier doit reconnaître ``^Junk +From +Me$'' et doit être en provenance de ``Jim +Somebody'' ou de ``Ed +SomeoneElse'' :

 '~s "^Junk +From +Me$" ~f ("Jim +Somebody"|"Ed +SomeoneElse")'

Recherche par date

Mutt supporte deux types de dates, les dates absolues et les dates relatives.

Absolue. Les dates doivent être de la forme JJ/MM/AA (le mois et l'année sont facultatifs, par défaut seront pris en compte le mois et l'année en cours). Voici un exemple d'intervalle de dates :

Limite les messages correspondant à : ~d 20/1/95-31/10

Si vous omettez la (première) date minimum, et que vous spécifiez juste ``-DD/MM/YY'', tous les messages avant la date donnée seront sélectionnés. Si vous omettez la (seconde) date maximum, et que vous spécifiez ``DD/MM/YY-'', tous les messages après la date donnée seront sélectionnés. Si vous indiquez une seule date sans le tiret (``-''), seuls les messages envoyés à la date donnée seront sélectionnés.

Marges d'erreur. Vous pouvez ajouter des marges d'erreur aux dates absolues. Une marge d'erreur est un signe (+ ou -), suivi d'un chiffre, suivi d'une des unités suivantes :

y       années
m       mois
w       semaines
d       jours
Vous pouvez remplacer le signe par le caractère ``*'', qui est équivalent à renseigner plus et moins dans les marges d'erreur.

Exemple : Pour choisir n'importe quel message deux semaines aux alentours du 15 Janvier 2001, vous pouvez utiliser le motif suivant :

 
Limite les messages correspondant à : ~d 15/1/2001*2w

Relatif. Ce type de date est relatif à la date du jour, et peut être spécifié comme suit :

Les décalages sont indiqués avec des nombres positifs suivis d'une des unités suivantes :

y       années
m       mois
w       semaines
d       jours

Exemple : Pour selectionner les messages de moins d'un mois, vous pouvez utiliser :

Limite les messages correspondant à : ~d <1m

Note : toutes les dates employées quand on fait une recherche sont relatives au fuseau horaire local, à moins que vous ne changiez la définition de votre $index_format pour inclure un autre format du type %[...] (ce ne sont pas les dates affichées dans l'index principal).

4.3 Using Tags

Sometimes it is desirable to perform an operation on a group of messages all at once rather than one at a time. An example might be to save messages to a mailing list to a separate folder, or to delete all messages with a given subject. To tag all messages matching a pattern, use the tag-pattern function, which is bound to ``shift-T'' by default. Or you can select individual messages by hand using the ``tag-message'' function, which is bound to ``t'' by default. See patterns for Mutt's pattern matching syntax.

Once you have tagged the desired messages, you can use the ``tag-prefix'' operator, which is the ``;'' (semicolon) key by default. When the ``tag-prefix'' operator is used, the next operation will be applied to all tagged messages if that operation can be used in that manner. If the $auto_tag variable is set, the next operation applies to the tagged messages automatically, without requiring the ``tag-prefix''.

4.4 Using Hooks

A hook is a concept borrowed from the EMACS editor which allows you to execute arbitrary commands before performing some operation. For example, you may wish to tailor your configuration based upon which mailbox you are reading, or to whom you are sending mail. In the Mutt world, a hook consists of a regular expression or pattern along with a configuration option/command. See

for specific details on each type of hook available.

Note: if a hook changes configuration settings, these changes remain effective until the end of the current mutt session. As this is generally not desired, a default hook needs to be added before all other hooks to restore configuration defaults. Here is an example with send-hook and the my_hdr directive:

send-hook . 'unmy_hdr From:'
send-hook ~Cb@b.b my_hdr from: c@c.c

Message Matching in Hooks

Hooks that act upon messages (send-hook, save-hook, fcc-hook, message-hook) are evaluated in a slightly different manner. For the other types of hooks, a regular expression is sufficient. But in dealing with messages a finer grain of control is needed for matching since for different purposes you want to match different criteria.

Mutt allows the use of the search pattern language for matching messages in hook commands. This works in exactly the same way as it would when limiting or searching the mailbox, except that you are restricted to those operators which match information mutt extracts from the header of the message (i.e. from, to, cc, date, subject, etc.).

For example, if you wanted to set your return address based upon sending mail to a specific address, you could do something like:

send-hook '~t ^me@cs\.hmc\.edu$' 'my_hdr From: Mutt User <user@host>'
which would execute the given command when sending mail to me@cs.hmc.edu.

However, it is not required that you write the pattern to match using the full searching language. You can still specify a simple regular expression like the other hooks, in which case Mutt will translate your pattern into the full language, using the translation specified by the $default_hook variable. The pattern is translated at the time the hook is declared, so the value of $default_hook that is in effect at that time will be used.

4.5 External Address Queries

Mutt supports connecting to external directory databases such as LDAP, ph/qi, bbdb, or NIS through a wrapper script which connects to mutt using a simple interface. Using the $query_command variable, you specify the wrapper command to use. For example:

set query_command = "mutt_ldap_query.pl '%s'"

The wrapper script should accept the query on the command-line. It should return a one line message, then each matching response on a single line, each line containing a tab separated address then name then some other optional information. On error, or if there are no matching addresses, return a non-zero exit code and a one line error message.

An example multiple response output:

Searching database ... 20 entries ... 3 matching:
me@cs.hmc.edu           Michael Elkins  mutt dude
blong@fiction.net       Brandon Long    mutt and more
roessler@guug.de        Thomas Roessler mutt pgp

There are two mechanisms for accessing the query function of mutt. One is to do a query from the index menu using the query function (default: Q). This will prompt for a query, then bring up the query menu which will list the matching responses. From the query menu, you can select addresses to create aliases, or to mail. You can tag multiple messages to mail, start a new query, or have a new query appended to the current responses.

The other mechanism for accessing the query function is for address completion, similar to the alias completion. In any prompt for address entry, you can use the complete-query function (default: ^T) to run a query based on the current address you have typed. Like aliases, mutt will look for what you have typed back to the last space or comma. If there is a single response for that query, mutt will expand the address in place. If there are multiple responses, mutt will activate the query menu. At the query menu, you can select one or more addresses to be added to the prompt.

4.6 Mailbox Formats

Mutt supports reading and writing of four different mailbox formats: mbox, MMDF, MH and Maildir. The mailbox type is autodetected, so there is no need to use a flag for different mailbox types. When creating new mailboxes, Mutt uses the default specified with the $mbox_type variable.

mbox. This is the most widely used mailbox format for UNIX. All messages are stored in a single file. Each message has a line of the form:

From me@cs.hmc.edu Fri, 11 Apr 1997 11:44:56 PST

to denote the start of a new message (this is often referred to as the ``From_'' line).

MMDF. This is a variant of the mbox format. Each message is surrounded by lines containing ``^A^A^A^A'' (four control-A's).

MH. A radical departure from mbox and MMDF, a mailbox consists of a directory and each message is stored in a separate file. The filename indicates the message number (however, this is may not correspond to the message number Mutt displays). Deleted messages are renamed with a comma (,) prepended to the filename. Note: Mutt detects this type of mailbox by looking for either .mh_sequences or .xmhcache (needed to distinguish normal directories from MH mailboxes).

Maildir. The newest of the mailbox formats, used by the Qmail MTA (a replacement for sendmail). Similar to MH, except that it adds three subdirectories of the mailbox: tmp, new and cur. Filenames for the messages are chosen in such a way they are unique, even when two programs are writing the mailbox over NFS, which means that no file locking is needed.

4.7 Mailbox Shortcuts

There are a number of built in shortcuts which refer to specific mailboxes. These shortcuts can be used anywhere you are prompted for a file or mailbox path.

4.8 Handling Mailing Lists

Mutt has a few configuration options that make dealing with large amounts of mail easier. The first thing you must do is to let Mutt know what addresses you consider to be mailing lists (technically this does not have to be a mailing list, but that is what it is most often used for), and what lists you are subscribed to. This is accomplished through the use of the lists and subscribe commands in your muttrc.

Now that Mutt knows what your mailing lists are, it can do several things, the first of which is the ability to show the name of a list through which you received a message (i.e., of a subscribed list) in the index menu display. This is useful to distinguish between personal and list mail in the same mailbox. In the $index_format variable, the escape ``%L'' will return the string ``To <list>'' when ``list'' appears in the ``To'' field, and ``Cc <list>'' when it appears in the ``Cc'' field (otherwise it returns the name of the author).

Often times the ``To'' and ``Cc'' fields in mailing list messages tend to get quite large. Most people do not bother to remove the author of the message they are reply to from the list, resulting in two or more copies being sent to that person. The ``list-reply'' function, which by default is bound to ``L'' in the index menu and pager, helps reduce the clutter by only replying to the known mailing list addresses instead of all recipients (except as specified by Mail-Followup-To, see below).

Mutt also supports the Mail-Followup-To header. When you send a message to a list of recipients which includes one or several subscribed mailing lists, and if the $followup_to option is set, mutt will generate a Mail-Followup-To header which contains all the recipients to whom you send this message, but not your address. This indicates that group-replies or list-replies (also known as ``followups'') to this message should only be sent to the original recipients of the message, and not separately to you - you'll receive your copy through one of the mailing lists you are subscribed to.

Conversely, when group-replying or list-replying to a message which has a Mail-Followup-To header, mutt will respect this header if the $honor_followup_to configuration variable is set. Using list-reply will in this case also make sure that the reply goes to the mailing list, even if it's not specified in the list of recipients in the Mail-Followup-To.

Note that, when header editing is enabled, you can create a Mail-Followup-To header manually. Mutt will only auto-generate this header if it doesn't exist when you send the message.

The other method some mailing list admins use is to generate a ``Reply-To'' field which points back to the mailing list address rather than the author of the message. This can create problems when trying to reply directly to the author in private, since most mail clients will automatically reply to the address given in the ``Reply-To'' field. Mutt uses the $reply_to variable to help decide which address to use. If set, you will be prompted as to whether or not you would like to use the address given in the ``Reply-To'' field, or reply directly to the address given in the ``From'' field. When unset, the ``Reply-To'' field will be used when present.

The ``X-Label:'' header field can be used to further identify mailing lists or list subject matter (or just to annotate messages individually). The $index_format variable's ``%y'' and ``%Y'' escapes can be used to expand ``X-Label:'' fields in the index, and Mutt's pattern-matcher can match regular expressions to ``X-Label:'' fields with the `` y'' selector. ``X-Label:'' is not a standard message header field, but it can easily be inserted by procmail and other mail filtering agents.

Lastly, Mutt has the ability to sort the mailbox into threads. A thread is a group of messages which all relate to the same subject. This is usually organized into a tree-like structure where a message and all of its replies are represented graphically. If you've ever used a threaded news client, this is the same concept. It makes dealing with large volume mailing lists easier because you can easily delete uninteresting threads and quickly find topics of value.

4.9 Support de DSN (notification de statut d'acheminement)

La RFC 1894 (DSN : Delivery Status Notification) définit un jeu de types MIME destinés à relayer l'état des courriers électroniques. Ceux-ci peuvent être vus comme des ``accusés de réception''. Berkeley sendmail 8.8.x possède des options de ligne de commande permettant au logiciel de messagerie client de choisir le type de messages d'état devant être retourné.

Deux variables sont disponibles pour gérer ceci. La variable $dsn_notify sert à demander des accusés pour différents résultats (comme envoi non réussi, message délivré, etc.). La variable $dsn_return contrôle la quantité de votre message devant être retournée avec l'accusé (en-têtes ou message complet). Veuillez vous référer au manuel de sendmail pour plus de détails sur DSN.

4.10 Support de POP3 (OPTIONNEL)

Si Mutt a été compilé avec le support du protocole POP3 (avec l'option --enable-pop du script configure), il est alors capable de travailler avec des boîtes aux lettres situées sur un serveur POP3 distant et de rapatrier des courriers pour consultation locale.

Vous pouvez accéder à la boîte POP3 distante en sélectionnant le dossier pop://serveurpop/

Vous pouvez préciser le numéro de port à utiliser sur le serveur avec la syntaxe suivante : pop://serveurpop:port/

Vous pouvez également spécifier un nom d'utilisateur différent pour chaque dossier de cette manière : pop://utilisateur@serveurpop[:port]/

Il est plus coûteux de vérifier la présence de nouveaux courriers par POP3 que localement. Pour cette raison, il est possible de contrôler la fréquence à laquelle Mutt va interroger le serveur distant à l'aide de la variable $pop_checkinterval (par défaut toutes les 60 secondes).

Si Mutt a été compilé avec le support de SSL (avec l'option --with-ssl du script configure), les connexions aux serveurs POP3 peuvent être chiffrées. Cela requiert naturellement que le serveur supporte les connexions chiffrées par SSL. Pour accéder à un dossier avec POP3/SSL, utilisez le préfixe pops:, ie : pops://[utilisateur@]serveurpop[:port]/

Un autre moyen d'accéder à vos courriers par POP3 est la fonction fetch-mail (raccourci par défaut : G), qui permet de se connecter à un serveur POP (défini par pop_host) et de rapatrier tous vos nouveaux courrier vers le spoule local ( spoolfile). Ensuite, Mutt fonctionne exactement comme si le courrier avait toujours été local.

Remarque : si votre seul besoin est de rapatrier tous vos messages vers des boîtes locales, vous devriez considérer l'utilisation de programmes spécifiquement conçus pour cette tâche, comme fetchmail.

4.11 Support d'IMAP (OPTIONNEL)

Si Mutt a été compilé avec le support d'IMAP (avec l'option --enable-imap du script configure), il est alors capable d'accéder à des dossiers situés sur un serveur IMAP distant.

Vous pouvez accéder à la boîte aux lettres distante en sélectionnant le dossier imap://serveurimap/INBOX, où serveurimap est le nom du serveur IMAP et INBOX est le nom particulier de votre boîte aux lettre courante (votre spoule) sur le serveur IMAP. Si vous souhaitez accéder un autre dossier sur le serveur IMAP, utilisez imap://serveurimap/chemin/vers/dossierchemin/vers/dossier est l'emplacement du dossier auquel vous voulez accéder.

Vous pouvez forcer le numéro de port en le précisant à la suite du nom du serveur, ie : imap://serveurimap:port/INBOX

Vous pouvez également spécifier un nom d'utilisateur différent pour chaque dossier, comme ceci : imap://utilisateur@serveurimap[:port]/INBOX

Si Mutt a été compilé avec le support de SSL (avec l'option --with-ssl du script configure), les connexions IMAP peuvent être chiffrées, à la condition naturelle que les serveurs IMAP supportent les connexions chiffrées par SSL. L'accès à un dossier par IMAP/SSL se fait en utilisant la syntaxe suivante : imaps://[utilisateur@]serveurimap[:port]/chemin/vers/dossier.

Une syntaxe compatible avec le logiciel de messagerie Pine peut également être utilisée, ie : {[utilisateur@]serveurimap[:port][/ssl]}chemin/vers/dossier

Notez que tous les serveurs n'utilisent pas / comme séparateur hiérarchique. Mutt parvient normalement à détecter le séparateur en usage sur le serveur et à convertir les chemins en conséquence.

Lorsque vous naviguez entre les dossiers d'un serveur IMAP, vous pouvez contrôler si vous voulez afficher tous les dossiers ou seulement ceux auxquels vous êtes inscrits, à l'aide de la commande toggle-subscribed. Voir également la variable $imap_list_subscribed.

L'interrogation d'un serveur IMAP pour vérifier la présence de nouveaux courriers peut causer des délais perceptibles. Vous souhaiterez donc paramétrer minutieusement les variables $mail_check et $timeout. Personnellement, avec

set mail_check=90
set timeout=15
j'obtiens de relativement bons résultats sur ma lente connexion RTC.

Notez que si le format de stockage mbox est utilisé sur un serveur UW antérieur à la version v12.250, il a été signalé que ce serveur déconnectait le client de messagerie si un autre client sélectionne le même dossier.

Le sélecteur de dossiers

Depuis la version 1.2, Mutt supporte la navigation entre les boîtes aux lettres d'un serveur IMAP. C'est dans les grandes lignes similaire au sélecteur de dossiers locaux, avec les différences suivantes :

Authentification

Mutt supporte quatre méthode d'authentification auprès des serveurs IMAP : SASL, GSSAPI, CRAM-MD5, et LOGIN (il existe un patch de Grant Edwards ajoutant le support de l'authentification NTLM pour vous autres, malheureux utilisateurs d'Exchange, mais il reste à intégrer dans la distribution officielle de Mutt). Il y a également un support pour le pseudo-protocole ANONYMOUS, qui vous permet de vous connecter à un serveur IMAP public sans disposer d'un compte sur celui-ci. Pour utiliser ANONYMOUS, utilisez simplement le nom d'utilisateur "anonymous" ou bien pas de nom du tout.

SASL est un "super-authentifiant" spécial, qui choisit parmi plusieurs protocoles (dont GSSAPI, CRAM-MD5, ANONYMOUS et DIGEST-MD5) le plus sécurisé disponible à la fois sur le serveur et votre machine cliente. En utilisant certaines de ces méthodes (comme DIGEST-MD5 et peut-être GSSAPI), l'intégralité de votre session sera chiffrée et invisible à ces foisonnants sniffeurs de réseaux. C'est la meilleure option, si vous en disposez. Pour l'utiliser, vous devez avoir la bibliothèque Cyrus SASL installée sur votre système, et Mutt doit avoir été compilé avec l'option --with-sasl.

Mutt essayera tour à tour les méthodes compilées dans Mutt et disponibles sur le serveur dans l'ordre suivant : SASL, ANONYMOUS, GSSAPI, CRAM-MD5, LOGIN.

Quelques variables sont disponibles pour contrôler l'authentification :

4.12 Gérer plusieurs comptes IMAP/POP (OPTIONNEL)

S'il se trouve que vous possédez des comptes sur plusieurs serveurs IMAP et/ou POP, il se peut que vous trouviez la gestion des paramètres d'authentification peu pratique et sujette à erreurs. La commande account-hook peut dans ce cas s'avérer utile. Ce "hook" (comportement contextuel) fonctionne comme un folder-hook, mais est invoqué chaque fois que vous accédez à une boîte aux lettres distante (également à l'intérieur du sélecteur de dossiers), et non seulement lorsque vous ouvrez la boîte.

Quelques exemples :

account-hook . 'unset imap_user; unset imap_pass; unset tunnel'
account-hook imap://serveur1/ 'set imap_user=moi1 imap_pass=foo'
account-hook imap://serveur2/ 'set tunnel="ssh host2 /usr/libexec/imapd"'

4.13 Démarrer un navigateur web sur les URLs (EXTERNE)

Si un courrier contient des URLs (unified ressource locator = adresse sur le web comme http://www.mutt.org/), il est pratique de disposer d'un menu présentant toutes ces URLs et permettant de démarrer un navigateur web sur l'une d'elles. Cette fonctionnalité est proposée par le programme externe urlview qui peut être trouvé à l'adresse ftp://ftp.guug.de/pub/mutt/contrib/, et par la configuration suivante :

macro index \cb |urlview\n
macro pager \cb |urlview\n


Next Previous Contents

L'équipe de traduction :