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"},
58 {MATCHCRITERIA_SUBJECT, "subject"},
59 {MATCHCRITERIA_NOT_SUBJECT, "~subject"},
60 {MATCHCRITERIA_FROM, "from"},
61 {MATCHCRITERIA_NOT_FROM, "~from"},
62 {MATCHCRITERIA_TO, "to"},
63 {MATCHCRITERIA_NOT_TO, "~to"},
64 {MATCHCRITERIA_CC, "cc"},
65 {MATCHCRITERIA_NOT_CC, "~cc"},
66 {MATCHCRITERIA_TO_OR_CC, "to_or_cc"},
67 {MATCHCRITERIA_NOT_TO_AND_NOT_CC, "~to_or_cc"},
68 {MATCHCRITERIA_AGE_GREATER, "age_greater"},
69 {MATCHCRITERIA_AGE_LOWER, "age_lower"},
70 {MATCHCRITERIA_NEWSGROUPS, "newsgroups"},
71 {MATCHCRITERIA_NOT_NEWSGROUPS, "~newsgroups"},
72 {MATCHCRITERIA_INREPLYTO, "inreplyto"},
73 {MATCHCRITERIA_NOT_INREPLYTO, "~inreplyto"},
74 {MATCHCRITERIA_REFERENCES, "references"},
75 {MATCHCRITERIA_NOT_REFERENCES, "~references"},
76 {MATCHCRITERIA_SCORE_GREATER, "score_greater"},
77 {MATCHCRITERIA_SCORE_LOWER, "score_lower"},
78 {MATCHCRITERIA_SCORE_EQUAL, "score_equal"},
80 {MATCHCRITERIA_SIZE_GREATER, "size_greater"},
81 {MATCHCRITERIA_SIZE_SMALLER, "size_smaller"},
82 {MATCHCRITERIA_SIZE_EQUAL, "size_equal"},
84 /* content have to be read */
85 {MATCHCRITERIA_HEADER, "header"},
86 {MATCHCRITERIA_NOT_HEADER, "~header"},
87 {MATCHCRITERIA_HEADERS_PART, "headers_part"},
88 {MATCHCRITERIA_NOT_HEADERS_PART, "~headers_part"},
89 {MATCHCRITERIA_MESSAGE, "message"},
90 {MATCHCRITERIA_NOT_MESSAGE, "~message"},
91 {MATCHCRITERIA_BODY_PART, "body_part"},
92 {MATCHCRITERIA_NOT_BODY_PART, "~body_part"},
93 {MATCHCRITERIA_EXECUTE, "execute"},
94 {MATCHCRITERIA_NOT_EXECUTE, "~execute"},
97 {MATCHTYPE_MATCHCASE, "matchcase"},
98 {MATCHTYPE_MATCH, "match"},
99 {MATCHTYPE_REGEXPCASE, "regexpcase"},
100 {MATCHTYPE_REGEXP, "regexp"},
103 {MATCHACTION_SCORE, "score"},
104 {MATCHACTION_MOVE, "move"},
105 {MATCHACTION_COPY, "copy"},
106 {MATCHACTION_DELETE, "delete"},
107 {MATCHACTION_MARK, "mark"},
108 {MATCHACTION_UNMARK, "unmark"},
109 {MATCHACTION_MARK_AS_READ, "mark_as_read"},
110 {MATCHACTION_MARK_AS_UNREAD, "mark_as_unread"},
111 {MATCHACTION_FORWARD, "forward"},
112 {MATCHACTION_FORWARD_AS_ATTACHMENT, "forward_as_attachment"},
113 {MATCHACTION_EXECUTE, "execute"},
114 {MATCHACTION_COLOR, "color"},
115 {MATCHACTION_REDIRECT, "redirect"},
116 {MATCHACTION_DELETE_ON_SERVER, "delete_on_server"}
119 /* get_matchparser_tab_str() - used by filtering.c to translate
120 * actions to debug strings */
121 gchar * get_matchparser_tab_str(gint id)
125 for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
127 if (matchparser_tab[i].id == id)
128 return matchparser_tab[i].str;
133 /* matcher_escape_str() - escapes a string returns newly allocated escaped string */
134 gchar *matcher_escape_str(const gchar *str)
136 register const gchar *walk;
139 register char *reswalk;
144 for (escape = 0, walk = str; *walk; walk++)
145 if (*walk == '\\' || *walk == '\'' || *walk == '\"')
149 return g_strdup(str);
151 reswalk = res = g_new0(gchar, (walk - str) + escape + 1);
152 for (walk = str; *walk; walk++, reswalk++) {
153 if (*walk == '\\' || *walk == '\'' || *walk == '\"')
162 /* matcher_unescape_str() - assumes that unescaping frees up room
163 * in the string, so it returns the unescaped string in the
165 gchar *matcher_unescape_str(gchar *str)
167 gchar *tmp = alloca(strlen(str) + 1);
168 register gchar *src = tmp;
169 register gchar *dst = str;
173 for ( ; *src; src++) {
178 if (*src == 'n') /* insert control characters */
180 else if (*src == 'r')
182 else if (*src == 't')
184 else if (*src == 'r')
186 else if (*src == 'b')
188 else if (*src == 'f')
190 else if (*src == '\\' || *src == '\'' || *src == '\"')
191 /* insert \\, \' or \" */
194 /* FIXME: should perhaps escape character... */
204 /* **************** data structure allocation **************** */
206 /* matcherprop_new() - allocates a structure for one condition
208 MatcherProp * matcherprop_new(gint criteria, gchar * header,
209 gint matchtype, gchar * expr,
214 prop = g_new0(MatcherProp, 1);
215 prop->criteria = criteria;
216 if (header != NULL) {
217 prop->header = g_strdup(header);
223 prop->expr = g_strdup(expr);
228 prop->matchtype = matchtype;
236 /* matcherprop_free()
238 void matcherprop_free(MatcherProp * prop)
243 g_free(prop->header);
244 if (prop->preg != NULL) {
251 MatcherProp *matcherprop_copy(MatcherProp *src)
253 MatcherProp *prop = g_new0(MatcherProp, 1);
254 prop->criteria = src->criteria;
256 prop->header = g_strdup(src->header);
260 prop->expr = g_strdup(src->expr);
263 prop->matchtype = src->matchtype;
265 prop->preg = NULL; /* will be re-evaluated */
266 prop->value = src->value;
267 prop->error = src->error;
271 /* ****************** wrapper for file reading ************** */
273 MatcherProp * matcherprop_unquote_new(gint criteria, gchar * header,
274 gint matchtype, gchar * expr,
280 expr = matcher_unescape_str(g_strdup(expr));
285 header = matcher_unescape_str(g_strdup(header));
289 prop = matcherprop_new(criteria, header,
290 matchtype, expr, value);
299 /* ************** match ******************************/
302 /* matcherprop_string_match() - finds out if a string matches
303 * with a criterium */
304 static gboolean matcherprop_string_match(MatcherProp * prop, gchar * str)
312 switch(prop->matchtype) {
313 case MATCHTYPE_REGEXPCASE:
314 case MATCHTYPE_REGEXP:
315 if (!prop->preg && (prop->error == 0)) {
316 prop->preg = g_new0(regex_t, 1);
317 /* if regexp then don't use the escaped string */
318 if (regcomp(prop->preg, prop->expr,
319 REG_NOSUB | REG_EXTENDED
320 | ((prop->matchtype == MATCHTYPE_REGEXPCASE)
321 ? REG_ICASE : 0)) != 0) {
327 if (prop->preg == NULL)
330 if (regexec(prop->preg, str, 0, NULL, 0) == 0)
335 case MATCHTYPE_MATCH:
336 return (strstr(str, prop->expr) != NULL);
338 /* FIXME: put upper in unesc_str */
339 case MATCHTYPE_MATCHCASE:
340 str2 = alloca(strlen(prop->expr) + 1);
341 strcpy(str2, prop->expr);
343 str1 = alloca(strlen(str) + 1);
346 return (strstr(str1, str2) != NULL);
353 gboolean matcherprop_match_execute(MatcherProp * prop, MsgInfo * info)
359 file = procmsg_get_message_file(info);
364 cmd = matching_build_command(prop->expr, info);
368 retval = system(cmd);
369 debug_print("Command exit code: %d\n", retval);
372 return (retval == 0);
375 /* match a message and his headers, hlist can be NULL if you don't
376 want to use headers */
378 gboolean matcherprop_match(MatcherProp * prop, MsgInfo * info)
382 switch(prop->criteria) {
383 case MATCHCRITERIA_ALL:
385 case MATCHCRITERIA_UNREAD:
386 return MSG_IS_UNREAD(info->flags);
387 case MATCHCRITERIA_NOT_UNREAD:
388 return !MSG_IS_UNREAD(info->flags);
389 case MATCHCRITERIA_NEW:
390 return MSG_IS_NEW(info->flags);
391 case MATCHCRITERIA_NOT_NEW:
392 return !MSG_IS_NEW(info->flags);
393 case MATCHCRITERIA_MARKED:
394 return MSG_IS_MARKED(info->flags);
395 case MATCHCRITERIA_NOT_MARKED:
396 return !MSG_IS_MARKED(info->flags);
397 case MATCHCRITERIA_DELETED:
398 return MSG_IS_DELETED(info->flags);
399 case MATCHCRITERIA_NOT_DELETED:
400 return !MSG_IS_DELETED(info->flags);
401 case MATCHCRITERIA_REPLIED:
402 return MSG_IS_REPLIED(info->flags);
403 case MATCHCRITERIA_NOT_REPLIED:
404 return !MSG_IS_REPLIED(info->flags);
405 case MATCHCRITERIA_FORWARDED:
406 return MSG_IS_FORWARDED(info->flags);
407 case MATCHCRITERIA_NOT_FORWARDED:
408 return !MSG_IS_FORWARDED(info->flags);
409 case MATCHCRITERIA_LOCKED:
410 return MSG_IS_LOCKED(info->flags);
411 case MATCHCRITERIA_NOT_LOCKED:
412 return !MSG_IS_LOCKED(info->flags);
413 case MATCHCRITERIA_SUBJECT:
414 return matcherprop_string_match(prop, info->subject);
415 case MATCHCRITERIA_NOT_SUBJECT:
416 return !matcherprop_string_match(prop, info->subject);
417 case MATCHCRITERIA_FROM:
418 return matcherprop_string_match(prop, info->from);
419 case MATCHCRITERIA_NOT_FROM:
420 return !matcherprop_string_match(prop, info->from);
421 case MATCHCRITERIA_TO:
422 return matcherprop_string_match(prop, info->to);
423 case MATCHCRITERIA_NOT_TO:
424 return !matcherprop_string_match(prop, info->to);
425 case MATCHCRITERIA_CC:
426 return matcherprop_string_match(prop, info->cc);
427 case MATCHCRITERIA_NOT_CC:
428 return !matcherprop_string_match(prop, info->cc);
429 case MATCHCRITERIA_TO_OR_CC:
430 return matcherprop_string_match(prop, info->to)
431 || matcherprop_string_match(prop, info->cc);
432 case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
433 return !(matcherprop_string_match(prop, info->to)
434 || matcherprop_string_match(prop, info->cc));
435 case MATCHCRITERIA_AGE_GREATER:
437 return ((t - info->date_t) / (60 * 60 * 24)) >= prop->value;
438 case MATCHCRITERIA_AGE_LOWER:
440 return ((t - info->date_t) / (60 * 60 * 24)) <= prop->value;
441 case MATCHCRITERIA_SCORE_GREATER:
442 return info->score >= prop->value;
443 case MATCHCRITERIA_SCORE_LOWER:
444 return info->score <= prop->value;
445 case MATCHCRITERIA_SCORE_EQUAL:
446 return info->score == prop->value;
447 case MATCHCRITERIA_SIZE_GREATER:
448 /* FIXME: info->size is an off_t */
449 return info->size > (off_t) prop->value;
450 case MATCHCRITERIA_SIZE_EQUAL:
451 /* FIXME: info->size is an off_t */
452 return info->size == (off_t) prop->value;
453 case MATCHCRITERIA_SIZE_SMALLER:
454 /* FIXME: info->size is an off_t */
455 return info->size < (off_t) prop->value;
456 case MATCHCRITERIA_NEWSGROUPS:
457 return matcherprop_string_match(prop, info->newsgroups);
458 case MATCHCRITERIA_NOT_NEWSGROUPS:
459 return !matcherprop_string_match(prop, info->newsgroups);
460 case MATCHCRITERIA_INREPLYTO:
461 return matcherprop_string_match(prop, info->inreplyto);
462 case MATCHCRITERIA_NOT_INREPLYTO:
463 return !matcherprop_string_match(prop, info->inreplyto);
464 case MATCHCRITERIA_REFERENCES:
465 return matcherprop_string_match(prop, info->references);
466 case MATCHCRITERIA_NOT_REFERENCES:
467 return !matcherprop_string_match(prop, info->references);
468 case MATCHCRITERIA_EXECUTE:
469 return matcherprop_match_execute(prop, info);
470 case MATCHCRITERIA_NOT_EXECUTE:
471 return !matcherprop_match_execute(prop, info);
477 /* ********************* MatcherList *************************** */
480 MatcherList * matcherlist_new(GSList * matchers, gboolean bool_and)
484 cond = g_new0(MatcherList, 1);
486 cond->matchers = matchers;
487 cond->bool_and = bool_and;
492 void matcherlist_free(MatcherList * cond)
496 for(l = cond->matchers ; l != NULL ; l = g_slist_next(l)) {
497 matcherprop_free((MatcherProp *) l->data);
506 static void matcherlist_skip_headers(FILE *fp)
510 while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1) {
515 matcherprop_match_one_header
516 returns TRUE if buf matchs the MatchersProp criteria
519 static gboolean matcherprop_match_one_header(MatcherProp * matcher,
525 switch(matcher->criteria) {
526 case MATCHCRITERIA_HEADER:
527 case MATCHCRITERIA_NOT_HEADER:
528 header = procheader_parse_header(buf);
531 if (procheader_headername_equal(header->name,
533 if (matcher->criteria == MATCHCRITERIA_HEADER)
534 result = matcherprop_string_match(matcher, header->body);
536 result = !matcherprop_string_match(matcher, header->body);
537 procheader_header_free(header);
541 procheader_header_free(header);
544 case MATCHCRITERIA_HEADERS_PART:
545 case MATCHCRITERIA_MESSAGE:
546 return matcherprop_string_match(matcher, buf);
547 case MATCHCRITERIA_NOT_MESSAGE:
548 case MATCHCRITERIA_NOT_HEADERS_PART:
549 return !matcherprop_string_match(matcher, buf);
555 matcherprop_criteria_header
556 returns TRUE if the headers must be matched
559 static gboolean matcherprop_criteria_headers(MatcherProp * matcher)
561 switch(matcher->criteria) {
562 case MATCHCRITERIA_HEADER:
563 case MATCHCRITERIA_NOT_HEADER:
564 case MATCHCRITERIA_HEADERS_PART:
565 case MATCHCRITERIA_NOT_HEADERS_PART:
572 static gboolean matcherprop_criteria_message(MatcherProp * matcher)
574 switch(matcher->criteria) {
575 case MATCHCRITERIA_MESSAGE:
576 case MATCHCRITERIA_NOT_MESSAGE:
584 matcherlist_match_one_header
585 returns TRUE if match should stop
588 static gboolean matcherlist_match_one_header(MatcherList * matchers,
593 for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
594 MatcherProp * matcher = (MatcherProp *) l->data;
596 if (matcherprop_criteria_headers(matcher) ||
597 matcherprop_criteria_message(matcher)) {
598 if (matcherprop_match_one_header(matcher, buf)) {
599 matcher->result = TRUE;
603 if (matcherprop_criteria_headers(matcher)) {
604 if (matcher->result) {
605 if (!matchers->bool_and)
615 matcherlist_match_headers
616 returns TRUE if one of the headers matchs the MatcherList criteria
619 static gboolean matcherlist_match_headers(MatcherList * matchers, FILE * fp)
623 while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1)
624 if (matcherlist_match_one_header(matchers, buf))
631 matcherprop_criteria_body
632 returns TRUE if the body must be matched
635 static gboolean matcherprop_criteria_body(MatcherProp * matcher)
637 switch(matcher->criteria) {
638 case MATCHCRITERIA_BODY_PART:
639 case MATCHCRITERIA_NOT_BODY_PART:
647 matcherprop_match_line
648 returns TRUE if the string matchs the MatcherProp criteria
651 static gboolean matcherprop_match_line(MatcherProp * matcher, gchar * line)
653 switch(matcher->criteria) {
654 case MATCHCRITERIA_BODY_PART:
655 case MATCHCRITERIA_MESSAGE:
656 return matcherprop_string_match(matcher, line);
657 case MATCHCRITERIA_NOT_BODY_PART:
658 case MATCHCRITERIA_NOT_MESSAGE:
659 return !matcherprop_string_match(matcher, line);
665 matcherlist_match_line
666 returns TRUE if the string matchs the MatcherList criteria
669 static gboolean matcherlist_match_line(MatcherList * matchers, gchar * line)
673 for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
674 MatcherProp * matcher = (MatcherProp *) l->data;
676 if (matcherprop_criteria_body(matcher) ||
677 matcherprop_criteria_message(matcher)) {
678 if (matcherprop_match_line(matcher, line)) {
679 matcher->result = TRUE;
683 if (matcher->result) {
684 if (!matchers->bool_and)
692 matcherlist_match_body
693 returns TRUE if one line of the body matchs the MatcherList criteria
696 static gboolean matcherlist_match_body(MatcherList * matchers, FILE * fp)
700 while (fgets(buf, sizeof(buf), fp) != NULL)
701 if (matcherlist_match_line(matchers, buf))
707 gboolean matcherlist_match_file(MatcherList * matchers, MsgInfo * info,
710 gboolean read_headers;
716 /* file need to be read ? */
718 read_headers = FALSE;
720 for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
721 MatcherProp * matcher = (MatcherProp *) l->data;
723 if (matcherprop_criteria_headers(matcher))
725 if (matcherprop_criteria_body(matcher))
727 if (matcherprop_criteria_message(matcher)) {
731 matcher->result = FALSE;
734 if (!read_headers && !read_body)
737 file = procmsg_get_message_file(info);
741 if ((fp = fopen(file, "rb")) == NULL) {
742 FILE_OP_ERROR(file, "fopen");
747 /* read the headers */
750 if (matcherlist_match_headers(matchers, fp))
754 matcherlist_skip_headers(fp);
759 matcherlist_match_body(matchers, fp);
762 for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
763 MatcherProp * matcher = (MatcherProp *) l->data;
765 if (matcherprop_criteria_headers(matcher) ||
766 matcherprop_criteria_body(matcher) ||
767 matcherprop_criteria_message(matcher)) {
768 if (matcher->result) {
769 if (!matchers->bool_and) {
775 if (matchers->bool_and) {
790 /* test a list of condition */
792 gboolean matcherlist_match(MatcherList * matchers, MsgInfo * info)
797 if (matchers->bool_and)
802 /* test the cached elements */
804 for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
805 MatcherProp * matcher = (MatcherProp *) l->data;
807 switch(matcher->criteria) {
808 case MATCHCRITERIA_ALL:
809 case MATCHCRITERIA_UNREAD:
810 case MATCHCRITERIA_NOT_UNREAD:
811 case MATCHCRITERIA_NEW:
812 case MATCHCRITERIA_NOT_NEW:
813 case MATCHCRITERIA_MARKED:
814 case MATCHCRITERIA_NOT_MARKED:
815 case MATCHCRITERIA_DELETED:
816 case MATCHCRITERIA_NOT_DELETED:
817 case MATCHCRITERIA_REPLIED:
818 case MATCHCRITERIA_NOT_REPLIED:
819 case MATCHCRITERIA_FORWARDED:
820 case MATCHCRITERIA_NOT_FORWARDED:
821 case MATCHCRITERIA_LOCKED:
822 case MATCHCRITERIA_NOT_LOCKED:
823 case MATCHCRITERIA_SUBJECT:
824 case MATCHCRITERIA_NOT_SUBJECT:
825 case MATCHCRITERIA_FROM:
826 case MATCHCRITERIA_NOT_FROM:
827 case MATCHCRITERIA_TO:
828 case MATCHCRITERIA_NOT_TO:
829 case MATCHCRITERIA_CC:
830 case MATCHCRITERIA_NOT_CC:
831 case MATCHCRITERIA_TO_OR_CC:
832 case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
833 case MATCHCRITERIA_AGE_GREATER:
834 case MATCHCRITERIA_AGE_LOWER:
835 case MATCHCRITERIA_NEWSGROUPS:
836 case MATCHCRITERIA_NOT_NEWSGROUPS:
837 case MATCHCRITERIA_INREPLYTO:
838 case MATCHCRITERIA_NOT_INREPLYTO:
839 case MATCHCRITERIA_REFERENCES:
840 case MATCHCRITERIA_NOT_REFERENCES:
841 case MATCHCRITERIA_SCORE_GREATER:
842 case MATCHCRITERIA_SCORE_LOWER:
843 case MATCHCRITERIA_SCORE_EQUAL:
844 case MATCHCRITERIA_SIZE_GREATER:
845 case MATCHCRITERIA_SIZE_SMALLER:
846 case MATCHCRITERIA_SIZE_EQUAL:
847 case MATCHCRITERIA_EXECUTE:
848 case MATCHCRITERIA_NOT_EXECUTE:
849 if (matcherprop_match(matcher, info)) {
850 if (!matchers->bool_and) {
855 if (matchers->bool_and) {
862 /* test the condition on the file */
864 if (matcherlist_match_file(matchers, info, result)) {
865 if (!matchers->bool_and)
869 if (matchers->bool_and)
877 gchar * matcherprop_to_string(MatcherProp * matcher)
879 gchar * matcher_str = NULL;
880 gchar * criteria_str;
881 gchar * matchtype_str;
887 for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
889 if (matchparser_tab[i].id == matcher->criteria)
890 criteria_str = matchparser_tab[i].str;
892 if (criteria_str == NULL)
895 switch(matcher->criteria) {
896 case MATCHCRITERIA_AGE_GREATER:
897 case MATCHCRITERIA_AGE_LOWER:
898 case MATCHCRITERIA_SCORE_GREATER:
899 case MATCHCRITERIA_SCORE_LOWER:
900 case MATCHCRITERIA_SCORE_EQUAL:
901 case MATCHCRITERIA_SIZE_GREATER:
902 case MATCHCRITERIA_SIZE_SMALLER:
903 case MATCHCRITERIA_SIZE_EQUAL:
904 return g_strdup_printf("%s %i", criteria_str, matcher->value);
905 case MATCHCRITERIA_ALL:
906 case MATCHCRITERIA_UNREAD:
907 case MATCHCRITERIA_NOT_UNREAD:
908 case MATCHCRITERIA_NEW:
909 case MATCHCRITERIA_NOT_NEW:
910 case MATCHCRITERIA_MARKED:
911 case MATCHCRITERIA_NOT_MARKED:
912 case MATCHCRITERIA_DELETED:
913 case MATCHCRITERIA_NOT_DELETED:
914 case MATCHCRITERIA_REPLIED:
915 case MATCHCRITERIA_NOT_REPLIED:
916 case MATCHCRITERIA_FORWARDED:
917 case MATCHCRITERIA_NOT_FORWARDED:
918 case MATCHCRITERIA_LOCKED:
919 case MATCHCRITERIA_NOT_LOCKED:
920 return g_strdup(criteria_str);
921 case MATCHCRITERIA_EXECUTE:
922 case MATCHCRITERIA_NOT_EXECUTE:
923 expr = matcher_escape_str(matcher->expr);
924 matcher_str = g_strdup_printf("%s \"%s\"", criteria_str, expr);
929 matchtype_str = NULL;
930 for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
932 if (matchparser_tab[i].id == matcher->matchtype)
933 matchtype_str = matchparser_tab[i].str;
936 if (matchtype_str == NULL)
939 switch (matcher->matchtype) {
940 case MATCHTYPE_MATCH:
941 case MATCHTYPE_MATCHCASE:
942 case MATCHTYPE_REGEXP:
943 case MATCHTYPE_REGEXPCASE:
944 expr = matcher_escape_str(matcher->expr);
945 header = matcher_escape_str(matcher->header);
948 g_strdup_printf("%s \"%s\" %s \"%s\"",
949 criteria_str, matcher->header,
950 matchtype_str, expr);
953 g_strdup_printf("%s %s \"%s\"", criteria_str,
954 matchtype_str, expr);
963 gchar * matcherlist_to_string(MatcherList * matchers)
969 gchar * result = NULL;
971 count = g_slist_length(matchers->matchers);
972 vstr = g_new(gchar *, count + 1);
974 for (l = matchers->matchers, cur_str = vstr ; l != NULL ;
975 l = g_slist_next(l), cur_str ++) {
976 *cur_str = matcherprop_to_string((MatcherProp *) l->data);
977 if (*cur_str == NULL)
982 if (matchers->bool_and)
983 result = g_strjoinv(" & ", vstr);
985 result = g_strjoinv(" | ", vstr);
987 for(cur_str = vstr ; *cur_str != NULL ; cur_str ++)
994 #define STRLEN_ZERO(s) ((s) ? strlen(s) : 0)
995 #define STRLEN_DEFAULT(s,d) ((s) ? strlen(s) : STRLEN_ZERO(d))
996 /* matching_build_command() - preferably cmd should be unescaped */
997 gchar * matching_build_command(gchar * cmd, MsgInfo * info)
1000 gchar * filename = NULL;
1001 gchar * processed_cmd;
1005 const gchar *const no_subject = _("(none)") ;
1006 const gchar *const no_from = _("(none)") ;
1007 const gchar *const no_to = _("(none)") ;
1008 const gchar *const no_cc = _("(none)") ;
1009 const gchar *const no_date = _("(none)") ;
1010 const gchar *const no_msgid = _("(none)") ;
1011 const gchar *const no_newsgroups = _("(none)") ;
1012 const gchar *const no_references = _("(none)") ;
1014 size = STRLEN_ZERO(cmd) + 1;
1015 while (*s != '\0') {
1022 case 's': /* subject */
1023 size += STRLEN_DEFAULT(info->subject, no_subject) - 2;
1025 case 'f': /* from */
1026 size += STRLEN_DEFAULT(info->from, no_from) - 2;
1029 size += STRLEN_DEFAULT(info->to, no_to) - 2;
1032 size += STRLEN_DEFAULT(info->cc, no_cc) - 2;
1034 case 'd': /* date */
1035 size += STRLEN_DEFAULT(info->date, no_date) - 2;
1037 case 'i': /* message-id */
1038 size += STRLEN_DEFAULT(info->msgid, no_msgid) - 2;
1040 case 'n': /* newsgroups */
1041 size += STRLEN_DEFAULT(info->newsgroups, no_newsgroups) - 2;
1043 case 'r': /* references */
1044 size += STRLEN_DEFAULT(info->references, no_references) - 2;
1046 case 'F': /* file */
1047 filename = folder_item_fetch_msg(info->folder,
1050 if (filename == NULL) {
1051 g_warning("filename is not set");
1055 size += strlen(filename) - 2;
1064 processed_cmd = g_new0(gchar, size);
1068 while (*s != '\0') {
1076 case 's': /* subject */
1077 if (info->subject != NULL)
1078 strcpy(p, info->subject);
1080 strcpy(p, no_subject);
1083 case 'f': /* from */
1084 if (info->from != NULL)
1085 strcpy(p, info->from);
1091 if (info->to != NULL)
1092 strcpy(p, info->to);
1098 if (info->cc != NULL)
1099 strcpy(p, info->cc);
1104 case 'd': /* date */
1105 if (info->date != NULL)
1106 strcpy(p, info->date);
1111 case 'i': /* message-id */
1112 if (info->msgid != NULL)
1113 strcpy(p, info->msgid);
1115 strcpy(p, no_msgid);
1118 case 'n': /* newsgroups */
1119 if (info->newsgroups != NULL)
1120 strcpy(p, info->newsgroups);
1122 strcpy(p, no_newsgroups);
1125 case 'r': /* references */
1126 if (info->references != NULL)
1127 strcpy(p, info->references);
1129 strcpy(p, no_references);
1132 case 'F': /* file */
1133 strcpy(p, filename);
1153 debug_print("*** exec string \"%s\"\n", processed_cmd);
1154 return processed_cmd;
1156 #undef STRLEN_DEFAULT
1159 /* ************************************************************ */
1161 static void prefs_scoring_write(FILE * fp, GSList * prefs_scoring)
1165 for (cur = prefs_scoring; cur != NULL; cur = cur->next) {
1169 prop = (ScoringProp *) cur->data;
1170 scoring_str = scoringprop_to_string(prop);
1171 if (fputs(scoring_str, fp) == EOF ||
1172 fputc('\n', fp) == EOF) {
1173 FILE_OP_ERROR("scoring config", "fputs || fputc");
1174 g_free(scoring_str);
1177 g_free(scoring_str);
1181 static void prefs_filtering_write(FILE * fp, GSList * prefs_scoring)
1185 for (cur = prefs_scoring; cur != NULL; cur = cur->next) {
1186 gchar *filtering_str;
1187 FilteringProp * prop;
1189 if (NULL == (prop = (FilteringProp *) cur->data))
1192 if (NULL == (filtering_str = filteringprop_to_string(prop)))
1195 if (fputs(filtering_str, fp) == EOF ||
1196 fputc('\n', fp) == EOF) {
1197 FILE_OP_ERROR("filtering config", "fputs || fputc");
1198 g_free(filtering_str);
1201 g_free(filtering_str);
1205 static gboolean prefs_matcher_write_func(GNode *node, gpointer data)
1210 GSList * prefs_scoring;
1211 GSList * prefs_filtering;
1215 /* prevent from the warning */
1216 if (item->path == NULL)
1218 id = folder_item_get_identifier(item);
1221 prefs_scoring = item->prefs->scoring;
1222 prefs_filtering = item->prefs->processing;
1226 id = g_strdup("global"); /* because it is g_freed */
1227 prefs_scoring = global_scoring;
1228 prefs_filtering = global_processing;
1231 if (prefs_filtering != NULL || prefs_scoring != NULL) {
1232 fprintf(fp, "[%s]\n", id);
1234 prefs_filtering_write(fp, prefs_filtering);
1235 prefs_scoring_write(fp, prefs_scoring);
1245 static void prefs_matcher_save(FILE * fp)
1249 for (cur = folder_get_list() ; cur != NULL ; cur = g_list_next(cur)) {
1252 folder = (Folder *) cur->data;
1253 g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1254 prefs_matcher_write_func, fp);
1256 prefs_matcher_write_func(NULL, fp);
1260 void prefs_matcher_write_config(void)
1265 debug_print("Writing matcher configuration...\n");
1267 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1270 if ((pfile = prefs_write_open(rcpath)) == NULL) {
1271 g_warning("failed to write configuration to file\n");
1277 prefs_matcher_save(pfile->fp);
1281 if (prefs_write_close(pfile) < 0) {
1282 g_warning("failed to write configuration to file\n");
1287 /* ******************************************************************* */
1289 void prefs_matcher_read_config(void)
1294 prefs_scoring_clear();
1295 prefs_filtering_clear();
1297 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, MATCHER_RC, NULL);
1298 f = fopen(rcpath, "rb");
1302 matcher_parser_start_parsing(f);
1306 /* previous version compatibily */
1308 /* printf("reading filtering\n"); */
1309 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1310 FILTERING_RC, NULL);
1311 f = fopen(rcpath, "rb");
1315 matcher_parser_start_parsing(f);
1316 fclose(matcher_parserin);
1319 /* printf("reading scoring\n"); */
1320 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1322 f = fopen(rcpath, "rb");
1326 matcher_parser_start_parsing(f);
1327 fclose(matcher_parserin);