A typical reason to use different delivery agents when using different identities is that messages may have to be routed to different SMTP servers with different authorization methods. For example, some servers will simply reject messages that have an unexpected From address.
Also there are other cases such as messages from a GMail address that should be routed to a Google SMTP server in order to be signed with a proper DomainKeys header field.
Indeed, while it’s not mandatory, some receivers may pre-sort as spam or reject messages from GMail addresses that are not signed as the Google SMTP servers do with a DomainKey signature (not trusing these messages being the point of DKIM). Let’s see how to route messages written in Manitou-Mail from a GMail address to Google SMTP servers.
I’ve used msmtp for a simple, easy to configure Mail Submission Agent. esmtp is also a candidate but its debian package makes it an alternative to postfix and I happen to want it to supplement postfix, not replace it. msmtp, on the other hand, is a supplementary package that doesn’t conflict with the default MSA.

The procedure to use msmtp is quite simple:
Create a $HOME/.certs directory if none already exists.
Create a $HOME/.msmtprc file (with perm 0600) containing:

# gmail account
auth on
host smtp.gmail.com
port 587
user USERNAME@gmail.com
password XXXXXX
from USERNAME@gmail.com
tls on
tls_trust_file /home/daniel/.cert/ThawtePremiumServerCA.crt

Obviously USERNAME is to be replaced by your GMail login.
The cert file is to be extracted from the set of Thawte certificates available at: https://www.verisign.com/support/thawte-roots.zip, with this command:

unzip -p thawte-roots.zip 'Thawte SSLWeb Server Roots/thawte Premium Server CA/Thawte Premium Server CA.pem' > ~/.certs/ThawtePremiumServerCA.crt


And in manitou-mdx’s configuration file, we have something like:

[common]
# various things
[USERNAME@gmail.com]
local_delivery_agent = msmtp -f $FROM$ -t


SELECT min(mail_id)
FROM header
WHERE position(E'\nFace: ' in lines)>0
GROUP BY
split_part(substr(lines, position(E'\nFace: ' in lines)+7, 1300), E'\n', 1)

position(…) let us know where the Face header field begins, substr(…) extracts a sufficient length of it, and split_part(…) cuts exactly the value at the first newline which marks the end of this header’s value (they’re unfolded in the header table precisely to be able to perform that kind of extraction).
Finally the GROUP BY ensures that each row in the result represents a distinct value of the Face header.

This query can be directly input into the SQL statement field of the Query Selection dialog, after which all there is to do is wait for the database engine to run it to completion.

On my sample database of about 800,000 messages from various mailing lists, it turned out that the result was a list of 176 messages. Here is a collage of a selection of the pictures (public messages only).

Here is how one particular message looks with its Face header:

Right now this is just about displaying, sometime in the future I’ll try to add Face headers to outgoing mail, and also I’d like to associate pictures to sender addresses so that messages from people who don’t use a Face header (the majority) still can be shown with a dedicated picture. I feel like even tags or sender domains (which means companies and organizations), could benefit from that kind of visual representation in certain cases.

So I’ve repackaged Manitou-Mail 0.9.12 for Windows with the necessary plugins that get installed into an imageformats directory, and re-uploaded the installer:
Manitou-Installer-0_9_12.exe

For users who were concerned by this problem, I suggest they reinstall and report if it still doesn’t work.

MinGW (compiler) installation

The current version is 5.1.4 is available here: MingW-5.1.4 installer on sourceforge.net.
Let’s run the installer and choose “Download and install”:

After accepting the license, we get to choose the destination directory. Let’s install into c:\mingw, the default choice.

We want the “current” version:

The next screen is about choosing the components.
We need to check the following ones:

• MinGW base tools
• g++ compiler
• MinGW Make

After that, a rapid succession of screens appear, that show the packages that are being downloaded and installed.

Then the install finished and we end up with a c:\mingw directory containing about 60MB of programs. It turns out that in my case, I’m also finding .tar.gz archives of the compiler packages on my desktop (from which I launched the installer), so let’s delete them.

MSYS (shell environment) installation

MSYS stands for minimal system. It’s a light unix-like environment with a shell and enough capabilities to support the autotools.

