#+TITLE: Jaro Mail 4
#+AUTHOR: by Jaromil @ dyne.org
#+DATE: March 2016

#+OPTIONS: H:3 num:t toc:t \n:nil @:t ::t |:t ^:nil f:t TeX:t
#+EXCLUDE_TAGS: noexport


#+LaTeX_CLASS: article
#+LaTeX_CLASS_OPTIONS: [a4,onecolumn,portrait]
#+LATEX_HEADER: \usepackage[english]{babel}

#+LATEX_HEADER: \usepackage{ucs}
#+LATEX_HEADER: \usepackage{inputenc}
#+LATEX_HEADER: \usepackage{fontenc}
#+LATEX_HEADER: \usepackage{hyperref}
#+LATEX_HEADER: \usepackage{graphicx}
#+LATEX_HEADER: \usepackage{parskip}

#+LATEX_HEADER: \usepackage{makeidx}
#+LATEX_HEADER: \makeindex

#+LATEX_HEADER: \usepackage{lmodern}
#+LATEX_HEADER: \usepackage{fullpage}
#+LATEX_HEADER: \usepackage{wrapfig}
#+LATEX_HEADER: \usepackage{verbatim}

#+LATEX_HEADER: \usepackage[hang,small]{caption}
#+LATEX_HEADER: \usepackage{float}

#+LATEX_HEADER:\usepackage[textheight=1.8\textwidth,lmargin=20mm,rmargin=20mm,driver=pdftex,heightrounded,headsep=7mm,footskip=11mm,vmarginratio=1:1]{geometry}

#+LATEX_HEADER: \usepackage{fancyhdr}
#+LATEX_HEADER: \setlength{\headheight}{18pt}
#+LATEX_HEADER: \pagestyle{fancyplain}

#+LATEX: \fancyhf{}
#+LATEX: \fancyhead[L]{\rule[-2ex]{0pt}{2ex}\small JaroMail manual}
#+LATEX: \fancyhead[R]{\rule[-2ex]{0pt}{2ex}\small version 4}
#+LATEX: \fancyfoot[C]{-- \thepage\ --}
#+LATEX: \fancyfoot[R]{\small Dyne.org Foundation}
#+LATEX: \fancyfoot[L]{\small Free Software Manual}

#+LATEX: \renewcommand{\headrulewidth}{0.4pt}
#+LATEX: \renewcommand{\footrulewidth}{0.4pt}


#+LATEX: \pagebreak


* Introduction

Jaro Mail is an integrated suite of interoperable tools to manage
e-mail communication in a private and efficient way, without relying
too much on on-line services, in fact encouraging users to store their
email locally.

Rather than reinventing the wheel, this suite reuses existing free and
open source tools and protocols and is mainly targeted for
GNU/Linux/BSD desktop usage.

This manual illustrates the usage of Jaro Mail. The newest version of
this manual is made available on http://files.dyne.org/jaromail/jaromail-manual.pdf

** Features

[[file:jaromail-shot.jpg]]

#+LATEX: \footnotesize
   + Minimalistic and efficient interface with message threading
   + Targets intensive usage of e-mails and mailinglists
   + Stores e-mails locally in a reliable format (maildir)
   + Integrates whitelisting and blacklisting, local and remote
   + Can do search and backup by advanced expressions
   + Automatically generates filter rules (sieve)
   + Imports and exports VCard contacts to addressbook
   + Computes and shows statistics on mail traffic
   + Facilitates sending anonymous emails (Mixmaster)
   + Encrypted password storage using OS native keyrings
   + Advanced maildir tools (merge, backup, address extraction)
   + Defers connections for off-line operations
   + Checks SSL/TLS certificates when fetching and sending mails
   + Supports strong encryption messaging (GnuPG)
   + Multi platform: GNU/Linux/BSD, Apple/OSX
   + Old school, used by its author for the past 10 years
#+LATEX: \normalsize

** Vision

#+LATEX_BEGIN:
\begin{wrapfigure}{r}{0.5\textwidth}
  \begin{center}
    \includegraphics[width=0.48\textwidth]{foster_privacy.png}
  \end{center}
\end{wrapfigure}
#+LATEX_END:

The internet offers plenty of free services, on the wave of the Web2.0
fuzz and the community boom, while all private informations are hosted
on servers owned by global corporations and monopolies.

It is important to keep in mind that no-one else better than you can
ensure the privacy of your personal data. Server hosted services and
web integrated technologies gather all data into huge information
pools that are made available to established economical and cultural
regimes.

The vision behind this software is that of sharing a simple and
consistent way to operate e-mail communication with tools that are
available on most platforms and can be as well used remotely over a
secure shell connection.

Jaro Mail aims to facilitate the task of downloading and storing e-mail
archives off-line in a way that they can be still accessible in more
than 10 years time and independently of any software. Nowadays many
users have the habit of keeping all their e-mails on servers,
accessing them through an often clumsy web interface, while
downloading them can free space and improve their privacy.

#+LATEX: \pagebreak

* Diagram

A little diagram that clarifies a bit where do we place the components
and actions involved in managing one's email communication:

#+LATEX_BEGIN:
\begin{figure}
  \begin{center}
    \includegraphics[width=0.4\textwidth]{jaromail-diagram.png}
  \end{center}
