?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Sync Spanish manual
[claws.git] / src / filtering.c
blobb5353f46b4f5a0f8c030e30f2738e5fd7c797744
1 /*
2 * Claws Mail -- a GTK based, lightweight, and fast e-mail client
3 * Copyright (C) 1999-2020 the Claws Mail Team and Hiroyuki Yamamoto
4 *
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 3 of the License, or
8 * (at your option) any later version.
9 *
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.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
17 */
18
19 #include "config.h"
20 #include "defs.h"
21 #include <glib.h>
22 #include <glib/gi18n.h>
23 #include <ctype.h>
24 #include <string.h>
25 #include <stdlib.h>
26 #include <errno.h>
27 #include <gtk/gtk.h>
28 #include <stdio.h>
29
30 #include "utils.h"
31 #include "procheader.h"
32 #include "matcher.h"
33 #include "filtering.h"
34 #include "prefs_gtk.h"
35 #include "compose.h"
36 #include "prefs_common.h"
37 #include "addritem.h"
38 #ifndef USE_ALT_ADDRBOOK
39 #include "addrbook.h"
40 #include "addressbook.h"
41 #else
42 #include "addressbook-dbus.h"
43 #include "addressadd.h"
44 #endif
45 #include "addr_compl.h"
46 #include "tags.h"
47 #include "log.h"
48 #include "account.h"
49 #include "addrindex.h"
50 #include "folder_item_prefs.h"
51
52 GSList * pre_global_processing = NULL;
53 GSList * post_global_processing = NULL;
54 GSList * filtering_rules = NULL;
55
56 gboolean debug_filtering_session = FALSE;
57
58 static gboolean filtering_is_final_action(FilteringAction *filtering_action);
59
60 FilteringAction * filteringaction_new(int type, int account_id,
61 gchar * destination,
62 gint labelcolor, gint score, gchar * header)
63 {
64 FilteringAction * action;
65
66 action = g_new0(FilteringAction, 1);
67
68 action->type = type;
69 action->account_id = account_id;
70 if (destination) {
71 action->destination = g_strdup(destination);
72 } else {
73 action->destination = NULL;
74 }
75 if (header) {
76 action->header = g_strdup(header);
77 } else {
78 action->header = NULL;
79 }
80 action->labelcolor = labelcolor;
81 action->score = score;
82 return action;
83 }
84
85 void filteringaction_free(FilteringAction * action)
86 {
87 cm_return_if_fail(action);
88 g_free(action->header);
89 g_free(action->destination);
90 g_free(action);
91 }
92
93 static gint action_list_sort(gconstpointer a, gconstpointer b)
94 {
95 int first = filtering_is_final_action((FilteringAction *) a) ? 1 : 0;
96 int second = filtering_is_final_action((FilteringAction *) b) ? 1 : 0;
97
98 return (first - second);
99 }
100
101 GSList *filtering_action_list_sort(GSList *action_list)
102 {
103 return g_slist_sort(action_list, action_list_sort);
104 }
105
106 FilteringProp * filteringprop_new(gboolean enabled,
107 const gchar *name,
108 gint account_id,
109 MatcherList * matchers,
110 GSList * action_list)
111 {
112 FilteringProp * filtering;
113
114 filtering = g_new0(FilteringProp, 1);
115 filtering->enabled = enabled;
116 filtering->name = name ? g_strdup(name): NULL;
117 filtering->account_id = account_id;
118 filtering->matchers = matchers;
119 filtering->action_list = filtering_action_list_sort(action_list);
120
121 return filtering;
122 }
123
124 static FilteringAction * filteringaction_copy(FilteringAction * src)
125 {
126 FilteringAction * new;
127
128 new = g_new0(FilteringAction, 1);
129
130 new->type = src->type;
131 new->account_id = src->account_id;
132 if (src->destination)
133 new->destination = g_strdup(src->destination);
134 else
135 new->destination = NULL;
136 new->labelcolor = src->labelcolor;
137 new->score = src->score;
138
139 return new;
140 }
141
142 FilteringProp * filteringprop_copy(FilteringProp *src)
143 {
144 FilteringProp * new;
145 GSList *tmp;
146
147 new = g_new0(FilteringProp, 1);
148 new->matchers = g_new0(MatcherList, 1);
149
150 for (tmp = src->matchers->matchers; tmp != NULL && tmp->data != NULL;) {
151 MatcherProp *matcher = (MatcherProp *)tmp->data;
152
153 new->matchers->matchers = g_slist_append(new->matchers->matchers,
154 matcherprop_copy(matcher));
155 tmp = tmp->next;
156 }
157
158 new->matchers->bool_and = src->matchers->bool_and;
159
160 new->action_list = NULL;
161
162 for (tmp = src->action_list ; tmp != NULL ; tmp = tmp->next) {
163 FilteringAction *filtering_action;
164
165 filtering_action = tmp->data;
166
167 new->action_list = g_slist_append(new->action_list,
168 filteringaction_copy(filtering_action));
169 }
170
171 new->enabled = src->enabled;
172 new->name = g_strdup(src->name);
173
174 return new;
175 }
176
177 void filteringprop_free(FilteringProp * prop)
178 {
179 GSList * tmp;
180
181 cm_return_if_fail(prop);
182 matcherlist_free(prop->matchers);
183
184 for (tmp = prop->action_list ; tmp != NULL ; tmp = tmp->next) {
185 filteringaction_free(tmp->data);
186 }
187 g_slist_free(prop->action_list);
188 g_free(prop->name);
189 g_free(prop);
190 }
191
192 /* move and copy messages by batches to be faster on IMAP */
193 void filtering_move_and_copy_msgs(GSList *msgs)
194 {
195 GSList *messages = g_slist_copy(msgs);
196 FolderItem *last_item = NULL;
197 FiltOp cur_op = IS_NOTHING;
198
199 debug_print("checking %d messages\n", g_slist_length(msgs));
200 while (messages) {
201 GSList *batch = NULL, *cur;
202 gint found = 0;
203 for (cur = messages; cur; cur = cur->next) {
204 MsgInfo *info = (MsgInfo *)cur->data;
205 if (last_item == NULL) {
206 if (info->filter_op == IS_COPY || info->filter_op == IS_MOVE)
207 last_item = info->to_filter_folder;
208 else if (info->filter_op == IS_DELE)
209 last_item = info->folder;
210 }
211 if (last_item == NULL)
212 continue;
213 if (cur_op == IS_NOTHING) {
214 if (info->filter_op == IS_COPY)
215 cur_op = IS_COPY;
216 else if (info->filter_op == IS_MOVE)
217 cur_op = IS_MOVE;
218 else if (info->filter_op == IS_DELE)
219 cur_op = IS_DELE;
220 }
221 if (info->filter_op == IS_COPY || info->filter_op == IS_MOVE) {
222 if (info->to_filter_folder == last_item
223 && cur_op == info->filter_op) {
224 found++;
225 batch = g_slist_prepend(batch, info);
226 }
227 } else if (info->filter_op == IS_DELE) {
228 if (info->folder == last_item
229 && cur_op == info->filter_op) {
230 found++;
231 batch = g_slist_prepend(batch, info);
232 }
233 }
234 }
235 if (found == 0) {
236 debug_print("no more messages to move/copy/del\n");
237 break;
238 } else {
239 debug_print("%d messages to %s in %s\n", found,
240 cur_op==IS_COPY ? "copy":(cur_op==IS_DELE ?"delete":"move"),
241 last_item->name ? last_item->name:"(noname)");
242 }
243 for (cur = batch; cur; cur = cur->next) {
244 MsgInfo *info = (MsgInfo *)cur->data;
245 messages = g_slist_remove(messages, info);
246 info->to_filter_folder = NULL;
247 info->filter_op = IS_NOTHING;
248 }
249 batch = g_slist_reverse(batch);
250 if (g_slist_length(batch)) {
251 MsgInfo *info = (MsgInfo *)batch->data;
252 if (cur_op == IS_COPY && last_item != info->folder) {
253 folder_item_copy_msgs(last_item, batch);
254 } else if (cur_op == IS_MOVE && last_item != info->folder) {
255 if (folder_item_move_msgs(last_item, batch) < 0)
256 folder_item_move_msgs(
257 folder_get_default_inbox(),
258 batch);
259 } else if (cur_op == IS_DELE && last_item == info->folder) {
260 folder_item_remove_msgs(last_item, batch);
261 }
262 /* we don't reference the msginfos, because caller will do */
263 if (prefs_common.real_time_sync)
264 folder_item_synchronise(last_item);
265 g_slist_free(batch);
266 batch = NULL;
267 GTK_EVENTS_FLUSH();
268 }
269 last_item = NULL;
270 cur_op = IS_NOTHING;
271 }
272 /* we don't reference the msginfos, because caller will do */
273 g_slist_free(messages);
274 }
275
276 /*
277 fitleringaction_apply
278 runs the action on one MsgInfo
279 return value : return TRUE if the action could be applied
280 */
281
282 #define FLUSH_COPY_IF_NEEDED(info) { \
283 if (info->filter_op == IS_COPY && info->to_filter_folder) { \
284 debug_print("must debatch pending copy\n"); \
285 folder_item_copy_msg(info->to_filter_folder, info); \
286 info->filter_op = IS_NOTHING; \
287 } \
288 }
289
290 static gboolean filteringaction_apply(FilteringAction * action, MsgInfo * info)
291 {
292 FolderItem * dest_folder;
293 gint val;
294 Compose * compose;
295 PrefsAccount * account;
296 gchar * cmd;
297
298 switch(action->type) {
299 case MATCHACTION_MOVE:
300 if (MSG_IS_LOCKED(info->flags))
301 return FALSE;
302
303 dest_folder =
304 folder_find_item_from_identifier(action->destination);
305 if (!dest_folder) {
306 debug_print("*** folder not found '%s'\n",
307 action->destination ?action->destination :"(null)");
308 return FALSE;
309 }
310
311 FLUSH_COPY_IF_NEEDED(info);
312 /* mark message to be moved */
313 info->filter_op = IS_MOVE;
314 info->to_filter_folder = dest_folder;
315 return TRUE;
316
317 case MATCHACTION_COPY:
318 dest_folder =
319 folder_find_item_from_identifier(action->destination);
320
321 if (!dest_folder) {
322 debug_print("*** folder not found '%s'\n",
323 action->destination ?action->destination :"(null)");
324 return FALSE;
325 }
326
327 FLUSH_COPY_IF_NEEDED(info);
328 /* mark message to be copied */
329 info->filter_op = IS_COPY;
330 info->to_filter_folder = dest_folder;
331 return TRUE;
332
333 case MATCHACTION_SET_TAG:
334 case MATCHACTION_UNSET_TAG:
335 val = tags_get_id_for_str(action->destination);
336 if (val == -1) {
337 debug_print("*** tag '%s' not found\n",
338 action->destination ?action->destination :"(null)");
339 return FALSE;
340 }
341 FLUSH_COPY_IF_NEEDED(info);
342 procmsg_msginfo_update_tags(info, (action->type == MATCHACTION_SET_TAG), val);
343 return TRUE;
344
345 case MATCHACTION_CLEAR_TAGS:
346 FLUSH_COPY_IF_NEEDED(info);
347 procmsg_msginfo_clear_tags(info);
348 return TRUE;
349
350 case MATCHACTION_DELETE:
351 FLUSH_COPY_IF_NEEDED(info);
352 info->filter_op = IS_DELE;
353 return TRUE;
354
355 case MATCHACTION_MARK:
356 FLUSH_COPY_IF_NEEDED(info);
357 procmsg_msginfo_set_flags(info, MSG_MARKED, 0);
358 return TRUE;
359
360 case MATCHACTION_UNMARK:
361 FLUSH_COPY_IF_NEEDED(info);
362 procmsg_msginfo_unset_flags(info, MSG_MARKED, 0);
363 return TRUE;
364
365 case MATCHACTION_LOCK:
366 FLUSH_COPY_IF_NEEDED(info);
367 procmsg_msginfo_set_flags(info, MSG_LOCKED, 0);
368 return TRUE;
369
370 case MATCHACTION_UNLOCK:
371 FLUSH_COPY_IF_NEEDED(info);
372 procmsg_msginfo_unset_flags(info, MSG_LOCKED, 0);
373 return TRUE;
374
375 case MATCHACTION_MARK_AS_READ:
376 FLUSH_COPY_IF_NEEDED(info);
377 procmsg_msginfo_unset_flags(info, MSG_UNREAD | MSG_NEW, 0);
378 return TRUE;
379
380 case MATCHACTION_MARK_AS_UNREAD:
381 FLUSH_COPY_IF_NEEDED(info);
382 procmsg_msginfo_change_flags(info, MSG_UNREAD, 0, MSG_NEW, 0);
383 return TRUE;
384
385 case MATCHACTION_MARK_AS_SPAM:
386 FLUSH_COPY_IF_NEEDED(info);
387 procmsg_spam_learner_learn(info, NULL, TRUE);
388 procmsg_msginfo_change_flags(info, MSG_SPAM, 0, MSG_NEW|MSG_UNREAD, 0);
389 return TRUE;
390
391 case MATCHACTION_MARK_AS_HAM:
392 FLUSH_COPY_IF_NEEDED(info);
393 procmsg_spam_learner_learn(info, NULL, FALSE);
394 procmsg_msginfo_unset_flags(info, MSG_SPAM, 0);
395 return TRUE;
396
397 case MATCHACTION_COLOR:
398 FLUSH_COPY_IF_NEEDED(info);
399 procmsg_msginfo_unset_flags(info, MSG_CLABEL_FLAG_MASK, 0);
400 procmsg_msginfo_set_flags(info, MSG_COLORLABEL_TO_FLAGS(action->labelcolor), 0);
401 return TRUE;
402
403 case MATCHACTION_FORWARD:
404 case MATCHACTION_FORWARD_AS_ATTACHMENT:
405 account = account_find_from_id(action->account_id);
406 compose = compose_forward(account, info,
407 action->type == MATCHACTION_FORWARD ? FALSE : TRUE,
408 NULL, TRUE, TRUE);
409 compose_entry_append(compose, action->destination,
410 compose->account->protocol == A_NNTP
411 ? COMPOSE_NEWSGROUPS
412 : COMPOSE_TO, PREF_NONE);
413
414 val = compose_send(compose);
415
416 return val == 0 ? TRUE : FALSE;
417
418 case MATCHACTION_REDIRECT:
419 account = account_find_from_id(action->account_id);
420 compose = compose_redirect(account, info, TRUE);
421 if (compose->account->protocol == A_NNTP)
422 break;
423 else
424 compose_entry_append(compose, action->destination,
425 COMPOSE_TO, PREF_NONE);
426
427 val = compose_send(compose);
428
429 return val == 0 ? TRUE : FALSE;
430
431 case MATCHACTION_EXECUTE:
432 cmd = matching_build_command(action->destination, info);
433 if (cmd == NULL)
434 return FALSE;
435 else {
436 if (system(cmd) == -1)
437 g_warning("couldn't run %s", cmd);
438 g_free(cmd);
439 }
440 return TRUE;
441
442 case MATCHACTION_SET_SCORE:
443 FLUSH_COPY_IF_NEEDED(info);
444 info->score = action->score;
445 return TRUE;
446
447 case MATCHACTION_CHANGE_SCORE:
448 FLUSH_COPY_IF_NEEDED(info);
449 info->score += action->score;
450 return TRUE;
451
452 case MATCHACTION_STOP:
453 return FALSE;
454
455 case MATCHACTION_HIDE:
456 FLUSH_COPY_IF_NEEDED(info);
457 info->hidden = TRUE;
458 return TRUE;
459
460 case MATCHACTION_IGNORE:
461 FLUSH_COPY_IF_NEEDED(info);
462 procmsg_msginfo_set_flags(info, MSG_IGNORE_THREAD, 0);
463 return TRUE;
464
465 case MATCHACTION_WATCH:
466 FLUSH_COPY_IF_NEEDED(info);
467 procmsg_msginfo_set_flags(info, MSG_WATCH_THREAD, 0);
468 return TRUE;
469
470 case MATCHACTION_ADD_TO_ADDRESSBOOK:
471 {
472 #ifndef USE_ALT_ADDRBOOK
473 AddressDataSource *book = NULL;
474 AddressBookFile *abf = NULL;
475 ItemFolder *folder = NULL;
476 #endif
477 gchar *buf = NULL;
478 Header *header = NULL;
479 gint errors = 0;
480
481 #ifndef USE_ALT_ADDRBOOK
482 if (!addressbook_peek_folder_exists(action->destination, &book, &folder)) {
483 g_warning("addressbook folder not found '%s'", action->destination?action->destination:"(null)");
484 return FALSE;
485 }
486 if (!book) {
487 g_warning("addressbook_peek_folder_exists returned NULL book");
488 return FALSE;
489 }
490
491 abf = book->rawDataSource;
492 #endif
493 /* get the header */
494 if (procheader_get_header_from_msginfo(info, &buf, action->header) < 0)
495 return FALSE;
496
497 header = procheader_parse_header(buf);
498 g_free(buf);
499
500 /* add all addresses that are not already in */
501 if (header && *header->body && (*header->body != '\0')) {
502 GSList *address_list = NULL;
503 GSList *walk = NULL;
504 gchar *path = NULL;
505
506 if (action->destination == NULL ||
507 strcasecmp(action->destination, "Any") == 0 ||
508 *(action->destination) == '\0')
509 path = NULL;
510 else
511 path = action->destination;
512 start_address_completion(path);
513
514 address_list = g_slist_append(address_list, header->body);
515 for (walk = address_list; walk != NULL; walk = walk->next) {
516 gchar *stripped_addr = g_strdup(walk->data);
517 extract_address(stripped_addr);
518
519 if (complete_matches_found(walk->data) == 0) {
520 gchar *name = procheader_get_fromname(walk->data);
521 debug_print("adding '%s <%s>' to addressbook '%s'\n",
522 name, stripped_addr, action->destination);
523 #ifndef USE_ALT_ADDRBOOK
524 if (!addrbook_add_contact(abf, folder, name, stripped_addr, NULL)) {
525 #else
526 if (!addressadd_selection(name, stripped_addr, NULL, NULL)) {
527 #endif
528 g_warning("contact could not be added");
529 errors++;
530 }
531 g_free(name);
532 } else {
533 debug_print("address '%s' already found in addressbook '%s', skipping\n",
534 stripped_addr, action->destination);
535 }
536 g_free(stripped_addr);
537 }
538
539 g_slist_free(address_list);
540 end_address_completion();
541 } else {
542 g_warning("header '%s' not set or empty", action->header?action->header:"(null)");
543 }
544 if (header)
545 procheader_header_free(header);
546 return (errors == 0);
547 }
548 default:
549 break;
550 }
551 return FALSE;
552 }
553
554 gboolean filteringaction_apply_action_list(GSList *action_list, MsgInfo *info)
555 {
556 GSList *p;
557 cm_return_val_if_fail(action_list, FALSE);
558 cm_return_val_if_fail(info, FALSE);
559 for (p = action_list; p && p->data; p = g_slist_next(p)) {
560 FilteringAction *a = (FilteringAction *) p->data;
561 if (filteringaction_apply(a, info)) {
562 if (filtering_is_final_action(a))
563 break;
564 } else
565 return FALSE;
566
567 }
568 return TRUE;
569 }
570
571 static gboolean filtering_match_condition(FilteringProp *filtering, MsgInfo *info,
572 PrefsAccount *ac_prefs)
573
574 /* this function returns true if a filtering rule applies regarding to its account
575 data and if it does, if the conditions list match.
576
577 per-account data of a filtering rule is either matched against current account
578 when filtering is done manually, or against the account currently used for
579 retrieving messages when it's an manual or automatic fetching of messages.
580 per-account data match doesn't apply to pre-/post-/folder-processing rules.
581
582 when filtering messages manually:
583 - either the filtering rule is not account-based and it will be processed
584 - or it's per-account and we check if we HAVE TO match it against the current
585 account (according to user-land settings, per-account rules might have to
586 be skipped, or only the rules that match the current account have to be
587 applied, or all rules will have to be applied regardless to if they are
588 account-based or not)
589
590 notes about debugging output in that function:
591 when not matching, log_status_skip() is used, otherwise log_status_ok() is used
592 no debug output is done when filtering_debug_level is low
593 */
594 {
595 gboolean matches = FALSE;
596
597 if (ac_prefs != NULL) {
598 matches = ((filtering->account_id == 0)
599 || (filtering->account_id == ac_prefs->account_id));
600
601 /* debug output */
602 if (debug_filtering_session) {
603 if (matches) {
604 /* either because rule is not account-based */
605 if (filtering->account_id == 0) {
606 if (prefs_common.filtering_debug_level >= FILTERING_DEBUG_LEVEL_MED) {
607 log_status_ok(LOG_DEBUG_FILTERING,
608 _("rule is not account-based\n"));
609 }
610 } else {
611 /* or because it is account-based, and matching current account */
612 if (prefs_common.filtering_debug_level == FILTERING_DEBUG_LEVEL_MED) {
613 /* with fewer detail when rule is OK */
614 log_status_ok(LOG_DEBUG_FILTERING,
615 _("rule is account-based, "
616 "matching the account currently used to retrieve messages\n"));
617 } else {
618 if (prefs_common.filtering_debug_level == FILTERING_DEBUG_LEVEL_HIGH) {
619 /* with more detail when rule is OK */
620 log_status_ok(LOG_DEBUG_FILTERING,
621 _("rule is account-based [id=%d, name='%s'], "
622 "matching the account currently used to retrieve messages\n"),
623 ac_prefs->account_id, ac_prefs?ac_prefs->account_name:_("NON_EXISTENT"));
624 }
625 }
626 }
627 } else {
628 if (prefs_common.filtering_debug_level == FILTERING_DEBUG_LEVEL_MED) {
629 /* with fewer detail when rule is skipped */
630 log_status_skip(LOG_DEBUG_FILTERING,
631 _("rule is account-based, "
632 "not matching the account currently used to retrieve messages\n"));
633 } else {
634 if (prefs_common.filtering_debug_level == FILTERING_DEBUG_LEVEL_HIGH) {
635 /* with more detail when rule is skipped */
636 PrefsAccount *account = account_find_from_id(filtering->account_id);
637
638 log_status_skip(LOG_DEBUG_FILTERING,
639 _("rule is account-based [id=%d, name='%s'], "
640 "not matching the account currently used to retrieve messages [id=%d, name='%s']\n"),
641 filtering->account_id, account?account->account_name:_("NON_EXISTENT"),
642 ac_prefs->account_id, ac_prefs?ac_prefs->account_name:_("NON_EXISTENT"));
643 }
644 }
645 }
646 }
647 } else {
648 switch (prefs_common.apply_per_account_filtering_rules) {
649 case FILTERING_ACCOUNT_RULES_FORCE:
650 /* apply filtering rules regardless to the account info */
651 matches = TRUE;
652
653 /* debug output */
654 if (debug_filtering_session) {
655 if (filtering->account_id == 0) {
656 if (prefs_common.filtering_debug_level >= FILTERING_DEBUG_LEVEL_MED) {
657 log_status_ok(LOG_DEBUG_FILTERING,
658 _("rule is not account-based, "
659 "but all rules are applied on user request anyway\n"));
660 }
661 } else {
662 if (prefs_common.filtering_debug_level == FILTERING_DEBUG_LEVEL_MED) {
663 /* with fewer detail when rule is OK */
664 log_status_ok(LOG_DEBUG_FILTERING,
665 _("rule is account-based, "
666 "but all rules are applied on user request anyway\n"));
667 } else {
668 if (prefs_common.filtering_debug_level == FILTERING_DEBUG_LEVEL_MED) {
669 /* with more detail when rule is OK */
670 PrefsAccount *account = account_find_from_id(filtering->account_id);
671
672 log_status_ok(LOG_DEBUG_FILTERING,
673 _("rule is account-based [id=%d, name='%s'], "
674 "but all rules are applied on user request anyway\n"),
675 filtering->account_id, account?account->account_name:_("NON_EXISTENT"));
676 }
677 }
678 }
679 }
680 break;
681 case FILTERING_ACCOUNT_RULES_SKIP:
682 /* don't apply filtering rules that belong to an account */
683 matches = (filtering->account_id == 0);
684
685 /* debug output */
686 if (debug_filtering_session) {
687 if (matches) {
688 if (prefs_common.filtering_debug_level >= FILTERING_DEBUG_LEVEL_MED) {
689 log_status_ok(LOG_DEBUG_FILTERING,
690 _("rule is not account-based\n"));
691 }
692 } else {
693 if (prefs_common.filtering_debug_level == FILTERING_DEBUG_LEVEL_MED) {
694 /* with fewer detail when rule is skipped */
695 log_status_skip(LOG_DEBUG_FILTERING,
696 _("rule is account-based, "
697 "skipped on user request\n"));
698 } else {
699 if (prefs_common.filtering_debug_level == FILTERING_DEBUG_LEVEL_HIGH) {
700 /* with more detail when rule is skipped */
701 PrefsAccount *account = account_find_from_id(filtering->account_id);
702
703 log_status_skip(LOG_DEBUG_FILTERING,
704 _("rule is account-based [id=%d, name='%s'], "
705 "skipped on user request\n"),
706 filtering->account_id, account?account->account_name:_("NON_EXISTENT"));
707 }
708 }
709 }
710 }
711 break;
712 case FILTERING_ACCOUNT_RULES_USE_CURRENT:
713 matches = ((filtering->account_id == 0)
714 || (filtering->account_id == cur_account->account_id));
715
716 /* debug output */
717 if (debug_filtering_session) {
718 if (matches) {
719 if (filtering->account_id == 0) {
720 if (prefs_common.filtering_debug_level >= FILTERING_DEBUG_LEVEL_MED) {
721 log_status_ok(LOG_DEBUG_FILTERING,
722 _("rule is not account-based\n"));
723 }
724 } else {
725 if (prefs_common.filtering_debug_level == FILTERING_DEBUG_LEVEL_MED) {
726 /* with fewer detail when rule is OK */
727 log_status_ok(LOG_DEBUG_FILTERING,
728 _("rule is account-based, "
729 "matching current account\n"));
730 } else {
731 if (prefs_common.filtering_debug_level == FILTERING_DEBUG_LEVEL_MED) {
732 /* with more detail when rule is OK */
733 PrefsAccount *account = account_find_from_id(filtering->account_id);
734
735 log_status_ok(LOG_DEBUG_FILTERING,
736 _("rule is account-based [id=%d, name='%s'], "
737 "matching current account [id=%d, name='%s']\n"),
738 account->account_id, account?account->account_name:_("NON_EXISTENT"),
739 cur_account->account_id, cur_account?cur_account->account_name:_("NON_EXISTENT"));
740 }
741 }
742 }
743 } else {
744 if (prefs_common.filtering_debug_level == FILTERING_DEBUG_LEVEL_MED) {
745 /* with fewer detail when rule is skipped */
746 log_status_skip(LOG_DEBUG_FILTERING,
747 _("rule is account-based, "
748 "not matching current account\n"));
749 } else {
750 if (prefs_common.filtering_debug_level == FILTERING_DEBUG_LEVEL_HIGH) {
751 /* with more detail when rule is skipped */
752 PrefsAccount *account = account_find_from_id(filtering->account_id);
753
754 log_status_skip(LOG_DEBUG_FILTERING,
755 _("rule is account-based [id=%d, name='%s'], "
756 "not matching current account [id=%d, name='%s']\n"),
757 filtering->account_id, account?account->account_name:_("NON_EXISTENT"),
758 cur_account->account_id, cur_account?cur_account->account_name:_("NON_EXISTENT"));
759 }
760 }
761 }
762 }
763 break;
764 }
765 }
766
767 return matches && matcherlist_match(filtering->matchers, info);
768 }
769
770 /*!
771 *\brief Apply a rule on message.
772 *
773 *\param filtering List of filtering rules.
774 *\param info Message to apply rules on.
775 *\param final Variable returning TRUE or FALSE if one of the
776 * encountered actions was final.
777 * See also \ref filtering_is_final_action.
778 *
779 *\return gboolean TRUE to continue applying rules.
780 */
781 static gboolean filtering_apply_rule(FilteringProp *filtering, MsgInfo *info,
782 gboolean * final)
783 {
784 gboolean result = TRUE;
785 gchar *buf;
786 GSList * tmp;
787
788 * final = FALSE;
789 for (tmp = filtering->action_list ; tmp != NULL ; tmp = tmp->next) {
790 FilteringAction * action;
791
792 action = tmp->data;
793 buf = filteringaction_to_string(action);
794 if (debug_filtering_session)
795 log_print(LOG_DEBUG_FILTERING, _("applying action [ %s ]\n"), buf);
796
797 if (FALSE == (result = filteringaction_apply(action, info))) {
798 if (debug_filtering_session) {
799 if (action->type != MATCHACTION_STOP)
800 log_warning(LOG_DEBUG_FILTERING, _("action could not apply\n"));
801 log_print(LOG_DEBUG_FILTERING,
802 _("no further processing after action [ %s ]\n"), buf);
803 }
804 debug_print("No further processing after rule %s\n", buf);
805 }
806 g_free(buf);
807 if (filtering_is_final_action(action)) {
808 * final = TRUE;
809 break;
810 }
811
812 }
813 return result;
814 }
815
816 /*!
817 *\brief Check if an action is "final", i.e. should break further
818 * processing.
819 *
820 *\param filtering_action Action to check.
821 *
822 *\return gboolean TRUE if \a filtering_action is final.
823 */
824 static gboolean filtering_is_final_action(FilteringAction *filtering_action)
825 {
826 switch(filtering_action->type) {
827 case MATCHACTION_MOVE:
828 case MATCHACTION_DELETE:
829 case MATCHACTION_STOP:
830 return TRUE; /* MsgInfo invalid for message */
831 default:
832 return FALSE;
833 }
834 }
835
836 gboolean processing_enabled(GSList *filtering_list)
837 {
838 GSList *l;
839 for (l = filtering_list; l != NULL; l = g_slist_next(l)) {
840 FilteringProp * filtering = (FilteringProp *) l->data;
841 if (filtering->enabled)
842 return TRUE;
843 }
844 return FALSE;
845 }
846
847 static gboolean filter_msginfo(GSList * filtering_list, MsgInfo * info, PrefsAccount* ac_prefs)
848 {
849 GSList *l;
850 gboolean final;
851 gboolean apply_next;
852
853 cm_return_val_if_fail(info != NULL, TRUE);
854
855 for (l = filtering_list, final = FALSE, apply_next = FALSE; l != NULL; l = g_slist_next(l)) {
856 FilteringProp * filtering = (FilteringProp *) l->data;
857
858 if (filtering->enabled) {
859 if (debug_filtering_session) {
860 gchar *buf = filteringprop_to_string(filtering);
861 if (filtering->name && *filtering->name != '\0') {
862 log_print(LOG_DEBUG_FILTERING,
863 _("processing rule '%s' [ %s ]\n"),
864 filtering->name, buf);
865 } else {
866 log_print(LOG_DEBUG_FILTERING,
867 _("processing rule <unnamed> [ %s ]\n"),
868 buf);
869 }
870 g_free(buf);
871 }
872
873 if (filtering_match_condition(filtering, info, ac_prefs)) {
874 apply_next = filtering_apply_rule(filtering, info, &final);
875 if (final)
876 break;
877 }
878
879 } else {
880 if (debug_filtering_session) {
881 gchar *buf = filteringprop_to_string(filtering);
882 if (prefs_common.filtering_debug_level >= FILTERING_DEBUG_LEVEL_MED) {
883 if (filtering->name && *filtering->name != '\0') {
884 log_status_skip(LOG_DEBUG_FILTERING,
885 _("disabled rule '%s' [ %s ]\n"),
886 filtering->name, buf);
887 } else {
888 log_status_skip(LOG_DEBUG_FILTERING,
889 _("disabled rule <unnamed> [ %s ]\n"),
890 buf);
891 }
892 }
893 g_free(buf);
894 }
895 }
896 }
897
898 /* put in inbox if the last rule was not a final one, or
899 * a final rule could not be applied.
900 * Either of these cases is likely. */
901 if (!final || !apply_next) {
902 return FALSE;
903 }
904
905 return TRUE;
906 }
907
908 /*!
909 *\brief Filter a message against a list of rules.
910 *
911 *\param flist List of filter rules.
912 *\param info Message.
913 *
914 *\return gboolean TRUE if filter rules handled the message.
915 *
916 *\note Returning FALSE means the message was not handled,
917 * and that the calling code should do the default
918 * processing. E.g. \ref inc.c::inc_start moves the
919 * message to the inbox.
920 */
921 gboolean filter_message_by_msginfo(GSList *flist, MsgInfo *info, PrefsAccount* ac_prefs,
922 FilteringInvocationType context, gchar *extra_info)
923 {
924 gboolean ret;
925
926 if (prefs_common.enable_filtering_debug) {
927 gchar *tmp = _("undetermined");
928
929 switch (context) {
930 case FILTERING_INCORPORATION:
931 tmp = _("incorporation");
932 debug_filtering_session = prefs_common.enable_filtering_debug_inc;
933 break;
934 case FILTERING_MANUALLY:
935 tmp = _("manually");
936 debug_filtering_session = prefs_common.enable_filtering_debug_manual;
937 break;
938 case FILTERING_FOLDER_PROCESSING:
939 tmp = _("folder processing");
940 debug_filtering_session = prefs_common.enable_filtering_debug_folder_proc;
941 break;
942 case FILTERING_PRE_PROCESSING:
943 tmp = _("pre-processing");
944 debug_filtering_session = prefs_common.enable_filtering_debug_pre_proc;
945 break;
946 case FILTERING_POST_PROCESSING:
947 tmp = _("post-processing");
948 debug_filtering_session = prefs_common.enable_filtering_debug_post_proc;
949 break;
950 default:
951 debug_filtering_session = FALSE;
952 break;
953 }
954
955 if (debug_filtering_session) {
956 gchar *file = procmsg_get_message_file_path(info);
957 gchar *spc = g_strnfill(LOG_TIME_LEN + 1, ' ');
958
959 /* show context info and essential info about the message */
960 if (prefs_common.filtering_debug_level >= FILTERING_DEBUG_LEVEL_MED) {
961 log_print(LOG_DEBUG_FILTERING,
962 _("filtering message (%s%s%s)\n"
963 "%smessage file: %s\n%s%s %s\n%s%s %s\n%s%s %s\n%s%s %s\n"),
964 tmp, extra_info ? _(": ") : "", extra_info ? extra_info : "",
965 spc, file, spc, prefs_common_translated_header_name("Date:"), info->date,
966 spc, prefs_common_translated_header_name("From:"), info->from,
967 spc, prefs_common_translated_header_name("To:"), info->to,
968 spc, prefs_common_translated_header_name("Subject:"), info->subject);
969 } else {
970 log_print(LOG_DEBUG_FILTERING,
971 _("filtering message (%s%s%s)\n"
972 "%smessage file: %s\n"),
973 tmp, extra_info ? _(": ") : "", extra_info ? extra_info : "",
974 spc, file);
975 }
976 g_free(file);
977 g_free(spc);
978 }
979 } else
980 debug_filtering_session = FALSE;
981
982 ret = filter_msginfo(flist, info, ac_prefs);
983 debug_filtering_session = FALSE;
984 return ret;
985 }
986
987 gchar *filteringaction_to_string(FilteringAction *action)
988 {
989 const gchar *command_str;
990 gchar * quoted_dest;
991 gchar * quoted_header;
992 GString *dest = g_string_new("");
993
994 command_str = get_matchparser_tab_str(action->type);
995
996 if (command_str == NULL) {
997 g_string_free(dest, TRUE);
998 return NULL;
999 }
1000
1001 switch(action->type) {
1002 case MATCHACTION_MOVE:
1003 case MATCHACTION_COPY:
1004 case MATCHACTION_EXECUTE:
1005 case MATCHACTION_SET_TAG:
1006 case MATCHACTION_UNSET_TAG:
1007 quoted_dest = matcher_quote_str(action->destination);
1008 g_string_append_printf(dest, "%s \"%s\"", command_str, quoted_dest);
1009 g_free(quoted_dest);
1010 break;
1011
1012 case MATCHACTION_DELETE:
1013 case MATCHACTION_MARK:
1014 case MATCHACTION_UNMARK:
1015 case MATCHACTION_LOCK:
1016 case MATCHACTION_UNLOCK:
1017 case MATCHACTION_MARK_AS_READ:
1018 case MATCHACTION_MARK_AS_UNREAD:
1019 case MATCHACTION_MARK_AS_SPAM:
1020 case MATCHACTION_MARK_AS_HAM:
1021 case MATCHACTION_STOP:
1022 case MATCHACTION_HIDE:
1023 case MATCHACTION_IGNORE:
1024 case MATCHACTION_WATCH:
1025 case MATCHACTION_CLEAR_TAGS:
1026 g_string_append_printf(dest, "%s", command_str);
1027 break;
1028
1029 case MATCHACTION_REDIRECT:
1030 case MATCHACTION_FORWARD:
1031 case MATCHACTION_FORWARD_AS_ATTACHMENT:
1032 quoted_dest = matcher_quote_str(action->destination);
1033 g_string_append_printf(dest, "%s %d \"%s\"", command_str, action->account_id, quoted_dest);
1034 g_free(quoted_dest);
1035 break;
1036
1037 case MATCHACTION_COLOR:
1038 g_string_append_printf(dest, "%s %d", command_str, action->labelcolor);
1039 break;
1040
1041 case MATCHACTION_CHANGE_SCORE:
1042 case MATCHACTION_SET_SCORE:
1043 g_string_append_printf(dest, "%s %d", command_str, action->score);
1044 break;
1045
1046 case MATCHACTION_ADD_TO_ADDRESSBOOK:
1047 quoted_header = matcher_quote_str(action->header);
1048 quoted_dest = matcher_quote_str(action->destination);
1049 g_string_append_printf(dest, "%s \"%s\" \"%s\"", command_str, quoted_header, quoted_dest);
1050 g_free(quoted_dest);
1051 g_free(quoted_header);
1052 break;
1053
1054 default:
1055 g_string_free(dest, TRUE);
1056 return NULL;
1057 }
1058 return g_string_free(dest, FALSE);
1059 }
1060
1061 gchar * filteringaction_list_to_string(GSList * action_list)
1062 {
1063 gchar *action_list_str;
1064 GSList * tmp;
1065 gchar *list_str;
1066
1067 action_list_str = NULL;
1068 for (tmp = action_list ; tmp != NULL ; tmp = tmp->next) {
1069 gchar *action_str;
1070 FilteringAction * action;
1071
1072 action = tmp->data;
1073
1074 action_str = filteringaction_to_string(action);
1075
1076 if (action_list_str != NULL) {
1077 list_str = g_strconcat(action_list_str, " ", action_str, NULL);
1078 g_free(action_list_str);
1079 }
1080 else {
1081 list_str = g_strdup(action_str);
1082 }
1083 g_free(action_str);
1084 action_list_str = list_str;
1085 }
1086
1087 return action_list_str;
1088 }
1089
1090 gchar * filteringprop_to_string(FilteringProp * prop)
1091 {
1092 gchar *list_str;
1093 gchar *action_list_str;
1094 gchar *filtering_str;
1095
1096 if (prop == NULL)
1097 return NULL;
1098
1099 action_list_str = filteringaction_list_to_string(prop->action_list);
1100
1101 if (action_list_str == NULL)
1102 return NULL;
1103
1104 list_str = matcherlist_to_string(prop->matchers);
1105
1106 if (list_str == NULL) {
1107 g_free(action_list_str);
1108 return NULL;
1109 }
1110
1111 filtering_str = g_strconcat(list_str, " ", action_list_str, NULL);
1112 g_free(action_list_str);
1113 g_free(list_str);
1114
1115 return filtering_str;
1116 }
1117
1118 static void prefs_filtering_free(GSList * prefs_filtering)
1119 {
1120 while (prefs_filtering != NULL) {
1121 FilteringProp * filtering = (FilteringProp *)
1122 prefs_filtering->data;
1123 prefs_filtering = g_slist_remove(prefs_filtering, filtering);
1124 filteringprop_free(filtering);
1125 }
1126 }
1127
1128 static gboolean prefs_filtering_free_func(GNode *node, gpointer data)
1129 {
1130 FolderItem *item = node->data;
1131
1132 cm_return_val_if_fail(item, FALSE);
1133 cm_return_val_if_fail(item->prefs, FALSE);
1134
1135 prefs_filtering_free(item->prefs->processing);
1136 item->prefs->processing = NULL;
1137
1138 return FALSE;
1139 }
1140
1141 void prefs_filtering_clear(void)
1142 {
1143 GList * cur;
1144
1145 for (cur = folder_get_list() ; cur != NULL ; cur = g_list_next(cur)) {
1146 Folder *folder;
1147
1148 folder = (Folder *) cur->data;
1149 g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1150 prefs_filtering_free_func, NULL);
1151 }
1152
1153 prefs_filtering_free(filtering_rules);
1154 filtering_rules = NULL;
1155 prefs_filtering_free(pre_global_processing);
1156 pre_global_processing = NULL;
1157 prefs_filtering_free(post_global_processing);
1158 post_global_processing = NULL;
1159 }
1160
1161 void prefs_filtering_clear_folder(Folder *folder)
1162 {
1163 cm_return_if_fail(folder);
1164 cm_return_if_fail(folder->node);
1165
1166 g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1167 prefs_filtering_free_func, NULL);
1168 /* FIXME: Note folder settings were changed, where the updates? */
1169 }
1170
1171 gboolean filtering_peek_per_account_rules(GSList *filtering_list)
1172 /* return TRUE if there's at least one per-account filtering rule */
1173 {
1174 GSList *l;
1175
1176 for (l = filtering_list; l != NULL; l = g_slist_next(l)) {
1177 FilteringProp * filtering = (FilteringProp *) l->data;
1178
1179 if (filtering->enabled && (filtering->account_id != 0)) {
1180 return TRUE;
1181 }
1182 }
1183
1184 return FALSE;
1185 }
1186
1187 gboolean filtering_action_list_rename_path(GSList *action_list, const gchar *old_path,
1188 const gchar *new_path)
1189 {
1190 gchar *base;
1191 gchar *prefix;
1192 gchar *suffix;
1193 gchar *dest_path;
1194 gchar *old_path_with_sep;
1195 gint destlen;
1196 gint prefixlen;
1197 gint oldpathlen;
1198 GSList * action_cur;
1199 const gchar *separator=G_DIR_SEPARATOR_S;
1200 gboolean matched = FALSE;
1201 #ifdef G_OS_WIN32
1202 again:
1203 #endif
1204 oldpathlen = strlen(old_path);
1205 old_path_with_sep = g_strconcat(old_path,separator,NULL);
1206
1207 for(action_cur = action_list ; action_cur != NULL ;
1208 action_cur = action_cur->next) {
1209
1210 FilteringAction *action = action_cur->data;
1211
1212 if (action->type == MATCHACTION_SET_TAG ||
1213 action->type == MATCHACTION_UNSET_TAG)
1214 continue;
1215 if (!action->destination)
1216 continue;
1217
1218 destlen = strlen(action->destination);
1219
1220 if (destlen > oldpathlen) {
1221 prefixlen = destlen - oldpathlen;
1222 suffix = action->destination + prefixlen;
1223
1224 if (!strncmp(old_path, suffix, oldpathlen)) {
1225 prefix = g_malloc0(prefixlen + 1);
1226 strncpy2(prefix, action->destination, prefixlen);
1227
1228 base = suffix + oldpathlen;
1229 while (*base == G_DIR_SEPARATOR)
1230 base++;
1231 if (*base == '\0')
1232 dest_path = g_strconcat(prefix, separator, new_path, NULL);
1233 else
1234 dest_path = g_strconcat(prefix, separator, new_path, separator, base, NULL);
1235
1236 g_free(prefix);
1237 g_free(action->destination);
1238 action->destination = dest_path;
1239 matched = TRUE;
1240 } else { /* for non-leaf folders */
1241 /* compare with trailing slash */
1242 if (!strncmp(old_path_with_sep, action->destination, oldpathlen+1)) {
1243
1244 suffix = action->destination + oldpathlen + 1;
1245 dest_path = g_strconcat(new_path, separator,
1246 suffix, NULL);
1247 g_free(action->destination);
1248 action->destination = dest_path;
1249 matched = TRUE;
1250 }
1251 }
1252 } else {
1253 /* folder-moving a leaf */
1254 if (!strcmp(old_path, action->destination)) {
1255 dest_path = g_strdup(new_path);
1256 g_free(action->destination);
1257 action->destination = dest_path;
1258 matched = TRUE;
1259 }
1260 }
1261 }
1262
1263 g_free(old_path_with_sep);
1264 #ifdef G_OS_WIN32
1265 if (!strcmp(separator, G_DIR_SEPARATOR_S) && !matched) {
1266 separator = "/";
1267 goto again;
1268 }
1269 #endif
1270
1271 return matched;
1272 }