wiki/HowtoDovecot.md

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

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

[Dovecot](https://www.dovecot.org/) est un serveur permettant l'accès à des emails avec les protocoles [POP](https://fr.wikipedia.org/wiki/Post_Office_Protocol) et [IMAP](https://fr.wikipedia.org/wiki/Internet_Message_Access_Protocol). Il possède toutes les fonctionnalités indispensables pour nous : la couche [SSL/TLS](HowtoSSL) pour sécuriser les échanges réseau, l'intégration avec [Postfix](HowtoPostfix), la gestion de l'authentification avec [LDAP](HowtoLDAP), le support du format de stockage [Maildir](https://fr.wikipedia.org/wiki/Maildir) et les filtres [Sieve](https://fr.wikipedia.org/wiki/Sieve). Nous aimons sa légèreté et sa rapidité, nous l'avons définitivement adoptés sur nos serveurs de messagerie en remplacement de [Courier POP/IMAP](http://www.courier-mta.org/).


## Installation

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

# dovecot --version
2.2.27 (c0f36b0)

# systemctl status dovecot
● dovecot.service - Dovecot IMAP/POP3 email server
   Loaded: loaded (/lib/systemd/system/dovecot.service; enabled; vendor preset: enabled)
   Active: active (running) since Wed 2017-10-11 02:37:57 CEST; 2 days ago
     Docs: man:dovecot(1)
           http://wiki2.dovecot.org/
 Main PID: 10102 (dovecot)
    Tasks: 6 (limit: 4915)
   CGroup: /system.slice/dovecot.service
           ├─10102 /usr/sbin/dovecot
           ├─10111 dovecot/anvil
           ├─10112 dovecot/log
           ├─13327 dovecot/config
           ├─13329 dovecot/auth
           └─20212 dovecot/auth -w
~~~

> * Note* : le paquet `dovecot-ldap` est utile uniquement pour gérer l'authentification avec un annuaire [LDAP](HowtoLDAP). Il est également possible de gérer l'authentification avec une base de données SQL, il faudra alors installer le paquet `dovecot-mysql` ou `dovecot-pgsql`.


## Configuration

Fichiers de configuration :

~~~
/etc/dovecot/
├── dovecot.conf
├── conf.d/
│   ├── 10-auth.conf
│   ├── 10-director.conf
│   ├── 10-logging.conf
│   ├── 10-mail.conf
│   ├── 10-master.conf
│   ├── 10-ssl.conf
│   ├── 10-tcpwrapper.conf
│   ├── 15-lda.conf
│   ├── 15-mailboxes.conf
│   ├── 20-imap.conf
│   ├── 20-managesieve.conf
│   ├── 20-pop3.conf
│   ├── 90-acl.conf
│   ├── 90-plugin.conf
│   ├── 90-quota.conf
│   ├── 90-sieve.conf
│   ├── 90-sieve-extprograms.conf
│   ├── auth-checkpassword.conf.ext
│   ├── auth-deny.conf.ext
│   ├── auth-dict.conf.ext
│   ├── auth-ldap.conf.ext
│   ├── auth-master.conf.ext
│   ├── auth-passwdfile.conf.ext
│   ├── auth-sql.conf.ext
│   ├── auth-static.conf.ext
│   ├── auth-system.conf.ext
│   ├── auth-vpopmail.conf.ext
│   └── z-evolinux-defaults.conf
├── dovecot-dict-auth.conf.ext
├── dovecot-dict-sql.conf.ext
├── dovecot-ldap.conf.ext
├── dovecot-sql.conf.ext
└── private/
~~~

La configuration se trouve dans le fichier `/etc/dovecot/dovecot.conf` qui inclut de nombreux fichiers séparés dans `/etc/dovecot/conf.d/*.conf`.

Le fichier `/etc/dovecot/conf.d/z-evolinux-defaults.conf` contient notre configuration de base :

~~~
# Autorise les mécanismes PLAIN/LOGIN même sans SSL/TLS
disable_plaintext_auth = no
auth_mechanisms = plain login

# Authentification LDAP + intégration avec Postfix pour l'auth SMTP
!include auth-ldap.conf.ext
service auth {
    unix_listener auth-userdb {
        mode = 0600
        user = vmail
        group = vmail
    }
    unix_listener /var/spool/postfix/private/auth-client {
        mode = 0666
        user = postfix
        group = postfix
    }
}

# Stockage des emails dans /home/mail avec UID/GID 5000/5000
mail_location = maildir:/home/vmail/%d/%n
mail_uid = 5000
mail_gid = 5000

# Activation Sieve
protocol lda {
    mail_plugins = sieve
}
~~~

Il est également important de commenter la ligne suivante si on utilise pas du tout l'authentification via PAM car cela évite d'avoir plusieurs secondes de 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

On conseille de déléguer l'authentification SMTP à Dovecot, ce qui est pratique pour ne pas définir à deux endroits différents les paramètres du
backend d'authentification utilisé. Cela consiste à faire écouter Dovecot sur une socket Unix (comme utilisé dans notre notre configuration de base) :

~~~
service auth {
  […]

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

puis indiquer le chemin vers la socket dans la configuration de Postfix :

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

### Configuration SSL/TLS

Il est fortement recommandé d'activer la couche [SSL/TLS](HowtoSSL).
Cela se fait ainsi :

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

> *Note* : la directive `ssl_cert` doit inclure le certificat du domaine ainsi que tous ceux de sa chaîne de certification.

À noter que si l'on veut forcer toutes les connexions POP/IMAP à utiliser SSL/TLS (sauf les connexions depuis *localhost*) , on utilise :

~~~
ssl = required
~~~

### Livraison avec Dovecot LDA

Dovecot fournit un agent de livraison (LDA) nommé `dovecot-lda` via la commande `deliver`.
Il est notamment important de l'utiliser pour pouvoir utiliser les filtres Sieve.

Avec Postfix, on ajoutera 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} -a ${recipient} -d ${user}@${nexthop}
~~~

et dans le fichier `/etc/postfix/main.cf` :

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

> *Note* : cela suppose que tous les comptes sont gérés par un unique compte Unix _vmail_.

Il également possible d'utiliser le démon *dovecot-lmtp* via le package `dovecot-lmtp`.


### Mailboxes Sent, Trash, Drafts, Junk

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

On peut créer automatiquement des sous-boîtes pour les clients IMAP.
Les noms sont à peu près normalisés dans la [RFC 6154](https://tools.ietf.org/html/rfc6154).

Voici comment créer automatiquement Sent, Trash, Drafts et Junk :

~~~
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 =
}
~~~


## Sieve

Sieve est un langage permettant d'écrire des règles de tri d'emails, du même type que [procmail](https://fr.wikipedia.org/wiki/Procmail).
Sieve est normalisé via la [RFC 5228](https://tools.ietf.org/html/rfc5228) et plusieurs clients email le supporte : *Mozilla Thundebird* via une [extension](http://sieve.mozdev.org/), [Roundcube](HowtoMail/Roundcube), [Ingo](https://www.horde.org/apps/ingo) etc.

Pour activer Sieve, il faut utiliser Dovecot LDA et ajuster la directive *mail_plugins* (comme utilisé dans notre notre configuration de base) :

~~~
protocol lda {
  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
~~~