/*
* Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
- * Copyright (C) 2002 by the Sylpheed Claws Team and Hiroyuki Yamamoto
+ * Copyright (C) 2002-2004 by the Sylpheed Claws Team and Hiroyuki Yamamoto
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
+#include <glib.h>
+#include <glib/gi18n.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
+
#include "defs.h"
#include "utils.h"
#include "procheader.h"
#include "matcher.h"
-#include "intl.h"
#include "matcher_parser.h"
#include "prefs_gtk.h"
+#include "addr_compl.h"
+#include "codeconv.h"
+#include "quoted-printable.h"
+#include <ctype.h>
/*!
*\brief Keyword lookup element
{MATCHCRITERIA_SCORE_GREATER, "score_greater"},
{MATCHCRITERIA_SCORE_LOWER, "score_lower"},
{MATCHCRITERIA_SCORE_EQUAL, "score_equal"},
+ {MATCHCRITERIA_PARTIAL, "partial"},
+ {MATCHCRITERIA_NOT_PARTIAL, "~partial"},
{MATCHCRITERIA_SIZE_GREATER, "size_greater"},
{MATCHCRITERIA_SIZE_SMALLER, "size_smaller"},
{MATCHCRITERIA_NOT_MESSAGE, "~message"},
{MATCHCRITERIA_BODY_PART, "body_part"},
{MATCHCRITERIA_NOT_BODY_PART, "~body_part"},
- {MATCHCRITERIA_EXECUTE, "execute"},
- {MATCHCRITERIA_NOT_EXECUTE, "~execute"},
+ {MATCHCRITERIA_TEST, "test"},
+ {MATCHCRITERIA_NOT_TEST, "~test"},
/* match type */
{MATCHTYPE_MATCHCASE, "matchcase"},
{MATCHTYPE_MATCH, "match"},
{MATCHTYPE_REGEXPCASE, "regexpcase"},
{MATCHTYPE_REGEXP, "regexp"},
+ {MATCHTYPE_ANY_IN_ADDRESSBOOK, "any_in_addressbook"},
+ {MATCHTYPE_ALL_IN_ADDRESSBOOK, "all_in_addressbook"},
/* actions */
- {MATCHACTION_SCORE, "score"},
+ {MATCHACTION_SCORE, "score"}, /* for backward compatibility */
{MATCHACTION_MOVE, "move"},
{MATCHACTION_COPY, "copy"},
{MATCHACTION_DELETE, "delete"},
{MATCHACTION_MARK, "mark"},
{MATCHACTION_UNMARK, "unmark"},
+ {MATCHACTION_LOCK, "lock"},
+ {MATCHACTION_UNLOCK, "unlock"},
{MATCHACTION_MARK_AS_READ, "mark_as_read"},
{MATCHACTION_MARK_AS_UNREAD, "mark_as_unread"},
{MATCHACTION_FORWARD, "forward"},
{MATCHACTION_EXECUTE, "execute"},
{MATCHACTION_COLOR, "color"},
{MATCHACTION_REDIRECT, "redirect"},
- {MATCHACTION_CHANGE_SCORE, "change_score"}
+ {MATCHACTION_CHANGE_SCORE, "change_score"},
+ {MATCHACTION_SET_SCORE, "set_score"},
+ {MATCHACTION_STOP, "stop"},
+ {MATCHACTION_HIDE, "hide"},
+ {MATCHACTION_IGNORE, "ignore"},
};
/*!
return -1;
}
-/*!
- *\brief Escape characters in a string by inserting '\' characters
- *
- *\param str String with characters to be escaped
- *
- *\return gchar * Newly allocated string with escaped characters
- */
-gchar *matcher_escape_str(const gchar *str)
-{
- register const gchar *walk;
- register int escape;
- gchar *res;
- register char *reswalk;
-
- if (str == NULL)
- return NULL;
-
- for (escape = 0, walk = str; *walk; walk++)
- if (*walk == '\\' || *walk == '\'' || *walk == '\"')
- escape++;
-
- if (!escape)
- return g_strdup(str);
-
- reswalk = res = g_new0(gchar, (walk - str) + escape + 1);
- for (walk = str; *walk; walk++, reswalk++) {
- if (*walk == '\\' || *walk == '\'' || *walk == '\"')
- *reswalk++ = '\\';
- *reswalk = *walk;
- }
-
- *reswalk = 0;
- return res;
-}
-
-/*!
- *\brief Unescape string by replacing escaped char sequences
- * (\b, \n, etc) by their actual char. Note that this
- * function changes the contents of the buffer pointed
- * to by \a str.
- *
- *\param str Buffer containing string that needs to be escaped.
- * Note that this function changes the contents of the
- * buffer
- *
- *\return gchar * Pointer to changed buffer
- */
-gchar *matcher_unescape_str(gchar *str)
-{
- gchar *tmp = alloca(strlen(str) + 1);
- register gchar *src = tmp;
- register gchar *dst = str;
-
- strcpy(tmp, str);
-
- for ( ; *src; src++) {
- if (*src != '\\')
- *dst++ = *src;
- else {
- src++;
- 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 == '\'' || *src == '\"')
- /* insert \\, \' or \" */
- *dst++ = *src;
- else {
- /* FIXME: should perhaps escape character... */
- src--;
- *dst++ = *src;
- }
- }
- }
- *dst = 0;
- return str;
-}
-
/* **************** data structure allocation **************** */
/*!
*/
void matcherprop_free(MatcherProp *prop)
{
- if (prop->expr)
- g_free(prop->expr);
- if (prop->header)
- g_free(prop->header);
+ g_free(prop->expr);
+ g_free(prop->header);
if (prop->preg != NULL) {
regfree(prop->preg);
g_free(prop->preg);
return prop;
}
-/* ****************** wrapper for file reading ************** */
+/* ************** match ******************************/
-/*!
- *\brief Allocate a matcher structure where all strings
- * are unescaped ("unquoted")
- *
- *\param criteria One of the MATCHCRITERIA_XXX constants
- *\param header A header string
- *\param matchtype Type of matcher (MATCHTYPE_XXX)
- *\param expr Matcher string expression
- *\param value Matcher integer value
- *
- *\return MatcherProp * Pointer to newly allocated matcher
- * structure
- */
-MatcherProp *matcherprop_unquote_new(gint criteria, const gchar *header,
- gint matchtype, const gchar *expr,
- int value)
+static gboolean match_with_addresses_in_addressbook
+ (MatcherProp *prop, const gchar *str, gint type)
{
- MatcherProp *prop;
+ GSList *address_list = NULL;
+ GSList *walk;
+ gboolean res = FALSE;
- if (expr != NULL)
- expr = matcher_unescape_str(g_strdup(expr));
+ if (str == NULL || *str == 0)
+ return FALSE;
+
+ /* XXX: perhaps complete with comments too */
+ address_list = address_list_append(address_list, str);
+ if (!address_list)
+ return FALSE;
- if (header != NULL)
- header = matcher_unescape_str(g_strdup(header));
-
- prop = matcherprop_new(criteria, header, matchtype, expr, value);
+ start_address_completion();
+ res = FALSE;
+ for (walk = address_list; walk != NULL; walk = walk->next) {
+ gboolean found = complete_address(walk->data) ? TRUE : FALSE;
+
+ g_free(walk->data);
+ if (!found && type == MATCHTYPE_ALL_IN_ADDRESSBOOK) {
+ res = FALSE;
+ break;
+ } else if (found)
+ res = TRUE;
+ }
- g_free((gpointer) header);
- g_free((gpointer) expr);
+ g_slist_free(address_list);
- return prop;
+ end_address_completion();
+
+ return res;
}
-
-/* ************** match ******************************/
-
/*!
*\brief Find out if a string matches a condition
*
return TRUE;
else
return FALSE;
+
+ case MATCHTYPE_ALL_IN_ADDRESSBOOK:
+ case MATCHTYPE_ANY_IN_ADDRESSBOOK:
+ return match_with_addresses_in_addressbook
+ (prop, str, prop->matchtype);
case MATCHTYPE_MATCH:
return (strstr(str, prop->expr) != NULL);
}
}
+/* FIXME body search is a hack. */
+static gboolean matcherprop_string_decode_match(MatcherProp *prop, const gchar *str)
+{
+ gchar *utf = NULL;
+ gchar tmp[BUFFSIZE];
+ gboolean res = FALSE;
+
+ if (str == NULL)
+ return FALSE;
+
+ /* we try to decode QP first, because it's faster than base64 */
+ qp_decode_const(tmp, BUFFSIZE-1, str);
+ if (!g_utf8_validate(tmp, -1, NULL)) {
+ utf = conv_codeset_strdup
+ (tmp, conv_get_locale_charset_str_no_utf8(),
+ CS_INTERNAL);
+ res = matcherprop_string_match(prop, utf);
+ g_free(utf);
+ } else {
+ res = matcherprop_string_match(prop, tmp);
+ }
+
+ if (res == FALSE && (strchr(prop->expr, '=') || strchr(prop->expr, '_')) ) {
+ /* if searching for something with an equal char, maybe
+ * we should try to match the non-decoded string.
+ * In case it was not qp-encoded. */
+ if (!g_utf8_validate(str, -1, NULL)) {
+ utf = conv_codeset_strdup
+ (str, conv_get_locale_charset_str_no_utf8(),
+ CS_INTERNAL);
+ res = matcherprop_string_match(prop, utf);
+ } else {
+ res = matcherprop_string_match(prop, str);
+ }
+ }
+
+ /* FIXME base64 decoding is too slow, especially since text can
+ * easily be handled as base64. Don't even try now. */
+
+ return res;
+}
+
/*!
*\brief Execute a command defined in the matcher structure
*
*
*\return gboolean TRUE if command was executed succesfully
*/
-static gboolean matcherprop_match_execute(const MatcherProp *prop,
+static gboolean matcherprop_match_test(const MatcherProp *prop,
MsgInfo *info)
{
gchar *file;
case MATCHCRITERIA_SIZE_SMALLER:
/* FIXME: info->size is an off_t */
return info->size < (off_t) prop->value;
+ case MATCHCRITERIA_PARTIAL:
+ /* FIXME: info->size is an off_t */
+ return (info->total_size != 0 && info->size != (off_t)info->total_size);
+ case MATCHCRITERIA_NOT_PARTIAL:
+ /* FIXME: info->size is an off_t */
+ return (info->total_size == 0 || info->size == (off_t)info->total_size);
case MATCHCRITERIA_NEWSGROUPS:
return matcherprop_string_match(prop, info->newsgroups);
case MATCHCRITERIA_NOT_NEWSGROUPS:
return matcherprop_string_match(prop, info->inreplyto);
case MATCHCRITERIA_NOT_INREPLYTO:
return !matcherprop_string_match(prop, info->inreplyto);
- case MATCHCRITERIA_REFERENCES:
- return matcherprop_string_match(prop, info->references);
+ /* FIXME: Using inreplyto, but matching the (newly implemented)
+ * list of references is better */
+ case MATCHCRITERIA_REFERENCES:
+ return matcherprop_string_match(prop, info->inreplyto);
case MATCHCRITERIA_NOT_REFERENCES:
- return !matcherprop_string_match(prop, info->references);
- case MATCHCRITERIA_EXECUTE:
- return matcherprop_match_execute(prop, info);
- case MATCHCRITERIA_NOT_EXECUTE:
- return !matcherprop_match_execute(prop, info);
+ return !matcherprop_string_match(prop, info->inreplyto);
+ case MATCHCRITERIA_TEST:
+ return matcherprop_match_test(prop, info);
+ case MATCHCRITERIA_NOT_TEST:
+ return !matcherprop_match_test(prop, info);
default:
return 0;
}
}
break;
case MATCHCRITERIA_HEADERS_PART:
- case MATCHCRITERIA_MESSAGE:
return matcherprop_string_match(matcher, buf);
+ case MATCHCRITERIA_MESSAGE:
+ return matcherprop_string_decode_match(matcher, buf);
case MATCHCRITERIA_NOT_MESSAGE:
+ return !matcherprop_string_decode_match(matcher, buf);
case MATCHCRITERIA_NOT_HEADERS_PART:
return !matcherprop_string_match(matcher, buf);
}
}
}
-/*!
- *\brief Check if a list of conditions match a header
- *
- *\param matchers One set of conditions
- *\param buf Name of header
- *
- *\return gboolean TRUE if matching should stop
- */
-static gboolean matcherlist_match_one_header(MatcherList *matchers,
- gchar *buf)
-{
- GSList *l;
-
- for (l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
- MatcherProp *matcher = (MatcherProp *) l->data;
-
- /* see if a single condition matches */
- if (matcherprop_criteria_headers(matcher) ||
- matcherprop_criteria_message(matcher)) {
- if (matcherprop_match_one_header(matcher, buf)) {
- matcher->result = TRUE;
- }
- }
-
- if (matcherprop_criteria_headers(matcher)) {
- if (matcher->result) {
- if (!matchers->bool_and)
- return TRUE;
- }
- }
- }
-
- return FALSE;
-}
-
/*!
*\brief Check if a list of conditions matches one header in
* a message file.
*/
static gboolean matcherlist_match_headers(MatcherList *matchers, FILE *fp)
{
+ GSList *l;
gchar buf[BUFFSIZE];
- while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1)
- if (matcherlist_match_one_header(matchers, buf))
- return TRUE;
-
+ while (procheader_get_one_field(buf, sizeof(buf), fp, NULL) != -1) {
+ for (l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
+ MatcherProp *matcher = (MatcherProp *) l->data;
+
+ if (matcher->done)
+ continue;
+
+ /* if the criteria is ~headers_part or ~message, ZERO lines
+ * must NOT match for the rule to match. */
+ if (matcher->criteria == MATCHCRITERIA_NOT_HEADERS_PART ||
+ matcher->criteria == MATCHCRITERIA_NOT_MESSAGE) {
+ if (matcherprop_match_one_header(matcher, buf)) {
+ matcher->result = TRUE;
+ } else {
+ matcher->result = FALSE;
+ matcher->done = TRUE;
+ }
+ /* else, just one line matching is enough for the rule to match
+ */
+ } else if (matcherprop_criteria_headers(matcher) ||
+ matcherprop_criteria_message(matcher)){
+ if (matcherprop_match_one_header(matcher, buf)) {
+ matcher->result = TRUE;
+ matcher->done = TRUE;
+ }
+ }
+
+ /* if the rule matched and the matchers are OR, no need to
+ * check the others */
+ if (matcher->result && matcher->done) {
+ if (!matchers->bool_and)
+ return TRUE;
+ }
+ }
+ }
return FALSE;
}
switch (matcher->criteria) {
case MATCHCRITERIA_BODY_PART:
case MATCHCRITERIA_MESSAGE:
- return matcherprop_string_match(matcher, line);
+ return matcherprop_string_decode_match(matcher, line);
case MATCHCRITERIA_NOT_BODY_PART:
case MATCHCRITERIA_NOT_MESSAGE:
- return !matcherprop_string_match(matcher, line);
- }
- return FALSE;
-}
-
-/*!
- *\brief Check if a list of conditions matches a (line) string
- *
- *\param matchers List of matchers
- *\param line String to match
- *
- *\return gboolean TRUE if string matches list of criteria
- */
-static gboolean matcherlist_match_line(MatcherList *matchers, const gchar *line)
-{
- GSList *l;
-
- for (l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
- MatcherProp *matcher = (MatcherProp *) l->data;
-
- if (matcherprop_criteria_body(matcher) ||
- matcherprop_criteria_message(matcher)) {
- if (matcherprop_match_line(matcher, line)) {
- matcher->result = TRUE;
- }
- }
-
- if (matcher->result) {
- if (!matchers->bool_and)
- return TRUE;
- }
+ return !matcherprop_string_decode_match(matcher, line);
}
return FALSE;
}
*/
static gboolean matcherlist_match_body(MatcherList *matchers, FILE *fp)
{
+ GSList *l;
gchar buf[BUFFSIZE];
+
+ while (fgets(buf, sizeof(buf), fp) != NULL) {
+ for (l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
+ MatcherProp *matcher = (MatcherProp *) l->data;
+
+ if (matcher->done)
+ continue;
+
+ /* if the criteria is ~body_part or ~message, ZERO lines
+ * must NOT match for the rule to match. */
+ if (matcher->criteria == MATCHCRITERIA_NOT_BODY_PART ||
+ matcher->criteria == MATCHCRITERIA_NOT_MESSAGE) {
+ if (matcherprop_match_line(matcher, buf)) {
+ matcher->result = TRUE;
+ } else {
+ matcher->result = FALSE;
+ matcher->done = TRUE;
+ }
+ /* else, just one line has to match */
+ } else if (matcherprop_criteria_body(matcher) ||
+ matcherprop_criteria_message(matcher)) {
+ if (matcherprop_match_line(matcher, buf)) {
+ matcher->result = TRUE;
+ matcher->done = TRUE;
+ }
+ }
- while (fgets(buf, sizeof(buf), fp) != NULL)
- if (matcherlist_match_line(matchers, buf))
- return TRUE;
-
+ /* if the matchers are OR'ed and the rule matched,
+ * no need to check the others. */
+ if (matcher->result && matcher->done) {
+ if (!matchers->bool_and)
+ return TRUE;
+ }
+ }
+ }
return FALSE;
}
read_body = TRUE;
}
matcher->result = FALSE;
+ matcher->done = FALSE;
}
if (!read_headers && !read_body)
return result;
- file = procmsg_get_message_file(info);
+ file = procmsg_get_message_file_full(info, read_headers, read_body);
if (file == NULL)
return FALSE;
- if ((fp = fopen(file, "rb")) == NULL) {
+ if ((fp = g_fopen(file, "rb")) == NULL) {
FILE_OP_ERROR(file, "fopen");
g_free(file);
return result;
if (read_headers) {
if (matcherlist_match_headers(matchers, fp))
read_body = FALSE;
- }
- else {
+ } else {
matcherlist_skip_headers(fp);
}
GSList *l;
gboolean result;
+ if (!matchers)
+ return FALSE;
+
if (matchers->bool_and)
result = TRUE;
else
case MATCHCRITERIA_SIZE_GREATER:
case MATCHCRITERIA_SIZE_SMALLER:
case MATCHCRITERIA_SIZE_EQUAL:
- case MATCHCRITERIA_EXECUTE:
- case MATCHCRITERIA_NOT_EXECUTE:
+ case MATCHCRITERIA_TEST:
+ case MATCHCRITERIA_NOT_TEST:
+ case MATCHCRITERIA_PARTIAL:
+ case MATCHCRITERIA_NOT_PARTIAL:
if (matcherprop_match(matcher, info)) {
if (!matchers->bool_and) {
return TRUE;
return result;
}
+
+static gint quote_filter_str(gchar * result, guint size,
+ const gchar * path)
+{
+ const gchar * p;
+ gchar * result_p;
+ guint remaining;
+
+ result_p = result;
+ remaining = size;
+
+ for(p = path ; * p != '\0' ; p ++) {
+
+ if ((* p != '\"') && (* p != '\\')) {
+ if (remaining > 0) {
+ * result_p = * p;
+ result_p ++;
+ remaining --;
+ }
+ else {
+ result[size - 1] = '\0';
+ return -1;
+ }
+ }
+ else {
+ if (remaining >= 2) {
+ * result_p = '\\';
+ result_p ++;
+ * result_p = * p;
+ result_p ++;
+ remaining -= 2;
+ }
+ else {
+ result[size - 1] = '\0';
+ return -1;
+ }
+ }
+ }
+ if (remaining > 0) {
+ * result_p = '\0';
+ }
+ else {
+ result[size - 1] = '\0';
+ return -1;
+ }
+
+ return 0;
+}
+
+
+gchar * matcher_quote_str(const gchar * src)
+{
+ gchar * res;
+ gint len;
+
+ len = strlen(src) * 2 + 1;
+ res = g_malloc(len);
+ quote_filter_str(res, len, src);
+
+ return res;
+}
+
/*!
*\brief Convert a matcher structure to a string
*
const gchar *criteria_str;
const gchar *matchtype_str;
int i;
- gchar *expr;
-
+ gchar * quoted_expr;
+
criteria_str = NULL;
for (i = 0; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)); i++) {
if (matchparser_tab[i].id == matcher->criteria)
case MATCHCRITERIA_NOT_FORWARDED:
case MATCHCRITERIA_LOCKED:
case MATCHCRITERIA_NOT_LOCKED:
+ case MATCHCRITERIA_PARTIAL:
+ case MATCHCRITERIA_NOT_PARTIAL:
case MATCHCRITERIA_IGNORE_THREAD:
case MATCHCRITERIA_NOT_IGNORE_THREAD:
return g_strdup(criteria_str);
- case MATCHCRITERIA_EXECUTE:
- case MATCHCRITERIA_NOT_EXECUTE:
- expr = matcher_escape_str(matcher->expr);
- matcher_str = g_strdup_printf("%s \"%s\"", criteria_str, expr);
- g_free((gpointer) expr);
+ case MATCHCRITERIA_TEST:
+ case MATCHCRITERIA_NOT_TEST:
+ quoted_expr = matcher_quote_str(matcher->expr);
+ matcher_str = g_strdup_printf("%s \"%s\"",
+ criteria_str, quoted_expr);
+ g_free(quoted_expr);
return matcher_str;
}
case MATCHTYPE_MATCHCASE:
case MATCHTYPE_REGEXP:
case MATCHTYPE_REGEXPCASE:
- expr = matcher_escape_str(matcher->expr);
- if (matcher->header)
+ case MATCHTYPE_ALL_IN_ADDRESSBOOK:
+ case MATCHTYPE_ANY_IN_ADDRESSBOOK:
+ quoted_expr = matcher_quote_str(matcher->expr);
+ if (matcher->header) {
+ gchar * quoted_header;
+
+ quoted_header = matcher_quote_str(matcher->header);
matcher_str = g_strdup_printf
("%s \"%s\" %s \"%s\"",
- criteria_str, matcher->header,
- matchtype_str, expr);
+ criteria_str, quoted_header,
+ matchtype_str, quoted_expr);
+ g_free(quoted_header);
+ }
else
matcher_str = g_strdup_printf
("%s %s \"%s\"", criteria_str,
- matchtype_str, expr);
- g_free((gpointer) expr);
+ matchtype_str, quoted_expr);
+ g_free(quoted_expr);
break;
}
return result;
}
+
#define STRLEN_ZERO(s) ((s) ? strlen(s) : 0)
#define STRLEN_DEFAULT(s,d) ((s) ? strlen(s) : STRLEN_ZERO(d))
+
+static void add_str_default(gchar ** dest,
+ const gchar * s, const gchar * d)
+{
+ gchar quoted_str[4096];
+ const gchar * str;
+
+ if (s != NULL)
+ str = s;
+ else
+ str = d;
+
+ quote_cmd_argument(quoted_str, sizeof(quoted_str), str);
+ strcpy(* dest, quoted_str);
+
+ (* dest) += strlen(* dest);
+}
+
/* matching_build_command() - preferably cmd should be unescaped */
/*!
*\brief Build the command line to execute
*\param info Message info to use for command
*
*\return gchar * Newly allocated string
- *
- *\warning The \a cmd string should have been unescaped using
- * #matcher_unescape_str.
*/
gchar *matching_build_command(const gchar *cmd, MsgInfo *info)
{
size += STRLEN_DEFAULT(info->newsgroups, no_newsgroups) - 2;
break;
case 'r': /* references */
- size += STRLEN_DEFAULT(info->references, no_references) - 2;
+ /* FIXME: using the inreplyto header for reference */
+ size += STRLEN_DEFAULT(info->inreplyto, no_references) - 2;
break;
case 'F': /* file */
- filename = folder_item_fetch_msg(info->folder,
- info->msgnum);
+ if (filename == NULL)
+ filename = folder_item_fetch_msg(info->folder, info->msgnum);
if (filename == NULL) {
g_warning("filename is not set");
return NULL;
}
- else
+ else {
size += strlen(filename) - 2;
+ }
break;
}
s++;
}
else s++;
}
+
+ /* as the string can be quoted, we double the result */
+ size *= 2;
processed_cmd = g_new0(gchar, size);
s = cmd;
p++;
break;
case 's': /* subject */
- if (info->subject != NULL)
- strcpy(p, info->subject);
- else
- strcpy(p, no_subject);
- p += strlen(p);
+ add_str_default(&p, info->subject,
+ no_subject);
break;
case 'f': /* from */
- if (info->from != NULL)
- strcpy(p, info->from);
- else
- strcpy(p, no_from);
- p += strlen(p);
+ add_str_default(&p, info->from,
+ no_from);
break;
case 't': /* to */
- if (info->to != NULL)
- strcpy(p, info->to);
- else
- strcpy(p, no_to);
- p += strlen(p);
+ add_str_default(&p, info->to,
+ no_to);
break;
case 'c': /* cc */
- if (info->cc != NULL)
- strcpy(p, info->cc);
- else
- strcpy(p, no_cc);
- p += strlen(p);
+ add_str_default(&p, info->cc,
+ no_cc);
break;
case 'd': /* date */
- if (info->date != NULL)
- strcpy(p, info->date);
- else
- strcpy(p, no_date);
- p += strlen(p);
+ add_str_default(&p, info->date,
+ no_date);
break;
case 'i': /* message-id */
- if (info->msgid != NULL)
- strcpy(p, info->msgid);
- else
- strcpy(p, no_msgid);
- p += strlen(p);
+ add_str_default(&p, info->msgid,
+ no_msgid);
break;
case 'n': /* newsgroups */
- if (info->newsgroups != NULL)
- strcpy(p, info->newsgroups);
- else
- strcpy(p, no_newsgroups);
- p += strlen(p);
+ add_str_default(&p, info->newsgroups,
+ no_newsgroups);
break;
case 'r': /* references */
- if (info->references != NULL)
- strcpy(p, info->references);
- else
- strcpy(p, no_references);
- p += strlen(p);
+ /* FIXME: using the inreplyto header for references */
+ add_str_default(&p, info->inreplyto, no_references);
break;
case 'F': /* file */
- strcpy(p, filename);
- p += strlen(p);
- g_free(filename);
+ if (filename != NULL)
+ add_str_default(&p, filename, NULL);
break;
default:
*p = '%';
s++;
}
}
-
+ g_free(filename);
+
return processed_cmd;
}
#undef STRLEN_DEFAULT
/* ************************************************************ */
-/*!
- *\brief Write scoring list to file
- *
- *\param fp File
- *\param prefs_scoring List of scoring conditions
- */
-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);
- }
-}
/*!
*\brief Write filtering list to file
for (cur = prefs_filtering; cur != NULL; cur = cur->next) {
gchar *filtering_str;
+ gchar *tmp_name = NULL;
FilteringProp *prop;
if (NULL == (prop = (FilteringProp *) cur->data))
if (NULL == (filtering_str = filteringprop_to_string(prop)))
continue;
-
- if (fputs(filtering_str, fp) == EOF ||
+
+ if (prop->enabled) {
+ if (fputs("enabled ", fp) == EOF) {
+ FILE_OP_ERROR("filtering config", "fputs || fputc");
+ return;
+ }
+ } else {
+ if (fputs("disabled ", fp) == EOF) {
+ FILE_OP_ERROR("filtering config", "fputs || fputc");
+ return;
+ }
+ }
+
+ if (fputs("rulename \"", fp) == EOF) {
+ FILE_OP_ERROR("filtering config", "fputs || fputc");
+ g_free(filtering_str);
+ return;
+ }
+ tmp_name = prop->name;
+ while (tmp_name && *tmp_name != '\0') {
+ if (*tmp_name != '"') {
+ if (fputc(*tmp_name, fp) == EOF) {
+ FILE_OP_ERROR("filtering config", "fputc");
+ g_free(filtering_str);
+ return;
+ }
+ } else if (*tmp_name == '"') {
+ if (fputc('\\', fp) == EOF ||
+ fputc('"', fp) == EOF) {
+ FILE_OP_ERROR("filtering config", "fputc");
+ g_free(filtering_str);
+ return;
+ }
+ }
+ tmp_name ++;
+ }
+ if(fputs("\" ", fp) == EOF ||
+ fputs(filtering_str, fp) == EOF ||
fputc('\n', fp) == EOF) {
FILE_OP_ERROR("filtering config", "fputs || fputc");
g_free(filtering_str);
FolderItem *item;
FILE *fp = data;
gchar *id;
- GSList *prefs_scoring;
GSList *prefs_filtering;
- if (node != NULL) {
- item = node->data;
- /* prevent 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;
- }
+ item = node->data;
+ /* prevent warning */
+ if (item->path == NULL)
+ return FALSE;
+ id = folder_item_get_identifier(item);
+ if (id == NULL)
+ return FALSE;
+ prefs_filtering = item->prefs->processing;
- if (prefs_filtering != NULL || prefs_scoring != NULL) {
+ if (prefs_filtering != NULL) {
fprintf(fp, "[%s]\n", id);
-
prefs_filtering_write(fp, prefs_filtering);
- prefs_scoring_write(fp, prefs_scoring);
-
fputc('\n', fp);
}
g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
prefs_matcher_write_func, fp);
}
- prefs_matcher_write_func(NULL, fp);
+
+ /* pre global rules */
+ fprintf(fp, "[preglobal]\n");
+ prefs_filtering_write(fp, pre_global_processing);
+ fputc('\n', fp);
+
+ /* post global rules */
+ fprintf(fp, "[postglobal]\n");
+ prefs_filtering_write(fp, post_global_processing);
+ fputc('\n', fp);
+
+ /* filtering rules */
+ fprintf(fp, "[filtering]\n");
+ prefs_filtering_write(fp, filtering_rules);
+ fputc('\n', fp);
}
/*!
/* ******************************************************************* */
+void matcher_add_rulenames(const gchar *rcpath)
+{
+ gchar *newpath = g_strconcat(rcpath, ".new", NULL);
+ FILE *src = g_fopen(rcpath, "rb");
+ FILE *dst = g_fopen(newpath, "wb");
+ gchar buf[BUFFSIZE];
+
+ if (dst == NULL) {
+ perror("fopen");
+ g_free(newpath);
+ return;
+ }
+
+ while (fgets (buf, sizeof(buf), src) != NULL) {
+ if (strlen(buf) > 2 && buf[0] != '['
+ && strncmp(buf, "rulename \"", 10)) {
+ fwrite("rulename \"\" ",
+ strlen("rulename \"\" "), 1, dst);
+ }
+ fwrite(buf, strlen(buf), 1, dst);
+ }
+ fclose(dst);
+ fclose(src);
+ move_file(newpath, rcpath, TRUE);
+ g_free(newpath);
+}
+
/*!
*\brief Read matcher configuration
*/
void prefs_matcher_read_config(void)
{
gchar *rcpath;
+ gchar *rc_old_format;
FILE *f;
create_matchparser_hashtab();
- prefs_scoring_clear();
prefs_filtering_clear();
rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, MATCHER_RC, NULL);
- f = fopen(rcpath, "rb");
+ rc_old_format = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, MATCHER_RC,
+ ".pre_names", NULL);
+
+ if (!is_file_exist(rc_old_format) && is_file_exist(rcpath)) {
+ /* backup file with no rules names, in case
+ * anything goes wrong */
+ copy_file(rcpath, rc_old_format, FALSE);
+ /* now hack the file in order to have it to the new format */
+ matcher_add_rulenames(rcpath);
+ }
+
+ g_free(rc_old_format);
+
+ f = g_fopen(rcpath, "rb");
g_free(rcpath);
if (f != NULL) {
matcher_parser_start_parsing(f);
- fclose(f);
+ fclose(matcher_parserin);
}
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");
+ f = g_fopen(rcpath, "rb");
g_free(rcpath);
if (f != NULL) {
/* printf("reading scoring\n"); */
rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
SCORING_RC, NULL);
- f = fopen(rcpath, "rb");
+ f = g_fopen(rcpath, "rb");
g_free(rcpath);
if (f != NULL) {