plug another memleak reported by Martin Kluge
[claws.git] / src / matcher.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 2002 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.h"
31
32 struct _MatchParser {
33         gint id;
34         gchar * str;
35 };
36
37 typedef struct _MatchParser MatchParser;
38
39 static MatchParser matchparser_tab[] = {
40         /* msginfo flags */
41         {MATCHCRITERIA_ALL, "all"},
42         {MATCHCRITERIA_UNREAD, "unread"},
43         {MATCHCRITERIA_NOT_UNREAD, "~unread"},
44         {MATCHCRITERIA_NEW, "new"},
45         {MATCHCRITERIA_NOT_NEW, "~new"},
46         {MATCHCRITERIA_MARKED, "marked"},
47         {MATCHCRITERIA_NOT_MARKED, "~marked"},
48         {MATCHCRITERIA_DELETED, "deleted"},
49         {MATCHCRITERIA_NOT_DELETED, "~deleted"},
50         {MATCHCRITERIA_REPLIED, "replied"},
51         {MATCHCRITERIA_NOT_REPLIED, "~replied"},
52         {MATCHCRITERIA_FORWARDED, "forwarded"},
53         {MATCHCRITERIA_NOT_FORWARDED, "~forwarded"},
54
55         /* msginfo headers */
56         {MATCHCRITERIA_SUBJECT, "subject"},
57         {MATCHCRITERIA_NOT_SUBJECT, "~subject"},
58         {MATCHCRITERIA_FROM, "from"},
59         {MATCHCRITERIA_NOT_FROM, "~from"},
60         {MATCHCRITERIA_TO, "to"},
61         {MATCHCRITERIA_NOT_TO, "~to"},
62         {MATCHCRITERIA_CC, "cc"},
63         {MATCHCRITERIA_NOT_CC, "~cc"},
64         {MATCHCRITERIA_TO_OR_CC, "to_or_cc"},
65         {MATCHCRITERIA_NOT_TO_AND_NOT_CC, "~to_or_cc"},
66         {MATCHCRITERIA_AGE_GREATER, "age_greater"},
67         {MATCHCRITERIA_AGE_LOWER, "age_lower"},
68         {MATCHCRITERIA_NEWSGROUPS, "newsgroups"},
69         {MATCHCRITERIA_NOT_NEWSGROUPS, "~newsgroups"},
70         {MATCHCRITERIA_INREPLYTO, "inreplyto"},
71         {MATCHCRITERIA_NOT_INREPLYTO, "~inreplyto"},
72         {MATCHCRITERIA_REFERENCES, "references"},
73         {MATCHCRITERIA_NOT_REFERENCES, "~references"},
74         {MATCHCRITERIA_SCORE_GREATER, "score_greater"},
75         {MATCHCRITERIA_SCORE_LOWER, "score_lower"},
76         {MATCHCRITERIA_SCORE_EQUAL, "score_equal"},
77
78         {MATCHCRITERIA_SIZE_GREATER, "size_greater"},
79         {MATCHCRITERIA_SIZE_SMALLER, "size_smaller"},
80         {MATCHCRITERIA_SIZE_EQUAL,   "size_equal"},
81
82         /* content have to be read */
83         {MATCHCRITERIA_HEADER, "header"},
84         {MATCHCRITERIA_NOT_HEADER, "~header"},
85         {MATCHCRITERIA_HEADERS_PART, "headers_part"},
86         {MATCHCRITERIA_NOT_HEADERS_PART, "~headers_part"},
87         {MATCHCRITERIA_MESSAGE, "message"},
88         {MATCHCRITERIA_NOT_MESSAGE, "~message"},
89         {MATCHCRITERIA_BODY_PART, "body_part"},
90         {MATCHCRITERIA_NOT_BODY_PART, "~body_part"},
91         {MATCHCRITERIA_EXECUTE, "execute"},
92         {MATCHCRITERIA_NOT_EXECUTE, "~execute"},
93
94         /* match type */
95         {MATCHTYPE_MATCHCASE, "matchcase"},
96         {MATCHTYPE_MATCH, "match"},
97         {MATCHTYPE_REGEXPCASE, "regexpcase"},
98         {MATCHTYPE_REGEXP, "regexp"},
99
100         /* actions */
101         {MATCHACTION_SCORE, "score"},
102         {MATCHACTION_MOVE, "move"},
103         {MATCHACTION_COPY, "copy"},
104         {MATCHACTION_DELETE, "delete"},
105         {MATCHACTION_MARK, "mark"},
106         {MATCHACTION_UNMARK, "unmark"},
107         {MATCHACTION_MARK_AS_READ, "mark_as_read"},
108         {MATCHACTION_MARK_AS_UNREAD, "mark_as_unread"},
109         {MATCHACTION_FORWARD, "forward"},
110         {MATCHACTION_FORWARD_AS_ATTACHMENT, "forward_as_attachment"},
111         {MATCHACTION_EXECUTE, "execute"},
112         {MATCHACTION_COLOR, "color"},
113         {MATCHACTION_REDIRECT, "redirect"},
114         {MATCHACTION_DELETE_ON_SERVER, "delete_on_server"}
115 };
116
117 /* get_matchparser_tab_str() - used by filtering.c to translate 
118  * actions to debug strings */
119 gchar * get_matchparser_tab_str(gint id)
120 {
121         gint i;
122
123         for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
124             i++) {
125                 if (matchparser_tab[i].id == id)
126                         return matchparser_tab[i].str;
127         }
128         return NULL;
129 }
130
131 /* matcher_escape_str() - escapes a string returns newly allocated escaped string */
132 gchar *matcher_escape_str(const gchar *str)
133 {
134         register const gchar *walk;
135         register int escape;
136         gchar *res;
137         register char *reswalk;
138
139         if (str == NULL)
140                 return NULL;
141
142         for (escape = 0, walk = str; *walk; walk++)
143                 if (*walk == '\'' || *walk == '\"')
144                         escape++;
145
146         if (!escape)
147                 return g_strdup(str);
148         
149         reswalk = res = g_new0(gchar, (walk - str) + escape + 1);
150         for (walk = str; *walk; walk++, reswalk++) {
151                 if (*walk == '\'' || *walk == '\"')
152                         *reswalk++ = '\\';
153                 *reswalk = *walk;
154         }
155
156         *reswalk = 0;
157         return res;
158 }
159
160 /* matcher_unescape_str() - assumes that unescaping frees up room
161  * in the string, so it returns the unescaped string in the 
162  * source */
163 gchar *matcher_unescape_str(gchar *str)
164 {
165         gchar *tmp = alloca(strlen(str) + 1);
166         register gchar *src = tmp;
167         register gchar *dst = str;
168         
169         strcpy(tmp, str);
170
171         for ( ; *src; src++) {
172                 if (*src != '\\') 
173                         *dst++ = *src;
174                 else {
175                         src++;
176                         if (*src == '\\')
177                                 *dst++ = '\\';                          /* insert backslash */
178                         else if (*src == 'n')                           /* insert control characters */
179                                 *dst++ = '\n';
180                         else if (*src == 'r') 
181                                 *dst++ = '\r';
182                         else if (*src == 't') 
183                                 *dst++ = '\t';
184                         else if (*src == 'r') 
185                                 *dst++ = '\r';
186                         else if (*src == 'b')
187                                 *dst++ = '\b';
188                         else if (*src == 'f')
189                                 *dst++ = '\f';
190                         else if (*src == '\'' || *src == '\"')          /* insert \' or \" */
191                                 *dst++ = *src;
192                         else {
193                                 /* FIXME: should perhaps escape character... */
194                                 src--;
195                                 *dst++ = *src;
196                         }                               
197                 }
198         }
199         *dst = 0;
200         return str;
201 }
202
203 /* **************** data structure allocation **************** */
204
205 /* matcherprop_new() - allocates a structure for one condition
206  */
207 MatcherProp * matcherprop_new(gint criteria, gchar * header,
208                               gint matchtype, gchar * expr,
209                               int value)
210 {
211         MatcherProp * prop;
212
213         prop = g_new0(MatcherProp, 1);
214         prop->criteria = criteria;
215         if (header != NULL) {
216                 prop->header       = g_strdup(header);
217                 prop->unesc_header = matcher_unescape_str(g_strdup(header)); 
218         }       
219         else {
220                 prop->header       = NULL;
221                 prop->unesc_header = NULL;
222         }       
223         if (expr != NULL) {
224                 prop->expr       = g_strdup(expr);
225                 prop->unesc_expr = matcher_unescape_str(g_strdup(expr));
226         }       
227         else {
228                 prop->expr       = NULL;
229                 prop->unesc_expr = NULL;
230         }       
231         prop->matchtype = matchtype;
232         prop->preg = NULL;
233         prop->value = value;
234         prop->error = 0;
235
236         return prop;
237 }
238
239 /* matcherprop_free()
240  */
241 void matcherprop_free(MatcherProp * prop)
242 {
243         if (prop->expr) 
244                 g_free(prop->expr);
245         if (prop->unesc_expr) 
246                 g_free(prop->unesc_expr);
247         if (prop->header)
248                 g_free(prop->header);
249         if (prop->unesc_header) 
250                 g_free(prop->unesc_header);
251         if (prop->preg != NULL) {
252                 regfree(prop->preg);
253                 g_free(prop->preg);
254         }
255         g_free(prop);
256 }
257
258
259 /* ************** match ******************************/
260
261
262 /* matcherprop_string_match() - finds out if a string matches
263  * with a criterium */
264 static gboolean matcherprop_string_match(MatcherProp * prop, gchar * str)
265 {
266         gchar * str1;
267         gchar * str2;
268
269         if (str == NULL)
270                 return FALSE;
271
272         switch(prop->matchtype) {
273         case MATCHTYPE_REGEXPCASE:
274         case MATCHTYPE_REGEXP:
275                 if (!prop->preg && (prop->error == 0)) {
276                         prop->preg = g_new0(regex_t, 1);
277                         /* if regexp then don't use the escaped string */
278                         if (regcomp(prop->preg, prop->expr,
279                                     REG_NOSUB | REG_EXTENDED
280                                     | ((prop->matchtype == MATCHTYPE_REGEXPCASE)
281                                     ? REG_ICASE : 0)) != 0) {
282                                 prop->error = 1;
283                                 g_free(prop->preg);
284                                 prop->preg = NULL;
285                         }
286                 }
287                 if (prop->preg == NULL)
288                         return FALSE;
289                 
290                 if (regexec(prop->preg, str, 0, NULL, 0) == 0)
291                         return TRUE;
292                 else
293                         return FALSE;
294
295         case MATCHTYPE_MATCH:
296                 return (strstr(str, prop->unesc_expr) != NULL);
297
298         /* FIXME: put upper in unesc_str */
299         case MATCHTYPE_MATCHCASE:
300                 str2 = alloca(strlen(prop->unesc_expr) + 1);
301                 strcpy(str2, prop->unesc_expr);
302                 g_strup(str2);
303                 str1 = alloca(strlen(str) + 1);
304                 strcpy(str1, str);
305                 g_strup(str1);
306                 return (strstr(str1, str2) != NULL);
307                 
308         default:
309                 return FALSE;
310         }
311 }
312
313 gboolean matcherprop_match_execute(MatcherProp * prop, MsgInfo * info)
314 {
315         gchar * file;
316         gchar * cmd;
317         gint retval;
318
319         file = procmsg_get_message_file(info);
320         if (file == NULL)
321                 return FALSE;
322
323         cmd = matching_build_command(prop->unesc_expr, info);
324         if (cmd == NULL)
325                 return FALSE;
326
327         retval = system(cmd);
328         debug_print("Command exit code: %d\n", retval);
329
330         return (retval == 0);
331 }
332
333 /* match a message and his headers, hlist can be NULL if you don't
334    want to use headers */
335
336 gboolean matcherprop_match(MatcherProp * prop, MsgInfo * info)
337 {
338         time_t t;
339
340         switch(prop->criteria) {
341         case MATCHCRITERIA_ALL:
342                 return 1;
343         case MATCHCRITERIA_UNREAD:
344                 return MSG_IS_UNREAD(info->flags);
345         case MATCHCRITERIA_NOT_UNREAD:
346                 return !MSG_IS_UNREAD(info->flags);
347         case MATCHCRITERIA_NEW:
348                 return MSG_IS_NEW(info->flags);
349         case MATCHCRITERIA_NOT_NEW:
350                 return !MSG_IS_NEW(info->flags);
351         case MATCHCRITERIA_MARKED:
352                 return MSG_IS_MARKED(info->flags);
353         case MATCHCRITERIA_NOT_MARKED:
354                 return !MSG_IS_MARKED(info->flags);
355         case MATCHCRITERIA_DELETED:
356                 return MSG_IS_DELETED(info->flags);
357         case MATCHCRITERIA_NOT_DELETED:
358                 return !MSG_IS_DELETED(info->flags);
359         case MATCHCRITERIA_REPLIED:
360                 return MSG_IS_REPLIED(info->flags);
361         case MATCHCRITERIA_NOT_REPLIED:
362                 return !MSG_IS_REPLIED(info->flags);
363         case MATCHCRITERIA_FORWARDED:
364                 return MSG_IS_FORWARDED(info->flags);
365         case MATCHCRITERIA_NOT_FORWARDED:
366                 return !MSG_IS_FORWARDED(info->flags);
367         case MATCHCRITERIA_SUBJECT:
368                 return matcherprop_string_match(prop, info->subject);
369         case MATCHCRITERIA_NOT_SUBJECT:
370                 return !matcherprop_string_match(prop, info->subject);
371         case MATCHCRITERIA_FROM:
372                 return matcherprop_string_match(prop, info->from);
373         case MATCHCRITERIA_NOT_FROM:
374                 return !matcherprop_string_match(prop, info->from);
375         case MATCHCRITERIA_TO:
376                 return matcherprop_string_match(prop, info->to);
377         case MATCHCRITERIA_NOT_TO:
378                 return !matcherprop_string_match(prop, info->to);
379         case MATCHCRITERIA_CC:
380                 return matcherprop_string_match(prop, info->cc);
381         case MATCHCRITERIA_NOT_CC:
382                 return !matcherprop_string_match(prop, info->cc);
383         case MATCHCRITERIA_TO_OR_CC:
384                 return matcherprop_string_match(prop, info->to)
385                         || matcherprop_string_match(prop, info->cc);
386         case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
387                 return !(matcherprop_string_match(prop, info->to)
388                 || matcherprop_string_match(prop, info->cc));
389         case MATCHCRITERIA_AGE_GREATER:
390                 t = time(NULL);
391                 return ((t - info->date_t) / (60 * 60 * 24)) >= prop->value;
392         case MATCHCRITERIA_AGE_LOWER:
393                 t = time(NULL);
394                 return ((t - info->date_t) / (60 * 60 * 24)) <= prop->value;
395         case MATCHCRITERIA_SCORE_GREATER:
396                 return info->score >= prop->value;
397         case MATCHCRITERIA_SCORE_LOWER:
398                 return info->score <= prop->value;
399         case MATCHCRITERIA_SCORE_EQUAL:
400                 return info->score == prop->value;
401         case MATCHCRITERIA_SIZE_GREATER:
402                 /* FIXME: info->size is an off_t */
403                 return info->size > (off_t) prop->value;
404         case MATCHCRITERIA_SIZE_EQUAL:
405                 /* FIXME: info->size is an off_t */
406                 return info->size == (off_t) prop->value;
407         case MATCHCRITERIA_SIZE_SMALLER:
408                 /* FIXME: info->size is an off_t */
409                 return info->size <  (off_t) prop->value;
410         case MATCHCRITERIA_NEWSGROUPS:
411                 return matcherprop_string_match(prop, info->newsgroups);
412         case MATCHCRITERIA_NOT_NEWSGROUPS:
413                 return !matcherprop_string_match(prop, info->newsgroups);
414         case MATCHCRITERIA_INREPLYTO:
415                 return matcherprop_string_match(prop, info->inreplyto);
416         case MATCHCRITERIA_NOT_INREPLYTO:
417                 return !matcherprop_string_match(prop, info->inreplyto);
418         case MATCHCRITERIA_REFERENCES:
419                 return matcherprop_string_match(prop, info->references);
420         case MATCHCRITERIA_NOT_REFERENCES:
421                 return !matcherprop_string_match(prop, info->references);
422         case MATCHCRITERIA_EXECUTE:
423                 return matcherprop_match_execute(prop, info);
424         case MATCHCRITERIA_NOT_EXECUTE:
425                 return !matcherprop_match_execute(prop, info);
426         default:
427                 return 0;
428         }
429 }
430
431 /* ********************* MatcherList *************************** */
432
433
434 MatcherList * matcherlist_new(GSList * matchers, gboolean bool_and)
435 {
436         MatcherList * cond;
437
438         cond = g_new0(MatcherList, 1);
439
440         cond->matchers = matchers;
441         cond->bool_and = bool_and;
442
443         return cond;
444 }
445
446 void matcherlist_free(MatcherList * cond)
447 {
448         GSList * l;
449
450         for(l = cond->matchers ; l != NULL ; l = g_slist_next(l)) {
451                 matcherprop_free((MatcherProp *) l->data);
452         }
453         g_free(cond);
454 }
455
456 /*
457   skip the headers
458  */
459
460 static void matcherlist_skip_headers(FILE *fp)
461 {
462         gchar buf[BUFFSIZE];
463
464         while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1) {
465         }
466 }
467
468 /*
469   matcherprop_match_one_header
470   returns TRUE if buf matchs the MatchersProp criteria
471  */
472
473 static gboolean matcherprop_match_one_header(MatcherProp * matcher,
474                                              gchar * buf)
475 {
476         gboolean result;
477         Header *header;
478
479         switch(matcher->criteria) {
480         case MATCHCRITERIA_HEADER:
481         case MATCHCRITERIA_NOT_HEADER:
482                 header = procheader_parse_header(buf);
483                 if (!header)
484                         return FALSE;
485                 if (procheader_headername_equal(header->name,
486                                                 matcher->header)) {
487                         if (matcher->criteria == MATCHCRITERIA_HEADER)
488                                 result = matcherprop_string_match(matcher, header->body);
489                         else
490                                 result = !matcherprop_string_match(matcher, header->body);
491                         procheader_header_free(header);
492                         return result;
493                 }
494                 else {
495                         procheader_header_free(header);
496                 }
497                 break;
498         case MATCHCRITERIA_HEADERS_PART:
499         case MATCHCRITERIA_MESSAGE:
500                 return matcherprop_string_match(matcher, buf);
501         case MATCHCRITERIA_NOT_MESSAGE:
502         case MATCHCRITERIA_NOT_HEADERS_PART:
503                 return !matcherprop_string_match(matcher, buf);
504         }
505         return FALSE;
506 }
507
508 /*
509   matcherprop_criteria_header
510   returns TRUE if the headers must be matched
511  */
512
513 static gboolean matcherprop_criteria_headers(MatcherProp * matcher)
514 {
515         switch(matcher->criteria) {
516         case MATCHCRITERIA_HEADER:
517         case MATCHCRITERIA_NOT_HEADER:
518         case MATCHCRITERIA_HEADERS_PART:
519         case MATCHCRITERIA_NOT_HEADERS_PART:
520                 return TRUE;
521         default:
522                 return FALSE;
523         }
524 }
525
526 static gboolean matcherprop_criteria_message(MatcherProp * matcher)
527 {
528         switch(matcher->criteria) {
529         case MATCHCRITERIA_MESSAGE:
530         case MATCHCRITERIA_NOT_MESSAGE:
531                 return TRUE;
532         default:
533                 return FALSE;
534         }
535 }
536
537 /*
538   matcherlist_match_one_header
539   returns TRUE if match should stop
540  */
541
542 static gboolean matcherlist_match_one_header(MatcherList * matchers,
543                                          gchar * buf)
544 {
545         GSList * l;
546
547         for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
548                 MatcherProp * matcher = (MatcherProp *) l->data;
549
550                 if (matcherprop_criteria_headers(matcher) ||
551                     matcherprop_criteria_message(matcher)) {
552                         if (matcherprop_match_one_header(matcher, buf)) {
553                                 matcher->result = TRUE;
554                         }
555                 }
556
557                 if (matcherprop_criteria_headers(matcher)) {
558                         if (matcher->result) {
559                                 if (!matchers->bool_and)
560                                         return TRUE;
561                         }
562                 }
563         }
564
565         return FALSE;
566 }
567
568 /*
569   matcherlist_match_headers
570   returns TRUE if one of the headers matchs the MatcherList criteria
571  */
572
573 static gboolean matcherlist_match_headers(MatcherList * matchers, FILE * fp)
574 {
575         gchar buf[BUFFSIZE];
576
577         while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1)
578                 if (matcherlist_match_one_header(matchers, buf))
579                         return TRUE;
580
581         return FALSE;
582 }
583
584 /*
585   matcherprop_criteria_body
586   returns TRUE if the body must be matched
587  */
588
589 static gboolean matcherprop_criteria_body(MatcherProp * matcher)
590 {
591         switch(matcher->criteria) {
592         case MATCHCRITERIA_BODY_PART:
593         case MATCHCRITERIA_NOT_BODY_PART:
594                 return TRUE;
595         default:
596                 return FALSE;
597         }
598 }
599
600 /*
601   matcherprop_match_line
602   returns TRUE if the string matchs the MatcherProp criteria
603  */
604
605 static gboolean matcherprop_match_line(MatcherProp * matcher, gchar * line)
606 {
607         switch(matcher->criteria) {
608         case MATCHCRITERIA_BODY_PART:
609         case MATCHCRITERIA_MESSAGE:
610                 return matcherprop_string_match(matcher, line);
611         case MATCHCRITERIA_NOT_BODY_PART:
612         case MATCHCRITERIA_NOT_MESSAGE:
613                 return !matcherprop_string_match(matcher, line);
614         }
615         return FALSE;
616 }
617
618 /*
619   matcherlist_match_line
620   returns TRUE if the string matchs the MatcherList criteria
621  */
622
623 static gboolean matcherlist_match_line(MatcherList * matchers, gchar * line)
624 {
625         GSList * l;
626
627         for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
628                 MatcherProp * matcher = (MatcherProp *) l->data;
629
630                 if (matcherprop_criteria_body(matcher) ||
631                     matcherprop_criteria_message(matcher)) {
632                         if (matcherprop_match_line(matcher, line)) {
633                                 matcher->result = TRUE;
634                         }
635                 }
636                         
637                 if (matcher->result) {
638                         if (!matchers->bool_and)
639                                 return TRUE;
640                 }
641         }
642         return FALSE;
643 }
644
645 /*
646   matcherlist_match_body
647   returns TRUE if one line of the body matchs the MatcherList criteria
648  */
649
650 static gboolean matcherlist_match_body(MatcherList * matchers, FILE * fp)
651 {
652         gchar buf[BUFFSIZE];
653
654         while (fgets(buf, sizeof(buf), fp) != NULL)
655                 if (matcherlist_match_line(matchers, buf))
656                         return TRUE;
657
658         return FALSE;
659 }
660
661 gboolean matcherlist_match_file(MatcherList * matchers, MsgInfo * info,
662                                 gboolean result)
663 {
664         gboolean read_headers;
665         gboolean read_body;
666         GSList * l;
667         FILE * fp;
668         gchar * file;
669
670         /* file need to be read ? */
671
672         read_headers = FALSE;
673         read_body = FALSE;
674         for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
675                 MatcherProp * matcher = (MatcherProp *) l->data;
676
677                 if (matcherprop_criteria_headers(matcher))
678                         read_headers = TRUE;
679                 if (matcherprop_criteria_body(matcher))
680                         read_body = TRUE;
681                 if (matcherprop_criteria_message(matcher)) {
682                         read_headers = TRUE;
683                         read_body = TRUE;
684                 }
685                 matcher->result = FALSE;
686         }
687
688         if (!read_headers && !read_body)
689                 return result;
690
691         file = procmsg_get_message_file(info);
692         if (file == NULL)
693                 return FALSE;
694
695         if ((fp = fopen(file, "rb")) == NULL) {
696                 FILE_OP_ERROR(file, "fopen");
697                 g_free(file);
698                 return result;
699         }
700
701         /* read the headers */
702
703         if (read_headers) {
704                 if (matcherlist_match_headers(matchers, fp))
705                         read_body = FALSE;
706         }
707         else {
708                 matcherlist_skip_headers(fp);
709         }
710
711         /* read the body */
712         if (read_body) {
713                 matcherlist_match_body(matchers, fp);
714         }
715         
716         for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
717                 MatcherProp * matcher = (MatcherProp *) l->data;
718
719                 if (matcherprop_criteria_headers(matcher) ||
720                     matcherprop_criteria_body(matcher)    ||
721                     matcherprop_criteria_message(matcher)) {
722                         if (matcher->result) {
723                                 if (!matchers->bool_and) {
724                                         result = TRUE;
725                                         break;
726                                 }
727                         }
728                         else {
729                                 if (matchers->bool_and) {
730                                         result = FALSE;
731                                         break;
732                                 }
733                         }
734                 }                       
735         }
736
737         g_free(file);
738
739         fclose(fp);
740         
741         return result;
742 }
743
744 /* test a list of condition */
745
746 gboolean matcherlist_match(MatcherList * matchers, MsgInfo * info)
747 {
748         GSList * l;
749         gboolean result;
750
751         if (matchers->bool_and)
752                 result = TRUE;
753         else
754                 result = FALSE;
755
756         /* test the cached elements */
757
758         for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
759                 MatcherProp * matcher = (MatcherProp *) l->data;
760
761                 switch(matcher->criteria) {
762                 case MATCHCRITERIA_ALL:
763                 case MATCHCRITERIA_UNREAD:
764                 case MATCHCRITERIA_NOT_UNREAD:
765                 case MATCHCRITERIA_NEW:
766                 case MATCHCRITERIA_NOT_NEW:
767                 case MATCHCRITERIA_MARKED:
768                 case MATCHCRITERIA_NOT_MARKED:
769                 case MATCHCRITERIA_DELETED:
770                 case MATCHCRITERIA_NOT_DELETED:
771                 case MATCHCRITERIA_REPLIED:
772                 case MATCHCRITERIA_NOT_REPLIED:
773                 case MATCHCRITERIA_FORWARDED:
774                 case MATCHCRITERIA_NOT_FORWARDED:
775                 case MATCHCRITERIA_SUBJECT:
776                 case MATCHCRITERIA_NOT_SUBJECT:
777                 case MATCHCRITERIA_FROM:
778                 case MATCHCRITERIA_NOT_FROM:
779                 case MATCHCRITERIA_TO:
780                 case MATCHCRITERIA_NOT_TO:
781                 case MATCHCRITERIA_CC:
782                 case MATCHCRITERIA_NOT_CC:
783                 case MATCHCRITERIA_TO_OR_CC:
784                 case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
785                 case MATCHCRITERIA_AGE_GREATER:
786                 case MATCHCRITERIA_AGE_LOWER:
787                 case MATCHCRITERIA_NEWSGROUPS:
788                 case MATCHCRITERIA_NOT_NEWSGROUPS:
789                 case MATCHCRITERIA_INREPLYTO:
790                 case MATCHCRITERIA_NOT_INREPLYTO:
791                 case MATCHCRITERIA_REFERENCES:
792                 case MATCHCRITERIA_NOT_REFERENCES:
793                 case MATCHCRITERIA_SCORE_GREATER:
794                 case MATCHCRITERIA_SCORE_LOWER:
795                 case MATCHCRITERIA_SCORE_EQUAL:
796                 case MATCHCRITERIA_SIZE_GREATER:
797                 case MATCHCRITERIA_SIZE_SMALLER:
798                 case MATCHCRITERIA_SIZE_EQUAL:
799                 case MATCHCRITERIA_EXECUTE:
800                 case MATCHCRITERIA_NOT_EXECUTE:
801                         if (matcherprop_match(matcher, info)) {
802                                 if (!matchers->bool_and) {
803                                         return TRUE;
804                                 }
805                         }
806                         else {
807                                 if (matchers->bool_and) {
808                                         return FALSE;
809                                 }
810                         }
811                 }
812         }
813
814         /* test the condition on the file */
815
816         if (matcherlist_match_file(matchers, info, result)) {
817                 if (!matchers->bool_and)
818                         return TRUE;
819         }
820         else {
821                 if (matchers->bool_and)
822                         return FALSE;
823         }
824
825         return result;
826 }
827
828
829 gchar * matcherprop_to_string(MatcherProp * matcher)
830 {
831         gchar * matcher_str = NULL;
832         gchar * criteria_str;
833         gchar * matchtype_str;
834         int i;
835         gchar * p;
836         gint count;
837         gchar * expr_str;
838         gchar * out;
839
840         criteria_str = NULL;
841         for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
842             i++) {
843                 if (matchparser_tab[i].id == matcher->criteria)
844                         criteria_str = matchparser_tab[i].str;
845         }
846         if (criteria_str == NULL)
847                 return NULL;
848
849         switch(matcher->criteria) {
850         case MATCHCRITERIA_AGE_GREATER:
851         case MATCHCRITERIA_AGE_LOWER:
852         case MATCHCRITERIA_SCORE_GREATER:
853         case MATCHCRITERIA_SCORE_LOWER:
854         case MATCHCRITERIA_SCORE_EQUAL:
855         case MATCHCRITERIA_SIZE_GREATER:
856         case MATCHCRITERIA_SIZE_SMALLER:
857         case MATCHCRITERIA_SIZE_EQUAL:
858                 return g_strdup_printf("%s %i", criteria_str, matcher->value);
859         case MATCHCRITERIA_ALL:
860         case MATCHCRITERIA_UNREAD:
861         case MATCHCRITERIA_NOT_UNREAD:
862         case MATCHCRITERIA_NEW:
863         case MATCHCRITERIA_NOT_NEW:
864         case MATCHCRITERIA_MARKED:
865         case MATCHCRITERIA_NOT_MARKED:
866         case MATCHCRITERIA_DELETED:
867         case MATCHCRITERIA_NOT_DELETED:
868         case MATCHCRITERIA_REPLIED:
869         case MATCHCRITERIA_NOT_REPLIED:
870         case MATCHCRITERIA_FORWARDED:
871         case MATCHCRITERIA_NOT_FORWARDED:
872                 return g_strdup(criteria_str);
873         case MATCHCRITERIA_EXECUTE:
874         case MATCHCRITERIA_NOT_EXECUTE:
875                 return g_strdup_printf("%s \"%s\"", criteria_str, matcher->expr);
876         }
877
878         matchtype_str = NULL;
879         for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
880             i++) {
881                 if (matchparser_tab[i].id == matcher->matchtype)
882                         matchtype_str = matchparser_tab[i].str;
883         }
884
885         if (matchtype_str == NULL)
886                 return NULL;
887
888         switch (matcher->matchtype) {
889         case MATCHTYPE_MATCH:
890         case MATCHTYPE_MATCHCASE:
891         case MATCHTYPE_REGEXP:
892         case MATCHTYPE_REGEXPCASE:
893                 if (matcher->header)
894                         matcher_str =
895                                 g_strdup_printf("%s \"%s\" %s \"%s\"",
896                                            criteria_str, matcher->header,
897                                            matchtype_str, matcher->expr);
898                 else
899                         matcher_str =
900                                 g_strdup_printf("%s %s \"%s\"", criteria_str,
901                                                 matchtype_str, matcher->expr);
902                 break;
903         }
904
905         return matcher_str;
906 }
907
908 gchar * matcherlist_to_string(MatcherList * matchers)
909 {
910         gint count;
911         gchar ** vstr;
912         GSList * l;
913         gchar ** cur_str;
914         gchar * result;
915
916         count = g_slist_length(matchers->matchers);
917         vstr = g_new(gchar *, count + 1);
918
919         for (l = matchers->matchers, cur_str = vstr ; l != NULL ;
920              l = g_slist_next(l), cur_str ++) {
921                 *cur_str = matcherprop_to_string((MatcherProp *) l->data);
922                 if (*cur_str == NULL)
923                         break;
924         }
925         *cur_str = NULL;
926         
927         if (matchers->bool_and)
928                 result = g_strjoinv(" & ", vstr);
929         else
930                 result = g_strjoinv(" | ", vstr);
931
932         for(cur_str = vstr ; *cur_str != NULL ; cur_str ++)
933                 g_free(*cur_str);
934         g_free(vstr);
935
936         return result;
937 }
938
939 #define STRLEN_ZERO(s) ((s) ? strlen(s) : 0)
940 #define STRLEN_DEFAULT(s,d) ((s) ? strlen(s) : STRLEN_ZERO(d))
941 /* matching_build_command() - preferably cmd should be unescaped */
942 gchar * matching_build_command(gchar * cmd, MsgInfo * info)
943 {
944         gchar * s = cmd;
945         gchar * filename = NULL;
946         gchar * processed_cmd;
947         gchar * p;
948         gint size;
949
950         const gchar *const no_subject    = _("(none)") ;
951         const gchar *const no_from       = _("(none)") ;
952         const gchar *const no_to         = _("(none)") ;
953         const gchar *const no_cc         = _("(none)") ;
954         const gchar *const no_date       = _("(none)") ;
955         const gchar *const no_msgid      = _("(none)") ;
956         const gchar *const no_newsgroups = _("(none)") ;
957         const gchar *const no_references = _("(none)") ;
958
959         size = STRLEN_ZERO(cmd) + 1;
960         while (*s != '\0') {
961                 if (*s == '%') {
962                         s++;
963                         switch (*s) {
964                         case '%':
965                                 size -= 1;
966                                 break;
967                         case 's': /* subject */
968                                 size += STRLEN_DEFAULT(info->subject, no_subject) - 2;
969                                 break;
970                         case 'f': /* from */
971                                 size += STRLEN_DEFAULT(info->from, no_from) - 2;
972                                 break;
973                         case 't': /* to */
974                                 size += STRLEN_DEFAULT(info->to, no_to) - 2;
975                                 break;
976                         case 'c': /* cc */
977                                 size += STRLEN_DEFAULT(info->cc, no_cc) - 2;
978                                 break;
979                         case 'd': /* date */
980                                 size += STRLEN_DEFAULT(info->date, no_date) - 2;
981                                 break;
982                         case 'i': /* message-id */
983                                 size += STRLEN_DEFAULT(info->msgid, no_msgid) - 2;
984                                 break;
985                         case 'n': /* newsgroups */
986                                 size += STRLEN_DEFAULT(info->newsgroups, no_newsgroups) - 2;
987                                 break;
988                         case 'r': /* references */
989                                 size += STRLEN_DEFAULT(info->references, no_references) - 2;
990                                 break;
991                         case 'F': /* file */
992                                 filename = folder_item_fetch_msg(info->folder,
993                                                                  info->msgnum);
994                                 
995                                 if (filename == NULL) {
996                                         g_warning(_("filename is not set"));
997                                         return NULL;
998                                 }
999                                 else
1000                                         size += strlen(filename) - 2;
1001                                 break;
1002                         }
1003                         s++;
1004                 }
1005                 else s++;
1006         }
1007
1008
1009         processed_cmd = g_new0(gchar, size);
1010         s = cmd;
1011         p = processed_cmd;
1012
1013         while (*s != '\0') {
1014                 if (*s == '%') {
1015                         s++;
1016                         switch (*s) {
1017                         case '%':
1018                                 *p = '%';
1019                                 p++;
1020                                 break;
1021                         case 's': /* subject */
1022                                 if (info->subject != NULL)
1023                                         strcpy(p, info->subject);
1024                                 else
1025                                         strcpy(p, no_subject);
1026                                 p += strlen(p);
1027                                 break;
1028                         case 'f': /* from */
1029                                 if (info->from != NULL)
1030                                         strcpy(p, info->from);
1031                                 else
1032                                         strcpy(p, no_from);
1033                                 p += strlen(p);
1034                                 break;
1035                         case 't': /* to */
1036                                 if (info->to != NULL)
1037                                         strcpy(p, info->to);
1038                                 else
1039                                         strcpy(p, no_to);
1040                                 p += strlen(p);
1041                                 break;
1042                         case 'c': /* cc */
1043                                 if (info->cc != NULL)
1044                                         strcpy(p, info->cc);
1045                                 else
1046                                         strcpy(p, no_cc);
1047                                 p += strlen(p);
1048                                 break;
1049                         case 'd': /* date */
1050                                 if (info->date != NULL)
1051                                         strcpy(p, info->date);
1052                                 else
1053                                         strcpy(p, no_date);
1054                                 p += strlen(p);
1055                                 break;
1056                         case 'i': /* message-id */
1057                                 if (info->msgid != NULL)
1058                                         strcpy(p, info->msgid);
1059                                 else
1060                                         strcpy(p, no_msgid);
1061                                 p += strlen(p);
1062                                 break;
1063                         case 'n': /* newsgroups */
1064                                 if (info->newsgroups != NULL)
1065                                         strcpy(p, info->newsgroups);
1066                                 else
1067                                         strcpy(p, no_newsgroups);
1068                                 p += strlen(p);
1069                                 break;
1070                         case 'r': /* references */
1071                                 if (info->references != NULL)
1072                                         strcpy(p, info->references);
1073                                 else
1074                                         strcpy(p, no_references);
1075                                 p += strlen(p);
1076                                 break;
1077                         case 'F': /* file */
1078                                 strcpy(p, filename);
1079                                 p += strlen(p);
1080                                 g_free(filename);
1081                                 break;
1082                         default:
1083                                 *p = '%';
1084                                 p++;
1085                                 *p = *s;
1086                                 p++;
1087                                 break;
1088                         }
1089                         s++;
1090                 }
1091                 else {
1092                         *p = *s;
1093                         p++;
1094                         s++;
1095                 }
1096         }
1097
1098         debug_print("*** exec string \"%s\"\n", processed_cmd);
1099         return processed_cmd;
1100 }
1101 #undef STRLEN_DEFAULT
1102 #undef STRLEN_ZERO
1103
1104 /* ************************************************************ */
1105
1106 static void prefs_scoring_write(FILE * fp, GSList * prefs_scoring)
1107 {
1108         GSList * cur;
1109
1110         for (cur = prefs_scoring; cur != NULL; cur = cur->next) {
1111                 gchar *scoring_str;
1112                 ScoringProp * prop;
1113
1114                 prop = (ScoringProp *) cur->data;
1115                 scoring_str = scoringprop_to_string(prop);
1116                 if (fputs(scoring_str, fp) == EOF ||
1117                     fputc('\n', fp) == EOF) {
1118                         FILE_OP_ERROR("scoring config", "fputs || fputc");
1119                         g_free(scoring_str);
1120                         return;
1121                 }
1122                 g_free(scoring_str);
1123         }
1124 }
1125
1126 static void prefs_filtering_write(FILE * fp, GSList * prefs_scoring)
1127 {
1128         GSList * cur;
1129
1130         for (cur = prefs_scoring; cur != NULL; cur = cur->next) {
1131                 gchar *filtering_str;
1132                 FilteringProp * prop;
1133
1134                 if (NULL == (prop = (FilteringProp *) cur->data))
1135                         continue;
1136                 
1137                 if (NULL == (filtering_str = filteringprop_to_string(prop)))
1138                         continue;
1139                 
1140                 if (fputs(filtering_str, fp) == EOF ||
1141                     fputc('\n', fp) == EOF) {
1142                         FILE_OP_ERROR("filtering config", "fputs || fputc");
1143                         g_free(filtering_str);
1144                         return;
1145                 }
1146                 g_free(filtering_str);
1147         }
1148 }
1149
1150 static gboolean prefs_matcher_write_func(GNode *node, gpointer data)
1151 {
1152         FolderItem *item;
1153         FILE * fp = data;
1154         gchar * id;
1155         GSList * prefs_scoring;
1156         GSList * prefs_filtering;
1157
1158         if (node != NULL) {
1159                 item = node->data;
1160                 /* prevent from the warning */
1161                 if (item->path == NULL)
1162                         return FALSE;
1163                 id = folder_item_get_identifier(item);
1164                 if (id == NULL)
1165                         return FALSE;
1166                 prefs_scoring = item->prefs->scoring;
1167                 prefs_filtering = item->prefs->processing;
1168         }
1169         else {
1170                 item = NULL;
1171                 id = g_strdup("global"); /* because it is g_freed */
1172                 prefs_scoring = global_scoring;
1173                 prefs_filtering = global_processing;
1174         }
1175
1176         if (prefs_filtering != NULL || prefs_scoring != NULL) {
1177                 fprintf(fp, "[%s]\n", id);
1178
1179                 prefs_filtering_write(fp, prefs_filtering);
1180                 prefs_scoring_write(fp, prefs_scoring);
1181
1182                 fputc('\n', fp);
1183         }
1184
1185         g_free(id);
1186
1187         return FALSE;
1188 }
1189
1190 static void prefs_matcher_save(FILE * fp)
1191 {
1192         GList * cur;
1193
1194         for (cur = folder_get_list() ; cur != NULL ; cur = g_list_next(cur)) {
1195                 Folder *folder;
1196
1197                 folder = (Folder *) cur->data;
1198                 g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1199                                 prefs_matcher_write_func, fp);
1200         }
1201         prefs_matcher_write_func(NULL, fp);
1202 }
1203
1204
1205 void prefs_matcher_write_config(void)
1206 {
1207         gchar *rcpath;
1208         PrefFile *pfile;
1209         GSList *cur;
1210         ScoringProp * prop;
1211
1212         debug_print("Writing matcher configuration...\n");
1213
1214         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1215                              MATCHER_RC, NULL);
1216
1217         if ((pfile = prefs_write_open(rcpath)) == NULL) {
1218                 g_warning(_("failed to write configuration to file\n"));
1219                 g_free(rcpath);
1220                 return;
1221         }
1222
1223
1224         prefs_matcher_save(pfile->fp);
1225
1226         g_free(rcpath);
1227
1228         if (prefs_write_close(pfile) < 0) {
1229                 g_warning(_("failed to write configuration to file\n"));
1230                 return;
1231         }
1232 }
1233
1234 /* ******************************************************************* */
1235
1236 void prefs_matcher_read_config(void)
1237 {
1238         gchar * rcpath;
1239         FILE * f;
1240
1241         prefs_scoring_clear();
1242         prefs_filtering_clear();
1243
1244         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, MATCHER_RC, NULL);
1245         f = fopen(rcpath, "rb");
1246         g_free(rcpath);
1247
1248         if (f != NULL) {
1249                 matcher_parser_start_parsing(f);
1250                 fclose(f);
1251         }
1252         else {
1253                 /* previous version compatibily */
1254
1255                 /* printf("reading filtering\n"); */
1256                 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1257                                      FILTERING_RC, NULL);
1258                 f = fopen(rcpath, "rb");
1259                 g_free(rcpath);
1260                 
1261                 if (f != NULL) {
1262                         matcher_parser_start_parsing(f);
1263                         fclose(matcher_parserin);
1264                 }
1265                 
1266                 /* printf("reading scoring\n"); */
1267                 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1268                                      SCORING_RC, NULL);
1269                 f = fopen(rcpath, "rb");
1270                 g_free(rcpath);
1271                 
1272                 if (f != NULL) {
1273                         matcher_parser_start_parsing(f);
1274                         fclose(matcher_parserin);
1275                 }
1276         }
1277 }