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"},
58 {MATCHCRITERIA_IGNORE_THREAD, "ignore_thread"},
59 {MATCHCRITERIA_NOT_IGNORE_THREAD, "~ignore_thread"},
62 {MATCHCRITERIA_SUBJECT, "subject"},
63 {MATCHCRITERIA_NOT_SUBJECT, "~subject"},
64 {MATCHCRITERIA_FROM, "from"},
65 {MATCHCRITERIA_NOT_FROM, "~from"},
66 {MATCHCRITERIA_TO, "to"},
67 {MATCHCRITERIA_NOT_TO, "~to"},
68 {MATCHCRITERIA_CC, "cc"},
69 {MATCHCRITERIA_NOT_CC, "~cc"},
70 {MATCHCRITERIA_TO_OR_CC, "to_or_cc"},
71 {MATCHCRITERIA_NOT_TO_AND_NOT_CC, "~to_or_cc"},
72 {MATCHCRITERIA_AGE_GREATER, "age_greater"},
73 {MATCHCRITERIA_AGE_LOWER, "age_lower"},
74 {MATCHCRITERIA_NEWSGROUPS, "newsgroups"},
75 {MATCHCRITERIA_NOT_NEWSGROUPS, "~newsgroups"},
76 {MATCHCRITERIA_INREPLYTO, "inreplyto"},
77 {MATCHCRITERIA_NOT_INREPLYTO, "~inreplyto"},
78 {MATCHCRITERIA_REFERENCES, "references"},
79 {MATCHCRITERIA_NOT_REFERENCES, "~references"},
80 {MATCHCRITERIA_SCORE_GREATER, "score_greater"},
81 {MATCHCRITERIA_SCORE_LOWER, "score_lower"},
82 {MATCHCRITERIA_SCORE_EQUAL, "score_equal"},
84 {MATCHCRITERIA_SIZE_GREATER, "size_greater"},
85 {MATCHCRITERIA_SIZE_SMALLER, "size_smaller"},
86 {MATCHCRITERIA_SIZE_EQUAL, "size_equal"},
88 /* content have to be read */
89 {MATCHCRITERIA_HEADER, "header"},
90 {MATCHCRITERIA_NOT_HEADER, "~header"},
91 {MATCHCRITERIA_HEADERS_PART, "headers_part"},
92 {MATCHCRITERIA_NOT_HEADERS_PART, "~headers_part"},
93 {MATCHCRITERIA_MESSAGE, "message"},
94 {MATCHCRITERIA_NOT_MESSAGE, "~message"},
95 {MATCHCRITERIA_BODY_PART, "body_part"},
96 {MATCHCRITERIA_NOT_BODY_PART, "~body_part"},
97 {MATCHCRITERIA_EXECUTE, "execute"},
98 {MATCHCRITERIA_NOT_EXECUTE, "~execute"},
101 {MATCHTYPE_MATCHCASE, "matchcase"},
102 {MATCHTYPE_MATCH, "match"},
103 {MATCHTYPE_REGEXPCASE, "regexpcase"},
104 {MATCHTYPE_REGEXP, "regexp"},
107 {MATCHACTION_SCORE, "score"},
108 {MATCHACTION_MOVE, "move"},
109 {MATCHACTION_COPY, "copy"},
110 {MATCHACTION_DELETE, "delete"},
111 {MATCHACTION_MARK, "mark"},
112 {MATCHACTION_UNMARK, "unmark"},
113 {MATCHACTION_MARK_AS_READ, "mark_as_read"},
114 {MATCHACTION_MARK_AS_UNREAD, "mark_as_unread"},
115 {MATCHACTION_FORWARD, "forward"},
116 {MATCHACTION_FORWARD_AS_ATTACHMENT, "forward_as_attachment"},
117 {MATCHACTION_EXECUTE, "execute"},
118 {MATCHACTION_COLOR, "color"},
119 {MATCHACTION_REDIRECT, "redirect"},
120 {MATCHACTION_DELETE_ON_SERVER, "delete_on_server"}
123 static GHashTable *matchparser_hashtab;
125 /* get_matchparser_tab_str() - used by filtering.c to translate
126 * actions to debug strings */
127 gchar *get_matchparser_tab_str(gint id)
131 for (i = 0; i < sizeof matchparser_tab / sizeof matchparser_tab[0]; i++) {
132 if (matchparser_tab[i].id == id)
133 return matchparser_tab[i].str;
138 static void create_matchparser_hashtab(void)
142 if (matchparser_hashtab) return;
143 matchparser_hashtab = g_hash_table_new(g_str_hash, g_str_equal);
144 for (i = 0; i < sizeof matchparser_tab / sizeof matchparser_tab[0]; i++)
145 g_hash_table_insert(matchparser_hashtab,
146 matchparser_tab[i].str,
147 &matchparser_tab[i]);
150 gint get_matchparser_tab_id(const gchar *str)
155 if (NULL != (res = g_hash_table_lookup(matchparser_hashtab, str))) {
161 /* matcher_escape_str() - escapes a string returns newly allocated escaped string */
162 gchar *matcher_escape_str(const gchar *str)
164 register const gchar *walk;
167 register char *reswalk;
172 for (escape = 0, walk = str; *walk; walk++)
173 if (*walk == '\\' || *walk == '\'' || *walk == '\"')
177 return g_strdup(str);
179 reswalk = res = g_new0(gchar, (walk - str) + escape + 1);
180 for (walk = str; *walk; walk++, reswalk++) {
181 if (*walk == '\\' || *walk == '\'' || *walk == '\"')
190 /* matcher_unescape_str() - assumes that unescaping frees up room
191 * in the string, so it returns the unescaped string in the
193 gchar *matcher_unescape_str(gchar *str)
195 gchar *tmp = alloca(strlen(str) + 1);
196 register gchar *src = tmp;
197 register gchar *dst = str;
201 for ( ; *src; src++) {
206 if (*src == 'n') /* insert control characters */
208 else if (*src == 'r')
210 else if (*src == 't')
212 else if (*src == 'r')
214 else if (*src == 'b')
216 else if (*src == 'f')
218 else if (*src == '\\' || *src == '\'' || *src == '\"')
219 /* insert \\, \' or \" */
222 /* FIXME: should perhaps escape character... */
232 /* **************** data structure allocation **************** */
234 /* matcherprop_new() - allocates a structure for one condition
236 MatcherProp *matcherprop_new(gint criteria, gchar *header,
237 gint matchtype, gchar *expr,
242 prop = g_new0(MatcherProp, 1);
243 prop->criteria = criteria;
244 prop->header = header != NULL ? g_strdup(header) : NULL;
245 prop->expr = expr != NULL ? g_strdup(expr) : NULL;
246 prop->matchtype = matchtype;
254 /* matcherprop_free()
256 void matcherprop_free(MatcherProp *prop)
261 g_free(prop->header);
262 if (prop->preg != NULL) {
269 MatcherProp *matcherprop_copy(MatcherProp *src)
271 MatcherProp *prop = g_new0(MatcherProp, 1);
273 prop->criteria = src->criteria;
274 prop->header = src->header ? g_strdup(src->header) : NULL;
275 prop->expr = src->expr ? g_strdup(src->expr) : NULL;
276 prop->matchtype = src->matchtype;
278 prop->preg = NULL; /* will be re-evaluated */
279 prop->value = src->value;
280 prop->error = src->error;
284 /* ****************** wrapper for file reading ************** */
286 MatcherProp *matcherprop_unquote_new(gint criteria, gchar *header,
287 gint matchtype, gchar *expr,
293 expr = matcher_unescape_str(g_strdup(expr));
296 header = matcher_unescape_str(g_strdup(header));
298 prop = matcherprop_new(criteria, header, matchtype, expr, value);
307 /* ************** match ******************************/
310 /* matcherprop_string_match() - finds out if a string matches
311 * with a criterium */
312 static gboolean matcherprop_string_match(MatcherProp *prop, gchar *str)
320 switch (prop->matchtype) {
321 case MATCHTYPE_REGEXPCASE:
322 case MATCHTYPE_REGEXP:
323 if (!prop->preg && (prop->error == 0)) {
324 prop->preg = g_new0(regex_t, 1);
325 /* if regexp then don't use the escaped string */
326 if (regcomp(prop->preg, prop->expr,
327 REG_NOSUB | REG_EXTENDED
328 | ((prop->matchtype == MATCHTYPE_REGEXPCASE)
329 ? REG_ICASE : 0)) != 0) {
335 if (prop->preg == NULL)
338 if (regexec(prop->preg, str, 0, NULL, 0) == 0)
343 case MATCHTYPE_MATCH:
344 return (strstr(str, prop->expr) != NULL);
346 /* FIXME: put upper in unesc_str */
347 case MATCHTYPE_MATCHCASE:
348 str2 = alloca(strlen(prop->expr) + 1);
349 strcpy(str2, prop->expr);
351 str1 = alloca(strlen(str) + 1);
354 return (strstr(str1, str2) != NULL);
361 gboolean matcherprop_match_execute(MatcherProp *prop, MsgInfo *info)
367 file = procmsg_get_message_file(info);
372 cmd = matching_build_command(prop->expr, info);
376 retval = system(cmd);
377 debug_print("Command exit code: %d\n", retval);
380 return (retval == 0);
383 /* match a message and his headers, hlist can be NULL if you don't
384 want to use headers */
386 gboolean matcherprop_match(MatcherProp *prop, MsgInfo *info)
390 switch(prop->criteria) {
391 case MATCHCRITERIA_ALL:
393 case MATCHCRITERIA_UNREAD:
394 return MSG_IS_UNREAD(info->flags);
395 case MATCHCRITERIA_NOT_UNREAD:
396 return !MSG_IS_UNREAD(info->flags);
397 case MATCHCRITERIA_NEW:
398 return MSG_IS_NEW(info->flags);
399 case MATCHCRITERIA_NOT_NEW:
400 return !MSG_IS_NEW(info->flags);
401 case MATCHCRITERIA_MARKED:
402 return MSG_IS_MARKED(info->flags);
403 case MATCHCRITERIA_NOT_MARKED:
404 return !MSG_IS_MARKED(info->flags);
405 case MATCHCRITERIA_DELETED:
406 return MSG_IS_DELETED(info->flags);
407 case MATCHCRITERIA_NOT_DELETED:
408 return !MSG_IS_DELETED(info->flags);
409 case MATCHCRITERIA_REPLIED:
410 return MSG_IS_REPLIED(info->flags);
411 case MATCHCRITERIA_NOT_REPLIED:
412 return !MSG_IS_REPLIED(info->flags);
413 case MATCHCRITERIA_FORWARDED:
414 return MSG_IS_FORWARDED(info->flags);
415 case MATCHCRITERIA_NOT_FORWARDED:
416 return !MSG_IS_FORWARDED(info->flags);
417 case MATCHCRITERIA_LOCKED:
418 return MSG_IS_LOCKED(info->flags);
419 case MATCHCRITERIA_NOT_LOCKED:
420 return !MSG_IS_LOCKED(info->flags);
421 case MATCHCRITERIA_COLORLABEL:
422 return MSG_GET_COLORLABEL_VALUE(info->flags) == prop->value;
423 case MATCHCRITERIA_NOT_COLORLABEL:
424 return MSG_GET_COLORLABEL_VALUE(info->flags) != prop->value;
425 case MATCHCRITERIA_IGNORE_THREAD:
426 return MSG_IS_IGNORE_THREAD(info->flags);
427 case MATCHCRITERIA_NOT_IGNORE_THREAD:
428 return !MSG_IS_IGNORE_THREAD(info->flags);
429 case MATCHCRITERIA_SUBJECT:
430 return matcherprop_string_match(prop, info->subject);
431 case MATCHCRITERIA_NOT_SUBJECT:
432 return !matcherprop_string_match(prop, info->subject);
433 case MATCHCRITERIA_FROM:
434 return matcherprop_string_match(prop, info->from);
435 case MATCHCRITERIA_NOT_FROM:
436 return !matcherprop_string_match(prop, info->from);
437 case MATCHCRITERIA_TO:
438 return matcherprop_string_match(prop, info->to);
439 case MATCHCRITERIA_NOT_TO:
440 return !matcherprop_string_match(prop, info->to);
441 case MATCHCRITERIA_CC:
442 return matcherprop_string_match(prop, info->cc);
443 case MATCHCRITERIA_NOT_CC:
444 return !matcherprop_string_match(prop, info->cc);
445 case MATCHCRITERIA_TO_OR_CC:
446 return matcherprop_string_match(prop, info->to)
447 || matcherprop_string_match(prop, info->cc);
448 case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
449 return !(matcherprop_string_match(prop, info->to)
450 || matcherprop_string_match(prop, info->cc));
451 case MATCHCRITERIA_AGE_GREATER:
453 return ((t - info->date_t) / (60 * 60 * 24)) >= prop->value;
454 case MATCHCRITERIA_AGE_LOWER:
456 return ((t - info->date_t) / (60 * 60 * 24)) <= prop->value;
457 case MATCHCRITERIA_SCORE_GREATER:
458 return info->score >= prop->value;
459 case MATCHCRITERIA_SCORE_LOWER:
460 return info->score <= prop->value;
461 case MATCHCRITERIA_SCORE_EQUAL:
462 return info->score == prop->value;
463 case MATCHCRITERIA_SIZE_GREATER:
464 /* FIXME: info->size is an off_t */
465 return info->size > (off_t) prop->value;
466 case MATCHCRITERIA_SIZE_EQUAL:
467 /* FIXME: info->size is an off_t */
468 return info->size == (off_t) prop->value;
469 case MATCHCRITERIA_SIZE_SMALLER:
470 /* FIXME: info->size is an off_t */
471 return info->size < (off_t) prop->value;
472 case MATCHCRITERIA_NEWSGROUPS:
473 return matcherprop_string_match(prop, info->newsgroups);
474 case MATCHCRITERIA_NOT_NEWSGROUPS:
475 return !matcherprop_string_match(prop, info->newsgroups);
476 case MATCHCRITERIA_INREPLYTO:
477 return matcherprop_string_match(prop, info->inreplyto);
478 case MATCHCRITERIA_NOT_INREPLYTO:
479 return !matcherprop_string_match(prop, info->inreplyto);
480 case MATCHCRITERIA_REFERENCES:
481 return matcherprop_string_match(prop, info->references);
482 case MATCHCRITERIA_NOT_REFERENCES:
483 return !matcherprop_string_match(prop, info->references);
484 case MATCHCRITERIA_EXECUTE:
485 return matcherprop_match_execute(prop, info);
486 case MATCHCRITERIA_NOT_EXECUTE:
487 return !matcherprop_match_execute(prop, info);
493 /* ********************* MatcherList *************************** */
496 MatcherList *matcherlist_new(GSList *matchers, gboolean bool_and)
500 cond = g_new0(MatcherList, 1);
502 cond->matchers = matchers;
503 cond->bool_and = bool_and;
508 void matcherlist_free(MatcherList *cond)
512 for (l = cond->matchers ; l != NULL ; l = g_slist_next(l)) {
513 matcherprop_free((MatcherProp *) l->data);
522 static void matcherlist_skip_headers(FILE *fp)
526 while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1)
531 matcherprop_match_one_header
532 returns TRUE if buf matchs the MatchersProp criteria
535 static gboolean matcherprop_match_one_header(MatcherProp *matcher,
541 switch (matcher->criteria) {
542 case MATCHCRITERIA_HEADER:
543 case MATCHCRITERIA_NOT_HEADER:
544 header = procheader_parse_header(buf);
547 if (procheader_headername_equal(header->name,
549 if (matcher->criteria == MATCHCRITERIA_HEADER)
550 result = matcherprop_string_match(matcher, header->body);
552 result = !matcherprop_string_match(matcher, header->body);
553 procheader_header_free(header);
557 procheader_header_free(header);
560 case MATCHCRITERIA_HEADERS_PART:
561 case MATCHCRITERIA_MESSAGE:
562 return matcherprop_string_match(matcher, buf);
563 case MATCHCRITERIA_NOT_MESSAGE:
564 case MATCHCRITERIA_NOT_HEADERS_PART:
565 return !matcherprop_string_match(matcher, buf);
571 matcherprop_criteria_header
572 returns TRUE if the headers must be matched
575 static gboolean matcherprop_criteria_headers(MatcherProp *matcher)
577 switch (matcher->criteria) {
578 case MATCHCRITERIA_HEADER:
579 case MATCHCRITERIA_NOT_HEADER:
580 case MATCHCRITERIA_HEADERS_PART:
581 case MATCHCRITERIA_NOT_HEADERS_PART:
588 static gboolean matcherprop_criteria_message(MatcherProp *matcher)
590 switch (matcher->criteria) {
591 case MATCHCRITERIA_MESSAGE:
592 case MATCHCRITERIA_NOT_MESSAGE:
600 matcherlist_match_one_header
601 returns TRUE if match should stop
604 static gboolean matcherlist_match_one_header(MatcherList *matchers,
609 for (l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
610 MatcherProp *matcher = (MatcherProp *) l->data;
612 if (matcherprop_criteria_headers(matcher) ||
613 matcherprop_criteria_message(matcher)) {
614 if (matcherprop_match_one_header(matcher, buf)) {
615 matcher->result = TRUE;
619 if (matcherprop_criteria_headers(matcher)) {
620 if (matcher->result) {
621 if (!matchers->bool_and)
631 matcherlist_match_headers
632 returns TRUE if one of the headers matchs the MatcherList criteria
635 static gboolean matcherlist_match_headers(MatcherList *matchers, FILE *fp)
639 while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1)
640 if (matcherlist_match_one_header(matchers, buf))
647 matcherprop_criteria_body
648 returns TRUE if the body must be matched
651 static gboolean matcherprop_criteria_body(MatcherProp *matcher)
653 switch (matcher->criteria) {
654 case MATCHCRITERIA_BODY_PART:
655 case MATCHCRITERIA_NOT_BODY_PART:
663 matcherprop_match_line
664 returns TRUE if the string matchs the MatcherProp criteria
667 static gboolean matcherprop_match_line(MatcherProp *matcher, gchar *line)
669 switch (matcher->criteria) {
670 case MATCHCRITERIA_BODY_PART:
671 case MATCHCRITERIA_MESSAGE:
672 return matcherprop_string_match(matcher, line);
673 case MATCHCRITERIA_NOT_BODY_PART:
674 case MATCHCRITERIA_NOT_MESSAGE:
675 return !matcherprop_string_match(matcher, line);
681 matcherlist_match_line
682 returns TRUE if the string matchs the MatcherList criteria
685 static gboolean matcherlist_match_line(MatcherList *matchers, gchar *line)
689 for (l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
690 MatcherProp *matcher = (MatcherProp *) l->data;
692 if (matcherprop_criteria_body(matcher) ||
693 matcherprop_criteria_message(matcher)) {
694 if (matcherprop_match_line(matcher, line)) {
695 matcher->result = TRUE;
699 if (matcher->result) {
700 if (!matchers->bool_and)
708 matcherlist_match_body
709 returns TRUE if one line of the body matchs the MatcherList criteria
712 static gboolean matcherlist_match_body(MatcherList *matchers, FILE *fp)
716 while (fgets(buf, sizeof(buf), fp) != NULL)
717 if (matcherlist_match_line(matchers, buf))
723 gboolean matcherlist_match_file(MatcherList *matchers, MsgInfo *info,
726 gboolean read_headers;
732 /* file need to be read ? */
734 read_headers = FALSE;
736 for (l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
737 MatcherProp *matcher = (MatcherProp *) l->data;
739 if (matcherprop_criteria_headers(matcher))
741 if (matcherprop_criteria_body(matcher))
743 if (matcherprop_criteria_message(matcher)) {
747 matcher->result = FALSE;
750 if (!read_headers && !read_body)
753 file = procmsg_get_message_file(info);
757 if ((fp = fopen(file, "rb")) == NULL) {
758 FILE_OP_ERROR(file, "fopen");
763 /* read the headers */
766 if (matcherlist_match_headers(matchers, fp))
770 matcherlist_skip_headers(fp);
775 matcherlist_match_body(matchers, fp);
778 for (l = matchers->matchers; l != NULL; l = g_slist_next(l)) {
779 MatcherProp *matcher = (MatcherProp *) l->data;
781 if (matcherprop_criteria_headers(matcher) ||
782 matcherprop_criteria_body(matcher) ||
783 matcherprop_criteria_message(matcher)) {
784 if (matcher->result) {
785 if (!matchers->bool_and) {
791 if (matchers->bool_and) {
806 /* test a list of condition */
808 gboolean matcherlist_match(MatcherList *matchers, MsgInfo *info)
813 if (matchers->bool_and)
818 /* test the cached elements */
820 for (l = matchers->matchers; l != NULL ;l = g_slist_next(l)) {
821 MatcherProp *matcher = (MatcherProp *) l->data;
823 switch(matcher->criteria) {
824 case MATCHCRITERIA_ALL:
825 case MATCHCRITERIA_UNREAD:
826 case MATCHCRITERIA_NOT_UNREAD:
827 case MATCHCRITERIA_NEW:
828 case MATCHCRITERIA_NOT_NEW:
829 case MATCHCRITERIA_MARKED:
830 case MATCHCRITERIA_NOT_MARKED:
831 case MATCHCRITERIA_DELETED:
832 case MATCHCRITERIA_NOT_DELETED:
833 case MATCHCRITERIA_REPLIED:
834 case MATCHCRITERIA_NOT_REPLIED:
835 case MATCHCRITERIA_FORWARDED:
836 case MATCHCRITERIA_NOT_FORWARDED:
837 case MATCHCRITERIA_LOCKED:
838 case MATCHCRITERIA_NOT_LOCKED:
839 case MATCHCRITERIA_COLORLABEL:
840 case MATCHCRITERIA_NOT_COLORLABEL:
841 case MATCHCRITERIA_IGNORE_THREAD:
842 case MATCHCRITERIA_NOT_IGNORE_THREAD:
843 case MATCHCRITERIA_SUBJECT:
844 case MATCHCRITERIA_NOT_SUBJECT:
845 case MATCHCRITERIA_FROM:
846 case MATCHCRITERIA_NOT_FROM:
847 case MATCHCRITERIA_TO:
848 case MATCHCRITERIA_NOT_TO:
849 case MATCHCRITERIA_CC:
850 case MATCHCRITERIA_NOT_CC:
851 case MATCHCRITERIA_TO_OR_CC:
852 case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
853 case MATCHCRITERIA_AGE_GREATER:
854 case MATCHCRITERIA_AGE_LOWER:
855 case MATCHCRITERIA_NEWSGROUPS:
856 case MATCHCRITERIA_NOT_NEWSGROUPS:
857 case MATCHCRITERIA_INREPLYTO:
858 case MATCHCRITERIA_NOT_INREPLYTO:
859 case MATCHCRITERIA_REFERENCES:
860 case MATCHCRITERIA_NOT_REFERENCES:
861 case MATCHCRITERIA_SCORE_GREATER:
862 case MATCHCRITERIA_SCORE_LOWER:
863 case MATCHCRITERIA_SCORE_EQUAL:
864 case MATCHCRITERIA_SIZE_GREATER:
865 case MATCHCRITERIA_SIZE_SMALLER:
866 case MATCHCRITERIA_SIZE_EQUAL:
867 case MATCHCRITERIA_EXECUTE:
868 case MATCHCRITERIA_NOT_EXECUTE:
869 if (matcherprop_match(matcher, info)) {
870 if (!matchers->bool_and) {
875 if (matchers->bool_and) {
882 /* test the condition on the file */
884 if (matcherlist_match_file(matchers, info, result)) {
885 if (!matchers->bool_and)
889 if (matchers->bool_and)
897 gchar *matcherprop_to_string(MatcherProp *matcher)
899 gchar *matcher_str = NULL;
901 gchar *matchtype_str;
907 for (i = 0; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)); i++) {
908 if (matchparser_tab[i].id == matcher->criteria)
909 criteria_str = matchparser_tab[i].str;
911 if (criteria_str == NULL)
914 switch (matcher->criteria) {
915 case MATCHCRITERIA_AGE_GREATER:
916 case MATCHCRITERIA_AGE_LOWER:
917 case MATCHCRITERIA_SCORE_GREATER:
918 case MATCHCRITERIA_SCORE_LOWER:
919 case MATCHCRITERIA_SCORE_EQUAL:
920 case MATCHCRITERIA_SIZE_GREATER:
921 case MATCHCRITERIA_SIZE_SMALLER:
922 case MATCHCRITERIA_SIZE_EQUAL:
923 case MATCHCRITERIA_COLORLABEL:
924 case MATCHCRITERIA_NOT_COLORLABEL:
925 return g_strdup_printf("%s %i", criteria_str, matcher->value);
926 case MATCHCRITERIA_ALL:
927 case MATCHCRITERIA_UNREAD:
928 case MATCHCRITERIA_NOT_UNREAD:
929 case MATCHCRITERIA_NEW:
930 case MATCHCRITERIA_NOT_NEW:
931 case MATCHCRITERIA_MARKED:
932 case MATCHCRITERIA_NOT_MARKED:
933 case MATCHCRITERIA_DELETED:
934 case MATCHCRITERIA_NOT_DELETED:
935 case MATCHCRITERIA_REPLIED:
936 case MATCHCRITERIA_NOT_REPLIED:
937 case MATCHCRITERIA_FORWARDED:
938 case MATCHCRITERIA_NOT_FORWARDED:
939 case MATCHCRITERIA_LOCKED:
940 case MATCHCRITERIA_NOT_LOCKED:
941 case MATCHCRITERIA_IGNORE_THREAD:
942 case MATCHCRITERIA_NOT_IGNORE_THREAD:
943 return g_strdup(criteria_str);
944 case MATCHCRITERIA_EXECUTE:
945 case MATCHCRITERIA_NOT_EXECUTE:
946 expr = matcher_escape_str(matcher->expr);
947 matcher_str = g_strdup_printf("%s \"%s\"", criteria_str, expr);
952 matchtype_str = NULL;
953 for (i = 0; i < sizeof matchparser_tab / sizeof matchparser_tab[0]; i++) {
954 if (matchparser_tab[i].id == matcher->matchtype)
955 matchtype_str = matchparser_tab[i].str;
958 if (matchtype_str == NULL)
961 switch (matcher->matchtype) {
962 case MATCHTYPE_MATCH:
963 case MATCHTYPE_MATCHCASE:
964 case MATCHTYPE_REGEXP:
965 case MATCHTYPE_REGEXPCASE:
966 expr = matcher_escape_str(matcher->expr);
967 header = matcher_escape_str(matcher->header);
969 matcher_str = g_strdup_printf
970 ("%s \"%s\" %s \"%s\"",
971 criteria_str, matcher->header,
972 matchtype_str, expr);
974 matcher_str = g_strdup_printf
975 ("%s %s \"%s\"", criteria_str,
976 matchtype_str, expr);
985 gchar *matcherlist_to_string(MatcherList *matchers)
991 gchar *result = NULL;
993 count = g_slist_length(matchers->matchers);
994 vstr = g_new(gchar *, count + 1);
996 for (l = matchers->matchers, cur_str = vstr; l != NULL;
997 l = g_slist_next(l), cur_str ++) {
998 *cur_str = matcherprop_to_string((MatcherProp *) l->data);
999 if (*cur_str == NULL)
1004 if (matchers->bool_and)
1005 result = g_strjoinv(" & ", vstr);
1007 result = g_strjoinv(" | ", vstr);
1009 for (cur_str = vstr ; *cur_str != NULL ; cur_str ++)
1016 #define STRLEN_ZERO(s) ((s) ? strlen(s) : 0)
1017 #define STRLEN_DEFAULT(s,d) ((s) ? strlen(s) : STRLEN_ZERO(d))
1018 /* matching_build_command() - preferably cmd should be unescaped */
1019 gchar *matching_build_command(gchar *cmd, MsgInfo *info)
1022 gchar *filename = NULL;
1023 gchar *processed_cmd;
1027 const gchar *const no_subject = _("(none)") ;
1028 const gchar *const no_from = _("(none)") ;
1029 const gchar *const no_to = _("(none)") ;
1030 const gchar *const no_cc = _("(none)") ;
1031 const gchar *const no_date = _("(none)") ;
1032 const gchar *const no_msgid = _("(none)") ;
1033 const gchar *const no_newsgroups = _("(none)") ;
1034 const gchar *const no_references = _("(none)") ;
1036 size = STRLEN_ZERO(cmd) + 1;
1037 while (*s != '\0') {
1044 case 's': /* subject */
1045 size += STRLEN_DEFAULT(info->subject, no_subject) - 2;
1047 case 'f': /* from */
1048 size += STRLEN_DEFAULT(info->from, no_from) - 2;
1051 size += STRLEN_DEFAULT(info->to, no_to) - 2;
1054 size += STRLEN_DEFAULT(info->cc, no_cc) - 2;
1056 case 'd': /* date */
1057 size += STRLEN_DEFAULT(info->date, no_date) - 2;
1059 case 'i': /* message-id */
1060 size += STRLEN_DEFAULT(info->msgid, no_msgid) - 2;
1062 case 'n': /* newsgroups */
1063 size += STRLEN_DEFAULT(info->newsgroups, no_newsgroups) - 2;
1065 case 'r': /* references */
1066 size += STRLEN_DEFAULT(info->references, no_references) - 2;
1068 case 'F': /* file */
1069 filename = folder_item_fetch_msg(info->folder,
1072 if (filename == NULL) {
1073 g_warning("filename is not set");
1077 size += strlen(filename) - 2;
1085 processed_cmd = g_new0(gchar, size);
1089 while (*s != '\0') {
1097 case 's': /* subject */
1098 if (info->subject != NULL)
1099 strcpy(p, info->subject);
1101 strcpy(p, no_subject);
1104 case 'f': /* from */
1105 if (info->from != NULL)
1106 strcpy(p, info->from);
1112 if (info->to != NULL)
1113 strcpy(p, info->to);
1119 if (info->cc != NULL)
1120 strcpy(p, info->cc);
1125 case 'd': /* date */
1126 if (info->date != NULL)
1127 strcpy(p, info->date);
1132 case 'i': /* message-id */
1133 if (info->msgid != NULL)
1134 strcpy(p, info->msgid);
1136 strcpy(p, no_msgid);
1139 case 'n': /* newsgroups */
1140 if (info->newsgroups != NULL)
1141 strcpy(p, info->newsgroups);
1143 strcpy(p, no_newsgroups);
1146 case 'r': /* references */
1147 if (info->references != NULL)
1148 strcpy(p, info->references);
1150 strcpy(p, no_references);
1153 case 'F': /* file */
1154 strcpy(p, filename);
1174 return processed_cmd;
1176 #undef STRLEN_DEFAULT
1179 /* ************************************************************ */
1181 static void prefs_scoring_write(FILE *fp, GSList *prefs_scoring)
1185 for (cur = prefs_scoring; cur != NULL; cur = cur->next) {
1189 prop = (ScoringProp *) cur->data;
1190 scoring_str = scoringprop_to_string(prop);
1191 if (fputs(scoring_str, fp) == EOF ||
1192 fputc('\n', fp) == EOF) {
1193 FILE_OP_ERROR("scoring config", "fputs || fputc");
1194 g_free(scoring_str);
1197 g_free(scoring_str);
1201 static void prefs_filtering_write(FILE *fp, GSList *prefs_scoring)
1205 for (cur = prefs_scoring; cur != NULL; cur = cur->next) {
1206 gchar *filtering_str;
1207 FilteringProp *prop;
1209 if (NULL == (prop = (FilteringProp *) cur->data))
1212 if (NULL == (filtering_str = filteringprop_to_string(prop)))
1215 if (fputs(filtering_str, fp) == EOF ||
1216 fputc('\n', fp) == EOF) {
1217 FILE_OP_ERROR("filtering config", "fputs || fputc");
1218 g_free(filtering_str);
1221 g_free(filtering_str);
1225 static gboolean prefs_matcher_write_func(GNode *node, gpointer data)
1230 GSList *prefs_scoring;
1231 GSList *prefs_filtering;
1235 /* prevent warning */
1236 if (item->path == NULL)
1238 id = folder_item_get_identifier(item);
1241 prefs_scoring = item->prefs->scoring;
1242 prefs_filtering = item->prefs->processing;
1246 id = g_strdup("global"); /* because it is g_freed */
1247 prefs_scoring = global_scoring;
1248 prefs_filtering = global_processing;
1251 if (prefs_filtering != NULL || prefs_scoring != NULL) {
1252 fprintf(fp, "[%s]\n", id);
1254 prefs_filtering_write(fp, prefs_filtering);
1255 prefs_scoring_write(fp, prefs_scoring);
1265 static void prefs_matcher_save(FILE *fp)
1269 for (cur = folder_get_list() ; cur != NULL ; cur = g_list_next(cur)) {
1272 folder = (Folder *) cur->data;
1273 g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1274 prefs_matcher_write_func, fp);
1276 prefs_matcher_write_func(NULL, fp);
1280 void prefs_matcher_write_config(void)
1285 debug_print("Writing matcher configuration...\n");
1287 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1290 if ((pfile = prefs_write_open(rcpath)) == NULL) {
1291 g_warning("failed to write configuration to file\n");
1297 prefs_matcher_save(pfile->fp);
1301 if (prefs_file_close(pfile) < 0) {
1302 g_warning("failed to write configuration to file\n");
1307 /* ******************************************************************* */
1309 void prefs_matcher_read_config(void)
1314 create_matchparser_hashtab();
1315 prefs_scoring_clear();
1316 prefs_filtering_clear();
1318 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, MATCHER_RC, NULL);
1319 f = fopen(rcpath, "rb");
1323 matcher_parser_start_parsing(f);
1327 /* previous version compatibily */
1329 /* printf("reading filtering\n"); */
1330 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1331 FILTERING_RC, NULL);
1332 f = fopen(rcpath, "rb");
1336 matcher_parser_start_parsing(f);
1337 fclose(matcher_parserin);
1340 /* printf("reading scoring\n"); */
1341 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1343 f = fopen(rcpath, "rb");
1347 matcher_parser_start_parsing(f);
1348 fclose(matcher_parserin);