2006-09-26 [colin] 2.5.1cvs5
[claws.git] / src / matcher.c
index a43af9a70f2b5d3fb30a06a85c2ea3a9df952381..f6d4c2415f216d7643e9385054fec4008ac64994 100644 (file)
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 2002-2004 by the Sylpheed Claws Team and Hiroyuki Yamamoto
+ *
+ * This program is free software; 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include <glib.h>
+#include <glib/gi18n.h>
 #include <ctype.h>
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
+
+#ifdef USE_PTHREAD
+#include <pthread.h>
+#endif
+
 #include "defs.h"
 #include "utils.h"
 #include "procheader.h"
 #include "matcher.h"
-#include "intl.h"
+#include "matcher_parser.h"
+#include "prefs_gtk.h"
+#include "addr_compl.h"
+#include "codeconv.h"
+#include "quoted-printable.h"
+#include "sylpheed.h"
+#include <ctype.h>
 
+/*!
+ *\brief       Keyword lookup element
+ */
 struct _MatchParser {
-       gint id;
-       gchar * str;
+       gint id;                /*!< keyword id */ 
+       gchar *str;             /*!< keyword */
 };
-
 typedef struct _MatchParser MatchParser;
 
-static MatchParser matchparser_tab[] = {
+/*!
+ *\brief       Table with strings and ids used by the lexer and
+ *             the parser. New keywords can be added here.
+ */
+static const MatchParser matchparser_tab[] = {
        /* msginfo flags */
-       {MATCHING_ALL, "all"},
-       {MATCHING_UNREAD, "unread"},
-       {MATCHING_NOT_UNREAD, "~unread"},
-       {MATCHING_NEW, "new"},
-       {MATCHING_NOT_NEW, "~new"},
-       {MATCHING_MARKED, "marked"},
-       {MATCHING_NOT_MARKED, "~marked"},
-       {MATCHING_DELETED, "deleted"},
-       {MATCHING_NOT_DELETED, "~deleted"},
-       {MATCHING_REPLIED, "replied"},
-       {MATCHING_NOT_REPLIED, "~replied"},
-       {MATCHING_FORWARDED, "forwarded"},
-       {MATCHING_NOT_FORWARDED, "~forwarded"},
+       {MATCHCRITERIA_ALL, "all"},
+       {MATCHCRITERIA_UNREAD, "unread"},
+       {MATCHCRITERIA_NOT_UNREAD, "~unread"},
+       {MATCHCRITERIA_NEW, "new"},
+       {MATCHCRITERIA_NOT_NEW, "~new"},
+       {MATCHCRITERIA_MARKED, "marked"},
+       {MATCHCRITERIA_NOT_MARKED, "~marked"},
+       {MATCHCRITERIA_DELETED, "deleted"},
+       {MATCHCRITERIA_NOT_DELETED, "~deleted"},
+       {MATCHCRITERIA_REPLIED, "replied"},
+       {MATCHCRITERIA_NOT_REPLIED, "~replied"},
+       {MATCHCRITERIA_FORWARDED, "forwarded"},
+       {MATCHCRITERIA_NOT_FORWARDED, "~forwarded"},
+       {MATCHCRITERIA_LOCKED, "locked"},
+       {MATCHCRITERIA_NOT_LOCKED, "~locked"},
+       {MATCHCRITERIA_COLORLABEL, "colorlabel"},
+       {MATCHCRITERIA_NOT_COLORLABEL, "~colorlabel"},
+       {MATCHCRITERIA_IGNORE_THREAD, "ignore_thread"},
+       {MATCHCRITERIA_NOT_IGNORE_THREAD, "~ignore_thread"},
 
        /* msginfo headers */
-       {MATCHING_SUBJECT, "subject"},
-       {MATCHING_NOT_SUBJECT, "~subject"},
-       {MATCHING_FROM, "from"},
-       {MATCHING_NOT_FROM, "~from"},
-       {MATCHING_TO, "to"},
-       {MATCHING_NOT_TO, "~to"},
-       {MATCHING_CC, "cc"},
-       {MATCHING_NOT_CC, "~cc"},
-       {MATCHING_TO_OR_CC, "to_or_cc"},
-       {MATCHING_NOT_TO_AND_NOT_CC, "~to_or_cc"},
-       {MATCHING_AGE_GREATER, "age_greater"},
-       {MATCHING_AGE_LOWER, "age_lower"},
-       {MATCHING_NEWSGROUPS, "newsgroups"},
-       {MATCHING_NOT_NEWSGROUPS, "~newsgroups"},
-       {MATCHING_INREPLYTO, "inreplyto"},
-       {MATCHING_NOT_INREPLYTO, "~inreplyto"},
-       {MATCHING_REFERENCES, "references"},
-       {MATCHING_NOT_REFERENCES, "~references"},
-       {MATCHING_SCORE_GREATER, "score_greater"},
-       {MATCHING_SCORE_LOWER, "score_lower"},
+       {MATCHCRITERIA_SUBJECT, "subject"},
+       {MATCHCRITERIA_NOT_SUBJECT, "~subject"},
+       {MATCHCRITERIA_FROM, "from"},
+       {MATCHCRITERIA_NOT_FROM, "~from"},
+       {MATCHCRITERIA_TO, "to"},
+       {MATCHCRITERIA_NOT_TO, "~to"},
+       {MATCHCRITERIA_CC, "cc"},
+       {MATCHCRITERIA_NOT_CC, "~cc"},
+       {MATCHCRITERIA_TO_OR_CC, "to_or_cc"},
+       {MATCHCRITERIA_NOT_TO_AND_NOT_CC, "~to_or_cc"},
+       {MATCHCRITERIA_AGE_GREATER, "age_greater"},
+       {MATCHCRITERIA_AGE_LOWER, "age_lower"},
+       {MATCHCRITERIA_NEWSGROUPS, "newsgroups"},
+       {MATCHCRITERIA_NOT_NEWSGROUPS, "~newsgroups"},
+       {MATCHCRITERIA_INREPLYTO, "inreplyto"},
+       {MATCHCRITERIA_NOT_INREPLYTO, "~inreplyto"},
+       {MATCHCRITERIA_REFERENCES, "references"},
+       {MATCHCRITERIA_NOT_REFERENCES, "~references"},
+       {MATCHCRITERIA_SCORE_GREATER, "score_greater"},
+       {MATCHCRITERIA_SCORE_LOWER, "score_lower"},
+       {MATCHCRITERIA_SCORE_EQUAL, "score_equal"},
+       {MATCHCRITERIA_PARTIAL, "partial"},
+       {MATCHCRITERIA_NOT_PARTIAL, "~partial"},
+       {MATCHCRITERIA_FOUND_IN_ADDRESSBOOK, "found_in_addressbook"},
+       {MATCHCRITERIA_NOT_FOUND_IN_ADDRESSBOOK, "~found_in_addressbook"},
+
+       {MATCHCRITERIA_SIZE_GREATER, "size_greater"},
+       {MATCHCRITERIA_SIZE_SMALLER, "size_smaller"},
+       {MATCHCRITERIA_SIZE_EQUAL,   "size_equal"},
 
        /* content have to be read */
-       {MATCHING_HEADER, "header"},
-       {MATCHING_NOT_HEADER, "~header"},
-       {MATCHING_HEADERS_PART, "headers_part"},
-       {MATCHING_NOT_HEADERS_PART, "~headers_part"},
-       {MATCHING_MESSAGE, "message"},
-       {MATCHING_NOT_MESSAGE, "~message"},
-       {MATCHING_BODY_PART, "body_part"},
-       {MATCHING_NOT_BODY_PART, "~body_part"},
-       {MATCHING_EXECUTE, "execute"},
-       {MATCHING_NOT_EXECUTE, "~execute"},
+       {MATCHCRITERIA_HEADER, "header"},
+       {MATCHCRITERIA_NOT_HEADER, "~header"},
+       {MATCHCRITERIA_HEADERS_PART, "headers_part"},
+       {MATCHCRITERIA_NOT_HEADERS_PART, "~headers_part"},
+       {MATCHCRITERIA_MESSAGE, "message"},
+       {MATCHCRITERIA_NOT_MESSAGE, "~message"},
+       {MATCHCRITERIA_BODY_PART, "body_part"},
+       {MATCHCRITERIA_NOT_BODY_PART, "~body_part"},
+       {MATCHCRITERIA_TEST, "test"},
+       {MATCHCRITERIA_NOT_TEST, "~test"},
 
        /* match type */
-       {MATCHING_MATCHCASE, "matchcase"},
-       {MATCHING_MATCH, "match"},
-       {MATCHING_REGEXPCASE, "regexpcase"},
-       {MATCHING_REGEXP, "regexp"},
+       {MATCHTYPE_MATCHCASE, "matchcase"},
+       {MATCHTYPE_MATCH, "match"},
+       {MATCHTYPE_REGEXPCASE, "regexpcase"},
+       {MATCHTYPE_REGEXP, "regexp"},
 
        /* actions */
-       {MATCHING_SCORE, "score"},
+       {MATCHACTION_SCORE, "score"},    /* for backward compatibility */
+       {MATCHACTION_MOVE, "move"},
+       {MATCHACTION_COPY, "copy"},
+       {MATCHACTION_DELETE, "delete"},
+       {MATCHACTION_MARK, "mark"},
+       {MATCHACTION_UNMARK, "unmark"},
+       {MATCHACTION_LOCK, "lock"},
+       {MATCHACTION_UNLOCK, "unlock"},
+       {MATCHACTION_MARK_AS_READ, "mark_as_read"},
+       {MATCHACTION_MARK_AS_UNREAD, "mark_as_unread"},
+       {MATCHACTION_FORWARD, "forward"},
+       {MATCHACTION_FORWARD_AS_ATTACHMENT, "forward_as_attachment"},
+       {MATCHACTION_EXECUTE, "execute"},
+       {MATCHACTION_COLOR, "color"},
+       {MATCHACTION_REDIRECT, "redirect"},
+       {MATCHACTION_CHANGE_SCORE, "change_score"},
+       {MATCHACTION_SET_SCORE, "set_score"},
+       {MATCHACTION_STOP, "stop"},
+       {MATCHACTION_HIDE, "hide"},
+       {MATCHACTION_IGNORE, "ignore"},
+};
 
-       /* actions */
-       {MATCHING_ACTION_MOVE, "move"},
-       {MATCHING_ACTION_COPY, "copy"},
-       {MATCHING_ACTION_DELETE, "delete"},
-       {MATCHING_ACTION_MARK, "mark"},
-       {MATCHING_ACTION_UNMARK, "unmark"},
-       {MATCHING_ACTION_MARK_AS_READ, "mark_as_read"},
-       {MATCHING_ACTION_MARK_AS_UNREAD, "mark_as_unread"},
-       {MATCHING_ACTION_FORWARD, "forward"},
-       {MATCHING_ACTION_FORWARD_AS_ATTACHMENT, "forward_as_attachment"},
-       /*      {MATCHING_EXECUTE, "execute"}, */
+enum {
+       MATCH_ANY = 0,
+       MATCH_ALL = 1,
+       MATCH_ONE = 2
 };
 
-gchar * get_matchparser_tab_str(gint id)
+/*!
+ *\brief       Look up table with keywords defined in \sa matchparser_tab
+ */
+static GHashTable *matchparser_hashtab;
+
+/*!
+ *\brief       Translate keyword id to keyword string
+ *
+ *\param       id Id of keyword
+ *
+ *\return      const gchar * Keyword
+ */
+const gchar *get_matchparser_tab_str(gint id)
 {
        gint i;
 
-       for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
-           i++) {
+       for (i = 0; i < sizeof matchparser_tab / sizeof matchparser_tab[0]; i++) {
                if (matchparser_tab[i].id == id)
                        return matchparser_tab[i].str;
        }
        return NULL;
 }
 
-
-
-/*
-  syntax for matcher
-
-  header "x-mailing" match "toto"
-  subject match "regexp" & to regexp "regexp"
-  subject match "regexp" | to regexpcase "regexp" | age_sup 5
+/*!
+ *\brief       Create keyword lookup table
  */
-
-static gboolean matcher_is_blank(gchar ch);
-
-/* ******************* parser *********************** */
-
-static gboolean matcher_is_blank(gchar ch)
-{
-       return (ch == ' ') || (ch == '\t');
-}
-
-/* parse for one condition */
-
-MatcherProp * matcherprop_parse(gchar ** str)
+static void create_matchparser_hashtab(void)
 {
-       MatcherProp * prop;
-       gchar * tmp;
-       gint key;
-       gint value;
-       gchar * expr;
-       gint match;
-       gchar * header = NULL;
-       
-       tmp = * str;
-       key = matcher_parse_keyword(&tmp);
-       if (tmp == NULL) {
-               * str = NULL;
-               return NULL;
-       }
-
-       switch (key) {
-       case MATCHING_AGE_LOWER:
-       case MATCHING_AGE_GREATER:
-       case MATCHING_SCORE_LOWER:
-       case MATCHING_SCORE_GREATER:
-               value = matcher_parse_number(&tmp);
-               if (tmp == NULL) {
-                       * str = NULL;
-                       return NULL;
-               }
-               *str = tmp;
-
-               prop = matcherprop_new(key, NULL, 0, NULL, value);
-
-               return prop;
-
-       case MATCHING_ALL:
-       case MATCHING_UNREAD:
-       case MATCHING_NOT_UNREAD:
-       case MATCHING_NEW:
-       case MATCHING_NOT_NEW:
-       case MATCHING_MARKED:
-       case MATCHING_NOT_MARKED:
-       case MATCHING_DELETED:
-       case MATCHING_NOT_DELETED:
-       case MATCHING_REPLIED:
-       case MATCHING_NOT_REPLIED:
-       case MATCHING_FORWARDED:
-       case MATCHING_NOT_FORWARDED:
-               prop = matcherprop_new(key, NULL, 0, NULL, 0);
-               *str = tmp;
-
-               return prop;
-
-       case MATCHING_SUBJECT:
-       case MATCHING_NOT_SUBJECT:
-       case MATCHING_FROM:
-       case MATCHING_NOT_FROM:
-       case MATCHING_TO:
-       case MATCHING_NOT_TO:
-       case MATCHING_CC:
-       case MATCHING_NOT_CC:
-       case MATCHING_TO_OR_CC:
-       case MATCHING_NOT_TO_AND_NOT_CC:
-       case MATCHING_NEWSGROUPS:
-       case MATCHING_NOT_NEWSGROUPS:
-       case MATCHING_INREPLYTO:
-       case MATCHING_NOT_REFERENCES:
-       case MATCHING_REFERENCES:
-       case MATCHING_NOT_INREPLYTO:
-       case MATCHING_MESSAGE:
-       case MATCHING_NOT_MESSAGE:
-       case MATCHING_EXECUTE:
-       case MATCHING_NOT_EXECUTE:
-       case MATCHING_HEADERS_PART:
-       case MATCHING_NOT_HEADERS_PART:
-       case MATCHING_BODY_PART:
-       case MATCHING_NOT_BODY_PART:
-       case MATCHING_HEADER:
-       case MATCHING_NOT_HEADER:
-               if ((key == MATCHING_HEADER) || (key == MATCHING_NOT_HEADER)) {
-                       header = matcher_parse_str(&tmp);
-                       if (tmp == NULL) {
-                               * str = NULL;
-                               return NULL;
-                       }
-               }
-
-               match = matcher_parse_keyword(&tmp);
-               if (tmp == NULL) {
-                       if (header)
-                               g_free(header);
-                       * str = NULL;
-                       return NULL;
-               }
-
-               switch(match) {
-               case MATCHING_REGEXP:
-               case MATCHING_REGEXPCASE:
-                       expr = matcher_parse_regexp(&tmp);
-                       if (tmp == NULL) {
-                               if (header)
-                                       g_free(header);
-                               * str = NULL;
-                               return NULL;
-                       }
-                       *str = tmp;
-                       prop = matcherprop_new(key, header, match, expr, 0);
-                       g_free(expr);
-
-                       return prop;
-               case MATCHING_MATCH:
-               case MATCHING_MATCHCASE:
-                       expr = matcher_parse_str(&tmp);
-                       if (tmp == NULL) {
-                               if (header)
-                                       g_free(header);
-                               * str = NULL;
-                               return NULL;
-                       }
-                       *str = tmp;
-                       prop = matcherprop_new(key, header, match, expr, 0);
-                       g_free(expr);
-
-                       return prop;
-               default:
-                       if (header)
-                               g_free(header);
-                       * str = NULL;
-                       return NULL;
-               }
-       default:
-               * str = NULL;
-               return NULL;
-       }
-}
-
-gint matcher_parse_keyword(gchar ** str)
-{
-       gchar * p;
-       gchar * dup;
-       gchar * start;
-       gint i;
-       gint match;
-
-       dup = alloca(strlen(* str) + 1);
-       p = dup;
-       strcpy(dup, * str);
-
-       while (matcher_is_blank(*p))
-               p++;
-
-       start = p;
-
-       while (!matcher_is_blank(*p) && (*p != '\0'))
-               p++;
+       int i;
        
-       match = -1;
-       for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
-           i++) {
-               if ((strlen(matchparser_tab[i].str) == p - start) &&
-                   (strncasecmp(matchparser_tab[i].str, start,
-                                p - start) == 0)) {
-                               match = i;
-                               break;
-                       }
-       }
-
-       if (match == -1) {
-               * str = NULL;
-               return 0;
-       }
-
-       *p = '\0';
-
-       *str += p - dup + 1;
-       return matchparser_tab[match].id;
+       if (matchparser_hashtab) return;
+       matchparser_hashtab = g_hash_table_new(g_str_hash, g_str_equal);
+       for (i = 0; i < sizeof matchparser_tab / sizeof matchparser_tab[0]; i++)
+               g_hash_table_insert(matchparser_hashtab,
+                                   matchparser_tab[i].str,
+                                   (gpointer) &matchparser_tab[i]);
 }
 
