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"
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"},
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"},
78 {MATCHCRITERIA_SIZE_GREATER, "size_greater"},
79 {MATCHCRITERIA_SIZE_SMALLER, "size_smaller"},
80 {MATCHCRITERIA_SIZE_EQUAL, "size_equal"},
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"},
95 {MATCHTYPE_MATCHCASE, "matchcase"},
96 {MATCHTYPE_MATCH, "match"},
97 {MATCHTYPE_REGEXPCASE, "regexpcase"},
98 {MATCHTYPE_REGEXP, "regexp"},
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"}
117 /* get_matchparser_tab_str() - used by filtering.c to translate
118 * actions to debug strings */
119 gchar * get_matchparser_tab_str(gint id)
123 for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
125 if (matchparser_tab[i].id == id)
126 return matchparser_tab[i].str;
131 /* matcher_escape_str() - escapes a string returns newly allocated escaped string */
132 gchar *matcher_escape_str(const gchar *str)
134 register const gchar *walk;
137 register char *reswalk;
142 for (escape = 0, walk = str; *walk; walk++)
143 if (*walk == '\\' || *walk == '\'' || *walk == '\"')
147 return g_strdup(str);
149 reswalk = res = g_new0(gchar, (walk - str) + escape + 1);
150 for (walk = str; *walk; walk++, reswalk++) {
151 if (*walk == '\\' || *walk == '\'' || *walk == '\"')
160 /* matcher_unescape_str() - assumes that unescaping frees up room
161 * in the string, so it returns the unescaped string in the
163 gchar *matcher_unescape_str(gchar *str)
165 gchar *tmp = alloca(strlen(str) + 1);
166 register gchar *src = tmp;
167 register gchar *dst = str;
171 for ( ; *src; src++) {
176 if (*src == 'n') /* insert control characters */
178 else if (*src == 'r')
180 else if (*src == 't')
182 else if (*src == 'r')
184 else if (*src == 'b')
186 else if (*src == 'f')
188 else if (*src == '\\' || *src == '\'' || *src == '\"')
189 /* insert \\, \' or \" */
192 /* FIXME: should perhaps escape character... */
202 /* **************** data structure allocation **************** */
204 /* matcherprop_new() - allocates a structure for one condition
206 MatcherProp * matcherprop_new(gint criteria, gchar * header,
207 gint matchtype, gchar * expr,
212 prop = g_new0(MatcherProp, 1);
213 prop->criteria = criteria;
214 if (header != NULL) {
215 prop->header = g_strdup(header);
221 prop->expr = g_strdup(expr);
226 prop->matchtype = matchtype;
234 /* matcherprop_free()
236 void matcherprop_free(MatcherProp * prop)
241 g_free(prop->header);
242 if (prop->preg != NULL) {
250 /* ****************** wrapper for file reading ************** */
252 MatcherProp * matcherprop_unquote_new(gint criteria, gchar * header,
253 gint matchtype, gchar * expr,
259 expr = matcher_unescape_str(g_strdup(expr));
264 header = matcher_unescape_str(g_strdup(header));
268 prop = matcherprop_new(criteria, header,
269 matchtype, expr, value);
278 /* ************** match ******************************/
281 /* matcherprop_string_match() - finds out if a string matches
282 * with a criterium */
283 static gboolean matcherprop_string_match(MatcherProp * prop, gchar * str)
291 switch(prop->matchtype) {
292 case MATCHTYPE_REGEXPCASE:
293 case MATCHTYPE_REGEXP:
294 if (!prop->preg && (prop->error == 0)) {
295 prop->preg = g_new0(regex_t, 1);
296 /* if regexp then don't use the escaped string */
297 if (regcomp(prop->preg, prop->expr,
298 REG_NOSUB | REG_EXTENDED
299 | ((prop->matchtype == MATCHTYPE_REGEXPCASE)
300 ? REG_ICASE : 0)) != 0) {
306 if (prop->preg == NULL)
309 if (regexec(prop->preg, str, 0, NULL, 0) == 0)
314 case MATCHTYPE_MATCH:
315 return (strstr(str, prop->expr) != NULL);
317 /* FIXME: put upper in unesc_str */
318 case MATCHTYPE_MATCHCASE:
319 str2 = alloca(strlen(prop->expr) + 1);
320 strcpy(str2, prop->expr);
322 str1 = alloca(strlen(str) + 1);
325 return (strstr(str1, str2) != NULL);
332 gboolean matcherprop_match_execute(MatcherProp * prop, MsgInfo * info)
338 file = procmsg_get_message_file(info);
343 cmd = matching_build_command(prop->expr, info);
347 retval = system(cmd);
348 debug_print("Command exit code: %d\n", retval);
351 return (retval == 0);
354 /* match a message and his headers, hlist can be NULL if you don't
355 want to use headers */
357 gboolean matcherprop_match(MatcherProp * prop, MsgInfo * info)
361 switch(prop->criteria) {
362 case MATCHCRITERIA_ALL:
364 case MATCHCRITERIA_UNREAD:
365 return MSG_IS_UNREAD(info->flags);
366 case MATCHCRITERIA_NOT_UNREAD:
367 return !MSG_IS_UNREAD(info->flags);
368 case MATCHCRITERIA_NEW:
369 return MSG_IS_NEW(info->flags);
370 case MATCHCRITERIA_NOT_NEW:
371 return !MSG_IS_NEW(info->flags);
372 case MATCHCRITERIA_MARKED:
373 return MSG_IS_MARKED(info->flags);
374 case MATCHCRITERIA_NOT_MARKED:
375 return !MSG_IS_MARKED(info->flags);
376 case MATCHCRITERIA_DELETED:
377 return MSG_IS_DELETED(info->flags);
378 case MATCHCRITERIA_NOT_DELETED:
379 return !MSG_IS_DELETED(info->flags);
380 case MATCHCRITERIA_REPLIED:
381 return MSG_IS_REPLIED(info->flags);
382 case MATCHCRITERIA_NOT_REPLIED:
383 return !MSG_IS_REPLIED(info->flags);
384 case MATCHCRITERIA_FORWARDED:
385 return MSG_IS_FORWARDED(info->flags);
386 case MATCHCRITERIA_NOT_FORWARDED:
387 return !MSG_IS_FORWARDED(info->flags);
388 case MATCHCRITERIA_SUBJECT:
389 return matcherprop_string_match(prop, info->subject);
390 case MATCHCRITERIA_NOT_SUBJECT:
391 return !matcherprop_string_match(prop, info->subject);
392 case MATCHCRITERIA_FROM:
393 return matcherprop_string_match(prop, info->from);
394 case MATCHCRITERIA_NOT_FROM:
395 return !matcherprop_string_match(prop, info->from);
396 case MATCHCRITERIA_TO:
397 return matcherprop_string_match(prop, info->to);
398 case MATCHCRITERIA_NOT_TO:
399 return !matcherprop_string_match(prop, info->to);
400 case MATCHCRITERIA_CC:
401 return matcherprop_string_match(prop, info->cc);
402 case MATCHCRITERIA_NOT_CC:
403 return !matcherprop_string_match(prop, info->cc);
404 case MATCHCRITERIA_TO_OR_CC:
405 return matcherprop_string_match(prop, info->to)
406 || matcherprop_string_match(prop, info->cc);
407 case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
408 return !(matcherprop_string_match(prop, info->to)
409 || matcherprop_string_match(prop, info->cc));
410 case MATCHCRITERIA_AGE_GREATER:
412 return ((t - info->date_t) / (60 * 60 * 24)) >= prop->value;
413 case MATCHCRITERIA_AGE_LOWER:
415 return ((t - info->date_t) / (60 * 60 * 24)) <= prop->value;
416 case MATCHCRITERIA_SCORE_GREATER:
417 return info->score >= prop->value;
418 case MATCHCRITERIA_SCORE_LOWER:
419 return info->score <= prop->value;
420 case MATCHCRITERIA_SCORE_EQUAL:
421 return info->score == prop->value;
422 case MATCHCRITERIA_SIZE_GREATER:
423 /* FIXME: info->size is an off_t */
424 return info->size > (off_t) prop->value;
425 case MATCHCRITERIA_SIZE_EQUAL:
426 /* FIXME: info->size is an off_t */
427 return info->size == (off_t) prop->value;
428 case MATCHCRITERIA_SIZE_SMALLER:
429 /* FIXME: info->size is an off_t */
430 return info->size < (off_t) prop->value;
431 case MATCHCRITERIA_NEWSGROUPS:
432 return matcherprop_string_match(prop, info->newsgroups);
433 case MATCHCRITERIA_NOT_NEWSGROUPS:
434 return !matcherprop_string_match(prop, info->newsgroups);
435 case MATCHCRITERIA_INREPLYTO:
436 return matcherprop_string_match(prop, info->inreplyto);
437 case MATCHCRITERIA_NOT_INREPLYTO:
438 return !matcherprop_string_match(prop, info->inreplyto);
439 case MATCHCRITERIA_REFERENCES:
440 return matcherprop_string_match(prop, info->references);
441 case MATCHCRITERIA_NOT_REFERENCES:
442 return !matcherprop_string_match(prop, info->references);
443 case MATCHCRITERIA_EXECUTE:
444 return matcherprop_match_execute(prop, info);
445 case MATCHCRITERIA_NOT_EXECUTE:
446 return !matcherprop_match_execute(prop, info);
452 /* ********************* MatcherList *************************** */
455 MatcherList * matcherlist_new(GSList * matchers, gboolean bool_and)
459 cond = g_new0(MatcherList, 1);
461 cond->matchers = matchers;
462 cond->bool_and = bool_and;
467 void matcherlist_free(MatcherList * cond)
471 for(l = cond->matchers ; l != NULL ; l = g_slist_next(l)) {
472 matcherprop_free((MatcherProp *) l->data);
481 static void matcherlist_skip_headers(FILE *fp)
485 while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1) {
490 matcherprop_match_one_header
491 returns TRUE if buf matchs the MatchersProp criteria
494 static gboolean matcherprop_match_one_header(MatcherProp * matcher,
500 switch(matcher->criteria) {
501 case MATCHCRITERIA_HEADER:
502 case MATCHCRITERIA_NOT_HEADER:
503 header = procheader_parse_header(buf);
506 if (procheader_headername_equal(header->name,
508 if (matcher->criteria == MATCHCRITERIA_HEADER)
509 result = matcherprop_string_match(matcher, header->body);
511 result = !matcherprop_string_match(matcher, header->body);
512 procheader_header_free(header);
516 procheader_header_free(header);
519 case MATCHCRITERIA_HEADERS_PART:
520 case MATCHCRITERIA_MESSAGE:
521 return matcherprop_string_match(matcher, buf);
522 case MATCHCRITERIA_NOT_MESSAGE:
523 case MATCHCRITERIA_NOT_HEADERS_PART:
524 return !matcherprop_string_match(matcher, buf);
530 matcherprop_criteria_header
531 returns TRUE if the headers must be matched
534 static gboolean matcherprop_criteria_headers(MatcherProp * matcher)
536 switch(matcher->criteria) {
537 case MATCHCRITERIA_HEADER:
538 case MATCHCRITERIA_NOT_HEADER:
539 case MATCHCRITERIA_HEADERS_PART:
540 case MATCHCRITERIA_NOT_HEADERS_PART:
547 static gboolean matcherprop_criteria_message(MatcherProp * matcher)
549 switch(matcher->criteria) {
550 case MATCHCRITERIA_MESSAGE:
551 case MATCHCRITERIA_NOT_MESSAGE:
559 matcherlist_match_one_header
560 returns TRUE if match should stop
563 static gboolean matcherlist_match_one_header(MatcherList * matchers,
568 for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
569 MatcherProp * matcher = (MatcherProp *) l->data;
571 if (matcherprop_criteria_headers(matcher) ||
572 matcherprop_criteria_message(matcher)) {
573 if (matcherprop_match_one_header(matcher, buf)) {
574 matcher->result = TRUE;
578 if (matcherprop_criteria_headers(matcher)) {
579 if (matcher->result) {
580 if (!matchers->bool_and)
590 matcherlist_match_headers
591 returns TRUE if one of the headers matchs the MatcherList criteria
594 static gboolean matcherlist_match_headers(MatcherList * matchers, FILE * fp)
598 while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1)
599 if (matcherlist_match_one_header(matchers, buf))
606 matcherprop_criteria_body
607 returns TRUE if the body must be matched
610 static gboolean matcherprop_criteria_body(MatcherProp * matcher)
612 switch(matcher->criteria) {
613 case MATCHCRITERIA_BODY_PART:
614 case MATCHCRITERIA_NOT_BODY_PART:
622 matcherprop_match_line
623 returns TRUE if the string matchs the MatcherProp criteria
626 static gboolean matcherprop_match_line(MatcherProp * matcher, gchar * line)
628 switch(matcher->criteria) {
629 case MATCHCRITERIA_BODY_PART:
630 case MATCHCRITERIA_MESSAGE:
631 return matcherprop_string_match(matcher, line);
632 case MATCHCRITERIA_NOT_BODY_PART:
633 case MATCHCRITERIA_NOT_MESSAGE:
634 return !matcherprop_string_match(matcher, line);
640 matcherlist_match_line
641 returns TRUE if the string matchs the MatcherList criteria
644 static gboolean matcherlist_match_line(MatcherList * matchers, gchar * line)
648 for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
649 MatcherProp * matcher = (MatcherProp *) l->data;
651 if (matcherprop_criteria_body(matcher) ||
652 matcherprop_criteria_message(matcher)) {
653 if (matcherprop_match_line(matcher, line)) {
654 matcher->result = TRUE;
658 if (matcher->result) {
659 if (!matchers->bool_and)
667 matcherlist_match_body
668 returns TRUE if one line of the body matchs the MatcherList criteria
671 static gboolean matcherlist_match_body(MatcherList * matchers, FILE * fp)
675 while (fgets(buf, sizeof(buf), fp) != NULL)
676 if (matcherlist_match_line(matchers, buf))
682 gboolean matcherlist_match_file(MatcherList * matchers, MsgInfo * info,
685 gboolean read_headers;
691 /* file need to be read ? */
693 read_headers = FALSE;
695 for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
696 MatcherProp * matcher = (MatcherProp *) l->data;
698 if (matcherprop_criteria_headers(matcher))
700 if (matcherprop_criteria_body(matcher))
702 if (matcherprop_criteria_message(matcher)) {
706 matcher->result = FALSE;
709 if (!read_headers && !read_body)
712 file = procmsg_get_message_file(info);
716 if ((fp = fopen(file, "rb")) == NULL) {
717 FILE_OP_ERROR(file, "fopen");
722 /* read the headers */
725 if (matcherlist_match_headers(matchers, fp))
729 matcherlist_skip_headers(fp);
734 matcherlist_match_body(matchers, fp);
737 for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
738 MatcherProp * matcher = (MatcherProp *) l->data;
740 if (matcherprop_criteria_headers(matcher) ||
741 matcherprop_criteria_body(matcher) ||
742 matcherprop_criteria_message(matcher)) {
743 if (matcher->result) {
744 if (!matchers->bool_and) {
750 if (matchers->bool_and) {
765 /* test a list of condition */
767 gboolean matcherlist_match(MatcherList * matchers, MsgInfo * info)
772 if (matchers->bool_and)
777 /* test the cached elements */
779 for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
780 MatcherProp * matcher = (MatcherProp *) l->data;
782 switch(matcher->criteria) {
783 case MATCHCRITERIA_ALL:
784 case MATCHCRITERIA_UNREAD:
785 case MATCHCRITERIA_NOT_UNREAD:
786 case MATCHCRITERIA_NEW:
787 case MATCHCRITERIA_NOT_NEW:
788 case MATCHCRITERIA_MARKED:
789 case MATCHCRITERIA_NOT_MARKED:
790 case MATCHCRITERIA_DELETED:
791 case MATCHCRITERIA_NOT_DELETED:
792 case MATCHCRITERIA_REPLIED:
793 case MATCHCRITERIA_NOT_REPLIED:
794 case MATCHCRITERIA_FORWARDED:
795 case MATCHCRITERIA_NOT_FORWARDED:
796 case MATCHCRITERIA_SUBJECT:
797 case MATCHCRITERIA_NOT_SUBJECT:
798 case MATCHCRITERIA_FROM:
799 case MATCHCRITERIA_NOT_FROM:
800 case MATCHCRITERIA_TO:
801 case MATCHCRITERIA_NOT_TO:
802 case MATCHCRITERIA_CC:
803 case MATCHCRITERIA_NOT_CC:
804 case MATCHCRITERIA_TO_OR_CC:
805 case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
806 case MATCHCRITERIA_AGE_GREATER:
807 case MATCHCRITERIA_AGE_LOWER:
808 case MATCHCRITERIA_NEWSGROUPS:
809 case MATCHCRITERIA_NOT_NEWSGROUPS:
810 case MATCHCRITERIA_INREPLYTO:
811 case MATCHCRITERIA_NOT_INREPLYTO:
812 case MATCHCRITERIA_REFERENCES:
813 case MATCHCRITERIA_NOT_REFERENCES:
814 case MATCHCRITERIA_SCORE_GREATER:
815 case MATCHCRITERIA_SCORE_LOWER:
816 case MATCHCRITERIA_SCORE_EQUAL:
817 case MATCHCRITERIA_SIZE_GREATER:
818 case MATCHCRITERIA_SIZE_SMALLER:
819 case MATCHCRITERIA_SIZE_EQUAL:
820 case MATCHCRITERIA_EXECUTE:
821 case MATCHCRITERIA_NOT_EXECUTE:
822 if (matcherprop_match(matcher, info)) {
823 if (!matchers->bool_and) {
828 if (matchers->bool_and) {
835 /* test the condition on the file */
837 if (matcherlist_match_file(matchers, info, result)) {
838 if (!matchers->bool_and)
842 if (matchers->bool_and)
850 gchar * matcherprop_to_string(MatcherProp * matcher)
852 gchar * matcher_str = NULL;
853 gchar * criteria_str;
854 gchar * matchtype_str;
860 for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
862 if (matchparser_tab[i].id == matcher->criteria)
863 criteria_str = matchparser_tab[i].str;
865 if (criteria_str == NULL)
868 switch(matcher->criteria) {
869 case MATCHCRITERIA_AGE_GREATER:
870 case MATCHCRITERIA_AGE_LOWER:
871 case MATCHCRITERIA_SCORE_GREATER:
872 case MATCHCRITERIA_SCORE_LOWER:
873 case MATCHCRITERIA_SCORE_EQUAL:
874 case MATCHCRITERIA_SIZE_GREATER:
875 case MATCHCRITERIA_SIZE_SMALLER:
876 case MATCHCRITERIA_SIZE_EQUAL:
877 return g_strdup_printf("%s %i", criteria_str, matcher->value);
878 case MATCHCRITERIA_ALL:
879 case MATCHCRITERIA_UNREAD:
880 case MATCHCRITERIA_NOT_UNREAD:
881 case MATCHCRITERIA_NEW:
882 case MATCHCRITERIA_NOT_NEW:
883 case MATCHCRITERIA_MARKED:
884 case MATCHCRITERIA_NOT_MARKED:
885 case MATCHCRITERIA_DELETED:
886 case MATCHCRITERIA_NOT_DELETED:
887 case MATCHCRITERIA_REPLIED:
888 case MATCHCRITERIA_NOT_REPLIED:
889 case MATCHCRITERIA_FORWARDED:
890 case MATCHCRITERIA_NOT_FORWARDED:
891 return g_strdup(criteria_str);
892 case MATCHCRITERIA_EXECUTE:
893 case MATCHCRITERIA_NOT_EXECUTE:
894 expr = matcher_escape_str(matcher->expr);
895 matcher_str = g_strdup_printf("%s \"%s\"", criteria_str, expr);
900 matchtype_str = NULL;
901 for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
903 if (matchparser_tab[i].id == matcher->matchtype)
904 matchtype_str = matchparser_tab[i].str;
907 if (matchtype_str == NULL)
910 switch (matcher->matchtype) {
911 case MATCHTYPE_MATCH:
912 case MATCHTYPE_MATCHCASE:
913 case MATCHTYPE_REGEXP:
914 case MATCHTYPE_REGEXPCASE:
915 expr = matcher_escape_str(matcher->expr);
916 header = matcher_escape_str(matcher->header);
919 g_strdup_printf("%s \"%s\" %s \"%s\"",
920 criteria_str, matcher->header,
921 matchtype_str, expr);
924 g_strdup_printf("%s %s \"%s\"", criteria_str,
925 matchtype_str, expr);
934 gchar * matcherlist_to_string(MatcherList * matchers)
942 count = g_slist_length(matchers->matchers);
943 vstr = g_new(gchar *, count + 1);
945 for (l = matchers->matchers, cur_str = vstr ; l != NULL ;
946 l = g_slist_next(l), cur_str ++) {
947 *cur_str = matcherprop_to_string((MatcherProp *) l->data);
948 if (*cur_str == NULL)
953 if (matchers->bool_and)
954 result = g_strjoinv(" & ", vstr);
956 result = g_strjoinv(" | ", vstr);
958 for(cur_str = vstr ; *cur_str != NULL ; cur_str ++)
965 #define STRLEN_ZERO(s) ((s) ? strlen(s) : 0)
966 #define STRLEN_DEFAULT(s,d) ((s) ? strlen(s) : STRLEN_ZERO(d))
967 /* matching_build_command() - preferably cmd should be unescaped */
968 gchar * matching_build_command(gchar * cmd, MsgInfo * info)
971 gchar * filename = NULL;
972 gchar * processed_cmd;
976 const gchar *const no_subject = _("(none)") ;
977 const gchar *const no_from = _("(none)") ;
978 const gchar *const no_to = _("(none)") ;
979 const gchar *const no_cc = _("(none)") ;
980 const gchar *const no_date = _("(none)") ;
981 const gchar *const no_msgid = _("(none)") ;
982 const gchar *const no_newsgroups = _("(none)") ;
983 const gchar *const no_references = _("(none)") ;
985 size = STRLEN_ZERO(cmd) + 1;
993 case 's': /* subject */
994 size += STRLEN_DEFAULT(info->subject, no_subject) - 2;
997 size += STRLEN_DEFAULT(info->from, no_from) - 2;
1000 size += STRLEN_DEFAULT(info->to, no_to) - 2;
1003 size += STRLEN_DEFAULT(info->cc, no_cc) - 2;
1005 case 'd': /* date */
1006 size += STRLEN_DEFAULT(info->date, no_date) - 2;
1008 case 'i': /* message-id */
1009 size += STRLEN_DEFAULT(info->msgid, no_msgid) - 2;
1011 case 'n': /* newsgroups */
1012 size += STRLEN_DEFAULT(info->newsgroups, no_newsgroups) - 2;
1014 case 'r': /* references */
1015 size += STRLEN_DEFAULT(info->references, no_references) - 2;
1017 case 'F': /* file */
1018 filename = folder_item_fetch_msg(info->folder,
1021 if (filename == NULL) {
1022 g_warning(_("filename is not set"));
1026 size += strlen(filename) - 2;
1035 processed_cmd = g_new0(gchar, size);
1039 while (*s != '\0') {
1047 case 's': /* subject */
1048 if (info->subject != NULL)
1049 strcpy(p, info->subject);
1051 strcpy(p, no_subject);
1054 case 'f': /* from */
1055 if (info->from != NULL)
1056 strcpy(p, info->from);
1062 if (info->to != NULL)
1063 strcpy(p, info->to);
1069 if (info->cc != NULL)
1070 strcpy(p, info->cc);
1075 case 'd': /* date */
1076 if (info->date != NULL)
1077 strcpy(p, info->date);
1082 case 'i': /* message-id */
1083 if (info->msgid != NULL)
1084 strcpy(p, info->msgid);
1086 strcpy(p, no_msgid);
1089 case 'n': /* newsgroups */
1090 if (info->newsgroups != NULL)
1091 strcpy(p, info->newsgroups);
1093 strcpy(p, no_newsgroups);
1096 case 'r': /* references */
1097 if (info->references != NULL)
1098 strcpy(p, info->references);
1100 strcpy(p, no_references);
1103 case 'F': /* file */
1104 strcpy(p, filename);
1124 debug_print("*** exec string \"%s\"\n", processed_cmd);
1125 return processed_cmd;
1127 #undef STRLEN_DEFAULT
1130 /* ************************************************************ */
1132 static void prefs_scoring_write(FILE * fp, GSList * prefs_scoring)
1136 for (cur = prefs_scoring; cur != NULL; cur = cur->next) {
1140 prop = (ScoringProp *) cur->data;
1141 scoring_str = scoringprop_to_string(prop);
1142 if (fputs(scoring_str, fp) == EOF ||
1143 fputc('\n', fp) == EOF) {
1144 FILE_OP_ERROR("scoring config", "fputs || fputc");
1145 g_free(scoring_str);
1148 g_free(scoring_str);
1152 static void prefs_filtering_write(FILE * fp, GSList * prefs_scoring)
1156 for (cur = prefs_scoring; cur != NULL; cur = cur->next) {
1157 gchar *filtering_str;
1158 FilteringProp * prop;
1160 if (NULL == (prop = (FilteringProp *) cur->data))
1163 if (NULL == (filtering_str = filteringprop_to_string(prop)))
1166 if (fputs(filtering_str, fp) == EOF ||
1167 fputc('\n', fp) == EOF) {
1168 FILE_OP_ERROR("filtering config", "fputs || fputc");
1169 g_free(filtering_str);
1172 g_free(filtering_str);
1176 static gboolean prefs_matcher_write_func(GNode *node, gpointer data)
1181 GSList * prefs_scoring;
1182 GSList * prefs_filtering;
1186 /* prevent from the warning */
1187 if (item->path == NULL)
1189 id = folder_item_get_identifier(item);
1192 prefs_scoring = item->prefs->scoring;
1193 prefs_filtering = item->prefs->processing;
1197 id = g_strdup("global"); /* because it is g_freed */
1198 prefs_scoring = global_scoring;
1199 prefs_filtering = global_processing;
1202 if (prefs_filtering != NULL || prefs_scoring != NULL) {
1203 fprintf(fp, "[%s]\n", id);
1205 prefs_filtering_write(fp, prefs_filtering);
1206 prefs_scoring_write(fp, prefs_scoring);
1216 static void prefs_matcher_save(FILE * fp)
1220 for (cur = folder_get_list() ; cur != NULL ; cur = g_list_next(cur)) {
1223 folder = (Folder *) cur->data;
1224 g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1225 prefs_matcher_write_func, fp);
1227 prefs_matcher_write_func(NULL, fp);
1231 void prefs_matcher_write_config(void)
1236 debug_print("Writing matcher configuration...\n");
1238 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1241 if ((pfile = prefs_write_open(rcpath)) == NULL) {
1242 g_warning(_("failed to write configuration to file\n"));
1248 prefs_matcher_save(pfile->fp);
1252 if (prefs_write_close(pfile) < 0) {
1253 g_warning(_("failed to write configuration to file\n"));
1258 /* ******************************************************************* */
1260 void prefs_matcher_read_config(void)
1265 prefs_scoring_clear();
1266 prefs_filtering_clear();
1268 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, MATCHER_RC, NULL);
1269 f = fopen(rcpath, "rb");
1273 matcher_parser_start_parsing(f);
1277 /* previous version compatibily */
1279 /* printf("reading filtering\n"); */
1280 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1281 FILTERING_RC, NULL);
1282 f = fopen(rcpath, "rb");
1286 matcher_parser_start_parsing(f);
1287 fclose(matcher_parserin);
1290 /* printf("reading scoring\n"); */
1291 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1293 f = fopen(rcpath, "rb");
1297 matcher_parser_start_parsing(f);
1298 fclose(matcher_parserin);