11180f2b4033553b48e19fa7afe54e4a6f5903a2
[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
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         folder_item_update_freeze();
663
664         for (cur = mlist; cur != NULL; cur = cur->next) {
665                 msginfo = (MsgInfo *)cur->data;
666                 if (!dest) {
667                         dest = msginfo->to_folder;
668                         movelist = g_slist_append(movelist, msginfo);
669                 } else if (dest == msginfo->to_folder) {
670                         movelist = g_slist_append(movelist, msginfo);
671                 } else {
672                         folder_item_move_msgs_with_dest(dest, movelist);
673                         g_slist_free(movelist);
674                         movelist = NULL;
675                         dest = msginfo->to_folder;
676                         movelist = g_slist_append(movelist, msginfo);
677                 }
678                 procmsg_msginfo_set_to_folder(msginfo, NULL);
679         }
680
681         if (movelist) {
682                 folder_item_move_msgs_with_dest(dest, movelist);
683                 g_slist_free(movelist);
684         }
685
686         folder_item_update_thaw();
687 }
688
689 void procmsg_copy_messages(GSList *mlist)
690 {
691         GSList *cur, *copylist = NULL;
692         MsgInfo *msginfo;
693         FolderItem *dest = NULL;
694
695         if (!mlist) return;
696
697         folder_item_update_freeze();
698
699         for (cur = mlist; cur != NULL; cur = cur->next) {
700                 msginfo = (MsgInfo *)cur->data;
701                 if (!dest) {
702                         dest = msginfo->to_folder;
703                         copylist = g_slist_append(copylist, msginfo);
704                 } else if (dest == msginfo->to_folder) {
705                         copylist = g_slist_append(copylist, msginfo);
706                 } else {
707                         folder_item_copy_msgs_with_dest(dest, copylist);
708                         g_slist_free(copylist);
709                         copylist = NULL;
710                         dest = msginfo->to_folder;
711                         copylist = g_slist_append(copylist, msginfo);
712                 }
713                 procmsg_msginfo_set_to_folder(msginfo, NULL);
714         }
715
716         if (copylist) {
717                 folder_item_copy_msgs_with_dest(dest, copylist);
718                 g_slist_free(copylist);
719         }
720
721         folder_item_update_thaw();
722 }
723
724 gchar *procmsg_get_message_file_path(MsgInfo *msginfo)
725 {
726         gchar *path, *file;
727
728         g_return_val_if_fail(msginfo != NULL, NULL);
729
730         if (msginfo->plaintext_file)
731                 file = g_strdup(msginfo->plaintext_file);
732         else {
733                 path = folder_item_get_path(msginfo->folder);
734                 file = g_strconcat(path, G_DIR_SEPARATOR_S,
735                                    itos(msginfo->msgnum), NULL);
736                 g_free(path);
737         }
738
739         return file;
740 }
741
742 gchar *procmsg_get_message_file(MsgInfo *msginfo)
743 {
744         gchar *filename = NULL;
745
746         g_return_val_if_fail(msginfo != NULL, NULL);
747
748         filename = folder_item_fetch_msg(msginfo->folder, msginfo->msgnum);
749         if (!filename)
750                 g_warning("can't fetch message %d\n", msginfo->msgnum);
751
752         return filename;
753 }
754
755 FILE *procmsg_open_message(MsgInfo *msginfo)
756 {
757         FILE *fp;
758         gchar *file;
759
760         g_return_val_if_fail(msginfo != NULL, NULL);
761
762         file = procmsg_get_message_file_path(msginfo);
763         g_return_val_if_fail(file != NULL, NULL);
764
765         if (!is_file_exist(file)) {
766                 g_free(file);
767                 file = procmsg_get_message_file(msginfo);
768                 g_return_val_if_fail(file != NULL, NULL);
769         }
770
771         if ((fp = fopen(file, "rb")) == NULL) {
772                 FILE_OP_ERROR(file, "fopen");
773                 g_free(file);
774                 return NULL;
775         }
776
777         g_free(file);
778
779         if (MSG_IS_QUEUED(msginfo->flags) || MSG_IS_DRAFT(msginfo->flags)) {
780                 gchar buf[BUFFSIZE];
781
782                 while (fgets(buf, sizeof(buf), fp) != NULL)
783                         if (buf[0] == '\r' || buf[0] == '\n') break;
784         }
785
786         return fp;
787 }
788
789 #if USE_GPGME
790 FILE *procmsg_open_message_decrypted(MsgInfo *msginfo, MimeInfo **mimeinfo)
791 {
792         FILE *fp;
793         MimeInfo *mimeinfo_;
794
795         g_return_val_if_fail(msginfo != NULL, NULL);
796
797         if (mimeinfo) *mimeinfo = NULL;
798
799         if ((fp = procmsg_open_message(msginfo)) == NULL) return NULL;
800
801         mimeinfo_ = procmime_scan_mime_header(fp);
802         if (!mimeinfo_) {
803                 fclose(fp);
804                 return NULL;
805         }
806
807         if (!MSG_IS_ENCRYPTED(msginfo->flags) &&
808             rfc2015_is_encrypted(mimeinfo_)) {
809                 MSG_SET_TMP_FLAGS(msginfo->flags, MSG_ENCRYPTED);
810         }
811
812         if (MSG_IS_ENCRYPTED(msginfo->flags) &&
813             (!msginfo->plaintext_file || 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 #if USE_GPGME
1118         full_msginfo->plaintext_file = g_strdup(msginfo->plaintext_file);
1119         full_msginfo->decryption_failed = msginfo->decryption_failed;
1120 #endif
1121         procmsg_msginfo_set_to_folder(full_msginfo, msginfo->to_folder);
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         if (msginfo->to_folder) {
1135                 msginfo->to_folder->op_count--;
1136                 folder_item_update(msginfo->to_folder, F_ITEM_UPDATE_MSGCNT);
1137         }
1138
1139         g_free(msginfo->fromspace);
1140         g_free(msginfo->references);
1141         g_free(msginfo->returnreceiptto);
1142         g_free(msginfo->dispositionnotificationto);
1143         g_free(msginfo->xface);
1144
1145         g_free(msginfo->fromname);
1146
1147         g_free(msginfo->date);
1148         g_free(msginfo->from);
1149         g_free(msginfo->to);
1150         g_free(msginfo->cc);
1151         g_free(msginfo->newsgroups);
1152         g_free(msginfo->subject);
1153         g_free(msginfo->msgid);
1154         g_free(msginfo->inreplyto);
1155         g_free(msginfo->xref);
1156
1157         g_free(msginfo);
1158 }
1159
1160 guint procmsg_msginfo_memusage(MsgInfo *msginfo)
1161 {
1162         guint memusage = 0;
1163         
1164         memusage += sizeof(MsgInfo);
1165         if (msginfo->fromname)
1166                 memusage += strlen(msginfo->fromname);
1167         if (msginfo->date)
1168                 memusage += strlen(msginfo->date);
1169         if (msginfo->from)
1170                 memusage += strlen(msginfo->from);
1171         if (msginfo->to)
1172                 memusage += strlen(msginfo->to);
1173         if (msginfo->cc)
1174                 memusage += strlen(msginfo->cc);
1175         if (msginfo->newsgroups)
1176                 memusage += strlen(msginfo->newsgroups);
1177         if (msginfo->subject)
1178                 memusage += strlen(msginfo->subject);
1179         if (msginfo->msgid)
1180                 memusage += strlen(msginfo->msgid);
1181         if (msginfo->inreplyto)
1182                 memusage += strlen(msginfo->inreplyto);
1183         if (msginfo->xface)
1184                 memusage += strlen(msginfo->xface);
1185         if (msginfo->dispositionnotificationto)
1186                 memusage += strlen(msginfo->dispositionnotificationto);
1187         if (msginfo->returnreceiptto)
1188                 memusage += strlen(msginfo->returnreceiptto);
1189         if (msginfo->references)
1190                 memusage += strlen(msginfo->references);
1191         if (msginfo->fromspace)
1192                 memusage += strlen(msginfo->fromspace);
1193
1194         return memusage;
1195 }
1196
1197 gint procmsg_cmp_msgnum_for_sort(gconstpointer a, gconstpointer b)
1198 {
1199         const MsgInfo *msginfo1 = a;
1200         const MsgInfo *msginfo2 = b;
1201
1202         if (!msginfo1)
1203                 return -1;
1204         if (!msginfo2)
1205                 return -1;
1206
1207         return msginfo1->msgnum - msginfo2->msgnum;
1208 }
1209
1210 enum
1211 {
1212         Q_SENDER           = 0,
1213         Q_SMTPSERVER       = 1,
1214         Q_RECIPIENTS       = 2,
1215         Q_NEWSGROUPS       = 3,
1216         Q_MAIL_ACCOUNT_ID  = 4,
1217         Q_NEWS_ACCOUNT_ID  = 5,
1218         Q_SAVE_COPY_FOLDER = 6,
1219         Q_REPLY_MESSAGE_ID = 7,
1220         Q_FWD_MESSAGE_ID   = 8
1221 };
1222
1223 gint procmsg_send_message_queue(const gchar *file)
1224 {
1225         static HeaderEntry qentry[] = {{"S:",    NULL, FALSE},
1226                                        {"SSV:",  NULL, FALSE},
1227                                        {"R:",    NULL, FALSE},
1228                                        {"NG:",   NULL, FALSE},
1229                                        {"MAID:", NULL, FALSE},
1230                                        {"NAID:", NULL, FALSE},
1231                                        {"SCF:",  NULL, FALSE},
1232                                        {"RMID:", NULL, FALSE},
1233                                        {"FMID:", NULL, FALSE},
1234                                        {NULL,    NULL, FALSE}};
1235         FILE *fp;
1236         gint filepos;
1237         gint mailval = 0, newsval = 0;
1238         gchar *from = NULL;
1239         gchar *smtpserver = NULL;
1240         GSList *to_list = NULL;
1241         GSList *newsgroup_list = NULL;
1242         gchar *savecopyfolder = NULL;
1243         gchar *replymessageid = NULL;
1244         gchar *fwdmessageid = NULL;
1245         gchar buf[BUFFSIZE];
1246         gint hnum;
1247         PrefsAccount *mailac = NULL, *newsac = NULL;
1248         int local = 0;
1249
1250         g_return_val_if_fail(file != NULL, -1);
1251
1252         if ((fp = fopen(file, "rb")) == NULL) {
1253                 FILE_OP_ERROR(file, "fopen");
1254                 return -1;
1255         }
1256
1257         while ((hnum = procheader_get_one_field(buf, sizeof(buf), fp, qentry))
1258                != -1) {
1259                 gchar *p = buf + strlen(qentry[hnum].name);
1260
1261                 switch (hnum) {
1262                 case Q_SENDER:
1263                         if (!from) from = g_strdup(p);
1264                         break;
1265                 case Q_SMTPSERVER:
1266                         if (!smtpserver) smtpserver = g_strdup(p);
1267                         break;
1268                 case Q_RECIPIENTS:
1269                         to_list = address_list_append(to_list, p);
1270                         break;
1271                 case Q_NEWSGROUPS:
1272                         newsgroup_list = newsgroup_list_append(newsgroup_list, p);
1273                         break;
1274                 case Q_MAIL_ACCOUNT_ID:
1275                         mailac = account_find_from_id(atoi(p));
1276                         break;
1277                 case Q_NEWS_ACCOUNT_ID:
1278                         newsac = account_find_from_id(atoi(p));
1279                         break;
1280                 case Q_SAVE_COPY_FOLDER:
1281                         if (!savecopyfolder) savecopyfolder = g_strdup(p);
1282                         break;
1283                 case Q_REPLY_MESSAGE_ID:
1284                         if (!replymessageid) replymessageid = g_strdup(p);
1285                         break;
1286                 case Q_FWD_MESSAGE_ID:
1287                         if (!fwdmessageid) fwdmessageid = g_strdup(p);
1288                         break;
1289                 }
1290         }
1291         filepos = ftell(fp);
1292
1293         if (to_list) {
1294                 debug_print("Sending message by mail\n");
1295                 if (!from) {
1296                         g_warning("Queued message header is broken.\n");
1297                         mailval = -1;
1298                 } else if (mailac && mailac->use_mail_command &&
1299                            mailac->mail_command && (* mailac->mail_command)) {
1300                         mailval = send_message_local(mailac->mail_command, fp);
1301                         local = 1;
1302                 } else if (prefs_common.use_extsend && prefs_common.extsend_cmd) {
1303                         mailval = send_message_local(prefs_common.extsend_cmd, fp);
1304                         local = 1;
1305                 } else {
1306                         if (!mailac) {
1307                                 mailac = account_find_from_smtp_server(from, smtpserver);
1308                                 if (!mailac) {
1309                                         g_warning("Account not found. "
1310                                                     "Using current account...\n");
1311                                         mailac = cur_account;
1312                                 }
1313                         }
1314
1315                         if (mailac)
1316                                 mailval = send_message_smtp(mailac, to_list, fp);
1317                         else {
1318                                 PrefsAccount tmp_ac;
1319
1320                                 g_warning("Account not found.\n");
1321
1322                                 memset(&tmp_ac, 0, sizeof(PrefsAccount));
1323                                 tmp_ac.address = from;
1324                                 tmp_ac.smtp_server = smtpserver;
1325                                 tmp_ac.smtpport = SMTP_PORT;
1326                                 mailval = send_message_smtp(&tmp_ac, to_list, fp);
1327                         }
1328                 }
1329                 if (mailval < 0) {
1330                         if (!local)
1331                                 alertpanel_error_log(
1332                                         _("Error occurred while sending the message to `%s'."),
1333                                         mailac ? mailac->smtp_server : smtpserver);
1334                         else
1335                                 alertpanel_error_log(
1336                                         _("Error occurred while sending the message with command `%s'."),
1337                                         (mailac && mailac->use_mail_command && 
1338                                          mailac->mail_command && (*mailac->mail_command)) ? 
1339                                                 mailac->mail_command : prefs_common.extsend_cmd);
1340                 }
1341         }
1342
1343         fseek(fp, filepos, SEEK_SET);
1344         if (newsgroup_list && (newsval == 0)) {
1345                 Folder *folder;
1346                 gchar *tmp = NULL;
1347                 FILE *tmpfp;
1348
1349                 /* write to temporary file */
1350                 tmp = g_strdup_printf("%s%ctmp%d", g_get_tmp_dir(),
1351                             G_DIR_SEPARATOR, (gint)file);
1352                 if ((tmpfp = fopen(tmp, "wb")) == NULL) {
1353                         FILE_OP_ERROR(tmp, "fopen");
1354                         newsval = -1;
1355                         alertpanel_error(_("Could not create temporary file for news sending."));
1356                 } else {
1357                         if (change_file_mode_rw(tmpfp, tmp) < 0) {
1358                                 FILE_OP_ERROR(tmp, "chmod");
1359                                 g_warning("can't change file mode\n");
1360                         }
1361
1362                         while ((newsval == 0) && fgets(buf, sizeof(buf), fp) != NULL) {
1363                                 if (fputs(buf, tmpfp) == EOF) {
1364                                         FILE_OP_ERROR(tmp, "fputs");
1365                                         newsval = -1;
1366                                         alertpanel_error(_("Error when writing temporary file for news sending."));
1367                                 }
1368                         }
1369                         fclose(tmpfp);
1370
1371                         if (newsval == 0) {
1372                                 debug_print("Sending message by news\n");
1373
1374                                 folder = FOLDER(newsac->folder);
1375
1376                                 newsval = news_post(folder, tmp);
1377                                 if (newsval < 0) {
1378                                         alertpanel_error(_("Error occurred while posting the message to %s ."),
1379                                                  newsac->nntp_server);
1380                                 }
1381                         }
1382                         unlink(tmp);
1383                 }
1384                 g_free(tmp);
1385         }
1386
1387         slist_free_strings(to_list);
1388         g_slist_free(to_list);
1389         slist_free_strings(newsgroup_list);
1390         g_slist_free(newsgroup_list);
1391         g_free(from);
1392         g_free(smtpserver);
1393         fclose(fp);
1394
1395         /* save message to outbox */
1396         if (mailval == 0 && newsval == 0 && savecopyfolder) {
1397                 FolderItem *outbox;
1398
1399                 debug_print("saving sent message...\n");
1400
1401                 outbox = folder_find_item_from_identifier(savecopyfolder);
1402                 if (!outbox)
1403                         outbox = folder_get_default_outbox();
1404
1405                 procmsg_save_to_outbox(outbox, file, TRUE);
1406         }
1407
1408         if (replymessageid != NULL || fwdmessageid != NULL) {
1409                 gchar **tokens;
1410                 FolderItem *item;
1411                 
1412                 if (replymessageid != NULL)
1413                         tokens = g_strsplit(replymessageid, "\x7f", 0);
1414                 else
1415                         tokens = g_strsplit(fwdmessageid, "\x7f", 0);
1416                 item = folder_find_item_from_identifier(tokens[0]);
1417                 if (item != NULL) {
1418                         MsgInfo *msginfo;
1419                         
1420                         msginfo = folder_item_get_msginfo(item, atoi(tokens[1]));
1421                         if ((msginfo != NULL) && (strcmp(msginfo->msgid, tokens[2]) != 0)) {
1422                                 procmsg_msginfo_free(msginfo);
1423                                 msginfo = NULL;
1424                         }
1425                         
1426                         if (msginfo == NULL) {
1427                                 msginfo = folder_item_get_msginfo_by_msgid(item, tokens[2]);
1428                         }
1429                         
1430                         if (msginfo != NULL) {
1431                                 if (replymessageid != NULL) {
1432                                         procmsg_msginfo_unset_flags(msginfo, MSG_FORWARDED, 0);
1433                                         procmsg_msginfo_set_flags(msginfo, MSG_REPLIED, 0);
1434                                 } 
1435                                 else {
1436                                         procmsg_msginfo_unset_flags(msginfo, MSG_REPLIED, 0);
1437                                         procmsg_msginfo_set_flags(msginfo, MSG_FORWARDED, 0);
1438                                 }
1439                                 procmsg_msginfo_free(msginfo);
1440                         }
1441                 }
1442                 g_strfreev(tokens);
1443         }
1444
1445         g_free(savecopyfolder);
1446         g_free(replymessageid);
1447         g_free(fwdmessageid);
1448         
1449         return (newsval != 0 ? newsval : mailval);
1450 }
1451
1452 #define CHANGE_FLAGS(msginfo) \
1453 { \
1454 if (msginfo->folder->folder->change_flags != NULL) \
1455 msginfo->folder->folder->change_flags(msginfo->folder->folder, \
1456                                       msginfo->folder, \
1457                                       msginfo); \
1458 }
1459
1460 void procmsg_msginfo_set_flags(MsgInfo *msginfo, MsgPermFlags perm_flags, MsgTmpFlags tmp_flags)
1461 {
1462         FolderItem *item;
1463         MsgInfoUpdate msginfo_update;
1464
1465         g_return_if_fail(msginfo != NULL);
1466         item = msginfo->folder;
1467         g_return_if_fail(item != NULL);
1468         
1469         debug_print("Setting flags for message %d in folder %s\n", msginfo->msgnum, item->path);
1470
1471         /* if new flag is set */
1472         if ((perm_flags & MSG_NEW) && !MSG_IS_NEW(msginfo->flags) &&
1473            !MSG_IS_IGNORE_THREAD(msginfo->flags)) {
1474                 item->new++;
1475         }
1476
1477         /* if unread flag is set */
1478         if ((perm_flags & MSG_UNREAD) && !MSG_IS_UNREAD(msginfo->flags) &&
1479            !MSG_IS_IGNORE_THREAD(msginfo->flags)) {
1480                 item->unread++;
1481         }
1482
1483         if (!MSG_IS_UNREAD(msginfo->flags) &&(perm_flags & MSG_UNREAD)
1484         && procmsg_msg_has_marked_parent(msginfo)) {
1485                 item->unreadmarked++;
1486         }
1487         
1488         if (!MSG_IS_MARKED(msginfo->flags) && (perm_flags & MSG_MARKED)) {
1489                 procmsg_update_unread_children(msginfo, TRUE);
1490         }
1491
1492
1493         /* if ignore thread flag is set */
1494         if ((perm_flags & MSG_IGNORE_THREAD) && !MSG_IS_IGNORE_THREAD(msginfo->flags)) {
1495                 if (MSG_IS_NEW(msginfo->flags) || (perm_flags & MSG_NEW)) {
1496                         item->new--;
1497                 }
1498                 if (MSG_IS_UNREAD(msginfo->flags) || (perm_flags & MSG_UNREAD)) {
1499                         item->unread--;
1500                 }
1501                 if ((perm_flags & MSG_UNREAD) || (MSG_IS_UNREAD(msginfo->flags)
1502                 && procmsg_msg_has_marked_parent(msginfo))) {
1503                         item->unreadmarked--;
1504                 }
1505                 if ((perm_flags & MSG_MARKED) || (MSG_IS_MARKED(msginfo->flags)
1506                 && !MSG_IS_IGNORE_THREAD(msginfo->flags))) {
1507                         procmsg_update_unread_children(msginfo, FALSE);
1508                 }
1509
1510         }
1511
1512         if (MSG_IS_IMAP(msginfo->flags))
1513                 imap_msg_set_perm_flags(msginfo, perm_flags);
1514
1515         msginfo->flags.perm_flags |= perm_flags;
1516         msginfo->flags.tmp_flags |= tmp_flags;
1517
1518         msginfo_update.msginfo = msginfo;
1519         hooks_invoke(MSGINFO_UPDATE_HOOKLIST, &msginfo_update);
1520         folder_item_update(msginfo->folder, F_ITEM_UPDATE_MSGCNT);
1521
1522         CHANGE_FLAGS(msginfo);
1523         procmsg_msginfo_write_flags(msginfo);
1524 }
1525
1526 void procmsg_msginfo_unset_flags(MsgInfo *msginfo, MsgPermFlags perm_flags, MsgTmpFlags tmp_flags)
1527 {
1528         FolderItem *item;
1529         MsgInfoUpdate msginfo_update;
1530
1531         g_return_if_fail(msginfo != NULL);
1532         item = msginfo->folder;
1533         g_return_if_fail(item != NULL); 
1534         
1535         debug_print("Unsetting flags for message %d in folder %s\n", msginfo->msgnum, item->path);
1536
1537         /* if new flag is unset */
1538         if ((perm_flags & MSG_NEW) && MSG_IS_NEW(msginfo->flags) &&
1539            !MSG_IS_IGNORE_THREAD(msginfo->flags)) {
1540                 item->new--;
1541         }
1542
1543         /* if unread flag is unset */
1544         if ((perm_flags & MSG_UNREAD) && MSG_IS_UNREAD(msginfo->flags) &&
1545            !MSG_IS_IGNORE_THREAD(msginfo->flags)) {
1546                 item->unread--;
1547         }
1548         
1549         if (MSG_IS_UNREAD(msginfo->flags) && (perm_flags & MSG_UNREAD)
1550         && !MSG_IS_IGNORE_THREAD(msginfo->flags)
1551         && procmsg_msg_has_marked_parent(msginfo)) {
1552                 item->unreadmarked--;
1553         }
1554
1555         if (MSG_IS_MARKED(msginfo->flags) && (perm_flags & MSG_MARKED)
1556         && !MSG_IS_IGNORE_THREAD(msginfo->flags)) {
1557                 procmsg_update_unread_children(msginfo, FALSE);
1558         }
1559
1560         /* if ignore thread flag is unset */
1561         if ((perm_flags & MSG_IGNORE_THREAD) && MSG_IS_IGNORE_THREAD(msginfo->flags)) {
1562                 if (MSG_IS_NEW(msginfo->flags) && !(perm_flags & MSG_NEW)) {
1563                         item->new++;
1564                 }
1565                 if (MSG_IS_UNREAD(msginfo->flags) && !(perm_flags & MSG_UNREAD)) {
1566                         item->unread++;
1567                 }
1568                 if (MSG_IS_UNREAD(msginfo->flags) && !(perm_flags & MSG_UNREAD)
1569                 && procmsg_msg_has_marked_parent(msginfo)) {
1570                         item->unreadmarked++;
1571                 }
1572                 if (MSG_IS_MARKED(msginfo->flags) && !(perm_flags & MSG_MARKED)) {
1573                         procmsg_update_unread_children(msginfo, TRUE);
1574                 }
1575
1576         }
1577
1578         if (MSG_IS_IMAP(msginfo->flags))
1579                 imap_msg_unset_perm_flags(msginfo, perm_flags);
1580
1581         msginfo->flags.perm_flags &= ~perm_flags;
1582         msginfo->flags.tmp_flags &= ~tmp_flags;
1583
1584         msginfo_update.msginfo = msginfo;
1585         hooks_invoke(MSGINFO_UPDATE_HOOKLIST, &msginfo_update);
1586         folder_item_update(msginfo->folder, F_ITEM_UPDATE_MSGCNT);
1587
1588         CHANGE_FLAGS(msginfo);
1589         procmsg_msginfo_write_flags(msginfo);
1590 }
1591
1592 void procmsg_msginfo_write_flags(MsgInfo *msginfo)
1593 {
1594         gchar *destdir;
1595         FILE *fp;
1596
1597         destdir = folder_item_get_path(msginfo->folder);
1598         if (!is_dir_exist(destdir))
1599                 make_dir_hier(destdir);
1600
1601         if ((fp = procmsg_open_mark_file(destdir, TRUE))) {
1602                 procmsg_write_flags(msginfo, fp);
1603                 fclose(fp);
1604         } else {
1605                 g_warning("Can't open mark file.\n");
1606         }
1607         
1608         g_free(destdir);
1609 }
1610
1611 /*!
1612  *\brief        check for flags (e.g. mark) in prior msgs of current thread
1613  *
1614  *\param        info Current message
1615  *\param        perm_flags Flags to be checked
1616  *\param        parentmsgs Hash of prior msgs to avoid loops
1617  *
1618  *\return       gboolean TRUE if perm_flags are found
1619  */
1620 gboolean procmsg_msg_has_flagged_parent_real(MsgInfo *info,
1621                 MsgPermFlags perm_flags, GHashTable *parentmsgs)
1622 {
1623         MsgInfo *tmp;
1624
1625         g_return_val_if_fail(info != NULL, FALSE);
1626
1627         if (info != NULL && info->folder != NULL && info->inreplyto != NULL) {
1628                 tmp = folder_item_get_msginfo_by_msgid(info->folder,
1629                                 info->inreplyto);
1630                 if (tmp && (tmp->flags.perm_flags & perm_flags)) {
1631                         procmsg_msginfo_free(tmp);
1632                         return TRUE;
1633                 } else if (tmp != NULL) {
1634                         gboolean result;
1635
1636                         if (g_hash_table_lookup(parentmsgs, info)) {
1637                                 debug_print("loop detected: %s%c%d\n",
1638                                         folder_item_get_path(info->folder),
1639                                         G_DIR_SEPARATOR, info->msgnum);
1640                                 result = FALSE;
1641                         } else {
1642                                 g_hash_table_insert(parentmsgs, info, "1");
1643                                 result = procmsg_msg_has_flagged_parent_real(
1644                                     tmp, perm_flags, parentmsgs);
1645                         }
1646                         procmsg_msginfo_free(tmp);
1647                         return result;
1648                 } else {
1649                         return FALSE;
1650                 }
1651         } else
1652                 return FALSE;
1653 }
1654
1655 /*!
1656  *\brief        Callback for cleaning up hash of parentmsgs
1657  */
1658 gboolean parentmsgs_hash_remove(gpointer key,
1659                             gpointer value,
1660                             gpointer user_data)
1661 {
1662         return TRUE;
1663 }
1664
1665 /*!
1666  *\brief        Set up list of parentmsgs
1667  *              See procmsg_msg_has_flagged_parent_real()
1668  */
1669 gboolean procmsg_msg_has_flagged_parent(MsgInfo *info, MsgPermFlags perm_flags)
1670 {
1671         gboolean result;
1672         GHashTable *parentmsgs = g_hash_table_new(NULL, NULL); 
1673
1674         result = procmsg_msg_has_flagged_parent_real(info, perm_flags, parentmsgs);
1675         g_hash_table_foreach_remove(parentmsgs, parentmsgs_hash_remove, NULL);
1676         g_hash_table_destroy(parentmsgs);
1677         return result;
1678 }
1679
1680 /*!
1681  *\brief        Check if msgs prior in thread are marked
1682  *              See procmsg_msg_has_flagged_parent_real()
1683  */
1684 gboolean procmsg_msg_has_marked_parent(MsgInfo *info)
1685 {
1686         return procmsg_msg_has_flagged_parent(info, MSG_MARKED);
1687 }
1688
1689
1690 GSList *procmsg_find_children (MsgInfo *info)
1691 {
1692         GSList *children = NULL;
1693         GSList *all, *cur;
1694         
1695         g_return_val_if_fail(info!=NULL, NULL);
1696         if (info->msgid == NULL)
1697                 return NULL;
1698         all = folder_item_get_msg_list(info->folder);
1699         for (cur = all; cur != NULL; cur = g_slist_next(cur)) {
1700                 MsgInfo *tmp = (MsgInfo *)cur->data;
1701                 if (tmp->inreplyto && !strcmp(tmp->inreplyto, info->msgid)) {
1702                         GSList *grand_children;
1703                         children = g_slist_prepend(children, tmp);
1704                         grand_children = procmsg_find_children(tmp);
1705                         children = slist_concat_unique(children, grand_children);
1706                         g_slist_free(grand_children);
1707                 }
1708                 if (tmp && tmp != info)
1709                         procmsg_msginfo_free(tmp);
1710         }
1711         
1712         return children;
1713 }
1714
1715 static void procmsg_update_unread_children(MsgInfo *info, gboolean newly_marked)
1716 {
1717         GSList *children = procmsg_find_children(info);
1718         GSList *cur;
1719         for (cur = children; cur != NULL; cur = g_slist_next(cur)) {
1720                 MsgInfo *tmp = (MsgInfo *)cur->data;
1721                 if(MSG_IS_UNREAD(tmp->flags) && !MSG_IS_IGNORE_THREAD(tmp->flags)) {
1722                         if(newly_marked) 
1723                                 info->folder->unreadmarked++;
1724                         else
1725                                 info->folder->unreadmarked--;
1726                         folder_item_update(info->folder, F_ITEM_UPDATE_MSGCNT);
1727                 }
1728                 procmsg_msginfo_free(tmp);
1729         }
1730 }
1731
1732 /**
1733  * Set the destination folder for a copy or move operation
1734  *
1735  * \param msginfo The message which's destination folder is changed
1736  * \param to_folder The destination folder for the operation
1737  */
1738 void procmsg_msginfo_set_to_folder(MsgInfo *msginfo, FolderItem *to_folder)
1739 {
1740         if(msginfo->to_folder != NULL) {
1741                 msginfo->to_folder->op_count--;
1742                 folder_item_update(msginfo->to_folder, F_ITEM_UPDATE_MSGCNT);
1743         }
1744         msginfo->to_folder = to_folder;
1745         if(to_folder != NULL) {
1746                 to_folder->op_count++;
1747                 folder_item_update(msginfo->to_folder, F_ITEM_UPDATE_MSGCNT);
1748         }
1749 }