2006-08-28 [paul] 2.4.0cvs103
[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 Sylpheed-Claws 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
29 #include <glib.h>
30 #include <glib/gi18n.h>
31
32 #if HAVE_LOCALE_H
33 #  include <locale.h>
34 #endif
35
36 #include "common/sylpheed.h"
37 #include "common/version.h"
38 #include "plugin.h"
39 #include "common/utils.h"
40 #include "hooks.h"
41 #include "procmsg.h"
42 #include "folder.h"
43 #include "prefs.h"
44 #include "prefs_gtk.h"
45
46 #include "bogofilter.h"
47 #include "inc.h"
48 #include "log.h"
49 #include "prefs_common.h"
50 #include "alertpanel.h"
51
52 #ifdef HAVE_SYSEXITS_H
53 #include <sysexits.h>
54 #endif
55 #ifdef HAVE_ERRNO_H
56 #include <errno.h>
57 #endif
58 #ifdef HAVE_SYS_ERRNO_H
59 #include <sys/errno.h>
60 #endif
61 #ifdef HAVE_TIME_H
62 #include <time.h>
63 #endif
64 #ifdef HAVE_SYS_TIME_H
65 #include <sys/time.h>
66 #endif
67 #ifdef HAVE_SIGNAL_H
68 #include <signal.h>
69 #endif
70 #ifdef HAVE_PWD_H
71 #include <pwd.h>
72 #endif
73
74 enum {
75     CHILD_RUNNING = 1 << 0,
76     TIMEOUT_RUNNING = 1 << 1,
77 };
78
79 static guint hook_id = -1;
80 static MessageCallback message_callback;
81
82 static BogofilterConfig config;
83
84 static PrefParam param[] = {
85         {"process_emails", "TRUE", &config.process_emails, P_BOOL,
86          NULL, NULL, NULL},
87         {"receive_spam", "TRUE", &config.receive_spam, P_BOOL,
88          NULL, NULL, NULL},
89         {"save_folder", NULL, &config.save_folder, P_STRING,
90          NULL, NULL, NULL},
91         {"max_size", "250", &config.max_size, P_INT,
92          NULL, NULL, NULL},
93         {"bogopath", "bogofilter", &config.bogopath, P_STRING,
94          NULL, NULL, NULL},
95
96         {NULL, NULL, NULL, P_OTHER, NULL, NULL, NULL}
97 };
98
99 static gboolean mail_filtering_hook(gpointer source, gpointer data)
100 {
101         MailFilteringData *mail_filtering_data = (MailFilteringData *) source;
102         MsgInfo *msginfo = mail_filtering_data->msginfo;
103         gboolean is_spam = FALSE;
104         static gboolean warned_error = FALSE;
105         gchar *file = NULL, *cmd = NULL;
106         int status = 3;
107         gchar *bogo_exec = (config.bogopath && *config.bogopath) ? config.bogopath:"bogofilter";
108
109         if (!config.process_emails) {
110                 return FALSE;
111         }
112         debug_print("Filtering message %d\n", msginfo->msgnum);
113         if (message_callback != NULL)
114                 message_callback(_("Bogofilter: filtering message..."), 0, 0);
115
116         file = procmsg_get_message_file(msginfo);
117
118         if (file)
119                 cmd = g_strdup_printf("%s -I %s", bogo_exec, file);
120         
121         if (cmd)
122                 status = system(cmd);
123         
124         if (status == -1)
125                 status = 3;
126         else 
127                 status = WEXITSTATUS(status);
128
129         g_free(cmd);
130         g_free(file);
131         debug_print("bogofilter status %d\n", status);
132         is_spam = (status == 0);
133         
134         if (is_spam) {
135                 debug_print("message is spam\n");
136                 procmsg_msginfo_set_flags(msginfo, MSG_SPAM, 0);
137                 if (config.receive_spam) {
138                         FolderItem *save_folder;
139
140                         if ((!config.save_folder) ||
141                             (config.save_folder[0] == '\0') ||
142                             ((save_folder = folder_find_item_from_identifier(config.save_folder)) == NULL))
143                                 save_folder = folder_get_default_trash();
144
145                         procmsg_msginfo_unset_flags(msginfo, ~0, 0);
146                         procmsg_msginfo_set_flags(msginfo, MSG_SPAM, 0);
147                         folder_item_move_msg(save_folder, msginfo);
148                 } else {
149                         folder_item_remove_msg(msginfo->folder, msginfo->msgnum);
150                 }
151
152                 return TRUE;
153         } else {
154                 debug_print("message is ham\n");
155                 procmsg_msginfo_unset_flags(msginfo, MSG_SPAM, 0);
156         }
157         
158         if (status == 3) { /* I/O or other errors */
159                 if (!warned_error) {
160                         alertpanel_error(_("The Bogofilter plugin couldn't filter "
161                                            "a message. The probable cause of the "
162                                            "error is that it didn't learn from any mail.\n"
163                                            "Use \"/Mark/Mark as spam\" and \"/Mark/Mark as "
164                                            "ham\" to train Bogofilter with a few hundred "
165                                            "spam and ham messages."));
166                 }
167                 warned_error = TRUE;
168         }
169         
170         return FALSE;
171 }
172
173 BogofilterConfig *bogofilter_get_config(void)
174 {
175         return &config;
176 }
177
178 int bogofilter_learn(MsgInfo *msginfo, GSList *msglist, gboolean spam)
179 {
180         gchar *cmd = NULL;
181         gchar *file = NULL;
182         const gchar *bogo_exec = (config.bogopath && *config.bogopath) ? config.bogopath:"bogofilter";
183         gint status = 0;
184         if (msginfo == NULL && msglist == NULL) {
185                 return -1;
186         }
187
188         if (msginfo) {
189                 file = procmsg_get_message_file(msginfo);
190                 if (file == NULL) {
191                         return -1;
192                 } else {
193                         if (message_callback != NULL)
194                                 message_callback(_("Bogofilter: learning from message..."), 0, 0);
195                         if (spam)
196                                 /* learn as spam */
197                                 cmd = g_strdup_printf("%s -s -I '%s'", bogo_exec, file);
198                         else if (MSG_IS_SPAM(msginfo->flags))
199                                 /* correct bogofilter, this wasn't spam */
200                                 cmd = g_strdup_printf("%s -Sn -I '%s'", bogo_exec, file);
201                         else 
202                                 /* learn as ham */
203                                 cmd = g_strdup_printf("%s -n -I '%s'", bogo_exec, file);
204                         if ((status = execute_command_line(cmd, FALSE)) != 0)
205                                 alertpanel_error(_("Learning failed; `%s` returned with status %d."),
206                                                 cmd, status);
207                         g_free(cmd);
208                         g_free(file);
209                         if (message_callback != NULL)
210                                 message_callback(NULL, 0, 0);
211                         return 0;
212                 }
213         }
214         if (msglist) {
215                 GSList *cur = msglist;
216                 MsgInfo *info;
217                 int total = g_slist_length(msglist);
218                 int done = 0;
219                 if (message_callback != NULL)
220                         message_callback(_("Bogofilter: learning from messages..."), total, 0);
221                 
222                 for (; cur && status == 0; cur = cur->next) {
223                         info = (MsgInfo *)cur->data;
224                         file = procmsg_get_message_file(info);
225
226                         if (spam)
227                                 /* learn as spam */
228                                 cmd = g_strdup_printf("%s -s -I '%s'", bogo_exec, file);
229                         else if (MSG_IS_SPAM(info->flags))
230                                 /* correct bogofilter, this wasn't spam */
231                                 cmd = g_strdup_printf("%s -Sn -I '%s'", bogo_exec, file);
232                         else 
233                                 /* learn as ham */
234                                 cmd = g_strdup_printf("%s -n -I '%s'", bogo_exec, file);
235         
236                         if ((status = execute_command_line(cmd, FALSE)) != 0)
237                                 alertpanel_error(_("Learning failed; `%s` returned with status %d."),
238                                                 cmd, status);
239
240                         g_free(cmd);
241                         g_free(file);
242                         done++;
243                         if (message_callback != NULL)
244                                 message_callback(NULL, total, done);
245                 }
246                 if (message_callback != NULL)
247                         message_callback(NULL, 0, 0);
248                 return 0;
249         }
250         return -1;
251 }
252
253 void bogofilter_save_config(void)
254 {
255         PrefFile *pfile;
256         gchar *rcpath;
257
258         debug_print("Saving Bogofilter Page\n");
259
260         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
261         pfile = prefs_write_open(rcpath);
262         g_free(rcpath);
263         if (!pfile || (prefs_set_block_label(pfile, "Bogofilter") < 0))
264                 return;
265
266         if (prefs_write_param(param, pfile->fp) < 0) {
267                 g_warning("Failed to write Bogofilter configuration to file\n");
268                 prefs_file_close_revert(pfile);
269                 return;
270         }
271         fprintf(pfile->fp, "\n");
272
273         prefs_file_close(pfile);
274 }
275
276 void bogofilter_set_message_callback(MessageCallback callback)
277 {
278         message_callback = callback;
279 }
280
281 gint plugin_init(gchar **error)
282 {
283         gchar *rcpath;
284
285         hook_id = -1;
286
287         if ((sylpheed_get_version() > VERSION_NUMERIC)) {
288                 *error = g_strdup("Your version of Sylpheed-Claws is newer than the version the Bogofilter plugin was built with");
289                 return -1;
290         }
291
292         if ((sylpheed_get_version() < MAKE_NUMERIC_VERSION(0, 9, 3, 86))) {
293                 *error = g_strdup("Your version of Sylpheed-Claws is too old for the Bogofilter plugin");
294                 return -1;
295         }
296
297         prefs_set_default(param);
298         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
299         prefs_read_config(param, "Bogofilter", rcpath, NULL);
300         g_free(rcpath);
301
302         bogofilter_gtk_init();
303                 
304         debug_print("Bogofilter plugin loaded\n");
305
306         if (config.process_emails) {
307                 bogofilter_register_hook();
308         }
309
310         procmsg_register_spam_learner(bogofilter_learn);
311         procmsg_spam_set_folder(config.save_folder);
312
313         return 0;
314         
315 }
316
317 void plugin_done(void)
318 {
319         if (hook_id != -1) {
320                 bogofilter_unregister_hook();
321         }
322         g_free(config.save_folder);
323         bogofilter_gtk_done();
324         procmsg_unregister_spam_learner(bogofilter_learn);
325         procmsg_spam_set_folder(NULL);
326         debug_print("Bogofilter plugin unloaded\n");
327 }
328
329 const gchar *plugin_name(void)
330 {
331         return _("Bogofilter");
332 }
333
334 const gchar *plugin_desc(void)
335 {
336         return _("This plugin can check all messages that are received from an "
337                  "IMAP, LOCAL or POP account for spam using Bogofilter. "
338                  "You will need Bogofilter installed locally.\n "
339                  "\n"
340                  "Before Bogofilter can recognize spam messages, you have to "
341                  "train it by marking a few hundred spam and ham messages. "
342                  "Use \"/Mark/Mark as Spam\" and \"/Mark/Mark as ham\" to "
343                  "train Bogofilter.\n"
344                  "\n"
345                  "When a message is identified as spam it can be deleted or "
346                  "saved in a specially designated folder.\n"
347                  "\n"
348                  "Options can be found in /Configuration/Preferences/Plugins/Bogofilter");
349 }
350
351 const gchar *plugin_type(void)
352 {
353         return "GTK2";
354 }
355
356 const gchar *plugin_licence(void)
357 {
358         return "GPL";
359 }
360
361 const gchar *plugin_version(void)
362 {
363         return VERSION;
364 }
365
366 struct PluginFeature *plugin_provides(void)
367 {
368         static struct PluginFeature features[] = 
369                 { {PLUGIN_FILTERING, N_("Spam detection")},
370                   {PLUGIN_FILTERING, N_("Spam learning")},
371                   {PLUGIN_NOTHING, NULL}};
372         return features;
373 }
374
375 void bogofilter_register_hook(void)
376 {
377         hook_id = hooks_register_hook(MAIL_FILTERING_HOOKLIST, mail_filtering_hook, NULL);
378         if (hook_id == -1) {
379                 g_warning("Failed to register mail filtering hook");
380                 config.process_emails = FALSE;
381         }
382 }
383
384 void bogofilter_unregister_hook(void)
385 {
386         if (hook_id != -1) {
387                 hooks_unregister_hook(MAIL_FILTERING_HOOKLIST, hook_id);
388         }
389 }