Newer
Older
Sieve implementation for Dovecot v1.2
Sieve is a machine language specifically tailored for internet message
filtering. This package compiles into a Sieve plugin for the Dovecot local
delivery agent called Deliver. The plugin adds Sieve filtering support to the
delivery process.
Previously, the same functionality was provided by the cmusieve plugin for
Dovecot. This old plugin is based on the CMU Sieve implementation included with
the Cyrus project. This new package provides a complete rewrite of the Sieve
engine integrating it tightly with Dovecot. The actual execution of the Sieve
actions is based on the original cmusieve plugin, but only on the code added to
The main reason for rewriting the Sieve engine is to provide more reliable
script execution and to provide better error messages to users and system
administrators. Also, since the Sieve language evolves quickly, with new
language extensions published every year, the aim is to provide support for
quickly extending the engine with new features.
* Well-structured 3-stage compiler:
Uses dovecot framework and avoids using lex/yacc. Compiler doesn't bail on
first error, but tries to find more. Produced errors are aimed to be useful
and generally user-comprehensible. Things like 'Generic error' are a nuisance
of the past.
* Highly extendable with new Sieve capabilities:
This keeps the possibility of plugins in mind. It should eventually provide
the necessary infrastructure for at least all currently known (proposed)
extensions. The goal is to keep the extension interface provided by sieve
engine as generic as possible, i.e. without explicit support for specific
extensions. New similar extensions can then use the same interface methods
without changes to the sieve engine code. If an extension is not loaded using
the require command, the compiler truly does not know of its existance.
* Supports all extensions provided by the original CMUSieve plugin:
In addition, it has support for the new and very useful variables extension
(see next section).
* Supports executing multiple scrips sequentially.
Using this feature it is possible to execute administrator-controlled Sieve
scripts before and after the user's Sieve script is executed. As long as the
verdict is at least (implicit) keep, the execution will continue with the next
script. Multiple scripts can be executed before or after the user's script by
specifying directories containing sieve files.
* Supported by ManageSieve service:
This Sieve implementation is supported by the ManageSieve implementation for
Dovecot v1.2. Therefore, ManageSieve support can be added to Dovecot for the
new Sieve plugin just as for the cmusieve plugin.
This package includes a test suite to automatically asses whether the compiled
sieve engine works correctly. The test suite is an extension to the Sieve
language and is therefore easily extended with new tests. Currently, the
test suite is mostly limited to testing script processing. The performed actions
are not tested fully yet.
Implementation Status
---------------------
The the core of the language (as specified in RFC 5228) is fully supported. In
addition to that, this Sieve implementation features various extensions. The
following list outlines the implementation status of each supported extension:
Base specification (RFC5228):
fileinto: full
reject: full (without Dovecot LMTP currently no refuse support)
envelope: full
encoded-character: full
Other RFCs/drafts:
subaddress: mostly full; not configurable
comparator-i;ascii-numeric: full
relational: full
copy: full
regex: mostly full; but suboptimal and no UTF-8
body: mostly full, but text body-transform implementation is simple
and some issues make it still not completely RFC incompliant.
include: mostly full; needs some more work (no external binaries)
vacation: mostly full; handling of utf-8 in headers is non-existant
imapflags: full
variables: mostly full; currently no support for future namespaces
All implemented extensions are like the engine itself currently experimental.
A status of 'full' does not necessarily mean that the extension is bug-free or
even fully RFC-compliant. Check the TODO file for open issues.
Many more extensions to the language exist. Not all of these extensions are
useful for Dovecot in particular, but many of them are. Currently, the author
has taken notice of the following extensions:
editheader: planned, needs additional support from Dovecot though.
mimeloop: planned
These extensions will be added as soon as the necessary infrastructure is
available. Extensions already supported by cmusieve have priority, meaning that
notify is next in line.
Compiling and Configuring
-------------------------
Stephan Bosch
committed
Refer to INSTALL file.
Using
-----
The main purpose of this package is to replace the existing cmusieve plugin that
is currently available for Dovecot's deliver. With this respect it is currently
not very different from the cmusieve plugin implementation.
Unlike cmusieve, this sieve module logs runtime errors to <scriptfile>.log if
it can and not <scriptfile>.err. It appends new timestamped log entries to the
end of the logfile. If the log grows too large (currently > 10kB), the logfile
is rotated to <scriptfile>.log.0 and <scriptfile>.log starts out empty again.
The cmusieve plugin compiled the script into a file with an appended c, e.g.
'test.sievec'. This new implementation recognizes scripts to have the .sieve
extension. The binary is (by default) written to a file with extension .svbin.
This means that the default .dovecot.sieve is compiled into .dovecot.svbin.
Included scripts are currently always compiled into the main binary, meaning
that no other files are written and no permission to do so is necessary for the
global script directories.
To test the sieve engine outside deliver, it is useful to try the commands that
exist in the src/sieve-tools/ directory of this package. After installation,
these are available at your $prefix/bin directory. The following commands are
installed:
sievec - Compiles sieve scripts into a binary representation for later
execution.
sieved - Dumps the content of a Sieve binary file for (development)
debugging purposes.
sieve-test - This is a universal Sieve test tool for testing the effect of a
Sieve script on a particular message.. It allows compiling, running
and testing Sieve scripts. It can either be used to display the
actions that would be performed on the provided test message or it
can be used to test the actual delivery of one message and show the
messages that would normally be sent through SMTP.
When installed, man pages are also available for these commands. In this package
the man pages are present in doc/man and can be viewed before install using e.g.:
man -l doc/man/sieve-test.1
Various example scripts are bundled in the directory 'examples'. These scripts
were downloaded from various locations. View the top comment in the scripts for
url and author information.
Known issues
------------
Most open issues are outlined in the TODO file. The more generic ones are (re-)
listed here:
- Compile errors are sometimes a bit obscure and long. This needs work.
Suggestions for improvement are welcome.
- The documentation needs work. The wiki needs to be updated with the newly
Authors
-------
Refer to AUTHORS file.
Contact Info
------------
Stephan Bosch <stephan at rename-it dot nl>
IRC: Freenode, #dovecot, S[r]us
Please use the Dovecot mailing list <dovecot at dovecot.org> for questions about
this package. You can post to the list without subscribing, the mail then waits
in a moderator queue for a while. See http://dovecot.org/mailinglists.html