\end{figure}
#+LATEX_END:



 | Acronym | Function              | Software  |
 |---------+-----------------------+-----------|
 | MUA     | Mail User Agent       | [[http://www.mutt.org][Mutt]]      |
 | MTA     | Mail Transport Agent  | [[http://www.fetchmail.info][Fetchmail]] |
 | LDA     | Local Delivery Agent  | Jaro Mail |
 | MDA     | Remote Delivery Agent | [[http://en.wikipedia.org/wiki/Sieve_(mail_filtering_language)][Sieve]]     |
 | SMTP    | Mail delivery agent   | [[http://msmtp.sourceforge.net][MSmtp]]     |
 | ANON    | Anonymous delivery    | [[http://mixmaster.sourceforge.net/][MixMaster]] |
 |         | Search engine         | [[http://notmuchmail.org/][Notmuch]]   |
 |         | Addressbook           | [[http://abook.sf.net][ABook]]     |
 | GPG     | Cryptographic Agent   | [[http://www.gnupg.org][GnuPG]]     |
 | STORE   | Cryptographic Storage | [[http://www.dyne.org/software/Tomb][Tomb]]      |


#+LATEX: \pagebreak

* Setup

** Build

   Jaro Mail needs to be built on GNU/Linux systems.

   For Apple/OSX users it comes in a pre-compiled bundle.

*** GNU/Linux

    Some dependencies are needed in order to build this software. The Makefile for GNU/Linux configures the build environment automatically on Debian and Fedora systems, using their packaging to install all needed packages.

    The dependencies to be installed on the system for JaroMail are
    - to *build*: gcc bison flex make autoconf automake sqlite3  libglib2.0-dev libgnome-keyring-dev
    - to *run*: fetchmail msmtp mutt pinentry abook wipe notmuch alot

      To install all needed components (done automatically, requires root):

: make

      Once compiled then *make install* will put all JaroMail files in */usr/local/share/jaromail*.

*** Apple/OSX

    Apple/OSX users that have no experience in building software can obtain a pre-built universal binary from our download zone on http://files.dyne.org/jaromail/binary

    One can simply drag JaroMail into Applications. When started JaroMail opens a Terminal window preconfigured with its environment, to activate it for any terminal add this to `~/.profile`:
: export PATH=/Applications/JaroMail.app/Contents/Resources/jaro/bin:$PATH

** Install

   Installing Jaro Mail once all dependencies are build is fairly
   easy: make a directory where all the emails and settings needs to be, change to the directory and init the environment:

: mkdir $HOME/Mail
: cd $HOME/Mail
: jaro init

   Every installation of Jaro Mail is fully reentrant, meaning the directory where it gets initialised contains all maildirs, configurations, filters, whitelist, addressbooks and other necessary files.

   A single user can have multiple Jaro Mail installations to permit the complete separation of E-Mail identities.

   If called from outside the installation directory, the *jaro* command will use the environmental variable *$JAROMAILDIR* to find out the active installation being in use. If one is using a different installation path then should first change that, i.e:

: export JAROMAILDIR=$HOME/OtherIdentities/Luther/Mail

* Configuration

   The place where Jaro Mail is installed (*$HOME/Mail* by default)
   contains all configuration files.

   For Apple/OSX users, this directory is inside their *$HOME/Library*, then *Application Support* and then *JaroMail*.

   From now own, we will call this place the *Mail directory*.

   Inside the *Mail directory* are all needed configurations to operate JaroMail. Such configurations are in readable plain text files that can be edited using any editor. Inside them there are comments to explain the settings: all comment lines start by '#' and will be ignored by JaroMail.

   The most important files to start configuring are:

   - Identity.txt : set up the way your email identity appear to others
   - Accounts/default.txt : main account configuration (there can be more)
   - Aliases.txt : more email addresses one may receive on the configured accounts
   - Filters.txt : Full set of mailinglist sorting rules
   - Applications.txt : mime type associations to programs used to open attachments
   - Mutt.txt : mutt specific custom configurations

** Send and receive mail

   Inside the Mail directory is found the folder *Accounts* with brief
   instructions and default templates to fill with Imap and Smtp account
   configurations to fetch mail. A default template will be found in
   fresh installations: *Accounts/default.txt*. The configuration can
   be edited with one's favourite text editor, the format of the file
   is pretty self-explanatory.

   It is possible to have more than one account (simply as a new file
   in the Accounts/ directory) and in fact when retreiving e-mails
   using the *jaro fetch* command all accounts will be processed,
   unless one is explicitly selected using the *-a* commandline
   option.

   The file *Identity.txt* is also found in the Mail directory and it
   contains basic settings on the published user identity (From:
   field) and any other Mutt specific configuration directives, such
   as custom headers appearing in composed e-mails and the default
   GPG[fn:gpg] key to be used when signing and encrypting them.  For
   more information about the vast amount of configurations that are
   supported please refer to the Mutt documentation[fn:muttman]

[fn:gpg] GPG stands for GNU Privacy Guard, a system to securely
encrypt and decrypt messages and files so that noone can read their
content, even when intercepting the communication.

[fn:muttman] The Mutt configuration manual is found on http://www.mutt.org/doc/manual or simply typing 'man mutt' in a console terminal.

** Filter mail

   In the mail directory a file named *Filters.txt* can be created and
   filled in with rules referencing the contents of the *From:*
   or *To:* fields of each e-mail that is fetched. The mails matching
   will be then saved in the indicated maildirs (created if not
   existing) to keep a bit of order, especially useful for mailinglist
   users.

   The format of the filters configurarion is pretty easy and self
   explanatory, an example is found in the appendix of this manual.


* Organization

  One of the main goals for Jaro Mail is to organize the e-mail workflow
  so that one's attention is dedicated to important communications,
  rather than being constantly distracted by various degrees of spam and
  the need to weed it out of the mailbox. This ambitious task is pursued
  by realizing an integrated approach consisting of flexible
  whitelisting and the distinction between mails from known people and
  the rest.

** Folders

   First lets start with a categorization of the standard maildirs and a
   brief description for each. This information is *very important* to
   understand how Jaro Mail works: these maildirs are standard in Jaro
   Mail, here they are listed in order of priority

| Folder         | What goes in there                               |
|----------------+--------------------------------------------------|
| *known*        | Mails whose sender is known (Whitelist)          |
| *priv*         | Unknown sender, we are among explicit recipients |
| *unsorted*     | Unknown sender, we are not among recipients      |
| *unsorted.ml*  | From a mailinglist that we haven't filtered yet  |
| *zz.blacklist* | Mails whose sender is not desired (Blacklist)    |
| *zz.spam*      | Mails that are tagged as spam (server-side)      |
| *zz.bounces*   | Mail bounces like mailman and similar            |

The advantage using such a folder organization is that every time we open up the mail reader we will be presented with something we are likely to be most interested in (known people replying our mails) and progressively, as we will have the time to scroll through, mails from "new people" or mass mailings of sort.

This setup is handy especially considering it produces *sieve* filters that can be uploaded to mail servers and processed server-side. Imagine having your email on a fixed computer, but occasionally checking it from a mobile phone: server-side filtering will save you time by presenting a clean INBOX of whitelisted contacts for the mobile phone use.

Please note this organization does not includes spam, which is supposedly weeded out on the server via spamlists: White/Blacklisting has more to do with our own selection of content sources than with the generic protection from random pieces of information.

At last, anything that is matched by filters configured in *Filters.txt* will be saved into the named maildir, whose name can be freely choosen.


** Whitelist

The way whitelisting works if quite crucial to this setup and, at the
same time, is fairly simple since it does not include any automatic
detection, learning filters, Markov chains or Bayesian A/I. We believe
the user should be in full control of prioritizing communication
channels and at the same time constantly able to tweak the setup in an
easy way.

To whitelist an address is sufficient to send it an e-mail: at the
moment the message is sent Jaro Mail will remember the destination
address and prioritize all messages coming back from it.
This we call implicit whitelisting.

To explicitly whitelist an address from inside the mail reader index
press [ *a* ] while selecting an email, this will add in the whitelist
the sender address (From: header). If you want to add all addresses
reached by the mail (From: To: and Cc: fields) use the same letter
capitalized pressing shift [ *A* ].

All addresses selected this way will have the privilege of ending up
in your *known/* folder, plus their name and e-mail will be completed
automatically when composing a new email, pressing the *Tab* key while
indicating them among the recipients.

** Blacklist

To blacklist an address instead one can use the [ *z* ] key while an
e-mail is selected on the index: the sender indicated in the From:
field will be downgraded to the very bottom of your priorities, closes
to spam than the rest, the most infamous *zz.blacklist/* folder.

** Organization In Brief

Below a recapitulation of keys related to the white and blacklisting
functionality, to be used in the e-mail index or when an e-mail is
open inside the mail user agent:

| List  | Key         | Function                | Fields        |
|-------+-------------+-------------------------+---------------|
| White | *a*         | Add the sender address  | From:         |
| White | *A* (shift) | Add all addresses       | From: To: Cc: |
| Black | *z*         | Blacklist the sender    | From:         |
| Black | *Z* (shift) | Blacklist all addresses | From: To: Cc: |

* Workflow

This section goes through a scenario of simple usage for Jaro Mail

** Fetch and read your mail at home

As you acces your computer where Jaro Mail has been configured, you can open a Terminal and type:

: jaro fetch

This will download all new mails.

If you have configured *fetchall* among the imap account options, then
will delete them from the server, freeing online space.

If you have configured the *keep* option, which is the default, Jaro Mail will only download the email that you have not yet read and in any case it won't delete anything from the server. Remove the *keep* option to delete on the server all emails that are downloaded.

: jaro

This will launch mutt on the first folder containing unread emails, starting from the *known* folder, then *priv*, then all the destinations specified by *Filters.txt* exactly in the ascending order they are listed in that configuration file..

From there on, pressing *=* or *c* you can change to other folders and your *unsorted* and *unsorted.ml* mails.

** Write a new mail

If you like to write a mail to someone, hit *m* and write the recipient address, you will be then asked about any additional Cc: recipients.

If you don't remember the emails of the recipients, you can just type their name or parts of the email you remember, then press the [ *Tab* ]
key for completion. A list of addresses may popup with matches found in your whitelist addressbook to help remind who are you looking for.

The email is composed using a special [[http://www.vim.org/][Vim]] configuration that facilitates justifying text to 72 columns using [ *ctrl-j* ]. After composing the email you will be able to review it and change:

 - the From: field using [ *ESC f* ]
 - the recipient in the To: field using [ *t* ]
 - the recipients in the Cc: field using [ *c* ]
 - the subject string using [ *s* ]

You'll also be able to add more attachments by pressing *a* and use the arrow keys to move over the existing ones and delete them using [ *D* ] (please note that is a uppercase D, because lowercase d will just add a description for the attachment).


At last, when ready, pressing *y* will queue the email into the outbox, ready for sending.

One can review at any time the sending queue, which is just another maildir named *outbox*

: jaro outbox

Mails can be deleted from this view using [ *d* ] or edited using [ *e* ] which will allow tweaking of both the header and body of the email.

Once sure the outbox contains all what needs to be sent, make sure the computer is connected to the Internet and issue the *send* command:

: jaro send

Jaro Mail will send all emails in outbox, one by one, listing their recipients and size while doing so. If successful, mails will be removed from the outbox and put into the *sent* folder, which can be accessed from inside mutt or with the command *jaro open sent*.

** Write a new email from the commandline

Jaro Mail supports a lot of commandline operations based on stdin/stdout pipes, which makes it pretty easy to use in scripts that send emails and attachments.

If you have written a plain-text email using your favorite editor, you can send it quickly using the commandline: save the email into a txt file and then pipe it into *jaro compose* followed by a list of recipients and, optionally a list of filenames to attach. For example:

: cat Greetings.txt | jaro compose friends@dyne.org picture01.jpg jingle02.mp3 ~/myicons/*

The command above may send an email with various separate attachments (using MIME encapsulation): a picture, an hopefully small audio file and a list of icons which are all the files contained into the myicons/ directory. In this case the recipient will be friends@dyne.org, but may be any other email address found on the commandline in any position.

Once executed you will find this email in *jaro outbox*, ready to be reviewed and sent with *jaro send*.

** Reply messages

While browsing through the index of emails in various folders, one can reply any of them just by pressing the [ *r* ] key, which will ask if
the original message should be quoted and then open your favorite editor to compose your text.

If the email you are replying has been sent to multiple recipients (for instance using multiple addresses in the Cc: or From: fields) they will all be included, but you will have the possibility to exclude them by hand, editing the Cc: field. To remove them all at once use [ *ctrl-k* ] just like deliting a line on the terminal.

It is also possible to forward a message to someone else than the sender, for instance to submit it to his or her attention, or that of a mailinglist. To do that, you can use the [ *f* ] key which will present you with the full message and the possibility to write something on top of it, to describe its contents to its new recipients. Forwards include all attachments and are sent as attachments themselves, but this behavious can be changed as a confirmation to "send forward as attach" is asked.

** Peek without downloading anything

If you are around and like to see your new mails without downloading
them, then you can use the *peek* function:

: jaro peek

This will open the default configured IMAP account and folder over SSL protocol (securing the data transfer) and allow you to browse, read and reply  your emails without downloading them.

Using peek you can reply and even delete emails, but be careful since what you delete here will be removed from the server and won't be
there when you download it from home.

This functionality can be also very useful if you are from a slow connection and need to delete some email that is clogging it and that you are not able to download because of its size.

The peek command will automatically open the INBOX, but also other remote imap folders can be specified, like for instance *priv* or *unsorted* if whitelisting is also setup server-side (the sieve filters generated by Jaro Mail need to be uploaded on the server). To have a list of imap folders on the server a command is also available:

: jaro imap listfolders

Will list on the terminal all folders found on the imap account, one per line.

** Save important emails for later

Sometimes one can be on the rush while reading emails (local or via imap) and flagging them as important can be useful to keep focus on
priorities. In some cases it is very useful to save such important messages locally for later reference, for instance in a folder keeping messages that need to be remembered and that will constitute a kind of TODO list (a'la GTD).

Jaro Mail implements such functionalities: by pressing the [ *F* ] key (uppercase) one can flag an email, which will turn bright-green in the
index. In addition to that there is a folder called *remember/* where one can copy emails on the fly using the [ *R* ] key (uppercase) any time. Messages will be duplicated into the remember folder (which of course can be opened with the command *jaro remember*) so they can
also be edited with annotations on the task they refer to, for instance using the [ *e* ] key, without affecting the original message.

** Workflow in brief

Below a recapitulation of keys commonly used in our workflow

| Key   | Function                             |
|-------+--------------------------------------|
| *m*   | Compose a new message                |
| *Tab* | Complete addresses and folders input |
| *r*   | Reply to the sender of a message     |
| *d*   | Delete a message                     |
| *y*   | Send a message (queue in outbox)     |
| *f*   | Forward a message to new recipients  |
| *=*   | List all filtered maildir folders    |
| *c*   | Change to another folder             |
| *F*   | Flag a message as important          |
| *R*   | Copy a message to remember           |
| *s*   | Move a message to another folder     |
| *C*   | Copy a message to another folder     |



* Searching

Searching across all your emails it is as important as demanding of a task. Jaro Mail implements it using [[https://notmuchmail.org/][Notmuch]] which is relying on the [[http://xapian.org][Xapian]] search engine, completely relying on local computations made on your machine, there is no data at all being communicated on-line.

To index and tag all your emails that are locally archived in Jaro Mail use:

: jaro index

This will take a while and increase the size of the storage of about one sixth of its total occupation, but will definitely come useful when in need of searching rapidly across all available emails. To run a search for emails containing the '/open source/' string, do

: jaro search open source

To search for all emails containing this string and dated between now and the last two weeks, do

: jaro search open source date:2w..

The search command prints out a list of found filenames which may be useful to a script, but less useful to a human. In order to read a quick summary of the emails found it is possible to pipe the results into the *headers* command which will print out date, sender and subject of each file

: jaro search open source date:2w.. | jaro headers

Searching has also an interactive interface called *alot* which pops up to show search results and browse through them, refine the terms and in general operate on emails with the usual keys. One can also reply to emails directly from alot:

: jaro alot search expression strings folder:known

To restrict the search to a single folder, one can use the *folder:* prefix to search terms. Tags can be used also with *tag:* as well dates can be specified with ranges using *date:*. Consecutive string expressions are aloud to refine the search match, connected with logical and/or, plus also the header to search can be indicated, as for instance *from:* or *to:*. Read more about this below in the /Search term/ and /Date and time search/ sections (extracts from the *notmuch-search-terms* manpage) and on the notmuch webpage at http://notmuchmail.org

With the *addr* command the search will be run on the whitelist addressbook entries instead of actual email contents.

: jaro addr joe

Will list all addresses matching the string 'joe' inside the /whitelist/ addressbook. Also the blacklist can be searched this way adding the switch *-l blacklist*.


** Combining terms

In addition to individual terms, multiple terms can be combined with Boolean operators ( *and*, *or*, *not* , etc.). Each term in the query will be implicitly connected by a logical AND if no explicit operator is provided.

Parentheses can also be used to control the combination of the Boolean operators, but will have to be protected from interpretation by the shell, (such as by putting quotation marks around any parenthesized expression).

** Search terms

The search terms can consist of free-form text (and quoted phrases) which will match all messages that contain all of the given terms/phrases in the body, the subject, or any of the sender or recipient headers.

As a special case, a search string consisting of exactly a single asterisk "*" will match all messages.

In addition to free text, the following prefixes can be used to force terms to match against specific portions of an email, (where <brackets> indicate user-supplied values):

: from:<name-or-address>
: to:<name-or-address>
: subject:<word-or-quoted-phrase>
: attachment:<word>
: tag:<tag> (or is:<tag>)
: id:<message-id>
: thread:<thread-id>
: folder:<directory-path>
: date:<since>..<until>

The /from:/ prefix is used to match the name or address of the sender of an email message.

The /to:/ prefix is used to match the names or addresses of any recipient of an email message, (whether To, Cc, or Bcc).

Any term prefixed with /subject:/ will match only text from the subject of an email. Searching for a phrase in the subject is supported by including quotation marks around the phrase, immediately following /subject:/.

The /attachment:/ prefix can be used to search for specific filenames (or extensions) of attachments to email messages.

For /tag:/ and /is:/ valid tag values include /inbox/ and /unread/ by default for new messages added by /notmuch new/ as well as any other tag values added manually with /notmuch tag/.

For /id:/, message ID values are the literal contents of the Message-ID: header of email messages, but without the '<', '>' delimiters.

The /thread:/ prefix can be used with the thread ID values that are generated internally by notmuch (and do not appear in email messages).  These thread ID values can be seen in the first column of output from /notmuch search/

The /folder:/ prefix can be used to search for email message files that are contained within particular directories within the mail store. If the same email message has multiple message files associated with it, it's sufficient for a match that at least one of the files is contained within a matching directory. Only the directory components below the top-level mail database path are available to be searched.


** Date and time search

See /DATE AND TIME SEARCH/ below for details on the range expression,
and supported syntax for <since> and <until> date and time expressions.

The /date:/ prefix can be used to restrict the results to only messages within a particular time range (based on the Date: header) with a range syntax of:

: date:<since>..<until>

The syntax /<initial-timestamp>..<final-timestamp>/ can be represented using the number of seconds since 1970-01-01 00:00:00 UTC.

The search syntax also understands a variety of standard and natural ways of expressing dates and times, both in absolute terms '/2012-10-24/' and in relative terms '/yesterday/'. Any number of relative terms can be combined '/1 hour 25 minutes/' and an absolute date/time can be combined with relative terms to further adjust it. A non-exhaustive description of the syntax supported for absolute and relative terms is given below.

*** The range expression

: date:<since>..<until>

The above expression restricts the results to only messages from <since> to <until>, based on the Date: header.

<since> and <until> can describe imprecise times, such as "yesterday". In this case, <since> is taken as the earliest time it could describe (the beginning of yesterday) and <until> is taken as the latest time it could describe (the end of yesterday).  Similarly, date:january..february matches from the beginning of January to the end of February.

Currently, we do not support spaces in range expressions. You can replace the spaces with '\_', or (in most cases) '-', or (in some cases) leave the spaces out altogether. Examples in this man page use spaces for clarity.

Open-ended ranges are supported (since Xapian 1.2.1), i.e. it's possible to specify date:..<until> or date:<since>.. to not limit the start or end time, respectively.

Entering date:expr without ".." (for example date:yesterday) won't work, as it's not interpreted as a range expression at all. You can achieve the expected result by duplicating the expr both sides of ".." (for example date:yesterday..yesterday).

*** Relative date and time

: [N|number]
:    (years|months|weeks|days|hours|hrs|minutes|mins|seconds|secs) [...]

All refer to past, can be repeated and will be accumulated.

Units can be abbreviated to any length, with the otherwise ambiguous single m being m for minutes and M for months.

Number can also be written out one, two, ..., ten, dozen, hundred.  Additionally, the unit may be preceded by "last" or "this" (e.g., "last week" or "this month").

When combined with absolute date and time, the relative date and time specification will be relative from the specified absolute date and time.

Examples:

: 5M2d

: two weeks

*** Absolute time formats

: H[H]:MM[:SS]
: [(am|a.m.|pm|p.m.)]
: H[H] (am|a.m.|pm|p.m.)
: HHMMSS
: now
: noon
: midnight

Examples:

: 17:05

: 5pm

*** Absolute date formats

: YYYY-MM[-DD]
: DD-MM[-[YY]YY]
: MM-YYYY
: M[M]/D[D][/[YY]YY]
: M[M]/YYYY
: D[D].M[M][.[YY]YY]
: D[D][(st|nd|rd|th)] Mon[thname] [YYYY]
: Mon[thname] D[D][(st|nd|rd|th)] [YYYY]
: Wee[kday]

Month names can be abbreviated at three or more characters.

Weekday names can be abbreviated at three or more characters.

Examples:

: 2012-07-31

: 31-07-2012

: 7/31/2012

: August 3

*** Time zones

: (+|-)HH:MM

: (+|-)HH[MM]

Some time zone codes.

Examples:

: UTC
: EET


* Compute and visualize statistics

The *stats* command is useful to quickly visualize statistics regarding folder usage as well the frequency of emails found in a stream from stdin. Such streams can be produced by the *search* and *extract* commands for instance and passed to stats in order to have a more graphical (yet ASCII based) visualization of results.

For example lets visualize the frequency of email domain hosts in our whitelist:

: jaro addr | jaro stat emails

Will print out bars and domains in descending order, highlighting the most frequent email domain in our contacts, which turns out to be very often gmail.com, unfortunately for our own privacy.

To visualize the frequency of traffic across our filtered folders in the past month:

: jaro search date:1w.. | jaro stat folders

Will show quantities of mails filed to folders during the past week, quickly highlighting the mailinglists that have seen more recent activity.

To see who is most active in a mailinglist which is filtered to a folder:

: jaro search folder:org.dyne.dng | jaro extract stdin from | jaro stat names

Will give an overview on who is the most prolific writer in the /org.dyne.dng/ mailinglist, filed into the folder by a rule in *Filters.txt* like:

: to    dng@lists.dyne       save         org.dyne.dng

Please note the *extract* command is there to extract email addresses and names found in the /From:/ field of all search hits, the command is explained better in the next chapter: /Addressbook/.

** Statistics in brief

All *stats* commands takes lists of addresses or email messages from stdin.

| command       | effect                                                                       |
|---------------+------------------------------------------------------------------------------|
| stats email   | reads addresses from stdin, prints out stats on frequency of emails found    |
| stats names   | reads addresses from stdin, prints out stats on frequency of names found     |
| stats folders | reads paths to messages from stdin, prints out stats on frequency of folders |

So in case of *stats email* or *stats names* any result of search must be first filtered by *extract* in order to provide addresses to stats, else errors will occur. To limit the stats to the /From:/ field use the *extract stdin from* also shown in examples, any other refinement can be done also in the domain of the search commands.

* Addressbook

Addressbooks are the files storing the whitelist, the blacklist and optionally other custom lists of addresses. The format we use is native *abook* database files, by convention in /$JAROMAILDIR/whitelist.abook/ and /$JAROMAILDIR/blacklist.abook/. More custom addressbooks can be used by specifying them using *-l* on the commandline, for instance *-l family* will query the /$JAROMAILDIR/family.abook/ addressbook; when not used, *whitelist* is the default.

Addressbooks can be edited using a interactive console interface, for instance to add or delete entries by hand: use the *abook* command and optionally the *-l* option.

: jaro abook

This will open the current whitelist for edit. To edit the blacklist add *-l blacklist* instead.

To quickly dump to the console all names and addresses in the Jaro Mail addressbook, one can use the *list* command

: jaro list

To match a string across the addressbook, simply use the composite command *addr* followed by strings, for instance:

: jaro addr dyne

will list all addresses containing 'dyne' in your whitelist.

** Address lists

Jaro Mail handles lists of addresses as plain text files or streams with entries formatted as '/Name <email>/' and newline terminated. This simple format conforms (or is normalized to) the RFC822 standard and UTF-8 charset encoding, both produced on /stdout/ and read from /stdin/ by various useful commands to take advantage of console piping.

Such lists of addresses are the output of the *extract* command, which is able to read the output of other commands and extract a list of email addresses found.

: jaro search open source date:2w..  | jaro extract stdin

Will print to stdout the list of addresses found among the results of a search for /open source/ through all the emails archived in the past 2 weeks.

: jaro search date:1y.. and folder:known | jaro extract

Will print a sorted list of unique addresses found in the emails matching the search expression '/date:1y.. and folder:known/', meaning all messages stored in the '/known/' folder and not older than 1 year from now.

The *import* command is complementary to extraction: it reads an address list from stdin and imports it inside an addressbook specified using '-l' or a /group/ list file provided as argument.

: jaro search folder:unsorted | jaro extract | jaro import -l blacklist

Will extract all addresses found in unsorted (the maildir collecting all non-mailinglist emails in which we are not an explicit recipient) and put them into our blacklist.

** Export to VCard and other formats

VCard is an exchange format useful to interface with other addressbook software and mobile phones, as well with spyware as Google and Apple mail. Jaro Mail supports converting address lists to a variety of formats thanks to /abook/:

: jaro addr | jaro export vcard

Will take the list of addresses in whitelist and convert it to the *vcard* format on stdout, ready to be redirected to a file.

Here below a list of output formats supported as argument to export:

| Format  | Description                         |
|---------+-------------------------------------|
| abook   | abook native format                 |
| ldif    | ldif / Netscape addressbook (.4ld)  |
| vcard   | vCard 2 file                        |
| mutt    | mutt alias                          |
| muttq   | mutt query format (internal use)    |
| html    | html document                       |
| pine    | pine addressbook                    |
| csv     | comma separated values              |
| allcsv  | comma separated values (all fields) |
| palmcsv | Palm comma separated values         |
| elm     | elm alias                           |
| text    | plain text                          |
| wl      | Wanderlust address book             |
| spruce  | Spruce address book                 |
| bsdcal  | BSD calendar                        |
| custom  | Custom format                       |

Of course *export* works with any list of addresses from stdin, for instance the result of *extract* operations on search queries, so that multiple commands can be concatenated.


** Addressbook in brief

Here a roundup on the addressbook commands that are available from the /jaro/ commandline script. Arguments '-l abook' take the string to identify

| Command   | Arguments   | Function (print on stdout, import from stdin)    |
|-----------+-------------+--------------------------------------------------|
| *abook*   | -l listname | edit the addressbook (default whitelist)         |
| *addr*    | search expr | print list of addresses matching expression      |
| *extract* | maildir     | print address list of all mails in maildir       |
| *extract* | gpg keyring | print address list of gpg public keyring         |
| *extract* | gpg pubkey  | print address list of gpg key signatures         |
| *extract* | vcard file  | print address list of entries in VCard file      |
| *import*  | -l listname | import address list from stdin to addressbook    |
| *export*  | format      | convert address list to a format (default vcard) |


* Storage and backup

Most existing e-mail systems have their own storage format which is
often over-complicated and forces us to convert our archives to it.

Jaro Mail stores emails using the well documented format *Maildir*
which is common to many other free and open source e-mail software and
was developed and well documented by D.J. Bernstein.

We can safely say that the Maildir format to store e-mails will stay
the same and well compatible in 10 years from now, if not more, mostly
because of its simplicity: that's what we need the most from a storage
format after all.

Quoting him about the wonders of this format:

#+BEGIN_QUOTE

Why should I use maildir?

Two words: no locks. An MUA can read and delete messages while new
mail is being delivered: each message is stored in a separate file
with a unique name, so it isn't affected by operations on other
messages. An MUA doesn't have to worry about partially delivered mail:
each message is safely written to disk in the tmp subdirectory before
it is moved to new. The maildir format is reliable even over NFS.[fn:djb]

#+END_QUOTE

[fn:djb] http://cr.yp.to/proto/maildir.html

What this virtuous, sometimes very cryptical man is trying to say here
is that the Maildir format in its simplicity of implementation
represents an extremely reliable way to retreive and store emails
without the risk of losing any if the Internet connection goes down.

While skipping over the internal details of this storage system, which
basically consists in plain text files saved into sub-directories, we
will have a look at some very interesting features that Jaro Mail can
offer to its users and to the even larger audience of Maildir format
users.

** Merge maildirs

Jaro Mail can safely merge two different maildirs basically gathering all e-mails stored in them into a unique place. This is done using two arguments, both maildir folders: the first is the source and the second is the destination e-mails from both will be gathered:

: jaro merge ml.saved-mails ml.global-archive

The above command will move all emails stored inside the maildir folder "ml.saved-mails" to the other maildir folder "ml.global-archive". Upon success the first argument "ml.saved-mails" will be deleted and all its contents will be found in "ml.global-archive".

** Remove duplicates from maildir         :noexport:

As a result of a merge or a multiple fetch of e-mails, it can often
occur that a maildir contains duplicates which are also highlighted in
red in the e-mail index and, if many, can be tedious to eliminate by
hand. Jaro Mail offers the automatic functionality of removing all
duplicate emails from a maildir folder using the *rmdupes* command:

: jaro rmdupes ml.overflow

Will look for all duplicates emails in the "ml.overlow" maildir,
matching them by their unique *Message-Id:* header and a SHA1 hash of
their content[fn:formail], and delete all duplicates for mails that
are present more than once.

[fn:formail] The standard utility 'formail -D' is used for this operation

** Backup mails

To facilitate the separation of stored email files across maildirs, for instance to move from a maildir to another all those mails that are older than a certain period, Jaro Mail implements the *copy* and *move* commands, reading a list of paths from stdin (as result of a search, for instance) and moving them to a destination maildir while preserving their reading state (new or cur).

For instance to move all archived mails older than 3 years into a separate folder:

: jaro search date:3y.. | jaro move /media/backup/old.mails

This will move all the emails found by the search expression /date:3y../ (all mails older than 3 years) into '/media/backup/old.mails/' which must be a maildir.

The same way one could use *jaro copy* to not delete originals or even *jaro link* to create symlinks to results into a new maildir, without increasing occupation and allowing to review results with the help of an external program supporting maildirs, for instance using directly

: mutt -f /media/backup/old.mails

This functionality is studied explicitly to be flexibly adopted in various situations and scripts, so the backups should really be customized ad-hoc for the particular setup.

** Filter a maildir

If filters are updated or one desires to import a maildir into Jaro
Mail processing it through its filters, the *filter* command is
provided to (re)filter a maildir. First edit *Filters.txt* with matches for the to: (which includes cc:) and from: header fields, then run:

: jaro update

To tell Jaro Mail to update its internal filters according to the modifications, and then:

: jaro filter my-old-maildir

Beware that filtering is a lengthy operation, especially on big
maildirs: it will first pass all messages found through your filters,
refiling them to folders (which may create duplicates if filenames are different).

It is possible to filter any maildir, also those coming from other
programs of course. Best practice is to copy the maildir inside the
$JAROMAILDIR directory (typically ~/Mail) and then refer to it by its
name: all arguments to the filter command can be relative to that
directory.

** Storage in brief

Here a recap of the commands dealing with maildir storage in Jaro Mail. Please note the syntax is subject to change in future:

| Command | Syntax                             |
|---------+------------------------------------|
| move    | (reads stdin) destination-maildir  |
| copy    | (reads stdin) destination-maildir  |
| link    | (reads stdin) destination-maildir  |
| merge   | origin-maildir destination-maildir |
| filter  | maildir                            |

* Security

** Password storage

Our MUA (Mutt) and our MTA (Fetchmail) normally required the user to input the email account password every time or write it clear inside a plain text file, jeopardizing the secrecy of it.

But most desktops nowadays have a keyring that stores passwords that are often used during a session, saving the user from retyping them every time.

Jaro Mail provides an interesting (and long awaited) feature even for those who are already using Mutt for their email: *it stores passwords securely*. This is done in different ways depending from the operating system is being running on.

Jaro Mail will use the default keyring whenever present to store all new passwords for each account used: the first time will prompt for a password and, while using it, will save it in relation to the particular account. This way the user can simply authenticate into the keyring at login and, while managing such sensitive informations using OS specific tools, Jaro Mail can be launched without the tedious task of a password input every time e-mails are being checked.

On *Apple/OSX* the default internal keyring is being used.

On *GNU/Linux* gnome-keyring is supported if found, else JaroMail will revert to use its own encrypted[fn:keyringenc] database called *keyring*. Every time a password will be retrieved or saved, the keyring password will be asked. However, it is recommended to use Gnome-Keyring over the native one, which has still some glitches.

[fn:keyringenc] The keyring is encrypted using weak symmetric encryption via GnuPG, the only protection for the data inside then is the password memorized by the used.

To explicitly change a password one can operate the default keyring manager or use the command *jaro passwd* (and specify other acconts using *-a accountname*)) which will prompt to set for a new password even if an old one is known.

** A tip for GNU/Linux users

Those using a GNU/Linux system might want to have a look at our other software *Tomb, the Crypto Undertaker* [fn:tomb] which takes care of quick mount and umount of an encrypted volume when desired and includes a *hook* mechanism to automatize the execution of commands to make a directory inside the encrypted volume immediately available in the user's home.

Using a light combination of scripts between Jaro Mail and Tomb is possible to achieve a strong level of personal security, definitely above the average.

In particular, Jaro Mail does not needs system-wide installation, but
can be installed and used in a way that makes it totally
self-contained and transportable across systems inside a Tomb. When
installing, just specify a prefix that is writable by the user, then
make sure the *JAROMAILDIR* environmental variable points to the path
where downloaded maildirs must be stored and the *JAROWORKDIR*
environmental variable points to the path where jaromail was
installed:

: cd JaroMail-3.0
: make
: PREFIX=/media/secrets.tomb/usr make install
: export JAROWORKDIR=/media/secrets.tomb/usr/share/jaromail
: export JAROMAILDIR=/media/secrets.tomb/Mail

For more information about Tomb please refer to its own documentation: environmental variables can also be set via hooks and file paths can be automatically overlayed into $HOME when the Tomb is open.

[fn:tomb] http://tomb.dyne.org


* Advanced usage
** Replay: avoid repeating long operations

   Working on the commandline can have some disadvantages. One of them is that if one runs a long operation to see its result and forgets to save it also on a file (i.e. using tee) the operation needs to be re-run and saved.

   Jaro Mail helps the user to *replay* the last output print by saving it everytime in its own cache. Replay can also save per-command outputs so that long pipe chains can be repeated selectively by naming the command. Only some commands have the replay capability, to have a list of available replays on your system do, based on your last run commands:

: jaro replay list

To replay the last search command and pipe it into headers to have a better view of it:

: jaro replay search | jaro headers

For instance imagine giving the command that searches for all mails sent to /nettime-l/ and extracts all addresses in the /From:/ including duplicates, then sorts them and eliminates duplicates

: jaro search to:nettime-l | jaro extract stdin from | sort | uniq

Depending from the size of your nettime archives, this operation may take some time and one may not want to repeat it in order to compute some stats on the extract result. So one can go on and send the old output to a new command:

: jaro replay extract | jaro stat names

This will print out statistics about the most prolific write to the nettime list according to your archives.

** Send anonymous emails

   Some people live difficult situations sometimes and are in need to
   send anonymous emails: for instance those endangered by the
   information they have, still in need to communicate it without
   being traced. Just imagine being a whistleblower part of a corrupt
   military organization, or a victim of mafia blackmailing, or a self
   determined woman in patriarcal societies. Situations like those may
   vary, still anonymity of communication is an important condition
   for personal safety and integrity.

   Anonymizing an email is not as simple as changing the From: field
   of an email, since its headers will carry the history of the
   envelope and server logs will be held by the various Internet hosts
   interacting with its delivery. Often those hosts are run by
   corporate organizations ready to sell the logged information to
   anyone with the money to afford it.

   To help these situations the MixMaster network exists since more
   than two decades, regularly routing emails across a chain of
   anonymizing servers that encrypt the envelope and delete logs,
   making it very difficult to track the origin and identity of those
   writing them. Anyway, such an operation requires long time and
   sometimes even fails to deliver: better send multiple copies of an
   anonymous email, then consider waiting one or two days before it
   gets delivered.

   Setting up MixMaster and using it is a fairly complex task, but
   here Jaro Mail comes to the rescue making it easy for its users:
   after composing your email just change the From: field to
   *anon@mixmaster*. Our application will recognize that as a request
   to send the email across the MixMaster anonymous network.

   To change the From: field after composition, just when headers and
   attachments are shown in Mutt, press *[ESC]* and then *f*, then
   type the special sender address *anon@mixmaster* and press *[Enter]*.

** Zsh commandline completion

   For Zsh users out there there is a completion recipe that can
   facilitate the use of Jaro Mail by adding tab completion on the
   console terminal: commands and accounts will be listed and
   completed automatically just like with other commands.

   To activate the completion move the file *src/completion/_jaromail*
   into the path where zsh loads vendor completions, typically that is
   */usr/share/zsh/vendor-completions*.

** Quickly send a file via email on Apple/OSX

   To right-click on a file and send it via email attach using Jaro
   Mail you must create a "Service" using the application
   "Automator". It is fairly simple:

   1) Start Automator
   2) Choose the Service template
   3) In the dropdown boxes that appear choose "files or folders" and "Finder"
   4) Look for "Run Applescript" in the Library tree
   5) Drag "Run Applescript" in the workflow area and paste this script into it:

#+BEGIN_EXAMPLE
on run {input, parameters}
	tell application "Terminal"
		activate
		tell window 1
			do script "/Applications/JaroMail.app/Contents/Resources/jaro/bin/jaro " & POSIX path of input
		end tell
	end tell
end run
#+END_EXAMPLE

   Now Save the new service (you can name it "Send file via Jaro
   Mail") and when you will right click on a file, in the submenu
   "Services" you will find the option you just scripted, which will
   open a Terminal asking you the email address, while the file will
   be already configured as attach.




* Acknowledgements

Jaro Mail would have never been possible without the incredible amount
of Love shared by the free and open source community, since it is
relying on the development of software like Mutt, Fetchmail and even
more code which is included and used by this program.

Heartfelt thanks go to all those contributing code and sharing it to
make the world a better place by not letting down all users in the
hands of corporate non-sense and proprietary technologies and
protocols.

This manual is written and maintained by Jaromil who is also the one
who wrote the Jaro Mail scripts. Still he is far from being the person
that wrote most of the code running here, just the one who organized
it in an hopefully intuitive way for users.

In the following chapters the best is done in order to credit most
people that contributed to free and open source software that Jaro
Mail makes use of.

** License

The following copyright notice applies to this manual, the software
included is licensed under the same or different GNU GPL or BSD
licenses, or available in the public domain.

#+BEGIN_EXAMPLE
 Copyleft (C) 2010-2014 Denis Roio <jaromil@dyne.org>

 Permission is granted to copy, distribute and/or modify this document
 under the terms of the GNU Free Documentation License, Version 1.3 or
 any later version published by the Free Software Foundation;
 Permission is granted to make and distribute verbatim copies of this
 manual page provided the above copyright notice and this permission
 notice are preserved on all copies.
#+END_EXAMPLE


** Jaro Mail credits

Jaro Mail is written and maintained by Denis Roio (aka Jaromil) it
started from the intention to share his own 10 years old e-mail setup,
encouraged by the geek tradition of exchanging configuration files
between friends.

Special thanks to Parazyd for useful code contributions and to Alvise
Gottieri, Anatole Shaw, Francesco Politi and Fabio Pietrosanti for
early testing and debugging.

The email envelop NyanCat graphics is kindly contributed by the
Société ECOGEX.

** Mutt credits

Please note that this is by no means an exhaustive list of all the
persons who have been contributing to Mutt.  Please see the
manual for a (probably still non complete) list of the persons who
have been helpful with the development of Mutt. Our special thanks go to
Antonio Radici, the Mutt maintainer in Debian, for his suggestions and
encouragement.

#+BEGIN_EXAMPLE
 Copyright (C) 1996-2007 Michael R. Elkins <me@cs.hmc.edu>
 Copyright (C) 1996-2002 Brandon Long <blong@fiction.net>
 Copyright (C) 1997-2008 Thomas Roessler <roessler@does-not-exist.org>
 Copyright (C) 1998-2005 Werner Koch <wk@isil.d.shuttle.de>
 Copyright (C) 1999-2009 Brendan Cully <brendan@kublai.com>
 Copyright (C) 1999-2002 Tommi Komulainen <Tommi.Komulainen@iki.fi>
 Copyright (C) 2000-2004 Edmund Grimley Evans <edmundo@rano.org>
 Copyright (C) 2006-2008 Rocco Rutte <pdmef@gmx.net>
#+END_EXAMPLE

** Notmuch credits
Jaro Mail includes a search engine for e-mails that is also licensed
GNU GPL v3+. Here below the names of the copyright holders and all
those who have written it:

#+BEGIN_EXAMPLE
Carl Worth <cworth@cworth.org> is the primary author of Notmuch.
But there's really not much that he's done. There's been a lot of
standing on shoulders here:

William Morgan deserves credit for providing the primary inspiration
for Notmuch with his program Sup (http://sup.rubyforge.org/).

Some people have contributed code that has made it into Notmuch
without their specific knowledge (but with their full permission
thanks to the GNU General Public License). This includes:

Brian Gladman (with Mikhail Gusarov <dottedmag@dottedmag.net>)
	Implementation of SHA-1 (nice and small) (libsha1.c)

Please see the various files in the Notmuch distribution for
individual copyright statements.
#+END_EXAMPLE

** Fetchmail credits

Fetchmail is licensed GNU GPL v2

#+BEGIN_EXAMPLE
Copyright (C) 2002, 2003 Eric S. Raymond
Copyright (C) 2004 Matthias Andree, Eric S. Raymond, Robert M. Funk, Graham Wilson
Copyright (C) 2005 - 2006, 2010 Sunil Shetye
Copyright (C) 2005 - 2010 Matthias Andree
#+END_EXAMPLE

** MSmtp credits

MSmtp is developed and maintained by Martin Lambers.

You can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation;
either version 3 of the License, or (at your option) any later
version.

** Statistics modules
   We are including some (experimental, still) modules for statistical
   visualization using JQuery libraries. The first module inspiring us
   to implement such a functionality is Timecloud, then other modules
   followed.

#+BEGIN_EXAMPLE
   Timecloud is Copyright (C) 2008-2009 by Stefan Marsiske
   Dual licensed under the MIT and GPLv3 licenses.

   TagCloud version 1.1.2
   (c) 2006 Lyo Kato <lyo.kato@gmail.com>
   TagCloud is freely distributable under the terms of an MIT-style license.

   ExCanvas is Copyright 2006 Google Inc.
   Licensed under the Apache License, Version 2.0 (the "License");

   jQuery project is distributed by the JQuery Foundation under the
   terms of either the GNU General Public License (GPL) Version 2.

   The Sizzle selector engine (which is included inside the jQuery
   library) is held by the Dojo Foundation and is licensed under the
   MIT, GPL, and BSD licenses.

   JQuery.sparkline 2.0 is licensed under the New BSD License

   Visualize.JQuery is written by Scott Jehl
   Copyright (c) 2009 Filament Group
   licensed under MIT (filamentgroup.com/examples/mit-license.txt)
#+END_EXAMPLE
* Appendix

** Configuration examples

*** Accounts/default.txt

#+BEGIN_EXAMPLE
# Name and values are separated by spaces or tabs
# comments start the line with a hash

# Give a name to this account
name To Be Configured
# configure Identity.txt to set your From: field

# Email address (default is same as login)
email unknown@dyne.org

# Username
login USERNAME@dyne.org

## Change the settings only if you need

# Imap host address
imap mail.dyne.org

# Imap port: usually 443, 220 or 993
imap_port 993


# Smtp host address
smtp mail.dyne.org

# Smtp port: usually 25 or 465
smtp_port 25

# Authentication type
auth plain # or kerberos, etc

# Server certificate: check or ignore
cert ignore

# Transport protocol: ssl, tls or plain
transport tls


# Options when fetching
# to empty your mailbox you can use: 'fetchall' 'flush'
# by default this is 'keep': don't delete mails from server
options keep

# Remote IMAP folders to be retreived
# fill to provide a list of folders to be fetched
# default is to detect and fetch all remote folders
## folders INBOX priv unsorted filters

# list of folders to exclude from fetch
# comment or change to avoid leaving them on server
# please note we filters social networks by default
# (see Filters.txt and change it as you like)
exclude zz.spam zz.bounces zz.blacklist zz.social


#
# The password field will be filled in automatically
#
#+END_EXAMPLE


*** Filters.txt

#+BEGIN_EXAMPLE
# Default filter configuration for Jaro Mail

# Mailinglist filters are in order of importance
# syntax: to <list email> save <folder>
# below some commented out examples, note the use of a prefix,
# which makes it handy when browsing with file completion.

# to	  crypto@lists.dyne	save	dyne.crypto
# to	  dynebolic		    save	dyne.dynebolic
# to	  freej			    save	dyne.freej
# to	  frei0r-devel		save	dyne.frei0r
# to	  taccuino		    save	ml.freaknet
# to	  deadpoets		    save	ml.freaknet
# to	  linux-libre		save	gnu.linux-libre
# to	  foundations@lists	save	gnu.foundations
# to	  debian-mentors	save	debian.mentors
# to	  debian-blends		save	debian.blends

# Other filters for web 2.0 using folder names with a prefix:
# they can facilitate folder maintainance.
# These are on by default, comment out if not desired.

from      github.com            save	zz.social
from      launchpad	            save	zz.social
from      identi.ca             save	zz.social
from      twitter.com		    save	zz.social
from      linkedin.com		    save	zz.social
from      googlealerts		    save	zz.social
from      plus.google.com	    save	zz.social
from      youtube.com		    save	zz.social
from      wmt-noreply@google	save	zz.social
from      facebook		        save	zz.social
from      FriendFeed		    save	zz.social
from      academia-mail.com	    save	zz.social
from      statusnet		        save	zz.social
from      basecamp		        save	zz.social
#+END_EXAMPLE
