2 * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
3 * Copyright (C) 1999-2012 Colin Leroy <colin@colino.net> and
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "claws-features.h"
28 #include <sys/types.h>
33 #include <glib/gi18n.h>
39 #include "common/claws.h"
40 #include "common/version.h"
42 #include "common/utils.h"
47 #include "prefs_gtk.h"
49 #include "bogofilter.h"
52 #include "prefs_common.h"
53 #include "alertpanel.h"
54 #include "addr_compl.h"
56 #ifdef HAVE_SYSEXITS_H
62 #ifdef HAVE_SYS_ERRNO_H
63 #include <sys/errno.h>
68 #ifdef HAVE_SYS_TIME_H
81 #define PLUGIN_NAME (_("Bogofilter"))
83 static guint hook_id = -1;
84 static MessageCallback message_callback;
86 static BogofilterConfig config;
88 static PrefParam param[] = {
89 {"process_emails", "TRUE", &config.process_emails, P_BOOL,
91 {"receive_spam", "1", &config.receive_spam, P_INT,
93 {"save_folder", NULL, &config.save_folder, P_STRING,
95 {"save_unsure", "FALSE", &config.save_unsure, P_BOOL,
97 {"save_unsure_folder", NULL, &config.save_unsure_folder, P_STRING,
99 {"max_size", "250", &config.max_size, P_INT,
101 {"bogopath", "bogofilter", &config.bogopath, P_STRING,
103 {"insert_header", "FALSE", &config.insert_header, P_BOOL,
105 {"whitelist_ab", "FALSE", &config.whitelist_ab, P_BOOL,
107 {"whitelist_ab_folder", N_("Any"), &config.whitelist_ab_folder, P_STRING,
109 {"learn_from_whitelist", "FALSE", &config.learn_from_whitelist, P_BOOL,
111 {"mark_as_read", "TRUE", &config.mark_as_read, P_BOOL,
114 {NULL, NULL, NULL, P_OTHER, NULL, NULL, NULL}
118 * Helper function for spawn_with_input() - write an entire
128 gssize count = write (fd, buf, to_write);
144 typedef struct _BogoFilterData {
145 MailFilteringData *mail_filtering_data;
151 GSList *whitelisted_new_spams;
157 static BogoFilterData *to_filter_data = NULL;
159 static gboolean filter_th_done = FALSE;
160 static pthread_mutex_t list_mutex = PTHREAD_MUTEX_INITIALIZER;
161 static pthread_mutex_t wait_mutex = PTHREAD_MUTEX_INITIALIZER;
162 static pthread_cond_t wait_cond = PTHREAD_COND_INITIALIZER;
165 static gboolean found_in_addressbook(const gchar *address)
168 gboolean found = FALSE;
174 addr = g_strdup(address);
175 extract_address(addr);
176 num_addr = complete_address(addr);
178 /* skip first item (this is the search string itself) */
180 for (; i < num_addr && !found; i++) {
181 gchar *caddr = get_complete_address(i);
182 extract_address(caddr);
183 if (strcasecmp(caddr, addr) == 0)
192 static void bogofilter_do_filter(BogoFilterData *data)
195 gint bogo_stdin, bogo_stdout;
196 GError *error = NULL;
197 gboolean bogo_forked;
201 int total = 0, curnum = 1;
205 total = g_slist_length(data->msglist);
207 bogo_forked = g_spawn_async_with_pipes(
208 NULL, data->bogo_args,NULL, G_SPAWN_SEARCH_PATH|G_SPAWN_DO_NOT_REAP_CHILD,
209 NULL, NULL, &bogo_pid, &bogo_stdin,
210 &bogo_stdout, NULL, &error);
212 if (bogo_forked == FALSE) {
213 g_warning("%s", error ? error->message:"ERROR???");
219 if (config.whitelist_ab) {
220 gchar *ab_folderpath;
222 if (*config.whitelist_ab_folder == '\0' ||
223 strcasecmp(config.whitelist_ab_folder, "Any") == 0) {
224 /* match the whole addressbook */
225 ab_folderpath = NULL;
227 /* match the specific book/folder of the addressbook */
228 ab_folderpath = config.whitelist_ab_folder;
231 start_address_completion(ab_folderpath);
234 for (cur = data->msglist; cur; cur = cur->next) {
235 gboolean whitelisted = FALSE;
236 msginfo = (MsgInfo *)cur->data;
237 debug_print("Filtering message %d (%d/%d)\n", msginfo->msgnum, curnum, total);
239 if (message_callback != NULL)
240 message_callback(NULL, total, curnum++, data->in_thread);
242 if (config.whitelist_ab && msginfo->from &&
243 found_in_addressbook(msginfo->from))
246 /* can set flags (SCANNED, ATTACHMENT) but that's ok
247 * as GUI updates are hooked not direct */
249 file = procmsg_get_message_file(msginfo);
252 gchar *tmp = g_strdup_printf("%s\n",file);
253 /* send filename to bogofilter */
254 write_all(bogo_stdin, tmp, strlen(tmp));
256 memset(buf, 0, sizeof(buf));
258 if (read(bogo_stdout, buf, sizeof(buf)-1) < 0) {
259 g_warning("bogofilter short read");
260 debug_print("message %d is ham\n", msginfo->msgnum);
261 data->mail_filtering_data->unfiltered = g_slist_prepend(
262 data->mail_filtering_data->unfiltered, msginfo);
263 data->new_hams = g_slist_prepend(data->new_hams, msginfo);
265 gchar **parts = NULL;
267 buf[sizeof(buf) - 1] = '\0';
268 if (strchr(buf, '/')) {
269 tmp = strrchr(buf, '/')+1;
273 parts = g_strsplit(tmp, " ", 0);
274 debug_print("read %s\n", buf);
276 /* note the result if the header if needed */
277 if (parts && parts[0] && parts[1] && parts[2] &&
278 FOLDER_TYPE(msginfo->folder->folder) == F_MH &&
279 config.insert_header) {
280 gchar *tmpfile = get_tmp_file();
281 FILE *input = g_fopen(file, "r");
282 FILE *output = g_fopen(tmpfile, "w");
283 if (strstr(parts[2], "\n"))
284 *(strstr(parts[2], "\n")) = '\0';
285 if (input && !output)
287 else if (!input && output)
289 else if (input && output) {
290 gchar tmpbuf[BUFFSIZE];
291 gboolean err = FALSE;
292 const gchar *bogosity = *parts[1] == 'S' ? "Spam":
293 (*parts[1] == 'H' ? "Ham":"Unsure");
294 gchar *tmpstr = g_strdup_printf(
295 "X-Bogosity: %s, spamicity=%s%s\n",
297 whitelisted?" [whitelisted]":"");
298 if (fwrite(tmpstr, 1, strlen(tmpstr), output) < strlen(tmpstr)) {
301 while (fgets(tmpbuf, sizeof(buf), input)) {
302 if (fputs(tmpbuf, output) == EOF) {
309 if (fclose(output) == EOF)
312 move_file(tmpfile, file, TRUE);
319 if (!whitelisted && parts && parts[0] && parts[1] && *parts[1] == 'S') {
321 debug_print("message %d is spam\n", msginfo->msgnum);
322 /* Spam will be filtered away, unless we want "mark only".
323 * In that case, we want it among unfiltered messages, so
324 * it gets processed further. */
325 if (config.receive_spam == SPAM_MARK_ONLY) {
326 data->mail_filtering_data->unfiltered = g_slist_prepend(
327 data->mail_filtering_data->unfiltered, msginfo);
329 data->mail_filtering_data->filtered = g_slist_prepend(
330 data->mail_filtering_data->filtered, msginfo);
332 data->new_spams = g_slist_prepend(data->new_spams, msginfo);
334 } else if (whitelisted && parts && parts[0] && parts[1] &&
335 (*parts[1] == 'S' || *parts[1] == 'U')) {
337 debug_print("message %d is whitelisted %s\n", msginfo->msgnum,
338 *parts[1] == 'S' ? "spam":"unsure");
339 /* Whitelisted spam will *not* be filtered away, but continue
340 * their trip through filtering as if it was ham. */
341 data->mail_filtering_data->unfiltered = g_slist_prepend(
342 data->mail_filtering_data->unfiltered, msginfo);
343 /* But it gets put in a different list, so that we
344 * can still flag it and inform the user that it is
345 * considered a spam (so that he can teach bogo that
347 data->whitelisted_new_spams = g_slist_prepend(data->whitelisted_new_spams, msginfo);
349 } else if (config.save_unsure && parts && parts[0] && parts[1] && *parts[1] == 'U') {
351 debug_print("message %d is unsure\n", msginfo->msgnum);
352 /* Spam will be filtered away */
353 data->mail_filtering_data->filtered = g_slist_prepend(
354 data->mail_filtering_data->filtered, msginfo);
355 data->new_unsure = g_slist_prepend(data->new_unsure, msginfo);
359 debug_print("message %d is ham\n", msginfo->msgnum);
360 data->mail_filtering_data->unfiltered = g_slist_prepend(
361 data->mail_filtering_data->unfiltered, msginfo);
362 data->new_hams = g_slist_prepend(data->new_hams, msginfo);
369 data->mail_filtering_data->unfiltered = g_slist_prepend(
370 data->mail_filtering_data->unfiltered, msginfo);
371 data->new_hams = g_slist_prepend(data->new_hams, msginfo);
374 if (config.whitelist_ab)
375 end_address_completion();
380 waitpid(bogo_pid, &status, 0);
381 if (!WIFEXITED(status))
384 status = WEXITSTATUS(status);
387 to_filter_data->status = status;
391 static void *bogofilter_filtering_thread(void *data)
393 while (!filter_th_done) {
394 pthread_mutex_lock(&list_mutex);
395 if (to_filter_data == NULL || to_filter_data->done == TRUE) {
396 pthread_mutex_unlock(&list_mutex);
397 debug_print("thread is waiting for something to filter\n");
398 pthread_mutex_lock(&wait_mutex);
399 pthread_cond_wait(&wait_cond, &wait_mutex);
400 pthread_mutex_unlock(&wait_mutex);
402 debug_print("thread awaken with something to filter\n");
403 to_filter_data->done = FALSE;
404 bogofilter_do_filter(to_filter_data);
405 pthread_mutex_unlock(&list_mutex);
406 to_filter_data->done = TRUE;
413 static pthread_t filter_th = 0;
415 static void bogofilter_start_thread(void)
417 filter_th_done = FALSE;
418 if (filter_th != 0 || 1)
420 if (pthread_create(&filter_th, 0,
421 bogofilter_filtering_thread,
426 debug_print("thread created\n");
429 static void bogofilter_stop_thread(void)
432 while (pthread_mutex_trylock(&list_mutex) != 0) {
436 if (filter_th != 0) {
437 filter_th_done = TRUE;
438 debug_print("waking thread up\n");
439 pthread_mutex_lock(&wait_mutex);
440 pthread_cond_broadcast(&wait_cond);
441 pthread_mutex_unlock(&wait_mutex);
442 pthread_join(filter_th, &res);
445 pthread_mutex_unlock(&list_mutex);
446 debug_print("thread done\n");
450 static gboolean mail_filtering_hook(gpointer source, gpointer data)
452 MailFilteringData *mail_filtering_data = (MailFilteringData *) source;
453 MsgInfo *msginfo = mail_filtering_data->msginfo;
454 GSList *msglist = mail_filtering_data->msglist;
456 static gboolean warned_error = FALSE;
458 int total = 0, curnum = 0;
459 GSList *new_hams = NULL, *new_spams = NULL;
460 GSList *new_unsure, *whitelisted_new_spams = NULL;
461 gchar *bogo_exec = (config.bogopath && *config.bogopath) ? config.bogopath:"bogofilter";
463 gboolean ok_to_thread = TRUE;
465 bogo_args[0] = bogo_exec;
470 if (!config.process_emails) {
474 if (msglist == NULL && msginfo != NULL) {
475 g_warning("wrong call to bogofilter mail_filtering_hook");
479 total = g_slist_length(msglist);
481 /* we have to make sure the mails are cached - or it'll break on IMAP */
482 if (message_callback != NULL)
483 message_callback(_("Bogofilter: fetching bodies..."), total, 0, FALSE);
484 for (cur = msglist; cur; cur = cur->next) {
485 gchar *file = procmsg_get_message_file((MsgInfo *)cur->data);
487 ok_to_thread = FALSE;
488 if (message_callback != NULL)
489 message_callback(NULL, total, curnum++, FALSE);
492 if (message_callback != NULL)
493 message_callback(NULL, 0, 0, FALSE);
495 if (message_callback != NULL)
496 message_callback(_("Bogofilter: filtering messages..."), total, 0, FALSE);
499 while (pthread_mutex_trylock(&list_mutex) != 0) {
504 to_filter_data = g_new0(BogoFilterData, 1);
505 to_filter_data->msglist = msglist;
506 to_filter_data->mail_filtering_data = mail_filtering_data;
507 to_filter_data->new_hams = NULL;
508 to_filter_data->new_unsure = NULL;
509 to_filter_data->new_spams = NULL;
510 to_filter_data->whitelisted_new_spams = NULL;
511 to_filter_data->done = FALSE;
512 to_filter_data->status = -1;
513 to_filter_data->bogo_args = bogo_args;
515 to_filter_data->in_thread = (filter_th != 0 && ok_to_thread);
517 to_filter_data->in_thread = FALSE;
521 pthread_mutex_unlock(&list_mutex);
523 if (filter_th != 0 && ok_to_thread) {
524 debug_print("waking thread to let it filter things\n");
525 pthread_mutex_lock(&wait_mutex);
526 pthread_cond_broadcast(&wait_cond);
527 pthread_mutex_unlock(&wait_mutex);
529 while (!to_filter_data->done) {
535 while (pthread_mutex_trylock(&list_mutex) != 0) {
540 if (filter_th == 0 || !ok_to_thread)
541 bogofilter_do_filter(to_filter_data);
543 bogofilter_do_filter(to_filter_data);
546 new_hams = to_filter_data->new_hams;
547 new_unsure = to_filter_data->new_unsure;
548 new_spams = to_filter_data->new_spams;
549 whitelisted_new_spams = to_filter_data->whitelisted_new_spams;
550 status = to_filter_data->status;
551 g_free(to_filter_data);
552 to_filter_data = NULL;
554 pthread_mutex_unlock(&list_mutex);
559 for (cur = new_hams; cur; cur = cur->next) {
560 MsgInfo *msginfo = (MsgInfo *)cur->data;
561 procmsg_msginfo_unset_flags(msginfo, MSG_SPAM, 0);
562 debug_print("unflagging ham: %d\n", msginfo->msgnum);
565 for (cur = new_unsure; cur; cur = cur->next) {
566 MsgInfo *msginfo = (MsgInfo *)cur->data;
567 procmsg_msginfo_unset_flags(msginfo, MSG_SPAM, 0);
568 debug_print("unflagging unsure: %d\n", msginfo->msgnum);
570 if (config.learn_from_whitelist && whitelisted_new_spams) {
571 /* flag whitelisted spams */
572 for (cur = whitelisted_new_spams; cur; cur = cur->next) {
573 MsgInfo *msginfo = (MsgInfo *)cur->data;
574 procmsg_msginfo_set_flags(msginfo, MSG_SPAM, 0);
575 debug_print("flagging whitelisted non-ham: %d\n", msginfo->msgnum);
578 bogofilter_learn(NULL, whitelisted_new_spams, FALSE);
581 for (cur = whitelisted_new_spams; cur; cur = cur->next) {
582 MsgInfo *msginfo = (MsgInfo *)cur->data;
583 procmsg_msginfo_unset_flags(msginfo, MSG_SPAM, 0);
584 debug_print("unflagging whitelisted non-ham: %d\n", msginfo->msgnum);
587 for (cur = whitelisted_new_spams; cur; cur = cur->next) {
588 MsgInfo *msginfo = (MsgInfo *)cur->data;
589 procmsg_msginfo_unset_flags(msginfo, MSG_SPAM, 0);
590 debug_print("not flagging whitelisted non-ham: %d\n", msginfo->msgnum);
594 /* flag spams and delete them if config.receive_spam == 0
595 * (if config.receive_spam is set to 1, we'll move them later,
596 * mark as spam only if set to 2) */
597 for (cur = new_spams; cur; cur = cur->next) {
598 MsgInfo *msginfo = (MsgInfo *)cur->data;
599 if (config.receive_spam != SPAM_DELETE) {
600 if (config.mark_as_read)
601 procmsg_msginfo_unset_flags(msginfo, ~0, 0);
602 procmsg_msginfo_set_flags(msginfo, MSG_SPAM, 0);
604 folder_item_remove_msg(msginfo->folder, msginfo->msgnum);
608 if (status < 0 || status > 2) { /* I/O or other errors */
612 msg = g_strdup_printf(_("The Bogofilter plugin couldn't filter "
613 "a message. The probable cause of the "
614 "error is that it didn't learn from any mail.\n"
615 "Use \"/Mark/Mark as spam\" and \"/Mark/Mark as "
616 "ham\" to train Bogofilter with a few hundred "
617 "spam and ham messages."));
619 msg = g_strdup_printf(_("The Bogofilter plugin couldn't filter "
620 "a message. The command `%s %s %s` couldn't be run."),
621 bogo_args[0], bogo_args[1], bogo_args[2]);
622 if (!prefs_common_get_prefs()->no_recv_err_panel) {
624 alertpanel_error("%s", msg);
628 log_error(LOG_PROTOCOL, "%s\n", msg);
632 if (status < 0 || status > 2) {
633 g_slist_free(mail_filtering_data->filtered);
634 g_slist_free(mail_filtering_data->unfiltered);
635 mail_filtering_data->filtered = NULL;
636 mail_filtering_data->unfiltered = NULL;
638 if (config.receive_spam == SPAM_MARK_AND_SAVE && new_spams) {
639 FolderItem *save_folder = NULL;
641 if ((!config.save_folder) ||
642 (config.save_folder[0] == '\0') ||
643 ((save_folder = folder_find_item_from_identifier(config.save_folder)) == NULL)) {
644 if (mail_filtering_data->account && mail_filtering_data->account->set_trash_folder) {
645 save_folder = folder_find_item_from_identifier(
646 mail_filtering_data->account->trash_folder);
648 debug_print("found trash folder from account's advanced settings\n");
650 if (save_folder == NULL && mail_filtering_data->account &&
651 mail_filtering_data->account->folder) {
652 save_folder = mail_filtering_data->account->folder->trash;
654 debug_print("found trash folder from account's trash\n");
656 if (save_folder == NULL && mail_filtering_data->account &&
657 !mail_filtering_data->account->folder) {
658 if (mail_filtering_data->account->inbox) {
659 FolderItem *item = folder_find_item_from_identifier(
660 mail_filtering_data->account->inbox);
661 if (item && item->folder->trash) {
662 save_folder = item->folder->trash;
663 debug_print("found trash folder from account's inbox\n");
666 if (!save_folder && mail_filtering_data->account->local_inbox) {
667 FolderItem *item = folder_find_item_from_identifier(
668 mail_filtering_data->account->local_inbox);
669 if (item && item->folder->trash) {
670 save_folder = item->folder->trash;
671 debug_print("found trash folder from account's local_inbox\n");
675 if (save_folder == NULL) {
676 debug_print("using default trash folder\n");
677 save_folder = folder_get_default_trash();
681 for (cur = new_spams; cur; cur = cur->next) {
682 msginfo = (MsgInfo *)cur->data;
683 msginfo->filter_op = IS_MOVE;
684 msginfo->to_filter_folder = save_folder;
688 if (config.save_unsure && new_unsure) {
689 FolderItem *save_unsure_folder = NULL;
691 if ((!config.save_unsure_folder) ||
692 (config.save_unsure_folder[0] == '\0') ||
693 ((save_unsure_folder = folder_find_item_from_identifier(config.save_unsure_folder)) == NULL)) {
694 if (mail_filtering_data->account)
695 save_unsure_folder = folder_find_item_from_identifier(
696 mail_filtering_data->account->inbox);
697 if (save_unsure_folder == NULL && mail_filtering_data->account &&
698 mail_filtering_data->account->folder)
699 save_unsure_folder = mail_filtering_data->account->folder->inbox;
700 if (save_unsure_folder == NULL && mail_filtering_data->account &&
701 !mail_filtering_data->account->folder) {
702 if (mail_filtering_data->account->inbox) {
703 FolderItem *item = folder_find_item_from_identifier(
704 mail_filtering_data->account->inbox);
706 save_unsure_folder = item;
709 if (!save_unsure_folder && mail_filtering_data->account->local_inbox) {
710 FolderItem *item = folder_find_item_from_identifier(
711 mail_filtering_data->account->local_inbox);
713 save_unsure_folder = item;
717 if (save_unsure_folder == NULL)
718 save_unsure_folder = folder_get_default_inbox();
720 if (save_unsure_folder) {
721 for (cur = new_unsure; cur; cur = cur->next) {
722 msginfo = (MsgInfo *)cur->data;
723 msginfo->filter_op = IS_MOVE;
724 msginfo->to_filter_folder = save_unsure_folder;
729 g_slist_free(new_hams);
730 g_slist_free(new_unsure);
731 g_slist_free(new_spams);
732 g_slist_free(whitelisted_new_spams);
734 if (message_callback != NULL)
735 message_callback(NULL, 0, 0, FALSE);
736 mail_filtering_data->filtered = g_slist_reverse(
737 mail_filtering_data->filtered);
738 mail_filtering_data->unfiltered = g_slist_reverse(
739 mail_filtering_data->unfiltered);
744 BogofilterConfig *bogofilter_get_config(void)
749 int bogofilter_learn(MsgInfo *msginfo, GSList *msglist, gboolean spam)
753 const gchar *bogo_exec = (config.bogopath && *config.bogopath) ? config.bogopath:"bogofilter";
756 if (msginfo == NULL && msglist == NULL) {
761 file = procmsg_get_message_file(msginfo);
765 if (message_callback != NULL)
766 message_callback(_("Bogofilter: learning from message..."), 0, 0, FALSE);
769 cmd = g_strdup_printf("%s -s -I '%s'", bogo_exec, file);
770 else if (MSG_IS_SPAM(msginfo->flags))
771 /* correct bogofilter, this wasn't spam */
772 cmd = g_strdup_printf("%s -Sn -I '%s'", bogo_exec, file);
775 cmd = g_strdup_printf("%s -n -I '%s'", bogo_exec, file);
777 debug_print("%s\n", cmd);
778 if ((status = execute_command_line(cmd, FALSE, NULL)) != 0)
779 log_error(LOG_PROTOCOL, _("Learning failed; `%s` returned with status %d."),
783 if (message_callback != NULL)
784 message_callback(NULL, 0, 0, FALSE);
786 } else if (msglist) {
787 GSList *cur = msglist;
789 int total = g_slist_length(msglist);
791 gboolean some_correction = FALSE, some_no_correction = FALSE;
793 if (message_callback != NULL)
794 message_callback(_("Bogofilter: learning from messages..."), total, 0, FALSE);
796 for (cur = msglist; cur && status == 0; cur = cur->next) {
797 info = (MsgInfo *)cur->data;
799 some_no_correction = TRUE;
800 else if (MSG_IS_SPAM(info->flags))
801 /* correct bogofilter, this wasn't spam */
802 some_correction = TRUE;
804 some_no_correction = TRUE;
808 if (some_correction && some_no_correction) {
809 /* we potentially have to do different stuff for every mail */
810 for (cur = msglist; cur && status == 0; cur = cur->next) {
811 info = (MsgInfo *)cur->data;
812 file = procmsg_get_message_file(info);
816 cmd = g_strdup_printf("%s -s -I '%s'", bogo_exec, file);
817 else if (MSG_IS_SPAM(info->flags))
818 /* correct bogofilter, this wasn't spam */
819 cmd = g_strdup_printf("%s -Sn -I '%s'", bogo_exec, file);
822 cmd = g_strdup_printf("%s -n -I '%s'", bogo_exec, file);
824 debug_print("%s\n", cmd);
825 if ((status = execute_command_line(cmd, FALSE, NULL)) != 0)
826 log_error(LOG_PROTOCOL, _("Learning failed; `%s` returned with status %d."),
832 if (message_callback != NULL)
833 message_callback(NULL, total, done, FALSE);
835 } else if (some_correction || some_no_correction) {
841 GError *error = NULL;
842 gboolean bogo_forked;
844 bogo_args[0] = (gchar *)bogo_exec;
845 if (some_correction && !some_no_correction)
846 bogo_args[1] = "-Sn";
847 else if (some_no_correction && !some_correction)
848 bogo_args[1] = spam ? "-s":"-n";
851 debug_print("|%s %s %s ...\n", bogo_args[0], bogo_args[1], bogo_args[2]);
852 bogo_forked = g_spawn_async_with_pipes(
853 NULL, bogo_args,NULL, G_SPAWN_SEARCH_PATH|G_SPAWN_DO_NOT_REAP_CHILD,
854 NULL, NULL, &bogo_pid, &bogo_stdin,
857 while (bogo_forked && cur) {
859 info = (MsgInfo *)cur->data;
860 file = procmsg_get_message_file(info);
862 tmp = g_strdup_printf("%s\n",
864 write_all(bogo_stdin, tmp, strlen(tmp));
869 if (message_callback != NULL)
870 message_callback(NULL, total, done, FALSE);
875 waitpid(bogo_pid, &status, 0);
876 if (!WIFEXITED(status))
879 status = WEXITSTATUS(status);
881 if (!bogo_forked || status != 0) {
882 log_error(LOG_PROTOCOL, _("Learning failed; `%s %s %s` returned with error:\n%s"),
883 bogo_args[0], bogo_args[1], bogo_args[2],
884 error ? error->message:_("Unknown error"));
891 if (message_callback != NULL)
892 message_callback(NULL, 0, 0, FALSE);
897 void bogofilter_save_config(void)
902 debug_print("Saving Bogofilter Page\n");
904 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
905 pfile = prefs_write_open(rcpath);
907 if (!pfile || (prefs_set_block_label(pfile, "Bogofilter") < 0))
910 if (prefs_write_param(param, pfile->fp) < 0) {
911 g_warning("Failed to write Bogofilter configuration to file");
912 prefs_file_close_revert(pfile);
915 if (fprintf(pfile->fp, "\n") < 0) {
916 FILE_OP_ERROR(rcpath, "fprintf");
917 prefs_file_close_revert(pfile);
919 prefs_file_close(pfile);
922 void bogofilter_set_message_callback(MessageCallback callback)
924 message_callback = callback;
927 gint plugin_init(gchar **error)
933 if (!check_plugin_version(MAKE_NUMERIC_VERSION(2,9,2,72),
934 VERSION_NUMERIC, PLUGIN_NAME, error))
937 prefs_set_default(param);
938 rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
939 prefs_read_config(param, "Bogofilter", rcpath, NULL);
942 bogofilter_gtk_init();
944 debug_print("Bogofilter plugin loaded\n");
947 bogofilter_start_thread();
950 if (config.process_emails) {
951 bogofilter_register_hook();
954 procmsg_register_spam_learner(bogofilter_learn);
955 procmsg_spam_set_folder(config.save_folder, bogofilter_get_spam_folder);
961 FolderItem *bogofilter_get_spam_folder(MsgInfo *msginfo)
963 FolderItem *item = folder_find_item_from_identifier(config.save_folder);
965 if (item || msginfo == NULL || msginfo->folder == NULL)
968 if (msginfo->folder->folder &&
969 msginfo->folder->folder->account &&
970 msginfo->folder->folder->account->set_trash_folder) {
971 item = folder_find_item_from_identifier(
972 msginfo->folder->folder->account->trash_folder);
976 msginfo->folder->folder &&
977 msginfo->folder->folder->trash)
978 item = msginfo->folder->folder->trash;
981 item = folder_get_default_trash();
983 debug_print("bogo spam dir: %s\n", folder_item_get_path(item));
987 gboolean plugin_done(void)
990 bogofilter_unregister_hook();
993 bogofilter_stop_thread();
995 g_free(config.save_folder);
996 bogofilter_gtk_done();
997 procmsg_unregister_spam_learner(bogofilter_learn);
998 procmsg_spam_set_folder(NULL, NULL);
999 debug_print("Bogofilter plugin unloaded\n");
1003 const gchar *plugin_name(void)
1008 const gchar *plugin_desc(void)
1010 return _("This plugin can check all messages that are received from an "
1011 "IMAP, LOCAL or POP account for spam using Bogofilter. "
1012 "You will need Bogofilter installed locally.\n"
1014 "Before Bogofilter can recognize spam messages, you have to "
1015 "train it by marking a few hundred spam and ham messages "
1016 "with the use of \"/Mark/Mark as spam\" and \"/Mark/Mark as "
1019 "When a message is identified as spam it can be deleted or "
1020 "saved in a specially designated folder.\n"
1022 "Options can be found in /Configuration/Preferences/Plugins/Bogofilter");
1025 const gchar *plugin_type(void)
1030 const gchar *plugin_licence(void)
1035 const gchar *plugin_version(void)
1040 struct PluginFeature *plugin_provides(void)
1042 static struct PluginFeature features[] =
1043 { {PLUGIN_FILTERING, N_("Spam detection")},
1044 {PLUGIN_FILTERING, N_("Spam learning")},
1045 {PLUGIN_NOTHING, NULL}};
1049 void bogofilter_register_hook(void)
1052 hook_id = hooks_register_hook(MAIL_LISTFILTERING_HOOKLIST, mail_filtering_hook, NULL);
1053 if (hook_id == -1) {
1054 g_warning("Failed to register mail filtering hook");
1055 config.process_emails = FALSE;
1059 void bogofilter_unregister_hook(void)
1061 if (hook_id != -1) {
1062 hooks_unregister_hook(MAIL_LISTFILTERING_HOOKLIST, hook_id);