wiki/HowtoDovecot.md

---
categories: email
title: Howto Dovecot
...

* Documentation : <http://wiki2.dovecot.org/>

[Dovecot](https://www.dovecot.org/) est un puissant serveur POP et IMAP et
écrit en ayant comme but la sécurité. Les autres objectifs sont la légèreté et
la rapidité ainsi que la facilité à le mettre en place ; la configuration de
base, après installation, fournit un serveur POP/IMAP fonctionnel.

## Installation

~~~
# apt install dovecot-pop3d dovecot-imapd dovecot-sieve dovecot-ldap dovecot-managesieved
~~~

`dovecot-ldap` est à installer si l'authentification se fait sur un annuaire
LDAP mais il est également possible d'utiliser une base MySQL ou PostgreSQL,
avec le paquet adapté en conséquence.

## Configuration

La configuration de Dovecot se trouve dans le répertoire `/etc/dovecot`. Le
fichier principal est `dovecot.conf` mais la configuration se fait dans des
fichiers séparés dans `/etc/dovecot/conf.d/`.

Les paramètres globaux se définissent notamment dans `10-mail.conf`. Dans le
cas d'un compte Unix unique pour tous les comptes :

~~~
mail_location = maildir:/home/vmail/%d/%n

mail_uid = 5000
mail_gid = 5000
~~~

Pour utiliser LDAP comme backend d'authentification, ajouter ceci dans `10-auth.conf` :

~~~
!include auth-ldap.conf.ext
service auth {
  unix_listener auth-userdb {
    mode = 0600
    user = vmail
    group = vmail
  }
}
~~~

Et commenter la ligne suivante si on utilise pas du tout l'authentification via
PAM (important autrement PAM introduit un lag lors de l'authentification) :

~~~
#!include auth-system.conf.ext
~~~

Les paramètres de connexion à LDAP ainsi que la correspondance des champs
doivent être indiqués dans le fichier `/etc/dovecot/dovecot-ldap.conf.ext` :

~~~
hosts = 127.0.0.1
auth_bind = yes
ldap_version = 3
base = dc=example,dc=com
user_attrs = homeDirectory=home
user_filter = (&(isActive=TRUE)(uid=%u))
pass_attrs = uid=user,userPassword=password
~~~

### Authentification SMTP sur Dovecot

Il est possible de déléguer l'authentification SMTP de Postfix à Dovecot, ce
qui est pratique pour ne pas définir à 2 endroits différents les paramètres du
backend d'authentification utilisé. Dans Dovecot, il s'agit de faire écouter
Dovecot sur un socket Unix, sur lequel on pourra récupérer la liste des comptes
et tester l'authentification.

Dans le fichier `10-master.conf`, décommenter/adapter les lignes suivantes :

~~~
service auth {
  […]

  # Postfix smtp-auth
  unix_listener /var/spool/postfix/private/auth {
    mode = 0666
    user = postfix
    group = postfix
  }
}

Puis indiquer le chemin vers le socket dans la configuration de Postfix, relatif à son chroot :

~~~
smtpd_sasl_type = dovecot
smtpd_sasl_path = private/auth-client
~~~

### Configuration TLS

La configuration se fait dans le fichier `10-ssl.conf` :

~~~
ssl = required
ssl_cert = </etc/ssl/certs/example.com.crt
ssl_key = </etc/ssl/private/example.com.key
ssl_dh_parameters_length = 2048
~~~

Avec `ssl = required`, toutes les connexions POP/IMAP doivent être chiffrées. Un exception est cependant faite pour localhost, où les connexions en clair restent possibles.

La directive `ssl_cert` doit inclure le certificat du domaine ainsi que tous ceux de sa chaine de certification.

### Créer des boîtes IMAP automatiquement

Voir <http://wiki2.dovecot.org/MailboxSettings>

~~~
namespace inbox {
  location =
  mailbox Drafts {
    auto = no
    special_use = \\Drafts
  }
  mailbox Sent {
    auto = subscribe
    special_use = \\Sent
  }
  mailbox Spam {
    auto = subscribe
    special_use = \\Junk
  }
  mailbox Trash {
    auto = no
    special_use = \\Trash
  }
  prefix =
}
~~~

## Utiliser Dovecot comme LDA

Dovecot fournit un agent de livraison (LDA) nommé `dovecot-lda` via la commande
`deliver`.

Note : il est également possible d'utiliser le démon `dovecot-lmtp` (paquet _dovecot-lmtp_).

Ajouter la ligne suivante dans le fichier `/etc/postfix/master.cf` :

~~~
dovecot  unix  -  n  n  -  -  pipe flags=DRhu user=vmail:vmail argv=/usr/lib/dovecot/deliver -f ${sender} -d ${recipient}
~~~

Note : cela suppose que tous les comptes de courriels sont gérés par un unique compte unix _vmail_.

Puis dans `/etc/postfix/main.cf`, ajouter :

~~~
virtual_transport = dovecot
dovecot_destination_recipient_limit = 1
~~~

### Support du + dans les adresses

Il faut modifier les options de `deliver` dans le fichier `master.cf` de Postfix ainsi :

~~~
-  flags=DRhu user=vmail:vmail argv=/usr/lib/dovecot/deliver -f ${sender} -d ${recipient}                      
+  flags=DRhu user=vmail:vmail argv=/usr/lib/dovecot/deliver -f ${sender} -a ${recipient} -d ${user}@${nexthop}
~~~

### Gestion de Sieve

Sieve est un langage permettant d'écrire des règles de tri de courriel, du même
type que se que `procmail` offre. Il a cependant l'avantage d'être normalisé
dans le RFC 5228 et donc supporté par plusieurs clients.

Pour utiliser sieve, il faut l'ajouter à la directive `mail_plugins` dans le fichier `15-lda.conf` :

~~~
protocol lda {
  # Space separated list of plugins to load (default is global mail_plugins).
  mail_plugins = sieve
}
~~~

Dovecot lit par défaut le fichier _.dovecot.sieve_ à la racine du compte de
l'utilisateur et le compile à la volée. Si une erreur est rencontrée, il va
simplement ignorer le fichier et délivrer les messages dans la boite
principale, de sorte qu'aucun message ne soit perdu. Les erreurs de compilation
sont journalisées dans le fichier *.dovecot.sieve.log* à la racine du compte.

Il est également possible de définir des scripts sieve globaux à tous les
comptes, voir le fichier `90-sieve.conf`.

#### Exemple de règles

Voici quelques liens pour écrire les règles : <http://support.tigertech.net/sieve> <http://sieve.info/tutorials>

On peut aussi utiliser des outils pour générer les règles comme Roundcube, Horde/Ingo, etc. voir <http://sieve.info/clients>

##### Ajouter un message d'absence

~~~
require ["vacation"];

if anyof (true)
{
	vacation
		:days 1
		:subject "Message d'absence"
		text:
Bonjour,

Veuillez utiliser email@example.net à présent pour me contacter.

Cordialement,
.
;
}
~~~

~~~
require ["vacation", "variables"];

if header :matches "subject" "*" {
  vacation :days 3 :subject "Re: ${1}" "Bonjour,

Je suis indispo jusqu'au DD/MM/YYYY.

";
}
~~~

##### Tri sur le sujet

~~~
require ["fileinto", "copy"];

if header :contains ["Subject"] ["testsieve"] {
  fileinto "Test";
}

~~~

##### Déduplication des mails entrants

Pour réaliser un équivalent de la règle procmail suivante :

~~~
:0 Wh: msgid.lock
| formail -D 8192 $HOME/.msgid.lock
~~~

Testé avec Dovecot 2.2.13 en Jessie.

Ajouter le plugin sieve duplicate dans `/etc/dovecot/conf.d/90-sieve.conf` :

~~~
  sieve_extensions = +vnd.dovecot.duplicate
~~~

Puis dans les règles sieve :

~~~
require ["fileinto","vnd.dovecot.duplicate"];

if duplicate {
    fileinto "Trash";
}

# Si on est sûr de vouloir les supprimer
#if duplicate {
#     discard;
#}
~~~

Note : la ligne require doit être unique et en début de fichier, si des modules
sont déjà chargés il suffit d'ajouter "vnd.dovecot.duplicate".

En Jessie-backports, version 2.2.27, « duplicate » est intégré. Et il faut mettre dans une règle sieve :

```
require ["duplicate", "variables"];
if header :matches "message-id" "*" {
  if duplicate :uniqueid "${0}" {
    discard;
  }
}
```

##### Déplacer les emails avec un certain sujet dans une sous-boîte Junk

~~~
require ["fileinto", "mailbox"];

if header :contains "subject" ["[SPAM]"] {
  fileinto :create "Spam";
}
~~~

##### Redirection

~~~
if header :contains "Subject" "Foo Bar"
{
    redirect "jdoe@example.com";
}
~~~

##### Syntaxe 

Conditions :

~~~
if header :contains "Subject" "Foo"
if header :contains "Subject" ["Foo", "Bar"]
if address :domain "From" "qq.com"
if anyof (header :contains "X-Foo" "Bar", header :contains "X-Baz" "Qux")
~~~

Enchainement de conditions :

~~~
if CONDITION1 {
  ACTION1;
} elsif CONDITION2 {
  ACTION2;
} else {
  keep;
}
~~~

> *Note* : le else {keep;} est le comportement par défaut


#### managesieve

Dovecot supporte le protocole managesieve, qui permet d'éditer les règles
depuis un client compatible (Thunderbird, Roundcube avec le plugin du même nom,
etc…). Il faut installer le paquet _dovecot-managesieved_ :

~~~
# apt install dovecot-managesieved
~~~

Et, si on utilise Roundcube :

~~~
# apt install roundcube-plugins php-net-sieve
~~~

La configuration se fait dans le fichier `20-managesieve.conf`. Celle fournie
par défaut est fonctionnelle. Le démon `managesieved` écoute par défaut sur le
port TCP 4190.

## Mode debug

### Activer le raw logging

<http://wiki.dovecot.org/Debugging/Rawlog>

Par exemple en IMAP, il faut activer cela dans le _dovecot.conf_ :

~~~
protocol imap {
  mail_executable = /usr/lib/dovecot/rawlog /usr/lib/dovecot/imap
}
~~~

Ensuite, il suffit de créer un répertoire _dovecot.rawlog_ dans le $HOME
de l'utilisateur (accessible en écriture évidemment), et toutes les commandes
IMAP passées seront stockées dans des fichiers : `<annee><mois><jour>-.*.{in,out}`

### Debug pour l'authentification

Activer :

~~~
# queries.
auth_debug = yes
#auth_debug_passwords = yes
~~~

## Nombre max de processus de login

À chaque login, dovecot fork un processus. Afin d'éviter les fork-bomb s'il y a trop de connexions il y a une limite par défaut à 128. L'augmenter peut résoudre des problèmes si le serveur reçoit de nombreuses connexions.

~~~
login_max_processes_count = 256
~~~

Il faut en parallèle augmenter la limite sur le nombre de fichiers ouverts, dans _/etc/default/dovecot_ :

~~~
ulimit -n 5696
~~~

## Nombre max de connexion par IP+Login

Dovecot limite également le nombre de connexion IMAP d'une même IP avec un même compte.
Cette limite est de 10 par défaut, il est possible de l'augmenter en ajoutant dans la section IMAP :

~~~
mail_max_userip_connections = 42
~~~

Si la limite n'est pas assez haute, on aura cette erreur :

~~~
dovecot: imap-login: Maximum number of connections from user+IP exceeded (mail_max_userip_connections)
~~~


## Mountpoints

<http://wiki2.dovecot.org/Mountpoints>


## Erreurs de LOCK

Si vous avez des chargements très longs à l'authentification ou des erreurs de type :

~~~
-ERR [IN-USE] Couldn't open INBOX: Timeout while waiting for lock
~~~

c'est peut-être que les locks sont activés pour le protocole POP3. Ainsi, dès qu'une connexion POP3 est en cours,
elle bloques les autres connexions POP3... et même IMAP. Pour résoudre cela, s'assurer d'avoir activé :

~~~
pop3_lock_session=no
~~~

## Munin

Plusieurs plugins Munin sont disponibles sur <https://github.com/munin-monitoring/contrib/search?q=dovecot>

Nous utilisons principalement <https://raw.githubusercontent.com/munin-monitoring/contrib/master/plugins/mail/dovecot>
à télécharger dans /etc/munin/plugins/ avec les droits 755 que l'on fait tourner avec le groupe adm via
/etc/munin/plugin-conf.d/munin-node :

~~~
[dovecot]
group adm
~~~

## doveadm

La commande _doveadm_ permet d'avoir différentes interactions avec le serveur Dovecot. Par exemple :

~~~
# doveadm who
username                           # proto (pids)                                                  (ips)
jdoe@example.com                   1 imap  (4242)                                                  ()

# doveadm kick foo 192.0.2.0/24
kicked connections from the following users:
foo
~~~

## FAQ

### Erreur "Out of memory"

Si vous avez des erreurs du type :

~~~
dovecot: imap(foo): Fatal: block_alloc(16777216): Out of memory
dovecot: imap(foo): Fatal: master: service(imap): child 666 returned error 83 (Out of memory (service imap { vsz_limit=256 MB }, you may need to increase it))
~~~

Vous pouvez augmenter la mémoire _vsz_limit = 512M_ dans le service imap.

### Vérifier la conf

Pour vérifier qu'il n'y a pas d'erreur dans la conf

~~~
# doveconf -n
~~~

Il se peut que la configuration soit bonne mais qu'il y ait tout de
même une erreur (un certificat ssl qui n'existe pas, par exemple), on
peut alors lancer dovecot en mode debug

~~~
# dovecot -F
~~~