RSSyl: Allow use of .netrc by libcurl. Bug/enhancement #3309, by Vincent Pelletier
[claws.git] / src / plugins / bogofilter / bogofilter.c
1 /*
2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2012 Colin Leroy <colin@colino.net> and 
4  * the Claws Mail team
5  *
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.
10  *
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.
15  *
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/>.
18  * 
19  */
20
21 #ifdef HAVE_CONFIG_H
22 #  include "config.h"
23 #include "claws-features.h"
24 #endif
25
26 #include "defs.h"
27
28 #include <sys/types.h>
29 #include <sys/wait.h>
30 #include <errno.h>
31
32 #include <glib.h>
33 #include <glib/gi18n.h>
34
35 #if HAVE_LOCALE_H
36 #  include <locale.h>
37 #endif
38
39 #include "common/claws.h"
40 #include "common/version.h"
41 #include "plugin.h"
42 #include "common/utils.h"
43 #include "hooks.h"
44 #include "procmsg.h"
45 #include "folder.h"
46 #include "prefs.h"
47 #include "prefs_gtk.h"
48
49 #include "bogofilter.h"
50 #include "inc.h"
51 #include "log.h"
52 #include "prefs_common.h"
53 #include "alertpanel.h"
54 #include "addr_compl.h"
55
56 #ifdef HAVE_SYSEXITS_H
57 #include <sysexits.h>
58 #endif
59 #ifdef HAVE_ERRNO_H
60 #include <errno.h>
61 #endif
62 #ifdef HAVE_SYS_ERRNO_H
63 #include <sys/errno.h>
64 #endif
65 #ifdef HAVE_TIME_H
66 #include <time.h>
67 #endif
68 #ifdef HAVE_SYS_TIME_H
69 #include <sys/time.h>
70 #endif
71 #ifdef HAVE_SIGNAL_H
72 #include <signal.h>
73 #endif
74 #ifdef HAVE_PWD_H
75 #include <pwd.h>
76 #endif
77 #ifdef USE_PTHREAD
78 #include <pthread.h>
79 #endif
80
81 #define PLUGIN_NAME (_("Bogofilter"))
82
83 static guint hook_id = -1;
84 static MessageCallback message_callback;
85
86 static BogofilterConfig config;
87
88 static PrefParam param[] = {
89         {"process_emails", "TRUE", &config.process_emails, P_BOOL,
90          NULL, NULL, NULL},
91         {"receive_spam", "TRUE", &config.receive_spam, P_BOOL,
92          NULL, NULL, NULL},
93         {"save_folder", NULL, &config.save_folder, P_STRING,
94          NULL, NULL, NULL},
95         {"save_unsure", "FALSE", &config.save_unsure, P_BOOL,
96          NULL, NULL, NULL},
97         {"save_unsure_folder", NULL, &config.save_unsure_folder, P_STRING,
98          NULL, NULL, NULL},
99         {"max_size", "250", &config.max_size, P_INT,
100          NULL, NULL, NULL},
101         {"bogopath", "bogofilter", &config.bogopath, P_STRING,
102          NULL, NULL, NULL},
103         {"insert_header", "FALSE", &config.insert_header, P_BOOL,
104          NULL, NULL, NULL},
105         {"whitelist_ab", "FALSE", &config.whitelist_ab, P_BOOL,
106          NULL, NULL, NULL},
107         {"whitelist_ab_folder", N_("Any"), &config.whitelist_ab_folder, P_STRING,
108          NULL, NULL, NULL},
109         {"learn_from_whitelist", "FALSE", &config.learn_from_whitelist, P_BOOL,
110          NULL, NULL, NULL},
111         {"mark_as_read", "TRUE", &config.mark_as_read, P_BOOL,
112          NULL, NULL, NULL},
113
114         {NULL, NULL, NULL, P_OTHER, NULL, NULL, NULL}
115 };
116
117 /*
118  * Helper function for spawn_with_input() - write an entire
119  * string to a fd.
120  */
121 static gboolean
122 write_all (int         fd,
123            const char *buf,
124            gsize       to_write)
125 {
126   while (to_write > 0)
127     {
128       gssize count = write (fd, buf, to_write);
129       if (count < 0)
130         {
131           if (errno != EINTR)
132             return FALSE;
133         }
134       else
135         {
136           to_write -= count;
137           buf += count;
138         }
139     }
140
141   return TRUE;
142 }
143
144 typedef struct _BogoFilterData {
145         MailFilteringData *mail_filtering_data;
146         gchar **bogo_args;
147         GSList *msglist;
148         GSList *new_hams;
149         GSList *new_unsure;
150         GSList *new_spams;
151         GSList *whitelisted_new_spams;
152         gboolean done;
153         int status;
154         gboolean in_thread;
155 } BogoFilterData;
156
157 static BogoFilterData *to_filter_data = NULL;
158 #ifdef USE_PTHREAD
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; 
163 #endif
164
165 static gboolean found_in_addressbook(const gchar *address)
166 {
167         gchar *addr = NULL;
168         gboolean found = FALSE;
169         gint num_addr = 0;
170         
171         if (!address)
172                 return FALSE;
173         
174         addr = g_strdup(address);
175         extract_address(addr);
176         num_addr = complete_address(addr);
177         if (num_addr > 1) {
178                 /* skip first item (this is the search string itself) */
179                 int i = 1;
180                 for (; i < num_addr && !found; i++) {
181                         gchar *caddr = get_complete_address(i);
182                         extract_address(caddr);
183                         if (strcasecmp(caddr, addr) == 0)
184                                 found = TRUE;
185                         g_free(caddr);
186                 }
187         }
188         g_free(addr);
189         return found;
190 }
191
192 static void bogofilter_do_filter(BogoFilterData *data)
193 {
194         GPid bogo_pid;
195         gint bogo_stdin, bogo_stdout;
196         GError *error = NULL;
197         gboolean bogo_forked;
198         int status = 0;
199         MsgInfo *msginfo;
200         GSList *cur = NULL;
201         int total = 0, curnum = 1;
202         gchar *file = NULL;
203         gchar buf[BUFSIZ];
204
205         total = g_slist_length(data->msglist);
206
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);
211                 
212         if (bogo_forked == FALSE) {
213                 g_warning("%s\n", error ? error->message:"ERROR???");
214                 g_error_free(error);
215                 error = NULL;
216                 status = -1;
217         } else {
218         
219                 if (config.whitelist_ab) {
220                         gchar *ab_folderpath;
221
222                         if (*config.whitelist_ab_folder == '\0' ||
223                                 strcasecmp(config.whitelist_ab_folder, "Any") == 0) {
224                                 /* match the whole addressbook */
225                                 ab_folderpath = NULL;
226                         } else {
227                                 /* match the specific book/folder of the addressbook */
228                                 ab_folderpath = config.whitelist_ab_folder;
229                         }
230
231                         start_address_completion(ab_folderpath);
232                 }
233
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);
238
239                         if (message_callback != NULL)
240                                 message_callback(NULL, total, curnum++, data->in_thread);
241
242                         if (config.whitelist_ab && msginfo->from && 
243                             found_in_addressbook(msginfo->from))
244                                 whitelisted = TRUE;
245
246                         /* can set flags (SCANNED, ATTACHMENT) but that's ok 
247                          * as GUI updates are hooked not direct */
248
249                         file = procmsg_get_message_file(msginfo);
250
251                         if (file) {
252                                 gchar *tmp = g_strdup_printf("%s\n",file);
253                                 /* send filename to bogofilter */
254                                 write_all(bogo_stdin, tmp, strlen(tmp));
255                                 g_free(tmp);
256                                 memset(buf, 0, sizeof(buf));
257                                 /* get the result */
258                                 if (read(bogo_stdout, buf, sizeof(buf)-1) < 0) {
259                                         g_warning("bogofilter short read\n");
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);
264                                 } else {
265                                         gchar **parts = NULL;
266
267                                         buf[sizeof(buf) - 1] = '\0';
268                                         if (strchr(buf, '/')) {
269                                                 tmp = strrchr(buf, '/')+1;
270                                         } else {
271                                                 tmp = buf;
272                                         }
273                                         parts = g_strsplit(tmp, " ", 0);
274                                         debug_print("read %s\n", buf);
275                                         
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) 
286                                                         fclose (input);
287                                                 else if (!input && output)
288                                                         fclose (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",
296                                                                         bogosity, parts[2],
297                                                                         whitelisted?" [whitelisted]":"");
298                                                         if (fwrite(tmpstr, 1, strlen(tmpstr), output) < strlen(tmpstr)) {
299                                                                 err = TRUE;
300                                                         } else {
301                                                                 while (fgets(tmpbuf, sizeof(buf), input)) {
302                                                                         if (fputs(tmpbuf, output) == EOF) {
303                                                                                 err = TRUE;
304                                                                                 break;
305                                                                         }
306                                                                 }
307                                                         }
308                                                         fclose(input);
309                                                         if (fclose(output) == EOF)
310                                                                 err = TRUE;
311                                                         if (!err)
312                                                                 move_file(tmpfile, file, TRUE);
313                                                         g_free(tmpstr);
314                                                 }
315                                                 g_free(tmpfile);
316                                         }
317
318                                         /* file the mail */
319                                         if (!whitelisted && parts && parts[0] && parts[1] && *parts[1] == 'S') {
320
321                                                 debug_print("message %d is spam\n", msginfo->msgnum);
322                                                 /* Spam will be filtered away */
323                                                 data->mail_filtering_data->filtered = g_slist_prepend(
324                                                         data->mail_filtering_data->filtered, msginfo);
325                                                 data->new_spams = g_slist_prepend(data->new_spams, msginfo);
326
327                                         } else if (whitelisted && parts && parts[0] && parts[1] && 
328                                                         (*parts[1] == 'S' || *parts[1] == 'U')) {
329
330                                                 debug_print("message %d is whitelisted %s\n", msginfo->msgnum,
331                                                         *parts[1] == 'S' ? "spam":"unsure");
332                                                 /* Whitelisted spam will *not* be filtered away, but continue
333                                                  * their trip through filtering as if it was ham. */
334                                                 data->mail_filtering_data->unfiltered = g_slist_prepend(
335                                                         data->mail_filtering_data->unfiltered, msginfo);
336                                                 /* But it gets put in a different list, so that we 
337                                                  * can still flag it and inform the user that it is
338                                                  * considered a spam (so that he can teach bogo that 
339                                                  * it was not). */
340                                                 data->whitelisted_new_spams = g_slist_prepend(data->whitelisted_new_spams, msginfo);
341
342                                         } else if (config.save_unsure && parts && parts[0] && parts[1] && *parts[1] == 'U') {
343                                                 
344                                                 debug_print("message %d is unsure\n", msginfo->msgnum);
345                                                 /* Spam will be filtered away */
346                                                 data->mail_filtering_data->filtered = g_slist_prepend(
347                                                         data->mail_filtering_data->filtered, msginfo);
348                                                 data->new_unsure = g_slist_prepend(data->new_unsure, msginfo);
349
350                                         } else {
351                                                 
352                                                 debug_print("message %d is ham\n", msginfo->msgnum);
353                                                 data->mail_filtering_data->unfiltered = g_slist_prepend(
354                                                         data->mail_filtering_data->unfiltered, msginfo);
355                                                 data->new_hams = g_slist_prepend(data->new_hams, msginfo);
356
357                                         }
358                                         g_strfreev(parts);
359                                 }
360                                 g_free(file);
361                         } else {
362                                 data->mail_filtering_data->unfiltered = g_slist_prepend(
363                                         data->mail_filtering_data->unfiltered, msginfo);
364                                 data->new_hams = g_slist_prepend(data->new_hams, msginfo);
365                         }
366                 }
367                 if (config.whitelist_ab)
368                         end_address_completion();
369         }
370         if (status != -1) {
371                 close(bogo_stdout);
372                 close(bogo_stdin);
373                 waitpid(bogo_pid, &status, 0);
374                 if (!WIFEXITED(status))
375                         status = -1;
376                 else
377                         status = WEXITSTATUS(status);
378         }
379
380         to_filter_data->status = status; 
381 }
382
383 #ifdef USE_PTHREAD
384 static void *bogofilter_filtering_thread(void *data) 
385 {
386         while (!filter_th_done) {
387                 pthread_mutex_lock(&list_mutex);
388                 if (to_filter_data == NULL || to_filter_data->done == TRUE) {
389                         pthread_mutex_unlock(&list_mutex);
390                         debug_print("thread is waiting for something to filter\n");
391                         pthread_mutex_lock(&wait_mutex);
392                         pthread_cond_wait(&wait_cond, &wait_mutex);
393                         pthread_mutex_unlock(&wait_mutex);
394                 } else {
395                         debug_print("thread awaken with something to filter\n");
396                         to_filter_data->done = FALSE;
397                         bogofilter_do_filter(to_filter_data);
398                         pthread_mutex_unlock(&list_mutex);
399                         to_filter_data->done = TRUE;
400                         usleep(100);
401                 }
402         }
403         return NULL;
404 }
405
406 static pthread_t filter_th = 0;
407
408 static void bogofilter_start_thread(void)
409 {
410         filter_th_done = FALSE;
411         if (filter_th != 0 || 1)
412                 return;
413         if (pthread_create(&filter_th, 0, 
414                         bogofilter_filtering_thread, 
415                         NULL) != 0) {
416                 filter_th = 0;
417                 return;
418         }
419         debug_print("thread created\n");
420 }
421
422 static void bogofilter_stop_thread(void)
423 {
424         void *res;
425         while (pthread_mutex_trylock(&list_mutex) != 0) {
426                 GTK_EVENTS_FLUSH();
427                 usleep(100);
428         }
429         if (filter_th != 0) {
430                 filter_th_done = TRUE;
431                 debug_print("waking thread up\n");
432                 pthread_mutex_lock(&wait_mutex);
433                 pthread_cond_broadcast(&wait_cond);
434                 pthread_mutex_unlock(&wait_mutex);
435                 pthread_join(filter_th, &res);
436                 filter_th = 0;
437         }
438         pthread_mutex_unlock(&list_mutex);
439         debug_print("thread done\n");
440 }
441 #endif
442
443 static gboolean mail_filtering_hook(gpointer source, gpointer data)
444 {
445         MailFilteringData *mail_filtering_data = (MailFilteringData *) source;
446         MsgInfo *msginfo = mail_filtering_data->msginfo;
447         GSList *msglist = mail_filtering_data->msglist;
448         GSList *cur = NULL;
449         static gboolean warned_error = FALSE;
450         int status = 0;
451         int total = 0, curnum = 0;
452         GSList *new_hams = NULL, *new_spams = NULL;
453         GSList *new_unsure, *whitelisted_new_spams = NULL;
454         gchar *bogo_exec = (config.bogopath && *config.bogopath) ? config.bogopath:"bogofilter";
455         gchar *bogo_args[4];
456         gboolean ok_to_thread = TRUE;
457
458         bogo_args[0] = bogo_exec;
459         bogo_args[1] = "-T";
460         bogo_args[2] = "-b";
461         bogo_args[3] = NULL;
462         
463         if (!config.process_emails) {
464                 return FALSE;
465         }
466         
467         if (msglist == NULL && msginfo != NULL) {
468                 g_warning("wrong call to bogofilter mail_filtering_hook");
469                 return FALSE;
470         }
471         
472         total = g_slist_length(msglist);
473         
474         /* we have to make sure the mails are cached - or it'll break on IMAP */
475         if (message_callback != NULL)
476                 message_callback(_("Bogofilter: fetching bodies..."), total, 0, FALSE);
477         for (cur = msglist; cur; cur = cur->next) {
478                 gchar *file = procmsg_get_message_file((MsgInfo *)cur->data);
479                 if (file == NULL)
480                         ok_to_thread = FALSE;
481                 if (message_callback != NULL)
482                         message_callback(NULL, total, curnum++, FALSE);
483                 g_free(file);
484         }
485         if (message_callback != NULL)
486                 message_callback(NULL, 0, 0, FALSE);
487
488         if (message_callback != NULL)
489                 message_callback(_("Bogofilter: filtering messages..."), total, 0, FALSE);
490
491 #ifdef USE_PTHREAD
492         while (pthread_mutex_trylock(&list_mutex) != 0) {
493                 GTK_EVENTS_FLUSH();
494                 usleep(100);
495         }
496 #endif
497         to_filter_data = g_new0(BogoFilterData, 1);
498         to_filter_data->msglist = msglist;
499         to_filter_data->mail_filtering_data = mail_filtering_data;
500         to_filter_data->new_hams = NULL;
501         to_filter_data->new_unsure = NULL;
502         to_filter_data->new_spams = NULL;
503         to_filter_data->whitelisted_new_spams = NULL;
504         to_filter_data->done = FALSE;
505         to_filter_data->status = -1;
506         to_filter_data->bogo_args = bogo_args;
507 #ifdef USE_PTHREAD
508         to_filter_data->in_thread = (filter_th != 0 && ok_to_thread);
509 #else
510         to_filter_data->in_thread = FALSE;
511 #endif
512
513 #ifdef USE_PTHREAD
514         pthread_mutex_unlock(&list_mutex);
515         
516         if (filter_th != 0 && ok_to_thread) {
517                 debug_print("waking thread to let it filter things\n");
518                 pthread_mutex_lock(&wait_mutex);
519                 pthread_cond_broadcast(&wait_cond);
520                 pthread_mutex_unlock(&wait_mutex);
521
522                 while (!to_filter_data->done) {
523                         GTK_EVENTS_FLUSH();
524                         usleep(100);
525                 }
526         }
527
528         while (pthread_mutex_trylock(&list_mutex) != 0) {
529                 GTK_EVENTS_FLUSH();
530                 usleep(100);
531
532         }
533         if (filter_th == 0 || !ok_to_thread)
534                 bogofilter_do_filter(to_filter_data);
535 #else
536         bogofilter_do_filter(to_filter_data);   
537 #endif
538
539         new_hams = to_filter_data->new_hams;
540         new_unsure = to_filter_data->new_unsure;
541         new_spams = to_filter_data->new_spams;
542         whitelisted_new_spams = to_filter_data->whitelisted_new_spams;
543         status = to_filter_data->status;
544         g_free(to_filter_data);
545         to_filter_data = NULL;
546 #ifdef USE_PTHREAD
547         pthread_mutex_unlock(&list_mutex);
548 #endif
549
550
551         /* unflag hams */
552         for (cur = new_hams; cur; cur = cur->next) {
553                 MsgInfo *msginfo = (MsgInfo *)cur->data;
554                 procmsg_msginfo_unset_flags(msginfo, MSG_SPAM, 0);
555                 debug_print("unflagging ham: %d\n", msginfo->msgnum);
556         }
557         /* unflag unsure */
558         for (cur = new_unsure; cur; cur = cur->next) {
559                 MsgInfo *msginfo = (MsgInfo *)cur->data;
560                 procmsg_msginfo_unset_flags(msginfo, MSG_SPAM, 0);
561                 debug_print("unflagging unsure: %d\n", msginfo->msgnum);
562         }
563         if (config.learn_from_whitelist && whitelisted_new_spams) {
564                 /* flag whitelisted spams */
565                 for (cur = whitelisted_new_spams; cur; cur = cur->next) {
566                         MsgInfo *msginfo = (MsgInfo *)cur->data;
567                         procmsg_msginfo_set_flags(msginfo, MSG_SPAM, 0);
568                         debug_print("flagging whitelisted non-ham: %d\n", msginfo->msgnum);
569                 }
570                 /* correct bogo */
571                 bogofilter_learn(NULL, whitelisted_new_spams, FALSE);
572
573                 /* unflag them */
574                 for (cur = whitelisted_new_spams; cur; cur = cur->next) {
575                         MsgInfo *msginfo = (MsgInfo *)cur->data;
576                         procmsg_msginfo_unset_flags(msginfo, MSG_SPAM, 0);
577                         debug_print("unflagging whitelisted non-ham: %d\n", msginfo->msgnum);
578                 }
579         } else {
580                 for (cur = whitelisted_new_spams; cur; cur = cur->next) {
581                         MsgInfo *msginfo = (MsgInfo *)cur->data;
582                         procmsg_msginfo_unset_flags(msginfo, MSG_SPAM, 0);
583                         debug_print("not flagging whitelisted non-ham: %d\n", msginfo->msgnum);
584                 }
585         }
586
587         /* flag spams and delete them if !config.receive_spam 
588          * (if config.receive_spam is set, we'll move them later) */
589         for (cur = new_spams; cur; cur = cur->next) {
590                 MsgInfo *msginfo = (MsgInfo *)cur->data;
591                 if (config.receive_spam) {
592                         if (config.mark_as_read)
593                                 procmsg_msginfo_unset_flags(msginfo, ~0, 0);
594                         procmsg_msginfo_set_flags(msginfo, MSG_SPAM, 0);
595                 } else {
596                         folder_item_remove_msg(msginfo->folder, msginfo->msgnum);
597                 }
598         }
599         
600         if (status < 0 || status > 2) { /* I/O or other errors */
601                 gchar *msg = NULL;
602                 
603                 if (status == 3)
604                         msg =  g_strdup_printf(_("The Bogofilter plugin couldn't filter "
605                                            "a message. The probable cause of the "
606                                            "error is that it didn't learn from any mail.\n"
607                                            "Use \"/Mark/Mark as spam\" and \"/Mark/Mark as "
608                                            "ham\" to train Bogofilter with a few hundred "
609                                            "spam and ham messages."));
610                 else
611                         msg =  g_strdup_printf(_("The Bogofilter plugin couldn't filter "
612                                            "a message. The command `%s %s %s` couldn't be run."), 
613                                            bogo_args[0], bogo_args[1], bogo_args[2]);
614                 if (!prefs_common.no_recv_err_panel) {
615                         if (!warned_error) {
616                                 alertpanel_error("%s", msg);
617                         }
618                         warned_error = TRUE;
619                 } else {
620                         log_error(LOG_PROTOCOL, "%s\n", msg);
621                 }
622                 g_free(msg);
623         }
624         if (status < 0 || status > 2) {
625                 g_slist_free(mail_filtering_data->filtered);
626                 g_slist_free(mail_filtering_data->unfiltered);
627                 mail_filtering_data->filtered = NULL;
628                 mail_filtering_data->unfiltered = NULL;
629         } else {
630                 if (config.receive_spam && new_spams) {
631                         FolderItem *save_folder = NULL;
632
633                         if ((!config.save_folder) ||
634                             (config.save_folder[0] == '\0') ||
635                             ((save_folder = folder_find_item_from_identifier(config.save_folder)) == NULL)) {
636                                 if (mail_filtering_data->account && mail_filtering_data->account->set_trash_folder) {
637                                         save_folder = folder_find_item_from_identifier(
638                                                 mail_filtering_data->account->trash_folder);
639                                         if (save_folder)
640                                                 debug_print("found trash folder from account's advanced settings\n");
641                                 }
642                                 if (save_folder == NULL && mail_filtering_data->account &&
643                                     mail_filtering_data->account->folder) {
644                                         save_folder = mail_filtering_data->account->folder->trash;
645                                         if (save_folder)
646                                                 debug_print("found trash folder from account's trash\n");
647                                 }
648                                 if (save_folder == NULL && mail_filtering_data->account &&
649                                     !mail_filtering_data->account->folder)  {
650                                         if (mail_filtering_data->account->inbox) {
651                                                 FolderItem *item = folder_find_item_from_identifier(
652                                                         mail_filtering_data->account->inbox);
653                                                 if (item && item->folder->trash) {
654                                                         save_folder = item->folder->trash;
655                                                         debug_print("found trash folder from account's inbox\n");
656                                                 }
657                                         } 
658                                         if (!save_folder && mail_filtering_data->account->local_inbox) {
659                                                 FolderItem *item = folder_find_item_from_identifier(
660                                                         mail_filtering_data->account->local_inbox);
661                                                 if (item && item->folder->trash) {
662                                                         save_folder = item->folder->trash;
663                                                         debug_print("found trash folder from account's local_inbox\n");
664                                                 }
665                                         }
666                                 }
667                                 if (save_folder == NULL) {
668                                         debug_print("using default trash folder\n");
669                                         save_folder = folder_get_default_trash();
670                                 }
671                         }
672                         if (save_folder) {
673                                 for (cur = new_spams; cur; cur = cur->next) {
674                                         msginfo = (MsgInfo *)cur->data;
675                                         msginfo->filter_op = IS_MOVE;
676                                         msginfo->to_filter_folder = save_folder;
677                                 }
678                         }
679                 }
680                 if (config.save_unsure && new_unsure) {
681                         FolderItem *save_unsure_folder = NULL;
682
683                         if ((!config.save_unsure_folder) ||
684                             (config.save_unsure_folder[0] == '\0') ||
685                             ((save_unsure_folder = folder_find_item_from_identifier(config.save_unsure_folder)) == NULL)) {
686                                 if (mail_filtering_data->account)
687                                         save_unsure_folder = folder_find_item_from_identifier(
688                                                 mail_filtering_data->account->inbox);
689                                 if (save_unsure_folder == NULL && mail_filtering_data->account &&
690                                     mail_filtering_data->account->folder)
691                                         save_unsure_folder = mail_filtering_data->account->folder->inbox;
692                                 if (save_unsure_folder == NULL && mail_filtering_data->account &&
693                                     !mail_filtering_data->account->folder)  {
694                                         if (mail_filtering_data->account->inbox) {
695                                                 FolderItem *item = folder_find_item_from_identifier(
696                                                         mail_filtering_data->account->inbox);
697                                                 if (item) {
698                                                         save_unsure_folder = item;
699                                                 }
700                                         } 
701                                         if (!save_unsure_folder && mail_filtering_data->account->local_inbox) {
702                                                 FolderItem *item = folder_find_item_from_identifier(
703                                                         mail_filtering_data->account->local_inbox);
704                                                 if (item) {
705                                                         save_unsure_folder = item;
706                                                 }
707                                         }
708                                 }
709                                 if (save_unsure_folder == NULL)
710                                         save_unsure_folder = folder_get_default_inbox();
711                         }
712                         if (save_unsure_folder) {
713                                 for (cur = new_unsure; cur; cur = cur->next) {
714                                         msginfo = (MsgInfo *)cur->data;
715                                         msginfo->filter_op = IS_MOVE;
716                                         msginfo->to_filter_folder = save_unsure_folder;
717                                 }
718                         }
719                 }
720         } 
721         g_slist_free(new_hams);
722         g_slist_free(new_unsure);
723         g_slist_free(new_spams);
724         g_slist_free(whitelisted_new_spams);
725
726         if (message_callback != NULL)
727                 message_callback(NULL, 0, 0, FALSE);
728         mail_filtering_data->filtered   = g_slist_reverse(
729                 mail_filtering_data->filtered);
730         mail_filtering_data->unfiltered = g_slist_reverse(
731                 mail_filtering_data->unfiltered);
732         
733         return FALSE;
734 }
735
736 BogofilterConfig *bogofilter_get_config(void)
737 {
738         return &config;
739 }
740
741 int bogofilter_learn(MsgInfo *msginfo, GSList *msglist, gboolean spam)
742 {
743         gchar *cmd = NULL;
744         gchar *file = NULL;
745         const gchar *bogo_exec = (config.bogopath && *config.bogopath) ? config.bogopath:"bogofilter";
746         gint status = 0;
747
748         if (msginfo == NULL && msglist == NULL) {
749                 return -1;
750         }
751
752         if (msginfo) {
753                 file = procmsg_get_message_file(msginfo);
754                 if (file == NULL) {
755                         return -1;
756                 } else {
757                         if (message_callback != NULL)
758                                 message_callback(_("Bogofilter: learning from message..."), 0, 0, FALSE);
759                         if (spam)
760                                 /* learn as spam */
761                                 cmd = g_strdup_printf("%s -s -I '%s'", bogo_exec, file);
762                         else if (MSG_IS_SPAM(msginfo->flags))
763                                 /* correct bogofilter, this wasn't spam */
764                                 cmd = g_strdup_printf("%s -Sn -I '%s'", bogo_exec, file);
765                         else 
766                                 /* learn as ham */
767                                 cmd = g_strdup_printf("%s -n -I '%s'", bogo_exec, file);
768                                 
769                         debug_print("%s\n", cmd);
770                         if ((status = execute_command_line(cmd, FALSE)) != 0)
771                                 log_error(LOG_PROTOCOL, _("Learning failed; `%s` returned with status %d."),
772                                                 cmd, status);
773                         g_free(cmd);
774                         g_free(file);
775                         if (message_callback != NULL)
776                                 message_callback(NULL, 0, 0, FALSE);
777                 }
778         } else if (msglist) {
779                 GSList *cur = msglist;
780                 MsgInfo *info;
781                 int total = g_slist_length(msglist);
782                 int done = 0;
783                 gboolean some_correction = FALSE, some_no_correction = FALSE;
784         
785                 if (message_callback != NULL)
786                         message_callback(_("Bogofilter: learning from messages..."), total, 0, FALSE);
787                 
788                 for (cur = msglist; cur && status == 0; cur = cur->next) {
789                         info = (MsgInfo *)cur->data;
790                         if (spam)
791                                 some_no_correction = TRUE;
792                         else if (MSG_IS_SPAM(info->flags))
793                                 /* correct bogofilter, this wasn't spam */
794                                 some_correction = TRUE;
795                         else 
796                                 some_no_correction = TRUE;
797                         
798                 }
799                 
800                 if (some_correction && some_no_correction) {
801                         /* we potentially have to do different stuff for every mail */
802                         for (cur = msglist; cur && status == 0; cur = cur->next) {
803                                 info = (MsgInfo *)cur->data;
804                                 file = procmsg_get_message_file(info);
805
806                                 if (spam)
807                                         /* learn as spam */
808                                         cmd = g_strdup_printf("%s -s -I '%s'", bogo_exec, file);
809                                 else if (MSG_IS_SPAM(info->flags))
810                                         /* correct bogofilter, this wasn't spam */
811                                         cmd = g_strdup_printf("%s -Sn -I '%s'", bogo_exec, file);
812                                 else 
813                                         /* learn as ham */
814                                         cmd = g_strdup_printf("%s -n -I '%s'", bogo_exec, file);
815                                 
816                                 debug_print("%s\n", cmd);
817                                 if ((status = execute_command_line(cmd, FALSE)) != 0)
818                                         log_error(LOG_PROTOCOL, _("Learning failed; `%s` returned with status %d."),
819                                                         cmd, status);
820
821                                 g_free(cmd);
822                                 g_free(file);
823                                 done++;
824                                 if (message_callback != NULL)
825                                         message_callback(NULL, total, done, FALSE);
826                         }
827                 } else if (some_correction || some_no_correction) {
828                         cur = msglist;
829                         
830                         gchar *bogo_args[4];
831                         GPid bogo_pid;
832                         gint bogo_stdin;
833                         GError *error = NULL;
834                         gboolean bogo_forked;
835
836                         bogo_args[0] = (gchar *)bogo_exec;
837                         if (some_correction && !some_no_correction)
838                                 bogo_args[1] = "-Sn";
839                         else if (some_no_correction && !some_correction)
840                                 bogo_args[1] = spam ? "-s":"-n";
841                         bogo_args[2] = "-b";
842                         bogo_args[3] = NULL;
843                         debug_print("|%s %s %s ...\n", bogo_args[0], bogo_args[1], bogo_args[2]);
844                         bogo_forked = g_spawn_async_with_pipes(
845                                         NULL, bogo_args,NULL, G_SPAWN_SEARCH_PATH|G_SPAWN_DO_NOT_REAP_CHILD,
846                                         NULL, NULL, &bogo_pid, &bogo_stdin,
847                                         NULL, NULL, &error);
848
849                         while (bogo_forked && cur) {
850                                 gchar *tmp = NULL;
851                                 info = (MsgInfo *)cur->data;
852                                 file = procmsg_get_message_file(info);
853                                 if (file) {
854                                         tmp = g_strdup_printf("%s\n", 
855                                                 file);
856                                         write_all(bogo_stdin, tmp, strlen(tmp));
857                                         g_free(tmp);
858                                 }
859                                 g_free(file);
860                                 done++;
861                                 if (message_callback != NULL)
862                                         message_callback(NULL, total, done, FALSE);
863                                 cur = cur->next;
864                         }
865                         if (bogo_forked) {
866                                 close(bogo_stdin);
867                                 waitpid(bogo_pid, &status, 0);
868                                 if (!WIFEXITED(status))
869                                         status = -1;
870                                 else
871                                         status = WEXITSTATUS(status);
872                         }
873                         if (!bogo_forked || status != 0) {
874                                 log_error(LOG_PROTOCOL, _("Learning failed; `%s %s %s` returned with error:\n%s"),
875                                                 bogo_args[0], bogo_args[1], bogo_args[2], 
876                                                 error ? error->message:_("Unknown error"));
877                                 if (error)
878                                         g_error_free(error);
879                         }
880
881                 }
882
883                 if (message_callback != NULL)
884                         message_callback(NULL, 0, 0, FALSE);
885         }
886         return 0;
887 }
888
889 void bogofilter_save_config(void)
890 {
891         PrefFile *pfile;
892         gchar *rcpath;
893
894         debug_print("Saving Bogofilter Page\n");
895
896         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
897         pfile = prefs_write_open(rcpath);
898         g_free(rcpath);
899         if (!pfile || (prefs_set_block_label(pfile, "Bogofilter") < 0))
900                 return;
901
902         if (prefs_write_param(param, pfile->fp) < 0) {
903                 g_warning("Failed to write Bogofilter configuration to file\n");
904                 prefs_file_close_revert(pfile);
905                 return;
906         }
907         if (fprintf(pfile->fp, "\n") < 0) {
908                 FILE_OP_ERROR(rcpath, "fprintf");
909                 prefs_file_close_revert(pfile);
910         } else
911                 prefs_file_close(pfile);
912 }
913
914 void bogofilter_set_message_callback(MessageCallback callback)
915 {
916         message_callback = callback;
917 }
918
919 gint plugin_init(gchar **error)
920 {
921         gchar *rcpath;
922
923         hook_id = -1;
924
925         if (!check_plugin_version(MAKE_NUMERIC_VERSION(2,9,2,72),
926                                 VERSION_NUMERIC, PLUGIN_NAME, error))
927                 return -1;
928
929         prefs_set_default(param);
930         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
931         prefs_read_config(param, "Bogofilter", rcpath, NULL);
932         g_free(rcpath);
933
934         bogofilter_gtk_init();
935                 
936         debug_print("Bogofilter plugin loaded\n");
937
938 #ifdef USE_PTHREAD
939         bogofilter_start_thread();
940 #endif
941
942         if (config.process_emails) {
943                 bogofilter_register_hook();
944         }
945
946         procmsg_register_spam_learner(bogofilter_learn);
947         procmsg_spam_set_folder(config.save_folder, bogofilter_get_spam_folder);
948
949         return 0;
950         
951 }
952
953 FolderItem *bogofilter_get_spam_folder(MsgInfo *msginfo)
954 {
955         FolderItem *item = folder_find_item_from_identifier(config.save_folder);
956
957         if (item || msginfo == NULL || msginfo->folder == NULL)
958                 return item;
959
960         if (msginfo->folder->folder &&
961             msginfo->folder->folder->account && 
962             msginfo->folder->folder->account->set_trash_folder) {
963                 item = folder_find_item_from_identifier(
964                         msginfo->folder->folder->account->trash_folder);
965         }
966
967         if (item == NULL && 
968             msginfo->folder->folder &&
969             msginfo->folder->folder->trash)
970                 item = msginfo->folder->folder->trash;
971                 
972         if (item == NULL)
973                 item = folder_get_default_trash();
974                 
975         debug_print("bogo spam dir: %s\n", folder_item_get_path(item));
976         return item;
977 }
978
979 gboolean plugin_done(void)
980 {
981         if (hook_id != -1) {
982                 bogofilter_unregister_hook();
983         }
984 #ifdef USE_PTHREAD
985         bogofilter_stop_thread();
986 #endif
987         g_free(config.save_folder);
988         bogofilter_gtk_done();
989         procmsg_unregister_spam_learner(bogofilter_learn);
990         procmsg_spam_set_folder(NULL, NULL);
991         debug_print("Bogofilter plugin unloaded\n");
992         return TRUE;
993 }
994
995 const gchar *plugin_name(void)
996 {
997         return PLUGIN_NAME;
998 }
999
1000 const gchar *plugin_desc(void)
1001 {
1002         return _("This plugin can check all messages that are received from an "
1003                  "IMAP, LOCAL or POP account for spam using Bogofilter. "
1004                  "You will need Bogofilter installed locally.\n"
1005                  "\n"
1006                  "Before Bogofilter can recognize spam messages, you have to "
1007                  "train it by marking a few hundred spam and ham messages "
1008                  "with the use of \"/Mark/Mark as spam\" and \"/Mark/Mark as "
1009                  "ham\".\n"
1010                  "\n"
1011                  "When a message is identified as spam it can be deleted or "
1012                  "saved in a specially designated folder.\n"
1013                  "\n"
1014                  "Options can be found in /Configuration/Preferences/Plugins/Bogofilter");
1015 }
1016
1017 const gchar *plugin_type(void)
1018 {
1019         return "GTK2";
1020 }
1021
1022 const gchar *plugin_licence(void)
1023 {
1024         return "GPL3+";
1025 }
1026
1027 const gchar *plugin_version(void)
1028 {
1029         return VERSION;
1030 }
1031
1032 struct PluginFeature *plugin_provides(void)
1033 {
1034         static struct PluginFeature features[] = 
1035                 { {PLUGIN_FILTERING, N_("Spam detection")},
1036                   {PLUGIN_FILTERING, N_("Spam learning")},
1037                   {PLUGIN_NOTHING, NULL}};
1038         return features;
1039 }
1040
1041 void bogofilter_register_hook(void)
1042 {
1043         if (hook_id == -1)
1044                 hook_id = hooks_register_hook(MAIL_LISTFILTERING_HOOKLIST, mail_filtering_hook, NULL);
1045         if (hook_id == -1) {
1046                 g_warning("Failed to register mail filtering hook");
1047                 config.process_emails = FALSE;
1048         }
1049 }
1050
1051 void bogofilter_unregister_hook(void)
1052 {
1053         if (hook_id != -1) {
1054                 hooks_unregister_hook(MAIL_LISTFILTERING_HOOKLIST, hook_id);
1055         }
1056         hook_id = -1;
1057 }