2008-05-07 [colin] 3.4.0cvs29
[claws.git] / src / plugins / spamassassin / spamassassin.c
1 /*
2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2007 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 3 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
17  * 
18  */
19
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/claws.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 "libspamc.h"
47 #include "spamassassin.h"
48 #include "inc.h"
49 #include "log.h"
50 #include "prefs_common.h"
51 #include "alertpanel.h"
52 #include "addr_compl.h"
53
54 #ifdef HAVE_SYSEXITS_H
55 #include <sysexits.h>
56 #endif
57 #ifdef HAVE_ERRNO_H
58 #include <errno.h>
59 #endif
60 #ifdef HAVE_SYS_ERRNO_H
61 #include <sys/errno.h>
62 #endif
63 #ifdef HAVE_TIME_H
64 #include <time.h>
65 #endif
66 #ifdef HAVE_SYS_TIME_H
67 #include <sys/time.h>
68 #endif
69 #ifdef HAVE_SIGNAL_H
70 #include <signal.h>
71 #endif
72 #ifdef HAVE_PWD_H
73 #include <pwd.h>
74 #endif
75
76 #define PLUGIN_NAME (_("SpamAssassin"))
77
78 enum {
79     CHILD_RUNNING = 1 << 0,
80     TIMEOUT_RUNNING = 1 << 1,
81 };
82
83 static guint hook_id = -1;
84 static int flags = SPAMC_RAW_MODE | SPAMC_SAFE_FALLBACK | SPAMC_CHECK_ONLY;
85 static MessageCallback message_callback;
86
87 static SpamAssassinConfig config;
88
89 static PrefParam param[] = {
90         {"enable", "FALSE", &config.enable, P_BOOL,
91         NULL, NULL, NULL},
92         {"transport", "0", &config.transport, P_INT,
93          NULL, NULL, NULL},
94         {"hostname", "localhost", &config.hostname, P_STRING,
95          NULL, NULL, NULL},
96         {"port", "783", &config.port, P_INT,
97          NULL, NULL, NULL},
98         {"socket", "", &config.socket, P_STRING,
99          NULL, NULL, NULL},
100         {"process_emails", "TRUE", &config.process_emails, P_BOOL,
101          NULL, NULL, NULL},
102         {"receive_spam", "TRUE", &config.receive_spam, P_BOOL,
103          NULL, NULL, NULL},
104         {"save_folder", NULL, &config.save_folder, P_STRING,
105          NULL, NULL, NULL},
106         {"max_size", "250", &config.max_size, P_INT,
107          NULL, NULL, NULL},
108         {"timeout", "30", &config.timeout, P_INT,
109          NULL, NULL, NULL},
110         {"username", "", &config.username, P_STRING,
111          NULL, NULL, NULL},
112         {"mark_as_read", "TRUE", &config.mark_as_read, P_BOOL,
113          NULL, NULL, NULL},
114         {"whitelist_ab", "FALSE", &config.whitelist_ab, P_BOOL,
115          NULL, NULL, NULL},
116         {"whitelist_ab_folder", N_("Any"), &config.whitelist_ab_folder, P_STRING,
117          NULL, NULL, NULL},
118
119         {NULL, NULL, NULL, P_OTHER, NULL, NULL, NULL}
120 };
121
122 gboolean timeout_func(gpointer data)
123 {
124         gint *running = (gint *) data;
125
126         if (*running & CHILD_RUNNING)
127                 return TRUE;
128
129         *running &= ~TIMEOUT_RUNNING;
130         return FALSE;
131 }
132
133 typedef enum {
134         MSG_IS_HAM = 0,
135         MSG_IS_SPAM = 1,
136         MSG_FILTERING_ERROR = 2
137 } MsgStatus;
138
139 static MsgStatus msg_is_spam(FILE *fp)
140 {
141         struct transport trans;
142         struct message m;
143         gboolean is_spam = FALSE;
144
145         if (!config.enable)
146                 return MSG_IS_HAM;
147
148         transport_init(&trans);
149         switch (config.transport) {
150         case SPAMASSASSIN_TRANSPORT_LOCALHOST:
151                 trans.type = TRANSPORT_LOCALHOST;
152                 trans.port = config.port;
153                 break;
154         case SPAMASSASSIN_TRANSPORT_TCP:
155                 trans.type = TRANSPORT_TCP;
156                 trans.hostname = config.hostname;
157                 trans.port = config.port;
158                 break;
159         case SPAMASSASSIN_TRANSPORT_UNIX:
160                 trans.type = TRANSPORT_UNIX;
161                 trans.socketpath = config.socket;
162                 break;
163         default:
164                 return MSG_IS_HAM;
165         }
166
167         if (transport_setup(&trans, flags) != EX_OK) {
168                 log_error(LOG_PROTOCOL, _("SpamAssassin plugin couldn't connect to spamd.\n"));
169                 debug_print("failed to setup transport\n");
170                 return MSG_FILTERING_ERROR;
171         }
172
173         m.type = MESSAGE_NONE;
174         m.max_len = config.max_size * 1024;
175         m.timeout = config.timeout;
176
177         if (message_read(fileno(fp), flags, &m) != EX_OK) {
178                 debug_print("failed to read message\n");
179                 message_cleanup(&m);
180                 return MSG_FILTERING_ERROR;
181         }
182
183         if (message_filter(&trans, config.username, flags, &m) != EX_OK) {
184                 log_error(LOG_PROTOCOL, _("SpamAssassin plugin filtering failed.\n"));
185                 debug_print("filtering the message failed\n");
186                 message_cleanup(&m);
187                 return MSG_FILTERING_ERROR;
188         }
189
190         if (m.is_spam == EX_ISSPAM)
191                 is_spam = TRUE;
192
193         message_cleanup(&m);
194
195         return is_spam ? MSG_IS_SPAM:MSG_IS_HAM;
196 }
197
198 static gboolean sa_found_in_addressbook(const gchar *address)
199 {
200         gchar *addr = NULL;
201         gboolean found = FALSE;
202         gint num_addr = 0;
203         
204         if (!address)
205                 return FALSE;
206         
207         addr = g_strdup(address);
208         extract_address(addr);
209         num_addr = complete_address(addr);
210         if (num_addr > 1) {
211                 /* skip first item (this is the search string itself) */
212                 int i = 1;
213                 for (; i < num_addr && !found; i++) {
214                         gchar *caddr = get_complete_address(i);
215                         extract_address(caddr);
216                         if (strcasecmp(caddr, addr) == 0)
217                                 found = TRUE;
218                         g_free(caddr);
219                 }
220         }
221         g_free(addr);
222         return found;
223 }
224
225 static gboolean mail_filtering_hook(gpointer source, gpointer data)
226 {
227         MailFilteringData *mail_filtering_data = (MailFilteringData *) source;
228         MsgInfo *msginfo = mail_filtering_data->msginfo;
229         gboolean is_spam = FALSE, error = FALSE;
230         static gboolean warned_error = FALSE;
231         FILE *fp = NULL;
232         int pid = 0;
233         int status;
234
235         /* SPAMASSASSIN_DISABLED : keep test for compatibility purpose */
236         if (!config.enable || config.transport == SPAMASSASSIN_DISABLED) {
237                 log_warning(LOG_PROTOCOL, _("SpamAssassin plugin is disabled by its preferences.\n"));
238                 return FALSE;
239         }
240         debug_print("Filtering message %d\n", msginfo->msgnum);
241         if (message_callback != NULL)
242                 message_callback(_("SpamAssassin: filtering message..."));
243
244         if ((fp = procmsg_open_message(msginfo)) == NULL) {
245                 debug_print("failed to open message file\n");
246                 return FALSE;
247         }
248
249         if (config.whitelist_ab) {
250                 gchar *ab_folderpath;
251                 gboolean whitelisted = FALSE;
252
253                 if (*config.whitelist_ab_folder == '\0' ||
254                         strcasecmp(config.whitelist_ab_folder, _("Any")) == 0) {
255                         /* match the whole addressbook */
256                         ab_folderpath = NULL;
257                 } else {
258                         /* match the specific book/folder of the addressbook */
259                         ab_folderpath = config.whitelist_ab_folder;
260                 }
261
262                 start_address_completion(ab_folderpath);
263                 if (msginfo->from && 
264                     sa_found_in_addressbook(msginfo->from))
265                                 whitelisted = TRUE;
266                 end_address_completion();
267                 
268                 if (whitelisted) {
269                         debug_print("message is ham (whitelisted)\n");
270                         return FALSE;
271                 }
272         }
273         pid = fork();
274         if (pid == 0) {
275                 _exit(msg_is_spam(fp));
276         } else {
277                 gint running = 0;
278
279                 running |= CHILD_RUNNING;
280
281                 g_timeout_add(50, timeout_func, &running);
282                 running |= TIMEOUT_RUNNING;
283
284                 while(running & CHILD_RUNNING) {
285                         int ret;
286
287                         ret = waitpid(pid, &status, WNOHANG);
288                         if (ret == pid) {
289                                 if (WIFEXITED(status)) {
290                                         MsgStatus result = MSG_IS_HAM;
291                                         running &= ~CHILD_RUNNING;
292                                         result = WEXITSTATUS(status);
293                                         is_spam = (result == MSG_IS_SPAM) ? TRUE : FALSE;
294                                         error = (result == MSG_FILTERING_ERROR);
295                                 }
296                         } if (ret < 0) {
297                                 running &= ~CHILD_RUNNING;
298                         } /* ret == 0 continue */
299             
300                         g_main_iteration(TRUE);
301                 }
302
303                 while (running & TIMEOUT_RUNNING)
304                         g_main_iteration(TRUE);
305         }
306
307         fclose(fp);
308
309         if (is_spam) {
310                 debug_print("message is spam\n");
311                 procmsg_msginfo_set_flags(msginfo, MSG_SPAM, 0);
312                 if (config.receive_spam) {
313                         FolderItem *save_folder = NULL;
314
315                         if ((!config.save_folder) ||
316                             (config.save_folder[0] == '\0') ||
317                             ((save_folder = folder_find_item_from_identifier(config.save_folder)) == NULL)) {
318                                 if (mail_filtering_data->account && mail_filtering_data->account->set_trash_folder) {
319                                         save_folder = folder_find_item_from_identifier(
320                                                 mail_filtering_data->account->trash_folder);
321                                         if (save_folder)
322                                                 debug_print("found trash folder from account's advanced settings\n");
323                                 }
324                                 if (save_folder == NULL && mail_filtering_data->account &&
325                                     mail_filtering_data->account->folder) {
326                                         save_folder = mail_filtering_data->account->folder->trash;
327                                         if (save_folder)
328                                                 debug_print("found trash folder from account's trash\n");
329                                 }
330                                 if (save_folder == NULL && mail_filtering_data->account &&
331                                     !mail_filtering_data->account->folder)  {
332                                         if (mail_filtering_data->account->inbox) {
333                                                 FolderItem *item = folder_find_item_from_identifier(
334                                                         mail_filtering_data->account->inbox);
335                                                 if (item && item->folder->trash) {
336                                                         save_folder = item->folder->trash;
337                                                         debug_print("found trash folder from account's inbox\n");
338                                                 }
339                                         } 
340                                         if (!save_folder && mail_filtering_data->account->local_inbox) {
341                                                 FolderItem *item = folder_find_item_from_identifier(
342                                                         mail_filtering_data->account->local_inbox);
343                                                 if (item && item->folder->trash) {
344                                                         save_folder = item->folder->trash;
345                                                         debug_print("found trash folder from account's local_inbox\n");
346                                                 }
347                                         }
348                                 }
349                                 if (save_folder == NULL) {
350                                         debug_print("using default trash folder\n");
351                                         save_folder = folder_get_default_trash();
352                                 }
353                         }
354                         if (config.mark_as_read)
355                                 procmsg_msginfo_unset_flags(msginfo, ~0, 0);
356                         procmsg_msginfo_set_flags(msginfo, MSG_SPAM, 0);
357                         msginfo->filter_op = IS_MOVE;
358                         msginfo->to_filter_folder = save_folder;
359                 } else {
360                         folder_item_remove_msg(msginfo->folder, msginfo->msgnum);
361                 }
362
363                 return TRUE;
364         } else {
365                 debug_print("message is ham\n");
366                 procmsg_msginfo_unset_flags(msginfo, MSG_SPAM, 0);
367         }
368         
369         if (error) {
370                 gchar *msg = _("The SpamAssassin plugin couldn't filter "
371                                            "a message. The probable cause of the error "
372                                            "is an unreachable spamd daemon. Please make "
373                                            "sure spamd is running and accessible.");
374                 if (!prefs_common.no_recv_err_panel) {
375                         if (!warned_error) {
376                                 alertpanel_error("%s", msg);
377                         }
378                         warned_error = TRUE;
379                 } else {
380                         log_error(LOG_PROTOCOL, "%s\n", msg);
381                 }
382         }
383         
384         return FALSE;
385 }
386
387 SpamAssassinConfig *spamassassin_get_config(void)
388 {
389         return &config;
390 }
391
392 gchar* spamassassin_create_tmp_spamc_wrapper(gboolean spam)
393 {
394         gchar *contents;
395         gchar *fname = get_tmp_file();
396
397         if (fname != NULL) {
398                 contents = g_strdup_printf(
399                                                 "spamc -d %s -p %u -u %s -t %u -s %u -L %s<\"$*\";exit $?",
400                                                 config.hostname, config.port, 
401                                                 config.username, config.timeout,
402                                                 config.max_size * 1024, spam?"spam":"ham");
403                 if (str_write_to_file(contents, fname) < 0) {
404                         g_free(fname);
405                         fname = NULL;
406                 }
407                 g_free(contents);
408         }
409         /* returned pointer must be free'ed by caller */
410         return fname;
411 }
412
413 int spamassassin_learn(MsgInfo *msginfo, GSList *msglist, gboolean spam)
414 {
415         gchar *cmd = NULL;
416         gchar *file = NULL;
417         const gchar *shell = g_getenv("SHELL");
418         gchar *spamc_wrapper = NULL;
419
420         if (msginfo == NULL && msglist == NULL) {
421                 return -1;
422         }
423
424         if (config.transport == SPAMASSASSIN_TRANSPORT_TCP
425         &&  prefs_common.work_offline
426         &&  !inc_offline_should_override(TRUE,
427                 _("Claws Mail needs network access in order "
428                   "to feed this mail(s) to the remote learner."))) {
429                 return -1;
430         }
431
432         if (msginfo) {
433                 file = procmsg_get_message_file(msginfo);
434                 if (file == NULL) {
435                         return -1;
436                 }
437                 if (config.transport == SPAMASSASSIN_TRANSPORT_TCP) {
438                         spamc_wrapper = spamassassin_create_tmp_spamc_wrapper(spam);
439                         if (spamc_wrapper != NULL) {
440                                 cmd = g_strconcat(shell?shell:"sh", " ",
441                                                                 spamc_wrapper, " ", file, NULL);
442                         }
443                 } else {
444                         cmd = g_strdup_printf("sa-learn -u %s %s %s %s",
445                                                         config.username,
446                                                         prefs_common.work_offline?"-L":"",
447                                                         spam?"--spam":"--ham", file);
448                 }
449         }
450         if (msglist) {
451                 GSList *cur = msglist;
452                 MsgInfo *info;
453
454                 if (config.transport == SPAMASSASSIN_TRANSPORT_TCP) {
455                         /* execute n-times the spamc command */
456                         for (; cur; cur = cur->next) {
457                                 info = (MsgInfo *)cur->data;
458                                 gchar *tmpcmd = NULL;
459                                 gchar *tmpfile = get_tmp_file();
460
461                                 if (spamc_wrapper == NULL) {
462                                         spamc_wrapper = spamassassin_create_tmp_spamc_wrapper(spam);
463                                 }
464
465                                 if (spamc_wrapper && tmpfile &&
466                                 copy_file(procmsg_get_message_file(info), tmpfile, TRUE) == 0) {
467                                         tmpcmd = g_strconcat(shell?shell:"sh", " ", spamc_wrapper, " ",
468                                                                                 tmpfile, NULL);
469                                         debug_print("%s\n", tmpcmd);
470                                         execute_command_line(tmpcmd, FALSE);
471                                         g_free(tmpcmd);
472                                 }
473                                 g_free(tmpfile);
474                         }
475                         g_free(spamc_wrapper);
476                         return 0;
477                 } else {
478                         cmd = g_strdup_printf("sa-learn -u %s %s %s",
479                                         config.username,
480                                         prefs_common.work_offline?"-L":"",
481                                         spam?"--spam":"--ham");
482
483                         /* concatenate all message tmpfiles to the sa-learn command-line */
484                         for (; cur; cur = cur->next) {
485                                 info = (MsgInfo *)cur->data;
486                                 gchar *tmpcmd = NULL;
487                                 gchar *tmpfile = get_tmp_file();
488
489                                 if (tmpfile &&
490                                 copy_file(procmsg_get_message_file(info), tmpfile, TRUE) == 0) {                        
491                                         tmpcmd = g_strconcat(cmd, " ", tmpfile, NULL);
492                                         g_free(cmd);
493                                         cmd = tmpcmd;
494                                 }
495                                 g_free(tmpfile);
496                         }
497                 }
498         }
499         if (cmd == NULL) {
500                 return -1;
501         }
502         debug_print("%s\n", cmd);
503         /* only run sync calls to sa-learn/spamc to prevent system lockdown */
504         execute_command_line(cmd, FALSE);
505         g_free(cmd);
506         g_free(spamc_wrapper);
507
508         return 0;
509 }
510
511 void spamassassin_save_config(void)
512 {
513         PrefFile *pfile;
514         gchar *rcpath;
515
516         debug_print("Saving SpamAssassin Page\n");
517
518         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
519         pfile = prefs_write_open(rcpath);
520         g_free(rcpath);
521         if (!pfile || (prefs_set_block_label(pfile, "SpamAssassin") < 0))
522                 return;
523
524         if (prefs_write_param(param, pfile->fp) < 0) {
525                 g_warning("Failed to write SpamAssassin configuration to file\n");
526                 prefs_file_close_revert(pfile);
527                 return;
528         }
529         if (fprintf(pfile->fp, "\n") < 0) {
530                 FILE_OP_ERROR(rcpath, "fprintf");
531                 prefs_file_close_revert(pfile);
532         } else
533                 prefs_file_close(pfile);
534 }
535
536 gboolean spamassassin_check_username(void)
537 {
538         if (config.username == NULL || config.username[0] == '\0') {
539                 config.username = (gchar*)g_get_user_name();
540                 if (config.username == NULL) {
541                         if (hook_id != -1) {
542                                 spamassassin_unregister_hook();
543                         }
544                         procmsg_unregister_spam_learner(spamassassin_learn);
545                         procmsg_spam_set_folder(NULL, NULL);
546                         return FALSE;
547                 }
548         }
549         return TRUE;
550 }
551
552 void spamassassin_set_message_callback(MessageCallback callback)
553 {
554         message_callback = callback;
555 }
556
557 gint plugin_init(gchar **error)
558 {
559         gchar *rcpath;
560
561         hook_id = -1;
562
563         if (!check_plugin_version(MAKE_NUMERIC_VERSION(2,9,2,72),
564                                 VERSION_NUMERIC, PLUGIN_NAME, error))
565                 return -1;
566
567         prefs_set_default(param);
568         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
569         prefs_read_config(param, "SpamAssassin", rcpath, NULL);
570         g_free(rcpath);
571         if (!spamassassin_check_username()) {
572                 *error = g_strdup(_("Failed to get username"));
573                 return -1;
574         }
575         spamassassin_gtk_init();
576                 
577         debug_print("SpamAssassin plugin loaded\n");
578
579         if (config.process_emails) {
580                 spamassassin_register_hook();
581         }
582
583         if (!config.enable || config.transport == SPAMASSASSIN_DISABLED) {
584                 log_warning(LOG_PROTOCOL, _("SpamAssassin plugin is loaded but disabled by its preferences.\n"));
585         }
586         else {
587                 if (config.transport == SPAMASSASSIN_TRANSPORT_TCP)
588                         debug_print("Enabling learner with a remote spamassassin server requires spamc/spamd 3.1.x\n");
589                 procmsg_register_spam_learner(spamassassin_learn);
590                 procmsg_spam_set_folder(config.save_folder, spamassassin_get_spam_folder);
591         }
592
593         return 0;
594         
595 }
596
597 gboolean plugin_done(void)
598 {
599         if (hook_id != -1) {
600                 spamassassin_unregister_hook();
601         }
602         g_free(config.hostname);
603         g_free(config.save_folder);
604         spamassassin_gtk_done();
605         procmsg_unregister_spam_learner(spamassassin_learn);
606         procmsg_spam_set_folder(NULL, NULL);
607         debug_print("SpamAssassin plugin unloaded\n");
608         return TRUE;
609 }
610
611 const gchar *plugin_name(void)
612 {
613         return PLUGIN_NAME;
614 }
615
616 const gchar *plugin_desc(void)
617 {
618         return _("This plugin can check all messages that are received from an "
619                  "IMAP, LOCAL or POP account for spam using a SpamAssassin "
620                  "server. You will need a SpamAssassin Server (spamd) running "
621                  "somewhere.\n"
622                  "\n"
623                  "It can also be used for marking messages as Ham or Spam.\n"
624                  "\n"
625                  "When a message is identified as spam it can be deleted or "
626                  "saved in a specially designated folder.\n"
627                  "\n"
628                  "Options can be found in /Configuration/Preferences/Plugins/SpamAssassin");
629 }
630
631 const gchar *plugin_type(void)
632 {
633         return "GTK2";
634 }
635
636 const gchar *plugin_licence(void)
637 {
638         return "GPL3+";
639 }
640
641 const gchar *plugin_version(void)
642 {
643         return VERSION;
644 }
645
646 struct PluginFeature *plugin_provides(void)
647 {
648         static struct PluginFeature features[] = 
649                 { {PLUGIN_FILTERING, N_("Spam detection")},
650                   {PLUGIN_FILTERING, N_("Spam learning")},
651                   {PLUGIN_NOTHING, NULL}};
652         return features;
653 }
654
655 void spamassassin_register_hook(void)
656 {
657         if (hook_id == -1)
658                 hook_id = hooks_register_hook(MAIL_FILTERING_HOOKLIST, mail_filtering_hook, NULL);
659         if (hook_id == -1) {
660                 g_warning("Failed to register mail filtering hook");
661                 config.process_emails = FALSE;
662         }
663 }
664
665 void spamassassin_unregister_hook(void)
666 {
667         if (hook_id != -1) {
668                 hooks_unregister_hook(MAIL_FILTERING_HOOKLIST, hook_id);
669         }
670         hook_id = -1;
671 }
672
673 FolderItem *spamassassin_get_spam_folder(MsgInfo *msginfo)
674 {
675         FolderItem *item = folder_find_item_from_identifier(config.save_folder);
676
677         if (item || msginfo == NULL || msginfo->folder == NULL)
678                 return item;
679
680         if (msginfo->folder->folder &&
681             msginfo->folder->folder->account && 
682             msginfo->folder->folder->account->set_trash_folder) {
683                 item = folder_find_item_from_identifier(
684                         msginfo->folder->folder->account->trash_folder);
685         }
686
687         if (item == NULL && 
688             msginfo->folder->folder &&
689             msginfo->folder->folder->trash)
690                 item = msginfo->folder->folder->trash;
691                 
692         if (item == NULL)
693                 item = folder_get_default_trash();
694                 
695         debug_print("SA spam dir: %s\n", folder_item_get_path(item));
696         return item;
697 }
698