2004-11-16 [colin] 0.9.12cvs148
[claws.git] / src / procmsg.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2004 Hiroyuki Yamamoto
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
22 #include <glib.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <ctype.h>
26
27 #include "intl.h"
28 #include "main.h"
29 #include "utils.h"
30 #include "procmsg.h"
31 #include "procheader.h"
32 #include "send_message.h"
33 #include "procmime.h"
34 #include "statusbar.h"
35 #include "prefs_filtering.h"
36 #include "filtering.h"
37 #include "folder.h"
38 #include "prefs_common.h"
39 #include "account.h"
40 #include "alertpanel.h"
41 #include "news.h"
42 #include "hooks.h"
43 #include "msgcache.h"
44 #include "partial_download.h"
45
46 GHashTable *procmsg_msg_hash_table_create(GSList *mlist)
47 {
48         GHashTable *msg_table;
49
50         if (mlist == NULL) return NULL;
51
52         msg_table = g_hash_table_new(NULL, g_direct_equal);
53         procmsg_msg_hash_table_append(msg_table, mlist);
54
55         return msg_table;
56 }
57
58 void procmsg_msg_hash_table_append(GHashTable *msg_table, GSList *mlist)
59 {
60         GSList *cur;
61         MsgInfo *msginfo;
62
63         if (msg_table == NULL || mlist == NULL) return;
64
65         for (cur = mlist; cur != NULL; cur = cur->next) {
66                 msginfo = (MsgInfo *)cur->data;
67
68                 g_hash_table_insert(msg_table,
69                                     GUINT_TO_POINTER(msginfo->msgnum),
70                                     msginfo);
71         }
72 }
73
74 GHashTable *procmsg_to_folder_hash_table_create(GSList *mlist)
75 {
76         GHashTable *msg_table;
77         GSList *cur;
78         MsgInfo *msginfo;
79
80         if (mlist == NULL) return NULL;
81
82         msg_table = g_hash_table_new(NULL, g_direct_equal);
83
84         for (cur = mlist; cur != NULL; cur = cur->next) {
85                 msginfo = (MsgInfo *)cur->data;
86                 g_hash_table_insert(msg_table, msginfo->to_folder, msginfo);
87         }
88
89         return msg_table;
90 }
91
92 gint procmsg_get_last_num_in_msg_list(GSList *mlist)
93 {
94         GSList *cur;
95         MsgInfo *msginfo;
96         gint last = 0;
97
98         for (cur = mlist; cur != NULL; cur = cur->next) {
99                 msginfo = (MsgInfo *)cur->data;
100                 if (msginfo && msginfo->msgnum > last)
101                         last = msginfo->msgnum;
102         }
103
104         return last;
105 }
106
107 void procmsg_msg_list_free(GSList *mlist)
108 {
109         GSList *cur;
110         MsgInfo *msginfo;
111
112         for (cur = mlist; cur != NULL; cur = cur->next) {
113                 msginfo = (MsgInfo *)cur->data;
114                 procmsg_msginfo_free(msginfo);
115         }
116         g_slist_free(mlist);
117 }
118
119 struct MarkSum {
120         gint *new_msgs;
121         gint *unread_msgs;
122         gint *total_msgs;
123         gint *min;
124         gint *max;
125         gint first;
126 };
127
128 /* CLAWS subject threading:
129   
130   in the first round it inserts subject lines in a 
131   relation (subject <-> node)
132
133   the second round finishes the threads by attaching
134   matching subject lines to the one found in the
135   relation. will use the oldest node with the same
136   subject that is not more then thread_by_subject_max_age
137   days old (see subject_relation_lookup)
138 */  
139
140 static void subject_relation_insert(GRelation *relation, GNode *node)
141 {
142         gchar *subject;
143         MsgInfo *msginfo;
144
145         g_return_if_fail(relation != NULL);
146         g_return_if_fail(node != NULL);
147         msginfo = (MsgInfo *) node->data;
148         g_return_if_fail(msginfo != NULL);
149
150         subject = msginfo->subject;
151         if (subject == NULL)
152                 return;
153         subject += subject_get_prefix_length(subject);
154
155         g_relation_insert(relation, subject, node);
156 }
157
158 static GNode *subject_relation_lookup(GRelation *relation, MsgInfo *msginfo)
159 {
160         gchar *subject;
161         GTuples *tuples;
162         GNode *node = NULL;
163         gint prefix_length;
164     
165         g_return_val_if_fail(relation != NULL, NULL);
166
167         subject = msginfo->subject;
168         if (subject == NULL)
169                 return NULL;
170         prefix_length = subject_get_prefix_length(subject);
171         if (prefix_length <= 0)
172                 return NULL;
173         subject += prefix_length;
174         
175         tuples = g_relation_select(relation, subject, 0);
176         if (tuples == NULL)
177                 return NULL;
178
179         if (tuples->len > 0) {
180                 int i;
181                 GNode *relation_node;
182                 MsgInfo *relation_msginfo = NULL, *best_msginfo = NULL;
183                 gboolean match;
184
185                 /* check all nodes with the same subject to find the best parent */
186                 for (i = 0; i < tuples->len; i++) {
187                         relation_node = (GNode *) g_tuples_index(tuples, i, 1);
188                         relation_msginfo = (MsgInfo *) relation_node->data;
189                         match = FALSE;
190
191                         /* best node should be the oldest in the found nodes */
192                         /* parent node must not be older then msginfo */
193                         if ((relation_msginfo->date_t < msginfo->date_t) &&
194                             ((best_msginfo == NULL) ||
195                              (best_msginfo->date_t > relation_msginfo->date_t)))
196                                 match = TRUE;
197
198                         /* parent node must not be more then thread_by_subject_max_age
199                            days older then msginfo */
200                         if (abs(difftime(msginfo->date_t, relation_msginfo->date_t)) >
201                             prefs_common.thread_by_subject_max_age * 3600 * 24)
202                                 match = FALSE;
203
204                         /* can add new tests for all matching
205                            nodes found by subject */
206
207                         if (match) {
208                                 node = relation_node;
209                                 best_msginfo = relation_msginfo;
210                         }
211                 }           
212         }
213
214         g_tuples_destroy(tuples);
215         return node;
216 }
217
218 /* return the reversed thread tree */
219 GNode *procmsg_get_thread_tree(GSList *mlist)
220 {
221         GNode *root, *parent, *node, *next;
222         GHashTable *msgid_table;
223         GRelation *subject_relation;
224         MsgInfo *msginfo;
225         const gchar *msgid;
226
227         root = g_node_new(NULL);
228         msgid_table = g_hash_table_new(g_str_hash, g_str_equal);
229         subject_relation = g_relation_new(2);
230         g_relation_index(subject_relation, 0, g_str_hash, g_str_equal);
231
232         for (; mlist != NULL; mlist = mlist->next) {
233                 msginfo = (MsgInfo *)mlist->data;
234                 parent = root;
235
236                 if (msginfo->inreplyto) {
237                         parent = g_hash_table_lookup(msgid_table, msginfo->inreplyto);
238                         if (parent == NULL) {
239                                 parent = root;
240                         }
241                 }
242                 node = g_node_insert_data_before
243                         (parent, parent == root ? parent->children : NULL,
244                          msginfo);
245                 if ((msgid = msginfo->msgid) && g_hash_table_lookup(msgid_table, msgid) == NULL)
246                         g_hash_table_insert(msgid_table, (gchar *)msgid, node);
247
248                 /* CLAWS: add subject to relation (without prefix) */
249                 if (prefs_common.thread_by_subject) {
250                         subject_relation_insert(subject_relation, node);
251                 }
252         }
253
254         /* complete the unfinished threads */
255         for (node = root->children; node != NULL; ) {
256                 parent = NULL;
257                 next = node->next;
258                 msginfo = (MsgInfo *)node->data;
259                 if (msginfo->inreplyto) { 
260                         parent = g_hash_table_lookup(msgid_table, msginfo->inreplyto);
261                         /* node should not be the parent, and node should not 
262                            be an ancestor of parent (circular reference) */
263                         if (parent && parent != node && 
264                             !g_node_is_ancestor(node, parent)) {
265                                 g_node_unlink(node);
266                                 g_node_insert_before
267                                         (parent, parent->children, node);
268                         }                               
269                 }
270                 node = next;
271         }
272
273         if (prefs_common.thread_by_subject) {
274                 for (node = root->children; node && node != NULL;) {
275                         next = node->next;
276                         msginfo = (MsgInfo *) node->data;
277                         
278                         parent = subject_relation_lookup(subject_relation, msginfo);
279                         
280                         /* the node may already be threaded by IN-REPLY-TO, so go up 
281                          * in the tree to 
282                            find the parent node */
283                         if (parent != NULL) {
284                                 if (g_node_is_ancestor(node, parent))
285                                         parent = NULL;
286                                 if (parent == node)
287                                         parent = NULL;
288                         }
289                         
290                         if (parent) {
291                                 g_node_unlink(node);
292                                 g_node_append(parent, node);
293                         }
294
295                         node = next;
296                 }       
297         }
298         
299         g_relation_destroy(subject_relation);
300         g_hash_table_destroy(msgid_table);
301
302         return root;
303 }
304
305 void procmsg_move_messages(GSList *mlist)
306 {
307         GSList *cur, *movelist = NULL;
308         MsgInfo *msginfo;
309         FolderItem *dest = NULL;
310
311         if (!mlist) return;
312
313         folder_item_update_freeze();
314
315         for (cur = mlist; cur != NULL; cur = cur->next) {
316                 msginfo = (MsgInfo *)cur->data;
317                 if (!dest) {
318                         dest = msginfo->to_folder;
319                         movelist = g_slist_append(movelist, msginfo);
320                 } else if (dest == msginfo->to_folder) {
321                         movelist = g_slist_append(movelist, msginfo);
322                 } else {
323                         folder_item_move_msgs(dest, movelist);
324                         g_slist_free(movelist);
325                         movelist = NULL;
326                         dest = msginfo->to_folder;
327                         movelist = g_slist_append(movelist, msginfo);
328                 }
329                 procmsg_msginfo_set_to_folder(msginfo, NULL);
330         }
331
332         if (movelist) {
333                 folder_item_move_msgs(dest, movelist);
334                 g_slist_free(movelist);
335         }
336
337         folder_item_update_thaw();
338 }
339
340 void procmsg_copy_messages(GSList *mlist)
341 {
342         GSList *cur, *copylist = NULL;
343         MsgInfo *msginfo;
344         FolderItem *dest = NULL;
345
346         if (!mlist) return;
347
348         folder_item_update_freeze();
349
350         for (cur = mlist; cur != NULL; cur = cur->next) {
351                 msginfo = (MsgInfo *)cur->data;
352                 if (!dest) {
353                         dest = msginfo->to_folder;
354                         copylist = g_slist_append(copylist, msginfo);
355                 } else if (dest == msginfo->to_folder) {
356                         copylist = g_slist_append(copylist, msginfo);
357                 } else {
358                         folder_item_copy_msgs(dest, copylist);
359                         g_slist_free(copylist);
360                         copylist = NULL;
361                         dest = msginfo->to_folder;
362                         copylist = g_slist_append(copylist, msginfo);
363                 }
364                 procmsg_msginfo_set_to_folder(msginfo, NULL);
365         }
366
367         if (copylist) {
368                 folder_item_copy_msgs(dest, copylist);
369                 g_slist_free(copylist);
370         }
371
372         folder_item_update_thaw();
373 }
374
375 gchar *procmsg_get_message_file_path(MsgInfo *msginfo)
376 {
377         gchar *file;
378
379         g_return_val_if_fail(msginfo != NULL, NULL);
380
381         if (msginfo->plaintext_file)
382                 file = g_strdup(msginfo->plaintext_file);
383         else {
384                 file = folder_item_fetch_msg(msginfo->folder, msginfo->msgnum);
385         }
386
387         return file;
388 }
389
390 gchar *procmsg_get_message_file(MsgInfo *msginfo)
391 {
392         gchar *filename = NULL;
393
394         g_return_val_if_fail(msginfo != NULL, NULL);
395
396         filename = folder_item_fetch_msg(msginfo->folder, msginfo->msgnum);
397         if (!filename)
398                 debug_print("can't fetch message %d\n", msginfo->msgnum);
399
400         return filename;
401 }
402
403 GSList *procmsg_get_message_file_list(GSList *mlist)
404 {
405         GSList *file_list = NULL;
406         MsgInfo *msginfo;
407         MsgFileInfo *fileinfo;
408         gchar *file;
409
410         while (mlist != NULL) {
411                 msginfo = (MsgInfo *)mlist->data;
412                 file = procmsg_get_message_file(msginfo);
413                 if (!file) {
414                         procmsg_message_file_list_free(file_list);
415                         return NULL;
416                 }
417                 fileinfo = g_new(MsgFileInfo, 1);
418                 fileinfo->msginfo = procmsg_msginfo_new_ref(msginfo);
419                 fileinfo->file = file;
420                 fileinfo->flags = g_new(MsgFlags, 1);
421                 *fileinfo->flags = msginfo->flags;
422                 file_list = g_slist_prepend(file_list, fileinfo);
423                 mlist = mlist->next;
424         }
425
426         file_list = g_slist_reverse(file_list);
427
428         return file_list;
429 }
430
431 void procmsg_message_file_list_free(MsgInfoList *file_list)
432 {
433         GSList *cur;
434         MsgFileInfo *fileinfo;
435
436         for (cur = file_list; cur != NULL; cur = cur->next) {
437                 fileinfo = (MsgFileInfo *)cur->data;
438                 procmsg_msginfo_free(fileinfo->msginfo);
439                 g_free(fileinfo->file);
440                 g_free(fileinfo->flags);
441                 g_free(fileinfo);
442         }
443
444         g_slist_free(file_list);
445 }
446
447 FILE *procmsg_open_message(MsgInfo *msginfo)
448 {
449         FILE *fp;
450         gchar *file;
451
452         g_return_val_if_fail(msginfo != NULL, NULL);
453
454         file = procmsg_get_message_file_path(msginfo);
455         g_return_val_if_fail(file != NULL, NULL);
456
457         if (!is_file_exist(file)) {
458                 g_free(file);
459                 file = procmsg_get_message_file(msginfo);
460                 if (!file)
461                         return NULL;
462         }
463
464         if ((fp = fopen(file, "rb")) == NULL) {
465                 FILE_OP_ERROR(file, "fopen");
466                 g_free(file);
467                 return NULL;
468         }
469
470         g_free(file);
471
472         if (MSG_IS_QUEUED(msginfo->flags) || MSG_IS_DRAFT(msginfo->flags)) {
473                 gchar buf[BUFFSIZE];
474
475                 while (fgets(buf, sizeof(buf), fp) != NULL)
476                         if (buf[0] == '\r' || buf[0] == '\n') break;
477         }
478
479         return fp;
480 }
481
482 gboolean procmsg_msg_exist(MsgInfo *msginfo)
483 {
484         gchar *path;
485         gboolean ret;
486
487         if (!msginfo) return FALSE;
488
489         path = folder_item_get_path(msginfo->folder);
490         change_dir(path);
491         ret = !folder_item_is_msg_changed(msginfo->folder, msginfo);
492         g_free(path);
493
494         return ret;
495 }
496
497 void procmsg_get_filter_keyword(MsgInfo *msginfo, gchar **header, gchar **key,
498                                 PrefsFilterType type)
499 {
500         static HeaderEntry hentry[] = {{"X-BeenThere:",    NULL, TRUE},
501                                        {"X-ML-Name:",      NULL, TRUE},
502                                        {"X-List:",         NULL, TRUE},
503                                        {"X-Mailing-list:", NULL, TRUE},
504                                        {"List-Id:",        NULL, TRUE},
505                                        {"X-Sequence:",     NULL, TRUE},
506                                        {NULL,              NULL, FALSE}};
507         enum
508         {
509                 H_X_BEENTHERE    = 0,
510                 H_X_ML_NAME      = 1,
511                 H_X_LIST         = 2,
512                 H_X_MAILING_LIST = 3,
513                 H_LIST_ID        = 4,
514                 H_X_SEQUENCE     = 5
515         };
516
517         FILE *fp;
518
519         g_return_if_fail(msginfo != NULL);
520         g_return_if_fail(header != NULL);
521         g_return_if_fail(key != NULL);
522
523         *header = NULL;
524         *key = NULL;
525
526         switch (type) {
527         case FILTER_BY_NONE:
528                 return;
529         case FILTER_BY_AUTO:
530                 if ((fp = procmsg_open_message(msginfo)) == NULL)
531                         return;
532                 procheader_get_header_fields(fp, hentry);
533                 fclose(fp);
534
535 #define SET_FILTER_KEY(hstr, idx)       \
536 {                                       \
537         *header = g_strdup(hstr);       \
538         *key = hentry[idx].body;        \
539         hentry[idx].body = NULL;        \
540 }
541
542                 if (hentry[H_X_BEENTHERE].body != NULL) {
543                         SET_FILTER_KEY("header \"X-BeenThere\"", H_X_BEENTHERE);
544                 } else if (hentry[H_X_ML_NAME].body != NULL) {
545                         SET_FILTER_KEY("header \"X-ML-Name\"", H_X_ML_NAME);
546                 } else if (hentry[H_X_LIST].body != NULL) {
547                         SET_FILTER_KEY("header \"X-List\"", H_X_LIST);
548                 } else if (hentry[H_X_MAILING_LIST].body != NULL) {
549                         SET_FILTER_KEY("header \"X-Mailing-List\"", H_X_MAILING_LIST);
550                 } else if (hentry[H_LIST_ID].body != NULL) {
551                         SET_FILTER_KEY("header \"List-Id\"", H_LIST_ID);
552                         extract_list_id_str(*key);
553                 } else if (hentry[H_X_SEQUENCE].body != NULL) {
554                         guchar *p;
555
556                         SET_FILTER_KEY("X-Sequence", H_X_SEQUENCE);
557                         p = *key;
558                         while (*p != '\0') {
559                                 while (*p != '\0' && !isspace(*p)) p++;
560                                 while (isspace(*p)) p++;
561                                 if (isdigit(*p)) {
562                                         *p = '\0';
563                                         break;
564                                 }
565                         }
566                         g_strstrip(*key);
567                 } else if (msginfo->subject) {
568                         *header = g_strdup("subject");
569                         *key = g_strdup(msginfo->subject);
570                 }
571
572 #undef SET_FILTER_KEY
573
574                 g_free(hentry[H_X_BEENTHERE].body);
575                 hentry[H_X_BEENTHERE].body = NULL;
576                 g_free(hentry[H_X_ML_NAME].body);
577                 hentry[H_X_ML_NAME].body = NULL;
578                 g_free(hentry[H_X_LIST].body);
579                 hentry[H_X_LIST].body = NULL;
580                 g_free(hentry[H_X_MAILING_LIST].body);
581                 hentry[H_X_MAILING_LIST].body = NULL;
582                 g_free(hentry[H_LIST_ID].body);
583                 hentry[H_LIST_ID].body = NULL;
584
585                 break;
586         case FILTER_BY_FROM:
587                 *header = g_strdup("from");
588                 *key = g_strdup(msginfo->from);
589                 break;
590         case FILTER_BY_TO:
591                 *header = g_strdup("to");
592                 *key = g_strdup(msginfo->to);
593                 break;
594         case FILTER_BY_SUBJECT:
595                 *header = g_strdup("subject");
596                 *key = g_strdup(msginfo->subject);
597                 break;
598         default:
599                 break;
600         }
601 }
602
603 void procmsg_empty_trash(FolderItem *trash)
604 {
605         FILE *fp;
606
607         if (trash && trash->total_msgs > 0) {
608                 GSList *mlist = folder_item_get_msg_list(trash);
609                 GSList *cur;
610                 for (cur = mlist ; cur != NULL ; cur = cur->next) {
611                         MsgInfo * msginfo = (MsgInfo *) cur->data;
612                         partial_mark_for_delete(msginfo);
613                         procmsg_msginfo_free(msginfo);
614                 }
615
616                 folder_item_remove_all_msg(trash);
617         }
618 }
619
620 void procmsg_empty_all_trash(void)
621 {
622         FolderItem *trash;
623         GList *cur;
624
625         for (cur = folder_get_list(); cur != NULL; cur = cur->next) {
626                 trash = FOLDER(cur->data)->trash;
627                 procmsg_empty_trash(trash);
628         }
629 }
630
631 /*!
632  *\brief        Send messages in queue
633  *
634  *\param        queue Queue folder to process
635  *\param        save_msgs Unused
636  *
637  *\return       Number of messages sent, negative if an error occurred
638  *              positive if no error occurred
639  */
640 gint procmsg_send_queue(FolderItem *queue, gboolean save_msgs)
641 {
642         gint ret = 1, count = 0;
643         GSList *list, *elem;
644
645         if (!queue)
646                 queue = folder_get_default_queue();
647         g_return_val_if_fail(queue != NULL, -1);
648
649         folder_item_scan(queue);
650         list = folder_item_get_msg_list(queue);
651
652         for (elem = list; elem != NULL; elem = elem->next) {
653                 gchar *file;
654                 MsgInfo *msginfo;
655                 
656                 msginfo = (MsgInfo *)(elem->data);
657                 if (!MSG_IS_LOCKED(msginfo->flags)) {
658                         file = folder_item_fetch_msg(queue, msginfo->msgnum);
659                         if (file) {
660                                 if (procmsg_send_message_queue(file) < 0) {
661                                         g_warning("Sending queued message %d failed.\n", 
662                                                   msginfo->msgnum);
663                                         ret = -1;
664                                 } else {
665                                         /* CLAWS: 
666                                          * We save in procmsg_send_message_queue because
667                                          * we need the destination folder from the queue
668                                          * header
669                                                         
670                                         if (save_msgs)
671                                                 procmsg_save_to_outbox
672                                                         (queue->folder->outbox,
673                                                          file, TRUE);
674                                          */
675                                         count++; 
676                                         folder_item_remove_msg(queue, msginfo->msgnum);
677                                 }
678                                 g_free(file);
679                         }
680                 }
681                 /* FIXME: supposedly if only one message is locked, and queue
682                  * is being flushed, the following free says something like 
683                  * "freeing msg ## in folder (nil)". */
684                 procmsg_msginfo_free(msginfo);
685         }
686
687         return ret * count;
688 }
689
690 gint procmsg_remove_special_headers(const gchar *in, const gchar *out)
691 {
692         FILE *fp, *outfp;
693         gchar buf[BUFFSIZE];
694         
695         if ((fp = fopen(in, "rb")) == NULL) {
696                 FILE_OP_ERROR(in, "fopen");
697                 return -1;
698         }
699         if ((outfp = fopen(out, "wb")) == NULL) {
700                 FILE_OP_ERROR(out, "fopen");
701                 fclose(fp);
702                 return -1;
703         }
704         while (fgets(buf, sizeof(buf), fp) != NULL)
705                 if (buf[0] == '\r' || buf[0] == '\n') break;
706         while (fgets(buf, sizeof(buf), fp) != NULL)
707                 fputs(buf, outfp);
708         fclose(outfp);
709         fclose(fp);
710         return 0;
711
712 }
713 gint procmsg_save_to_outbox(FolderItem *outbox, const gchar *file,
714                             gboolean is_queued)
715 {
716         gint num;
717         MsgInfo *msginfo, *tmp_msginfo;
718         MsgFlags flag = {0, 0};
719
720         debug_print("saving sent message...\n");
721
722         if (!outbox)
723                 outbox = folder_get_default_outbox();
724         g_return_val_if_fail(outbox != NULL, -1);
725
726         /* remove queueing headers */
727         if (is_queued) {
728                 gchar tmp[MAXPATHLEN + 1];
729
730                 g_snprintf(tmp, sizeof(tmp), "%s%ctmpmsg.out.%08x",
731                            get_rc_dir(), G_DIR_SEPARATOR, (guint) rand());
732                 
733                 if (procmsg_remove_special_headers(file, tmp) !=0)
734                         return -1;
735
736                 folder_item_scan(outbox);
737                 if ((num = folder_item_add_msg(outbox, tmp, &flag, TRUE)) < 0) {
738                         g_warning("can't save message\n");
739                         unlink(tmp);
740                         return -1;
741                 }
742         } else {
743                 folder_item_scan(outbox);
744                 if ((num = folder_item_add_msg
745                         (outbox, file, &flag, FALSE)) < 0) {
746                         g_warning("can't save message\n");
747                         return -1;
748                 }
749                 return -1;
750         }
751         msginfo = folder_item_get_msginfo(outbox, num);         /* refcnt++ */
752         tmp_msginfo = procmsg_msginfo_get_full_info(msginfo);   /* refcnt++ */ 
753         if (msginfo != NULL) {
754                 procmsg_msginfo_unset_flags(msginfo, ~0, 0);
755                 procmsg_msginfo_free(msginfo);                  /* refcnt-- */
756                 /* tmp_msginfo == msginfo */
757                 if (tmp_msginfo && (msginfo->dispositionnotificationto || 
758                     msginfo->returnreceiptto)) {
759                         procmsg_msginfo_set_flags(msginfo, MSG_RETRCPT_SENT, 0); 
760                         procmsg_msginfo_free(msginfo);          /* refcnt-- */
761                 }       
762         }
763
764         return 0;
765 }
766
767 void procmsg_print_message(MsgInfo *msginfo, const gchar *cmdline)
768 {
769         static const gchar *def_cmd = "lpr %s";
770         static guint id = 0;
771         gchar *prtmp;
772         FILE *tmpfp, *prfp;
773         gchar buf[1024];
774         gchar *p;
775
776         g_return_if_fail(msginfo);
777
778         if ((tmpfp = procmime_get_first_text_content(msginfo)) == NULL) {
779                 g_warning("Can't get text part\n");
780                 return;
781         }
782
783         prtmp = g_strdup_printf("%s%cprinttmp.%08x",
784                                 get_mime_tmp_dir(), G_DIR_SEPARATOR, id++);
785
786         if ((prfp = fopen(prtmp, "wb")) == NULL) {
787                 FILE_OP_ERROR(prtmp, "fopen");
788                 g_free(prtmp);
789                 fclose(tmpfp);
790                 return;
791         }
792
793         if (msginfo->date) fprintf(prfp, "Date: %s\n", msginfo->date);
794         if (msginfo->from) fprintf(prfp, "From: %s\n", msginfo->from);
795         if (msginfo->to)   fprintf(prfp, "To: %s\n", msginfo->to);
796         if (msginfo->cc)   fprintf(prfp, "Cc: %s\n", msginfo->cc);
797         if (msginfo->newsgroups)
798                 fprintf(prfp, "Newsgroups: %s\n", msginfo->newsgroups);
799         if (msginfo->subject) fprintf(prfp, "Subject: %s\n", msginfo->subject);
800         fputc('\n', prfp);
801
802         while (fgets(buf, sizeof(buf), tmpfp) != NULL)
803                 fputs(buf, prfp);
804
805         fclose(prfp);
806         fclose(tmpfp);
807
808         if (cmdline && (p = strchr(cmdline, '%')) && *(p + 1) == 's' &&
809             !strchr(p + 2, '%'))
810                 g_snprintf(buf, sizeof(buf) - 1, cmdline, prtmp);
811         else {
812                 if (cmdline)
813                         g_warning("Print command line is invalid: `%s'\n",
814                                   cmdline);
815                 g_snprintf(buf, sizeof(buf) - 1, def_cmd, prtmp);
816         }
817
818         g_free(prtmp);
819
820         g_strchomp(buf);
821         if (buf[strlen(buf) - 1] != '&') strcat(buf, "&");
822         system(buf);
823 }
824
825 MsgInfo *procmsg_msginfo_new_ref(MsgInfo *msginfo)
826 {
827         msginfo->refcnt++;
828         
829         return msginfo;
830 }
831
832 MsgInfo *procmsg_msginfo_new(void)
833 {
834         MsgInfo *newmsginfo;
835
836         newmsginfo = g_new0(MsgInfo, 1);
837         newmsginfo->refcnt = 1;
838         
839         return newmsginfo;
840 }
841
842 MsgInfo *procmsg_msginfo_copy(MsgInfo *msginfo)
843 {
844         MsgInfo *newmsginfo;
845
846         if (msginfo == NULL) return NULL;
847
848         newmsginfo = g_new0(MsgInfo, 1);
849
850         newmsginfo->refcnt = 1;
851
852 #define MEMBCOPY(mmb)   newmsginfo->mmb = msginfo->mmb
853 #define MEMBDUP(mmb)    newmsginfo->mmb = msginfo->mmb ? \
854                         g_strdup(msginfo->mmb) : NULL
855
856         MEMBCOPY(msgnum);
857         MEMBCOPY(size);
858         MEMBCOPY(mtime);
859         MEMBCOPY(date_t);
860
861         MEMBCOPY(flags);
862
863         MEMBDUP(fromname);
864
865         MEMBDUP(date);
866         MEMBDUP(from);
867         MEMBDUP(to);
868         MEMBDUP(cc);
869         MEMBDUP(newsgroups);
870         MEMBDUP(subject);
871         MEMBDUP(msgid);
872         MEMBDUP(inreplyto);
873         MEMBDUP(xref);
874
875         MEMBCOPY(folder);
876         MEMBCOPY(to_folder);
877
878         MEMBDUP(xface);
879         MEMBDUP(dispositionnotificationto);
880         MEMBDUP(returnreceiptto);
881         MEMBDUP(references);
882
883         MEMBCOPY(score);
884         MEMBCOPY(threadscore);
885         MEMBDUP(plaintext_file);
886
887         return newmsginfo;
888 }
889
890 MsgInfo *procmsg_msginfo_get_full_info(MsgInfo *msginfo)
891 {
892         MsgInfo *full_msginfo;
893         gchar *file;
894
895         if (msginfo == NULL) return NULL;
896
897         file = procmsg_get_message_file(msginfo);
898         if (!file) {
899                 g_warning("procmsg_msginfo_get_full_info(): can't get message file.\n");
900                 return NULL;
901         }
902
903         full_msginfo = procheader_parse_file(file, msginfo->flags, TRUE, FALSE);
904         g_free(file);
905         if (!full_msginfo) return NULL;
906
907         /* CLAWS: make sure we add the missing members; see: 
908          * procheader.c::procheader_get_headernames() */
909         if (!msginfo->xface)
910                 msginfo->xface = g_strdup(full_msginfo->xface);
911         if (!msginfo->dispositionnotificationto)
912                 msginfo->dispositionnotificationto = 
913                         g_strdup(full_msginfo->dispositionnotificationto);
914         if (!msginfo->returnreceiptto)
915                 msginfo->returnreceiptto = g_strdup
916                         (full_msginfo->returnreceiptto);
917         if (!msginfo->partial_recv && full_msginfo->partial_recv)
918                 msginfo->partial_recv = g_strdup
919                         (full_msginfo->partial_recv);
920         msginfo->total_size = full_msginfo->total_size;
921         if (!msginfo->account_server && full_msginfo->account_server)
922                 msginfo->account_server = g_strdup
923                         (full_msginfo->account_server);
924         if (!msginfo->account_login && full_msginfo->account_login)
925                 msginfo->account_login = g_strdup
926                         (full_msginfo->account_login);
927         msginfo->planned_download = full_msginfo->planned_download;
928         procmsg_msginfo_free(full_msginfo);
929
930         return procmsg_msginfo_new_ref(msginfo);
931 }
932
933 void procmsg_msginfo_free(MsgInfo *msginfo)
934 {
935         if (msginfo == NULL) return;
936
937         msginfo->refcnt--;
938         if (msginfo->refcnt > 0)
939                 return;
940
941         if (msginfo->to_folder) {
942                 msginfo->to_folder->op_count--;
943                 folder_item_update(msginfo->to_folder, F_ITEM_UPDATE_MSGCNT);
944         }
945
946         g_free(msginfo->fromspace);
947         g_free(msginfo->references);
948         g_free(msginfo->returnreceiptto);
949         g_free(msginfo->dispositionnotificationto);
950         g_free(msginfo->xface);
951
952         g_free(msginfo->fromname);
953
954         g_free(msginfo->date);
955         g_free(msginfo->from);
956         g_free(msginfo->to);
957         g_free(msginfo->cc);
958         g_free(msginfo->newsgroups);
959         g_free(msginfo->subject);
960         g_free(msginfo->msgid);
961         g_free(msginfo->inreplyto);
962         g_free(msginfo->xref);
963
964         g_free(msginfo->partial_recv);
965         g_free(msginfo->account_server);
966         g_free(msginfo->account_login);
967         
968         g_free(msginfo->plaintext_file);
969
970         g_free(msginfo);
971 }
972
973 guint procmsg_msginfo_memusage(MsgInfo *msginfo)
974 {
975         guint memusage = 0;
976         
977         memusage += sizeof(MsgInfo);
978         if (msginfo->fromname)
979                 memusage += strlen(msginfo->fromname);
980         if (msginfo->date)
981                 memusage += strlen(msginfo->date);
982         if (msginfo->from)
983                 memusage += strlen(msginfo->from);
984         if (msginfo->to)
985                 memusage += strlen(msginfo->to);
986         if (msginfo->cc)
987                 memusage += strlen(msginfo->cc);
988         if (msginfo->newsgroups)
989                 memusage += strlen(msginfo->newsgroups);
990         if (msginfo->subject)
991                 memusage += strlen(msginfo->subject);
992         if (msginfo->msgid)
993                 memusage += strlen(msginfo->msgid);
994         if (msginfo->inreplyto)
995                 memusage += strlen(msginfo->inreplyto);
996         if (msginfo->xface)
997                 memusage += strlen(msginfo->xface);
998         if (msginfo->dispositionnotificationto)
999                 memusage += strlen(msginfo->dispositionnotificationto);
1000         if (msginfo->returnreceiptto)
1001                 memusage += strlen(msginfo->returnreceiptto);
1002         if (msginfo->references)
1003                 memusage += strlen(msginfo->references);
1004         if (msginfo->fromspace)
1005                 memusage += strlen(msginfo->fromspace);
1006
1007         return memusage;
1008 }
1009
1010 gint procmsg_cmp_msgnum_for_sort(gconstpointer a, gconstpointer b)
1011 {
1012         const MsgInfo *msginfo1 = a;
1013         const MsgInfo *msginfo2 = b;
1014
1015         if (!msginfo1)
1016                 return -1;
1017         if (!msginfo2)
1018                 return -1;
1019
1020         return msginfo1->msgnum - msginfo2->msgnum;
1021 }
1022
1023 enum
1024 {
1025         Q_SENDER           = 0,
1026         Q_SMTPSERVER       = 1,
1027         Q_RECIPIENTS       = 2,
1028         Q_NEWSGROUPS       = 3,
1029         Q_MAIL_ACCOUNT_ID  = 4,
1030         Q_NEWS_ACCOUNT_ID  = 5,
1031         Q_SAVE_COPY_FOLDER = 6,
1032         Q_REPLY_MESSAGE_ID = 7,
1033         Q_FWD_MESSAGE_ID   = 8,
1034         Q_PRIVACY_SYSTEM   = 9,
1035         Q_ENCRYPT          = 10,
1036         Q_ENCRYPT_DATA     = 11,
1037 };
1038
1039 gint procmsg_send_message_queue(const gchar *file)
1040 {
1041         static HeaderEntry qentry[] = {{"S:",    NULL, FALSE},
1042                                        {"SSV:",  NULL, FALSE},
1043                                        {"R:",    NULL, FALSE},
1044                                        {"NG:",   NULL, FALSE},
1045                                        {"MAID:", NULL, FALSE},
1046                                        {"NAID:", NULL, FALSE},
1047                                        {"SCF:",  NULL, FALSE},
1048                                        {"RMID:", NULL, FALSE},
1049                                        {"FMID:", NULL, FALSE},
1050                                        {"X-Sylpheed-Privacy-System:", NULL, FALSE},
1051                                        {"X-Sylpheed-Encrypt:", NULL, FALSE},
1052                                        {"X-Sylpheed-Encrypt-Data:", NULL, FALSE},
1053                                        {NULL,    NULL, FALSE}};
1054         FILE *fp;
1055         gint filepos;
1056         gint mailval = 0, newsval = 0;
1057         gchar *from = NULL;
1058         gchar *smtpserver = NULL;
1059         GSList *to_list = NULL;
1060         GSList *newsgroup_list = NULL;
1061         gchar *savecopyfolder = NULL;
1062         gchar *replymessageid = NULL;
1063         gchar *fwdmessageid = NULL;
1064         gchar *privacy_system = NULL;
1065         gboolean encrypt = FALSE;
1066         gchar *encrypt_data = NULL;
1067         gchar buf[BUFFSIZE];
1068         gint hnum;
1069         PrefsAccount *mailac = NULL, *newsac = NULL;
1070         int local = 0;
1071
1072         g_return_val_if_fail(file != NULL, -1);
1073
1074         if ((fp = fopen(file, "rb")) == NULL) {
1075                 FILE_OP_ERROR(file, "fopen");
1076                 return -1;
1077         }
1078
1079         while ((hnum = procheader_get_one_field(buf, sizeof(buf), fp, qentry))
1080                != -1) {
1081                 gchar *p = buf + strlen(qentry[hnum].name);
1082
1083                 switch (hnum) {
1084                 case Q_SENDER:
1085                         if (!from) from = g_strdup(p);
1086                         break;
1087                 case Q_SMTPSERVER:
1088                         if (!smtpserver) smtpserver = g_strdup(p);
1089                         break;
1090                 case Q_RECIPIENTS:
1091                         to_list = address_list_append(to_list, p);
1092                         break;
1093                 case Q_NEWSGROUPS:
1094                         newsgroup_list = newsgroup_list_append(newsgroup_list, p);
1095                         break;
1096                 case Q_MAIL_ACCOUNT_ID:
1097                         mailac = account_find_from_id(atoi(p));
1098                         break;
1099                 case Q_NEWS_ACCOUNT_ID:
1100                         newsac = account_find_from_id(atoi(p));
1101                         break;
1102                 case Q_SAVE_COPY_FOLDER:
1103                         if (!savecopyfolder) savecopyfolder = g_strdup(p);
1104                         break;
1105                 case Q_REPLY_MESSAGE_ID:
1106                         if (!replymessageid) replymessageid = g_strdup(p);
1107                         break;
1108                 case Q_FWD_MESSAGE_ID:
1109                         if (!fwdmessageid) fwdmessageid = g_strdup(p);
1110                         break;
1111                 case Q_PRIVACY_SYSTEM:
1112                         if (!privacy_system) privacy_system = g_strdup(p);
1113                         break;
1114                 case Q_ENCRYPT:
1115                         if (p[0] == '1') encrypt = TRUE;
1116                         break;
1117                 case Q_ENCRYPT_DATA:
1118                         if (!encrypt_data) encrypt_data = g_strdup(p);
1119                         break;
1120                 }
1121         }
1122         filepos = ftell(fp);
1123
1124         if (encrypt) {
1125                 MimeInfo *mimeinfo;
1126
1127                 fclose(fp);
1128                 
1129                 mimeinfo = procmime_scan_queue_file(file);
1130                 if (!privacy_encrypt(privacy_system, mimeinfo, encrypt_data)
1131                 || (fp = my_tmpfile()) == NULL
1132                 ||  procmime_write_mimeinfo(mimeinfo, fp) < 0) {
1133                         if (fp)
1134                                 fclose(fp);
1135                         procmime_mimeinfo_free_all(mimeinfo);
1136                         g_free(from);
1137                         g_free(smtpserver);
1138                         slist_free_strings(to_list);
1139                         g_slist_free(to_list);
1140                         slist_free_strings(newsgroup_list);
1141                         g_slist_free(newsgroup_list);
1142                         g_free(savecopyfolder);
1143                         g_free(replymessageid);
1144                         g_free(fwdmessageid);
1145                         g_free(privacy_system);
1146                         g_free(encrypt_data);
1147                         return -1;
1148                 }
1149                 
1150                 procmime_mimeinfo_free_all(mimeinfo);
1151                 rewind(fp);
1152                 filepos = 0;
1153         }
1154
1155         if (to_list) {
1156                 debug_print("Sending message by mail\n");
1157                 if (!from) {
1158                         g_warning("Queued message header is broken.\n");
1159                         mailval = -1;
1160                 } else if (mailac && mailac->use_mail_command &&
1161                            mailac->mail_command && (* mailac->mail_command)) {
1162                         mailval = send_message_local(mailac->mail_command, fp);
1163                         local = 1;
1164                 } else {
1165                         if (!mailac) {
1166                                 mailac = account_find_from_smtp_server(from, smtpserver);
1167                                 if (!mailac) {
1168                                         g_warning("Account not found. "
1169                                                     "Using current account...\n");
1170                                         mailac = cur_account;
1171                                 }
1172                         }
1173
1174                         if (mailac)
1175                                 mailval = send_message_smtp(mailac, to_list, fp);
1176                         else {
1177                                 PrefsAccount tmp_ac;
1178
1179                                 g_warning("Account not found.\n");
1180
1181                                 memset(&tmp_ac, 0, sizeof(PrefsAccount));
1182                                 tmp_ac.address = from;
1183                                 tmp_ac.smtp_server = smtpserver;
1184                                 tmp_ac.smtpport = SMTP_PORT;
1185                                 mailval = send_message_smtp(&tmp_ac, to_list, fp);
1186                         }
1187                 }
1188         }
1189
1190         fseek(fp, filepos, SEEK_SET);
1191         if (newsgroup_list && (mailval == 0)) {
1192                 Folder *folder;
1193                 gchar *tmp = NULL;
1194                 FILE *tmpfp;
1195
1196                 /* write to temporary file */
1197                 tmp = g_strdup_printf("%s%ctmp%d", g_get_tmp_dir(),
1198                             G_DIR_SEPARATOR, (gint)file);
1199                 if ((tmpfp = fopen(tmp, "wb")) == NULL) {
1200                         FILE_OP_ERROR(tmp, "fopen");
1201                         newsval = -1;
1202                         alertpanel_error(_("Could not create temporary file for news sending."));
1203                 } else {
1204                         if (change_file_mode_rw(tmpfp, tmp) < 0) {
1205                                 FILE_OP_ERROR(tmp, "chmod");
1206                                 g_warning("can't change file mode\n");
1207                         }
1208
1209                         while ((newsval == 0) && fgets(buf, sizeof(buf), fp) != NULL) {
1210                                 if (fputs(buf, tmpfp) == EOF) {
1211                                         FILE_OP_ERROR(tmp, "fputs");
1212                                         newsval = -1;
1213                                         alertpanel_error(_("Error when writing temporary file for news sending."));
1214                                 }
1215                         }
1216                         fclose(tmpfp);
1217
1218                         if (newsval == 0) {
1219                                 debug_print("Sending message by news\n");
1220
1221                                 folder = FOLDER(newsac->folder);
1222
1223                                 newsval = news_post(folder, tmp);
1224                                 if (newsval < 0) {
1225                                         alertpanel_error(_("Error occurred while posting the message to %s ."),
1226                                                  newsac->nntp_server);
1227                                 }
1228                         }
1229                         unlink(tmp);
1230                 }
1231                 g_free(tmp);
1232         }
1233
1234         fclose(fp);
1235
1236         /* save message to outbox */
1237         if (mailval == 0 && newsval == 0 && savecopyfolder) {
1238                 FolderItem *outbox;
1239
1240                 debug_print("saving sent message...\n");
1241
1242                 outbox = folder_find_item_from_identifier(savecopyfolder);
1243                 if (!outbox)
1244                         outbox = folder_get_default_outbox();
1245
1246                 procmsg_save_to_outbox(outbox, file, TRUE);
1247         }
1248
1249         if (replymessageid != NULL || fwdmessageid != NULL) {
1250                 gchar **tokens;
1251                 FolderItem *item;
1252                 
1253                 if (replymessageid != NULL)
1254                         tokens = g_strsplit(replymessageid, "\x7f", 0);
1255                 else
1256                         tokens = g_strsplit(fwdmessageid, "\x7f", 0);
1257                 item = folder_find_item_from_identifier(tokens[0]);
1258
1259                 /* check if queued message has valid folder and message id */
1260                 if (item != NULL && tokens[2] != NULL) {
1261                         MsgInfo *msginfo;
1262                         
1263                         msginfo = folder_item_get_msginfo(item, atoi(tokens[1]));
1264                 
1265                         /* check if referring message exists and has a message id */
1266                         if ((msginfo != NULL) && 
1267                             (msginfo->msgid != NULL) &&
1268                             (strcmp(msginfo->msgid, tokens[2]) != 0)) {
1269                                 procmsg_msginfo_free(msginfo);
1270                                 msginfo = NULL;
1271                         }
1272                         
1273                         if (msginfo == NULL) {
1274                                 msginfo = folder_item_get_msginfo_by_msgid(item, tokens[2]);
1275                         }
1276                         
1277                         if (msginfo != NULL) {
1278                                 if (replymessageid != NULL) {
1279                                         procmsg_msginfo_unset_flags(msginfo, MSG_FORWARDED, 0);
1280                                         procmsg_msginfo_set_flags(msginfo, MSG_REPLIED, 0);
1281                                 }  else {
1282                                         procmsg_msginfo_unset_flags(msginfo, MSG_REPLIED, 0);
1283                                         procmsg_msginfo_set_flags(msginfo, MSG_FORWARDED, 0);
1284                                 }
1285                                 procmsg_msginfo_free(msginfo);
1286                         }
1287                 }
1288                 g_strfreev(tokens);
1289         }
1290
1291         g_free(from);
1292         g_free(smtpserver);
1293         slist_free_strings(to_list);
1294         g_slist_free(to_list);
1295         slist_free_strings(newsgroup_list);
1296         g_slist_free(newsgroup_list);
1297         g_free(savecopyfolder);
1298         g_free(replymessageid);
1299         g_free(fwdmessageid);
1300         g_free(privacy_system);
1301         g_free(encrypt_data);
1302
1303         return (newsval != 0 ? newsval : mailval);
1304 }
1305
1306 static void update_folder_msg_counts(FolderItem *item, MsgInfo *msginfo, MsgPermFlags old_flags)
1307 {
1308         MsgPermFlags new_flags = msginfo->flags.perm_flags;
1309
1310         /* NEW flag */
1311         if (!(old_flags & MSG_NEW) && (new_flags & MSG_NEW)) {
1312                 item->new_msgs++;
1313         }
1314
1315         if ((old_flags & MSG_NEW) && !(new_flags & MSG_NEW)) {
1316                 item->new_msgs--;
1317         }
1318
1319         /* UNREAD flag */
1320         if (!(old_flags & MSG_UNREAD) && (new_flags & MSG_UNREAD)) {
1321                 item->unread_msgs++;
1322                 if (procmsg_msg_has_marked_parent(msginfo))
1323                         item->unreadmarked_msgs++;
1324         }
1325
1326         if ((old_flags & MSG_UNREAD) && !(new_flags & MSG_UNREAD)) {
1327                 item->unread_msgs--;
1328                 if (procmsg_msg_has_marked_parent(msginfo))
1329                         item->unreadmarked_msgs--;
1330         }
1331         
1332         /* MARK flag */
1333         if (!(old_flags & MSG_MARKED) && (new_flags & MSG_MARKED)) {
1334                 procmsg_update_unread_children(msginfo, TRUE);
1335         }
1336
1337         if ((old_flags & MSG_MARKED) && !(new_flags & MSG_MARKED)) {
1338                 procmsg_update_unread_children(msginfo, FALSE);
1339         }
1340 }
1341
1342 void procmsg_msginfo_set_flags(MsgInfo *msginfo, MsgPermFlags perm_flags, MsgTmpFlags tmp_flags)
1343 {
1344         FolderItem *item;
1345         MsgInfoUpdate msginfo_update;
1346         MsgPermFlags perm_flags_new, perm_flags_old;
1347         MsgTmpFlags tmp_flags_old;
1348
1349         g_return_if_fail(msginfo != NULL);
1350         item = msginfo->folder;
1351         g_return_if_fail(item != NULL);
1352         
1353         debug_print("Setting flags for message %d in folder %s\n", msginfo->msgnum, item->path);
1354
1355         /* Perm Flags handling */
1356         perm_flags_old = msginfo->flags.perm_flags;
1357         perm_flags_new = msginfo->flags.perm_flags | perm_flags;
1358         if ((perm_flags & MSG_IGNORE_THREAD) || (perm_flags_old & MSG_IGNORE_THREAD)) {
1359                 perm_flags_new &= ~(MSG_NEW | MSG_UNREAD);
1360         }
1361
1362         if (perm_flags_old != perm_flags_new) {
1363                 folder_item_change_msg_flags(msginfo->folder, msginfo, perm_flags_new);
1364
1365                 update_folder_msg_counts(item, msginfo, perm_flags_old);
1366
1367         }
1368
1369         /* Tmp flags handling */
1370         tmp_flags_old = msginfo->flags.tmp_flags;
1371         msginfo->flags.tmp_flags |= tmp_flags;
1372
1373         /* update notification */
1374         if ((perm_flags_old != perm_flags_new) || (tmp_flags_old != msginfo->flags.tmp_flags)) {
1375                 msginfo_update.msginfo = msginfo;
1376                 msginfo_update.flags = MSGINFO_UPDATE_FLAGS;
1377                 hooks_invoke(MSGINFO_UPDATE_HOOKLIST, &msginfo_update);
1378                 folder_item_update(msginfo->folder, F_ITEM_UPDATE_MSGCNT);
1379         }
1380 }
1381
1382 void procmsg_msginfo_unset_flags(MsgInfo *msginfo, MsgPermFlags perm_flags, MsgTmpFlags tmp_flags)
1383 {
1384         FolderItem *item;
1385         MsgInfoUpdate msginfo_update;
1386         MsgPermFlags perm_flags_new, perm_flags_old;
1387         MsgTmpFlags tmp_flags_old;
1388
1389         g_return_if_fail(msginfo != NULL);
1390         item = msginfo->folder;
1391         g_return_if_fail(item != NULL);
1392         
1393         debug_print("Unsetting flags for message %d in folder %s\n", msginfo->msgnum, item->path);
1394
1395         /* Perm Flags handling */
1396         perm_flags_old = msginfo->flags.perm_flags;
1397         perm_flags_new = msginfo->flags.perm_flags & ~perm_flags;
1398         
1399         if (perm_flags_old != perm_flags_new) {
1400                 folder_item_change_msg_flags(msginfo->folder, msginfo, perm_flags_new);
1401
1402                 update_folder_msg_counts(item, msginfo, perm_flags_old);
1403
1404                 msginfo_update.msginfo = msginfo;
1405                 msginfo_update.flags = MSGINFO_UPDATE_FLAGS;
1406                 hooks_invoke(MSGINFO_UPDATE_HOOKLIST, &msginfo_update);
1407                 folder_item_update(msginfo->folder, F_ITEM_UPDATE_MSGCNT);
1408         }
1409
1410         /* Tmp flags hanlding */
1411         tmp_flags_old = msginfo->flags.tmp_flags;
1412         msginfo->flags.tmp_flags &= ~tmp_flags;
1413
1414         /* update notification */
1415         if ((perm_flags_old != perm_flags_new) || (tmp_flags_old != msginfo->flags.tmp_flags)) {
1416                 msginfo_update.msginfo = msginfo;
1417                 msginfo_update.flags = MSGINFO_UPDATE_FLAGS;
1418                 hooks_invoke(MSGINFO_UPDATE_HOOKLIST, &msginfo_update);
1419                 folder_item_update(msginfo->folder, F_ITEM_UPDATE_MSGCNT);
1420         }
1421 }
1422
1423 /*!
1424  *\brief        check for flags (e.g. mark) in prior msgs of current thread
1425  *
1426  *\param        info Current message
1427  *\param        perm_flags Flags to be checked
1428  *\param        parentmsgs Hash of prior msgs to avoid loops
1429  *
1430  *\return       gboolean TRUE if perm_flags are found
1431  */
1432 gboolean procmsg_msg_has_flagged_parent_real(MsgInfo *info,
1433                 MsgPermFlags perm_flags, GHashTable *parentmsgs)
1434 {
1435         MsgInfo *tmp;
1436
1437         g_return_val_if_fail(info != NULL, FALSE);
1438
1439         if (info != NULL && info->folder != NULL && info->inreplyto != NULL) {
1440                 tmp = folder_item_get_msginfo_by_msgid(info->folder,
1441                                 info->inreplyto);
1442                 if (tmp && (tmp->flags.perm_flags & perm_flags)) {
1443                         procmsg_msginfo_free(tmp);
1444                         return TRUE;
1445                 } else if (tmp != NULL) {
1446                         gboolean result;
1447
1448                         if (g_hash_table_lookup(parentmsgs, info)) {
1449                                 debug_print("loop detected: %s%c%d\n",
1450                                         folder_item_get_path(info->folder),
1451                                         G_DIR_SEPARATOR, info->msgnum);
1452                                 result = FALSE;
1453                         } else {
1454                                 g_hash_table_insert(parentmsgs, info, "1");
1455                                 result = procmsg_msg_has_flagged_parent_real(
1456                                     tmp, perm_flags, parentmsgs);
1457                         }
1458                         procmsg_msginfo_free(tmp);
1459                         return result;
1460                 } else {
1461                         return FALSE;
1462                 }
1463         } else
1464                 return FALSE;
1465 }
1466
1467 /*!
1468  *\brief        Callback for cleaning up hash of parentmsgs
1469  */
1470 gboolean parentmsgs_hash_remove(gpointer key,
1471                             gpointer value,
1472                             gpointer user_data)
1473 {
1474         return TRUE;
1475 }
1476
1477 /*!
1478  *\brief        Set up list of parentmsgs
1479  *              See procmsg_msg_has_flagged_parent_real()
1480  */
1481 gboolean procmsg_msg_has_flagged_parent(MsgInfo *info, MsgPermFlags perm_flags)
1482 {
1483         gboolean result;
1484         GHashTable *parentmsgs = g_hash_table_new(NULL, NULL); 
1485
1486         result = procmsg_msg_has_flagged_parent_real(info, perm_flags, parentmsgs);
1487         g_hash_table_foreach_remove(parentmsgs, parentmsgs_hash_remove, NULL);
1488         g_hash_table_destroy(parentmsgs);
1489         return result;
1490 }
1491
1492 /*!
1493  *\brief        Check if msgs prior in thread are marked
1494  *              See procmsg_msg_has_flagged_parent_real()
1495  */
1496 gboolean procmsg_msg_has_marked_parent(MsgInfo *info)
1497 {
1498         return procmsg_msg_has_flagged_parent(info, MSG_MARKED);
1499 }
1500
1501
1502 GSList *procmsg_find_children_func(MsgInfo *info, 
1503                                    GSList *children, GSList *all)
1504 {
1505         GSList *cur;
1506
1507         g_return_val_if_fail(info!=NULL, children);
1508         if (info->msgid == NULL)
1509                 return children;
1510
1511         for (cur = all; cur != NULL; cur = g_slist_next(cur)) {
1512                 MsgInfo *tmp = (MsgInfo *)cur->data;
1513                 if (tmp->inreplyto && !strcmp(tmp->inreplyto, info->msgid)) {
1514                         /* Check if message is already in the list */
1515                         if ((children == NULL) || 
1516                             (g_slist_index(children, tmp) == -1)) {
1517                                 children = g_slist_prepend(children,
1518                                                 procmsg_msginfo_new_ref(tmp));
1519                                 children = procmsg_find_children_func(tmp, 
1520                                                         children, 
1521                                                         all);
1522                         }
1523                 }
1524         }
1525         return children;
1526 }
1527
1528 GSList *procmsg_find_children (MsgInfo *info)
1529 {
1530         GSList *children;
1531         GSList *all, *cur;
1532
1533         g_return_val_if_fail(info!=NULL, NULL);
1534         all = folder_item_get_msg_list(info->folder);
1535         children = procmsg_find_children_func(info, NULL, all);
1536         if (children != NULL) {
1537                 for (cur = all; cur != NULL; cur = g_slist_next(cur)) {
1538                         /* this will not free the used pointers
1539                            created with procmsg_msginfo_new_ref */
1540                         procmsg_msginfo_free((MsgInfo *)cur->data);
1541                 }
1542         }
1543         g_slist_free(all);
1544
1545         return children;
1546 }
1547
1548 void procmsg_update_unread_children(MsgInfo *info, gboolean newly_marked)
1549 {
1550         GSList *children = procmsg_find_children(info);
1551         GSList *cur;
1552         for (cur = children; cur != NULL; cur = g_slist_next(cur)) {
1553                 MsgInfo *tmp = (MsgInfo *)cur->data;
1554                 if(MSG_IS_UNREAD(tmp->flags) && !MSG_IS_IGNORE_THREAD(tmp->flags)) {
1555                         if(newly_marked) 
1556                                 info->folder->unreadmarked_msgs++;
1557                         else
1558                                 info->folder->unreadmarked_msgs--;
1559                         folder_item_update(info->folder, F_ITEM_UPDATE_MSGCNT);
1560                 }
1561                 procmsg_msginfo_free(tmp);
1562         }
1563         g_slist_free(children);
1564 }
1565
1566 /**
1567  * Set the destination folder for a copy or move operation
1568  *
1569  * \param msginfo The message which's destination folder is changed
1570  * \param to_folder The destination folder for the operation
1571  */
1572 void procmsg_msginfo_set_to_folder(MsgInfo *msginfo, FolderItem *to_folder)
1573 {
1574         if(msginfo->to_folder != NULL) {
1575                 msginfo->to_folder->op_count--;
1576                 folder_item_update(msginfo->to_folder, F_ITEM_UPDATE_MSGCNT);
1577         }
1578         msginfo->to_folder = to_folder;
1579         if(to_folder != NULL) {
1580                 to_folder->op_count++;
1581                 folder_item_update(msginfo->to_folder, F_ITEM_UPDATE_MSGCNT);
1582         }
1583 }
1584
1585 /**
1586  * Apply filtering actions to the msginfo
1587  *
1588  * \param msginfo The MsgInfo describing the message that should be filtered
1589  * \return TRUE if the message was moved and MsgInfo is now invalid,
1590  *         FALSE otherwise
1591  */
1592 gboolean procmsg_msginfo_filter(MsgInfo *msginfo)
1593 {
1594         MailFilteringData mail_filtering_data;
1595                         
1596         mail_filtering_data.msginfo = msginfo;                  
1597         if (hooks_invoke(MAIL_FILTERING_HOOKLIST, &mail_filtering_data))
1598                 return TRUE;
1599
1600         /* filter if enabled in prefs or move to inbox if not */
1601         if((filtering_rules != NULL) &&
1602            filter_message_by_msginfo(filtering_rules, msginfo))
1603                 return TRUE;
1604
1605         return FALSE;
1606 }