uninitialized filter list when deleting a folder; debug_print some warning if destfol...
[claws.git] / src / filtering.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2002 Hiroyuki Yamamoto & 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18  */
19
20 #include "defs.h"
21 #include <ctype.h>
22 #include <string.h>
23 #include <stdlib.h>
24 #include <errno.h>
25 #include <gtk/gtk.h>
26 #include <stdio.h>
27 #include "intl.h"
28 #include "utils.h"
29 #include "procheader.h"
30 #include "matcher.h"
31 #include "filtering.h"
32 #include "prefs_gtk.h"
33 #include "compose.h"
34
35 #define PREFSBUFSIZE            1024
36
37 GSList * pre_global_processing = NULL;
38 GSList * post_global_processing = NULL;
39 GSList * filtering_rules = NULL;
40
41 static gboolean filtering_is_final_action(FilteringAction *filtering_action);
42
43 #define STRLEN_WITH_CHECK(expr) \
44         strlen_with_check(#expr, __LINE__, expr)
45                 
46 static inline gint strlen_with_check(const gchar *expr, gint fline, const gchar *str)
47 {
48         if (str) 
49                 return strlen(str);
50         else {
51                 debug_print("%s(%d) - invalid string %s\n", __FILE__, fline, expr);
52                 return 0;
53         }
54 }
55
56 FilteringAction * filteringaction_new(int type, int account_id,
57                                       gchar * destination,
58                                       gint labelcolor, gint score)
59 {
60         FilteringAction * action;
61
62         action = g_new0(FilteringAction, 1);
63
64         action->type = type;
65         action->account_id = account_id;
66         if (destination) {
67                 action->destination       = g_strdup(destination);
68         } else {
69                 action->destination       = NULL;
70         }
71         action->labelcolor = labelcolor;        
72         action->score = score;
73         return action;
74 }
75
76 void filteringaction_free(FilteringAction * action)
77 {
78         g_return_if_fail(action);
79         if (action->destination)
80                 g_free(action->destination);
81         g_free(action);
82 }
83
84 FilteringProp * filteringprop_new(MatcherList * matchers,
85                                   GSList * action_list)
86 {
87         FilteringProp * filtering;
88
89         filtering = g_new0(FilteringProp, 1);
90         filtering->matchers = matchers;
91         filtering->action_list = action_list;
92
93         return filtering;
94 }
95
96 static FilteringAction * filteringaction_copy(FilteringAction * src)
97 {
98         FilteringAction * new;
99         
100         new = g_new0(FilteringAction, 1);
101         
102         new->type = src->type;
103         new->account_id = src->account_id;
104         if (src->destination)
105                 new->destination = g_strdup(src->destination);
106         else 
107                 new->destination = NULL;
108         new->labelcolor = src->labelcolor;
109
110         return new;
111 }
112
113 FilteringProp * filteringprop_copy(FilteringProp *src)
114 {
115         FilteringProp * new;
116         GSList *tmp;
117         
118         new = g_new0(FilteringProp, 1);
119         new->matchers = g_new0(MatcherList, 1);
120
121         for (tmp = src->matchers->matchers; tmp != NULL && tmp->data != NULL;) {
122                 MatcherProp *matcher = (MatcherProp *)tmp->data;
123                 
124                 new->matchers->matchers = g_slist_append(new->matchers->matchers,
125                                                    matcherprop_copy(matcher));
126                 tmp = tmp->next;
127         }
128
129         new->matchers->bool_and = src->matchers->bool_and;
130
131         new->action_list = NULL;
132
133         for (tmp = src->action_list ; tmp != NULL ; tmp = tmp->next) {
134                 FilteringAction *filtering_action;
135                 
136                 filtering_action = tmp->data;
137                 
138                 new->action_list = g_slist_append(new->action_list,
139                     filteringaction_copy(filtering_action));
140         }
141
142         return new;
143 }
144
145 void filteringprop_free(FilteringProp * prop)
146 {
147         GSList * tmp;
148
149         g_return_if_fail(prop);
150         matcherlist_free(prop->matchers);
151         
152         for (tmp = prop->action_list ; tmp != NULL ; tmp = tmp->next) {
153                 filteringaction_free(tmp->data);
154         }
155         g_free(prop);
156 }
157
158 /*
159   fitleringaction_apply
160   runs the action on one MsgInfo
161   return value : return TRUE if the action could be applied
162 */
163
164 static gboolean filteringaction_apply(FilteringAction * action, MsgInfo * info)
165 {
166         FolderItem * dest_folder;
167         gint val;
168         Compose * compose;
169         PrefsAccount * account;
170         gchar * cmd;
171
172         switch(action->type) {
173         case MATCHACTION_MOVE:
174                 dest_folder =
175                         folder_find_item_from_identifier(action->destination);
176                 if (!dest_folder) {
177                         debug_print("*** folder not found '%s'\n",
178                                 action->destination ?action->destination :"");
179                         return FALSE;
180                 }
181                 
182                 if (folder_item_move_msg(dest_folder, info) == -1) {
183                         debug_print("*** could not move message\n");
184                         return FALSE;
185                 }       
186
187                 return TRUE;
188
189         case MATCHACTION_COPY:
190                 dest_folder =
191                         folder_find_item_from_identifier(action->destination);
192
193                 if (!dest_folder) {
194                         debug_print("*** folder not found '%s'\n",
195                                 action->destination ?action->destination :"");
196                         return FALSE;
197                 }
198
199                 if (folder_item_copy_msg(dest_folder, info) == -1)
200                         return FALSE;
201
202                 return TRUE;
203
204         case MATCHACTION_DELETE:
205                 if (folder_item_remove_msg(info->folder, info->msgnum) == -1)
206                         return FALSE;
207                 return TRUE;
208
209         case MATCHACTION_MARK:
210                 procmsg_msginfo_set_flags(info, MSG_MARKED, 0);
211                 return TRUE;
212
213         case MATCHACTION_UNMARK:
214                 procmsg_msginfo_unset_flags(info, MSG_MARKED, 0);
215                 return TRUE;
216
217         case MATCHACTION_LOCK:
218                 procmsg_msginfo_set_flags(info, MSG_LOCKED, 0);
219                 return TRUE;
220
221         case MATCHACTION_UNLOCK:
222                 procmsg_msginfo_unset_flags(info, MSG_LOCKED, 0);       
223                 return TRUE;
224                 
225         case MATCHACTION_MARK_AS_READ:
226                 procmsg_msginfo_unset_flags(info, MSG_UNREAD | MSG_NEW, 0);
227                 return TRUE;
228
229         case MATCHACTION_MARK_AS_UNREAD:
230                 procmsg_msginfo_set_flags(info, MSG_UNREAD | MSG_NEW, 0);
231                 return TRUE;
232         
233         case MATCHACTION_COLOR:
234                 procmsg_msginfo_unset_flags(info, MSG_CLABEL_FLAG_MASK, 0); 
235                 procmsg_msginfo_set_flags(info, MSG_COLORLABEL_TO_FLAGS(action->labelcolor), 0);
236                 return TRUE;
237
238         case MATCHACTION_FORWARD:
239         case MATCHACTION_FORWARD_AS_ATTACHMENT:
240                 account = account_find_from_id(action->account_id);
241                 compose = compose_forward(account, info,
242                         action->type == MATCHACTION_FORWARD ? FALSE : TRUE,
243                         NULL, TRUE);
244                 compose_entry_append(compose, action->destination,
245                                      compose->account->protocol == A_NNTP
246                                             ? COMPOSE_NEWSGROUPS
247                                             : COMPOSE_TO);
248
249                 val = compose_send(compose);
250                 gtk_widget_destroy(compose->window);
251
252                 return val == 0 ? TRUE : FALSE;
253
254         case MATCHACTION_REDIRECT:
255                 account = account_find_from_id(action->account_id);
256                 compose = compose_redirect(account, info);
257                 if (compose->account->protocol == A_NNTP)
258                         break;
259                 else
260                         compose_entry_append(compose, action->destination,
261                                              COMPOSE_TO);
262
263                 val = compose_send(compose);
264                 gtk_widget_destroy(compose->window);
265                 
266                 return val == 0 ? TRUE : FALSE;
267
268         case MATCHACTION_EXECUTE:
269                 cmd = matching_build_command(action->destination, info);
270                 if (cmd == NULL)
271                         return FALSE;
272                 else {
273                         system(cmd);
274                         g_free(cmd);
275                 }
276                 return TRUE;
277
278         case MATCHACTION_SET_SCORE:
279                 info->score = action->score;
280                 return TRUE;
281
282         case MATCHACTION_ADD_SCORE:
283                 info->score += action->score;
284                 return TRUE;
285
286         case MATCHACTION_STOP:
287                 return TRUE;
288
289         case MATCHACTION_HIDE:
290                 info->hidden = TRUE;
291                 return TRUE;
292
293         default:
294                 break;
295         }
296         return FALSE;
297 }
298
299 gboolean filteringaction_apply_action_list(GSList *action_list, MsgInfo *info)
300 {
301         GSList *p;
302         g_return_val_if_fail(action_list, FALSE);
303         g_return_val_if_fail(info, FALSE);
304         for (p = action_list; p && p->data; p = g_slist_next(p)) {
305                 FilteringAction *a = (FilteringAction *) p->data;
306                 if (filteringaction_apply(a, info)) {
307                         if (filtering_is_final_action(a))
308                                 break;
309                 } else
310                         return FALSE;
311                 
312         }
313         return TRUE;
314 }
315
316 static gboolean filtering_match_condition(FilteringProp *filtering, MsgInfo *info)
317 {
318         return matcherlist_match(filtering->matchers, info);
319 }
320
321 static gboolean filtering_apply_rule(FilteringProp *filtering, MsgInfo *info,
322     gboolean * final)
323 {
324         gboolean result;
325         gchar    buf[50];
326         GSList * tmp;
327         
328         * final = FALSE;
329         for (tmp = filtering->action_list ; tmp != NULL ; tmp = tmp->next) {
330                 FilteringAction * action;
331                 
332                 action = tmp->data;
333                 
334                 if (FALSE == (result = filteringaction_apply(action, info))) {
335                         g_warning("action %s could not be applied", 
336                             filteringaction_to_string(buf, sizeof buf, action));
337                 }
338                 
339                 if (filtering_is_final_action(action)) {
340                         * final = TRUE;
341                         break;
342                 }
343         }
344         return result;
345 }
346
347 static gboolean filtering_is_final_action(FilteringAction *filtering_action)
348 {
349         switch(filtering_action->type) {
350         case MATCHACTION_MOVE:
351         case MATCHACTION_DELETE:
352         case MATCHACTION_STOP:
353                 return TRUE; /* MsgInfo invalid for message */
354         default:
355                 return FALSE;
356         }
357 }
358
359 static gboolean filter_msginfo(GSList * filtering_list, MsgInfo * info)
360 {
361         GSList  *l;
362         gboolean final;
363         gboolean applied;
364         
365         g_return_val_if_fail(info != NULL, TRUE);
366         
367         for (l = filtering_list, final = FALSE, applied = FALSE; l != NULL; l = g_slist_next(l)) {
368                 FilteringProp * filtering = (FilteringProp *) l->data;
369
370                 if (filtering_match_condition(filtering, info)) {
371                         applied = filtering_apply_rule(filtering, info, &final);
372                         if (final)
373                                 break;
374                 }               
375         }
376
377         /* put in inbox if a final rule could not be applied, or
378          * the last rule was not a final one. */
379         if ((final && !applied) || !final) {
380                 return FALSE;
381         }
382
383         return TRUE;
384 }
385
386 gboolean filter_message_by_msginfo(GSList *flist, MsgInfo *info)
387 {
388         return filter_msginfo(flist, info);
389 }
390
391 gchar *filteringaction_to_string(gchar *dest, gint destlen, FilteringAction *action)
392 {
393         const gchar *command_str;
394         gchar * quoted_dest;
395         
396         command_str = get_matchparser_tab_str(action->type);
397
398         if (command_str == NULL)
399                 return NULL;
400
401         switch(action->type) {
402         case MATCHACTION_MOVE:
403         case MATCHACTION_COPY:
404         case MATCHACTION_EXECUTE:
405                 quoted_dest = matcher_quote_str(action->destination);
406                 g_snprintf(dest, destlen, "%s \"%s\"", command_str, quoted_dest);
407                 g_free(quoted_dest);
408                 return dest;
409
410         case MATCHACTION_DELETE:
411         case MATCHACTION_MARK:
412         case MATCHACTION_UNMARK:
413         case MATCHACTION_LOCK:
414         case MATCHACTION_UNLOCK:
415         case MATCHACTION_MARK_AS_READ:
416         case MATCHACTION_MARK_AS_UNREAD:
417         case MATCHACTION_STOP:
418         case MATCHACTION_HIDE:
419                 g_snprintf(dest, destlen, "%s", command_str);
420                 return dest;
421
422         case MATCHACTION_REDIRECT:
423         case MATCHACTION_FORWARD:
424         case MATCHACTION_FORWARD_AS_ATTACHMENT:
425                 quoted_dest = matcher_quote_str(action->destination);
426                 g_snprintf(dest, destlen, "%s %d \"%s\"", command_str, action->account_id, quoted_dest);
427                 g_free(quoted_dest);
428                 return dest; 
429
430         case MATCHACTION_COLOR:
431                 g_snprintf(dest, destlen, "%s %d", command_str, action->labelcolor);
432                 return dest;  
433
434         case MATCHACTION_ADD_SCORE:
435         case MATCHACTION_SET_SCORE:
436                 g_snprintf(dest, destlen, "%s %d", command_str, action->score);
437                 return dest;  
438
439         default:
440                 return NULL;
441         }
442 }
443
444 gchar * filteringaction_list_to_string(GSList * action_list)
445 {
446         gchar *action_list_str;
447         gchar  buf[256];
448         GSList * tmp;
449         gchar *list_str;
450
451         action_list_str = NULL;
452         for (tmp = action_list ; tmp != NULL ; tmp = tmp->next) {
453                 gchar *action_str;
454                 FilteringAction * action;
455                 
456                 action = tmp->data;
457                 
458                 action_str = filteringaction_to_string(buf,
459                     sizeof buf, action);
460                 
461                 if (action_list_str != NULL) {
462                         list_str = g_strconcat(action_list_str, " ", action_str, NULL);
463                         g_free(action_list_str);
464                 }
465                 else {
466                         list_str = g_strdup(action_str);
467                 }
468                 action_list_str = list_str;
469         }
470
471         return action_list_str;
472 }
473
474 gchar * filteringprop_to_string(FilteringProp * prop)
475 {
476         gchar *list_str;
477         gchar *action_list_str;
478         gchar *filtering_str;
479
480         action_list_str = filteringaction_list_to_string(prop->action_list);
481
482         if (action_list_str == NULL)
483                 return NULL;
484
485         list_str = matcherlist_to_string(prop->matchers);
486
487         if (list_str == NULL) {
488                 g_free(action_list_str);
489                 return NULL;
490         }
491
492         filtering_str = g_strconcat(list_str, " ", action_list_str, NULL);
493         g_free(action_list_str);
494         g_free(list_str);
495
496         return filtering_str;
497 }
498
499 void prefs_filtering_free(GSList * prefs_filtering)
500 {
501         while (prefs_filtering != NULL) {
502                 FilteringProp * filtering = (FilteringProp *)
503                         prefs_filtering->data;
504                 filteringprop_free(filtering);
505                 prefs_filtering = g_slist_remove(prefs_filtering, filtering);
506         }
507 }
508
509 static gboolean prefs_filtering_free_func(GNode *node, gpointer data)
510 {
511         FolderItem *item = node->data;
512
513         g_return_val_if_fail(item, FALSE);
514         g_return_val_if_fail(item->prefs, FALSE);
515
516         prefs_filtering_free(item->prefs->processing);
517         item->prefs->processing = NULL;
518
519         return FALSE;
520 }
521
522 void prefs_filtering_clear(void)
523 {
524         GList * cur;
525
526         for (cur = folder_get_list() ; cur != NULL ; cur = g_list_next(cur)) {
527                 Folder *folder;
528
529                 folder = (Folder *) cur->data;
530                 g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
531                                 prefs_filtering_free_func, NULL);
532         }
533
534         prefs_filtering_free(filtering_rules);
535         filtering_rules = NULL;
536         prefs_filtering_free(pre_global_processing);
537         pre_global_processing = NULL;
538         prefs_filtering_free(post_global_processing);
539         post_global_processing = NULL;
540 }
541
542 void prefs_filtering_clear_folder(Folder *folder)
543 {
544         g_return_if_fail(folder);
545         g_return_if_fail(folder->node);
546
547         g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
548                         prefs_filtering_free_func, NULL);
549         /* FIXME: Note folder settings were changed, where the updates? */
550 }
551