and another one
[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         g_free(file);           
323
324         cmd = matching_build_command(prop->unesc_expr, info);
325         if (cmd == NULL)
326                 return FALSE;
327
328         retval = system(cmd);
329         debug_print("Command exit code: %d\n", retval);
330
331         return (retval == 0);
332 }
333
334 /* match a message and his headers, hlist can be NULL if you don't
335    want to use headers */
336
337 gboolean matcherprop_match(MatcherProp * prop, MsgInfo * info)
338 {
339         time_t t;
340
341         switch(prop->criteria) {
342         case MATCHCRITERIA_ALL:
343                 return 1;
344         case MATCHCRITERIA_UNREAD:
345                 return MSG_IS_UNREAD(info->flags);
346         case MATCHCRITERIA_NOT_UNREAD:
347                 return !MSG_IS_UNREAD(info->flags);
348         case MATCHCRITERIA_NEW:
349                 return MSG_IS_NEW(info->flags);
350         case MATCHCRITERIA_NOT_NEW:
351                 return !MSG_IS_NEW(info->flags);
352         case MATCHCRITERIA_MARKED:
353                 return MSG_IS_MARKED(info->flags);
354         case MATCHCRITERIA_NOT_MARKED:
355                 return !MSG_IS_MARKED(info->flags);
356         case MATCHCRITERIA_DELETED:
357                 return MSG_IS_DELETED(info->flags);
358         case MATCHCRITERIA_NOT_DELETED:
359                 return !MSG_IS_DELETED(info->flags);
360         case MATCHCRITERIA_REPLIED:
361                 return MSG_IS_REPLIED(info->flags);
362         case MATCHCRITERIA_NOT_REPLIED:
363                 return !MSG_IS_REPLIED(info->flags);
364         case MATCHCRITERIA_FORWARDED:
365                 return MSG_IS_FORWARDED(info->flags);
366         case MATCHCRITERIA_NOT_FORWARDED:
367                 return !MSG_IS_FORWARDED(info->flags);
368         case MATCHCRITERIA_SUBJECT:
369                 return matcherprop_string_match(prop, info->subject);
370         case MATCHCRITERIA_NOT_SUBJECT:
371                 return !matcherprop_string_match(prop, info->subject);
372         case MATCHCRITERIA_FROM:
373                 return matcherprop_string_match(prop, info->from);
374         case MATCHCRITERIA_NOT_FROM:
375                 return !matcherprop_string_match(prop, info->from);
376         case MATCHCRITERIA_TO:
377                 return matcherprop_string_match(prop, info->to);
378         case MATCHCRITERIA_NOT_TO:
379                 return !matcherprop_string_match(prop, info->to);
380         case MATCHCRITERIA_CC:
381                 return matcherprop_string_match(prop, info->cc);
382         case MATCHCRITERIA_NOT_CC:
383                 return !matcherprop_string_match(prop, info->cc);
384         case MATCHCRITERIA_TO_OR_CC:
385                 return matcherprop_string_match(prop, info->to)
386                         || matcherprop_string_match(prop, info->cc);
387         case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
388                 return !(matcherprop_string_match(prop, info->to)
389                 || matcherprop_string_match(prop, info->cc));
390         case MATCHCRITERIA_AGE_GREATER:
391                 t = time(NULL);
392                 return ((t - info->date_t) / (60 * 60 * 24)) >= prop->value;
393         case MATCHCRITERIA_AGE_LOWER:
394                 t = time(NULL);
395                 return ((t - info->date_t) / (60 * 60 * 24)) <= prop->value;
396         case MATCHCRITERIA_SCORE_GREATER:
397                 return info->score >= prop->value;
398         case MATCHCRITERIA_SCORE_LOWER:
399                 return info->score <= prop->value;
400         case MATCHCRITERIA_SCORE_EQUAL:
401                 return info->score == prop->value;
402         case MATCHCRITERIA_SIZE_GREATER:
403                 /* FIXME: info->size is an off_t */
404                 return info->size > (off_t) prop->value;
405         case MATCHCRITERIA_SIZE_EQUAL:
406                 /* FIXME: info->size is an off_t */
407                 return info->size == (off_t) prop->value;
408         case MATCHCRITERIA_SIZE_SMALLER:
409                 /* FIXME: info->size is an off_t */
410                 return info->size <  (off_t) prop->value;
411         case MATCHCRITERIA_NEWSGROUPS:
412                 return matcherprop_string_match(prop, info->newsgroups);
413         case MATCHCRITERIA_NOT_NEWSGROUPS:
414                 return !matcherprop_string_match(prop, info->newsgroups);
415         case MATCHCRITERIA_INREPLYTO:
416                 return matcherprop_string_match(prop, info->inreplyto);
417         case MATCHCRITERIA_NOT_INREPLYTO:
418                 return !matcherprop_string_match(prop, info->inreplyto);
419         case MATCHCRITERIA_REFERENCES:
420                 return matcherprop_string_match(prop, info->references);
421         case MATCHCRITERIA_NOT_REFERENCES:
422                 return !matcherprop_string_match(prop, info->references);
423         case MATCHCRITERIA_EXECUTE:
424                 return matcherprop_match_execute(prop, info);
425         case MATCHCRITERIA_NOT_EXECUTE:
426                 return !matcherprop_match_execute(prop, info);
427         default:
428                 return 0;
429         }
430 }
431
432 /* ********************* MatcherList *************************** */
433
434
435 MatcherList * matcherlist_new(GSList * matchers, gboolean bool_and)
436 {
437         MatcherList * cond;
438
439         cond = g_new0(MatcherList, 1);
440
441         cond->matchers = matchers;
442         cond->bool_and = bool_and;
443
444         return cond;
445 }
446
447 void matcherlist_free(MatcherList * cond)
448 {
449         GSList * l;
450
451         for(l = cond->matchers ; l != NULL ; l = g_slist_next(l)) {
452                 matcherprop_free((MatcherProp *) l->data);
453         }
454         g_free(cond);
455 }
456
457 /*
458   skip the headers
459  */
460
461 static void matcherlist_skip_headers(FILE *fp)
462 {
463         gchar buf[BUFFSIZE];
464
465         while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1) {
466         }
467 }
468
469 /*
470   matcherprop_match_one_header
471   returns TRUE if buf matchs the MatchersProp criteria
472  */
473
474 static gboolean matcherprop_match_one_header(MatcherProp * matcher,
475                                              gchar * buf)
476 {
477         gboolean result;
478         Header *header;
479
480         switch(matcher->criteria) {
481         case MATCHCRITERIA_HEADER:
482         case MATCHCRITERIA_NOT_HEADER:
483                 header = procheader_parse_header(buf);
484                 if (!header)
485                         return FALSE;
486                 if (procheader_headername_equal(header->name,
487                                                 matcher->header)) {
488                         if (matcher->criteria == MATCHCRITERIA_HEADER)
489                                 result = matcherprop_string_match(matcher, header->body);
490                         else
491                                 result = !matcherprop_string_match(matcher, header->body);
492                         procheader_header_free(header);
493                         return result;
494                 }
495                 else {
496                         procheader_header_free(header);
497                 }
498                 break;
499         case MATCHCRITERIA_HEADERS_PART:
500         case MATCHCRITERIA_MESSAGE:
501                 return matcherprop_string_match(matcher, buf);
502         case MATCHCRITERIA_NOT_MESSAGE:
503         case MATCHCRITERIA_NOT_HEADERS_PART:
504                 return !matcherprop_string_match(matcher, buf);
505         }
506         return FALSE;
507 }
508
509 /*
510   matcherprop_criteria_header
511   returns TRUE if the headers must be matched
512  */
513
514 static gboolean matcherprop_criteria_headers(MatcherProp * matcher)
515 {
516         switch(matcher->criteria) {
517         case MATCHCRITERIA_HEADER:
518         case MATCHCRITERIA_NOT_HEADER:
519         case MATCHCRITERIA_HEADERS_PART:
520         case MATCHCRITERIA_NOT_HEADERS_PART:
521                 return TRUE;
522         default:
523                 return FALSE;
524         }
525 }
526
527 static gboolean matcherprop_criteria_message(MatcherProp * matcher)
528 {
529         switch(matcher->criteria) {
530         case MATCHCRITERIA_MESSAGE:
531         case MATCHCRITERIA_NOT_MESSAGE:
532                 return TRUE;
533         default:
534                 return FALSE;
535         }
536 }
537
538 /*
539   matcherlist_match_one_header
540   returns TRUE if match should stop
541  */
542
543 static gboolean matcherlist_match_one_header(MatcherList * matchers,
544                                          gchar * buf)
545 {
546         GSList * l;
547
548         for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
549                 MatcherProp * matcher = (MatcherProp *) l->data;
550
551                 if (matcherprop_criteria_headers(matcher) ||
552                     matcherprop_criteria_message(matcher)) {
553                         if (matcherprop_match_one_header(matcher, buf)) {
554                                 matcher->result = TRUE;
555                         }
556                 }
557
558                 if (matcherprop_criteria_headers(matcher)) {
559                         if (matcher->result) {
560                                 if (!matchers->bool_and)
561                                         return TRUE;
562                         }
563                 }
564         }
565
566         return FALSE;
567 }
568
569 /*
570   matcherlist_match_headers
571   returns TRUE if one of the headers matchs the MatcherList criteria
572  */
573
574 static gboolean matcherlist_match_headers(MatcherList * matchers, FILE * fp)
575 {
576         gchar buf[BUFFSIZE];
577
578         while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1)
579                 if (matcherlist_match_one_header(matchers, buf))
580                         return TRUE;
581
582         return FALSE;
583 }
584
585 /*
586   matcherprop_criteria_body
587   returns TRUE if the body must be matched
588  */
589
590 static gboolean matcherprop_criteria_body(MatcherProp * matcher)
591 {
592         switch(matcher->criteria) {
593         case MATCHCRITERIA_BODY_PART:
594         case MATCHCRITERIA_NOT_BODY_PART:
595                 return TRUE;
596         default:
597                 return FALSE;
598         }
599 }
600
601 /*
602   matcherprop_match_line
603   returns TRUE if the string matchs the MatcherProp criteria
604  */
605
606 static gboolean matcherprop_match_line(MatcherProp * matcher, gchar * line)
607 {
608         switch(matcher->criteria) {
609         case MATCHCRITERIA_BODY_PART:
610         case MATCHCRITERIA_MESSAGE:
611                 return matcherprop_string_match(matcher, line);
612         case MATCHCRITERIA_NOT_BODY_PART:
613         case MATCHCRITERIA_NOT_MESSAGE:
614                 return !matcherprop_string_match(matcher, line);
615         }
616         return FALSE;
617 }
618
619 /*
620   matcherlist_match_line
621   returns TRUE if the string matchs the MatcherList criteria
622  */
623
624 static gboolean matcherlist_match_line(MatcherList * matchers, gchar * line)
625 {
626         GSList * l;
627
628         for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
629                 MatcherProp * matcher = (MatcherProp *) l->data;
630
631                 if (matcherprop_criteria_body(matcher) ||
632                     matcherprop_criteria_message(matcher)) {
633                         if (matcherprop_match_line(matcher, line)) {
634                                 matcher->result = TRUE;
635                         }
636                 }
637                         
638                 if (matcher->result) {
639                         if (!matchers->bool_and)
640                                 return TRUE;
641                 }
642         }
643         return FALSE;
644 }
645
646 /*
647   matcherlist_match_body
648   returns TRUE if one line of the body matchs the MatcherList criteria
649  */
650
651 static gboolean matcherlist_match_body(MatcherList * matchers, FILE * fp)
652 {
653         gchar buf[BUFFSIZE];
654
655         while (fgets(buf, sizeof(buf), fp) != NULL)
656                 if (matcherlist_match_line(matchers, buf))
657                         return TRUE;
658
659         return FALSE;
660 }
661
662 gboolean matcherlist_match_file(MatcherList * matchers, MsgInfo * info,
663                                 gboolean result)
664 {
665         gboolean read_headers;
666         gboolean read_body;
667         GSList * l;
668         FILE * fp;
669         gchar * file;
670
671         /* file need to be read ? */
672
673         read_headers = FALSE;
674         read_body = FALSE;
675         for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
676                 MatcherProp * matcher = (MatcherProp *) l->data;
677
678                 if (matcherprop_criteria_headers(matcher))
679                         read_headers = TRUE;
680                 if (matcherprop_criteria_body(matcher))
681                         read_body = TRUE;
682                 if (matcherprop_criteria_message(matcher)) {
683                         read_headers = TRUE;
684                         read_body = TRUE;
685                 }
686                 matcher->result = FALSE;
687         }
688
689         if (!read_headers && !read_body)
690                 return result;
691
692         file = procmsg_get_message_file(info);
693         if (file == NULL)
694                 return FALSE;
695
696         if ((fp = fopen(file, "rb")) == NULL) {
697                 FILE_OP_ERROR(file, "fopen");
698                 g_free(file);
699                 return result;
700         }
701
702         /* read the headers */
703
704         if (read_headers) {
705                 if (matcherlist_match_headers(matchers, fp))
706                         read_body = FALSE;
707         }
708         else {
709                 matcherlist_skip_headers(fp);
710         }
711
712         /* read the body */
713         if (read_body) {
714                 matcherlist_match_body(matchers, fp);
715         }
716         
717         for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
718                 MatcherProp * matcher = (MatcherProp *) l->data;
719
720                 if (matcherprop_criteria_headers(matcher) ||
721                     matcherprop_criteria_body(matcher)    ||
722                     matcherprop_criteria_message(matcher)) {
723                         if (matcher->result) {
724                                 if (!matchers->bool_and) {
725                                         result = TRUE;
726                                         break;
727                                 }
728                         }
729                         else {
730                                 if (matchers->bool_and) {
731                                         result = FALSE;
732                                         break;
733                                 }
734                         }
735                 }                       
736         }
737
738         g_free(file);
739
740         fclose(fp);
741         
742         return result;
743 }
744
745 /* test a list of condition */
746
747 gboolean matcherlist_match(MatcherList * matchers, MsgInfo * info)
748 {
749         GSList * l;
750         gboolean result;
751
752         if (matchers->bool_and)
753                 result = TRUE;
754         else
755                 result = FALSE;
756
757         /* test the cached elements */
758
759         for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
760                 MatcherProp * matcher = (MatcherProp *) l->data;
761
762                 switch(matcher->criteria) {
763                 case MATCHCRITERIA_ALL:
764                 case MATCHCRITERIA_UNREAD:
765                 case MATCHCRITERIA_NOT_UNREAD:
766                 case MATCHCRITERIA_NEW:
767                 case MATCHCRITERIA_NOT_NEW:
768                 case MATCHCRITERIA_MARKED:
769                 case MATCHCRITERIA_NOT_MARKED:
770                 case MATCHCRITERIA_DELETED:
771                 case MATCHCRITERIA_NOT_DELETED:
772                 case MATCHCRITERIA_REPLIED:
773                 case MATCHCRITERIA_NOT_REPLIED:
774                 case MATCHCRITERIA_FORWARDED:
775                 case MATCHCRITERIA_NOT_FORWARDED:
776                 case MATCHCRITERIA_SUBJECT:
777                 case MATCHCRITERIA_NOT_SUBJECT:
778                 case MATCHCRITERIA_FROM:
779                 case MATCHCRITERIA_NOT_FROM:
780                 case MATCHCRITERIA_TO:
781                 case MATCHCRITERIA_NOT_TO:
782                 case MATCHCRITERIA_CC:
783                 case MATCHCRITERIA_NOT_CC:
784                 case MATCHCRITERIA_TO_OR_CC:
785                 case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
786                 case MATCHCRITERIA_AGE_GREATER:
787                 case MATCHCRITERIA_AGE_LOWER:
788                 case MATCHCRITERIA_NEWSGROUPS:
789                 case MATCHCRITERIA_NOT_NEWSGROUPS:
790                 case MATCHCRITERIA_INREPLYTO:
791                 case MATCHCRITERIA_NOT_INREPLYTO:
792                 case MATCHCRITERIA_REFERENCES:
793                 case MATCHCRITERIA_NOT_REFERENCES:
794                 case MATCHCRITERIA_SCORE_GREATER:
795                 case MATCHCRITERIA_SCORE_LOWER:
796                 case MATCHCRITERIA_SCORE_EQUAL:
797                 case MATCHCRITERIA_SIZE_GREATER:
798                 case MATCHCRITERIA_SIZE_SMALLER:
799                 case MATCHCRITERIA_SIZE_EQUAL:
800                 case MATCHCRITERIA_EXECUTE:
801                 case MATCHCRITERIA_NOT_EXECUTE:
802                         if (matcherprop_match(matcher, info)) {
803                                 if (!matchers->bool_and) {
804                                         return TRUE;
805                                 }
806                         }
807                         else {
808                                 if (matchers->bool_and) {
809                                         return FALSE;
810                                 }
811                         }
812                 }
813         }
814
815         /* test the condition on the file */
816
817         if (matcherlist_match_file(matchers, info, result)) {
818                 if (!matchers->bool_and)
819                         return TRUE;
820         }
821         else {
822                 if (matchers->bool_and)
823                         return FALSE;
824         }
825
826         return result;
827 }
828
829
830 gchar * matcherprop_to_string(MatcherProp * matcher)
831 {
832         gchar * matcher_str = NULL;
833         gchar * criteria_str;
834         gchar * matchtype_str;
835         int i;
836         gchar * p;
837         gint count;
838         gchar * expr_str;
839         gchar * out;
840
841         criteria_str = NULL;
842         for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
843             i++) {
844                 if (matchparser_tab[i].id == matcher->criteria)
845                         criteria_str = matchparser_tab[i].str;
846         }
847         if (criteria_str == NULL)
848                 return NULL;
849
850         switch(matcher->criteria) {
851         case MATCHCRITERIA_AGE_GREATER:
852         case MATCHCRITERIA_AGE_LOWER:
853         case MATCHCRITERIA_SCORE_GREATER:
854         case MATCHCRITERIA_SCORE_LOWER:
855         case MATCHCRITERIA_SCORE_EQUAL:
856         case MATCHCRITERIA_SIZE_GREATER:
857         case MATCHCRITERIA_SIZE_SMALLER:
858         case MATCHCRITERIA_SIZE_EQUAL:
859                 return g_strdup_printf("%s %i", criteria_str, matcher->value);
860         case MATCHCRITERIA_ALL:
861         case MATCHCRITERIA_UNREAD:
862         case MATCHCRITERIA_NOT_UNREAD:
863         case MATCHCRITERIA_NEW:
864         case MATCHCRITERIA_NOT_NEW:
865         case MATCHCRITERIA_MARKED:
866         case MATCHCRITERIA_NOT_MARKED:
867         case MATCHCRITERIA_DELETED:
868         case MATCHCRITERIA_NOT_DELETED:
869         case MATCHCRITERIA_REPLIED:
870         case MATCHCRITERIA_NOT_REPLIED:
871         case MATCHCRITERIA_FORWARDED:
872         case MATCHCRITERIA_NOT_FORWARDED:
873                 return g_strdup(criteria_str);
874         case MATCHCRITERIA_EXECUTE:
875         case MATCHCRITERIA_NOT_EXECUTE:
876                 return g_strdup_printf("%s \"%s\"", criteria_str, matcher->expr);
877         }
878
879         matchtype_str = NULL;
880         for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
881             i++) {
882                 if (matchparser_tab[i].id == matcher->matchtype)
883                         matchtype_str = matchparser_tab[i].str;
884         }
885
886         if (matchtype_str == NULL)
887                 return NULL;
888
889         switch (matcher->matchtype) {
890         case MATCHTYPE_MATCH:
891         case MATCHTYPE_MATCHCASE:
892         case MATCHTYPE_REGEXP:
893         case MATCHTYPE_REGEXPCASE:
894                 if (matcher->header)
895                         matcher_str =
896                                 g_strdup_printf("%s \"%s\" %s \"%s\"",
897                                            criteria_str, matcher->header,
898                                            matchtype_str, matcher->expr);
899                 else
900                         matcher_str =
901                                 g_strdup_printf("%s %s \"%s\"", criteria_str,
902                                                 matchtype_str, matcher->expr);
903                 break;
904         }
905
906         return matcher_str;
907 }
908
909 gchar * matcherlist_to_string(MatcherList * matchers)
910 {
911         gint count;
912         gchar ** vstr;
913         GSList * l;
914         gchar ** cur_str;
915         gchar * result;
916
917         count = g_slist_length(matchers->matchers);
918         vstr = g_new(gchar *, count + 1);
919
920         for (l = matchers->matchers, cur_str = vstr ; l != NULL ;
921              l = g_slist_next(l), cur_str ++) {
922                 *cur_str = matcherprop_to_string((MatcherProp *) l->data);
923                 if (*cur_str == NULL)
924                         break;
925         }
926         *cur_str = NULL;
927         
928         if (matchers->bool_and)
929                 result = g_strjoinv(" & ", vstr);
930         else
931                 result = g_strjoinv(" | ", vstr);
932
933         for(cur_str = vstr ; *cur_str != NULL ; cur_str ++)
934                 g_free(*cur_str);
935         g_free(vstr);
936
937         return result;
938 }
939
940 #define STRLEN_ZERO(s) ((s) ? strlen(s) : 0)
941 #define STRLEN_DEFAULT(s,d) ((s) ? strlen(s) : STRLEN_ZERO(d))
942 /* matching_build_command() - preferably cmd should be unescaped */
943 gchar * matching_build_command(gchar * cmd, MsgInfo * info)
944 {
945         gchar * s = cmd;
946         gchar * filename = NULL;
947         gchar * processed_cmd;
948         gchar * p;
949         gint size;
950
951         const gchar *const no_subject    = _("(none)") ;
952         const gchar *const no_from       = _("(none)") ;
953         const gchar *const no_to         = _("(none)") ;
954         const gchar *const no_cc         = _("(none)") ;
955         const gchar *const no_date       = _("(none)") ;
956         const gchar *const no_msgid      = _("(none)") ;
957         const gchar *const no_newsgroups = _("(none)") ;
958         const gchar *const no_references = _("(none)") ;
959
960         size = STRLEN_ZERO(cmd) + 1;
961         while (*s != '\0') {
962                 if (*s == '%') {
963                         s++;
964                         switch (*s) {
965                         case '%':
966                                 size -= 1;
967                                 break;
968                         case 's': /* subject */
969                                 size += STRLEN_DEFAULT(info->subject, no_subject) - 2;
970                                 break;
971                         case 'f': /* from */
972                                 size += STRLEN_DEFAULT(info->from, no_from) - 2;
973                                 break;
974                         case 't': /* to */
975                                 size += STRLEN_DEFAULT(info->to, no_to) - 2;
976                                 break;
977                         case 'c': /* cc */
978                                 size += STRLEN_DEFAULT(info->cc, no_cc) - 2;
979                                 break;
980                         case 'd': /* date */
981                                 size += STRLEN_DEFAULT(info->date, no_date) - 2;
982                                 break;
983                         case 'i': /* message-id */
984                                 size += STRLEN_DEFAULT(info->msgid, no_msgid) - 2;
985                                 break;
986                         case 'n': /* newsgroups */
987                                 size += STRLEN_DEFAULT(info->newsgroups, no_newsgroups) - 2;
988                                 break;
989                         case 'r': /* references */
990                                 size += STRLEN_DEFAULT(info->references, no_references) - 2;
991                                 break;
992                         case 'F': /* file */
993                                 filename = folder_item_fetch_msg(info->folder,
994                                                                  info->msgnum);
995                                 
996                                 if (filename == NULL) {
997                                         g_warning(_("filename is not set"));
998                                         return NULL;
999                                 }
1000                                 else
1001                                         size += strlen(filename) - 2;
1002                                 break;
1003                         }
1004                         s++;
1005                 }
1006                 else s++;
1007         }
1008
1009
1010         processed_cmd = g_new0(gchar, size);
1011         s = cmd;
1012         p = processed_cmd;
1013
1014         while (*s != '\0') {
1015                 if (*s == '%') {
1016                         s++;
1017                         switch (*s) {
1018                         case '%':
1019                                 *p = '%';
1020                                 p++;
1021                                 break;
1022                         case 's': /* subject */
1023                                 if (info->subject != NULL)
1024                                         strcpy(p, info->subject);
1025                                 else
1026                                         strcpy(p, no_subject);
1027                                 p += strlen(p);
1028                                 break;
1029                         case 'f': /* from */
1030                                 if (info->from != NULL)
1031                                         strcpy(p, info->from);
1032                                 else
1033                                         strcpy(p, no_from);
1034                                 p += strlen(p);
1035                                 break;
1036                         case 't': /* to */
1037                                 if (info->to != NULL)
1038                                         strcpy(p, info->to);
1039                                 else
1040                                         strcpy(p, no_to);
1041                                 p += strlen(p);
1042                                 break;
1043                         case 'c': /* cc */
1044                                 if (info->cc != NULL)
1045                                         strcpy(p, info->cc);
1046                                 else
1047                                         strcpy(p, no_cc);
1048                                 p += strlen(p);
1049                                 break;
1050                         case 'd': /* date */
1051                                 if (info->date != NULL)
1052                                         strcpy(p, info->date);
1053                                 else
1054                                         strcpy(p, no_date);
1055                                 p += strlen(p);
1056                                 break;
1057                         case 'i': /* message-id */
1058                                 if (info->msgid != NULL)
1059                                         strcpy(p, info->msgid);
1060                                 else
1061                                         strcpy(p, no_msgid);
1062                                 p += strlen(p);
1063                                 break;
1064                         case 'n': /* newsgroups */
1065                                 if (info->newsgroups != NULL)
1066                                         strcpy(p, info->newsgroups);
1067                                 else
1068                                         strcpy(p, no_newsgroups);
1069                                 p += strlen(p);
1070                                 break;
1071                         case 'r': /* references */
1072                                 if (info->references != NULL)
1073                                         strcpy(p, info->references);
1074                                 else
1075                                         strcpy(p, no_references);
1076                                 p += strlen(p);
1077                                 break;
1078                         case 'F': /* file */
1079                                 strcpy(p, filename);
1080                                 p += strlen(p);
1081                                 g_free(filename);
1082                                 break;
1083                         default:
1084                                 *p = '%';
1085                                 p++;
1086                                 *p = *s;
1087                                 p++;
1088                                 break;
1089                         }
1090                         s++;
1091                 }
1092                 else {
1093                         *p = *s;
1094                         p++;
1095                         s++;
1096                 }
1097         }
1098
1099         debug_print("*** exec string \"%s\"\n", processed_cmd);
1100         return processed_cmd;
1101 }
1102 #undef STRLEN_DEFAULT
1103 #undef STRLEN_ZERO
1104
1105 /* ************************************************************ */
1106
1107 static void prefs_scoring_write(FILE * fp, GSList * prefs_scoring)
1108 {
1109         GSList * cur;
1110
1111         for (cur = prefs_scoring; cur != NULL; cur = cur->next) {
1112                 gchar *scoring_str;
1113                 ScoringProp * prop;
1114
1115                 prop = (ScoringProp *) cur->data;
1116                 scoring_str = scoringprop_to_string(prop);
1117                 if (fputs(scoring_str, fp) == EOF ||
1118                     fputc('\n', fp) == EOF) {
1119                         FILE_OP_ERROR("scoring config", "fputs || fputc");
1120                         g_free(scoring_str);
1121                         return;
1122                 }
1123                 g_free(scoring_str);
1124         }
1125 }
1126
1127 static void prefs_filtering_write(FILE * fp, GSList * prefs_scoring)
1128 {
1129         GSList * cur;
1130
1131         for (cur = prefs_scoring; cur != NULL; cur = cur->next) {
1132                 gchar *filtering_str;
1133                 FilteringProp * prop;
1134
1135                 if (NULL == (prop = (FilteringProp *) cur->data))
1136                         continue;
1137                 
1138                 if (NULL == (filtering_str = filteringprop_to_string(prop)))
1139                         continue;
1140                 
1141                 if (fputs(filtering_str, fp) == EOF ||
1142                     fputc('\n', fp) == EOF) {
1143                         FILE_OP_ERROR("filtering config", "fputs || fputc");
1144                         g_free(filtering_str);
1145                         return;
1146                 }
1147                 g_free(filtering_str);
1148         }
1149 }
1150
1151 static gboolean prefs_matcher_write_func(GNode *node, gpointer data)
1152 {
1153         FolderItem *item;
1154         FILE * fp = data;
1155         gchar * id;
1156         GSList * prefs_scoring;
1157         GSList * prefs_filtering;
1158
1159         if (node != NULL) {
1160                 item = node->data;
1161                 /* prevent from the warning */
1162                 if (item->path == NULL)
1163                         return FALSE;
1164                 id = folder_item_get_identifier(item);
1165                 if (id == NULL)
1166                         return FALSE;
1167                 prefs_scoring = item->prefs->scoring;
1168                 prefs_filtering = item->prefs->processing;
1169         }
1170         else {
1171                 item = NULL;
1172                 id = g_strdup("global"); /* because it is g_freed */
1173                 prefs_scoring = global_scoring;
1174                 prefs_filtering = global_processing;
1175         }
1176
1177         if (prefs_filtering != NULL || prefs_scoring != NULL) {
1178                 fprintf(fp, "[%s]\n", id);
1179
1180                 prefs_filtering_write(fp, prefs_filtering);
1181                 prefs_scoring_write(fp, prefs_scoring);
1182
1183                 fputc('\n', fp);
1184         }
1185
1186         g_free(id);
1187
1188         return FALSE;
1189 }
1190
1191 static void prefs_matcher_save(FILE * fp)
1192 {
1193         GList * cur;
1194
1195         for (cur = folder_get_list() ; cur != NULL ; cur = g_list_next(cur)) {
1196                 Folder *folder;
1197
1198                 folder = (Folder *) cur->data;
1199                 g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1200                                 prefs_matcher_write_func, fp);
1201         }
1202         prefs_matcher_write_func(NULL, fp);
1203 }
1204
1205
1206 void prefs_matcher_write_config(void)
1207 {
1208         gchar *rcpath;
1209         PrefFile *pfile;
1210         GSList *cur;
1211         ScoringProp * prop;
1212
1213         debug_print("Writing matcher configuration...\n");
1214
1215         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1216                              MATCHER_RC, NULL);
1217
1218         if ((pfile = prefs_write_open(rcpath)) == NULL) {
1219                 g_warning(_("failed to write configuration to file\n"));
1220                 g_free(rcpath);
1221                 return;
1222         }
1223
1224
1225         prefs_matcher_save(pfile->fp);
1226
1227         g_free(rcpath);
1228
1229         if (prefs_write_close(pfile) < 0) {
1230                 g_warning(_("failed to write configuration to file\n"));
1231                 return;
1232         }
1233 }
1234
1235 /* ******************************************************************* */
1236
1237 void prefs_matcher_read_config(void)
1238 {
1239         gchar * rcpath;
1240         FILE * f;
1241
1242         prefs_scoring_clear();
1243         prefs_filtering_clear();
1244
1245         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, MATCHER_RC, NULL);
1246         f = fopen(rcpath, "rb");
1247         g_free(rcpath);
1248
1249         if (f != NULL) {
1250                 matcher_parser_start_parsing(f);
1251                 fclose(f);
1252         }
1253         else {
1254                 /* previous version compatibily */
1255
1256                 /* printf("reading filtering\n"); */
1257                 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1258                                      FILTERING_RC, NULL);
1259                 f = fopen(rcpath, "rb");
1260                 g_free(rcpath);
1261                 
1262                 if (f != NULL) {
1263                         matcher_parser_start_parsing(f);
1264                         fclose(matcher_parserin);
1265                 }
1266                 
1267                 /* printf("reading scoring\n"); */
1268                 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1269                                      SCORING_RC, NULL);
1270                 f = fopen(rcpath, "rb");
1271                 g_free(rcpath);
1272                 
1273                 if (f != NULL) {
1274                         matcher_parser_start_parsing(f);
1275                         fclose(matcher_parserin);
1276                 }
1277         }
1278 }