revised filtering; currently only copy, move, mark (and combinations) have been tested
authorAlfons Hoogervorst <alfons@proteus.demon.nl>
Thu, 19 Jul 2001 17:15:49 +0000 (17:15 +0000)
committerAlfons Hoogervorst <alfons@proteus.demon.nl>
Thu, 19 Jul 2001 17:15:49 +0000 (17:15 +0000)
ChangeLog.claws
configure.in
src/filtering.c
src/filtering.h
src/inc.c
src/matcher.c
src/mbox.c
src/procmsg.h
src/summaryview.c

index 18f492b..c0fe76b 100644 (file)
@@ -1,3 +1,18 @@
+2001-07-18 [alfons]
+
+       0.5.0claws6
+
+       * src/summaryview.c
+               clean up
+
+       * src/matcher.c, src/filtering.[ch], src/inc.c, src/mbox.c,
+         src/procmsg.[ch]
+               revise filtering; currently move, copy, marking have
+               been tested. if you like bleeding edge stuff, you
+               should definitely go for this version :)
+
+       * mark old working stuff as VERSION_0_5_0_CLAWS5        
+
 2001-07-17 [christoph]
 
        * src/utils.c
index bcb460a..a9a976a 100644 (file)
@@ -8,7 +8,7 @@ MINOR_VERSION=5
 MICRO_VERSION=0
 INTERFACE_AGE=0
 BINARY_AGE=0
-EXTRA_VERSION=claws5
+EXTRA_VERSION=claws6
 VERSION=$MAJOR_VERSION.$MINOR_VERSION.$MICRO_VERSION$EXTRA_VERSION
 
 dnl
index 9113f03..e1806bf 100644 (file)
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 
-/* (alfons) - Just a quick note of how this filtering module works on 
- * new (arriving) messages.
- * 
- * 1) as an initialization step, code in inc.c and mbox.c set up the 
- *    drop folder to the inbox (see inc.c and mbox.c).
- *
- * 2) the message is actually being copied to the drop folder using
- *    folder_item_add_msg(dropfolder, file, TRUE). this function
- *    eventually calls mh->add_msg(). however, the important thing
- *    about this function is, is that the folder is not yet updated
- *    to reflect the copy. i don't know about the validity of this
- *    assumption, however, the filtering code assumes this and
- *    updates the marks itself.
- *
- * 3) technically there's nothing wrong with the matcher (the 
- *    piece of code which matches search strings). there's
- *    one gotcha in procmsg.c:procmsg_get_message_file(): it
- *    only reads a message file based on a MsgInfo. for design
- *    reasons the filtering system should read directly from
- *    a file (based on the file's name).
- *
- * 4) after the matcher sorts out any matches, it looks at the
- *    action. this part again pushes the folder system design
- *    to its limits. based on the assumption in 2), the matcher
- *    knows the message has not been added to the folder system yet.
- *    it can happily update mark files, and in fact it does.
+/* 
+ * initital    Hoa             initial
+ * 07/16/01    Alfons          fix bugs
+ * 07/18/01    Alfons          rewrite things
+ */
+
+/* 07/18/01 (alfons) 
  * 
+ * filter_message() is no longer the entry point for filtering. it's
+ * replaced with filter_incoming_message() which does not trust
+ * on MsgInfo's from a folder. instead it directly works with
+ * the temporary file.  
+ * updating the mark file is a lot easier now, because we can do that
+ * right after a call to folder_item_add_msg(). 
  */ 
 
 #include <ctype.h>
@@ -232,6 +219,19 @@ static gboolean filteringaction_update_mark(MsgInfo * info)
        return FALSE;
 }
 