Like MingW, MSYS has a base system and packages, except that it has a lot more packages. We need only a half-dozen of them.
The current version of the MSYS base is available at:

MSYS-1.0.11 installer on sourceforge.net

Let’s select the default directory: c:\msys\1.0

At the end of the installation, a post-installer script running in a CMD window “will try to normalize” with MingW, so we just accept what it suggests and type the path of our mingw directory as told (c:/mingw)

Once the installation is done, we have this icon on the desktop to launch an MSYS shell :

Autotools installation

MSYS has an MSYS Developer Toolkit in the form of a .EXE that installs automake, autoconf and the perl interpreter they depend on, but unfortunately their versions are too old for manitou’s configure script. It installs autoconf version 2.56 and automake 1.7.1 that date back from 2002, while we need at least autoconf version 2.60. Perl is version 5.6.1.

Still, let’s install that package, if just to have Perl, and upgrade separately automake and autoconf.

We install MSYS DTK into the recommended location

Now, following the advice from the MSYS wiki, we get the source archives for autoconf and automake directly off the main GNU FTP server (so it’s the baseline, not modified versions for MSYS).
The current sources are autoconf-2.64.tar.bz2 and automake-1.11.tar.bz2.

Let’s download these archives into c:/tmp/ and unpack them (all the subsequent commands are run inside the MSYS shell)

$ cd c:/tmp
$ tar xjf autoconf-2.64.tar.bz2
$ tar xjf automake-1.11.tar.bz2

The MSYS wiki says it’s important to compile into separate build directories so we do as told:

$ mkdir build-autoconf
$ cd build-autoconf
$ ../autoconf-2.64/configure --prefix=/mingw
$ make
$ make install

Same thing for automake:

$ mkdir build-automake
$ cd build-automake
$ ../automake-1.11/configure --prefix=/mingw
$ make
$ make install

Now that they’re both installed, autoconf --version displays:

$ autoconf --version
autoconf (GNU Autoconf) 2.64
Copyright (C) 2009 Free Software Foundation, Inc.
License GPLv2+: GNU GPL version 2 or later

This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Written by David J. MacKenzie and Akim Demaille.

And automake –version:

$ automake --version
automake (GNU automake) 1.11
Copyright (C) 2009 Free Software Foundation, Inc.
License GPLv2+: GNU GPL version 2 or later
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Written by Tom Tromey
       and Alexandre Duret-Lutz .

Conclusion of part 1

With MinGW and MSYS, we have an environment that is good enough to build programs on Windows the same way that they are on unix (basically: configure && make && make install)
With autotools we can regenerate the configure script and the Makefile.in files, which is something we need to add new source files to the project or modify the configure.in script.
Also, we’re ready to compile Qt and a PostgreSQL client, which will be done in the next part.

It’s relatively easy to write a manitou-mdx Perl plugin that does just that, by using a CPAN module to do the HTML to text conversion: HTML::FormatText

Apart from the usual init and process functions that are described in the mdx plugins reference, we need to provide two functions: one that recursively descends the MIME tree to find the html parts, and another that extracts them to text and pass them to the indexer.

sub index_contents {
  my ($fh, $ctxt)=@_;
  my $html;
  my $text;
  {
    local $/;
    $html = $fh->getline();
  }
 
  if (defined $html) {
    my $tree = HTML::TreeBuilder->new;
    $tree->parse_content($html);
    my $formatter = HTML::FormatText->new(leftmargin=>0, rightmargin=>78);
    $text = $formatter->format($tree);
  }
  if (defined $text) {
    Manitou::Words::index_words($ctxt->{'dbh'}, $ctxt->{'mail_id'}, \$text);
  }
}
 
sub process_parts {
  my ($obj,$ctxt) = @_;;
  if ($obj->is_multipart) {
    foreach my $subobj ($obj->parts) {
      process_parts($subobj, $ctxt);    # recurse
    }
  }
  else {
    my $type=$obj->effective_type;
    if ($type eq "text/html") {
      my $io = $obj->bodyhandle->open("r");
      index_contents($io, $ctxt);
      $io->close;
    }
  }
}

The full source code and download link are available on the wiki