2006-12-15 [paul] 2.6.1cvs36
[claws.git] / src / plugins / bogofilter / bogofilter.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2006 Hiroyuki Yamamoto and the Claws Mail Team
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 2 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, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #  include "config.h"
22 #endif
23
24 #include "defs.h"
25
26 #include <sys/types.h>
27 #include <sys/wait.h>
28 #include <errno.h>
29
30 #include <glib.h>
31 #include <glib/gi18n.h>
32
33 #if HAVE_LOCALE_H
34 #  include <locale.h>
35 #endif
36
37 #include "common/claws.h"
38 #include "common/version.h"
39 #include "plugin.h"
40 #include "common/utils.h"
41 #include "hooks.h"
42 #include "procmsg.h"
43 #include "folder.h"
44 #include "prefs.h"
45 #include "prefs_gtk.h"
46
47 #include "bogofilter.h"
48 #include "inc.h"
49 #include "log.h"
50 #include "prefs_common.h"
51 #include "alertpanel.h"
52
53 #ifdef HAVE_SYSEXITS_H
54 #include <sysexits.h>
55 #endif
56 #ifdef HAVE_ERRNO_H
57 #include <errno.h>
58 #endif
59 #ifdef HAVE_SYS_ERRNO_H
60 #include <sys/errno.h>
61 #endif
62 #ifdef HAVE_TIME_H
63 #include <time.h>
64 #endif
65 #ifdef HAVE_SYS_TIME_H
66 #include <sys/time.h>
67 #endif
68 #ifdef HAVE_SIGNAL_H
69 #include <signal.h>
70 #endif
71 #ifdef HAVE_PWD_H
72 #include <pwd.h>
73 #endif
74
75 static guint hook_id = -1;
76 static MessageCallback message_callback;
77
78 static BogofilterConfig config;
79
80 static PrefParam param[] = {
81         {"process_emails", "TRUE", &config.process_emails, P_BOOL,
82          NULL, NULL, NULL},
83         {"receive_spam", "TRUE", &config.receive_spam, P_BOOL,
84          NULL, NULL, NULL},
85         {"save_folder", NULL, &config.save_folder, P_STRING,
86          NULL, NULL, NULL},
87         {"max_size", "250", &config.max_size, P_INT,
88          NULL, NULL, NULL},
89         {"bogopath", "bogofilter", &config.bogopath, P_STRING,
90          NULL, NULL, NULL},
91         {"insert_header", "FALSE", &config.insert_header, P_BOOL,
92          NULL, NULL, NULL},
93
94         {NULL, NULL, NULL, P_OTHER, NULL, NULL, NULL}
95 };
96
97 /*
98  * Helper function for spawn_with_input() - write an entire
99  * string to a fd.
100  */
101 static gboolean
102 write_all (int         fd,
103            const char *buf,
104            gsize       to_write)
105 {
106   while (to_write > 0)
107     {
108       gssize count = write (fd, buf, to_write);
109       if (count < 0)
110         {
111           if (errno != EINTR)
112             return FALSE;
113         }
114       else
115         {
116           to_write -= count;
117           buf += count;
118         }
119     }
120
121   return TRUE;
122 }
123
124 typedef struct _BogoFilterData {
125         MailFilteringData *mail_filtering_data;
126         gchar **bogo_args;
127         GSList *msglist;
128         GSList *new_hams;
129         GSList *new_spams;
130         GSList *spams_to_receive;
131         gboolean done;
132         int status;
133         gboolean in_thread;
134 } BogoFilterData;
135
136 static BogoFilterData *to_filter_data = NULL;
137 #ifdef USE_PTHREAD
138 static gboolean filter_th_done = FALSE;
139 static pthread_mutex_t list_mutex = PTHREAD_MUTEX_INITIALIZER;
140 static pthread_mutex_t wait_mutex = PTHREAD_MUTEX_INITIALIZER; 
141 static pthread_cond_t wait_cond = PTHREAD_COND_INITIALIZER; 
142 #endif
143
144 static void bogofilter_do_filter(BogoFilterData *data)
145 {
146         GPid bogo_pid;
147         gint bogo_stdin, bogo_stdout;
148         GError *error = NULL;
149         gboolean bogo_forked;
150         int status = 0;
151         MsgInfo *msginfo;
152         GSList *cur = NULL;
153         int total = 0, curnum = 0;
154         gchar *file = NULL;
155         gchar buf[BUFSIZ];
156
157         total = g_slist_length(data->msglist);
158
159         bogo_forked = g_spawn_async_with_pipes(
160                         NULL, data->bogo_args,NULL, G_SPAWN_SEARCH_PATH|G_SPAWN_DO_NOT_REAP_CHILD,
161                         NULL, NULL, &bogo_pid, &bogo_stdin,
162                         &bogo_stdout, NULL, &error);
163                 
164         if (bogo_forked == FALSE) {
165                 g_warning("%s\n", error ? error->message:"ERROR???");
166                 g_error_free(error);
167                 error = NULL;
168                 status = -1;
169         } else {
170                 for (cur = data->msglist; cur; cur = cur->next) {
171                         msginfo = (MsgInfo *)cur->data;
172                         debug_print("Filtering message %d (%d/%d)\n", msginfo->msgnum, curnum, total);
173
174                         if (message_callback != NULL)
175                                 message_callback(NULL, total, curnum++, data->in_thread);
176
177                         /* can set flags (SCANNED, ATTACHMENT) but that's ok 
178                          * as GUI updates are hooked not direct */
179                         file = procmsg_get_message_file(msginfo);
180                         if (file) {
181                                 gchar *tmp = g_strdup_printf("%s\n",file);
182                                 write_all(bogo_stdin, tmp, strlen(tmp));
183                                 g_free(tmp);
184                                 memset(buf, 0, sizeof(buf));
185                                 if (read(bogo_stdout, buf, sizeof(buf)-1) < 0) {
186                                         g_warning("bogofilter short read\n");
187                                         debug_print("message %d is ham\n", msginfo->msgnum);
188                                         data->mail_filtering_data->unfiltered = g_slist_prepend(
189                                                 data->mail_filtering_data->unfiltered, msginfo);
190                                         data->new_hams = g_slist_prepend(data->new_hams, msginfo);
191                                 } else {
192                                         gchar **parts = NULL;
193                                         if (strchr(buf, '/')) {
194                                                 tmp = strrchr(buf, '/')+1;
195                                         } else {
196                                                 tmp = buf;
197                                         }
198                                         parts = g_strsplit(tmp, " ", 0);
199                                         debug_print("read %s\n", buf);
200                                         if (parts && parts[0] && parts[1] && parts[2] && 
201                                             FOLDER_TYPE(msginfo->folder->folder) == F_MH &&
202                                             config.insert_header) {
203                                                 gchar *tmpfile = get_tmp_file();
204                                                 FILE *input = fopen(file, "r");
205                                                 FILE *output = fopen(tmpfile, "w");
206                                                 if (strstr(parts[2], "\n"))
207                                                         *(strstr(parts[2], "\n")) = '\0';
208                                                 if (input && !output) 
209                                                         fclose (input);
210                                                 else if (!input && output)
211                                                         fclose (output);
212                                                 else {
213                                                         gchar tmpbuf[BUFFSIZE];
214                                                         const gchar *bogosity = *parts[1] == 'S' ? "Spam":
215                                                                                  (*parts[1] == 'H' ? "Ham":"Unsure");
216                                                         gchar *tmpstr = g_strdup_printf(
217                                                                         "X-Claws-Bogosity: %s, spamicity=%s\n",
218                                                                         bogosity, parts[2]);
219                                                         fwrite(tmpstr, 1, strlen(tmpstr), output);
220                                                         while (fgets(tmpbuf, sizeof(buf), input))
221                                                                 fputs(tmpbuf, output);
222                                                         fclose(input);
223                                                         fclose(output);
224                                                         move_file(tmpfile, file, TRUE);
225                                                         g_free(tmpstr);
226                                                 }
227                                                 g_free(tmpfile);
228                                         }
229                                         if (parts && parts[0] && parts[1] && *parts[1] == 'S') {
230                                                 debug_print("message %d is spam\n", msginfo->msgnum);
231                                                 if (config.receive_spam) {
232                                                         data->spams_to_receive = g_slist_prepend(data->spams_to_receive, msginfo);
233                                                 } 
234
235                                                 data->mail_filtering_data->filtered = g_slist_prepend(
236                                                         data->mail_filtering_data->filtered, msginfo);
237                                                 data->new_spams = g_slist_prepend(data->new_spams, msginfo);
238                                         } else {
239                                                 debug_print("message %d is ham\n", msginfo->msgnum);
240                                                 data->mail_filtering_data->unfiltered = g_slist_prepend(
241                                                         data->mail_filtering_data->unfiltered, msginfo);
242                                                 data->new_hams = g_slist_prepend(data->new_hams, msginfo);
243                                         }
244                                         g_strfreev(parts);
245                                 }
246                                 g_free(file);
247                         } else {
248                                 data->mail_filtering_data->unfiltered = g_slist_prepend(
249                                         data->mail_filtering_data->unfiltered, msginfo);
250                                 data->new_hams = g_slist_prepend(data->new_hams, msginfo);
251                         }
252                 }
253         }
254         if (status != -1) {
255                 close(bogo_stdout);
256                 close(bogo_stdin);
257                 waitpid(bogo_pid, &status, 0);
258                 if (!WIFEXITED(status))
259                         status = -1;
260                 else
261                         status = WEXITSTATUS(status);
262         }
263         
264         to_filter_data->status = status; 
265 }
266
267 #ifdef USE_PTHREAD
268 static void *bogofilter_filtering_thread(void *data) 
269 {
270         while (!filter_th_done) {
271                 pthread_mutex_lock(&list_mutex);
272                 if (to_filter_data == NULL || to_filter_data->done == TRUE) {
273                         pthread_mutex_unlock(&list_mutex);
274                         debug_print("thread is waiting for something to filter\n");
275                         pthread_mutex_lock(&wait_mutex);
276                         pthread_cond_wait(&wait_cond, &wait_mutex);
277                         pthread_mutex_unlock(&wait_mutex);
278                 } else {
279                         debug_print("thread awaken with something to filter\n");
280                         to_filter_data->done = FALSE;
281                         bogofilter_do_filter(to_filter_data);
282                         pthread_mutex_unlock(&list_mutex);
283                         to_filter_data->done = TRUE;
284                         usleep(100);
285                 }
286         }
287         return NULL;
288 }
289
290 static pthread_t filter_th = 0;
291
292 static void bogofilter_start_thread(void)
293 {
294         filter_th_done = FALSE;
295         if (filter_th != 0 || 1)
296                 return;
297         if (pthread_create(&filter_th, 0, 
298                         bogofilter_filtering_thread, 
299                         NULL) != 0) {
300                 filter_th = 0;
301                 return;
302         }
303         debug_print("thread created\n");
304 }
305
306 static void bogofilter_stop_thread(void)
307 {
308         void *res;
309         while (pthread_mutex_trylock(&list_mutex) != 0) {
310                 GTK_EVENTS_FLUSH();
311                 usleep(100);
312         }
313         if (filter_th != 0) {
314                 filter_th_done = TRUE;
315                 debug_print("waking thread up\n");
316                 pthread_mutex_lock(&wait_mutex);
317                 pthread_cond_broadcast(&wait_cond);
318                 pthread_mutex_unlock(&wait_mutex);
319                 pthread_join(filter_th, &res);
320                 filter_th = 0;
321         }
322         pthread_mutex_unlock(&list_mutex);
323         debug_print("thread done\n");
324 }
325 #endif
326
327 static gboolean mail_filtering_hook(gpointer source, gpointer data)
328 {
329         MailFilteringData *mail_filtering_data = (MailFilteringData *) source;
330         MsgInfo *msginfo = mail_filtering_data->msginfo;
331         GSList *msglist = mail_filtering_data->msglist;
332         GSList *cur = NULL;
333         static gboolean warned_error = FALSE;
334         int status = 0;
335         int total = 0, curnum = 0;
336         GSList *spams_to_receive = NULL, *new_hams = NULL, *new_spams = NULL;
337         gchar *bogo_exec = (config.bogopath && *config.bogopath) ? config.bogopath:"bogofilter";
338         gchar *bogo_args[4];
339         gboolean ok_to_thread = TRUE;
340
341         bogo_args[0] = bogo_exec;
342         bogo_args[1] = "-T";
343         bogo_args[2] = "-b";
344         bogo_args[3] = NULL;
345         
346         if (!config.process_emails) {
347                 return FALSE;
348         }
349         
350         if (msglist == NULL && msginfo != NULL) {
351                 g_warning("wrong call to bogofilter mail_filtering_hook");
352                 return FALSE;
353         }
354         
355         total = g_slist_length(msglist);
356         
357         /* we have to make sure the mails are cached - or it'll break on IMAP */
358         if (message_callback != NULL)
359                 message_callback(_("Bogofilter: fetching bodies..."), total, 0, FALSE);
360         for (cur = msglist; cur; cur = cur->next) {
361                 gchar *file = procmsg_get_message_file((MsgInfo *)cur->data);
362                 if (file == NULL)
363                         ok_to_thread = FALSE;
364                 if (message_callback != NULL)
365                         message_callback(NULL, total, curnum++, FALSE);
366                 g_free(file);
367         }
368         if (message_callback != NULL)
369                 message_callback(NULL, 0, 0, FALSE);
370
371         if (message_callback != NULL)
372                 message_callback(_("Bogofilter: filtering messages..."), total, 0, FALSE);
373
374 #ifdef USE_PTHREAD
375         while (pthread_mutex_trylock(&list_mutex) != 0) {
376                 GTK_EVENTS_FLUSH();
377                 usleep(100);
378         }
379 #endif
380         to_filter_data = g_new0(BogoFilterData, 1);
381         to_filter_data->msglist = msglist;
382         to_filter_data->mail_filtering_data = mail_filtering_data;
383         to_filter_data->spams_to_receive = NULL;
384         to_filter_data->new_hams = NULL;
385         to_filter_data->new_spams = NULL;
386         to_filter_data->done = FALSE;
387         to_filter_data->status = -1;
388         to_filter_data->bogo_args = bogo_args;
389 #ifdef USE_PTHREAD
390         to_filter_data->in_thread = (filter_th != 0 && ok_to_thread);
391 #else
392         to_filter_data->in_thread = FALSE;
393 #endif
394
395 #ifdef USE_PTHREAD
396         pthread_mutex_unlock(&list_mutex);
397         
398         if (filter_th != 0 && ok_to_thread) {
399                 debug_print("waking thread to let it filter things\n");
400                 pthread_mutex_lock(&wait_mutex);
401                 pthread_cond_broadcast(&wait_cond);
402                 pthread_mutex_unlock(&wait_mutex);
403
404                 while (!to_filter_data->done) {
405                         GTK_EVENTS_FLUSH();
406                         usleep(100);
407                 }
408         }
409
410         while (pthread_mutex_trylock(&list_mutex) != 0) {
411                 GTK_EVENTS_FLUSH();
412                 usleep(100);
413
414         }
415         if (filter_th == 0 || !ok_to_thread)
416                 bogofilter_do_filter(to_filter_data);
417 #else
418         bogofilter_do_filter(to_filter_data);   
419 #endif
420
421         spams_to_receive = to_filter_data->spams_to_receive;
422         new_hams = to_filter_data->new_hams;
423         new_spams = to_filter_data->new_spams;
424         status = to_filter_data->status;
425         g_free(to_filter_data);
426         to_filter_data = NULL;
427 #ifdef USE_PTHREAD
428         pthread_mutex_unlock(&list_mutex);
429 #endif
430
431
432         /* flag hams */
433         for (cur = new_hams; cur; cur = cur->next) {
434                 MsgInfo *msginfo = (MsgInfo *)cur->data;
435                 procmsg_msginfo_unset_flags(msginfo, MSG_SPAM, 0);
436         }
437         g_slist_free(new_hams);
438         /* flag spams */
439         for (cur = new_spams; cur; cur = cur->next) {
440                 MsgInfo *msginfo = (MsgInfo *)cur->data;
441                 if (config.receive_spam) {
442                         procmsg_msginfo_change_flags(msginfo, MSG_SPAM, 0, ~0, 0);
443                 } else {
444                         folder_item_remove_msg(msginfo->folder, msginfo->msgnum);
445                 }
446         }
447         g_slist_free(new_spams);
448         
449         if (status < 0 || status > 2) { /* I/O or other errors */
450                 gchar *msg = NULL;
451                 
452                 if (status == 3)
453                         msg =  g_strdup_printf(_("The Bogofilter plugin couldn't filter "
454                                            "a message. The probable cause of the "
455                                            "error is that it didn't learn from any mail.\n"
456                                            "Use \"/Mark/Mark as spam\" and \"/Mark/Mark as "
457                                            "ham\" to train Bogofilter with a few hundred "
458                                            "spam and ham messages."));
459                 else
460                         msg =  g_strdup_printf(_("The Bogofilter plugin couldn't filter "
461                                            "a message. the command `%s %s %s` couldn't be run."), 
462                                            bogo_args[0], bogo_args[1], bogo_args[2]);
463                 if (!prefs_common.no_recv_err_panel) {
464                         if (!warned_error) {
465                                 alertpanel_error(msg);
466                         }
467                         warned_error = TRUE;
468                 } else {
469                         gchar *tmp = g_strdup_printf("%s\n", msg);
470                         log_error(tmp);
471                         g_free(tmp);
472                 }
473                 g_free(msg);
474         }
475         if (status < 0 || status > 2) {
476                 g_slist_free(mail_filtering_data->filtered);
477                 g_slist_free(mail_filtering_data->unfiltered);
478                 g_slist_free(spams_to_receive);
479                 mail_filtering_data->filtered = NULL;
480                 mail_filtering_data->unfiltered = NULL;
481         } else if (config.receive_spam && spams_to_receive) {
482                 FolderItem *save_folder;
483
484                 if ((!config.save_folder) ||
485                     (config.save_folder[0] == '\0') ||
486                     ((save_folder = folder_find_item_from_identifier(config.save_folder)) == NULL))
487                         save_folder = folder_get_default_trash();
488                 if (save_folder) {
489                         for (cur = spams_to_receive; cur; cur = cur->next) {
490                                 msginfo = (MsgInfo *)cur->data;
491                                 msginfo->is_move = TRUE;
492                                 msginfo->to_filter_folder = save_folder;
493                         }
494                 }
495         } 
496
497         if (message_callback != NULL)
498                 message_callback(NULL, 0, 0, FALSE);
499         mail_filtering_data->filtered = g_slist_reverse(
500                 mail_filtering_data->filtered);
501         mail_filtering_data->unfiltered = g_slist_reverse(
502                 mail_filtering_data->unfiltered);
503         
504         return FALSE;
505 }
506
507 BogofilterConfig *bogofilter_get_config(void)
508 {
509         return &config;
510 }
511
512 int bogofilter_learn(MsgInfo *msginfo, GSList *msglist, gboolean spam)
513 {
514         gchar *cmd = NULL;
515         gchar *file = NULL;
516         const gchar *bogo_exec = (config.bogopath && *config.bogopath) ? config.bogopath:"bogofilter";
517         gint status = 0;
518         if (msginfo == NULL && msglist == NULL) {
519                 return -1;
520         }
521
522         if (msginfo) {
523                 file = procmsg_get_message_file(msginfo);
524                 if (file == NULL) {
525                         return -1;
526                 } else {
527                         if (message_callback != NULL)
528                                 message_callback(_("Bogofilter: learning from message..."), 0, 0, FALSE);
529                         if (spam)
530                                 /* learn as spam */
531                                 cmd = g_strdup_printf("%s -s -I '%s'", bogo_exec, file);
532                         else if (MSG_IS_SPAM(msginfo->flags))
533                                 /* correct bogofilter, this wasn't spam */
534                                 cmd = g_strdup_printf("%s -Sn -I '%s'", bogo_exec, file);
535                         else 
536                                 /* learn as ham */
537                                 cmd = g_strdup_printf("%s -n -I '%s'", bogo_exec, file);
538                         if ((status = execute_command_line(cmd, FALSE)) != 0)
539                                 log_error(_("Learning failed; `%s` returned with status %d."),
540                                                 cmd, status);
541                         g_free(cmd);
542                         g_free(file);
543                         if (message_callback != NULL)
544                                 message_callback(NULL, 0, 0, FALSE);
545                         return 0;
546                 }
547         }
548         if (msglist) {
549                 GSList *cur = msglist;
550                 MsgInfo *info;
551                 int total = g_slist_length(msglist);
552                 int done = 0;
553                 gboolean some_correction = FALSE, some_no_correction = FALSE;
554         
555                 if (message_callback != NULL)
556                         message_callback(_("Bogofilter: learning from messages..."), total, 0, FALSE);
557                 
558                 for (cur = msglist; cur && status == 0; cur = cur->next) {
559                         info = (MsgInfo *)cur->data;
560                         if (spam)
561                                 some_no_correction = TRUE;
562                         else if (MSG_IS_SPAM(info->flags))
563                                 /* correct bogofilter, this wasn't spam */
564                                 some_correction = TRUE;
565                         else 
566                                 some_no_correction = TRUE;
567                         
568                 }
569                 
570                 if (some_correction && some_no_correction) {
571                         /* we potentially have to do different stuff for every mail */
572                         for (cur = msglist; cur && status == 0; cur = cur->next) {
573                                 info = (MsgInfo *)cur->data;
574                                 file = procmsg_get_message_file(info);
575
576                                 if (spam)
577                                         /* learn as spam */
578                                         cmd = g_strdup_printf("%s -s -I '%s'", bogo_exec, file);
579                                 else if (MSG_IS_SPAM(info->flags))
580                                         /* correct bogofilter, this wasn't spam */
581                                         cmd = g_strdup_printf("%s -Sn -I '%s'", bogo_exec, file);
582                                 else 
583                                         /* learn as ham */
584                                         cmd = g_strdup_printf("%s -n -I '%s'", bogo_exec, file);
585
586                                 if ((status = execute_command_line(cmd, FALSE)) != 0)
587                                         log_error(_("Learning failed; `%s` returned with status %d."),
588                                                         cmd, status);
589
590                                 g_free(cmd);
591                                 g_free(file);
592                                 done++;
593                                 if (message_callback != NULL)
594                                         message_callback(NULL, total, done, FALSE);
595                         }
596                 } else if (some_correction || some_no_correction) {
597                         cur = msglist;
598                         
599                         gchar *bogo_args[4];
600                         GPid bogo_pid;
601                         gint bogo_stdin;
602                         GError *error = NULL;
603                         gboolean bogo_forked;
604
605                         bogo_args[0] = (gchar *)bogo_exec;
606                         if (some_correction && !some_no_correction)
607                                 bogo_args[1] = "-Sn";
608                         else if (some_no_correction && !some_correction)
609                                 bogo_args[1] = spam ? "-s":"-n";
610                         bogo_args[2] = "-b";
611                         bogo_args[3] = NULL;
612
613                         bogo_forked = g_spawn_async_with_pipes(
614                                         NULL, bogo_args,NULL, G_SPAWN_SEARCH_PATH|G_SPAWN_DO_NOT_REAP_CHILD,
615                                         NULL, NULL, &bogo_pid, &bogo_stdin,
616                                         NULL, NULL, &error);
617
618                         while (bogo_forked && cur) {
619                                 gchar *tmp = NULL;
620                                 info = (MsgInfo *)cur->data;
621                                 file = procmsg_get_message_file(info);
622                                 if (file) {
623                                         tmp = g_strdup_printf("%s\n", 
624                                                 file);
625                                         write_all(bogo_stdin, tmp, strlen(tmp));
626                                         g_free(tmp);
627                                 }
628                                 g_free(file);
629                                 done++;
630                                 if (message_callback != NULL)
631                                         message_callback(NULL, total, done, FALSE);
632                                 cur = cur->next;
633                         }
634                         if (bogo_forked) {
635                                 close(bogo_stdin);
636                                 waitpid(bogo_pid, &status, 0);
637                                 if (!WIFEXITED(status))
638                                         status = -1;
639                                 else
640                                         status = WEXITSTATUS(status);
641                         }
642                         if (!bogo_forked || status != 0) {
643                                 log_error(_("Learning failed; `%s %s %s` returned with error:\n%s"),
644                                                 bogo_args[0], bogo_args[1], bogo_args[2], 
645                                                 error ? error->message:_("Unknown error"));
646                                 if (error)
647                                         g_error_free(error);
648                         }
649
650                 }
651
652                 if (message_callback != NULL)
653                         message_callback(NULL, 0, 0, FALSE);
654                 return 0;
655         }
656         return -1;
657 }
658
659 void bogofilter_save_config(void)
660 {
661         PrefFile *pfile;
662         gchar *rcpath;
663
664         debug_print("Saving Bogofilter Page\n");
665
666         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
667         pfile = prefs_write_open(rcpath);
668         g_free(rcpath);
669         if (!pfile || (prefs_set_block_label(pfile, "Bogofilter") < 0))
670                 return;
671
672         if (prefs_write_param(param, pfile->fp) < 0) {
673                 g_warning("Failed to write Bogofilter configuration to file\n");
674                 prefs_file_close_revert(pfile);
675                 return;
676         }
677         fprintf(pfile->fp, "\n");
678
679         prefs_file_close(pfile);
680 }
681
682 void bogofilter_set_message_callback(MessageCallback callback)
683 {
684         message_callback = callback;
685 }
686
687 gint plugin_init(gchar **error)
688 {
689         gchar *rcpath;
690
691         hook_id = -1;
692
693         if ((claws_get_version() > VERSION_NUMERIC)) {
694                 *error = g_strdup(_("Your version of Claws Mail is newer than the version the Bogofilter plugin was built with"));
695                 return -1;
696         }
697
698         if ((claws_get_version() < MAKE_NUMERIC_VERSION(0, 9, 3, 86))) {
699                 *error = g_strdup(_("Your version of Claws Mail is too old for the Bogofilter plugin"));
700                 return -1;
701         }
702
703         prefs_set_default(param);
704         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
705         prefs_read_config(param, "Bogofilter", rcpath, NULL);
706         g_free(rcpath);
707
708         bogofilter_gtk_init();
709                 
710         debug_print("Bogofilter plugin loaded\n");
711
712 #ifdef USE_PTHREAD
713         bogofilter_start_thread();
714 #endif
715
716         if (config.process_emails) {
717                 bogofilter_register_hook();
718         }
719
720         procmsg_register_spam_learner(bogofilter_learn);
721         procmsg_spam_set_folder(config.save_folder);
722
723         return 0;
724         
725 }
726
727 void plugin_done(void)
728 {
729         if (hook_id != -1) {
730                 bogofilter_unregister_hook();
731         }
732 #ifdef USE_PTHREAD
733         bogofilter_stop_thread();
734 #endif
735         g_free(config.save_folder);
736         bogofilter_gtk_done();
737         procmsg_unregister_spam_learner(bogofilter_learn);
738         procmsg_spam_set_folder(NULL);
739         debug_print("Bogofilter plugin unloaded\n");
740 }
741
742 const gchar *plugin_name(void)
743 {
744         return _("Bogofilter");
745 }
746
747 const gchar *plugin_desc(void)
748 {
749         return _("This plugin can check all messages that are received from an "
750                  "IMAP, LOCAL or POP account for spam using Bogofilter. "
751                  "You will need Bogofilter installed locally.\n "
752                  "\n"
753                  "Before Bogofilter can recognize spam messages, you have to "
754                  "train it by marking a few hundred spam and ham messages. "
755                  "Use \"/Mark/Mark as spam\" and \"/Mark/Mark as ham\" to "
756                  "train Bogofilter.\n"
757                  "\n"
758                  "When a message is identified as spam it can be deleted or "
759                  "saved in a specially designated folder.\n"
760                  "\n"
761                  "Options can be found in /Configuration/Preferences/Plugins/Bogofilter");
762 }
763
764 const gchar *plugin_type(void)
765 {
766         return "GTK2";
767 }
768
769 const gchar *plugin_licence(void)
770 {
771         return "GPL";
772 }
773
774 const gchar *plugin_version(void)
775 {
776         return VERSION;
777 }
778
779 struct PluginFeature *plugin_provides(void)
780 {
781         static struct PluginFeature features[] = 
782                 { {PLUGIN_FILTERING, N_("Spam detection")},
783                   {PLUGIN_FILTERING, N_("Spam learning")},
784                   {PLUGIN_NOTHING, NULL}};
785         return features;
786 }
787
788 void bogofilter_register_hook(void)
789 {
790         if (hook_id == -1)
791                 hook_id = hooks_register_hook(MAIL_LISTFILTERING_HOOKLIST, mail_filtering_hook, NULL);
792         if (hook_id == -1) {
793                 g_warning("Failed to register mail filtering hook");
794                 config.process_emails = FALSE;
795         }
796 }
797
798 void bogofilter_unregister_hook(void)
799 {
800         if (hook_id != -1) {
801                 hooks_unregister_hook(MAIL_LISTFILTERING_HOOKLIST, hook_id);
802         }
803         hook_id = -1;
804 }