+static inline gint strlen_with_check(const gchar *expr, gint fline, const gchar *str)
+{
+       if (str) 
+               return strlen(str);
+       else {
+               debug_print("%s(%d) - invalid string %s\n", __FILE__, fline, expr);
+               return 0;
+       }
+}
+
+#define STRLEN_WITH_CHECK(expr) \
+       strlen_with_check(#expr, __LINE__, expr)
+       
 static gchar * filteringaction_execute_command(gchar * cmd, MsgInfo * info)
 {
        gchar * s = cmd;
@@ -249,32 +249,34 @@ static gchar * filteringaction_execute_command(gchar * cmd, MsgInfo * info)
                                size -= 1;
                                break;
                        case 's': /* subject */
-                               size += strlen(info->subject) - 2;
+                               size += STRLEN_WITH_CHECK(info->subject) - 2;
                                break;
                        case 'f': /* from */
-                               size += strlen(info->from) - 2;
+                               size += STRLEN_WITH_CHECK(info->from) - 2;
                                break;
                        case 't': /* to */
-                               size += strlen(info->to) - 2;
+                               size += STRLEN_WITH_CHECK(info->to) - 2;
                                break;
                        case 'c': /* cc */
-                               size += strlen(info->cc) - 2;
+                               size += STRLEN_WITH_CHECK(info->cc) - 2;
                                break;
                        case 'd': /* date */
-                               size += strlen(info->date) - 2;
+                               size += STRLEN_WITH_CHECK(info->date) - 2;
                                break;
                        case 'i': /* message-id */
-                               size += strlen(info->msgid) - 2;
+                               size += STRLEN_WITH_CHECK(info->msgid) - 2;
                                break;
                        case 'n': /* newsgroups */
-                               size += strlen(info->newsgroups) - 2;
+                               size += STRLEN_WITH_CHECK(info->newsgroups) - 2;
                                break;
                        case 'r': /* references */
-                               size += strlen(info->references) - 2;
+                               size += STRLEN_WITH_CHECK(info->references) - 2;
                                break;
                        case 'F': /* file */
-                               filename = folder_item_fetch_msg(info->folder,
-                                                                info->msgnum);
+                               if (MSG_IS_FILTERING(info->flags))
+                                       filename = g_strdup(info->folder);
+                               else
+                                       filename = folder_item_fetch_msg(info->folder, info->msgnum);
                                
                                if (filename == NULL) {
                                        g_warning(_("filename is not set"));
@@ -377,6 +379,8 @@ static gchar * filteringaction_execute_command(gchar * cmd, MsgInfo * info)
                        s++;
                }
        }
+
+       g_free(filename);
        return processed_cmd;
 }
 
