src/matcher.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 2002-2004 by the Sylpheed Claws Team and Hiroyuki Yamamoto
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <ctype.h>
  21 #include <string.h>
  22 #include <stdlib.h>
  23 #include <errno.h>
  24 #include "defs.h"
  25 #include "utils.h"
  26 #include "procheader.h"
  27 #include "matcher.h"
  28 #include "intl.h"
  29 #include "matcher_parser.h"
  30 #include "prefs_gtk.h"
  31 #include "addr_compl.h"
  32 #include <ctype.h>
  33
  34 /*!
  35  *\brief        Keyword lookup element
  36  */
  37 struct _MatchParser {
  38         gint id;                /*!< keyword id */
  39         gchar *str;             /*!< keyword */
  40 };
  41 typedef struct _MatchParser MatchParser;
  42
  43 /*!
  44  *\brief        Table with strings and ids used by the lexer and
  45  *              the parser. New keywords can be added here.
  46  */
  47 static const MatchParser matchparser_tab[] = {
  48         /* msginfo flags */
  49         {MATCHCRITERIA_ALL, "all"},
  50         {MATCHCRITERIA_UNREAD, "unread"},
  51         {MATCHCRITERIA_NOT_UNREAD, "~unread"},
  52         {MATCHCRITERIA_NEW, "new"},
  53         {MATCHCRITERIA_NOT_NEW, "~new"},
  54         {MATCHCRITERIA_MARKED, "marked"},
  55         {MATCHCRITERIA_NOT_MARKED, "~marked"},
  56         {MATCHCRITERIA_DELETED, "deleted"},
  57         {MATCHCRITERIA_NOT_DELETED, "~deleted"},
  58         {MATCHCRITERIA_REPLIED, "replied"},
  59         {MATCHCRITERIA_NOT_REPLIED, "~replied"},
  60         {MATCHCRITERIA_FORWARDED, "forwarded"},
  61         {MATCHCRITERIA_NOT_FORWARDED, "~forwarded"},
  62         {MATCHCRITERIA_LOCKED, "locked"},
  63         {MATCHCRITERIA_NOT_LOCKED, "~locked"},
  64         {MATCHCRITERIA_COLORLABEL, "colorlabel"},
  65         {MATCHCRITERIA_NOT_COLORLABEL, "~colorlabel"},
  66         {MATCHCRITERIA_IGNORE_THREAD, "ignore_thread"},
  67         {MATCHCRITERIA_NOT_IGNORE_THREAD, "~ignore_thread"},
  68
  69         /* msginfo headers */
  70         {MATCHCRITERIA_SUBJECT, "subject"},
  71         {MATCHCRITERIA_NOT_SUBJECT, "~subject"},
  72         {MATCHCRITERIA_FROM, "from"},
  73         {MATCHCRITERIA_NOT_FROM, "~from"},
  74         {MATCHCRITERIA_TO, "to"},
  75         {MATCHCRITERIA_NOT_TO, "~to"},
  76         {MATCHCRITERIA_CC, "cc"},
  77         {MATCHCRITERIA_NOT_CC, "~cc"},
  78         {MATCHCRITERIA_TO_OR_CC, "to_or_cc"},
  79         {MATCHCRITERIA_NOT_TO_AND_NOT_CC, "~to_or_cc"},
  80         {MATCHCRITERIA_AGE_GREATER, "age_greater"},
  81         {MATCHCRITERIA_AGE_LOWER, "age_lower"},
  82         {MATCHCRITERIA_NEWSGROUPS, "newsgroups"},
  83         {MATCHCRITERIA_NOT_NEWSGROUPS, "~newsgroups"},
  84         {MATCHCRITERIA_INREPLYTO, "inreplyto"},
  85         {MATCHCRITERIA_NOT_INREPLYTO, "~inreplyto"},
  86         {MATCHCRITERIA_REFERENCES, "references"},
  87         {MATCHCRITERIA_NOT_REFERENCES, "~references"},
  88         {MATCHCRITERIA_SCORE_GREATER, "score_greater"},
  89         {MATCHCRITERIA_SCORE_LOWER, "score_lower"},
  90         {MATCHCRITERIA_SCORE_EQUAL, "score_equal"},
  91         {MATCHCRITERIA_PARTIAL, "partial"},
  92         {MATCHCRITERIA_NOT_PARTIAL, "~partial"},
  93
  94         {MATCHCRITERIA_SIZE_GREATER, "size_greater"},
  95         {MATCHCRITERIA_SIZE_SMALLER, "size_smaller"},
  96         {MATCHCRITERIA_SIZE_EQUAL,   "size_equal"},
  97
  98         /* content have to be read */
  99         {MATCHCRITERIA_HEADER, "header"},
 100         {MATCHCRITERIA_NOT_HEADER, "~header"},
 101         {MATCHCRITERIA_HEADERS_PART, "headers_part"},
 102         {MATCHCRITERIA_NOT_HEADERS_PART, "~headers_part"},
 103         {MATCHCRITERIA_MESSAGE, "message"},
 104         {MATCHCRITERIA_NOT_MESSAGE, "~message"},
 105         {MATCHCRITERIA_BODY_PART, "body_part"},
 106         {MATCHCRITERIA_NOT_BODY_PART, "~body_part"},
 107         {MATCHCRITERIA_TEST, "test"},
 108         {MATCHCRITERIA_NOT_TEST, "~test"},
 109
 110         /* match type */
 111         {MATCHTYPE_MATCHCASE, "matchcase"},
 112         {MATCHTYPE_MATCH, "match"},
 113         {MATCHTYPE_REGEXPCASE, "regexpcase"},
 114         {MATCHTYPE_REGEXP, "regexp"},
 115         {MATCHTYPE_ANY_IN_ADDRESSBOOK, "any_in_addressbook"},
 116         {MATCHTYPE_ALL_IN_ADDRESSBOOK, "all_in_addressbook"},
 117
 118         /* actions */
 119         {MATCHACTION_SCORE, "score"},    /* for backward compatibility */
 120         {MATCHACTION_MOVE, "move"},
 121         {MATCHACTION_COPY, "copy"},
 122         {MATCHACTION_DELETE, "delete"},
 123         {MATCHACTION_MARK, "mark"},
 124         {MATCHACTION_UNMARK, "unmark"},
 125         {MATCHACTION_LOCK, "lock"},
 126         {MATCHACTION_UNLOCK, "unlock"},
 127         {MATCHACTION_MARK_AS_READ, "mark_as_read"},
 128         {MATCHACTION_MARK_AS_UNREAD, "mark_as_unread"},
 129         {MATCHACTION_FORWARD, "forward"},
 130         {MATCHACTION_FORWARD_AS_ATTACHMENT, "forward_as_attachment"},
 131         {MATCHACTION_EXECUTE, "execute"},
 132         {MATCHACTION_COLOR, "color"},
 133         {MATCHACTION_REDIRECT, "redirect"},
 134         {MATCHACTION_CHANGE_SCORE, "change_score"},
 135         {MATCHACTION_SET_SCORE, "set_score"},
 136         {MATCHACTION_STOP, "stop"},
 137         {MATCHACTION_HIDE, "hide"},
 138 };
 139
 140 /*!
 141  *\brief        Look up table with keywords defined in \sa matchparser_tab
 142  */
 143 static GHashTable *matchparser_hashtab;
 144
 145 /*!
 146  *\brief        Translate keyword id to keyword string
 147  *
 148  *\param        id Id of keyword
 149  *
 150  *\return       const gchar * Keyword
 151  */
 152 const gchar *get_matchparser_tab_str(gint id)
 153 {
 154         gint i;
 155
 156         for (i = 0; i < sizeof matchparser_tab / sizeof matchparser_tab[0]; i++) {
 157                 if (matchparser_tab[i].id == id)
 158                         return matchparser_tab[i].str;
 159         }
 160         return NULL;
 161 }
 162
 163 /*!
 164  *\brief        Create keyword lookup table
 165  */
 166 static void create_matchparser_hashtab(void)
 167 {
 168         int i;
 169
 170         if (matchparser_hashtab) return;
 171         matchparser_hashtab = g_hash_table_new(g_str_hash, g_str_equal);
 172         for (i = 0; i < sizeof matchparser_tab / sizeof matchparser_tab[0]; i++)
 173                 g_hash_table_insert(matchparser_hashtab,
 174                                     matchparser_tab[i].str,
 175                                     (gpointer) &matchparser_tab[i]);
 176 }
 177
 178 /*!
 179  *\brief        Return a keyword id from a keyword string
 180  *
 181  *\param        str Keyword string
 182  *
 183  *\return       gint Keyword id
 184  */
 185 gint get_matchparser_tab_id(const gchar *str)
 186 {
 187         MatchParser *res;
 188
 189         if (NULL != (res = g_hash_table_lookup(matchparser_hashtab, str))) {
 190                 return res->id;
 191         } else
 192                 return -1;
 193 }
 194
 195 /* **************** data structure allocation **************** */
 196
 197 /*!
 198  *\brief        Allocate a structure for a filtering / scoring
 199  *              "condition" (a matcher structure)
 200  *
 201  *\param        criteria Criteria ID (MATCHCRITERIA_XXXX)
 202  *\param        header Header string (if criteria is MATCHCRITERIA_HEADER)
 203  *\param        matchtype Type of action (MATCHTYPE_XXX)
 204  *\param        expr String value or expression to check
 205  *\param        value Integer value to check
 206  *
 207  *\return       MatcherProp * Pointer to newly allocated structure
 208  */
 209 MatcherProp *matcherprop_new(gint criteria, const gchar *header,
 210                               gint matchtype, const gchar *expr,
 211                               int value)
 212 {
 213         MatcherProp *prop;
 214
 215         prop = g_new0(MatcherProp, 1);
 216         prop->criteria = criteria;
 217         prop->header = header != NULL ? g_strdup(header) : NULL;
 218         prop->expr = expr != NULL ? g_strdup(expr) : NULL;
 219         prop->matchtype = matchtype;
 220         prop->preg = NULL;
 221         prop->value = value;
 222         prop->error = 0;
 223
 224         return prop;
 225 }
 226
 227 /*!
 228  *\brief        Free a matcher structure
 229  *
 230  *\param        prop Pointer to matcher structure allocated with
 231  *              #matcherprop_new
 232  */
 233 void matcherprop_free(MatcherProp *prop)
 234 {
 235         if (prop->expr)
 236                 g_free(prop->expr);
 237         if (prop->header)
 238                 g_free(prop->header);
 239         if (prop->preg != NULL) {
 240                 regfree(prop->preg);
 241                 g_free(prop->preg);
 242         }
 243         g_free(prop);
 244 }
 245
 246 /*!
 247  *\brief        Copy a matcher structure
 248  *
 249  *\param        src Matcher structure to copy
 250  *
 251  *\return       MatcherProp * Pointer to newly allocated matcher structure
 252  */
 253 MatcherProp *matcherprop_copy(const MatcherProp *src)
 254 {
 255         MatcherProp *prop = g_new0(MatcherProp, 1);
 256
 257         prop->criteria = src->criteria;
 258         prop->header = src->header ? g_strdup(src->header) : NULL;
 259         prop->expr = src->expr ? g_strdup(src->expr) : NULL;
 260         prop->matchtype = src->matchtype;
 261
 262         prop->preg = NULL; /* will be re-evaluated */
 263         prop->value = src->value;
 264         prop->error = src->error;
 265         return prop;
 266 }
 267
 268 /* ************** match ******************************/
 269
 270 static gboolean match_with_addresses_in_addressbook
 271         (MatcherProp *prop, const gchar *str, gint type)
 272 {
 273         GSList *address_list = NULL;
 274         GSList *walk;
 275         gboolean res = FALSE;
 276
 277         if (str == NULL || *str == 0)
 278                 return FALSE;
 279
 280         /* XXX: perhaps complete with comments too */
 281         address_list = address_list_append(address_list, str);
 282         if (!address_list)
 283                 return FALSE;
 284
 285         start_address_completion();
 286         res = FALSE;
 287         for (walk = address_list; walk != NULL; walk = walk->next) {
 288                 gboolean found = complete_address(walk->data) ? TRUE : FALSE;
 289
 290                 g_free(walk->data);
 291                 if (!found && type == MATCHTYPE_ALL_IN_ADDRESSBOOK) {
 292                         res = FALSE;
 293                         break;
 294                 } else if (found)
 295                         res = TRUE;
 296         }
 297
 298         g_slist_free(address_list);
 299
 300         end_address_completion();
 301
 302         return res;
 303 }
 304
 305 /*!
 306  *\brief        Find out if a string matches a condition
 307  *
 308  *\param        prop Matcher structure
 309  *\param        str String to check
 310  *
 311  *\return       gboolean TRUE if str matches the condition in the
 312  *              matcher structure
 313  */
 314 static gboolean matcherprop_string_match(MatcherProp *prop, const gchar *str)
 315 {
 316         gchar *str1;
 317         gchar *str2;
 318
 319         if (str == NULL)
 320                 return FALSE;
 321
 322         switch (prop->matchtype) {
 323         case MATCHTYPE_REGEXPCASE:
 324         case MATCHTYPE_REGEXP:
 325                 if (!prop->preg && (prop->error == 0)) {
 326                         prop->preg = g_new0(regex_t, 1);
 327                         /* if regexp then don't use the escaped string */
 328                         if (regcomp(prop->preg, prop->expr,
 329                                     REG_NOSUB | REG_EXTENDED
 330                                     | ((prop->matchtype == MATCHTYPE_REGEXPCASE)
 331                                     ? REG_ICASE : 0)) != 0) {
 332                                 prop->error = 1;
 333                                 g_free(prop->preg);
 334                                 prop->preg = NULL;
 335                         }
 336                 }
 337                 if (prop->preg == NULL)
 338                         return FALSE;
 339
 340                 if (regexec(prop->preg, str, 0, NULL, 0) == 0)
 341                         return TRUE;
 342                 else
 343                         return FALSE;
 344
 345         case MATCHTYPE_ALL_IN_ADDRESSBOOK:
 346         case MATCHTYPE_ANY_IN_ADDRESSBOOK:
 347                 return match_with_addresses_in_addressbook
 348                         (prop, str, prop->matchtype);
 349
 350         case MATCHTYPE_MATCH:
 351                 return (strstr(str, prop->expr) != NULL);
 352
 353         /* FIXME: put upper in unesc_str */
 354         case MATCHTYPE_MATCHCASE:
 355                 str2 = alloca(strlen(prop->expr) + 1);
 356                 strcpy(str2, prop->expr);
 357                 g_strup(str2);
 358                 str1 = alloca(strlen(str) + 1);
 359                 strcpy(str1, str);
 360                 g_strup(str1);
 361                 return (strstr(str1, str2) != NULL);
 362
 363         default:
 364                 return FALSE;
 365         }
 366 }
 367
 368 /*!
 369  *\brief        Execute a command defined in the matcher structure
 370  *
 371  *\param        prop Pointer to matcher structure
 372  *\param        info Pointer to message info structure
 373  *
 374  *\return       gboolean TRUE if command was executed succesfully
 375  */
 376 static gboolean matcherprop_match_test(const MatcherProp *prop,
 377                                           MsgInfo *info)
 378 {
 379         gchar *file;
 380         gchar *cmd;
 381         gint retval;
 382
 383         file = procmsg_get_message_file(info);
 384         if (file == NULL)
 385                 return FALSE;
 386         g_free(file);
 387
 388         cmd = matching_build_command(prop->expr, info);
 389         if (cmd == NULL)
 390                 return FALSE;
 391
 392         retval = system(cmd);
 393         debug_print("Command exit code: %d\n", retval);
 394
 395         g_free(cmd);
 396         return (retval == 0);
 397 }
 398
 399 /*!
 400  *\brief        Check if a message matches the condition in a matcher
 401  *              structure.
 402  *
 403  *\param        prop Pointer to matcher structure
 404  *\param        info Pointer to message info
 405  *
 406  *\return       gboolean TRUE if a match
 407  */
 408 gboolean matcherprop_match(MatcherProp *prop,
 409                            MsgInfo *info)
 410 {
 411         time_t t;
 412
 413         switch(prop->criteria) {
 414         case MATCHCRITERIA_ALL:
 415                 return 1;
 416         case MATCHCRITERIA_UNREAD:
 417                 return MSG_IS_UNREAD(info->flags);
 418         case MATCHCRITERIA_NOT_UNREAD:
 419                 return !MSG_IS_UNREAD(info->flags);
 420         case MATCHCRITERIA_NEW:
 421                 return MSG_IS_NEW(info->flags);
 422         case MATCHCRITERIA_NOT_NEW:
 423                 return !MSG_IS_NEW(info->flags);
 424         case MATCHCRITERIA_MARKED:
 425                 return MSG_IS_MARKED(info->flags);
 426         case MATCHCRITERIA_NOT_MARKED:
 427                 return !MSG_IS_MARKED(info->flags);
 428         case MATCHCRITERIA_DELETED:
 429                 return MSG_IS_DELETED(info->flags);
 430         case MATCHCRITERIA_NOT_DELETED:
 431                 return !MSG_IS_DELETED(info->flags);
 432         case MATCHCRITERIA_REPLIED:
 433                 return MSG_IS_REPLIED(info->flags);
 434         case MATCHCRITERIA_NOT_REPLIED:
 435                 return !MSG_IS_REPLIED(info->flags);
 436         case MATCHCRITERIA_FORWARDED:
 437                 return MSG_IS_FORWARDED(info->flags);
 438         case MATCHCRITERIA_NOT_FORWARDED:
 439                 return !MSG_IS_FORWARDED(info->flags);
 440         case MATCHCRITERIA_LOCKED:
 441                 return MSG_IS_LOCKED(info->flags);
 442         case MATCHCRITERIA_NOT_LOCKED:
 443                 return !MSG_IS_LOCKED(info->flags);
 444         case MATCHCRITERIA_COLORLABEL:
 445                 return MSG_GET_COLORLABEL_VALUE(info->flags) == prop->value;
 446         case MATCHCRITERIA_NOT_COLORLABEL:
 447                 return MSG_GET_COLORLABEL_VALUE(info->flags) != prop->value;
 448         case MATCHCRITERIA_IGNORE_THREAD:
 449                 return MSG_IS_IGNORE_THREAD(info->flags);
 450         case MATCHCRITERIA_NOT_IGNORE_THREAD:
 451                 return !MSG_IS_IGNORE_THREAD(info->flags);
 452         case MATCHCRITERIA_SUBJECT:
 453                 return matcherprop_string_match(prop, info->subject);
 454         case MATCHCRITERIA_NOT_SUBJECT:
 455                 return !matcherprop_string_match(prop, info->subject);
 456         case MATCHCRITERIA_FROM:
 457                 return matcherprop_string_match(prop, info->from);
 458         case MATCHCRITERIA_NOT_FROM:
 459                 return !matcherprop_string_match(prop, info->from);
 460         case MATCHCRITERIA_TO:
 461                 return matcherprop_string_match(prop, info->to);
 462         case MATCHCRITERIA_NOT_TO:
 463                 return !matcherprop_string_match(prop, info->to);
 464         case MATCHCRITERIA_CC:
 465                 return matcherprop_string_match(prop, info->cc);
 466         case MATCHCRITERIA_NOT_CC:
 467                 return !matcherprop_string_match(prop, info->cc);
 468         case MATCHCRITERIA_TO_OR_CC:
 469                 return matcherprop_string_match(prop, info->to)
 470                         || matcherprop_string_match(prop, info->cc);
 471         case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
 472                 return !(matcherprop_string_match(prop, info->to)
 473                 || matcherprop_string_match(prop, info->cc));
 474         case MATCHCRITERIA_AGE_GREATER:
 475                 t = time(NULL);
 476                 return ((t - info->date_t) / (60 * 60 * 24)) >= prop->value;
 477         case MATCHCRITERIA_AGE_LOWER:
 478                 t = time(NULL);
 479                 return ((t - info->date_t) / (60 * 60 * 24)) <= prop->value;
 480         case MATCHCRITERIA_SCORE_GREATER:
 481                 return info->score >= prop->value;
 482         case MATCHCRITERIA_SCORE_LOWER:
 483                 return info->score <= prop->value;
 484         case MATCHCRITERIA_SCORE_EQUAL:
 485                 return info->score == prop->value;
 486         case MATCHCRITERIA_SIZE_GREATER:
 487                 /* FIXME: info->size is an off_t */
 488                 return info->size > (off_t) prop->value;
 489         case MATCHCRITERIA_SIZE_EQUAL:
 490                 /* FIXME: info->size is an off_t */
 491                 return info->size == (off_t) prop->value;
 492         case MATCHCRITERIA_SIZE_SMALLER:
 493                 /* FIXME: info->size is an off_t */
 494                 return info->size <  (off_t) prop->value;
 495         case MATCHCRITERIA_PARTIAL:
 496                 /* FIXME: info->size is an off_t */
 497                 return (info->total_size != 0 && info->size != (off_t)info->total_size);
 498         case MATCHCRITERIA_NOT_PARTIAL:
 499                 /* FIXME: info->size is an off_t */
 500                 return (info->total_size == 0 || info->size == (off_t)info->total_size);
 501         case MATCHCRITERIA_NEWSGROUPS:
 502                 return matcherprop_string_match(prop, info->newsgroups);
 503         case MATCHCRITERIA_NOT_NEWSGROUPS:
 504                 return !matcherprop_string_match(prop, info->newsgroups);
 505         case MATCHCRITERIA_INREPLYTO:
 506                 return matcherprop_string_match(prop, info->inreplyto);
 507         case MATCHCRITERIA_NOT_INREPLYTO:
 508                 return !matcherprop_string_match(prop, info->inreplyto);
 509         case MATCHCRITERIA_REFERENCES:
 510                 return matcherprop_string_match(prop, info->references);
 511         case MATCHCRITERIA_NOT_REFERENCES:
 512                 return !matcherprop_string_match(prop, info->references);
 513         case MATCHCRITERIA_TEST:
 514                 return matcherprop_match_test(prop, info);
 515         case MATCHCRITERIA_NOT_TEST:
 516                 return !matcherprop_match_test(prop, info);
 517         default:
 518                 return 0;
 519         }
 520 }
 521
 522 /* ********************* MatcherList *************************** */
 523
 524 /*!
 525  *\brief        Create a new list of matchers
 526  *
 527  *\param        matchers List of matcher structures
 528  *\param        bool_and Operator
 529  *
 530  *\return       MatcherList * New list
 531  */
 532 MatcherList *matcherlist_new(GSList *matchers, gboolean bool_and)
 533 {
 534         MatcherList *cond;
 535
 536         cond = g_new0(MatcherList, 1);
 537
 538         cond->matchers = matchers;
 539         cond->bool_and = bool_and;
 540
 541         return cond;
 542 }
 543
 544 /*!
 545  *\brief        Frees a list of matchers
 546  *
 547  *\param        cond List of matchers
 548  */
 549 void matcherlist_free(MatcherList *cond)
 550 {
 551         GSList *l;
 552
 553         g_return_if_fail(cond);
 554         for (l = cond->matchers ; l != NULL ; l = g_slist_next(l)) {
 555                 matcherprop_free((MatcherProp *) l->data);
 556         }
 557         g_free(cond);
 558 }
 559
 560 /*!
 561  *\brief        Skip all headers in a message file
 562  *
 563  *\param        fp Message file
 564  */
 565 static void matcherlist_skip_headers(FILE *fp)
 566 {
 567         gchar buf[BUFFSIZE];
 568
 569         while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1)
 570                 ;
 571 }
 572
 573 /*!
 574  *\brief        Check if a header matches a matcher condition
 575  *
 576  *\param        matcher Matcher structure to check header for
 577  *\param        buf Header name
 578  *
 579  *\return       boolean TRUE if matching header
 580  */
 581 static gboolean matcherprop_match_one_header(MatcherProp *matcher,
 582                                              gchar *buf)
 583 {
 584         gboolean result;
 585         Header *header;
 586
 587         switch (matcher->criteria) {
 588         case MATCHCRITERIA_HEADER:
 589         case MATCHCRITERIA_NOT_HEADER:
 590                 header = procheader_parse_header(buf);
 591                 if (!header)
 592                         return FALSE;
 593                 if (procheader_headername_equal(header->name,
 594                                                 matcher->header)) {
 595                         if (matcher->criteria == MATCHCRITERIA_HEADER)
 596                                 result = matcherprop_string_match(matcher, header->body);
 597                         else
 598                                 result = !matcherprop_string_match(matcher, header->body);
 599                         procheader_header_free(header);
 600                         return result;
 601                 }
 602                 else {
 603                         procheader_header_free(header);
 604                 }
 605                 break;
 606         case MATCHCRITERIA_HEADERS_PART:
 607         case MATCHCRITERIA_MESSAGE:
 608                 return matcherprop_string_match(matcher, buf);
 609         case MATCHCRITERIA_NOT_MESSAGE:
 610         case MATCHCRITERIA_NOT_HEADERS_PART:
 611                 return !matcherprop_string_match(matcher, buf);
 612         }
 613         return FALSE;
 614 }
 615
 616 /*!
 617  *\brief        Check if the matcher structure wants headers to
 618  *              be matched
 619  *
 620  *\param        matcher Matcher structure
 621  *
 622  *\return       gboolean TRUE if the matcher structure describes
 623  *              a header match condition
 624  */
 625 static gboolean matcherprop_criteria_headers(const MatcherProp *matcher)
 626 {
 627         switch (matcher->criteria) {
 628         case MATCHCRITERIA_HEADER:
 629         case MATCHCRITERIA_NOT_HEADER:
 630         case MATCHCRITERIA_HEADERS_PART:
 631         case MATCHCRITERIA_NOT_HEADERS_PART:
 632                 return TRUE;
 633         default:
 634                 return FALSE;
 635         }
 636 }
 637
 638 /*!
 639  *\brief        Check if the matcher structure wants the message
 640  *              to be matched (just perform an action on any
 641  *              message)
 642  *
 643  *\param        matcher Matcher structure
 644  *
 645  *\return       gboolean TRUE if matcher condition should match
 646  *              a message
 647  */
 648 static gboolean matcherprop_criteria_message(MatcherProp *matcher)
 649 {
 650         switch (matcher->criteria) {
 651         case MATCHCRITERIA_MESSAGE:
 652         case MATCHCRITERIA_NOT_MESSAGE:
 653                 return TRUE;
 654         default:
 655                 return FALSE;
 656         }
 657 }
 658
 659 /*!
 660  *\brief        Check if a list of conditions match a header
 661  *
 662  *\param        matchers One set of conditions
 663  *\param        buf Name of header
 664  *
 665  *\return       gboolean TRUE if matching should stop
 666  */
 667 static gboolean matcherlist_match_one_header(MatcherList *matchers,
 668                                              gchar *buf)
 669 {
 670         GSList *l;
 671
 672         for (l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
 673                 MatcherProp *matcher = (MatcherProp *) l->data;
 674
 675                 /* see if a single condition matches */
 676                 if (matcherprop_criteria_headers(matcher) ||
 677                     matcherprop_criteria_message(matcher)) {
 678                         if (matcherprop_match_one_header(matcher, buf)) {
 679                                 matcher->result = TRUE;
 680                         }
 681                 }
 682
 683                 if (matcherprop_criteria_headers(matcher)) {
 684                         if (matcher->result) {
 685                                 if (!matchers->bool_and)
 686                                         return TRUE;
 687                         }
 688                 }
 689         }
 690
 691         return FALSE;
 692 }
 693
 694 /*!
 695  *\brief        Check if a list of conditions matches one header in
 696  *              a message file.
 697  *
 698  *\param        matchers List of conditions
 699  *\param        fp Message file
 700  *
 701  *\return       gboolean TRUE if one of the headers is matched by
 702  *              the list of conditions.
 703  */
 704 static gboolean matcherlist_match_headers(MatcherList *matchers, FILE *fp)
 705 {
 706         gchar buf[BUFFSIZE];
 707
 708         while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1)
 709                 if (matcherlist_match_one_header(matchers, buf))
 710                         return TRUE;
 711
 712         return FALSE;
 713 }
 714
 715 /*!
 716  *\brief        Check if a matcher wants to check the message body
 717  *
 718  *\param        matcher Matcher structure
 719  *
 720  *\return       gboolean TRUE if body must be matched.
 721  */
 722 static gboolean matcherprop_criteria_body(const MatcherProp *matcher)
 723 {
 724         switch (matcher->criteria) {
 725         case MATCHCRITERIA_BODY_PART:
 726         case MATCHCRITERIA_NOT_BODY_PART:
 727                 return TRUE;
 728         default:
 729                 return FALSE;
 730         }
 731 }
 732
 733 /*!
 734  *\brief        Check if a (line) string matches the criteria
 735  *              described by a matcher structure
 736  *
 737  *\param        matcher Matcher structure
 738  *\param        line String
 739  *
 740  *\return       gboolean TRUE if string matches criteria
 741  */
 742 static gboolean matcherprop_match_line(MatcherProp *matcher, const gchar *line)
 743 {
 744         switch (matcher->criteria) {
 745         case MATCHCRITERIA_BODY_PART:
 746         case MATCHCRITERIA_MESSAGE:
 747                 return matcherprop_string_match(matcher, line);
 748         case MATCHCRITERIA_NOT_BODY_PART:
 749         case MATCHCRITERIA_NOT_MESSAGE:
 750                 return !matcherprop_string_match(matcher, line);
 751         }
 752         return FALSE;
 753 }
 754
 755 /*!
 756  *\brief        Check if a list of conditions matches a (line) string
 757  *
 758  *\param        matchers List of matchers
 759  *\param        line String to match
 760  *
 761  *\return       gboolean TRUE if string matches list of criteria
 762  */
 763 static gboolean matcherlist_match_line(MatcherList *matchers, const gchar *line)
 764 {
 765         GSList *l;
 766
 767         for (l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
 768                 MatcherProp *matcher = (MatcherProp *) l->data;
 769
 770                 if (matcherprop_criteria_body(matcher) ||
 771                     matcherprop_criteria_message(matcher)) {
 772                         if (matcherprop_match_line(matcher, line)) {
 773                                 matcher->result = TRUE;
 774                         }
 775                 }
 776
 777                 if (matcher->result) {
 778                         if (!matchers->bool_and)
 779                                 return TRUE;
 780                 }
 781         }
 782         return FALSE;
 783 }
 784
 785 /*!
 786  *\brief        Check if a line in a message file's body matches
 787  *              the criteria
 788  *
 789  *\param        matchers List of conditions
 790  *\param        fp Message file
 791  *
 792  *\return       gboolean TRUE if succesful match
 793  */
 794 static gboolean matcherlist_match_body(MatcherList *matchers, FILE *fp)
 795 {
 796         gchar buf[BUFFSIZE];
 797
 798         while (fgets(buf, sizeof(buf), fp) != NULL)
 799                 if (matcherlist_match_line(matchers, buf))
 800                         return TRUE;
 801
 802         return FALSE;
 803 }
 804
 805 /*!
 806  *\brief        Check if a message file matches criteria
 807  *
 808  *\param        matchers Criteria
 809  *\param        info Message info
 810  *\param        result Default result
 811  *
 812  *\return       gboolean TRUE if matched
 813  */
 814 gboolean matcherlist_match_file(MatcherList *matchers, MsgInfo *info,
 815                                 gboolean result)
 816 {
 817         gboolean read_headers;
 818         gboolean read_body;
 819         GSList *l;
 820         FILE *fp;
 821         gchar *file;
 822
 823         /* file need to be read ? */
 824
 825         read_headers = FALSE;
 826         read_body = FALSE;
 827         for (l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
 828                 MatcherProp *matcher = (MatcherProp *) l->data;
 829
 830                 if (matcherprop_criteria_headers(matcher))
 831                         read_headers = TRUE;
 832                 if (matcherprop_criteria_body(matcher))
 833                         read_body = TRUE;
 834                 if (matcherprop_criteria_message(matcher)) {
 835                         read_headers = TRUE;
 836                         read_body = TRUE;
 837                 }
 838                 matcher->result = FALSE;
 839         }
 840
 841         if (!read_headers && !read_body)
 842                 return result;
 843
 844         file = procmsg_get_message_file(info);
 845         if (file == NULL)
 846                 return FALSE;
 847
 848         if ((fp = fopen(file, "rb")) == NULL) {
 849                 FILE_OP_ERROR(file, "fopen");
 850                 g_free(file);
 851                 return result;
 852         }
 853
 854         /* read the headers */
 855
 856         if (read_headers) {
 857                 if (matcherlist_match_headers(matchers, fp))
 858                         read_body = FALSE;
 859         }
 860         else {
 861                 matcherlist_skip_headers(fp);
 862         }
 863
 864         /* read the body */
 865         if (read_body) {
 866                 matcherlist_match_body(matchers, fp);
 867         }
 868
 869         for (l = matchers->matchers; l != NULL; l = g_slist_next(l)) {
 870                 MatcherProp *matcher = (MatcherProp *) l->data;
 871
 872                 if (matcherprop_criteria_headers(matcher) ||
 873                     matcherprop_criteria_body(matcher)    ||
 874                     matcherprop_criteria_message(matcher)) {
 875                         if (matcher->result) {
 876                                 if (!matchers->bool_and) {
 877                                         result = TRUE;
 878                                         break;
 879                                 }
 880                         }
 881                         else {
 882                                 if (matchers->bool_and) {
 883                                         result = FALSE;
 884                                         break;
 885                                 }
 886                         }
 887                 }
 888         }
 889
 890         g_free(file);
 891
 892         fclose(fp);
 893
 894         return result;
 895 }
 896
 897 /*!
 898  *\brief        Test list of conditions on a message.
 899  *
 900  *\param        matchers List of conditions
 901  *\param        info Message info
 902  *
 903  *\return       gboolean TRUE if matched
 904  */
 905 gboolean matcherlist_match(MatcherList *matchers, MsgInfo *info)
 906 {
 907         GSList *l;
 908         gboolean result;
 909
 910         if (matchers->bool_and)
 911                 result = TRUE;
 912         else
 913                 result = FALSE;
 914
 915         /* test the cached elements */
 916
 917         for (l = matchers->matchers; l != NULL ;l = g_slist_next(l)) {
 918                 MatcherProp *matcher = (MatcherProp *) l->data;
 919
 920                 switch(matcher->criteria) {
 921                 case MATCHCRITERIA_ALL:
 922                 case MATCHCRITERIA_UNREAD:
 923                 case MATCHCRITERIA_NOT_UNREAD:
 924                 case MATCHCRITERIA_NEW:
 925                 case MATCHCRITERIA_NOT_NEW:
 926                 case MATCHCRITERIA_MARKED:
 927                 case MATCHCRITERIA_NOT_MARKED:
 928                 case MATCHCRITERIA_DELETED:
 929                 case MATCHCRITERIA_NOT_DELETED:
 930                 case MATCHCRITERIA_REPLIED:
 931                 case MATCHCRITERIA_NOT_REPLIED:
 932                 case MATCHCRITERIA_FORWARDED:
 933                 case MATCHCRITERIA_NOT_FORWARDED:
 934                 case MATCHCRITERIA_LOCKED:
 935                 case MATCHCRITERIA_NOT_LOCKED:
 936                 case MATCHCRITERIA_COLORLABEL:
 937                 case MATCHCRITERIA_NOT_COLORLABEL:
 938                 case MATCHCRITERIA_IGNORE_THREAD:
 939                 case MATCHCRITERIA_NOT_IGNORE_THREAD:
 940                 case MATCHCRITERIA_SUBJECT:
 941                 case MATCHCRITERIA_NOT_SUBJECT:
 942                 case MATCHCRITERIA_FROM:
 943                 case MATCHCRITERIA_NOT_FROM:
 944                 case MATCHCRITERIA_TO:
 945                 case MATCHCRITERIA_NOT_TO:
 946                 case MATCHCRITERIA_CC:
 947                 case MATCHCRITERIA_NOT_CC:
 948                 case MATCHCRITERIA_TO_OR_CC:
 949                 case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
 950                 case MATCHCRITERIA_AGE_GREATER:
 951                 case MATCHCRITERIA_AGE_LOWER:
 952                 case MATCHCRITERIA_NEWSGROUPS:
 953                 case MATCHCRITERIA_NOT_NEWSGROUPS:
 954                 case MATCHCRITERIA_INREPLYTO:
 955                 case MATCHCRITERIA_NOT_INREPLYTO:
 956                 case MATCHCRITERIA_REFERENCES:
 957                 case MATCHCRITERIA_NOT_REFERENCES:
 958                 case MATCHCRITERIA_SCORE_GREATER:
 959                 case MATCHCRITERIA_SCORE_LOWER:
 960                 case MATCHCRITERIA_SCORE_EQUAL:
 961                 case MATCHCRITERIA_SIZE_GREATER:
 962                 case MATCHCRITERIA_SIZE_SMALLER:
 963                 case MATCHCRITERIA_SIZE_EQUAL:
 964                 case MATCHCRITERIA_TEST:
 965                 case MATCHCRITERIA_NOT_TEST:
 966                 case MATCHCRITERIA_PARTIAL:
 967                 case MATCHCRITERIA_NOT_PARTIAL:
 968                         if (matcherprop_match(matcher, info)) {
 969                                 if (!matchers->bool_and) {
 970                                         return TRUE;
 971                                 }
 972                         }
 973                         else {
 974                                 if (matchers->bool_and) {
 975                                         return FALSE;
 976                                 }
 977                         }
 978                 }
 979         }
 980
 981         /* test the condition on the file */
 982
 983         if (matcherlist_match_file(matchers, info, result)) {
 984                 if (!matchers->bool_and)
 985                         return TRUE;
 986         }
 987         else {
 988                 if (matchers->bool_and)
 989                         return FALSE;
 990         }
 991
 992         return result;
 993 }
 994
 995
 996 static gint quote_filter_str(gchar * result, guint size,
 997                              const gchar * path)
 998 {
 999         const gchar * p;
1000         gchar * result_p;
1001         guint remaining;
1002
1003         result_p = result;
1004         remaining = size;
1005
1006         for(p = path ; * p != '\0' ; p ++) {
1007
1008                 if ((* p != '\"') && (* p != '\\')) {
1009                         if (remaining > 0) {
1010                                 * result_p = * p;
1011                                 result_p ++;
1012                                 remaining --;
1013                         }
1014                         else {
1015                                 result[size - 1] = '\0';
1016                                 return -1;
1017                         }
1018                 }
1019                 else {
1020                         if (remaining >= 2) {
1021                                 * result_p = '\\';
1022                                 result_p ++;
1023                                 * result_p = * p;
1024                                 result_p ++;
1025                                 remaining -= 2;
1026                         }
1027                         else {
1028                                 result[size - 1] = '\0';
1029                                 return -1;
1030                         }
1031                 }
1032         }
1033         if (remaining > 0) {
1034                 * result_p = '\0';
1035         }
1036         else {
1037                 result[size - 1] = '\0';
1038                 return -1;
1039         }
1040
1041         return 0;
1042 }
1043
1044
1045 gchar * matcher_quote_str(const gchar * src)
1046 {
1047         gchar * res;
1048         gint len;
1049
1050         len = strlen(src) * 2 + 1;
1051         res = g_malloc(len);
1052         quote_filter_str(res, len, src);
1053
1054         return res;
1055 }
1056
1057 /*!
1058  *\brief        Convert a matcher structure to a string
1059  *
1060  *\param        matcher Matcher structure
1061  *
1062  *\return       gchar * Newly allocated string
1063  */
1064 gchar *matcherprop_to_string(MatcherProp *matcher)
1065 {
1066         gchar *matcher_str = NULL;
1067         const gchar *criteria_str;
1068         const gchar *matchtype_str;
1069         int i;
1070         gchar * quoted_expr;
1071
1072         criteria_str = NULL;
1073         for (i = 0; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)); i++) {
1074                 if (matchparser_tab[i].id == matcher->criteria)
1075                         criteria_str = matchparser_tab[i].str;
1076         }
1077         if (criteria_str == NULL)
1078                 return NULL;
1079
1080         switch (matcher->criteria) {
1081         case MATCHCRITERIA_AGE_GREATER:
1082         case MATCHCRITERIA_AGE_LOWER:
1083         case MATCHCRITERIA_SCORE_GREATER:
1084         case MATCHCRITERIA_SCORE_LOWER:
1085         case MATCHCRITERIA_SCORE_EQUAL:
1086         case MATCHCRITERIA_SIZE_GREATER:
1087         case MATCHCRITERIA_SIZE_SMALLER:
1088         case MATCHCRITERIA_SIZE_EQUAL:
1089         case MATCHCRITERIA_COLORLABEL:
1090         case MATCHCRITERIA_NOT_COLORLABEL:
1091                 return g_strdup_printf("%s %i", criteria_str, matcher->value);
1092         case MATCHCRITERIA_ALL:
1093         case MATCHCRITERIA_UNREAD:
1094         case MATCHCRITERIA_NOT_UNREAD:
1095         case MATCHCRITERIA_NEW:
1096         case MATCHCRITERIA_NOT_NEW:
1097         case MATCHCRITERIA_MARKED:
1098         case MATCHCRITERIA_NOT_MARKED:
1099         case MATCHCRITERIA_DELETED:
1100         case MATCHCRITERIA_NOT_DELETED:
1101         case MATCHCRITERIA_REPLIED:
1102         case MATCHCRITERIA_NOT_REPLIED:
1103         case MATCHCRITERIA_FORWARDED:
1104         case MATCHCRITERIA_NOT_FORWARDED:
1105         case MATCHCRITERIA_LOCKED:
1106         case MATCHCRITERIA_NOT_LOCKED:
1107         case MATCHCRITERIA_PARTIAL:
1108         case MATCHCRITERIA_NOT_PARTIAL:
1109         case MATCHCRITERIA_IGNORE_THREAD:
1110         case MATCHCRITERIA_NOT_IGNORE_THREAD:
1111                 return g_strdup(criteria_str);
1112         case MATCHCRITERIA_TEST:
1113         case MATCHCRITERIA_NOT_TEST:
1114                 quoted_expr = matcher_quote_str(matcher->expr);
1115                 matcher_str = g_strdup_printf("%s \"%s\"",
1116                                               criteria_str, quoted_expr);
1117                 g_free(quoted_expr);
1118                 return matcher_str;
1119         }
1120
1121         matchtype_str = NULL;
1122         for (i = 0; i < sizeof matchparser_tab / sizeof matchparser_tab[0]; i++) {
1123                 if (matchparser_tab[i].id == matcher->matchtype)
1124                         matchtype_str = matchparser_tab[i].str;
1125         }
1126
1127         if (matchtype_str == NULL)
1128                 return NULL;
1129
1130         switch (matcher->matchtype) {
1131         case MATCHTYPE_MATCH:
1132         case MATCHTYPE_MATCHCASE:
1133         case MATCHTYPE_REGEXP:
1134         case MATCHTYPE_REGEXPCASE:
1135         case MATCHTYPE_ALL_IN_ADDRESSBOOK:
1136         case MATCHTYPE_ANY_IN_ADDRESSBOOK:
1137                 quoted_expr = matcher_quote_str(matcher->expr);
1138                 if (matcher->header) {
1139                         gchar * quoted_header;
1140
1141                         quoted_header = matcher_quote_str(matcher->header);
1142                         matcher_str = g_strdup_printf
1143                                         ("%s \"%s\" %s \"%s\"",
1144                                          criteria_str, quoted_header,
1145                                          matchtype_str, quoted_expr);
1146                         g_free(quoted_header);
1147                 }
1148                 else
1149                         matcher_str = g_strdup_printf
1150                                         ("%s %s \"%s\"", criteria_str,
1151                                          matchtype_str, quoted_expr);
1152                 g_free(quoted_expr);
1153                 break;
1154         }
1155
1156         return matcher_str;
1157 }
1158
1159 /*!
1160  *\brief        Convert a list of conditions to a string
1161  *
1162  *\param        matchers List of conditions
1163  *
1164  *\return       gchar * Newly allocated string
1165  */
1166 gchar *matcherlist_to_string(const MatcherList *matchers)
1167 {
1168         gint count;
1169         gchar **vstr;
1170         GSList *l;
1171         gchar **cur_str;
1172         gchar *result = NULL;
1173
1174         count = g_slist_length(matchers->matchers);
1175         vstr = g_new(gchar *, count + 1);
1176
1177         for (l = matchers->matchers, cur_str = vstr; l != NULL;
1178              l = g_slist_next(l), cur_str ++) {
1179                 *cur_str = matcherprop_to_string((MatcherProp *) l->data);
1180                 if (*cur_str == NULL)
1181                         break;
1182         }
1183         *cur_str = NULL;
1184
1185         if (matchers->bool_and)
1186                 result = g_strjoinv(" & ", vstr);
1187         else
1188                 result = g_strjoinv(" | ", vstr);
1189
1190         for (cur_str = vstr ; *cur_str != NULL ; cur_str ++)
1191                 g_free(*cur_str);
1192         g_free(vstr);
1193
1194         return result;
1195 }
1196
1197
1198 #define STRLEN_ZERO(s) ((s) ? strlen(s) : 0)
1199 #define STRLEN_DEFAULT(s,d) ((s) ? strlen(s) : STRLEN_ZERO(d))
1200
1201 static void add_str_default(gchar ** dest,
1202                             const gchar * s, const gchar * d)
1203 {
1204         gchar quoted_str[4096];
1205         const gchar * str;
1206
1207         if (s != NULL)
1208                 str = s;
1209         else
1210                 str = d;
1211
1212         quote_cmd_argument(quoted_str, sizeof(quoted_str), str);
1213         strcpy(* dest, quoted_str);
1214
1215         (* dest) += strlen(* dest);
1216 }
1217
1218 /* matching_build_command() - preferably cmd should be unescaped */
1219 /*!
1220  *\brief        Build the command line to execute
1221  *
1222  *\param        cmd String with command line specifiers
1223  *\param        info Message info to use for command
1224  *
1225  *\return       gchar * Newly allocated string
1226  */
1227 gchar *matching_build_command(const gchar *cmd, MsgInfo *info)
1228 {
1229         const gchar *s = cmd;
1230         gchar *filename = NULL;
1231         gchar *processed_cmd;
1232         gchar *p;
1233         gint size;
1234
1235         const gchar *const no_subject    = _("(none)") ;
1236         const gchar *const no_from       = _("(none)") ;
1237         const gchar *const no_to         = _("(none)") ;
1238         const gchar *const no_cc         = _("(none)") ;
1239         const gchar *const no_date       = _("(none)") ;
1240         const gchar *const no_msgid      = _("(none)") ;
1241         const gchar *const no_newsgroups = _("(none)") ;
1242         const gchar *const no_references = _("(none)") ;
1243
1244         size = STRLEN_ZERO(cmd) + 1;
1245         while (*s != '\0') {
1246                 if (*s == '%') {
1247                         s++;
1248                         switch (*s) {
1249                         case '%':
1250                                 size -= 1;
1251                                 break;
1252                         case 's': /* subject */
1253                                 size += STRLEN_DEFAULT(info->subject, no_subject) - 2;
1254                                 break;
1255                         case 'f': /* from */
1256                                 size += STRLEN_DEFAULT(info->from, no_from) - 2;
1257                                 break;
1258                         case 't': /* to */
1259                                 size += STRLEN_DEFAULT(info->to, no_to) - 2;
1260                                 break;
1261                         case 'c': /* cc */
1262                                 size += STRLEN_DEFAULT(info->cc, no_cc) - 2;
1263                                 break;
1264                         case 'd': /* date */
1265                                 size += STRLEN_DEFAULT(info->date, no_date) - 2;
1266                                 break;
1267                         case 'i': /* message-id */
1268                                 size += STRLEN_DEFAULT(info->msgid, no_msgid) - 2;
1269                                 break;
1270                         case 'n': /* newsgroups */
1271                                 size += STRLEN_DEFAULT(info->newsgroups, no_newsgroups) - 2;
1272                                 break;
1273                         case 'r': /* references */
1274                                 size += STRLEN_DEFAULT(info->references, no_references) - 2;
1275                                 break;
1276                         case 'F': /* file */
1277                                 if (filename == NULL)
1278                                         filename = folder_item_fetch_msg(info->folder, info->msgnum);
1279
1280                                 if (filename == NULL) {
1281                                         g_warning("filename is not set");
1282                                         return NULL;
1283                                 }
1284                                 else {
1285                                         size += strlen(filename) - 2;
1286                                 }
1287                                 break;
1288                         }
1289                         s++;
1290                 }
1291                 else s++;
1292         }
1293
1294         /* as the string can be quoted, we double the result */
1295         size *= 2;
1296
1297         processed_cmd = g_new0(gchar, size);
1298         s = cmd;
1299         p = processed_cmd;
1300
1301         while (*s != '\0') {
1302                 if (*s == '%') {
1303                         s++;
1304                         switch (*s) {
1305                         case '%':
1306                                 *p = '%';
1307                                 p++;
1308                                 break;
1309                         case 's': /* subject */
1310                                 add_str_default(&p, info->subject,
1311                                                 no_subject);
1312                                 break;
1313                         case 'f': /* from */
1314                                 add_str_default(&p, info->from,
1315                                                 no_from);
1316                                 break;
1317                         case 't': /* to */
1318                                 add_str_default(&p, info->to,
1319                                                 no_to);
1320                                 break;
1321                         case 'c': /* cc */
1322                                 add_str_default(&p, info->cc,
1323                                                 no_cc);
1324                                 break;
1325                         case 'd': /* date */
1326                                 add_str_default(&p, info->date,
1327                                                 no_date);
1328                                 break;
1329                         case 'i': /* message-id */
1330                                 add_str_default(&p, info->msgid,
1331                                                 no_msgid);
1332                                 break;
1333                         case 'n': /* newsgroups */
1334                                 add_str_default(&p, info->newsgroups,
1335                                                 no_newsgroups);
1336                                 break;
1337                         case 'r': /* references */
1338                                 add_str_default(&p, info->references,
1339                                                 no_references);
1340                                 break;
1341                         case 'F': /* file */
1342                                 if (filename != NULL)
1343                                         add_str_default(&p, filename, NULL);
1344                                 break;
1345                         default:
1346                                 *p = '%';
1347                                 p++;
1348                                 *p = *s;
1349                                 p++;
1350                                 break;
1351                         }
1352                         s++;
1353                 }
1354                 else {
1355                         *p = *s;
1356                         p++;
1357                         s++;
1358                 }
1359         }
1360         g_free(filename);
1361
1362         return processed_cmd;
1363 }
1364 #undef STRLEN_DEFAULT
1365 #undef STRLEN_ZERO
1366
1367 /* ************************************************************ */
1368
1369
1370 /*!
1371  *\brief        Write filtering list to file
1372  *
1373  *\param        fp File
1374  *\param        prefs_filtering List of filtering conditions
1375  */
1376 static void prefs_filtering_write(FILE *fp, GSList *prefs_filtering)
1377 {
1378         GSList *cur;
1379
1380         for (cur = prefs_filtering; cur != NULL; cur = cur->next) {
1381                 gchar *filtering_str;
1382                 FilteringProp *prop;
1383
1384                 if (NULL == (prop = (FilteringProp *) cur->data))
1385                         continue;
1386
1387                 if (NULL == (filtering_str = filteringprop_to_string(prop)))
1388                         continue;
1389
1390                 if (fputs(filtering_str, fp) == EOF ||
1391                     fputc('\n', fp) == EOF) {
1392                         FILE_OP_ERROR("filtering config", "fputs || fputc");
1393                         g_free(filtering_str);
1394                         return;
1395                 }
1396                 g_free(filtering_str);
1397         }
1398 }
1399
1400 /*!
1401  *\brief        Write matchers from a folder item
1402  *
1403  *\param        node Node with folder info
1404  *\param        data File pointer
1405  *
1406  *\return       gboolean FALSE
1407  */
1408 static gboolean prefs_matcher_write_func(GNode *node, gpointer data)
1409 {
1410         FolderItem *item;
1411         FILE *fp = data;
1412         gchar *id;
1413         GSList *prefs_filtering;
1414
1415         item = node->data;
1416         /* prevent warning */
1417         if (item->path == NULL)
1418                 return FALSE;
1419         id = folder_item_get_identifier(item);
1420         if (id == NULL)
1421                 return FALSE;
1422         prefs_filtering = item->prefs->processing;
1423
1424         if (prefs_filtering != NULL) {
1425                 fprintf(fp, "[%s]\n", id);
1426                 prefs_filtering_write(fp, prefs_filtering);
1427                 fputc('\n', fp);
1428         }
1429
1430         g_free(id);
1431
1432         return FALSE;
1433 }
1434
1435 /*!
1436  *\brief        Save matchers from folder items
1437  *
1438  *\param        fp File
1439  */
1440 static void prefs_matcher_save(FILE *fp)
1441 {
1442         GList *cur;
1443
1444         for (cur = folder_get_list() ; cur != NULL ; cur = g_list_next(cur)) {
1445                 Folder *folder;
1446
1447                 folder = (Folder *) cur->data;
1448                 g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1449                                 prefs_matcher_write_func, fp);
1450         }
1451
1452         /* pre global rules */
1453         fprintf(fp, "[preglobal]\n");
1454         prefs_filtering_write(fp, pre_global_processing);
1455         fputc('\n', fp);
1456
1457         /* post global rules */
1458         fprintf(fp, "[postglobal]\n");
1459         prefs_filtering_write(fp, post_global_processing);
1460         fputc('\n', fp);
1461
1462         /* filtering rules */
1463         fprintf(fp, "[filtering]\n");
1464         prefs_filtering_write(fp, filtering_rules);
1465         fputc('\n', fp);
1466 }
1467
1468 /*!
1469  *\brief        Write filtering / matcher configuration file
1470  */
1471 void prefs_matcher_write_config(void)
1472 {
1473         gchar *rcpath;
1474         PrefFile *pfile;
1475
1476         debug_print("Writing matcher configuration...\n");
1477
1478         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1479                              MATCHER_RC, NULL);
1480
1481         if ((pfile = prefs_write_open(rcpath)) == NULL) {
1482                 g_warning("failed to write configuration to file\n");
1483                 g_free(rcpath);
1484                 return;
1485         }
1486
1487
1488         prefs_matcher_save(pfile->fp);
1489
1490         g_free(rcpath);
1491
1492         if (prefs_file_close(pfile) < 0) {
1493                 g_warning("failed to write configuration to file\n");
1494                 return;
1495         }
1496 }
1497
1498 /* ******************************************************************* */
1499
1500 /*!
1501  *\brief        Read matcher configuration
1502  */
1503 void prefs_matcher_read_config(void)
1504 {
1505         gchar *rcpath;
1506         FILE *f;
1507
1508         create_matchparser_hashtab();
1509         prefs_filtering_clear();
1510
1511         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, MATCHER_RC, NULL);
1512         f = fopen(rcpath, "rb");
1513         g_free(rcpath);
1514
1515         if (f != NULL) {
1516                 matcher_parser_start_parsing(f);
1517                 fclose(matcher_parserin);
1518         }
1519         else {
1520                 /* previous version compatibily */
1521
1522                 /* printf("reading filtering\n"); */
1523                 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1524                                      FILTERING_RC, NULL);
1525                 f = fopen(rcpath, "rb");
1526                 g_free(rcpath);
1527
1528                 if (f != NULL) {
1529                         matcher_parser_start_parsing(f);
1530                         fclose(matcher_parserin);
1531                 }
1532
1533                 /* printf("reading scoring\n"); */
1534                 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1535                                      SCORING_RC, NULL);
1536                 f = fopen(rcpath, "rb");
1537                 g_free(rcpath);
1538
1539                 if (f != NULL) {
1540                         matcher_parser_start_parsing(f);
1541                         fclose(matcher_parserin);
1542                 }
1543         }
1544 }