-gint matcher_parse_number(gchar ** str)
-{
-       gchar * p;
-       gchar * dup;
-       gchar * start;
-
-       dup = alloca(strlen(* str) + 1);
-       p = dup;
-       strcpy(dup, * str);
-
-       while (matcher_is_blank(*p))
-               p++;
-
-       start = p;
-
-       if (!isdigit(*p) && *p != '-' && *p != '+') {
-               *str = NULL;
-               return 0;
-       }
-       if (*p == '-' || *p == '+')
-               p++;
-       while (isdigit(*p))
-               p++;
-
-       *p = '\0';
-
-       *str += p - dup + 1;
-       return atoi(start);
-}
-
-gboolean matcher_parse_boolean_op(gchar ** str)
-{
-       gchar * p;
-
-       p = * str;
-
-       while (matcher_is_blank(*p))
-               p++;
-
-       if (*p == '|') {
-               *str += p - * str + 1;
-               return FALSE;
-       }
-       else if (*p == '&') {
-               *str += p - * str + 1;
-               return TRUE;
-       }
-       else {
-               *str = NULL;
-               return FALSE;
-       }
-}
-
-gchar * matcher_parse_regexp(gchar ** str)
-{
-       gchar * p;
-       gchar * dup;
-       gchar * start;
-
-       dup = alloca(strlen(* str) + 1);
-       p = dup;
-       strcpy(dup, * str);
-
-       while (matcher_is_blank(*p))
-               p++;
-
-       if (*p != '/') {
-               * str = NULL;
-               return NULL;
-       }
-
-       p ++;
-       start = p;
-       while (*p != '/') {
-               if (*p == '\\')
-                       p++;
-               p++;
-       }
-       *p = '\0';
-
-       *str += p - dup + 2;
-       return g_strdup(start);
-}
-
-gchar * matcher_parse_str(gchar ** str)
+/*!
+ *\brief       Return a keyword id from a keyword string
+ *
+ *\param       str Keyword string
+ *
+ *\return      gint Keyword id
+ */
+gint get_matchparser_tab_id(const gchar *str)
 {
-       gchar * p;
-       gchar * dup;
-       gchar * start;
-       gchar * dest;
-
-       dup = alloca(strlen(* str) + 1);
-       p = dup;
-       strcpy(dup, * str);
-
-       while (matcher_is_blank(*p))
-               p++;
+       MatchParser *res;
 
-       if (*p != '"') {
-               * str = NULL;
-               return NULL;
-       }
-       
-       p ++;
-       start = p;
-       dest = p;
-       while (*p != '"') {
-               if (*p == '\\') {
-                       p++;
-                       *dest = *p;
-               }
-               else
-                       *dest = *p;
-               dest++;
-               p++;
-       }
-       *dest = '\0';
-
-       *str += dest - dup + 2;
-       return g_strdup(start);
+       if (NULL != (res = g_hash_table_lookup(matchparser_hashtab, str))) {
+               return res->id;
+       } else
+               return -1;
 }
 
 /* **************** data structure allocation **************** */
 
