2 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3 * Copyright (C) 2002 by the Sylpheed Claws Team and Hiroyuki Yamamoto
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.
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.
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.
26 #include "procheader.h"
29 #include "matcher_parser.h"
30 #include "prefs_gtk.h"
37 typedef struct _MatchParser MatchParser;
39 static MatchParser matchparser_tab[] = {
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 {MATCHCRITERIA_LOCKED, "locked"},
55 {MATCHCRITERIA_NOT_LOCKED, "~locked"},
56 {MATCHCRITERIA_COLORLABEL, "colorlabel"},
57 {MATCHCRITERIA_NOT_COLORLABEL, "~colorlabel"},
60 {MATCHCRITERIA_SUBJECT, "subject"},
61 {MATCHCRITERIA_NOT_SUBJECT, "~subject"},
62 {MATCHCRITERIA_FROM, "from"},
63 {MATCHCRITERIA_NOT_FROM, "~from"},
64 {MATCHCRITERIA_TO, "to"},
65 {MATCHCRITERIA_NOT_TO, "~to"},
66 {MATCHCRITERIA_CC, "cc"},
67 {MATCHCRITERIA_NOT_CC, "~cc"},
68 {MATCHCRITERIA_TO_OR_CC, "to_or_cc"},
69 {MATCHCRITERIA_NOT_TO_AND_NOT_CC, "~to_or_cc"},
70 {MATCHCRITERIA_AGE_GREATER, "age_greater"},
71 {MATCHCRITERIA_AGE_LOWER, "age_lower"},
72 {MATCHCRITERIA_NEWSGROUPS, "newsgroups"},
73 {MATCHCRITERIA_NOT_NEWSGROUPS, "~newsgroups"},
74 {MATCHCRITERIA_INREPLYTO, "inreplyto"},
75 {MATCHCRITERIA_NOT_INREPLYTO, "~inreplyto"},
76 {MATCHCRITERIA_REFERENCES, "references"},
77 {MATCHCRITERIA_NOT_REFERENCES, "~references"},
78 {MATCHCRITERIA_SCORE_GREATER, "score_greater"},
79 {MATCHCRITERIA_SCORE_LOWER, "score_lower"},
80 {MATCHCRITERIA_SCORE_EQUAL, "score_equal"},
82 {MATCHCRITERIA_SIZE_GREATER, "size_greater"},
83 {MATCHCRITERIA_SIZE_SMALLER, "size_smaller"},
84 {MATCHCRITERIA_SIZE_EQUAL, "size_equal"},
86 /* content have to be read */
87 {MATCHCRITERIA_HEADER, "header"},
88 {MATCHCRITERIA_NOT_HEADER, "~header"},
89 {MATCHCRITERIA_HEADERS_PART, "headers_part"},
90 {MATCHCRITERIA_NOT_HEADERS_PART, "~headers_part"},
91 {MATCHCRITERIA_MESSAGE, "message"},
92 {MATCHCRITERIA_NOT_MESSAGE, "~message"},
93 {MATCHCRITERIA_BODY_PART, "body_part"},
94 {MATCHCRITERIA_NOT_BODY_PART, "~body_part"},
95 {MATCHCRITERIA_EXECUTE, "execute"},
96 {MATCHCRITERIA_NOT_EXECUTE, "~execute"},
99 {MATCHTYPE_MATCHCASE, "matchcase"},
100 {MATCHTYPE_MATCH, "match"},
101 {MATCHTYPE_REGEXPCASE, "regexpcase"},
102 {MATCHTYPE_REGEXP, "regexp"},
105 {MATCHACTION_SCORE, "score"},
106 {MATCHACTION_MOVE, "move"},
107 {MATCHACTION_COPY, "copy"},
108 {MATCHACTION_DELETE, "delete"},
109 {MATCHACTION_MARK, "mark"},
110 {MATCHACTION_UNMARK, "unmark"},
111 {MATCHACTION_MARK_AS_READ, "mark_as_read"},
112 {MATCHACTION_MARK_AS_UNREAD, "mark_as_unread"},
113 {MATCHACTION_FORWARD, "forward"},
114 {MATCHACTION_FORWARD_AS_ATTACHMENT, "forward_as_attachment"},
115 {MATCHACTION_EXECUTE, "execute"},
116 {MATCHACTION_COLOR, "color"},
117 {MATCHACTION_REDIRECT, "redirect"},
118 {MATCHACTION_DELETE_ON_SERVER, "delete_on_server"}
121 /* get_matchparser_tab_str() - used by filtering.c to translate
122 * actions to debug strings */
123 gchar * get_matchparser_tab_str(gint id)
127 for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
129 if (matchparser_tab[i].id == id)
130 return matchparser_tab[i].str;
135 /* matcher_escape_str() - escapes a string returns newly allocated escaped string */
136 gchar *matcher_escape_str(const gchar *str)
138 register const gchar *walk;
141 register char *reswalk;
146 for (escape = 0, walk = str; *walk; walk++)
147 if (*walk == '\\' || *walk == '\'' || *walk == '\"')
151 return g_strdup(str);
153 reswalk = res = g_new0(gchar, (walk - str) + escape + 1);
154 for (walk = str; *walk; walk++, reswalk++) {
155 if (*walk == '\\' || *walk == '\'' || *walk == '\"')
164 /* matcher_unescape_str() - assumes that unescaping frees up room
165 * in the string, so it returns the unescaped string in the
167 gchar *matcher_unescape_str(gchar *str)
169 gchar *tmp = alloca(strlen(str) + 1);
170 register gchar *src = tmp;
171 register gchar *dst = str;
175 for ( ; *src; src++) {
180 if (*src == 'n') /* insert control characters */
182 else if (*src == 'r')
184 else if (*src == 't')
186 else if (*src == 'r')
188 else if (*src == 'b')
190 else if (*src == 'f')
192 else if (*src == '\\' || *src == '\'' || *src == '\"')
193 /* insert \\, \' or \" */
196 /* FIXME: should perhaps escape character... */
206 /* **************** data structure allocation **************** */
208 /* matcherprop_new() - allocates a structure for one condition
210 MatcherProp * matcherprop_new(gint criteria, gchar * header,
211 gint matchtype, gchar * expr,
216 prop = g_new0(MatcherProp, 1);
217 prop->criteria = criteria;
218 if (header != NULL) {
219 prop->header = g_strdup(header);
225 prop->expr = g_strdup(expr);
230 prop->matchtype = matchtype;
238 /* matcherprop_free()
240 void matcherprop_free(MatcherProp * prop)
245 g_free(prop->header);
246 if (prop->preg != NULL) {
253 MatcherProp *matcherprop_copy(MatcherProp *src)
255 MatcherProp *prop = g_new0(MatcherProp, 1);
256 prop->criteria = src->criteria;
258 prop->header = g_strdup(src->header);
262 prop->expr = g_strdup(src->expr);
265 prop->matchtype = src->matchtype;
267 prop->preg = NULL; /* will be re-evaluated */
268 prop->value = src->value;
269 prop->error = src->error;
273 /* ****************** wrapper for file reading ************** */
275 MatcherProp * matcherprop_unquote_new(gint criteria, gchar * header,
276 gint matchtype, gchar * expr,
282 expr = matcher_unescape_str(g_strdup(expr));
287 header = matcher_unescape_str(g_strdup(header));
291 prop = matcherprop_new(criteria, header,
292 matchtype, expr, value);
301 /* ************** match ******************************/
304 /* matcherprop_string_match() - finds out if a string matches
305 * with a criterium */
306 static gboolean matcherprop_string_match(MatcherProp * prop, gchar * str)
314 switch(prop->matchtype) {
315 case MATCHTYPE_REGEXPCASE:
316 case MATCHTYPE_REGEXP:
317 if (!prop->preg && (prop->error == 0)) {
318 prop->preg = g_new0(regex_t, 1);
319 /* if regexp then don't use the escaped string */
320 if (regcomp(prop->preg, prop->expr,
321 REG_NOSUB | REG_EXTENDED
322 | ((prop->matchtype == MATCHTYPE_REGEXPCASE)
323 ? REG_ICASE : 0)) != 0) {
329 if (prop->preg == NULL)
332 if (regexec(prop->preg, str, 0, NULL, 0) == 0)
337 case MATCHTYPE_MATCH:
338 return (strstr(str, prop->expr) != NULL);
340 /* FIXME: put upper in unesc_str */
341 case MATCHTYPE_MATCHCASE:
342 str2 = alloca(strlen(prop->expr) + 1);
343 strcpy(str2, prop->expr);
345 str1 = alloca(strlen(str) + 1);
348 return (strstr(str1, str2) != NULL);
355 gboolean matcherprop_match_execute(MatcherProp * prop, MsgInfo * info)
361 file = procmsg_get_message_file(info);
366 cmd = matching_build_command(prop->expr, info);
370 retval = system(cmd);
371 debug_print("Command exit code: %d\n", retval);
374 return (retval == 0);
377 /* match a message and his headers, hlist can be NULL if you don't
378 want to use headers */
380 gboolean matcherprop_match(MatcherProp * prop, MsgInfo * info)
384 switch(prop->criteria) {
385 case MATCHCRITERIA_ALL:
387 case MATCHCRITERIA_UNREAD:
388 return MSG_IS_UNREAD(info->flags);
389 case MATCHCRITERIA_NOT_UNREAD:
390 return !MSG_IS_UNREAD(info->flags);
391 case MATCHCRITERIA_NEW:
392 return MSG_IS_NEW(info->flags);
393 case MATCHCRITERIA_NOT_NEW:
394 return !MSG_IS_NEW(info->flags);
395 case MATCHCRITERIA_MARKED:
396 return MSG_IS_MARKED(info->flags);
397 case MATCHCRITERIA_NOT_MARKED:
398 return !MSG_IS_MARKED(info->flags);
399 case MATCHCRITERIA_DELETED:
400 return MSG_IS_DELETED(info->flags);
401 case MATCHCRITERIA_NOT_DELETED:
402 return !MSG_IS_DELETED(info->flags);
403 case MATCHCRITERIA_REPLIED:
404 return MSG_IS_REPLIED(info->flags);
405 case MATCHCRITERIA_NOT_REPLIED:
406 return !MSG_IS_REPLIED(info->flags);
407 case MATCHCRITERIA_FORWARDED:
408 return MSG_IS_FORWARDED(info->flags);
409 case MATCHCRITERIA_NOT_FORWARDED:
410 return !MSG_IS_FORWARDED(info->flags);
411 case MATCHCRITERIA_LOCKED:
412 return MSG_IS_LOCKED(info->flags);
413 case MATCHCRITERIA_NOT_LOCKED:
414 return !MSG_IS_LOCKED(info->flags);
415 case MATCHCRITERIA_COLORLABEL:
416 return MSG_GET_COLORLABEL_VALUE(info->flags) == prop->value;
417 case MATCHCRITERIA_NOT_COLORLABEL:
418 return MSG_GET_COLORLABEL_VALUE(info->flags) != prop->value;
419 case MATCHCRITERIA_SUBJECT:
420 return matcherprop_string_match(prop, info->subject);
421 case MATCHCRITERIA_NOT_SUBJECT:
422 return !matcherprop_string_match(prop, info->subject);
423 case MATCHCRITERIA_FROM:
424 return matcherprop_string_match(prop, info->from);
425 case MATCHCRITERIA_NOT_FROM:
426 return !matcherprop_string_match(prop, info->from);
427 case MATCHCRITERIA_TO:
428 return matcherprop_string_match(prop, info->to);
429 case MATCHCRITERIA_NOT_TO:
430 return !matcherprop_string_match(prop, info->to);
431 case MATCHCRITERIA_CC:
432 return matcherprop_string_match(prop, info->cc);
433 case MATCHCRITERIA_NOT_CC:
434 return !matcherprop_string_match(prop, info->cc);
435 case MATCHCRITERIA_TO_OR_CC:
436 return matcherprop_string_match(prop, info->to)
437 || matcherprop_string_match(prop, info->cc);
438 case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
439 return !(matcherprop_string_match(prop, info->to)
440 || matcherprop_string_match(prop, info->cc));
441 case MATCHCRITERIA_AGE_GREATER:
443 return ((t - info->date_t) / (60 * 60 * 24)) >= prop->value;
444 case MATCHCRITERIA_AGE_LOWER:
446 return ((t - info->date_t) / (60 * 60 * 24)) <= prop->value;
447 case MATCHCRITERIA_SCORE_GREATER:
448 return info->score >= prop->value;
449 case MATCHCRITERIA_SCORE_LOWER:
450 return info->score <= prop->value;
451 case MATCHCRITERIA_SCORE_EQUAL:
452 return info->score == prop->value;
453 case MATCHCRITERIA_SIZE_GREATER:
454 /* FIXME: info->size is an off_t */
455 return info->size > (off_t) prop->value;
456 case MATCHCRITERIA_SIZE_EQUAL:
457 /* FIXME: info->size is an off_t */
458 return info->size == (off_t) prop->value;
459 case MATCHCRITERIA_SIZE_SMALLER:
460 /* FIXME: info->size is an off_t */
461 return info->size < (off_t) prop->value;
462 case MATCHCRITERIA_NEWSGROUPS:
463 return matcherprop_string_match(prop, info->newsgroups);
464 case MATCHCRITERIA_NOT_NEWSGROUPS:
465 return !matcherprop_string_match(prop, info->newsgroups);
466 case MATCHCRITERIA_INREPLYTO:
467 return matcherprop_string_match(prop, info->inreplyto);
468 case MATCHCRITERIA_NOT_INREPLYTO:
469 return !matcherprop_string_match(prop, info->inreplyto);
470 case MATCHCRITERIA_REFERENCES:
471 return matcherprop_string_match(prop, info->references);
472 case MATCHCRITERIA_NOT_REFERENCES:
473 return !matcherprop_string_match(prop, info->references);
474 case MATCHCRITERIA_EXECUTE:
475 return matcherprop_match_execute(prop, info);
476 case MATCHCRITERIA_NOT_EXECUTE:
477 return !matcherprop_match_execute(prop, info);
483 /* ********************* MatcherList *************************** */
486 MatcherList * matcherlist_new(GSList * matchers, gboolean bool_and)
490 cond = g_new0(MatcherList, 1);
492 cond->matchers = matchers;
493 cond->bool_and = bool_and;
498 void matcherlist_free(MatcherList * cond)
502 for(l = cond->matchers ; l != NULL ; l = g_slist_next(l)) {
503 matcherprop_free((MatcherProp *) l->data);
512 static void matcherlist_skip_headers(FILE *fp)
516 while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1) {
521 matcherprop_match_one_header
522 returns TRUE if buf matchs the MatchersProp criteria
525 static gboolean matcherprop_match_one_header(MatcherProp * matcher,
531 switch(matcher->criteria) {
532 case MATCHCRITERIA_HEADER:
533 case MATCHCRITERIA_NOT_HEADER:
534 header = procheader_parse_header(buf);
537 if (procheader_headername_equal(header->name,
539 if (matcher->criteria == MATCHCRITERIA_HEADER)
540 result = matcherprop_string_match(matcher, header->body);
542 result = !matcherprop_string_match(matcher, header->body);
543 procheader_header_free(header);
547 procheader_header_free(header);
550 case MATCHCRITERIA_HEADERS_PART:
551 case MATCHCRITERIA_MESSAGE:
552 return matcherprop_string_match(matcher, buf);
553 case MATCHCRITERIA_NOT_MESSAGE:
554 case MATCHCRITERIA_NOT_HEADERS_PART:
555 return !matcherprop_string_match(matcher, buf);
561 matcherprop_criteria_header
562 returns TRUE if the headers must be matched
565 static gboolean matcherprop_criteria_headers(MatcherProp * matcher)
567 switch(matcher->criteria) {
568 case MATCHCRITERIA_HEADER:
569 case MATCHCRITERIA_NOT_HEADER:
570 case MATCHCRITERIA_HEADERS_PART:
571 case MATCHCRITERIA_NOT_HEADERS_PART:
578 static gboolean matcherprop_criteria_message(MatcherProp * matcher)
580 switch(matcher->criteria) {
581 case MATCHCRITERIA_MESSAGE:
582 case MATCHCRITERIA_NOT_MESSAGE:
590 matcherlist_match_one_header
591 returns TRUE if match should stop
594 static gboolean matcherlist_match_one_header(MatcherList * matchers,
599 for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
600 MatcherProp * matcher = (MatcherProp *) l->data;
602 if (matcherprop_criteria_headers(matcher) ||
603 matcherprop_criteria_message(matcher)) {
604 if (matcherprop_match_one_header(matcher, buf)) {
605 matcher->result = TRUE;
609 if (matcherprop_criteria_headers(matcher)) {
610 if (matcher->result) {
611 if (!matchers->bool_and)
621 matcherlist_match_headers
622 returns TRUE if one of the headers matchs the MatcherList criteria
625 static gboolean matcherlist_match_headers(MatcherList * matchers, FILE * fp)
629 while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1)
630 if (matcherlist_match_one_header(matchers, buf))
637 matcherprop_criteria_body
638 returns TRUE if the body must be matched
641 static gboolean matcherprop_criteria_body(MatcherProp * matcher)
643 switch(matcher->criteria) {
644 case MATCHCRITERIA_BODY_PART:
645 case MATCHCRITERIA_NOT_BODY_PART:
653 matcherprop_match_line
654 returns TRUE if the string matchs the MatcherProp criteria
657 static gboolean matcherprop_match_line(MatcherProp * matcher, gchar * line)
659 switch(matcher->criteria) {
660 case MATCHCRITERIA_BODY_PART:
661 case MATCHCRITERIA_MESSAGE:
662 return matcherprop_string_match(matcher, line);
663 case MATCHCRITERIA_NOT_BODY_PART:
664 case MATCHCRITERIA_NOT_MESSAGE:
665 return !matcherprop_string_match(matcher, line);
671 matcherlist_match_line
672 returns TRUE if the string matchs the MatcherList criteria
675 static gboolean matcherlist_match_line(MatcherList * matchers, gchar * line)
679 for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
680 MatcherProp * matcher = (MatcherProp *) l->data;
682 if (matcherprop_criteria_body(matcher) ||
683 matcherprop_criteria_message(matcher)) {
684 if (matcherprop_match_line(matcher, line)) {
685 matcher->result = TRUE;
689 if (matcher->result) {
690 if (!matchers->bool_and)
698 matcherlist_match_body
699 returns TRUE if one line of the body matchs the MatcherList criteria
702 static gboolean matcherlist_match_body(MatcherList * matchers, FILE * fp)
706 while (fgets(buf, sizeof(buf), fp) != NULL)
707 if (matcherlist_match_line(matchers, buf))
713 gboolean matcherlist_match_file(MatcherList * matchers, MsgInfo * info,
716 gboolean read_headers;
722 /* file need to be read ? */
724 read_headers = FALSE;
726 for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
727 MatcherProp * matcher = (MatcherProp *) l->data;
729 if (matcherprop_criteria_headers(matcher))
731 if (matcherprop_criteria_body(matcher))
733 if (matcherprop_criteria_message(matcher)) {
737 matcher->result = FALSE;
740 if (!read_headers && !read_body)
743 file = procmsg_get_message_file(info);
747 if ((fp = fopen(file, "rb")) == NULL) {
748 FILE_OP_ERROR(file, "fopen");
753 /* read the headers */
756 if (matcherlist_match_headers(matchers, fp))
760 matcherlist_skip_headers(fp);
765 matcherlist_match_body(matchers, fp);
768 for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
769 MatcherProp * matcher = (MatcherProp *) l->data;
771 if (matcherprop_criteria_headers(matcher) ||
772 matcherprop_criteria_body(matcher) ||
773 matcherprop_criteria_message(matcher)) {
774 if (matcher->result) {
775 if (!matchers->bool_and) {
781 if (matchers->bool_and) {
796 /* test a list of condition */
798 gboolean matcherlist_match(MatcherList * matchers, MsgInfo * info)
803 if (matchers->bool_and)
808 /* test the cached elements */
810 for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
811 MatcherProp * matcher = (MatcherProp *) l->data;
813 switch(matcher->criteria) {
814 case MATCHCRITERIA_ALL:
815 case MATCHCRITERIA_UNREAD:
816 case MATCHCRITERIA_NOT_UNREAD:
817 case MATCHCRITERIA_NEW:
818 case MATCHCRITERIA_NOT_NEW:
819 case MATCHCRITERIA_MARKED:
820 case MATCHCRITERIA_NOT_MARKED:
821 case MATCHCRITERIA_DELETED:
822 case MATCHCRITERIA_NOT_DELETED:
823 case MATCHCRITERIA_REPLIED:
824 case MATCHCRITERIA_NOT_REPLIED:
825 case MATCHCRITERIA_FORWARDED:
826 case MATCHCRITERIA_NOT_FORWARDED:
827 case MATCHCRITERIA_LOCKED:
828 case MATCHCRITERIA_NOT_LOCKED:
829 case MATCHCRITERIA_COLORLABEL:
830 case MATCHCRITERIA_NOT_COLORLABEL:
831 case MATCHCRITERIA_SUBJECT:
832 case MATCHCRITERIA_NOT_SUBJECT:
833 case MATCHCRITERIA_FROM:
834 case MATCHCRITERIA_NOT_FROM:
835 case MATCHCRITERIA_TO:
836 case MATCHCRITERIA_NOT_TO:
837 case MATCHCRITERIA_CC:
838 case MATCHCRITERIA_NOT_CC:
839 case MATCHCRITERIA_TO_OR_CC:
840 case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
841 case MATCHCRITERIA_AGE_GREATER:
842 case MATCHCRITERIA_AGE_LOWER:
843 case MATCHCRITERIA_NEWSGROUPS:
844 case MATCHCRITERIA_NOT_NEWSGROUPS:
845 case MATCHCRITERIA_INREPLYTO:
846 case MATCHCRITERIA_NOT_INREPLYTO:
847 case MATCHCRITERIA_REFERENCES:
848 case MATCHCRITERIA_NOT_REFERENCES:
849 case MATCHCRITERIA_SCORE_GREATER:
850 case MATCHCRITERIA_SCORE_LOWER:
851 case MATCHCRITERIA_SCORE_EQUAL:
852 case MATCHCRITERIA_SIZE_GREATER:
853 case MATCHCRITERIA_SIZE_SMALLER:
854 case MATCHCRITERIA_SIZE_EQUAL:
855 case MATCHCRITERIA_EXECUTE:
856 case MATCHCRITERIA_NOT_EXECUTE:
857 if (matcherprop_match(matcher, info)) {
858 if (!matchers->bool_and) {
863 if (matchers->bool_and) {
870 /* test the condition on the file */
872 if (matcherlist_match_file(matchers, info, result)) {
873 if (!matchers->bool_and)
877 if (matchers->bool_and)
885 gchar * matcherprop_to_string(MatcherProp * matcher)
887 gchar * matcher_str = NULL;
888 gchar * criteria_str;
889 gchar * matchtype_str;
895 for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
897 if (matchparser_tab[i].id == matcher->criteria)
898 criteria_str = matchparser_tab[i].str;
900 if (criteria_str == NULL)
903 switch(matcher->criteria) {
904 case MATCHCRITERIA_AGE_GREATER:
905 case MATCHCRITERIA_AGE_LOWER:
906 case MATCHCRITERIA_SCORE_GREATER:
907 case MATCHCRITERIA_SCORE_LOWER:
908 case MATCHCRITERIA_SCORE_EQUAL:
909 case MATCHCRITERIA_SIZE_GREATER:
910 case MATCHCRITERIA_SIZE_SMALLER:
911 case MATCHCRITERIA_SIZE_EQUAL:
912 case MATCHCRITERIA_COLORLABEL:
913 case MATCHCRITERIA_NOT_COLORLABEL:
914 return g_strdup_printf("%s %i", criteria_str, matcher->value);
915 case MATCHCRITERIA_ALL:
916 case MATCHCRITERIA_UNREAD:
917 case MATCHCRITERIA_NOT_UNREAD:
918 case MATCHCRITERIA_NEW:
919 case MATCHCRITERIA_NOT_NEW:
920 case MATCHCRITERIA_MARKED:
921 case MATCHCRITERIA_NOT_MARKED:
922 case MATCHCRITERIA_DELETED:
923 case MATCHCRITERIA_NOT_DELETED:
924 case MATCHCRITERIA_REPLIED:
925 case MATCHCRITERIA_NOT_REPLIED:
926 case MATCHCRITERIA_FORWARDED:
927 case MATCHCRITERIA_NOT_FORWARDED:
928 case MATCHCRITERIA_LOCKED:
929 case MATCHCRITERIA_NOT_LOCKED:
930 return g_strdup(criteria_str);
931 case MATCHCRITERIA_EXECUTE:
932 case MATCHCRITERIA_NOT_EXECUTE:
933 expr = matcher_escape_str(matcher->expr);
934 matcher_str = g_strdup_printf("%s \"%s\"", criteria_str, expr);
939 matchtype_str = NULL;
940 for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
942 if (matchparser_tab[i].id == matcher->matchtype)
943 matchtype_str = matchparser_tab[i].str;
946 if (matchtype_str == NULL)
949 switch (matcher->matchtype) {
950 case MATCHTYPE_MATCH:
951 case MATCHTYPE_MATCHCASE:
952 case MATCHTYPE_REGEXP:
953 case MATCHTYPE_REGEXPCASE:
954 expr = matcher_escape_str(matcher->expr);
955 header = matcher_escape_str(matcher->header);
958 g_strdup_printf("%s \"%s\" %s \"%s\"",
959 criteria_str, matcher->header,
960 matchtype_str, expr);
963 g_strdup_printf("%s %s \"%s\"", criteria_str,
964 matchtype_str, expr);
973 gchar * matcherlist_to_string(MatcherList * matchers)
979 gchar * result = NULL;
981 count = g_slist_length(matchers->matchers);
982 vstr = g_new(gchar *, count + 1);
984 for (l = matchers->matchers, cur_str = vstr ; l != NULL ;
985 l = g_slist_next(l), cur_str ++) {
986 *cur_str = matcherprop_to_string((MatcherProp *) l->data);
987 if (*cur_str == NULL)
992 if (matchers->bool_and)
993 result = g_strjoinv(" & ", vstr);
995 result = g_strjoinv(" | ", vstr);
997 for(cur_str = vstr ; *cur_str != NULL ; cur_str ++)
1004 #define STRLEN_ZERO(s) ((s) ? strlen(s) : 0)
1005 #define STRLEN_DEFAULT(s,d) ((s) ? strlen(s) : STRLEN_ZERO(d))
1006 /* matching_build_command() - preferably cmd should be unescaped */
1007 gchar * matching_build_command(gchar * cmd, MsgInfo * info)
1010 gchar * filename = NULL;
1011 gchar * processed_cmd;
1015 const gchar *const no_subject = _("(none)") ;
1016 const gchar *const no_from = _("(none)") ;
1017 const gchar *const no_to = _("(none)") ;
1018 const gchar *const no_cc = _("(none)") ;
1019 const gchar *const no_date = _("(none)") ;
1020 const gchar *const no_msgid = _("(none)") ;
1021 const gchar *const no_newsgroups = _("(none)") ;
1022 const gchar *const no_references = _("(none)") ;
1024 size = STRLEN_ZERO(cmd) + 1;
1025 while (*s != '\0') {
1032 case 's': /* subject */
1033 size += STRLEN_DEFAULT(info->subject, no_subject) - 2;
1035 case 'f': /* from */
1036 size += STRLEN_DEFAULT(info->from, no_from) - 2;
1039 size += STRLEN_DEFAULT(info->to, no_to) - 2;
1042 size += STRLEN_DEFAULT(info->cc, no_cc) - 2;
1044 case 'd': /* date */
1045 size += STRLEN_DEFAULT(info->date, no_date) - 2;
1047 case 'i': /* message-id */
1048 size += STRLEN_DEFAULT(info->msgid, no_msgid) - 2;
1050 case 'n': /* newsgroups */
1051 size += STRLEN_DEFAULT(info->newsgroups, no_newsgroups) - 2;
1053 case 'r': /* references */
1054 size += STRLEN_DEFAULT(info->references, no_references) - 2;
1056 case 'F': /* file */
1057 filename = folder_item_fetch_msg(info->folder,
1060 if (filename == NULL) {
1061 g_warning("filename is not set");
1065 size += strlen(filename) - 2;
1074 processed_cmd = g_new0(gchar, size);
1078 while (*s != '\0') {
1086 case 's': /* subject */
1087 if (info->subject != NULL)
1088 strcpy(p, info->subject);
1090 strcpy(p, no_subject);
1093 case 'f': /* from */
1094 if (info->from != NULL)
1095 strcpy(p, info->from);
1101 if (info->to != NULL)
1102 strcpy(p, info->to);
1108 if (info->cc != NULL)
1109 strcpy(p, info->cc);
1114 case 'd': /* date */
1115 if (info->date != NULL)
1116 strcpy(p, info->date);
1121 case 'i': /* message-id */
1122 if (info->msgid != NULL)
1123 strcpy(p, info->msgid);
1125 strcpy(p, no_msgid);
1128 case 'n': /* newsgroups */
1129 if (info->newsgroups != NULL)
1130 strcpy(p, info->newsgroups);
1132 strcpy(p, no_newsgroups);
1135 case 'r': /* references */
1136 if (info->references != NULL)
1137 strcpy(p, info->references);
1139 strcpy(p, no_references);
1142 case 'F': /* file */
1143 strcpy(p, filename);
1163 debug_print("*** exec string \"%s\"\n", processed_cmd);
1164 return processed_cmd;
1166 #undef STRLEN_DEFAULT
1169 /* ************************************************************ */
1171 static void prefs_scoring_write(FILE * fp, GSList * prefs_scoring)
1175 for (cur = prefs_scoring; cur != NULL; cur = cur->next) {
1179 prop = (ScoringProp *) cur->data;
1180 scoring_str = scoringprop_to_string(prop);
1181 if (fputs(scoring_str, fp) == EOF ||
1182 fputc('\n', fp) == EOF) {
1183 FILE_OP_ERROR("scoring config", "fputs || fputc");
1184 g_free(scoring_str);
1187 g_free(scoring_str);
1191 static void prefs_filtering_write(FILE * fp, GSList * prefs_scoring)
1195 for (cur = prefs_scoring; cur != NULL; cur = cur->next) {
1196 gchar *filtering_str;
1197 FilteringProp * prop;
1199 if (NULL == (prop = (FilteringProp *) cur->data))
1202 if (NULL == (filtering_str = filteringprop_to_string(prop)))
1205 if (fputs(filtering_str, fp) == EOF ||
1206 fputc('\n', fp) == EOF) {
1207 FILE_OP_ERROR("filtering config", "fputs || fputc");
1208 g_free(filtering_str);
1211 g_free(filtering_str);
1215 static gboolean prefs_matcher_write_func(GNode *node, gpointer data)
1220 GSList * prefs_scoring;
1221 GSList * prefs_filtering;
1225 /* prevent from the warning */
1226 if (item->path == NULL)
1228 id = folder_item_get_identifier(item);
1231 prefs_scoring = item->prefs->scoring;
1232 prefs_filtering = item->prefs->processing;
1236 id = g_strdup("global"); /* because it is g_freed */
1237 prefs_scoring = global_scoring;
1238 prefs_filtering = global_processing;
1241 if (prefs_filtering != NULL || prefs_scoring != NULL) {
1242 fprintf(fp, "[%s]\n", id);
1244 prefs_filtering_write(fp, prefs_filtering);
1245 prefs_scoring_write(fp, prefs_scoring);
1255 static void prefs_matcher_save(FILE * fp)
1259 for (cur = folder_get_list() ; cur != NULL ; cur = g_list_next(cur)) {
1262 folder = (Folder *) cur->data;
1263 g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1264 prefs_matcher_write_func, fp);
1266 prefs_matcher_write_func(NULL, fp);
1270 void prefs_matcher_write_config(void)
1275 debug_print("Writing matcher configuration...\n");
1277 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1280 if ((pfile = prefs_write_open(rcpath)) == NULL) {
1281 g_warning("failed to write configuration to file\n");
1287 prefs_matcher_save(pfile->fp);
1291 if (prefs_write_close(pfile) < 0) {
1292 g_warning("failed to write configuration to file\n");
1297 /* ******************************************************************* */
1299 void prefs_matcher_read_config(void)
1304 prefs_scoring_clear();
1305 prefs_filtering_clear();
1307 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, MATCHER_RC, NULL);
1308 f = fopen(rcpath, "rb");
1312 matcher_parser_start_parsing(f);
1316 /* previous version compatibily */
1318 /* printf("reading filtering\n"); */
1319 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1320 FILTERING_RC, NULL);
1321 f = fopen(rcpath, "rb");
1325 matcher_parser_start_parsing(f);
1326 fclose(matcher_parserin);
1329 /* printf("reading scoring\n"); */
1330 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1332 f = fopen(rcpath, "rb");
1336 matcher_parser_start_parsing(f);
1337 fclose(matcher_parserin);