# Howto Dovecot

## Installation

Dovecot est un puissant serveur POP et IMAP.
Pour l'installer sous Debian :

~~~
# aptitude install dovecot-pop3d dovecot-imapd
~~~

## Configuration

La configuration de Dovecot se trouve dans le répertoire _/etc/dovecot_
et notamment le fichier _dovecot.conf_.

Pour activer les protocoles POP(S) et IMAP(S) :

~~~
protocols = imap imaps pop3 pop3s
~~~

Pour autoriser l'authentification en clair même sans SSL/TLS (attention,
les identifiants circuleront donc en clair !!) :

~~~
disable_plaintext_auth = no
~~~

### Support du + dans les adresses

Il faut patcher le 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}
~~~


### Crée 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 =
}
~~~

### SSL/TLS

~~~
ssl_cert = </etc/ssl/certs/mail.example.com.cert
ssl_key = </etc/ssl/private/mail.example.com.key
ssl_ca = </etc/ssl/certs/sub.class1.server.ca.pem
~~~

## Utiliser Dovecot/LDA pour utiliser le langage Sieve

Dovecot/LDA (ou deliver) est un agent de livraison fourni avec Dovecot, que Postfix peut utiliser pour délivrer les mails dans les maildir des utilisateurs d'un serveur mail. Celui-ci prend notamment en charge le langage "sieve", qui offre des fonctionnalités du même type que le programme "procmail".

~~~
# aptitude install dovecot-common
~~~

/etc/postfix/master.cf :

~~~
dovecot  unix  -  n  n  -  -  pipe flags=DORqhu user=dovelda
    argv=sudo /usr/lib/dovecot/deliver -n -f ${sender} -d ${recipient}
~~~

/etc/postfix/main.cf :

~~~
virtual_transport dovecot
dovecot_destination_recipient_limit = 1
~~~

Dans la configuration de sudo :

~~~
Defaults:dovelda !syslog
dovelda ALL=NOPASSWD:/usr/lib/dovecot/deliver
~~~

/etc/dovecot/dovecot.conf :

~~~
protocols = none
log_timestamp = "%Y-%m-%d %H:%M:%S "
mail_privileged_group = mail
mail_location = maildir:~
protocol imap {
}
protocol pop3 {
  pop3_uidl_format = %08Xu%08Xv
}
protocol sieve {
}
protocol lda {
  auth_socket_path = /var/run/dovecot/auth-master
  mail_plugins = sieve
  postmaster_address = postmaster@example.com
}
auth default {
  mechanisms = plain
  userdb ldap {
    args = /etc/dovecot/dovecot-ldap.conf
  }
  passdb ldap {
    args = /etc/dovecot/dovecot-ldap.conf
  }
  user = root
  socket listen {
    # for LDA
    master {
      path = /var/run/dovecot/auth-master
      mode = 666
      user = dovecot
    }
  }
}
dict {
}
plugin {
}
~~~

/etc/dovecot/dovecot-ldap.conf :

~~~
hosts = 127.0.0.1
base = dc=example,dc=com
ldap_version = 3
user_filter = (&(objectClass=mailAccount)(isActive=TRUE)(courierActive=TRUE)(uid=%u))
pass_attrs = uid=user,userPassword=password,homeDirectory=userdb_home,uidNumber=userdb_uid,gidNumber=userdb_gid
#dn = cn=courier,ou=ldapuser,dc=example,dc=com
#dnpass = xxx
#user_attrs = homeDirectory=home,uidNumber=uid,gidNumber=gid
~~~

On peut alors créer des fichiers .dovecot.sieve de ce type dans le $HOME d'un utilisateur, qui seront traités par dovecot/LDA :

Simple :

~~~
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 ["fileinto", "copy", "vacation", "variables"];

# Exemple d'une règle de filtrage
if header :contains ["Subject"] ["testsieve"] {
  fileinto "Test";
}

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

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

";
}
~~~

### Langage Sieve

On peut donc écrire des règles Sieve dans le fichier *.dovecot.sieve*

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>

#### Debug

Regarder dans le fichier *.dovecot.sieve.log*

### 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;
  }
}
```

## 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
~~~