@@ -479,6 +483,9 @@ static gboolean filteringaction_apply(FilteringAction * action, MsgInfo * info,
 
        case MATCHING_ACTION_MARK:
                MSG_SET_PERM_FLAGS(info->flags, MSG_MARKED);
+               debug_print("*** MARKING message %d, in folder %s, \"%s\"\n",
+                           info->msgnum, info->folder->name,
+                           info->subject ? info->subject : "<none>");
                filteringaction_update_mark(info);
 
                CHANGE_FLAGS(info);
@@ -696,6 +703,364 @@ void filter_message(GSList * filtering_list, FolderItem * item,
        filter_msginfo(filtering_list, msginfo, folder_table);
 }
 
+
+/******************************************************************************/
+
+/* revised filtering system.  
+ * 
+ * 07/18/01    alfons          initial revisement
+ */
+
+/* (alfons)
+ * 
+ * the revised filtering system does not rely on a message being "registered"
+ * in one of sylpheed's folders. it now uses the file sylpheed created on
+ * incorporation of mail. 
+ * i do use MsgInfo data; that's needed by the matcher, but for the rest
+ * the MsgInfo is not really used. */
+
+/* add_mark() - adds a mark for a file */
+static void add_mark(FolderItem *folder, gint msgnum, MsgPermFlags flags)
+{
+       gchar * dest_path;
+       FILE * fp;
+
+       if (folder->folder->type == F_MH) {
+               dest_path = folder_item_get_path(folder);
+               if (!is_dir_exist(dest_path))
+                       make_dir_hier(dest_path);
+               
+               if (dest_path == NULL) {
+                       g_warning(_("Can't open mark file.\n"));
+                       return;
+               }
+               
+               if ((fp = procmsg_open_mark_file(dest_path, TRUE))
+                   == NULL) {
+                       g_warning(_("Can't open mark file.\n"));
+                       return;
+               }
+
+               /* TODO: straight from procmsg.c:procmsg_write_flags()
+                * should update this when mark file version changes */
+#if MARK_VERSION == 2           
+               WRITE_CACHE_DATA_INT(msgnum, fp);
+               WRITE_CACHE_DATA_INT(flags, fp);
+#else
+#error should rewrite the above for new  mark version  
+               /* paste the source code of procmsg.c:procmsg_write_flags() */
+#endif
+               fclose(fp);
+               return;
+       }
+       return;
+}
+
+/* prepare_destination() - prepares destination folder by registering it 
+ * in the global folder table (if not already there). it returns TRUE if
+ * successful. it also returns the FolderItem for the destination */
+static gboolean prepare_destination(const gchar *destination, FolderItem **item, 
+                                   GHashTable *folder_table)
+{
+       gint val;
+       FolderItem *result;
+
+       result = folder_find_item_from_identifier(destination);
+       if (!result)
+               return FALSE;
+       if (folder_table) {
+               *item = result;
+               val = GPOINTER_TO_INT(g_hash_table_lookup(folder_table, *item));
+               if (val == 0) {
+                       folder_item_scan(*item);
+                       g_hash_table_insert(folder_table, *item, GINT_TO_POINTER(1));
+               }
+       }
+       return TRUE;
+}
+
+/* filter_incoming_perform_actions() - performs actions on incoming
+ * message. this function handles updating marks a little bit smarter;
+ * remember that marks can only be appended. */
+static gboolean filter_incoming_perform_actions(FolderItem *default_folder, 
+                                               MsgInfo    *msginfo,
+                                               GHashTable *folder_table)
+{
+       /* matching actions for msginfo */
+       struct matching_action {
+               FilteringAction         *action;
+               struct matching_action  *next;
+       };
+
+       struct matching_action  ma_head = { NULL, NULL };
+       struct matching_action *ma_tail = &ma_head;
+
+       /* need this for the forwarding stuff */
+       PrefsAccount *account;
+       Compose      *compose;
+       MsgFlags      tmp;
+       gchar        *fwd_msg_name;
+       gint          val;
+       MsgInfo      *fwd_msg;
+
+       MsgFlags     markflags = { 0, 0 };
+
+       /* use the global prefs_filtering list */
+       GSList *     list = prefs_filtering;
+
+       /* things we get after having added a message to a folder */
+       FolderItem  *dest_folder;
+       gint         msgnum;
+       
+       /* after performing certain action, we may have to copy 
+        * the message to inbox too */
+       gboolean     copy_to_inbox_too = TRUE;
+       
+       /* filename is only put in msginfo->folder if MSG_FILTERING is set. */
+       const gchar *filename = (gchar *) msginfo->folder;
+       
+       MsgPermFlags flags;
+       gboolean     stop;
+       gchar        *cmd;
+
+       /* build list of matching actions */
+       for (; list != NULL; list = g_slist_next(list)) {
+               FilteringProp *prop = (FilteringProp *) list->data;
+               
+               if (!matcherlist_match(prop->matchers, msginfo))
+                       continue;
+
+               if (NULL == (ma_tail->next = alloca(sizeof(struct matching_action)))) {
+                       debug_print(_("action allocation error\n"));
+                       break;
+               }
+
+               debug_print("*** action %d\n", prop->action->type);
+
+               ma_tail->action = prop->action;
+               ma_tail->next->action = NULL;
+               ma_tail->next->next = NULL;
+               ma_tail = ma_tail->next;
+       }
+
+       debug_print("*** collecting marks\n");          
+       
+       /* collect all marks */
+       for (ma_tail = &ma_head, stop = FALSE; ma_tail->action && !stop; ma_tail = ma_tail->next) {
+               switch (ma_tail->action->type) {
+               
+               case MATCHING_ACTION_MARK:
+                       MSG_SET_PERM_FLAGS(markflags, MSG_MARKED);
+                       break;
+                       
+               case MATCHING_ACTION_UNMARK:
+                       MSG_UNSET_PERM_FLAGS(markflags, MSG_MARKED);
+                       break;
+               
+               case MATCHING_ACTION_MARK_AS_READ:
+                       MSG_UNSET_PERM_FLAGS(markflags, MSG_UNREAD);
+                       break;
+
+               case MATCHING_ACTION_MARK_AS_UNREAD:                    
+                       MSG_SET_PERM_FLAGS(markflags, MSG_UNREAD);
+                       break;
+
+               /* UNCONTINUABLE */
+               case MATCHING_ACTION_FORWARD:
+               case MATCHING_ACTION_FORWARD_AS_ATTACHMENT:
+               case MATCHING_ACTION_MOVE:
+               case MATCHING_ACTION_DELETE:
+                       stop = TRUE;
+                       break;
+               
+               default:
+                       break;
+               }
+       }
+
+
+       /* msgnum & dest_folder should have valid values after a succesful
+        * drop; in this case there is a MsgInfo available */
+       msgnum      = -1;
+       dest_folder = NULL;
+
+       debug_print("*** performing actions\n"); 
+       
+       for (ma_tail = &ma_head ; ma_tail->action; ma_tail = ma_tail->next) {
+
+               /* there are variables you have to use when defining new actions:
+                *
+                * copy_to_inbox_too - if the original message should be copied to the inbox 
+                *                     (default_folder) too.
+                * 
+                * also note that after dropping it to a folder (folder_item_add_msg()) you have
+                * to mark the message, just to make sure any defined mark actions are applied. */
+                
+#define ACTION (ma_tail->action->type) 
+
+               /* C O N T I N U A B L E */
+
+               if (MATCHING_ACTION_COPY == ACTION) {
+                       debug_print("*** performing copy\n");
+                       copy_to_inbox_too = TRUE;
+                       if (!prepare_destination(ma_tail->action->destination, &dest_folder, folder_table)) {
+                               debug_print("Rule failed: unknown destination %s\n", ma_tail->action->destination);
+                               continue; /* try next action */
+                       }
+                       if (0 > (msgnum = folder_item_add_msg(dest_folder, filename, FALSE))) {
+                               debug_print(_("Rule failed: could not copy to folder %s\n"),
+                                           ma_tail->action->destination);
+                               continue; /* try next action */     
+                       }   
+                       flags = msginfo->flags.perm_flags | markflags.perm_flags;
+                       add_mark(dest_folder, msgnum, flags);
+               }               
+               else if (MATCHING_EXECUTE == ACTION) {
+                       debug_print("*** performing exec\n");
+                       copy_to_inbox_too = TRUE;
+                       
+                       /* matching_build_command() knows about filtering */
+                       cmd = matching_build_command(ma_tail->action->destination, msginfo);
+                       if (cmd) { 
+                               system(cmd);
+                               g_free(cmd);
+                       }
+                       else
+                               debug_print(_("Rule failed: no command line\n"));
+               } 
+
+               /* U N C O N T I N U A B L E */
+               
+               else if (MATCHING_ACTION_FORWARD == ACTION
+               ||       MATCHING_ACTION_FORWARD_AS_ATTACHMENT == ACTION) {
+                       debug_print("*** performing forward\n");
+
+                       /* forwarding messages is complicated because there's currently no 
+                        * way to forward a message using "filenames"; you can only forward
+                        * a message if you have its MsgInfo. this means we have to drop
+                        * the message first */ 
+                       if (0 > (msgnum = folder_item_add_msg(default_folder, filename, FALSE))) {
+                               debug_print(_("Rule failed: could not forward\n"));
+                               copy_to_inbox_too = TRUE;
+                               continue;
+                       }
+                               
+                       flags = msginfo->flags.perm_flags | markflags.perm_flags;
+                       add_mark(default_folder, msgnum, flags);
+
+                       /* grab the dropped message */
+                       fwd_msg_name = folder_item_fetch_msg(default_folder, msgnum);
+
+                       tmp.perm_flags = tmp.tmp_flags = 0;
+                       fwd_msg = procheader_parse(fwd_msg_name, tmp, TRUE);
+
+                       /* do the compose_XXX stuff */
+                       account = account_find_from_id(ma_tail->action->account_id);
+                       compose = compose_forward(account, fwd_msg, ma_tail->action->type == ACTION ? FALSE : TRUE);
+                       if (compose->account->protocol == A_NNTP)
+                               compose_entry_append(compose, ma_tail->action->destination,
+                                                    COMPOSE_NEWSGROUPS);
+                       else
+                               compose_entry_append(compose, ma_tail->action->destination,
+                                                    COMPOSE_TO);
+
+                       compose_send(compose);
+
+                       procmsg_msginfo_free(fwd_msg);
+                       
+                       gtk_widget_destroy(compose->window);
+                       break;
+               }                       
+               else if (MATCHING_ACTION_DELETE == ACTION) {
+                       debug_print("*** performing delete\n");
+                       copy_to_inbox_too = FALSE;
+                       if (unlink(filename) < 0)
+                               debug_print(_("Rule failed: could not delete message\n"));
+                       break;                          
+               }
+               else if (MATCHING_ACTION_MOVE == ACTION) {
+                       debug_print("*** performing move\n");
+                       copy_to_inbox_too = FALSE;
+                       
+                       if (!prepare_destination(ma_tail->action->destination, &dest_folder, folder_table)) {
+                               copy_to_inbox_too = TRUE;
+                               break;
+                       }
+                               
+                       msgnum = folder_item_add_msg(dest_folder, filename, FALSE);
+                       if (msgnum < 0) {
+                               debug_print(_("Rule failed: could not move to folder %s\n"),
+                                           ma_tail->action->destination);
+                               copy_to_inbox_too = TRUE;                                          
+                               break;
+                       }   
+                       
+                       flags = msginfo->flags.perm_flags | markflags.perm_flags;
+                       add_mark(dest_folder, msgnum, flags);
+                       break;
+               }
+       }
+
+       /* may need to copy it to inbox too */
+       if (copy_to_inbox_too) {
+               debug_print("*** performing inbox copy\n");
+               msgnum = folder_item_add_msg(default_folder, filename, TRUE);
+               if (msgnum < 0) {
+                       debug_print(_("error copying incoming file %s to inbox\n"), 
+                                   filename);
+                       return FALSE;                               
+               }
+               flags = msginfo->flags.perm_flags | markflags.perm_flags;
+               add_mark(default_folder, msgnum, flags);
+       }
+       else {
+               debug_print("*** unlinking\n");
+               if (unlink(filename) < 0) 
+                       debug_print(_("error deleting incoming message file\n"));
+       }
+
+#undef ACTION
+
+       return TRUE;
+}
+
+static void filter_incoming_msginfo(FolderItem *default_folder, MsgInfo *msginfo, 
+                                   GHashTable *folder_table)
+{
+       filter_incoming_perform_actions(default_folder, msginfo, folder_table); 
+}
+
+/* filter_incoming_message() - tries to apply a filter on one incoming message.
+ * it also handles the case when there's no filter match */
+void filter_incoming_message(FolderItem *default_folder, const gchar *file_name, 
+                            GHashTable *folder_table)
+{
+       MsgInfo *msginfo;
+       MsgFlags msgflags = { 0, 0 };
+       
+       /* make an "uncomplete" msginfo. it's incomplete because it doesn't
+        * have a message number / folder yet. */
+       if (NULL == (msginfo = procheader_parse(file_name, msgflags, TRUE))) {
+               g_warning(_("error filtering incoming message %s\n"), 
+                         file_name);
+               return;         
+       }
+
+       /* let matcher know that this is a message that has no
+        * valid body data yet. */
+       MSG_SET_TMP_FLAGS(msginfo->flags, MSG_FILTERING);
+       msginfo->folder = g_strdup(file_name);
+       msginfo->msgnum = 0;
+
+       filter_incoming_msginfo(default_folder, msginfo, folder_table);
+
+       g_free(msginfo->folder);
+       procmsg_msginfo_free(msginfo);
+}
+
+/******************************************************************************/
+
 void prefs_filtering_read_config(void)
 {
        gchar *rcpath;
index 43fb6c5..4748109 100644 (file)
@@ -61,6 +61,8 @@ void filter_msginfo_move_or_delete(GSList * filtering_list, MsgInfo * info,
                                   GHashTable *folder_table);
 void filter_message(GSList * filtering_list, FolderItem * item,
                    gint msgnum, GHashTable *folder_table);
+void filter_incoming_message(FolderItem *default_folder, const gchar *file_name, 
+                            GHashTable *folder_table);
 
 gchar * filteringaction_to_string(FilteringAction * action);
 void prefs_filtering_write_config(void);
index 1a5faa4..afbc7e3 100644 (file)
--- a/src/inc.c
+++ b/src/inc.c
@@ -886,7 +886,7 @@ gint inc_drop_message(const gchar *file, Pop3State *state)
        FolderItem *dropfolder;
        gint val;
        gint msgnum;
-
+       
        if (state->ac_prefs->inbox) {
                inbox = folder_find_item_from_path(state->ac_prefs->inbox);
                if (!inbox)
@@ -923,18 +923,15 @@ gint inc_drop_message(const gchar *file, Pop3State *state)
                                    GINT_TO_POINTER(1));
        }
 
-       if ((msgnum = folder_item_add_msg(dropfolder, file, TRUE)) < 0) {
-               unlink(file);
-               return -1;
-       }
-
-       if (prefs_filtering != NULL) {
-               /* new filtering */
-               if (state->ac_prefs->filter_on_recv) {
-                       filter_message(prefs_filtering, dropfolder, msgnum,
-                                      state->folder_table);
+       if (prefs_filtering == NULL || !state->ac_prefs->filter_on_recv) {
+               if ((msgnum = folder_item_add_msg(dropfolder, file, TRUE)) < 0) {
+                       unlink(file);
+                       return -1;
                }
        }
+       else {
+               filter_incoming_message(dropfolder, file, state->folder_table);
+        }              
 
        return 0;
 }
index a43af9a..ccd394d 100644 (file)
@@ -1,3 +1,30 @@
+/*
+ * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2001 Hiroyuki Yamamoto & The Sylpheed Claws Team
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * 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.
+ */
+
+/* 
+ * initial     Hoa             initial
+ *
+ * 07/18/01    Alfons          when we want a file name from a MsgInfo, get that
+ *                             from MsgInfo->folder if the message is being filtered
+ *                             from incorporation. also some more safe string checking.
+ */
+
 #include <ctype.h>
 #include <string.h>
 #include <stdlib.h>
@@ -509,13 +536,8 @@ static gboolean matcherprop_string_match(MatcherProp * prop, gchar * str)
 
 gboolean matcherprop_match_execute(MatcherProp * prop, MsgInfo * info)
 {
-       gchar * file;
        gchar * cmd;
 
-       file = procmsg_get_message_file(info);
-       if (file == NULL)
-               return FALSE;
-
        cmd = matching_build_command(prop->expr, info);
        if (cmd == NULL)
                return FALSE;
@@ -903,11 +925,12 @@ gboolean matcherlist_match_file(MatcherList * matchers, MsgInfo * info,
        GSList * l;
        FILE * fp;
        gchar * file;
-
-       /* file need to be read ? */
-
+       gboolean is_incorporating = MSG_IS_FILTERING(info->flags);
+       
+       /* check which things we need to do */
        read_headers = FALSE;
-       read_body = FALSE;
+       read_body    = FALSE;
+       
        for(l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
                MatcherProp * matcher = (MatcherProp *) l->data;
 
@@ -925,7 +948,9 @@ gboolean matcherlist_match_file(MatcherList * matchers, MsgInfo * info,
        if (!read_headers && !read_body)
                return result;
 
-       file = procmsg_get_message_file(info);
+       file = is_incorporating ? g_strdup(info->folder) 
+               : procmsg_get_message_file(info);
+               
        if (file == NULL)
                return FALSE;
 
@@ -1234,6 +1259,18 @@ gchar * matcherlist_to_string(MatcherList * matchers)
        return result;
 }
 
+static inline gint strlen_with_check(const gchar *expr, gint fline, const gchar *str)
+{
+       if (str) 
+               return strlen(str);
+       else {
+               debug_print("%s(%d) - invalid string %s\n", __FILE__, fline, expr);
+               return 0;
+       }
+}
+
+#define STRLEN_WITH_CHECK(expr) \
+       strlen_with_check(#expr, __LINE__, expr)
 
 gchar * matching_build_command(gchar * cmd, MsgInfo * info)
 {
@@ -1252,35 +1289,37 @@ gchar * matching_build_command(gchar * cmd, MsgInfo * info)
                                size -= 1;
                                break;
                        case 's': /* subject */
-                               size += strlen(info->subject) - 2;
+                               size += STRLEN_WITH_CHECK(info->subject) - 2;
                                break;
                        case 'f': /* from */
-                               size += strlen(info->from) - 2;
+                               size += STRLEN_WITH_CHECK(info->from) - 2;
                                break;
                        case 't': /* to */
-                               size += strlen(info->to) - 2;
+                               size += STRLEN_WITH_CHECK(info->to) - 2;
                                break;
                        case 'c': /* cc */
-                               size += strlen(info->cc) - 2;
+                               size += STRLEN_WITH_CHECK(info->cc) - 2;
                                break;
                        case 'd': /* date */
-                               size += strlen(info->date) - 2;
+                               size += STRLEN_WITH_CHECK(info->date) - 2;
                                break;
                        case 'i': /* message-id */
-                               size += strlen(info->msgid) - 2;
+                               size += STRLEN_WITH_CHECK(info->msgid) - 2;
                                break;
                        case 'n': /* newsgroups */
-                               size += strlen(info->newsgroups) - 2;
+                               size += STRLEN_WITH_CHECK(info->newsgroups) - 2;
                                break;
                        case 'r': /* references */
-                               size += strlen(info->references) - 2;
+                               size += STRLEN_WITH_CHECK(info->references) - 2;
                                break;
                        case 'F': /* file */
-                               filename = folder_item_fetch_msg(info->folder,
-                                                                info->msgnum);
+                               if (MSG_IS_FILTERING(info->flags))
+                                       filename = g_strdup(info->folder);
+                               else                                            
+                                       filename = folder_item_fetch_msg(info->folder, info->msgnum);
                                
                                if (filename == NULL) {
-                                       g_warning(_("filename is not set"));
+                                       debug_print(_("%s(%d) - filename is not set"), __FILE__, __LINE__);
                                        return NULL;
                                }
                                else
@@ -1292,7 +1331,6 @@ gchar * matching_build_command(gchar * cmd, MsgInfo * info)
                else s++;
        }
 
-
        processed_cmd = g_new0(gchar, size);
        s = cmd;
        p = processed_cmd;
@@ -1380,6 +1418,8 @@ gchar * matching_build_command(gchar * cmd, MsgInfo * info)
                        s++;
                }
        }
+
+       g_free(filename);
        return processed_cmd;
 }
 
index cf60a2c..cc76d05 100644 (file)
@@ -224,21 +224,17 @@ gint proc_mbox(FolderItem *dest, const gchar *mbox, GHashTable *folder_table)
                } else
                        dropfolder = dest;
 
-               if ((msgnum = folder_item_add_msg(dropfolder, tmp_file, TRUE)) < 0) {
-                       fclose(mbox_fp);
-                       unlink(tmp_file);
-                       return -1;
-               }
-
-               folder_item_scan(dropfolder);
-               
-               if (prefs_filtering != NULL) {
-                       /* new filtering */
-                       if (folder_table) {
-                               filter_message(prefs_filtering, dropfolder,
-                                              msgnum, folder_table);
+               /* old filtering */
+               if (prefs_filtering == NULL || folder_table == NULL) {  
+                       if ((msgnum = folder_item_add_msg(dropfolder, tmp_file, TRUE)) < 0) {
+                               fclose(mbox_fp);
+                               unlink(tmp_file);
+                               return -1;
                        }
+                       folder_item_scan(dropfolder);
                }
+               else    
+                       filter_incoming_message(dropfolder, tmp_file, folder_table);
 
                msgs++;
        } while (from_line[0] != '\0');
index 1becc14..b506399 100644 (file)
@@ -83,6 +83,8 @@ typedef enum
        MSG_IMAP        = 1 << 19,
        MSG_NEWS        = 1 << 20,
 
+       MSG_FILTERING   = 1 << 25,      /* claws: re/set by filtering */
+
        MSG_MIME        = 1 << 29,
        MSG_CACHED      = 1 << 31
 } MsgTmpFlags;
@@ -125,6 +127,8 @@ typedef enum
 #define MSG_GET_LABEL_VALUE(msg)       (MSG_GET_LABEL(msg) >> MSG_LABEL_SBIT)
 /* 7 == nr. of colors excl. none */
 #define MSG_SET_LABEL_VALUE(msg, val)  MSG_SET_PERM_FLAGS(msg, ((((int)(val)) & 7) << MSG_LABEL_SBIT))
+#define MSG_IS_FILTERING(msg)          (((msg).tmp_flags  & MSG_FILTERING) != 0)
+
 
 #define WRITE_CACHE_DATA_INT(n, fp) \
        fwrite(&n, sizeof(n), 1, fp)
index c883e42..7fa7232 100644 (file)
@@ -309,7 +309,9 @@ static gint summary_cmp_by_label    (GtkCList               *clist,
                                         gconstpointer           ptr1,
                                         gconstpointer           ptr2);
 
+#if MARK_ALL_READ
 static void summary_mark_all_read (SummaryView *summaryview);                                   
+#endif
 
 GtkTargetEntry summary_drag_types[1] =
 {
@@ -328,7 +330,9 @@ static GtkItemFactoryEntry summary_popup_entries[] =
        {N_("/_Mark/---"),              NULL, NULL,             0, "<Separator>"},
        {N_("/_Mark/Mark as unr_ead"),  NULL, summary_mark_as_unread, 0, NULL},
        {N_("/_Mark/Mark as rea_d"),    NULL, summary_mark_as_read, 0, NULL},
+#if MARK_ALL_READ      
        {N_("/_Mark/Mark all read"),    NULL, summary_mark_all_read, 0, NULL},
+#endif 
        {N_("/_Mark/Ignore thread"),    NULL, summary_ignore_thread, 0, NULL},
        {N_("/_Mark/Unignore thread"),  NULL, summary_unignore_thread, 0, NULL},
 
@@ -452,7 +456,7 @@ void summary_set_label(SummaryView *summaryview, guint labelcolor, GtkWidget *wi
 
 /* summary_create_label_pixmaps() - creates label pixmaps. perhaps a little 
  * bit contrived. */
-static gboolean summary_create_label_pixmaps(SummaryView *summaryview)
+static void summary_create_label_pixmaps(SummaryView *summaryview)
 {
        const char *FMT = "+      c #%2.2X%2.2X%2.2X";
        char buf[40];
@@ -1262,7 +1266,9 @@ static void summary_set_menu_sensitive(SummaryView *summaryview)
 
        menu_set_sensitive(ifactory, "/Mark/Mark as unread", TRUE);
        menu_set_sensitive(ifactory, "/Mark/Mark as read",   TRUE);
+#if MARK_ALL_READ      
        menu_set_sensitive(ifactory, "/Mark/Mark all read", TRUE);
+#endif 
        menu_set_sensitive(ifactory, "/Mark/Ignore thread",   TRUE);
        menu_set_sensitive(ifactory, "/Mark/Unignore thread", TRUE);
 
@@ -2482,12 +2488,14 @@ void summary_mark_as_read(SummaryView *summaryview)
        summary_status_show(summaryview);
 }
 
+#if MARK_ALL_READ
 static void summary_mark_all_read(SummaryView *summaryview)
 {
        summary_select_all(summaryview);
        summary_mark_as_read(summaryview);
        summary_unselect_all(summaryview);
 }
+#endif
 
 static void summary_mark_row_as_unread(SummaryView *summaryview,
                                       GtkCTreeNode *row)