#include "matcher.h"
#include "intl.h"
#include "matcher_parser.h"
+#include "prefs.h"
struct _MatchParser {
gint id;
typedef struct _MatchParser MatchParser;
-static MatchParser matchcriteria_str_tab[] = {
+static MatchParser matchparser_tab[] = {
/* msginfo flags */
{MATCHCRITERIA_ALL, "all"},
{MATCHCRITERIA_UNREAD, "unread"},
{MATCHCRITERIA_NOT_REFERENCES, "~references"},
{MATCHCRITERIA_SCORE_GREATER, "score_greater"},
{MATCHCRITERIA_SCORE_LOWER, "score_lower"},
+ {MATCHCRITERIA_SCORE_EQUAL, "score_equal"},
+
+ {MATCHCRITERIA_SIZE_GREATER, "size_greater"},
+ {MATCHCRITERIA_SIZE_SMALLER, "size_smaller"},
+ {MATCHCRITERIA_SIZE_EQUAL, "size_equal"},
/* content have to be read */
{MATCHCRITERIA_HEADER, "header"},
{MATCHCRITERIA_BODY_PART, "body_part"},
{MATCHCRITERIA_NOT_BODY_PART, "~body_part"},
{MATCHCRITERIA_EXECUTE, "execute"},
- {MATCHCRITERIA_NOT_EXECUTE, "~execute"}
-};
+ {MATCHCRITERIA_NOT_EXECUTE, "~execute"},
-static MatchParser matchtype_str_tab[] = {
/* match type */
{MATCHTYPE_MATCHCASE, "matchcase"},
{MATCHTYPE_MATCH, "match"},
{MATCHTYPE_REGEXPCASE, "regexpcase"},
- {MATCHTYPE_REGEXP, "regexp"}
-};
+ {MATCHTYPE_REGEXP, "regexp"},
-static MatchParser matchaction_str_tab[] = {
/* actions */
{MATCHACTION_SCORE, "score"},
-
- /* actions */
{MATCHACTION_MOVE, "move"},
{MATCHACTION_COPY, "copy"},
{MATCHACTION_DELETE, "delete"},
{MATCHACTION_MARK_AS_UNREAD, "mark_as_unread"},
{MATCHACTION_FORWARD, "forward"},
{MATCHACTION_FORWARD_AS_ATTACHMENT, "forward_as_attachment"},
- {MATCHCRITERIA_EXECUTE, "execute"}
+ {MATCHACTION_EXECUTE, "execute"},
+ {MATCHACTION_COLOR, "color"},
+ {MATCHACTION_BOUNCE, "bounce"},
+ {MATCHACTION_DELETE_ON_SERVER, "delete_on_server"}
};
-gchar * get_matchparser_str(MatchParser * tab, gint size, gint id)
+/* get_matchparser_tab_str() - used by filtering.c to translate
+ * actions to debug strings */
+gchar * get_matchparser_tab_str(gint id)
{
gint i;
- for(i = 0 ; i < size ; i++) {
- if (tab[i].id == id)
- return tab[i].str;
- }
- return NULL;
-}
-
-gchar * get_matchcriteria_str(gint id)
-{
- return get_matchparser_str(matchcriteria_str_tab,
- (int) (sizeof(matchcriteria_str_tab) /
- sizeof(MatchParser)), id);
-}
-
-gchar * get_matchtype_str(gint id)
-{
- return get_matchparser_str(matchtype_str_tab,
- (int) (sizeof(matchtype_str_tab) /
- sizeof(MatchParser)), id);
-}
-
-gchar * get_matchaction_str(gint id)
-{
- return get_matchparser_str(matchaction_str_tab,
- (int) (sizeof(matchaction_str_tab) /
- sizeof(MatchParser)), id);
-}
-
-
-
-/*
- syntax for matcher
-
- header "x-mailing" match "toto"
- subject match "regexp" & to regexp "regexp"
- subject match "regexp" | to regexpcase "regexp" | age_sup 5
- */
-
-static gboolean matcher_is_blank(gchar ch);
-
-/* ******************* parser *********************** */
-
-static gboolean matcher_is_blank(gchar ch)
-{
- return (ch == ' ') || (ch == '\t');
-}
-
-/* parse for one condition */
-
-/*
-MatcherProp * matcherprop_parse(gchar ** str)
-{
- MatcherProp * prop;
- gchar * tmp;
- gint key;
- gint value;
- gchar * expr;
- gint match;
- gchar * header = NULL;
-
- tmp = * str;
- key = matcher_parse_keyword(&tmp);
- if (tmp == NULL) {
- * str = NULL;
- return NULL;
- }
-
- switch (key) {
- case MATCHCRITERIA_AGE_LOWER:
- case MATCHCRITERIA_AGE_GREATER:
- case MATCHCRITERIA_SCORE_LOWER:
- case MATCHCRITERIA_SCORE_GREATER:
- value = matcher_parse_number(&tmp);
- if (tmp == NULL) {
- * str = NULL;
- return NULL;
- }
- *str = tmp;
-
- prop = matcherprop_new(key, NULL, 0, NULL, value);
-
- return prop;
-
- case MATCHCRITERIA_ALL:
- case MATCHCRITERIA_UNREAD:
- case MATCHCRITERIA_NOT_UNREAD:
- case MATCHCRITERIA_NEW:
- case MATCHCRITERIA_NOT_NEW:
- case MATCHCRITERIA_MARKED:
- case MATCHCRITERIA_NOT_MARKED:
- case MATCHCRITERIA_DELETED:
- case MATCHCRITERIA_NOT_DELETED:
- case MATCHCRITERIA_REPLIED:
- case MATCHCRITERIA_NOT_REPLIED:
- case MATCHCRITERIA_FORWARDED:
- case MATCHCRITERIA_NOT_FORWARDED:
- prop = matcherprop_new(key, NULL, 0, NULL, 0);
- *str = tmp;
-
- return prop;
-
- case MATCHCRITERIA_SUBJECT:
- case MATCHCRITERIA_NOT_SUBJECT:
- case MATCHCRITERIA_FROM:
- case MATCHCRITERIA_NOT_FROM:
- case MATCHCRITERIA_TO:
- case MATCHCRITERIA_NOT_TO:
- case MATCHCRITERIA_CC:
- case MATCHCRITERIA_NOT_CC:
- case MATCHCRITERIA_TO_OR_CC:
- case MATCHCRITERIA_NOT_TO_AND_NOT_CC:
- case MATCHCRITERIA_NEWSGROUPS:
- case MATCHCRITERIA_NOT_NEWSGROUPS:
- case MATCHCRITERIA_INREPLYTO:
- case MATCHCRITERIA_NOT_REFERENCES:
- case MATCHCRITERIA_REFERENCES:
- case MATCHCRITERIA_NOT_INREPLYTO:
- case MATCHCRITERIA_MESSAGE:
- case MATCHCRITERIA_NOT_MESSAGE:
- case MATCHCRITERIA_EXECUTE:
- case MATCHCRITERIA_NOT_EXECUTE:
- case MATCHCRITERIA_HEADERS_PART:
- case MATCHCRITERIA_NOT_HEADERS_PART:
- case MATCHCRITERIA_BODY_PART:
- case MATCHCRITERIA_NOT_BODY_PART:
- case MATCHCRITERIA_HEADER:
- case MATCHCRITERIA_NOT_HEADER:
- if ((key == MATCHCRITERIA_HEADER) || (key == MATCHCRITERIA_NOT_HEADER)) {
- header = matcher_parse_str(&tmp);
- if (tmp == NULL) {
- * str = NULL;
- return NULL;
- }
- }
-
- match = matcher_parse_keyword(&tmp);
- if (tmp == NULL) {
- if (header)
- g_free(header);
- * str = NULL;
- return NULL;
- }
-
- switch(match) {
- case MATCHCRITERIA_REGEXP:
- case MATCHCRITERIA_REGEXPCASE:
- expr = matcher_parse_regexp(&tmp);
- if (tmp == NULL) {
- if (header)
- g_free(header);
- * str = NULL;
- return NULL;
- }
- *str = tmp;
- prop = matcherprop_new(key, header, match, expr, 0);
- g_free(expr);
-
- return prop;
- case MATCHCRITERIA_MATCH:
- case MATCHCRITERIA_MATCHCASE:
- expr = matcher_parse_str(&tmp);
- if (tmp == NULL) {
- if (header)
- g_free(header);
- * str = NULL;
- return NULL;
- }
- *str = tmp;
- prop = matcherprop_new(key, header, match, expr, 0);
- g_free(expr);
-
- return prop;
- default:
- if (header)
- g_free(header);
- * str = NULL;
- return NULL;
- }
- default:
- * str = NULL;
- return NULL;
- }
-}
-
-gint matcher_parse_keyword(gchar ** str)
-{
- gchar * p;
- gchar * dup;
- gchar * start;
- gint i;
- gint match;
-
- dup = alloca(strlen(* str) + 1);
- p = dup;
- strcpy(dup, * str);
-
- while (matcher_is_blank(*p))
- p++;
-
- start = p;
-
- while (!matcher_is_blank(*p) && (*p != '\0'))
- p++;
-
- match = -1;
for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
i++) {
- if ((strlen(matchparser_tab[i].str) == p - start) &&
- (strncasecmp(matchparser_tab[i].str, start,
- p - start) == 0)) {
- match = i;
- break;
- }
- }
-
- if (match == -1) {
- * str = NULL;
- return 0;
- }
-
- *p = '\0';
-
- *str += p - dup + 1;
- return matchparser_tab[match].id;
-}
-
-gint matcher_parse_number(gchar ** str)
-{
- gchar * p;
- gchar * dup;
- gchar * start;
-
- dup = alloca(strlen(* str) + 1);
- p = dup;
- strcpy(dup, * str);
-
- while (matcher_is_blank(*p))
- p++;
-
- start = p;
-
- if (!isdigit(*p) && *p != '-' && *p != '+') {
- *str = NULL;
- return 0;
- }
- if (*p == '-' || *p == '+')
- p++;
- while (isdigit(*p))
- p++;
-
- *p = '\0';
-
- *str += p - dup + 1;
- return atoi(start);
-}
-
-gboolean matcher_parse_boolean_op(gchar ** str)
-{
- gchar * p;
-
- p = * str;
-
- while (matcher_is_blank(*p))
- p++;
-
- if (*p == '|') {
- *str += p - * str + 1;
- return FALSE;
+ if (matchparser_tab[i].id == id)
+ return matchparser_tab[i].str;
}
- else if (*p == '&') {
- *str += p - * str + 1;
- return TRUE;
- }
- else {
- *str = NULL;
- return FALSE;
- }
-}
-
-gchar * matcher_parse_regexp(gchar ** str)
-{
- gchar * p;
- gchar * dup;
- gchar * start;
-
- dup = alloca(strlen(* str) + 1);
- p = dup;
- strcpy(dup, * str);
-
- while (matcher_is_blank(*p))
- p++;
-
- if (*p != '/') {
- * str = NULL;
- return NULL;
- }
-
- p ++;
- start = p;
- while (*p != '/') {
- if (*p == '\\')
- p++;
- p++;
- }
- *p = '\0';
-
- *str += p - dup + 2;
- return g_strdup(start);
+ return NULL;
}
-gchar * matcher_parse_str(gchar ** str)
+/* matcher_unescape_str() - assumes that unescaping frees up room
+ * in the string, so it returns the unescaped string in the
+ * source */
+gchar *matcher_unescape_str(gchar *str)
{
- gchar * p;
- gchar * dup;
- gchar * start;
- gchar * dest;
-
- dup = alloca(strlen(* str) + 1);
- p = dup;
- strcpy(dup, * str);
-
- while (matcher_is_blank(*p))
- p++;
-
- if (*p != '"') {
- * str = NULL;
- return NULL;
- }
+ gchar *tmp = alloca(strlen(str) + 1);
+ register gchar *src = tmp;
+ register gchar *dst = str;
- p ++;
- start = p;
- dest = p;
- while (*p != '"') {
- if (*p == '\\') {
- p++;
- *dest = *p;
+ strcpy(tmp, str);
+
+ for ( ; *src; src++) {
+ if (*src != '\\')
+ *dst++ = *src;
+ else {
+ src++;
+ if (*src == '\\')
+ *dst++ = '\\'; /* insert backslash */
+ else if (*src == 'n') /* insert control characters */
+ *dst++ = '\n';
+ else if (*src == 'r')
+ *dst++ = '\r';
+ else if (*src == 't')
+ *dst++ = '\t';
+ else if (*src == 'r')
+ *dst++ = '\r';
+ else if (*src == 'b')
+ *dst++ = '\b';
+ else if (*src == 'f')
+ *dst++ = '\f';
+ else if (*src == '\'' || *src == '\"') /* insert \' or \" */
+ *dst++ = *src;
+ else {
+ /* FIXME: should perhaps escape character... */
+ src--;
+ *dst++ = *src;
+ }
}
- else
- *dest = *p;
- dest++;
- p++;
}
- *dest = '\0';
-
- *str += dest - dup + 2;
- return g_strdup(start);
+ *dst = 0;
+ return str;
}
-*/
/* **************** data structure allocation **************** */
-
+/* matcherprop_new() - allocates a structure for one condition
+ */
MatcherProp * matcherprop_new(gint criteria, gchar * header,
gint matchtype, gchar * expr,
int value)
prop = g_new0(MatcherProp, 1);
prop->criteria = criteria;
- if (header != NULL)
- prop->header = g_strdup(header);
- else
- prop->header = NULL;
- if (expr != NULL)
- prop->expr = g_strdup(expr);
- else
- prop->expr = NULL;
+ if (header != NULL) {
+ prop->header = g_strdup(header);
+ prop->unesc_header = matcher_unescape_str(g_strdup(header));
+ }
+ else {
+ prop->header = NULL;
+ prop->unesc_header = NULL;
+ }
+ if (expr != NULL) {
+ prop->expr = g_strdup(expr);
+ prop->unesc_expr = matcher_unescape_str(g_strdup(expr));
+ }
+ else {
+ prop->expr = NULL;
+ prop->unesc_expr = NULL;
+ }
prop->matchtype = matchtype;
prop->preg = NULL;
prop->value = value;
return prop;
}
+/* matcherprop_free()
+ */
void matcherprop_free(MatcherProp * prop)
{
- g_free(prop->expr);
+ if (prop->expr)
+ g_free(prop->expr);
+ if (prop->unesc_expr)
+ g_free(prop->unesc_expr);
+ if (prop->header)
+ g_free(prop->header);
+ if (prop->unesc_header)
+ g_free(prop->unesc_header);
if (prop->preg != NULL) {
regfree(prop->preg);
g_free(prop->preg);
/* ************** match ******************************/
-/* match the given string */
-
+/* matcherprop_string_match() - finds out if a string matches
+ * with a criterium */
static gboolean matcherprop_string_match(MatcherProp * prop, gchar * str)
{
gchar * str1;
case MATCHTYPE_REGEXP:
if (!prop->preg && (prop->error == 0)) {
prop->preg = g_new0(regex_t, 1);
+ /* if regexp then don't use the escaped string */
if (regcomp(prop->preg, prop->expr,
REG_NOSUB | REG_EXTENDED
- | ((prop->matchtype ==
- MATCHTYPE_REGEXPCASE)
+ | ((prop->matchtype == MATCHTYPE_REGEXPCASE)
? REG_ICASE : 0)) != 0) {
prop->error = 1;
g_free(prop->preg);
return FALSE;
case MATCHTYPE_MATCH:
- return (strstr(str, prop->expr) != NULL);
+ return (strstr(str, prop->unesc_expr) != NULL);
+ /* FIXME: put upper in unesc_str */
case MATCHTYPE_MATCHCASE:
- str2 = alloca(strlen(prop->expr) + 1);
- strcpy(str2, prop->expr);
+ str2 = alloca(strlen(prop->unesc_expr) + 1);
+ strcpy(str2, prop->unesc_expr);
g_strup(str2);
str1 = alloca(strlen(str) + 1);
strcpy(str1, str);
if (file == NULL)
return FALSE;
- cmd = matching_build_command(prop->expr, info);
+ cmd = matching_build_command(prop->unesc_expr, info);
if (cmd == NULL)
return FALSE;
return info->score >= prop->value;
case MATCHCRITERIA_SCORE_LOWER:
return info->score <= prop->value;
+ case MATCHCRITERIA_SCORE_EQUAL:
+ return info->score == prop->value;
+ case MATCHCRITERIA_SIZE_GREATER:
+ /* FIXME: info->size is an off_t */
+ return info->size > (off_t) prop->value;
+ case MATCHCRITERIA_SIZE_EQUAL:
+ /* FIXME: info->size is an off_t */
+ return info->size == (off_t) prop->value;
+ case MATCHCRITERIA_SIZE_SMALLER:
+ /* FIXME: info->size is an off_t */
+ return info->size < (off_t) prop->value;
case MATCHCRITERIA_NEWSGROUPS:
return matcherprop_string_match(prop, info->newsgroups);
case MATCHCRITERIA_NOT_NEWSGROUPS:
/* ********************* MatcherList *************************** */
-/* parse for a list of conditions */
-
-/*
-MatcherList * matcherlist_parse(gchar ** str)
-{
- gchar * tmp;
- MatcherProp * matcher;
- GSList * matchers_list = NULL;
- gboolean bool_and = TRUE;
- gchar * save;
- MatcherList * cond;
- gboolean main_bool_and = TRUE;
- GSList * l;
-
- tmp = * str;
-
- matcher = matcherprop_parse(&tmp);
-
- if (tmp == NULL) {
- * str = NULL;
- return NULL;
- }
- matchers_list = g_slist_append(matchers_list, matcher);
- while (matcher) {
- save = tmp;
- bool_and = matcher_parse_boolean_op(&tmp);
- if (tmp == NULL) {
- tmp = save;
- matcher = NULL;
- }
- else {
- main_bool_and = bool_and;
- matcher = matcherprop_parse(&tmp);
- if (tmp != NULL) {
- matchers_list =
- g_slist_append(matchers_list, matcher);
- }
- else {
- for(l = matchers_list ; l != NULL ;
- l = g_slist_next(l))
- matcherprop_free((MatcherProp *)
- l->data);
- g_slist_free(matchers_list);
- * str = NULL;
- return NULL;
- }
- }
- }
-
- cond = matcherlist_new(matchers_list, main_bool_and);
-
- * str = tmp;
-
- return cond;
-}
-*/
-
MatcherList * matcherlist_new(GSList * matchers, gboolean bool_and)
{
MatcherList * cond;
if (file == NULL)
return FALSE;
- if ((fp = fopen(file, "r")) == NULL) {
+ if ((fp = fopen(file, "rb")) == NULL) {
FILE_OP_ERROR(file, "fopen");
g_free(file);
return result;
MatcherProp * matcher = (MatcherProp *) l->data;
if (matcherprop_criteria_headers(matcher) ||
- matcherprop_criteria_body(matcher) ||
- matcherprop_criteria_message(matcher))
+ matcherprop_criteria_body(matcher) ||
+ matcherprop_criteria_message(matcher)) {
if (matcher->result) {
if (!matchers->bool_and) {
result = TRUE;
result = FALSE;
break;
}
- }
+ }
+ }
}
g_free(file);
case MATCHCRITERIA_NOT_REFERENCES:
case MATCHCRITERIA_SCORE_GREATER:
case MATCHCRITERIA_SCORE_LOWER:
+ case MATCHCRITERIA_SCORE_EQUAL:
+ case MATCHCRITERIA_SIZE_GREATER:
+ case MATCHCRITERIA_SIZE_SMALLER:
+ case MATCHCRITERIA_SIZE_EQUAL:
case MATCHCRITERIA_EXECUTE:
case MATCHCRITERIA_NOT_EXECUTE:
if (matcherprop_match(matcher, info)) {
return result;
}
-#if 0
-static void matcherprop_print(MatcherProp * matcher)
-{
- int i;
-
- if (matcher == NULL) {
- printf("no matcher\n");
- return;
- }
-
- switch (matcher->matchtype) {
- case MATCHCRITERIA_MATCH:
- printf("match\n");
- break;
- case MATCHCRITERIA_REGEXP:
- printf("regexp\n");
- break;
- case MATCHCRITERIA_MATCHCASE:
- printf("matchcase\n");
- break;
- case MATCHCRITERIA_REGEXPCASE:
- printf("regexpcase\n");
- break;
- }
-
- for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
- i++) {
- if (matchparser_tab[i].id == matcher->criteria)
- printf("%s\n", matchparser_tab[i].str);
- }
-
- if (matcher->expr)
- printf("expr : %s\n", matcher->expr);
-
- printf("age: %i\n", matcher->value;
-
- printf("compiled : %s\n", matcher->preg != NULL ? "yes" : "no");
- printf("error: %i\n", matcher->error);
-}
-#endif
gchar * matcherprop_to_string(MatcherProp * matcher)
{
gchar * out;
criteria_str = NULL;
-
- criteria_str = get_matchcriteria_str(matcher->criteria);
-
+ for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
+ i++) {
+ if (matchparser_tab[i].id == matcher->criteria)
+ criteria_str = matchparser_tab[i].str;
+ }
if (criteria_str == NULL)
return NULL;
case MATCHCRITERIA_AGE_LOWER:
case MATCHCRITERIA_SCORE_GREATER:
case MATCHCRITERIA_SCORE_LOWER:
+ case MATCHCRITERIA_SCORE_EQUAL:
+ case MATCHCRITERIA_SIZE_GREATER:
+ case MATCHCRITERIA_SIZE_SMALLER:
+ case MATCHCRITERIA_SIZE_EQUAL:
return g_strdup_printf("%s %i", criteria_str, matcher->value);
- break;
case MATCHCRITERIA_ALL:
case MATCHCRITERIA_UNREAD:
case MATCHCRITERIA_NOT_UNREAD:
}
matchtype_str = NULL;
-
- matchtype_str = get_matchtype_str(matcher->matchtype);
+ for(i = 0 ; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)) ;
+ i++) {
+ if (matchparser_tab[i].id == matcher->matchtype)
+ matchtype_str = matchparser_tab[i].str;
+ }
if (matchtype_str == NULL)
return NULL;
- count = 0;
- for(p = matcher->expr; *p != 0 ; p++)
- if ((*p == '\"') || (*p == '\\')) count ++;
-
- expr_str = g_new(char, strlen(matcher->expr) + count + 1);
-
- for(p = matcher->expr, out = expr_str ; *p != 0 ; p++, out++) {
- switch (*p) {
- case '\"':
- case '\\':
- *out = '\\'; out++;
- *out = *p;
- break;
- default:
- *out = *p;
- }
+ switch (matcher->matchtype) {
+ case MATCHTYPE_MATCH:
+ case MATCHTYPE_MATCHCASE:
+ case MATCHTYPE_REGEXP:
+ case MATCHTYPE_REGEXPCASE:
+ if (matcher->header)
+ matcher_str =
+ g_strdup_printf("%s \"%s\" %s \"%s\"",
+ criteria_str, matcher->header,
+ matchtype_str, matcher->expr);
+ else
+ matcher_str =
+ g_strdup_printf("%s %s \"%s\"", criteria_str,
+ matchtype_str, matcher->expr);
+ break;
}
- * out = '\0';
-
- if (matcher->header)
- matcher_str =
- g_strdup_printf("%s \"%s\" %s \"%s\"",
- criteria_str, matcher->header,
- matchtype_str, expr_str);
- else
- matcher_str =
- g_strdup_printf("%s %s \"%s\"", criteria_str,
- matchtype_str, expr_str);
-
- g_free(expr_str);
-
+
return matcher_str;
}
return result;
}
-
+/* matching_build_command() - preferably cmd should be unescaped */
gchar * matching_build_command(gchar * cmd, MsgInfo * info)
{
gchar * s = cmd;
if (info->subject != NULL)
strcpy(p, info->subject);
else
- strcpy(p, "(none)");
+ strcpy(p, _("(none)"));
p += strlen(p);
break;
case 'f': /* from */
if (info->from != NULL)
strcpy(p, info->from);
else
- strcpy(p, "(none)");
+ strcpy(p, _("(none)"));
p += strlen(p);
break;
case 't': /* to */
if (info->to != NULL)
strcpy(p, info->to);
else
- strcpy(p, "(none)");
+ strcpy(p, _("(none)"));
p += strlen(p);
break;
case 'c': /* cc */
if (info->cc != NULL)
strcpy(p, info->cc);
else
- strcpy(p, "(none)");
+ strcpy(p, _("(none)"));
p += strlen(p);
break;
case 'd': /* date */
if (info->date != NULL)
strcpy(p, info->date);
else
- strcpy(p, "(none)");
+ strcpy(p, _("(none)"));
p += strlen(p);
break;
case 'i': /* message-id */
if (info->msgid != NULL)
strcpy(p, info->msgid);
else
- strcpy(p, "(none)");
+ strcpy(p, _("(none)"));
p += strlen(p);
break;
case 'n': /* newsgroups */
if (info->newsgroups != NULL)
strcpy(p, info->newsgroups);
else
- strcpy(p, "(none)");
+ strcpy(p, _("(none)"));
p += strlen(p);
break;
case 'r': /* references */
if (info->references != NULL)
strcpy(p, info->references);
else
- strcpy(p, "(none)");
+ strcpy(p, _("(none)"));
p += strlen(p);
break;
case 'F': /* file */
s++;
}
}
+
+ debug_print("*** exec string \"%s\"\n", processed_cmd);
return processed_cmd;
}
+
+/* ************************************************************ */
+
+static void prefs_scoring_write(FILE * fp, GSList * prefs_scoring)
+{
+ GSList * cur;
+
+ for (cur = prefs_scoring; cur != NULL; cur = cur->next) {
+ gchar *scoring_str;
+ ScoringProp * prop;
+
+ prop = (ScoringProp *) cur->data;
+ scoring_str = scoringprop_to_string(prop);
+ if (fputs(scoring_str, fp) == EOF ||
+ fputc('\n', fp) == EOF) {
+ FILE_OP_ERROR("scoring config", "fputs || fputc");
+ g_free(scoring_str);
+ return;
+ }
+ g_free(scoring_str);
+ }
+}
+
+static void prefs_filtering_write(FILE * fp, GSList * prefs_scoring)
+{
+ GSList * cur;
+
+ for (cur = prefs_scoring; cur != NULL; cur = cur->next) {
+ gchar *filtering_str;
+ FilteringProp * prop;
+
+ prop = (FilteringProp *) cur->data;
+ filtering_str = filteringprop_to_string(prop);
+
+ if (fputs(filtering_str, fp) == EOF ||
+ fputc('\n', fp) == EOF) {
+ FILE_OP_ERROR("filtering config", "fputs || fputc");
+ g_free(filtering_str);
+ return;
+ }
+ g_free(filtering_str);
+ }
+}
+
+static gboolean prefs_matcher_write_func(GNode *node, gpointer data)
+{
+ FolderItem *item;
+ FILE * fp = data;
+ gchar * id;
+ GSList * prefs_scoring;
+ GSList * prefs_filtering;
+
+ if (node != NULL) {
+ item = node->data;
+ /* prevent from the warning */
+ if (item->path == NULL)
+ return FALSE;
+ id = folder_item_get_identifier(item);
+ if (id == NULL)
+ return FALSE;
+ prefs_scoring = item->prefs->scoring;
+ prefs_filtering = item->prefs->processing;
+ }
+ else {
+ item = NULL;
+ id = g_strdup("global"); /* because it is g_freed */
+ prefs_scoring = global_scoring;
+ prefs_filtering = global_processing;
+ }
+
+ if (prefs_filtering != NULL || prefs_scoring != NULL) {
+ fprintf(fp, "[%s]\n", id);
+
+ prefs_filtering_write(fp, prefs_filtering);
+ prefs_scoring_write(fp, prefs_scoring);
+
+ fputc('\n', fp);
+ }
+
+ g_free(id);
+
+ return FALSE;
+}
+
+static void prefs_matcher_save(FILE * fp)
+{
+ GList * cur;
+
+ for (cur = folder_get_list() ; cur != NULL ; cur = g_list_next(cur)) {
+ Folder *folder;
+
+ folder = (Folder *) cur->data;
+ g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
+ prefs_matcher_write_func, fp);
+ }
+ prefs_matcher_write_func(NULL, fp);
+}
+
+
+void prefs_matcher_write_config(void)
+{
+ gchar *rcpath;
+ PrefFile *pfile;
+ GSList *cur;
+ ScoringProp * prop;
+
+ debug_print(_("Writing matcher configuration...\n"));
+
+ rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+ MATCHER_RC, NULL);
+
+ if ((pfile = prefs_write_open(rcpath)) == NULL) {
+ g_warning(_("failed to write configuration to file\n"));
+ g_free(rcpath);
+ return;
+ }
+
+
+ prefs_matcher_save(pfile->fp);
+
+ g_free(rcpath);
+
+ if (prefs_write_close(pfile) < 0) {
+ g_warning(_("failed to write configuration to file\n"));
+ return;
+ }
+}
+
+/* ******************************************************************* */
+
+void prefs_matcher_read_config(void)
+{
+ gchar * rcpath;
+ FILE * f;
+
+ prefs_scoring_clear();
+ prefs_filtering_clear();
+
+ rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, MATCHER_RC, NULL);
+ f = fopen(rcpath, "rb");
+ g_free(rcpath);
+
+ if (f != NULL)
+ matcher_parser_start_parsing(f);
+ else {
+ /* previous version compatibily */
+
+ printf("reading filtering\n");
+ rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+ FILTERING_RC, NULL);
+ f = fopen(rcpath, "rb");
+ g_free(rcpath);
+
+ if (f != NULL) {
+ matcher_parser_start_parsing(f);
+ fclose(matcher_parserin);
+ }
+
+ printf("reading scoring\n");
+ rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
+ SCORING_RC, NULL);
+ f = fopen(rcpath, "rb");
+ g_free(rcpath);
+
+ if (f != NULL) {
+ matcher_parser_start_parsing(f);
+ fclose(matcher_parserin);
+ }
+ }
+}