-
-MatcherProp * matcherprop_new(gint criteria, gchar * header,
-                             gint matchtype, gchar * expr,
+/*!
+ *\brief       Allocate a structure for a filtering / scoring
+ *             "condition" (a matcher structure)
+ *
+ *\param       criteria Criteria ID (MATCHCRITERIA_XXXX)
+ *\param       header Header string (if criteria is MATCHCRITERIA_HEADER
+                       or MATCHCRITERIA_FOUND_IN_ADDRESSBOOK)
+ *\param       matchtype Type of action (MATCHTYPE_XXX)
+ *\param       expr String value or expression to check
+ *\param       value Integer value to check
+ *
+ *\return      MatcherProp * Pointer to newly allocated structure
+ */
+MatcherProp *matcherprop_new(gint criteria, const gchar *header,
+                             gint matchtype, const gchar *expr,
                              int value)
 {
-       MatcherProp * prop;
+       MatcherProp *prop;
 
        prop = g_new0(MatcherProp, 1);
        prop->criteria = criteria;
-       if (header != NULL)
-               prop->header = g_strdup(header);
-       else
-               prop->header = NULL;
-       if (expr != NULL)
-               prop->expr = g_strdup(expr);
-       else
-               prop->expr = NULL;
+       prop->header = header != NULL ? g_strdup(header) : NULL;
+       prop->expr = expr != NULL ? g_strdup(expr) : NULL;
        prop->matchtype = matchtype;
        prop->preg = NULL;
        prop->value = value;
@@ -445,9 +245,16 @@ MatcherProp * matcherprop_new(gint criteria, gchar * header,
        return prop;
 }
 
-void matcherprop_free(MatcherProp * prop)
+/*!
+ *\brief       Free a matcher structure
+ *
+ *\param       prop Pointer to matcher structure allocated with
+ *             #matcherprop_new
+ */
+void matcherprop_free(MatcherProp *prop)
 {
        g_free(prop->expr);
+       g_free(prop->header);
        if (prop->preg != NULL) {
                regfree(prop->preg);
                g_free(prop->preg);
@@ -455,31 +262,116 @@ void matcherprop_free(MatcherProp * prop)
        g_free(prop);
 }
 
+/*!
+ *\brief       Copy a matcher structure
+ *
+ *\param       src Matcher structure to copy
+ *
+ *\return      MatcherProp * Pointer to newly allocated matcher structure
+ */
+MatcherProp *matcherprop_copy(const MatcherProp *src)
+{
+       MatcherProp *prop = g_new0(MatcherProp, 1);
+       
+       prop->criteria = src->criteria;
+       prop->header = src->header ? g_strdup(src->header) : NULL;
+       prop->expr = src->expr ? g_strdup(src->expr) : NULL;
+       prop->matchtype = src->matchtype;
+       
+       prop->preg = NULL; /* will be re-evaluated */
+       prop->value = src->value;
+       prop->error = src->error;       
+       return prop;            
+}
 
 /* ************** match ******************************/
 
+static gboolean match_with_addresses_in_addressbook
+       (MatcherProp *prop, GSList *address_list, gint type,
+        gchar* folderpath, gint match)
+{
+       GSList *walk = NULL;
+       gboolean found = FALSE;
+       gchar *path = NULL;
+
+       g_return_val_if_fail(address_list != NULL, FALSE);
 
-/* match the given string */
+       debug_print("match_with_addresses_in_addressbook(%d, %s)\n",
+                               g_slist_length(address_list), folderpath);
 
-static gboolean matcherprop_string_match(MatcherProp * prop, gchar * str)
+       if (folderpath == NULL ||
+               strcasecmp(folderpath, _("Any")) == 0 ||
+               *folderpath == '\0')
+               path = NULL;
+       else
+               path = folderpath;
+       
+       start_address_completion(path);
+
+       for (walk = address_list; walk != NULL; walk = walk->next) {
+               /* exact matching of email address */
+               guint num_addr = complete_address(walk->data);
+               found = FALSE;
+               if (num_addr > 1) {
+                       /* skip first item (this is the search string itself) */
+                       int i = 1;
+                       for (; i < num_addr && !found; i++) {
+                               gchar *addr = get_complete_address(i);
+                               extract_address(addr);
+                               if (strcasecmp(addr, walk->data) == 0)
+                                       found = TRUE;
+                               g_free(addr);
+                       }
+               }
+               g_free(walk->data);
+
+               if (match == MATCH_ALL) {
+                       /* if matching all addresses, stop if one doesn't match */
+                       if (!found)
+                       break;
+               } else if (match == MATCH_ANY) {
+                       /* if matching any address, stop if one does match */
+                       if (found)
+                               break;
+       }
+               /* MATCH_ONE: there should be only one loop iteration */
+       }
+
+       end_address_completion();
+       
+       return found;
+}
+
+/*!
+ *\brief       Find out if a string matches a condition
+ *
+ *\param       prop Matcher structure
+ *\param       str String to check 
+ *
+ *\return      gboolean TRUE if str matches the condition in the 
+ *             matcher structure
+ */
+static gboolean matcherprop_string_match(MatcherProp *prop, const gchar *str)
 {
-       gchar * str1;
-       gchar * str2;
+       gchar *str1;
+       gchar *str2;
 
        if (str == NULL)
                return FALSE;
 
-       switch(prop->matchtype) {
-       case MATCHING_REGEXPCASE:
-       case MATCHING_REGEXP:
+       switch (prop->matchtype) {
+       case MATCHTYPE_REGEXPCASE:
+       case MATCHTYPE_REGEXP:
                if (!prop->preg && (prop->error == 0)) {
                        prop->preg = g_new0(regex_t, 1);
+                       /* if regexp then don't use the escaped string */
                        if (regcomp(prop->preg, prop->expr,
                                    REG_NOSUB | REG_EXTENDED
-                                   | ((prop->matchtype == MATCHING_REGEXPCASE)
+                                   | ((prop->matchtype == MATCHTYPE_REGEXPCASE)
                                    ? REG_ICASE : 0)) != 0) {
                                prop->error = 1;
                                g_free(prop->preg);
+                               prop->preg = NULL;
                        }
                }
                if (prop->preg == NULL)
@@ -489,11 +381,12 @@ static gboolean matcherprop_string_match(MatcherProp * prop, gchar * str)
                        return TRUE;
                else
                        return FALSE;
-
-       case MATCHING_MATCH:
+                       
+       case MATCHTYPE_MATCH:
                return (strstr(str, prop->expr) != NULL);
 
-       case MATCHING_MATCHCASE:
+       /* FIXME: put upper in unesc_str */
+       case MATCHTYPE_MATCHCASE:
                str2 = alloca(strlen(prop->expr) + 1);
                strcpy(str2, prop->expr);
                g_strup(str2);
@@ -507,170 +400,272 @@ static gboolean matcherprop_string_match(MatcherProp * prop, gchar * str)
        }
 }
 
-gboolean matcherprop_match_execute(MatcherProp * prop, MsgInfo * info)
+/* FIXME body search is a hack. */
+static gboolean matcherprop_string_decode_match(MatcherProp *prop, const gchar *str)
 {
-       gchar * file;
-       gchar * cmd;
+       gchar *utf = NULL;
+       gchar tmp[BUFFSIZE];
+       gboolean res = FALSE;
+
+       if (str == NULL)
+               return FALSE;
+
+       /* we try to decode QP first, because it's faster than base64 */
+       qp_decode_const(tmp, BUFFSIZE-1, str);
+       if (!g_utf8_validate(tmp, -1, NULL)) {
+               utf = conv_codeset_strdup
+                       (tmp, conv_get_locale_charset_str_no_utf8(),
+                        CS_INTERNAL);
+               res = matcherprop_string_match(prop, utf);
+               g_free(utf);
+       } else {
+               res = matcherprop_string_match(prop, tmp);
+       }
+       
+       if (res == FALSE && (strchr(prop->expr, '=') || strchr(prop->expr, '_')
+                           || strchr(str, '=') || strchr(str, '_'))) {
+               /* if searching for something with an equal char, maybe 
+                * we should try to match the non-decoded string. 
+                * In case it was not qp-encoded. */
+               if (!g_utf8_validate(str, -1, NULL)) {
+                       utf = conv_codeset_strdup
+                               (str, conv_get_locale_charset_str_no_utf8(),
+                                CS_INTERNAL);
+                       res = matcherprop_string_match(prop, utf);
+                       g_free(utf);
+               } else {
+                       res = matcherprop_string_match(prop, str);
+               }
+       }
+
+       /* FIXME base64 decoding is too slow, especially since text can 
+        * easily be handled as base64. Don't even try now. */
+
+       return res;
+}
+
+#ifdef USE_PTHREAD
+typedef struct _thread_data {
+       const gchar *cmd;
+       gboolean done;
+} thread_data;
+#endif
+
+#ifdef USE_PTHREAD
+void *matcher_test_thread(void *data)
+{
+       thread_data *td = (thread_data *)data;
+       int result = -1;
+
+       pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+       pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+
+       result = system(td->cmd);
+       if (result) perror("system");
+       td->done = TRUE; /* let the caller thread join() */
+       return GINT_TO_POINTER(result);
+}
+#endif
+
+/*!
+ *\brief       Execute a command defined in the matcher structure
+ *
+ *\param       prop Pointer to matcher structure
+ *\param       info Pointer to message info structure
+ *
+ *\return      gboolean TRUE if command was executed succesfully
+ */
+static gboolean matcherprop_match_test(const MatcherProp *prop, 
+                                         MsgInfo *info)
+{
+       gchar *file;
+       gchar *cmd;
+       gint retval;
+#ifdef USE_PTHREAD
+       pthread_t pt;
+       thread_data *td = g_new0(thread_data, 1);
+       void *res = NULL;
+       time_t start_time = time(NULL);
+#endif
 
        file = procmsg_get_message_file(info);
        if (file == NULL)
                return FALSE;
+       g_free(file);           
 
        cmd = matching_build_command(prop->expr, info);
        if (cmd == NULL)
                return FALSE;
 
-       return (system(cmd) == 0);
-}
+#if (defined USE_PTHREAD && defined __GLIBC__ && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)))
+       td->cmd = cmd;
+       td->done = FALSE;
+       if (pthread_create(&pt, PTHREAD_CREATE_JOINABLE, 
+                       matcher_test_thread, td) != 0)
+               retval = system(cmd);
+       else {
+               printf("waiting for test thread\n");
+               while(!td->done) {
+                       /* don't let the interface freeze while waiting */
+                       sylpheed_do_idle();
+                       if (time(NULL) - start_time > 30) {
+                               pthread_cancel(pt);
+                               td->done = TRUE;
+                               retval = -1;
+                       }
+               }
+               pthread_join(pt, &res);
+               retval = GPOINTER_TO_INT(res);
+               printf(" test thread returned %d\n", retval);
+       }
+       g_free(td);
+#else
+       retval = system(cmd);
+#endif
+       debug_print("Command exit code: %d\n", retval);
 
-/* match a message and his headers, hlist can be NULL if you don't
-   want to use headers */
+       g_free(cmd);
+       return (retval == 0);
+}
 
-gboolean matcherprop_match(MatcherProp * prop, MsgInfo * info)
+/*!
+ *\brief       Check if a message matches the condition in a matcher
+ *             structure.
+ *
+ *\param       prop Pointer to matcher structure
+ *\param       info Pointer to message info
+ *
+ *\return      gboolean TRUE if a match
+ */
+gboolean matcherprop_match(MatcherProp *prop, 
+                          MsgInfo *info)
 {
        time_t t;
 
        switch(prop->criteria) {
-       case MATCHING_ALL:
+       case MATCHCRITERIA_ALL:
                return 1;
-       case MATCHING_UNREAD:
+       case MATCHCRITERIA_UNREAD:
                return MSG_IS_UNREAD(info->flags);
-       case MATCHING_NOT_UNREAD:
+       case MATCHCRITERIA_NOT_UNREAD:
                return !MSG_IS_UNREAD(info->flags);
-       case MATCHING_NEW:
+       case MATCHCRITERIA_NEW:
                return MSG_IS_NEW(info->flags);
-       case MATCHING_NOT_NEW:
+       case MATCHCRITERIA_NOT_NEW:
                return !MSG_IS_NEW(info->flags);
-       case MATCHING_MARKED:
+       case MATCHCRITERIA_MARKED:
                return MSG_IS_MARKED(info->flags);
-       case MATCHING_NOT_MARKED:
+       case MATCHCRITERIA_NOT_MARKED:
                return !MSG_IS_MARKED(info->flags);
-       case MATCHING_DELETED:
+       case MATCHCRITERIA_DELETED:
                return MSG_IS_DELETED(info->flags);
-       case MATCHING_NOT_DELETED:
+       case MATCHCRITERIA_NOT_DELETED:
                return !MSG_IS_DELETED(info->flags);
-       case MATCHING_REPLIED:
+       case MATCHCRITERIA_REPLIED:
                return MSG_IS_REPLIED(info->flags);
-       case MATCHING_NOT_REPLIED:
+       case MATCHCRITERIA_NOT_REPLIED:
                return !MSG_IS_REPLIED(info->flags);
-       case MATCHING_FORWARDED:
+       case MATCHCRITERIA_FORWARDED:
                return MSG_IS_FORWARDED(info->flags);
-       case MATCHING_NOT_FORWARDED:
+       case MATCHCRITERIA_NOT_FORWARDED:
                return !MSG_IS_FORWARDED(info->flags);
-       case MATCHING_SUBJECT:
+       case MATCHCRITERIA_LOCKED:
+               return MSG_IS_LOCKED(info->flags);
+       case MATCHCRITERIA_NOT_LOCKED:
+               return !MSG_IS_LOCKED(info->flags);
+       case MATCHCRITERIA_COLORLABEL:
+               return MSG_GET_COLORLABEL_VALUE(info->flags) == prop->value; 
+       case MATCHCRITERIA_NOT_COLORLABEL:
+               return MSG_GET_COLORLABEL_VALUE(info->flags) != prop->value;
+       case MATCHCRITERIA_IGNORE_THREAD:
+               return MSG_IS_IGNORE_THREAD(info->flags);
+       case MATCHCRITERIA_NOT_IGNORE_THREAD:
+               return !MSG_IS_IGNORE_THREAD(info->flags);
+       case MATCHCRITERIA_SUBJECT:
                return matcherprop_string_match(prop, info->subject);
-       case MATCHING_NOT_SUBJECT:
+       case MATCHCRITERIA_NOT_SUBJECT:
                return !matcherprop_string_match(prop, info->subject);
-       case MATCHING_FROM:
+       case MATCHCRITERIA_FROM:
                return matcherprop_string_match(prop, info->from);
-       case MATCHING_NOT_FROM:
+       case MATCHCRITERIA_NOT_FROM:
                return !matcherprop_string_match(prop, info->from);
-       case MATCHING_TO:
+       case MATCHCRITERIA_TO:
                return matcherprop_string_match(prop, info->to);
-       case MATCHING_NOT_TO:
+       case MATCHCRITERIA_NOT_TO:
                return !matcherprop_string_match(prop, info->to);
-       case MATCHING_CC:
+       case MATCHCRITERIA_CC:
                return matcherprop_string_match(prop, info->cc);
-       case MATCHING_NOT_CC:
+       case MATCHCRITERIA_NOT_CC:
                return !matcherprop_string_match(prop, info->cc);
-       case MATCHING_TO_OR_CC:
+       case MATCHCRITERIA_TO_OR_CC:
                return matcherprop_string_match(prop, info->to)
                        || matcherprop_string_match(prop, info->cc);
-       case MATCHING_NOT_TO_AND_NOT_CC:
+       case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
                return !(matcherprop_string_match(prop, info->to)
                || matcherprop_string_match(prop, info->cc));
-       case MATCHING_AGE_GREATER:
+       case MATCHCRITERIA_AGE_GREATER:
                t = time(NULL);
-               return ((t - info->date_t) / (60 * 60 * 24)) >= prop->value;
-       case MATCHING_AGE_LOWER:
+               return ((t - info->date_t) / (60 * 60 * 24)) > prop->value;
+       case MATCHCRITERIA_AGE_LOWER:
                t = time(NULL);
-               return ((t - info->date_t) / (60 * 60 * 24)) <= prop->value;
-       case MATCHING_SCORE_GREATER:
-               return info->score >= prop->value;
-       case MATCHING_SCORE_LOWER:
-               return info->score <= prop->value;
-       case MATCHING_NEWSGROUPS:
+               return ((t - info->date_t) / (60 * 60 * 24)) < prop->value;
+       case MATCHCRITERIA_SCORE_GREATER:
+               return info->score > prop->value;
+       case MATCHCRITERIA_SCORE_LOWER:
+               return info->score < prop->value;
+       case MATCHCRITERIA_SCORE_EQUAL:
+               return info->score == prop->value;
+       case MATCHCRITERIA_SIZE_GREATER:
+               /* FIXME: info->size is an off_t */
+               return info->size > (off_t) prop->value;
+       case MATCHCRITERIA_SIZE_EQUAL:
+               /* FIXME: info->size is an off_t */
+               return info->size == (off_t) prop->value;
+       case MATCHCRITERIA_SIZE_SMALLER:
+               /* FIXME: info->size is an off_t */
+               return info->size <  (off_t) prop->value;
+       case MATCHCRITERIA_PARTIAL:
+               /* FIXME: info->size is an off_t */
+               return (info->total_size != 0 && info->size != (off_t)info->total_size);
+       case MATCHCRITERIA_NOT_PARTIAL:
+               /* FIXME: info->size is an off_t */
+               return (info->total_size == 0 || info->size == (off_t)info->total_size);
+       case MATCHCRITERIA_NEWSGROUPS:
                return matcherprop_string_match(prop, info->newsgroups);
-       case MATCHING_NOT_NEWSGROUPS:
+       case MATCHCRITERIA_NOT_NEWSGROUPS:
                return !matcherprop_string_match(prop, info->newsgroups);
-       case MATCHING_INREPLYTO:
+       case MATCHCRITERIA_INREPLYTO:
+               return matcherprop_string_match(prop, info->inreplyto);
+       case MATCHCRITERIA_NOT_INREPLYTO:
+               return !matcherprop_string_match(prop, info->inreplyto);
+       /* FIXME: Using inreplyto, but matching the (newly implemented)
+         * list of references is better */
+        case MATCHCRITERIA_REFERENCES:
                return matcherprop_string_match(prop, info->inreplyto);
-       case MATCHING_NOT_INREPLYTO:
+       case MATCHCRITERIA_NOT_REFERENCES:
                return !matcherprop_string_match(prop, info->inreplyto);
-       case MATCHING_REFERENCES:
-               return matcherprop_string_match(prop, info->references);
-       case MATCHING_NOT_REFERENCES:
-               return !matcherprop_string_match(prop, info->references);
-       case MATCHING_EXECUTE:
-               return matcherprop_match_execute(prop, info);
-       case MATCHING_NOT_EXECUTE:
-               return !matcherprop_match_execute(prop, info);
+       case MATCHCRITERIA_TEST:
+               return matcherprop_match_test(prop, info);
+       case MATCHCRITERIA_NOT_TEST:
+               return !matcherprop_match_test(prop, info);
        default:
-               return 0;
+               return FALSE;
        }
 }
 
 /* ********************* MatcherList *************************** */
 
-
-/* parse for a list of conditions */
-
-MatcherList * matcherlist_parse(gchar ** str)
-{
-       gchar * tmp;
-       MatcherProp * matcher;
-       GSList * matchers_list = NULL;
-       gboolean bool_and = TRUE;
-       gchar * save;
-       MatcherList * cond;
-       gboolean main_bool_and = TRUE;
-       GSList * l;
-
-       tmp = * str;
-
-       matcher = matcherprop_parse(&tmp);
-
-       if (tmp == NULL) {
-               * str = NULL;
-               return NULL;
-       }
-       matchers_list = g_slist_append(matchers_list, matcher);
-       while (matcher) {
-               save = tmp;
-               bool_and = matcher_parse_boolean_op(&tmp);
-               if (tmp == NULL) {
-                       tmp = save;
-                       matcher = NULL;
-               }
-               else {
-                       main_bool_and = bool_and;
-                       matcher = matcherprop_parse(&tmp);
-                       if (tmp != NULL) {
-                               matchers_list =
-                                       g_slist_append(matchers_list, matcher);
-                       }
-                       else {
-                               for(l = matchers_list ; l != NULL ;
-                                   l = g_slist_next(l))
-                                       matcherprop_free((MatcherProp *)
-                                                        l->data);
-                               g_slist_free(matchers_list);
-                               * str = NULL;
-                               return NULL;
-                       }
-               }
-       }
-
-       cond = matcherlist_new(matchers_list, main_bool_and);
-
-       * str = tmp;
-
-       return cond;
-}
-
-MatcherList * matcherlist_new(GSList * matchers, gboolean bool_and)
+/*!
+ *\brief       Create a new list of matchers 
+ *
+ *\param       matchers List of matcher structures
+ *\param       bool_and Operator
+ *
+ *\return      MatcherList * New list
+ */
+MatcherList *matcherlist_new(GSList *matchers, gboolean bool_and)
 {
-       MatcherList * cond;
+       MatcherList *cond;
 
        cond = g_new0(MatcherList, 1);
 
@@ -680,48 +675,58 @@ MatcherList * matcherlist_new(GSList * matchers, gboolean bool_and)
        return cond;
 }
 
-void matcherlist_free(MatcherList * cond)
+/*!
+ *\brief       Frees a list of matchers
+ *
+ *\param       cond List of matchers
+ */
+void matcherlist_free(MatcherList *cond)
 {
-       GSList * l;
+       GSList *l;
 
-       for(l = cond->matchers ; l != NULL ; l = g_slist_next(l)) {
+       g_return_if_fail(cond);
+       for (l = cond->matchers ; l != NULL ; l = g_slist_next(l)) {
                matcherprop_free((MatcherProp *) l->data);
        }
        g_free(cond);
 }
 
-/*
-  skip the headers
+/*!
+ *\brief       Skip all headers in a message file
+ *
+ *\param       fp Message file
  */
-
 static void matcherlist_skip_headers(FILE *fp)
 {
        gchar buf[BUFFSIZE];
 
-       while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1) {
-       }
+       while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1)
+               ;
 }
 
-/*
-  matcherprop_match_one_header
-  returns TRUE if buf matchs the MatchersProp criteria
+/*!
+ *\brief       Check if a header matches a matcher condition
+ *
+ *\param       matcher Matcher structure to check header for
+ *\param       buf Header name
+ *
+ *\return      boolean TRUE if matching header
  */
-
-static gboolean matcherprop_match_one_header(MatcherProp * matcher,
-                                            gchar * buf)
+static gboolean matcherprop_match_one_header(MatcherProp *matcher,
+                                            gchar *buf)
 {
-       gboolean result;
-       Header *header;
+       gboolean result = FALSE;
+       Header *header = NULL;
 
-       switch(matcher->criteria) {
-       case MATCHING_HEADER:
-       case MATCHING_NOT_HEADER:
+       switch (matcher->criteria) {
+       case MATCHCRITERIA_HEADER:
+       case MATCHCRITERIA_NOT_HEADER:
                header = procheader_parse_header(buf);
                if (!header)
                        return FALSE;
                if (procheader_headername_equal(header->name,
                                                matcher->header)) {
-                       if (matcher->criteria == MATCHING_HEADER)
+                       if (matcher->criteria == MATCHCRITERIA_HEADER)
                                result = matcherprop_string_match(matcher, header->body);
                        else
                                result = !matcherprop_string_match(matcher, header->body);
@@ -732,67 +737,190 @@ static gboolean matcherprop_match_one_header(MatcherProp * matcher,
                        procheader_header_free(header);
                }
                break;
-       case MATCHING_HEADERS_PART:
-       case MATCHING_MESSAGE:
+       case MATCHCRITERIA_HEADERS_PART:
                return matcherprop_string_match(matcher, buf);
-       case MATCHING_NOT_MESSAGE:
-       case MATCHING_NOT_HEADERS_PART:
+       case MATCHCRITERIA_MESSAGE:
+               return matcherprop_string_decode_match(matcher, buf);
+       case MATCHCRITERIA_NOT_MESSAGE:
+               return !matcherprop_string_decode_match(matcher, buf);
+       case MATCHCRITERIA_NOT_HEADERS_PART:
                return !matcherprop_string_match(matcher, buf);
+       case MATCHCRITERIA_FOUND_IN_ADDRESSBOOK:
+       case MATCHCRITERIA_NOT_FOUND_IN_ADDRESSBOOK:
+               {
+                       GSList *address_list = NULL;
+                       gint match = MATCH_ONE;
+                       gboolean found = FALSE;
+
+                       /* how many address headers are me trying to mach? */
+                       if (strcasecmp(matcher->header, _("Any")) == 0)
+                               match = MATCH_ANY;
+                       else if (strcasecmp(matcher->header, Q_("Filtering Matcher Menu|All")) == 0)
+                                       match = MATCH_ALL;
+
+                       if (match == MATCH_ONE) {
+                               /* matching one address header exactly, is that the right one? */
+                               header = procheader_parse_header(buf);
+                               if (!header ||
+                                               !procheader_headername_equal(header->name, matcher->header))
+                                       return FALSE;
+                               address_list = address_list_append(address_list, header->body);
+                               if (address_list == NULL)
+                                       return FALSE;
+
+                       } else {
+                               header = procheader_parse_header(buf);
+                               if (!header)
+                                       return FALSE;
+                               /* address header is one of the headers we have to match when checking
+                                  for any address header or all address headers? */
+                               if (procheader_headername_equal(header->name, "From") ||
+                                        procheader_headername_equal(header->name, "To") ||
+                                        procheader_headername_equal(header->name, "Cc") ||
+                                        procheader_headername_equal(header->name, "Reply-To") ||
+                                        procheader_headername_equal(header->name, "Sender"))
+                                       address_list = address_list_append(address_list, header->body);
+                               if (address_list == NULL)
+                                       return FALSE;
+                       }
+
+                       found = match_with_addresses_in_addressbook
+                                                       (matcher, address_list, matcher->criteria,
+                                                        matcher->expr, match);
+                       g_slist_free(address_list);
+
+                       if (matcher->criteria == MATCHCRITERIA_NOT_FOUND_IN_ADDRESSBOOK)
+                               return !found;
+                       else
+                               return found;
+       }
        }
+
        return FALSE;
 }
 
-/*
-  matcherprop_criteria_header
-  returns TRUE if the headers must be matched
+/*!
+ *\brief       Check if the matcher structure wants headers to
+ *             be matched
+ *
+ *\param       matcher Matcher structure
+ *
+ *\return      gboolean TRUE if the matcher structure describes
+ *             a header match condition
  */
-
-static gboolean matcherprop_criteria_headers(MatcherProp * matcher)
+static gboolean matcherprop_criteria_headers(const MatcherProp *matcher)
 {
-       switch(matcher->criteria) {
-       case MATCHING_HEADER:
-       case MATCHING_NOT_HEADER:
-       case MATCHING_HEADERS_PART:
-       case MATCHING_NOT_HEADERS_PART:
+       switch (matcher->criteria) {
+       case MATCHCRITERIA_HEADER:
+       case MATCHCRITERIA_NOT_HEADER:
+       case MATCHCRITERIA_HEADERS_PART:
+       case MATCHCRITERIA_NOT_HEADERS_PART:
+       case MATCHCRITERIA_FOUND_IN_ADDRESSBOOK:
+       case MATCHCRITERIA_NOT_FOUND_IN_ADDRESSBOOK:
                return TRUE;
        default:
                return FALSE;
        }
 }
 
-static gboolean matcherprop_criteria_message(MatcherProp * matcher)
+/*!
+ *\brief       Check if the matcher structure wants the message
+ *             to be matched (just perform an action on any
+ *             message)
+ *
+ *\param       matcher Matcher structure
+ *
+ *\return      gboolean TRUE if matcher condition should match
+ *             a message
+ */
+static gboolean matcherprop_criteria_message(MatcherProp *matcher)
 {
-       switch(matcher->criteria) {
-       case MATCHING_MESSAGE:
-       case MATCHING_NOT_MESSAGE:
+       switch (matcher->criteria) {
+       case MATCHCRITERIA_MESSAGE:
+       case MATCHCRITERIA_NOT_MESSAGE:
                return TRUE;
        default:
                return FALSE;
        }
 }
 
-/*
-  matcherlist_match_one_header
-  returns TRUE if match should stop
+/*!
+ *\brief       Check if a list of conditions matches one header in
+ *             a message file.
+ *
+ *\param       matchers List of conditions
+ *\param       fp Message file
+ *
+ *\return      gboolean TRUE if one of the headers is matched by
+ *             the list of conditions. 
  */
-
-static gboolean matcherlist_match_one_header(MatcherList * matchers,
-                                        gchar * buf)
+static gboolean matcherlist_match_headers(MatcherList *matchers, FILE *fp)
 {
-       GSList * l;
-
-       for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
-               MatcherProp * matcher = (MatcherProp *) l->data;
+       GSList *l;
+       gchar buf[BUFFSIZE];
 
-               if (matcherprop_criteria_headers(matcher) ||
-                   matcherprop_criteria_message(matcher)) {
-                       if (matcherprop_match_one_header(matcher, buf)) {
-                               matcher->result = TRUE;
+       while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1) {
+               for (l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
+                       MatcherProp *matcher = (MatcherProp *) l->data;
+                       gint match = MATCH_ANY;
+
+                       if (matcher->done)
+                               continue;
+
+                       /* determine the match range (all, any are our concern here) */
+                       if (matcher->criteria == MATCHCRITERIA_NOT_HEADERS_PART ||
+                           matcher->criteria == MATCHCRITERIA_NOT_MESSAGE) {
+                               match = MATCH_ALL;
+
+                       } else if (matcher->criteria == MATCHCRITERIA_FOUND_IN_ADDRESSBOOK ||
+                                          matcher->criteria == MATCHCRITERIA_NOT_FOUND_IN_ADDRESSBOOK) {
+                               Header *header = NULL;
+
+                               /* address header is one of the headers we have to match when checking
+                                  for any address header or all address headers? */
+                               header = procheader_parse_header(buf);
+                               if (header &&
+                                       (procheader_headername_equal(header->name, "From") ||
+                                        procheader_headername_equal(header->name, "To") ||
+                                        procheader_headername_equal(header->name, "Cc") ||
+                                        procheader_headername_equal(header->name, "Reply-To") ||
+                                        procheader_headername_equal(header->name, "Sender"))) {
+
+                                       if (strcasecmp(matcher->header, _("Any")) == 0)
+                                               match = MATCH_ANY;
+                                       else if (strcasecmp(matcher->header, Q_("Filtering Matcher Menu|All")) == 0)
+                                               match = MATCH_ALL;
+                                       else
+                                               match = MATCH_ONE;
+                               } else {
+                                       /* further call to matcherprop_match_one_header() can't match
+                                          and it irrelevant, so: don't alter the match result */
+                                       continue;
+                               }
                        }
-               }
 
-               if (matcherprop_criteria_headers(matcher)) {
-                       if (matcher->result) {
+                       /* ZERO line must NOT match for the rule to match.
+                        */
+                       if (match == MATCH_ALL) {
+                               if (matcherprop_match_one_header(matcher, buf)) {
+                                       matcher->result = TRUE;
+                               } else {
+                                       matcher->result = FALSE;
+                                       matcher->done = TRUE;
+                               }
+                       /* else, just one line matching is enough for the rule to match
+                        */
+                       } else if (matcherprop_criteria_headers(matcher) ||
+                                  matcherprop_criteria_message(matcher)) {
+                               if (matcherprop_match_one_header(matcher, buf)) {
+                                       matcher->result = TRUE;
+                                       matcher->done = TRUE;
+                               }
+                       }
+                       
+                       /* if the rule matched and the matchers are OR, no need to
+                        * check the others */
+                       if (matcher->result && matcher->done) {
                                if (!matchers->bool_and)
                                        return TRUE;
                        }
@@ -802,114 +930,121 @@ static gboolean matcherlist_match_one_header(MatcherList * matchers,
        return FALSE;
 }
 
-/*
-  matcherlist_match_headers
-  returns TRUE if one of the headers matchs the MatcherList criteria
+/*!
+ *\brief       Check if a matcher wants to check the message body
+ *
+ *\param       matcher Matcher structure
+ *
+ *\return      gboolean TRUE if body must be matched.
  */
-
-static gboolean matcherlist_match_headers(MatcherList * matchers, FILE * fp)
+static gboolean matcherprop_criteria_body(const MatcherProp *matcher)
 {
-       gchar buf[BUFFSIZE];
-
-       while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1)
-               if (matcherlist_match_one_header(matchers, buf))
-                       return TRUE;
-
-       return FALSE;
-}
-
-/*
-  matcherprop_criteria_body
-  returns TRUE if the body must be matched
- */
-
-static gboolean matcherprop_criteria_body(MatcherProp * matcher)
-{
-       switch(matcher->criteria) {
-       case MATCHING_BODY_PART:
-       case MATCHING_NOT_BODY_PART:
+       switch (matcher->criteria) {
+       case MATCHCRITERIA_BODY_PART:
+       case MATCHCRITERIA_NOT_BODY_PART:
                return TRUE;
        default:
                return FALSE;
        }
 }
 
-/*
-  matcherprop_match_line
-  returns TRUE if the string matchs the MatcherProp criteria
+/*!
+ *\brief       Check if a (line) string matches the criteria
+ *             described by a matcher structure
+ *
+ *\param       matcher Matcher structure
+ *\param       line String
+ *
+ *\return      gboolean TRUE if string matches criteria
  */
-
-static gboolean matcherprop_match_line(MatcherProp * matcher, gchar * line)
+static gboolean matcherprop_match_line(MatcherProp *matcher, const gchar *line)
 {
-       switch(matcher->criteria) {
-       case MATCHING_BODY_PART:
-       case MATCHING_MESSAGE:
-               return matcherprop_string_match(matcher, line);
-       case MATCHING_NOT_BODY_PART:
-       case MATCHING_NOT_MESSAGE:
-               return !matcherprop_string_match(matcher, line);
+       switch (matcher->criteria) {
+       case MATCHCRITERIA_BODY_PART:
+       case MATCHCRITERIA_MESSAGE:
+               return matcherprop_string_decode_match(matcher, line);
+       case MATCHCRITERIA_NOT_BODY_PART:
+       case MATCHCRITERIA_NOT_MESSAGE:
+               return !matcherprop_string_decode_match(matcher, line);
        }
        return FALSE;
 }
 
-/*
-  matcherlist_match_line
-  returns TRUE if the string matchs the MatcherList criteria
+/*!
+ *\brief       Check if a line in a message file's body matches
+ *             the criteria
+ *
+ *\param       matchers List of conditions
+ *\param       fp Message file
+ *
+ *\return      gboolean TRUE if succesful match
  */
-
-static gboolean matcherlist_match_line(MatcherList * matchers, gchar * line)
+static gboolean matcherlist_match_body(MatcherList *matchers, FILE *fp)
 {
-       GSList * l;
-
-       for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
-               MatcherProp * matcher = (MatcherProp *) l->data;
+       GSList *l;
+       gchar buf[BUFFSIZE];
+       
+       while (fgets(buf, sizeof(buf), fp) != NULL) {
+               for (l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
+                       MatcherProp *matcher = (MatcherProp *) l->data;
+                       
+                       if (matcher->done) 
+                               continue;
+
+                       /* if the criteria is ~body_part or ~message, ZERO lines
+                        * must NOT match for the rule to match. */
+                       if (matcher->criteria == MATCHCRITERIA_NOT_BODY_PART ||
+                           matcher->criteria == MATCHCRITERIA_NOT_MESSAGE) {
+                               if (matcherprop_match_line(matcher, buf)) {
+                                       matcher->result = TRUE;
+                               } else {
+                                       matcher->result = FALSE;
+                                       matcher->done = TRUE;
+                               }
+                       /* else, just one line has to match */
+                       } else if (matcherprop_criteria_body(matcher) ||
+                                  matcherprop_criteria_message(matcher)) {
+                               if (matcherprop_match_line(matcher, buf)) {
+                                       matcher->result = TRUE;
+                                       matcher->done = TRUE;
+                               }
+                       }
 
-               if (matcherprop_criteria_body(matcher) ||
-                   matcherprop_criteria_message(matcher)) {
-                       if (matcherprop_match_line(matcher, line)) {
-                               matcher->result = TRUE;
+                       /* if the matchers are OR'ed and the rule matched,
+                        * no need to check the others. */
+                       if (matcher->result && matcher->done) {
+                               if (!matchers->bool_and)
+                                       return TRUE;
                        }
                }
-                       
-               if (matcher->result) {
-                       if (!matchers->bool_and)
-                               return TRUE;
-               }
        }
        return FALSE;
 }
 
-/*
-  matcherlist_match_body
-  returns TRUE if one line of the body matchs the MatcherList criteria
+/*!
+ *\brief       Check if a message file matches criteria
+ *
+ *\param       matchers Criteria
+ *\param       info Message info
+ *\param       result Default result
+ *
+ *\return      gboolean TRUE if matched
  */
-
-static gboolean matcherlist_match_body(MatcherList * matchers, FILE * fp)
-{
-       gchar buf[BUFFSIZE];
-
-       while (fgets(buf, sizeof(buf), fp) != NULL)
-               if (matcherlist_match_line(matchers, buf))
-                       return TRUE;
-
-       return FALSE;
-}
-
-gboolean matcherlist_match_file(MatcherList * matchers, MsgInfo * info,
+gboolean matcherlist_match_file(MatcherList *matchers, MsgInfo *info,
                                gboolean result)
 {
        gboolean read_headers;
        gboolean read_body;
-       GSList * l;
-       FILE * fp;
-       gchar * file;
+       GSList *l;
+       FILE *fp;
+       gchar *file;
 
        /* file need to be read ? */
 
        read_headers = FALSE;
        read_body = FALSE;
-       for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
-               MatcherProp * matcher = (MatcherProp *) l->data;
+       for (l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
+               MatcherProp *matcher = (MatcherProp *) l->data;
 
                if (matcherprop_criteria_headers(matcher))
                        read_headers = TRUE;
@@ -920,16 +1055,17 @@ gboolean matcherlist_match_file(MatcherList * matchers, MsgInfo * info,
                        read_body = TRUE;
                }
                matcher->result = FALSE;
+               matcher->done = FALSE;
        }
 
        if (!read_headers && !read_body)
                return result;
 
-       file = procmsg_get_message_file(info);
+       file = procmsg_get_message_file_full(info, read_headers, read_body);
        if (file == NULL)
                return FALSE;
 
-       if ((fp = fopen(file, "r")) == NULL) {
+       if ((fp = g_fopen(file, "rb")) == NULL) {
                FILE_OP_ERROR(file, "fopen");
                g_free(file);
                return result;
@@ -940,8 +1076,7 @@ gboolean matcherlist_match_file(MatcherList * matchers, MsgInfo * info,
        if (read_headers) {
                if (matcherlist_match_headers(matchers, fp))
                        read_body = FALSE;
-       }
-       else {
+       } else {
                matcherlist_skip_headers(fp);
        }
 
@@ -950,12 +1085,12 @@ gboolean matcherlist_match_file(MatcherList * matchers, MsgInfo * info,
                matcherlist_match_body(matchers, fp);
        }
        
-       for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
-               MatcherProp * matcher = (MatcherProp *) l->data;
+       for (l = matchers->matchers; l != NULL; l = g_slist_next(l)) {
+               MatcherProp *matcher = (MatcherProp *) l->data;
 
                if (matcherprop_criteria_headers(matcher) ||
-                   matcherprop_criteria_body(matcher) ||
-                   matcherprop_criteria_message(matcher))
+                   matcherprop_criteria_body(matcher)    ||
+                   matcherprop_criteria_message(matcher)) {
                        if (matcher->result) {
                                if (!matchers->bool_and) {
                                        result = TRUE;
@@ -967,7 +1102,8 @@ gboolean matcherlist_match_file(MatcherList * matchers, MsgInfo * info,
                                        result = FALSE;
                                        break;
                                }
-               }
+                       }
+               }                       
        }
 
        g_free(file);
@@ -977,13 +1113,22 @@ gboolean matcherlist_match_file(MatcherList * matchers, MsgInfo * info,
        return result;
 }
 
-/* test a list of condition */
-
-gboolean matcherlist_match(MatcherList * matchers, MsgInfo * info)
+/*!
+ *\brief       Test list of conditions on a message.
+ *
+ *\param       matchers List of conditions
+ *\param       info Message info
+ *
+ *\return      gboolean TRUE if matched
+ */
+gboolean matcherlist_match(MatcherList *matchers, MsgInfo *info)
 {
-       GSList * l;
+       GSList *l;
        gboolean result;
 
+       if (!matchers)
+               return FALSE;
+
        if (matchers->bool_and)
                result = TRUE;
        else
@@ -991,45 +1136,57 @@ gboolean matcherlist_match(MatcherList * matchers, MsgInfo * info)
 
        /* test the cached elements */
 
-       for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
-               MatcherProp * matcher = (MatcherProp *) l->data;
+       for (l = matchers->matchers; l != NULL ;l = g_slist_next(l)) {
+               MatcherProp *matcher = (MatcherProp *) l->data;
 
                switch(matcher->criteria) {
-               case MATCHING_ALL:
-               case MATCHING_UNREAD:
-               case MATCHING_NOT_UNREAD:
-               case MATCHING_NEW:
-               case MATCHING_NOT_NEW:
-               case MATCHING_MARKED:
-               case MATCHING_NOT_MARKED:
-               case MATCHING_DELETED:
-               case MATCHING_NOT_DELETED:
-               case MATCHING_REPLIED:
-               case MATCHING_NOT_REPLIED:
-               case MATCHING_FORWARDED:
-               case MATCHING_NOT_FORWARDED:
-               case MATCHING_SUBJECT:
-               case MATCHING_NOT_SUBJECT:
-               case MATCHING_FROM:
-               case MATCHING_NOT_FROM:
-               case MATCHING_TO:
-               case MATCHING_NOT_TO:
-               case MATCHING_CC:
-               case MATCHING_NOT_CC:
-               case MATCHING_TO_OR_CC:
-               case MATCHING_NOT_TO_AND_NOT_CC:
-               case MATCHING_AGE_GREATER:
-               case MATCHING_AGE_LOWER:
-               case MATCHING_NEWSGROUPS:
-               case MATCHING_NOT_NEWSGROUPS:
-               case MATCHING_INREPLYTO:
-               case MATCHING_NOT_INREPLYTO:
-               case MATCHING_REFERENCES:
-               case MATCHING_NOT_REFERENCES:
-               case MATCHING_SCORE_GREATER:
-               case MATCHING_SCORE_LOWER:
-               case MATCHING_EXECUTE:
-               case MATCHING_NOT_EXECUTE:
+               case MATCHCRITERIA_ALL:
+               case MATCHCRITERIA_UNREAD:
+               case MATCHCRITERIA_NOT_UNREAD:
+               case MATCHCRITERIA_NEW:
+               case MATCHCRITERIA_NOT_NEW:
+               case MATCHCRITERIA_MARKED:
+               case MATCHCRITERIA_NOT_MARKED:
+               case MATCHCRITERIA_DELETED:
+               case MATCHCRITERIA_NOT_DELETED:
+               case MATCHCRITERIA_REPLIED:
+               case MATCHCRITERIA_NOT_REPLIED:
+               case MATCHCRITERIA_FORWARDED:
+               case MATCHCRITERIA_NOT_FORWARDED:
+               case MATCHCRITERIA_LOCKED:
+               case MATCHCRITERIA_NOT_LOCKED:
+               case MATCHCRITERIA_COLORLABEL:
+               case MATCHCRITERIA_NOT_COLORLABEL:
+               case MATCHCRITERIA_IGNORE_THREAD:
+               case MATCHCRITERIA_NOT_IGNORE_THREAD:
+               case MATCHCRITERIA_SUBJECT:
+               case MATCHCRITERIA_NOT_SUBJECT:
+               case MATCHCRITERIA_FROM:
+               case MATCHCRITERIA_NOT_FROM:
+               case MATCHCRITERIA_TO:
+               case MATCHCRITERIA_NOT_TO:
+               case MATCHCRITERIA_CC:
+               case MATCHCRITERIA_NOT_CC:
+               case MATCHCRITERIA_TO_OR_CC:
+               case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
+               case MATCHCRITERIA_AGE_GREATER:
+               case MATCHCRITERIA_AGE_LOWER:
+               case MATCHCRITERIA_NEWSGROUPS:
+               case MATCHCRITERIA_NOT_NEWSGROUPS:
+               case MATCHCRITERIA_INREPLYTO:
+               case MATCHCRITERIA_NOT_INREPLYTO:
+               case MATCHCRITERIA_REFERENCES:
+               case MATCHCRITERIA_NOT_REFERENCES:
+               case MATCHCRITERIA_SCORE_GREATER:
+               case MATCHCRITERIA_SCORE_LOWER:
+               case MATCHCRITERIA_SCORE_EQUAL:
+               case MATCHCRITERIA_SIZE_GREATER:
+               case MATCHCRITERIA_SIZE_SMALLER:
+               case MATCHCRITERIA_SIZE_EQUAL:
+               case MATCHCRITERIA_TEST:
+               case MATCHCRITERIA_NOT_TEST:
+               case MATCHCRITERIA_PARTIAL:
+               case MATCHCRITERIA_NOT_PARTIAL:
                        if (matcherprop_match(matcher, info)) {
                                if (!matchers->bool_and) {
                                        return TRUE;
@@ -1057,93 +1214,144 @@ gboolean matcherlist_match(MatcherList * matchers, MsgInfo * info)
        return result;
 }
 
-#if 0
-static void matcherprop_print(MatcherProp * matcher)
+
+static gint quote_filter_str(gchar * result, guint size,
+                            const gchar * path)
 {
-  int i;
+       const gchar * p;
+       gchar * result_p;
+       guint remaining;
 
-       if (matcher == NULL) {
-               printf("no matcher\n");
-               return;
-       }
+       result_p = result;
+       remaining = size;
 
-       switch (matcher->matchtype) {
-       case MATCHING_MATCH:
-               printf("match\n");
-               break;
-       case MATCHING_REGEXP:
-               printf("regexp\n");
-               break;
-       case MATCHING_MATCHCASE:
-               printf("matchcase\n");
-               break;
-       case MATCHING_REGEXPCASE:
-               printf("regexpcase\n");
-               break;
-       }
+       for(p = path ; * p != '\0' ; p ++) {
 
-       for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
-           i++) {
-               if (matchparser_tab[i].id == matcher->criteria)
-                       printf("%s\n", matchparser_tab[i].str);
+               if ((* p != '\"') && (* p != '\\')) {
+                       if (remaining > 0) {
+                               * result_p = * p;
+                               result_p ++; 
+                               remaining --;
+                       }
+                       else {
+                               result[size - 1] = '\0';
+                               return -1;
+                       }
+               }
+               else { 
+                       if (remaining >= 2) {
+                               * result_p = '\\';
+                               result_p ++; 
+                               * result_p = * p;
+                               result_p ++; 
+                               remaining -= 2;
+                       }
+                       else {
+                               result[size - 1] = '\0';
+                               return -1;
+                       }
+               }
        }
+       if (remaining > 0) {
+               * result_p = '\0';
+       }
+       else {
+               result[size - 1] = '\0';
+               return -1;
+       }
+  
+       return 0;
+}
 
-       if (matcher->expr)
-               printf("expr : %s\n", matcher->expr);
-
-       printf("age: %i\n", matcher->value;
 
-       printf("compiled : %s\n", matcher->preg != NULL ? "yes" : "no");
-       printf("error: %i\n",  matcher->error);
+gchar * matcher_quote_str(const gchar * src)
+{
+       gchar * res;
+       gint len;
+       
+       len = strlen(src) * 2 + 1;
+       res = g_malloc(len);
+       quote_filter_str(res, len, src);
+       
+       return res;
 }
-#endif
 
-gchar * matcherprop_to_string(MatcherProp * matcher)
+/*!
+ *\brief       Convert a matcher structure to a string
+ *
+ *\param       matcher Matcher structure
+ *
+ *\return      gchar * Newly allocated string
+ */
+gchar *matcherprop_to_string(MatcherProp *matcher)
 {
-       gchar * matcher_str = NULL;
-       gchar * criteria_str;
-       gchar * matchtype_str;
+       gchar *matcher_str = NULL;
+       const gchar *criteria_str;
+       const gchar *matchtype_str;
        int i;
-       gchar * p;
-       gint count;
-       gchar * expr_str;
-       gchar * out;
-
+       gchar * quoted_expr;
+       gchar * quoted_header;
+       
        criteria_str = NULL;
-       for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
-           i++) {
+       for (i = 0; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)); i++) {
                if (matchparser_tab[i].id == matcher->criteria)
                        criteria_str = matchparser_tab[i].str;
        }
        if (criteria_str == NULL)
                return NULL;
 
-       switch(matcher->criteria) {
-       case MATCHING_AGE_GREATER:
-       case MATCHING_AGE_LOWER:
-       case MATCHING_SCORE_GREATER:
-       case MATCHING_SCORE_LOWER:
+       switch (matcher->criteria) {
+       case MATCHCRITERIA_AGE_GREATER:
+       case MATCHCRITERIA_AGE_LOWER:
+       case MATCHCRITERIA_SCORE_GREATER:
+       case MATCHCRITERIA_SCORE_LOWER:
+       case MATCHCRITERIA_SCORE_EQUAL:
+       case MATCHCRITERIA_SIZE_GREATER:
+       case MATCHCRITERIA_SIZE_SMALLER:
+       case MATCHCRITERIA_SIZE_EQUAL:
+       case MATCHCRITERIA_COLORLABEL:
+       case MATCHCRITERIA_NOT_COLORLABEL:
                return g_strdup_printf("%s %i", criteria_str, matcher->value);
-               break;
-       case MATCHING_ALL:
-       case MATCHING_UNREAD:
-       case MATCHING_NOT_UNREAD:
-       case MATCHING_NEW:
-       case MATCHING_NOT_NEW:
-       case MATCHING_MARKED:
-       case MATCHING_NOT_MARKED:
-       case MATCHING_DELETED:
-       case MATCHING_NOT_DELETED:
-       case MATCHING_REPLIED:
-       case MATCHING_NOT_REPLIED:
-       case MATCHING_FORWARDED:
-       case MATCHING_NOT_FORWARDED:
+       case MATCHCRITERIA_ALL:
+       case MATCHCRITERIA_UNREAD:
+       case MATCHCRITERIA_NOT_UNREAD:
+       case MATCHCRITERIA_NEW:
+       case MATCHCRITERIA_NOT_NEW:
+       case MATCHCRITERIA_MARKED:
+       case MATCHCRITERIA_NOT_MARKED:
+       case MATCHCRITERIA_DELETED:
+       case MATCHCRITERIA_NOT_DELETED:
+       case MATCHCRITERIA_REPLIED:
+       case MATCHCRITERIA_NOT_REPLIED:
+       case MATCHCRITERIA_FORWARDED:
+       case MATCHCRITERIA_NOT_FORWARDED:
+       case MATCHCRITERIA_LOCKED:
+       case MATCHCRITERIA_NOT_LOCKED:
+       case MATCHCRITERIA_PARTIAL:
+       case MATCHCRITERIA_NOT_PARTIAL:
+       case MATCHCRITERIA_IGNORE_THREAD:
+       case MATCHCRITERIA_NOT_IGNORE_THREAD:
                return g_strdup(criteria_str);
+       case MATCHCRITERIA_TEST:
+       case MATCHCRITERIA_NOT_TEST:
+               quoted_expr = matcher_quote_str(matcher->expr);
+               matcher_str = g_strdup_printf("%s \"%s\"",
+                                             criteria_str, quoted_expr);
+               g_free(quoted_expr);
+                return matcher_str;
+       case MATCHCRITERIA_FOUND_IN_ADDRESSBOOK:
+       case MATCHCRITERIA_NOT_FOUND_IN_ADDRESSBOOK:
+               quoted_header = matcher_quote_str(matcher->header);
+               quoted_expr = matcher_quote_str(matcher->expr);
+               matcher_str = g_strdup_printf("%s \"%s\" in \"%s\"",
+                                             criteria_str, quoted_header, quoted_expr);
+               g_free(quoted_header);
+               g_free(quoted_expr);
+               return matcher_str;
        }
 
        matchtype_str = NULL;
-       for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
-           i++) {
+       for (i = 0; i < sizeof matchparser_tab / sizeof matchparser_tab[0]; i++) {
                if (matchparser_tab[i].id == matcher->matchtype)
                        matchtype_str = matchparser_tab[i].str;
        }
@@ -1152,69 +1360,49 @@ gchar * matcherprop_to_string(MatcherProp * matcher)
                return NULL;
 
        switch (matcher->matchtype) {
-       case MATCHING_MATCH:
-       case MATCHING_MATCHCASE:
-               count = 0;
-               for(p = matcher->expr; *p != 0 ; p++)
-                       if (*p == '\"') count ++;
-               
-               expr_str = g_new(char, strlen(matcher->expr) + count + 1);
-
-               for(p = matcher->expr, out = expr_str ; *p != 0 ; p++, out++) {
-                       if (*p == '\"') {
-                               *out = '\\'; out++;
-                               *out = '\"';
-                       }
-                       else
-                               *out = *p;
+       case MATCHTYPE_MATCH:
+       case MATCHTYPE_MATCHCASE:
+       case MATCHTYPE_REGEXP:
+       case MATCHTYPE_REGEXPCASE:
+               quoted_expr = matcher_quote_str(matcher->expr);
+               if (matcher->header) {
+                       quoted_header = matcher_quote_str(matcher->header);
+                       matcher_str = g_strdup_printf
+                                       ("%s \"%s\" %s \"%s\"",
+                                        criteria_str, quoted_header,
+                                        matchtype_str, quoted_expr);
+                       g_free(quoted_header);
                }
-               * out = '\0';
-
-               if (matcher->header)
-                       matcher_str =
-                               g_strdup_printf("%s \"%s\" %s \"%s\"",
-                                          criteria_str, matcher->header,
-                                          matchtype_str, expr_str);
-               else
-                       matcher_str =
-                               g_strdup_printf("%s %s \"%s\"", criteria_str,
-                                               matchtype_str, expr_str);
-               
-               g_free(expr_str);
-               
-               break;
-
-       case MATCHING_REGEXP:
-       case MATCHING_REGEXPCASE:
-
-               if (matcher->header)
-                       matcher_str =
-                               g_strdup_printf("%s \"%s\" %s /%s/",
-                                               criteria_str, matcher->header,
-                                               matchtype_str, matcher->expr);
                else
-                       matcher_str =
-                               g_strdup_printf("%s %s /%s/", criteria_str,
-                                               matchtype_str, matcher->expr);
-
+                       matcher_str = g_strdup_printf
+                                       ("%s %s \"%s\"", criteria_str,
+                                        matchtype_str, quoted_expr);
+                g_free(quoted_expr);
                break;
        }
 
        return matcher_str;
 }
 
-gchar * matcherlist_to_string(MatcherList * matchers)
+/*!
+ *\brief       Convert a list of conditions to a string
+ *
+ *\param       matchers List of conditions
+ *
+ *\return      gchar * Newly allocated string
+ */
+gchar *matcherlist_to_string(const MatcherList *matchers)
 {
        gint count;
-       gchar ** vstr;
-       GSList * l;
-       gchar ** cur_str;
-       gchar * result;
+       gchar **vstr;
+       GSList *l;
+       gchar **cur_str;
+       gchar *result = NULL;
 
        count = g_slist_length(matchers->matchers);
        vstr = g_new(gchar *, count + 1);
 
-       for (l = matchers->matchers, cur_str = vstr ; l != NULL ;
+       for (l = matchers->matchers, cur_str = vstr; l != NULL;
             l = g_slist_next(l), cur_str ++) {
                *cur_str = matcherprop_to_string((MatcherProp *) l->data);
                if (*cur_str == NULL)
@@ -1227,7 +1415,7 @@ gchar * matcherlist_to_string(MatcherList * matchers)
        else
                result = g_strjoinv(" | ", vstr);
 
-       for(cur_str = vstr ; *cur_str != NULL ; cur_str ++)
+       for (cur_str = vstr ; *cur_str != NULL ; cur_str ++)
                g_free(*cur_str);
        g_free(vstr);
 
@@ -1235,15 +1423,53 @@ gchar * matcherlist_to_string(MatcherList * matchers)
 }
 
 
-gchar * matching_build_command(gchar * cmd, MsgInfo * info)
+#define STRLEN_ZERO(s) ((s) ? strlen(s) : 0)
+#define STRLEN_DEFAULT(s,d) ((s) ? strlen(s) : STRLEN_ZERO(d))
+
+static void add_str_default(gchar ** dest,
+                           const gchar * s, const gchar * d)
+{
+       gchar quoted_str[4096];
+       const gchar * str;
+       
+        if (s != NULL)
+               str = s;
+       else
+               str = d;
+       
+       quote_cmd_argument(quoted_str, sizeof(quoted_str), str);
+       strcpy(* dest, quoted_str);
+       
+       (* dest) += strlen(* dest);
+}
+
+/* matching_build_command() - preferably cmd should be unescaped */
+/*!
+ *\brief       Build the command line to execute
+ *
+ *\param       cmd String with command line specifiers
+ *\param       info Message info to use for command
+ *
+ *\return      gchar * Newly allocated string
+ */
+gchar *matching_build_command(const gchar *cmd, MsgInfo *info)
 {
-       gchar * s = cmd;
-       gchar * filename = NULL;
-       gchar * processed_cmd;
-       gchar * p;
+       const gchar *s = cmd;
+       gchar *filename = NULL;
+       gchar *processed_cmd;
+       gchar *p;
        gint size;
 
-       size = strlen(cmd) + 1;
+       const gchar *const no_subject    = _("(none)") ;
+       const gchar *const no_from       = _("(none)") ;
+       const gchar *const no_to         = _("(none)") ;
+       const gchar *const no_cc         = _("(none)") ;
+       const gchar *const no_date       = _("(none)") ;
+       const gchar *const no_msgid      = _("(none)") ;
+       const gchar *const no_newsgroups = _("(none)") ;
+       const gchar *const no_references = _("(none)") ;
+
+       size = STRLEN_ZERO(cmd) + 1;
        while (*s != '\0') {
                if (*s == '%') {
                        s++;
@@ -1252,46 +1478,50 @@ gchar * matching_build_command(gchar * cmd, MsgInfo * info)
                                size -= 1;
                                break;
                        case 's': /* subject */
-                               size += strlen(info->subject) - 2;
+                               size += STRLEN_DEFAULT(info->subject, no_subject) - 2;
                                break;
                        case 'f': /* from */
-                               size += strlen(info->from) - 2;
+                               size += STRLEN_DEFAULT(info->from, no_from) - 2;
                                break;
                        case 't': /* to */
-                               size += strlen(info->to) - 2;
+                               size += STRLEN_DEFAULT(info->to, no_to) - 2;
                                break;
                        case 'c': /* cc */
-                               size += strlen(info->cc) - 2;
+                               size += STRLEN_DEFAULT(info->cc, no_cc) - 2;
                                break;
                        case 'd': /* date */
-                               size += strlen(info->date) - 2;
+                               size += STRLEN_DEFAULT(info->date, no_date) - 2;
                                break;
                        case 'i': /* message-id */
-                               size += strlen(info->msgid) - 2;
+                               size += STRLEN_DEFAULT(info->msgid, no_msgid) - 2;
                                break;
                        case 'n': /* newsgroups */
-                               size += strlen(info->newsgroups) - 2;
+                               size += STRLEN_DEFAULT(info->newsgroups, no_newsgroups) - 2;
                                break;
                        case 'r': /* references */
-                               size += strlen(info->references) - 2;
+                                /* FIXME: using the inreplyto header for reference */
+                               size += STRLEN_DEFAULT(info->inreplyto, no_references) - 2;
                                break;
                        case 'F': /* file */
-                               filename = folder_item_fetch_msg(info->folder,
-                                                                info->msgnum);
+                               if (filename == NULL)
+                                       filename = folder_item_fetch_msg(info->folder, info->msgnum);
                                
                                if (filename == NULL) {
-                                       g_warning(_("filename is not set"));
+                                       g_warning("filename is not set");
                                        return NULL;
                                }
-                               else
+                               else {
                                        size += strlen(filename) - 2;
+                               }
                                break;
                        }
                        s++;
                }
                else s++;
        }
-
+       
+       /* as the string can be quoted, we double the result */
+       size *= 2;
 
        processed_cmd = g_new0(gchar, size);
        s = cmd;
@@ -1306,64 +1536,40 @@ gchar * matching_build_command(gchar * cmd, MsgInfo * info)
                                p++;
                                break;
                        case 's': /* subject */
-                               if (info->subject != NULL)
-                                       strcpy(p, info->subject);
-                               else
-                                       strcpy(p, "(none)");
-                               p += strlen(p);
+                               add_str_default(&p, info->subject,
+                                               no_subject);
                                break;
                        case 'f': /* from */
-                               if (info->from != NULL)
-                                       strcpy(p, info->from);
-                               else
-                                       strcpy(p, "(none)");
-                               p += strlen(p);
+                               add_str_default(&p, info->from,
+                                               no_from);
                                break;
                        case 't': /* to */
-                               if (info->to != NULL)
-                                       strcpy(p, info->to);
-                               else
-                                       strcpy(p, "(none)");
-                               p += strlen(p);
+                               add_str_default(&p, info->to,
+                                               no_to);
                                break;
                        case 'c': /* cc */
-                               if (info->cc != NULL)
-                                       strcpy(p, info->cc);
-                               else
-                                       strcpy(p, "(none)");
-                               p += strlen(p);
+                               add_str_default(&p, info->cc,
+                                               no_cc);
                                break;
                        case 'd': /* date */
-                               if (info->date != NULL)
-                                       strcpy(p, info->date);
-                               else
-                                       strcpy(p, "(none)");
-                               p += strlen(p);
+                               add_str_default(&p, info->date,
+                                               no_date);
                                break;
                        case 'i': /* message-id */
-                               if (info->msgid != NULL)
-                                       strcpy(p, info->msgid);
-                               else
-                                       strcpy(p, "(none)");
-                               p += strlen(p);
+                               add_str_default(&p, info->msgid,
+                                               no_msgid);
                                break;
                        case 'n': /* newsgroups */
-                               if (info->newsgroups != NULL)
-                                       strcpy(p, info->newsgroups);
-                               else
-                                       strcpy(p, "(none)");
-                               p += strlen(p);
+                               add_str_default(&p, info->newsgroups,
+                                               no_newsgroups);
                                break;
                        case 'r': /* references */
-                               if (info->references != NULL)
-                                       strcpy(p, info->references);
-                               else
-                                       strcpy(p, "(none)");
-                               p += strlen(p);
+                                /* FIXME: using the inreplyto header for references */
+                               add_str_default(&p, info->inreplyto, no_references);
                                break;
                        case 'F': /* file */
-                               strcpy(p, filename);
-                               p += strlen(p);
+                               if (filename != NULL)
+                                       add_str_default(&p, filename, NULL);
                                break;
                        default:
                                *p = '%';
@@ -1380,16 +1586,283 @@ gchar * matching_build_command(gchar * cmd, MsgInfo * info)
                        s++;
                }
        }
+       g_free(filename);
+       
        return processed_cmd;
 }
-
+#undef STRLEN_DEFAULT
+#undef STRLEN_ZERO
 
 /* ************************************************************ */
 
-/*
-static void matcher_parse              (gchar * str)
+
+/*!
+ *\brief       Write filtering list to file
+ *
+ *\param       fp File
+ *\param       prefs_filtering List of filtering conditions
+ */
+static void prefs_filtering_write(FILE *fp, GSList *prefs_filtering)
 {
-       matcher_parser_scan_string(str);
-       matcher_parserparse();
+       GSList *cur = NULL;
+
+       for (cur = prefs_filtering; cur != NULL; cur = cur->next) {
+               gchar *filtering_str = NULL;
+               gchar *tmp_name = NULL;
+               FilteringProp *prop = NULL;
+
+               if (NULL == (prop = (FilteringProp *) cur->data))
+                       continue;
+               
+               if (NULL == (filtering_str = filteringprop_to_string(prop)))
+                       continue;
+
+               if (prop->enabled) {
+                       if (fputs("enabled ", fp) == EOF) {
+                               FILE_OP_ERROR("filtering config", "fputs");
+                               return;
+                       }
+               } else {
+                       if (fputs("disabled ", fp) == EOF) {
+                               FILE_OP_ERROR("filtering config", "fputs");
+                               return;
+                       }
+               }
+
+               if (fputs("rulename \"", fp) == EOF) {
+                       FILE_OP_ERROR("filtering config", "fputs");
+                       g_free(filtering_str);
+                       return;
+               }
+               tmp_name = prop->name;
+               while (tmp_name && *tmp_name != '\0') {
+                       if (*tmp_name != '"') {
+                               if (fputc(*tmp_name, fp) == EOF) {
+                                       FILE_OP_ERROR("filtering config", "fputs || fputc");
+                                       g_free(filtering_str);
+                                       return;
+                               }
+                       } else if (*tmp_name == '"') {
+                               if (fputc('\\', fp) == EOF ||
+                                   fputc('"', fp) == EOF) {
+                                       FILE_OP_ERROR("filtering config", "fputs || fputc");
+                                       g_free(filtering_str);
+                                       return;
+                               }
+                       }
+                       tmp_name ++;
+               }
+               if (fputs("\" ", fp) == EOF) {
+                       FILE_OP_ERROR("filtering config", "fputs");
+                       g_free(filtering_str);
+                       return;
+               }
+
+               if (prop->account_id != 0) {
+                       gchar *tmp = NULL;
+
+                       tmp = g_strdup_printf("account %d ", prop->account_id);
+                       if (fputs(tmp, fp) == EOF) {
+                               FILE_OP_ERROR("filtering config", "fputs");
+                               g_free(tmp);
+                               return;
+                       }
+                       g_free(tmp);
+               }
+
+               if(fputs(filtering_str, fp) == EOF ||
+                   fputc('\n', fp) == EOF) {
+                       FILE_OP_ERROR("filtering config", "fputs || fputc");
+                       g_free(filtering_str);
+                       return;
+               }
+               g_free(filtering_str);
+       }
+}
+
+/*!
+ *\brief       Write matchers from a folder item
+ *
+ *\param       node Node with folder info
+ *\param       data File pointer
+ *
+ *\return      gboolean FALSE
+ */
+static gboolean prefs_matcher_write_func(GNode *node, gpointer data)
+{
+       FolderItem *item;
+       FILE *fp = data;
+       gchar *id;
+       GSList *prefs_filtering;
+
+        item = node->data;
+        /* prevent warning */
+        if (item->path == NULL)
+                return FALSE;
+        id = folder_item_get_identifier(item);
+        if (id == NULL)
+                return FALSE;
+        prefs_filtering = item->prefs->processing;
+
+       if (prefs_filtering != NULL) {
+               fprintf(fp, "[%s]\n", id);
+               prefs_filtering_write(fp, prefs_filtering);
+               fputc('\n', fp);
+       }
+
+       g_free(id);
+
+       return FALSE;
+}
+
+/*!
+ *\brief       Save matchers from folder items
+ *
+ *\param       fp File
+ */
+static void prefs_matcher_save(FILE *fp)
+{
+       GList *cur;
+
+       for (cur = folder_get_list() ; cur != NULL ; cur = g_list_next(cur)) {
+               Folder *folder;
+
+               folder = (Folder *) cur->data;
+               g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
+                               prefs_matcher_write_func, fp);
+       }
+        
+        /* pre global rules */
+        fprintf(fp, "[preglobal]\n");
+        prefs_filtering_write(fp, pre_global_processing);
+        fputc('\n', fp);
+
+        /* post global rules */
+        fprintf(fp, "[postglobal]\n");
+        prefs_filtering_write(fp, post_global_processing);
+        fputc('\n', fp);
+        
+        /* filtering rules */
+        fprintf(fp, "[filtering]\n");
+        prefs_filtering_write(fp, filtering_rules);
+        fputc('\n', fp);
+}
+
+/*!
+ *\brief       Write filtering / matcher configuration file
+ */
+void prefs_matcher_write_config(void)
+{
+       gchar *rcpath;
+       PrefFile *pfile;
+
+       debug_print("Writing matcher configuration...\n");
+
+       rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+                            MATCHER_RC, NULL);
+
+       if ((pfile = prefs_write_open(rcpath)) == NULL) {
+               g_warning("failed to write configuration to file\n");
+               g_free(rcpath);
+               return;
+       }
+
+
+       prefs_matcher_save(pfile->fp);
+
+       g_free(rcpath);
+
+       if (prefs_file_close(pfile) < 0) {
+               g_warning("failed to write configuration to file\n");
+               return;
+       }
+}
+
+/* ******************************************************************* */
+
+void matcher_add_rulenames(const gchar *rcpath)
+{
+       gchar *newpath = g_strconcat(rcpath, ".new", NULL);
+       FILE *src = g_fopen(rcpath, "rb");
+       FILE *dst = g_fopen(newpath, "wb");
+       gchar buf[BUFFSIZE];
+
+       if (dst == NULL) {
+               perror("fopen");
+               g_free(newpath);
+               return;
+       }
+
+       while (fgets (buf, sizeof(buf), src) != NULL) {
+               if (strlen(buf) > 2 && buf[0] != '['
+               && strncmp(buf, "rulename \"", 10)) {
+                       fwrite("rulename \"\" ",
+                               strlen("rulename \"\" "), 1, dst);
+               }
+               fwrite(buf, strlen(buf), 1, dst);
+       }
+       fclose(dst);
+       fclose(src);
+       move_file(newpath, rcpath, TRUE);
+       g_free(newpath);
+}
+
+/*!
+ *\brief       Read matcher configuration
+ */
+void prefs_matcher_read_config(void)
+{
+       gchar *rcpath;
+       gchar *rc_old_format;
+       FILE *f;
+
+       create_matchparser_hashtab();
+       prefs_filtering_clear();
+
+       rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, MATCHER_RC, NULL);
+       rc_old_format = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, MATCHER_RC, 
+                               ".pre_names", NULL);
+       
+       if (!is_file_exist(rc_old_format) && is_file_exist(rcpath)) {
+               /* backup file with no rules names, in case 
+                * anything goes wrong */
+               copy_file(rcpath, rc_old_format, FALSE);
+               /* now hack the file in order to have it to the new format */
+               matcher_add_rulenames(rcpath);
+       }
+       
+       g_free(rc_old_format);
+
+       f = g_fopen(rcpath, "rb");
+       g_free(rcpath);
+
+       if (f != NULL) {
+               matcher_parser_start_parsing(f);
+               fclose(matcher_parserin);
+       }
+       else {
+               /* previous version compatibility */
+
+               /* printf("reading filtering\n"); */
+               rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+                                    FILTERING_RC, NULL);
+               f = g_fopen(rcpath, "rb");
+               g_free(rcpath);
+               
+               if (f != NULL) {
+                       matcher_parser_start_parsing(f);
+                       fclose(matcher_parserin);
+               }
+               
+               /* printf("reading scoring\n"); */
+               rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+                                    SCORING_RC, NULL);
+               f = g_fopen(rcpath, "rb");
+               g_free(rcpath);
+               
+               if (f != NULL) {
+                       matcher_parser_start_parsing(f);
+                       fclose(matcher_parserin);
+               }
+       }
 }
-*/