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