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