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