src/procmsg.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2012 Hiroyuki Yamamoto and the Claws Mail team
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 3 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, see <http://www.gnu.org/licenses/>.
  17  *
  18  */
  19
  20 #include "defs.h"
  21
  22 #include <glib.h>
  23 #include <glib/gi18n.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <ctype.h>
  27
  28 #include "main.h"
  29 #include "utils.h"
  30 #include "procmsg.h"
  31 #include "procheader.h"
  32 #include "send_message.h"
  33 #include "procmime.h"
  34 #include "statusbar.h"
  35 #include "prefs_filtering.h"
  36 #include "filtering.h"
  37 #include "folder.h"
  38 #include "prefs_common.h"
  39 #include "account.h"
  40 #include "alertpanel.h"
  41 #include "news.h"
  42 #include "hooks.h"
  43 #include "msgcache.h"
  44 #include "partial_download.h"
  45 #include "mainwindow.h"
  46 #include "summaryview.h"
  47 #include "log.h"
  48 #include "tags.h"
  49 #include "timing.h"
  50 #include "inc.h"
  51 #include "privacy.h"
  52
  53 extern SessionStats session_stats;
  54
  55 static gint procmsg_send_message_queue_full(const gchar *file, gboolean keep_session, gchar **errstr,
  56                                             FolderItem *queue, gint msgnum, gboolean *queued_removed);
  57 static void procmsg_update_unread_children      (MsgInfo        *info,
  58                                          gboolean        newly_marked);
  59 enum
  60 {
  61         Q_SENDER           = 0,
  62         Q_SMTPSERVER       = 1,
  63         Q_RECIPIENTS       = 2,
  64         Q_NEWSGROUPS       = 3,
  65         Q_MAIL_ACCOUNT_ID  = 4,
  66         Q_NEWS_ACCOUNT_ID  = 5,
  67         Q_SAVE_COPY_FOLDER = 6,
  68         Q_REPLY_MESSAGE_ID = 7,
  69         Q_FWD_MESSAGE_ID   = 8,
  70         Q_PRIVACY_SYSTEM   = 9,
  71         Q_ENCRYPT          = 10,
  72         Q_ENCRYPT_DATA     = 11,
  73         Q_CLAWS_HDRS       = 12,
  74         Q_PRIVACY_SYSTEM_OLD = 13,
  75         Q_ENCRYPT_OLD        = 14,
  76         Q_ENCRYPT_DATA_OLD   = 15,
  77         Q_CLAWS_HDRS_OLD     = 16,
  78 };
  79
  80 void procmsg_msg_list_free(GSList *mlist)
  81 {
  82         GSList *cur;
  83         MsgInfo *msginfo;
  84
  85         for (cur = mlist; cur != NULL; cur = cur->next) {
  86                 msginfo = (MsgInfo *)cur->data;
  87                 procmsg_msginfo_free(msginfo);
  88         }
  89         g_slist_free(mlist);
  90 }
  91
  92 MsgNumberList *procmsg_get_number_list_for_msgs(MsgInfoList *msglist)
  93 {
  94         GSList *cur = NULL;
  95         GSList *nums = NULL;
  96
  97         for (cur = msglist; cur; cur = cur->next) {
  98                 MsgInfo *msg = (MsgInfo *)cur->data;
  99                 nums = g_slist_prepend(nums, GUINT_TO_POINTER(msg->msgnum));
 100         }
 101
 102         return g_slist_reverse(nums);
 103 }
 104
 105 struct MarkSum {
 106         gint *new_msgs;
 107         gint *unread_msgs;
 108         gint *total_msgs;
 109         gint *min;
 110         gint *max;
 111         gint first;
 112 };
 113
 114 /* CLAWS subject threading:
 115
 116   in the first round it inserts subject lines in a
 117   hashtable (subject <-> node)
 118
 119   the second round finishes the threads by attaching
 120   matching subject lines to the one found in the
 121   hashtable. will use the oldest node with the same
 122   subject that is not more then thread_by_subject_max_age
 123   days old (see subject_hashtable_lookup)
 124 */
 125
 126 static void subject_hashtable_insert(GHashTable *hashtable, GNode *node)
 127 {
 128         gchar *subject;
 129         MsgInfo *msginfo;
 130         GSList *list = NULL;
 131
 132         cm_return_if_fail(hashtable != NULL);
 133         cm_return_if_fail(node != NULL);
 134         msginfo = (MsgInfo *) node->data;
 135         cm_return_if_fail(msginfo != NULL);
 136
 137         subject = msginfo->subject;
 138         if (subject == NULL)
 139                 return;
 140
 141         subject += subject_get_prefix_length(subject);
 142
 143         list = g_hash_table_lookup(hashtable, subject);
 144         list = g_slist_prepend(list, node);
 145         g_hash_table_insert(hashtable, subject, list);
 146 }
 147
 148 static GNode *subject_hashtable_lookup(GHashTable *hashtable, MsgInfo *msginfo)
 149 {
 150         gchar *subject;
 151         GSList *list, *cur;
 152         GNode *node = NULL, *hashtable_node = NULL;
 153         gint prefix_length;
 154         MsgInfo *hashtable_msginfo = NULL, *best_msginfo = NULL;
 155         gboolean match;
 156
 157         cm_return_val_if_fail(hashtable != NULL, NULL);
 158
 159         subject = msginfo->subject;
 160         if (subject == NULL)
 161                 return NULL;
 162         prefix_length = subject_get_prefix_length(subject);
 163         if (prefix_length <= 0)
 164                 return NULL;
 165         subject += prefix_length;
 166
 167         list = g_hash_table_lookup(hashtable, subject);
 168         if (list == NULL)
 169                 return NULL;
 170
 171         /* check all nodes with the same subject to find the best parent */
 172         for (cur = list; cur; cur = cur->next) {
 173                 hashtable_node = (GNode *)cur->data;
 174                 hashtable_msginfo = (MsgInfo *) hashtable_node->data;
 175                 match = FALSE;
 176
 177                 /* best node should be the oldest in the found nodes */
 178                 /* parent node must not be older then msginfo */
 179                 if ((hashtable_msginfo->date_t < msginfo->date_t) &&
 180                     ((best_msginfo == NULL) ||
 181                      (best_msginfo->date_t > hashtable_msginfo->date_t)))
 182                         match = TRUE;
 183
 184                 /* parent node must not be more then thread_by_subject_max_age
 185                    days older then msginfo */
 186                 if (abs(difftime(msginfo->date_t, hashtable_msginfo->date_t)) >
 187                     prefs_common.thread_by_subject_max_age * 3600 * 24)
 188                         match = FALSE;
 189
 190                 /* can add new tests for all matching
 191                    nodes found by subject */
 192
 193                 if (match) {
 194                         node = hashtable_node;
 195                         best_msginfo = hashtable_msginfo;
 196                 }
 197         }
 198
 199         return node;
 200 }
 201
 202 static void subject_hashtable_free(gpointer key, gpointer value, gpointer data)
 203 {
 204         g_slist_free(value);
 205 }
 206
 207 /* return the reversed thread tree */
 208 GNode *procmsg_get_thread_tree(GSList *mlist)
 209 {
 210         GNode *root, *parent, *node, *next;
 211         GHashTable *msgid_table;
 212         GHashTable *subject_hashtable = NULL;
 213         MsgInfo *msginfo;
 214         const gchar *msgid;
 215         GSList *reflist;
 216         START_TIMING("");
 217         root = g_node_new(NULL);
 218         msgid_table = g_hash_table_new(g_str_hash, g_str_equal);
 219
 220         if (prefs_common.thread_by_subject) {
 221                 subject_hashtable = g_hash_table_new(g_str_hash, g_str_equal);
 222         }
 223
 224         for (; mlist != NULL; mlist = mlist->next) {
 225                 msginfo = (MsgInfo *)mlist->data;
 226                 parent = root;
 227
 228                 if (msginfo->inreplyto) {
 229                         parent = g_hash_table_lookup(msgid_table, msginfo->inreplyto);
 230                         if (parent == NULL) {
 231                                 parent = root;
 232                         }
 233                 }
 234                 node = g_node_insert_data_before
 235                         (parent, parent == root ? parent->children : NULL,
 236                          msginfo);
 237                 if ((msgid = msginfo->msgid) && g_hash_table_lookup(msgid_table, msgid) == NULL)
 238                         g_hash_table_insert(msgid_table, (gchar *)msgid, node);
 239
 240                 /* CLAWS: add subject to hashtable (without prefix) */
 241                 if (prefs_common.thread_by_subject) {
 242                         subject_hashtable_insert(subject_hashtable, node);
 243                 }
 244         }
 245
 246         /* complete the unfinished threads */
 247         for (node = root->children; node != NULL; ) {
 248                 next = node->next;
 249                 msginfo = (MsgInfo *)node->data;
 250                 parent = NULL;
 251
 252                 if (msginfo->inreplyto)
 253                         parent = g_hash_table_lookup(msgid_table, msginfo->inreplyto);
 254
 255                 /* try looking for the indirect parent */
 256                 if (!parent && msginfo->references) {
 257                         for (reflist = msginfo->references;
 258                              reflist != NULL; reflist = reflist->next)
 259                                 if ((parent = g_hash_table_lookup
 260                                         (msgid_table, reflist->data)) != NULL)
 261                                         break;
 262                 }
 263
 264                 /* node should not be the parent, and node should not
 265                    be an ancestor of parent (circular reference) */
 266                 if (parent && parent != node &&
 267                     !g_node_is_ancestor(node, parent)) {
 268                         g_node_unlink(node);
 269                         g_node_insert_before
 270                                 (parent, parent->children, node);
 271                 }
 272
 273                 node = next;
 274         }
 275
 276         if (prefs_common.thread_by_subject) {
 277                 START_TIMING("thread by subject");
 278                 for (node = root->children; node && node != NULL;) {
 279                         next = node->next;
 280                         msginfo = (MsgInfo *) node->data;
 281
 282                         parent = subject_hashtable_lookup(subject_hashtable, msginfo);
 283
 284                         /* the node may already be threaded by IN-REPLY-TO, so go up
 285                          * in the tree to
 286                            find the parent node */
 287                         if (parent != NULL) {
 288                                 if (g_node_is_ancestor(node, parent))
 289                                         parent = NULL;
 290                                 if (parent == node)
 291                                         parent = NULL;
 292                         }
 293
 294                         if (parent) {
 295                                 g_node_unlink(node);
 296                                 g_node_append(parent, node);
 297                         }
 298
 299                         node = next;
 300                 }
 301                 END_TIMING();
 302         }
 303
 304         if (prefs_common.thread_by_subject)
 305         {
 306                 g_hash_table_foreach(subject_hashtable, subject_hashtable_free, NULL);
 307                 g_hash_table_destroy(subject_hashtable);
 308         }
 309
 310         g_hash_table_destroy(msgid_table);
 311         END_TIMING();
 312         return root;
 313 }
 314
 315 gint procmsg_move_messages(GSList *mlist)
 316 {
 317         GSList *cur, *movelist = NULL;
 318         MsgInfo *msginfo;
 319         FolderItem *dest = NULL;
 320         gint retval = 0;
 321         gboolean finished = TRUE;
 322         if (!mlist) return 0;
 323
 324         folder_item_update_freeze();
 325
 326 next_folder:
 327         for (cur = mlist; cur != NULL; cur = cur->next) {
 328                 msginfo = (MsgInfo *)cur->data;
 329                 if (!msginfo->to_folder) {
 330                         continue;
 331                 } else {
 332                         finished = FALSE;
 333                 }
 334                 if (!dest) {
 335                         dest = msginfo->to_folder;
 336                         movelist = g_slist_prepend(movelist, msginfo);
 337                 } else if (dest == msginfo->to_folder) {
 338                         movelist = g_slist_prepend(movelist, msginfo);
 339                 } else {
 340                         continue;
 341                 }
 342                 procmsg_msginfo_set_to_folder(msginfo, NULL);
 343         }
 344         if (movelist) {
 345                 movelist = g_slist_reverse(movelist);
 346                 retval |= folder_item_move_msgs(dest, movelist);
 347                 g_slist_free(movelist);
 348                 movelist = NULL;
 349         }
 350         if (finished == FALSE) {
 351                 finished = TRUE;
 352                 dest = NULL;
 353                 goto next_folder;
 354         }
 355
 356         folder_item_update_thaw();
 357         return retval;
 358 }
 359
 360 void procmsg_copy_messages(GSList *mlist)
 361 {
 362         GSList *cur, *copylist = NULL;
 363         MsgInfo *msginfo;
 364         FolderItem *dest = NULL;
 365         gboolean finished = TRUE;
 366         if (!mlist) return;
 367
 368         folder_item_update_freeze();
 369
 370 next_folder:
 371         for (cur = mlist; cur != NULL; cur = cur->next) {
 372                 msginfo = (MsgInfo *)cur->data;
 373                 if (!msginfo->to_folder) {
 374                         continue;
 375                 } else {
 376                         finished = FALSE;
 377                 }
 378                 if (!dest) {
 379                         dest = msginfo->to_folder;
 380                         copylist = g_slist_prepend(copylist, msginfo);
 381                 } else if (dest == msginfo->to_folder) {
 382                         copylist = g_slist_prepend(copylist, msginfo);
 383                 } else {
 384                         continue;
 385                 }
 386                 procmsg_msginfo_set_to_folder(msginfo, NULL);
 387         }
 388         if (copylist) {
 389                 copylist = g_slist_reverse(copylist);
 390                 folder_item_copy_msgs(dest, copylist);
 391                 g_slist_free(copylist);
 392                 copylist = NULL;
 393         }
 394         if (finished == FALSE) {
 395                 finished = TRUE;
 396                 dest = NULL;
 397                 goto next_folder;
 398         }
 399
 400         folder_item_update_thaw();
 401 }
 402
 403 gchar *procmsg_get_message_file_path(MsgInfo *msginfo)
 404 {
 405         gchar *file;
 406
 407         cm_return_val_if_fail(msginfo != NULL, NULL);
 408
 409         if (msginfo->plaintext_file)
 410                 file = g_strdup(msginfo->plaintext_file);
 411         else {
 412                 file = folder_item_fetch_msg(msginfo->folder, msginfo->msgnum);
 413         }
 414
 415         return file;
 416 }
 417
 418 gchar *procmsg_get_message_file(MsgInfo *msginfo)
 419 {
 420         gchar *filename = NULL;
 421
 422         cm_return_val_if_fail(msginfo != NULL, NULL);
 423
 424         filename = folder_item_fetch_msg(msginfo->folder, msginfo->msgnum);
 425         if (!filename)
 426                 debug_print("can't fetch message %d\n", msginfo->msgnum);
 427
 428         return filename;
 429 }
 430
 431 gchar *procmsg_get_message_file_full(MsgInfo *msginfo, gboolean headers, gboolean body)
 432 {
 433         gchar *filename = NULL;
 434
 435         cm_return_val_if_fail(msginfo != NULL, NULL);
 436
 437         filename = folder_item_fetch_msg_full(msginfo->folder, msginfo->msgnum,
 438                                                 headers, body);
 439         if (!filename)
 440                 debug_print("can't fetch message %d\n", msginfo->msgnum);
 441
 442         return filename;
 443 }
 444
 445 GSList *procmsg_get_message_file_list(GSList *mlist)
 446 {
 447         GSList *file_list = NULL;
 448         MsgInfo *msginfo;
 449         MsgFileInfo *fileinfo;
 450         gchar *file;
 451
 452         while (mlist != NULL) {
 453                 msginfo = (MsgInfo *)mlist->data;
 454                 file = procmsg_get_message_file(msginfo);
 455                 if (!file) {
 456                         procmsg_message_file_list_free(file_list);
 457                         return NULL;
 458                 }
 459                 fileinfo = g_new(MsgFileInfo, 1);
 460                 fileinfo->msginfo = procmsg_msginfo_new_ref(msginfo);
 461                 fileinfo->file = file;
 462                 fileinfo->flags = g_new(MsgFlags, 1);
 463                 *fileinfo->flags = msginfo->flags;
 464                 file_list = g_slist_prepend(file_list, fileinfo);
 465                 mlist = mlist->next;
 466         }
 467
 468         file_list = g_slist_reverse(file_list);
 469
 470         return file_list;
 471 }
 472
 473 void procmsg_message_file_list_free(MsgInfoList *file_list)
 474 {
 475         GSList *cur;
 476         MsgFileInfo *fileinfo;
 477
 478         for (cur = file_list; cur != NULL; cur = cur->next) {
 479                 fileinfo = (MsgFileInfo *)cur->data;
 480                 procmsg_msginfo_free(fileinfo->msginfo);
 481                 g_free(fileinfo->file);
 482                 g_free(fileinfo->flags);
 483                 g_free(fileinfo);
 484         }
 485
 486         g_slist_free(file_list);
 487 }
 488
 489 FILE *procmsg_open_message(MsgInfo *msginfo)
 490 {
 491         FILE *fp;
 492         gchar *file;
 493
 494         cm_return_val_if_fail(msginfo != NULL, NULL);
 495
 496         file = procmsg_get_message_file_path(msginfo);
 497         cm_return_val_if_fail(file != NULL, NULL);
 498
 499         if (!is_file_exist(file)) {
 500                 g_free(file);
 501                 file = procmsg_get_message_file(msginfo);
 502                 if (!file)
 503                         return NULL;
 504         }
 505
 506         if ((fp = g_fopen(file, "rb")) == NULL) {
 507                 FILE_OP_ERROR(file, "fopen");
 508                 g_free(file);
 509                 return NULL;
 510         }
 511
 512         g_free(file);
 513
 514         if (MSG_IS_QUEUED(msginfo->flags) || MSG_IS_DRAFT(msginfo->flags)) {
 515                 gchar buf[BUFFSIZE];
 516
 517                 while (fgets(buf, sizeof(buf), fp) != NULL) {
 518                         /* new way */
 519                         if ((!strncmp(buf, "X-Claws-End-Special-Headers: 1",
 520                                 strlen("X-Claws-End-Special-Headers:"))) ||
 521                             (!strncmp(buf, "X-Sylpheed-End-Special-Headers: 1",
 522                                 strlen("X-Sylpheed-End-Special-Headers:"))))
 523                                 break;
 524                         /* old way */
 525                         if (buf[0] == '\r' || buf[0] == '\n') break;
 526                         /* from other mailers */
 527                         if (!strncmp(buf, "Date: ", 6)
 528                         ||  !strncmp(buf, "To: ", 4)
 529                         ||  !strncmp(buf, "From: ", 6)
 530                         ||  !strncmp(buf, "Subject: ", 9)) {
 531                                 rewind(fp);
 532                                 break;
 533                         }
 534                 }
 535         }
 536
 537         return fp;
 538 }
 539
 540 gboolean procmsg_msg_exist(MsgInfo *msginfo)
 541 {
 542         gchar *path;
 543         gboolean ret;
 544
 545         if (!msginfo) return FALSE;
 546
 547         path = folder_item_get_path(msginfo->folder);
 548         change_dir(path);
 549         ret = !folder_item_is_msg_changed(msginfo->folder, msginfo);
 550         g_free(path);
 551
 552         return ret;
 553 }
 554
 555 void procmsg_get_filter_keyword(MsgInfo *msginfo, gchar **header, gchar **key,
 556                                 PrefsFilterType type)
 557 {
 558         static HeaderEntry hentry[] = {{"X-BeenThere:",    NULL, TRUE},
 559                                        {"X-ML-Name:",      NULL, TRUE},
 560                                        {"X-List:",         NULL, TRUE},
 561                                        {"X-Mailing-list:", NULL, TRUE},
 562                                        {"List-Id:",        NULL, TRUE},
 563                                        {"X-Sequence:",     NULL, TRUE},
 564                                        {"Sender:",         NULL, TRUE},
 565                                        {"List-Post:",      NULL, TRUE},
 566                                        {NULL,              NULL, FALSE}};
 567         enum
 568         {
 569                 H_X_BEENTHERE    = 0,
 570                 H_X_ML_NAME      = 1,
 571                 H_X_LIST         = 2,
 572                 H_X_MAILING_LIST = 3,
 573                 H_LIST_ID        = 4,
 574                 H_X_SEQUENCE     = 5,
 575                 H_SENDER         = 6,
 576                 H_LIST_POST      = 7
 577         };
 578
 579         FILE *fp;
 580
 581         cm_return_if_fail(msginfo != NULL);
 582         cm_return_if_fail(header != NULL);
 583         cm_return_if_fail(key != NULL);
 584
 585         *header = NULL;
 586         *key = NULL;
 587
 588         switch (type) {
 589         case FILTER_BY_NONE:
 590                 return;
 591         case FILTER_BY_AUTO:
 592                 if ((fp = procmsg_open_message(msginfo)) == NULL)
 593                         return;
 594                 procheader_get_header_fields(fp, hentry);
 595                 fclose(fp);
 596
 597 #define SET_FILTER_KEY(hstr, idx)       \
 598 {                                       \
 599         *header = g_strdup(hstr);       \
 600         *key = hentry[idx].body;        \
 601         hentry[idx].body = NULL;        \
 602 }
 603
 604                 if (hentry[H_LIST_ID].body != NULL) {
 605                         SET_FILTER_KEY("header \"List-Id\"", H_LIST_ID);
 606                         extract_list_id_str(*key);
 607                 } else if (hentry[H_X_BEENTHERE].body != NULL) {
 608                         SET_FILTER_KEY("header \"X-BeenThere\"", H_X_BEENTHERE);
 609                 } else if (hentry[H_X_ML_NAME].body != NULL) {
 610                         SET_FILTER_KEY("header \"X-ML-Name\"", H_X_ML_NAME);
 611                 } else if (hentry[H_X_LIST].body != NULL) {
 612                         SET_FILTER_KEY("header \"X-List\"", H_X_LIST);
 613                 } else if (hentry[H_X_MAILING_LIST].body != NULL) {
 614                         SET_FILTER_KEY("header \"X-Mailing-List\"", H_X_MAILING_LIST);
 615                 } else  if (hentry[H_X_SEQUENCE].body != NULL) {
 616                         gchar *p;
 617
 618                         SET_FILTER_KEY("X-Sequence", H_X_SEQUENCE);
 619                         p = *key;
 620                         while (*p != '\0') {
 621                                 while (*p != '\0' && !g_ascii_isspace(*p)) p++;
 622                                 while (g_ascii_isspace(*p)) p++;
 623                                 if (g_ascii_isdigit(*p)) {
 624                                         *p = '\0';
 625                                         break;
 626                                 }
 627                         }
 628                         g_strstrip(*key);
 629                 } else if (hentry[H_SENDER].body != NULL) {
 630                         SET_FILTER_KEY("header \"Sender\"", H_SENDER);
 631                 } else if (hentry[H_LIST_POST].body != NULL) {
 632                         SET_FILTER_KEY("header \"List-Post\"", H_LIST_POST);
 633                 } else if (msginfo->to) {
 634                         *header = g_strdup("to");
 635                         *key = g_strdup(msginfo->to);
 636                 } else if (msginfo->subject) {
 637                         *header = g_strdup("subject");
 638                         *key = g_strdup(msginfo->subject);
 639                 }
 640
 641 #undef SET_FILTER_KEY
 642
 643                 g_free(hentry[H_X_BEENTHERE].body);
 644                 hentry[H_X_BEENTHERE].body = NULL;
 645                 g_free(hentry[H_X_ML_NAME].body);
 646                 hentry[H_X_ML_NAME].body = NULL;
 647                 g_free(hentry[H_X_LIST].body);
 648                 hentry[H_X_LIST].body = NULL;
 649                 g_free(hentry[H_X_MAILING_LIST].body);
 650                 hentry[H_X_MAILING_LIST].body = NULL;
 651                 g_free(hentry[H_LIST_ID].body);
 652                 hentry[H_LIST_ID].body = NULL;
 653                 g_free(hentry[H_SENDER].body);
 654                 hentry[H_SENDER].body = NULL;
 655                 g_free(hentry[H_LIST_POST].body);
 656                 hentry[H_LIST_POST].body = NULL;
 657
 658                 break;
 659         case FILTER_BY_FROM:
 660                 *header = g_strdup("from");
 661                 *key = g_strdup(msginfo->from);
 662                 break;
 663         case FILTER_BY_TO:
 664                 *header = g_strdup("to");
 665                 *key = g_strdup(msginfo->to);
 666                 break;
 667         case FILTER_BY_SUBJECT:
 668                 *header = g_strdup("subject");
 669                 *key = g_strdup(msginfo->subject);
 670                 break;
 671         default:
 672                 break;
 673         }
 674 }
 675
 676 static void procmsg_empty_trash(FolderItem *trash)
 677 {
 678         GNode *node, *next;
 679
 680         if (!trash ||
 681             (trash->stype != F_TRASH &&
 682              !folder_has_parent_of_type(trash, F_TRASH)))
 683                 return;
 684
 685         if (trash && trash->total_msgs > 0) {
 686                 GSList *mlist = folder_item_get_msg_list(trash);
 687                 GSList *cur;
 688                 for (cur = mlist ; cur != NULL ; cur = cur->next) {
 689                         MsgInfo * msginfo = (MsgInfo *) cur->data;
 690                         if (MSG_IS_LOCKED(msginfo->flags)) {
 691                                 procmsg_msginfo_free(msginfo);
 692                                 continue;
 693                         }
 694                         if (msginfo->total_size != 0 &&
 695                             msginfo->size != (off_t)msginfo->total_size)
 696                                 partial_mark_for_delete(msginfo);
 697
 698                         procmsg_msginfo_free(msginfo);
 699                 }
 700                 g_slist_free(mlist);
 701                 folder_item_remove_all_msg(trash);
 702         }
 703
 704         if (!trash->node || !trash->node->children)
 705                 return;
 706
 707         node = trash->node->children;
 708         while (node != NULL) {
 709                 next = node->next;
 710                 procmsg_empty_trash(FOLDER_ITEM(node->data));
 711                 node = next;
 712         }
 713 }
 714
 715 void procmsg_empty_all_trash(void)
 716 {
 717         FolderItem *trash;
 718         GList *cur;
 719
 720         for (cur = folder_get_list(); cur != NULL; cur = cur->next) {
 721                 Folder *folder = FOLDER(cur->data);
 722                 trash = folder->trash;
 723                 procmsg_empty_trash(trash);
 724                 if (folder->account && folder->account->set_trash_folder &&
 725                     folder_find_item_from_identifier(folder->account->trash_folder))
 726                         procmsg_empty_trash(
 727                                 folder_find_item_from_identifier(folder->account->trash_folder));
 728         }
 729 }
 730
 731 static PrefsAccount *procmsg_get_account_from_file(const gchar *file)
 732 {
 733         PrefsAccount *mailac = NULL;
 734         FILE *fp;
 735         int hnum;
 736         gchar buf[BUFFSIZE];
 737         static HeaderEntry qentry[] = {{"S:",    NULL, FALSE},
 738                                        {"SSV:",  NULL, FALSE},
 739                                        {"R:",    NULL, FALSE},
 740                                        {"NG:",   NULL, FALSE},
 741                                        {"MAID:", NULL, FALSE},
 742                                        {"NAID:", NULL, FALSE},
 743                                        {"SCF:",  NULL, FALSE},
 744                                        {"RMID:", NULL, FALSE},
 745                                        {"FMID:", NULL, FALSE},
 746                                        {"X-Claws-Privacy-System:", NULL, FALSE},
 747                                        {"X-Claws-Encrypt:", NULL, FALSE},
 748                                        {"X-Claws-Encrypt-Data:", NULL, FALSE},
 749                                        {"X-Claws-End-Special-Headers",    NULL, FALSE},
 750                                        {"X-Sylpheed-Privacy-System:", NULL, FALSE},
 751                                        {"X-Sylpheed-Encrypt:", NULL, FALSE},
 752                                        {"X-Sylpheed-Encrypt-Data:", NULL, FALSE},
 753                                        {NULL,    NULL, FALSE}};
 754
 755         cm_return_val_if_fail(file != NULL, NULL);
 756
 757         if ((fp = g_fopen(file, "rb")) == NULL) {
 758                 FILE_OP_ERROR(file, "fopen");
 759                 return NULL;
 760         }
 761
 762         while ((hnum = procheader_get_one_field(buf, sizeof(buf), fp, qentry))
 763                != -1) {
 764                 gchar *p = buf + strlen(qentry[hnum].name);
 765
 766                 if (hnum == Q_MAIL_ACCOUNT_ID) {
 767                         mailac = account_find_from_id(atoi(p));
 768                         break;
 769                 }
 770         }
 771         fclose(fp);
 772         return mailac;
 773 }
 774
 775 gchar *procmsg_msginfo_get_avatar(MsgInfo *msginfo, gint type)
 776 {
 777         GSList *mia;
 778
 779         if (!msginfo || !msginfo->extradata || !msginfo->extradata->avatars)
 780                 return NULL;
 781
 782         for (mia = msginfo->extradata->avatars; mia; mia = mia->next) {
 783                 MsgInfoAvatar *avatar = (MsgInfoAvatar *)mia->data;
 784                 if (avatar->avatar_id == type)
 785                         return avatar->avatar_src;
 786         }
 787
 788         return NULL;
 789 }
 790
 791 void procmsg_msginfo_add_avatar(MsgInfo *msginfo, gint type, const gchar *data)
 792 {
 793         MsgInfoAvatar *av;
 794
 795         if (!msginfo->extradata)
 796                 msginfo->extradata = g_new0(MsgInfoExtraData, 1);
 797
 798         av = g_new0(MsgInfoAvatar, 1);
 799         av->avatar_id = type;
 800         av->avatar_src = g_strdup(data);
 801
 802         msginfo->extradata->avatars = g_slist_append(msginfo->extradata->avatars, av);
 803 }
 804
 805 gchar *procmsg_msginfo_get_identifier(MsgInfo *msginfo)
 806 {
 807         gchar *folder_id;
 808         const gchar *msgid;
 809         gchar *id;
 810
 811         cm_return_val_if_fail(msginfo != NULL, NULL);
 812         folder_id = folder_item_get_identifier(msginfo->folder);
 813         msgid = msginfo->msgid;
 814
 815         id = g_strconcat(folder_id, G_DIR_SEPARATOR_S, msgid, NULL);
 816
 817         g_free(folder_id);
 818
 819         return id;
 820 }
 821
 822 MsgInfo *procmsg_get_msginfo_from_identifier(const gchar *id)
 823 {
 824         gchar *folder_id = g_strdup(id);
 825         gchar *separator = strrchr(folder_id, G_DIR_SEPARATOR);
 826         const gchar *msgid;
 827         FolderItem *item;
 828         MsgInfo *msginfo;
 829
 830         if (separator == NULL) {
 831                 g_free(folder_id);
 832                 return NULL;
 833         }
 834
 835         *separator = '\0';
 836         msgid = separator + 1;
 837
 838         item = folder_find_item_from_identifier(folder_id);
 839
 840         if (item == NULL) {
 841                 g_free(folder_id);
 842                 return NULL;
 843         }
 844
 845         msginfo = folder_item_get_msginfo_by_msgid(item, msgid);
 846         g_free(folder_id);
 847
 848         return msginfo;
 849 }
 850
 851 static GSList *procmsg_list_sort_by_account(FolderItem *queue, GSList *list)
 852 {
 853         GSList *result = NULL;
 854         GSList *orig = NULL;
 855         PrefsAccount *last_account = NULL;
 856         MsgInfo *msg = NULL;
 857         GSList *cur = NULL;
 858         gboolean nothing_to_sort = TRUE;
 859
 860         if (!list)
 861                 return NULL;
 862
 863         orig = g_slist_copy(list);
 864
 865         msg = (MsgInfo *)orig->data;
 866
 867         for (cur = orig; cur; cur = cur->next)
 868                 debug_print("sort before %s\n", ((MsgInfo *)cur->data)->from);
 869
 870         debug_print("\n");
 871
 872 parse_again:
 873         nothing_to_sort = TRUE;
 874         cur = orig;
 875         while (cur) {
 876                 gchar *file = NULL;
 877                 PrefsAccount *ac = NULL;
 878                 msg = (MsgInfo *)cur->data;
 879                 file = folder_item_fetch_msg(queue, msg->msgnum);
 880                 ac = procmsg_get_account_from_file(file);
 881                 g_free(file);
 882
 883                 if (last_account == NULL || (ac != NULL && ac == last_account)) {
 884                         result = g_slist_append(result, msg);
 885                         orig = g_slist_remove(orig, msg);
 886                         last_account = ac;
 887                         nothing_to_sort = FALSE;
 888                         goto parse_again;
 889                 }
 890                 cur = cur->next;
 891         }
 892
 893         if (orig && g_slist_length(orig)) {
 894                 if (!last_account && nothing_to_sort) {
 895                         /* can't find an account for the rest of the list */
 896                         cur = orig;
 897                         while (cur) {
 898                                 result = g_slist_append(result, cur->data);
 899                                 cur = cur->next;
 900                         }
 901                 } else {
 902                         last_account = NULL;
 903                         goto parse_again;
 904                 }
 905         }
 906
 907         g_slist_free(orig);
 908
 909         for (cur = result; cur; cur = cur->next)
 910                 debug_print("sort after %s\n", ((MsgInfo *)cur->data)->from);
 911
 912         debug_print("\n");
 913
 914         return result;
 915 }
 916
 917 static gboolean procmsg_is_last_for_account(FolderItem *queue, MsgInfo *msginfo, GSList *elem)
 918 {
 919         gchar *file = folder_item_fetch_msg(queue, msginfo->msgnum);
 920         PrefsAccount *ac = procmsg_get_account_from_file(file);
 921         GSList *cur;
 922         g_free(file);
 923         for (cur = elem; cur; cur = cur->next) {
 924                 MsgInfo *cur_msginfo = (MsgInfo *)cur->data;
 925                 file = folder_item_fetch_msg(queue, cur_msginfo->msgnum);
 926
 927                 if (cur_msginfo != msginfo && !MSG_IS_LOCKED(cur_msginfo->flags)) {
 928                         if (procmsg_get_account_from_file(file) == ac) {
 929                                 g_free(file);
 930                                 return FALSE;
 931                         }
 932                 }
 933
 934                 g_free(file);
 935         }
 936         return TRUE;
 937 }
 938
 939 static gboolean send_queue_lock = FALSE;
 940
 941 gboolean procmsg_queue_lock(char **errstr)
 942 {
 943         if (send_queue_lock) {
 944                 /* Avoid having to translate two similar strings */
 945                 log_warning(LOG_PROTOCOL, "%s\n", _("Already trying to send."));
 946                 if (errstr) {
 947                         if (*errstr) g_free(*errstr);
 948                         *errstr = g_strdup_printf(_("Already trying to send."));
 949                 }
 950                 return FALSE;
 951         }
 952         send_queue_lock = TRUE;
 953         return TRUE;
 954 }
 955 void procmsg_queue_unlock(void)
 956 {
 957         send_queue_lock = FALSE;
 958 }
 959 /*!
 960  *\brief        Send messages in queue
 961  *
 962  *\param        queue Queue folder to process
 963  *\param        save_msgs Unused
 964  *
 965  *\return       Number of messages sent, negative if an error occurred
 966  *              positive if no error occurred
 967  */
 968 gint procmsg_send_queue(FolderItem *queue, gboolean save_msgs, gchar **errstr)
 969 {
 970         gint sent = 0, err = 0;
 971         GSList *list, *elem;
 972         GSList *sorted_list = NULL;
 973         GNode *node, *next;
 974
 975         if (!procmsg_queue_lock(errstr)) {
 976                 main_window_set_menu_sensitive(mainwindow_get_mainwindow());
 977                 toolbar_main_set_sensitive(mainwindow_get_mainwindow());
 978                 return -1;
 979         }
 980         inc_lock();
 981         if (!queue)
 982                 queue = folder_get_default_queue();
 983
 984         if (queue == NULL) {
 985                 procmsg_queue_unlock();
 986                 inc_unlock();
 987                 return -1;
 988         }
 989
 990         main_window_set_menu_sensitive(mainwindow_get_mainwindow());
 991         toolbar_main_set_sensitive(mainwindow_get_mainwindow());
 992
 993         folder_item_scan(queue);
 994         list = folder_item_get_msg_list(queue);
 995
 996         /* sort the list per sender account; this helps reusing the same SMTP server */
 997         sorted_list = procmsg_list_sort_by_account(queue, list);
 998
 999         for (elem = sorted_list; elem != NULL; elem = elem->next) {
1000                 gchar *file;
1001                 MsgInfo *msginfo;
1002
1003                 msginfo = (MsgInfo *)(elem->data);
1004                 if (!MSG_IS_LOCKED(msginfo->flags) && !MSG_IS_DELETED(msginfo->flags)) {
1005                         file = folder_item_fetch_msg(queue, msginfo->msgnum);
1006                         if (file) {
1007                                 gboolean queued_removed = FALSE;
1008                                 if (procmsg_send_message_queue_full(file,
1009                                                 !procmsg_is_last_for_account(queue, msginfo, elem),
1010                                                 errstr, queue, msginfo->msgnum, &queued_removed) < 0) {
1011                                         g_warning("Sending queued message %d failed.\n",
1012                                                   msginfo->msgnum);
1013                                         err++;
1014                                 } else {
1015                                         sent++;
1016                                         if (!queued_removed)
1017                                                 folder_item_remove_msg(queue, msginfo->msgnum);
1018                                 }
1019                                 g_free(file);
1020                         }
1021                 }
1022                 /* FIXME: supposedly if only one message is locked, and queue
1023                  * is being flushed, the following free says something like
1024                  * "freeing msg ## in folder (nil)". */
1025                 procmsg_msginfo_free(msginfo);
1026         }
1027
1028         g_slist_free(sorted_list);
1029         folder_item_scan(queue);
1030
1031         if (queue->node && queue->node->children) {
1032                 node = queue->node->children;
1033                 while (node != NULL) {
1034                         int res = 0;
1035                         next = node->next;
1036                         send_queue_lock = FALSE;
1037                         res = procmsg_send_queue(FOLDER_ITEM(node->data), save_msgs, errstr);
1038                         send_queue_lock = TRUE;
1039                         if (res < 0)
1040                                 err = -res;
1041                         else
1042                                 sent += res;
1043                         node = next;
1044                 }
1045         }
1046         procmsg_queue_unlock();
1047         inc_unlock();
1048         main_window_set_menu_sensitive(mainwindow_get_mainwindow());
1049         toolbar_main_set_sensitive(mainwindow_get_mainwindow());
1050
1051         return (err != 0 ? -err : sent);
1052 }
1053
1054 gboolean procmsg_is_sending(void)
1055 {
1056         return send_queue_lock;
1057 }
1058
1059 /*!
1060  *\brief        Determine if a queue folder is empty
1061  *
1062  *\param        queue Queue folder to process
1063  *
1064  *\return       TRUE if the queue folder is empty, otherwise return FALSE
1065  */
1066 gboolean procmsg_queue_is_empty(FolderItem *queue)
1067 {
1068         GSList *list;
1069         gboolean res = FALSE;
1070         if (!queue)
1071                 queue = folder_get_default_queue();
1072         cm_return_val_if_fail(queue != NULL, TRUE);
1073
1074         folder_item_scan(queue);
1075         list = folder_item_get_msg_list(queue);
1076         res = (list == NULL);
1077         procmsg_msg_list_free(list);
1078
1079         if (res == TRUE) {
1080                 GNode *node, *next;
1081                 if (queue->node && queue->node->children) {
1082                         node = queue->node->children;
1083                         while (node != NULL) {
1084                                 next = node->next;
1085                                 if (!procmsg_queue_is_empty(FOLDER_ITEM(node->data)))
1086                                         return FALSE;
1087                                 node = next;
1088                         }
1089                 }
1090         }
1091         return res;
1092 }
1093
1094 gint procmsg_remove_special_headers(const gchar *in, const gchar *out)
1095 {
1096         FILE *fp, *outfp;
1097         gchar buf[BUFFSIZE];
1098
1099         if ((fp = g_fopen(in, "rb")) == NULL) {
1100                 FILE_OP_ERROR(in, "fopen");
1101                 return -1;
1102         }
1103         if ((outfp = g_fopen(out, "wb")) == NULL) {
1104                 FILE_OP_ERROR(out, "fopen");
1105                 fclose(fp);
1106                 return -1;
1107         }
1108         while (fgets(buf, sizeof(buf), fp) != NULL) {
1109                 /* new way */
1110                 if ((!strncmp(buf, "X-Claws-End-Special-Headers: 1",
1111                         strlen("X-Claws-End-Special-Headers:"))) ||
1112                     (!strncmp(buf, "X-Sylpheed-End-Special-Headers: 1",
1113                         strlen("X-Sylpheed-End-Special-Headers:"))))
1114                         break;
1115                 /* old way */
1116                 if (buf[0] == '\r' || buf[0] == '\n') break;
1117                 /* from other mailers */
1118                 if (!strncmp(buf, "Date: ", 6)
1119                 ||  !strncmp(buf, "To: ", 4)
1120                 ||  !strncmp(buf, "From: ", 6)
1121                 ||  !strncmp(buf, "Subject: ", 9)) {
1122                         rewind(fp);
1123                         break;
1124                 }
1125         }
1126         while (fgets(buf, sizeof(buf), fp) != NULL) {
1127                 if (fputs(buf, outfp) == EOF) {
1128                         FILE_OP_ERROR(out, "fputs");
1129                         fclose(outfp);
1130                         fclose(fp);
1131                         return -1;
1132                 }
1133         }
1134         fclose(outfp);
1135         fclose(fp);
1136         return 0;
1137 }
1138
1139 gint procmsg_save_to_outbox(FolderItem *outbox, const gchar *file,
1140                             gboolean is_queued)
1141 {
1142         gint num;
1143         MsgInfo *msginfo, *tmp_msginfo;
1144         MsgFlags flag = {0, 0};
1145
1146         debug_print("saving sent message...\n");
1147
1148         if (!outbox)
1149                 outbox = folder_get_default_outbox();
1150         cm_return_val_if_fail(outbox != NULL, -1);
1151
1152         /* remove queueing headers */
1153         if (is_queued) {
1154                 gchar tmp[MAXPATHLEN + 1];
1155
1156                 g_snprintf(tmp, sizeof(tmp), "%s%ctmpmsg.out.%08x",
1157                            get_rc_dir(), G_DIR_SEPARATOR, (guint) rand());
1158
1159                 if (procmsg_remove_special_headers(file, tmp) !=0)
1160                         return -1;
1161
1162                 folder_item_scan(outbox);
1163                 if ((num = folder_item_add_msg(outbox, tmp, &flag, TRUE)) < 0) {
1164                         g_warning("can't save message\n");
1165                         claws_unlink(tmp);
1166                         return -1;
1167                 }
1168         } else {
1169                 folder_item_scan(outbox);
1170                 if ((num = folder_item_add_msg
1171                         (outbox, file, &flag, FALSE)) < 0) {
1172                         g_warning("can't save message\n");
1173                         return -1;
1174                 }
1175         }
1176         msginfo = folder_item_get_msginfo(outbox, num);         /* refcnt++ */
1177         tmp_msginfo = procmsg_msginfo_get_full_info(msginfo);   /* refcnt++ */
1178         if (msginfo != NULL) {
1179                 procmsg_msginfo_unset_flags(msginfo, ~0, 0);
1180                 procmsg_msginfo_free(msginfo);                  /* refcnt-- */
1181                 /* tmp_msginfo == msginfo */
1182                 if (tmp_msginfo && msginfo->extradata &&
1183                     (msginfo->extradata->dispositionnotificationto ||
1184                      msginfo->extradata->returnreceiptto)) {
1185                         procmsg_msginfo_set_flags(msginfo, MSG_RETRCPT_SENT, 0);
1186                 }
1187                 procmsg_msginfo_free(tmp_msginfo);              /* refcnt-- */
1188         }
1189
1190         return 0;
1191 }
1192
1193
1194 MsgInfo *procmsg_msginfo_new_ref(MsgInfo *msginfo)
1195 {
1196         msginfo->refcnt++;
1197
1198         return msginfo;
1199 }
1200
1201 MsgInfo *procmsg_msginfo_new(void)
1202 {
1203         MsgInfo *newmsginfo;
1204
1205         newmsginfo = g_new0(MsgInfo, 1);
1206         newmsginfo->refcnt = 1;
1207
1208         return newmsginfo;
1209 }
1210
1211 static MsgInfoAvatar *procmsg_msginfoavatar_copy(MsgInfoAvatar *avatar)
1212 {
1213         MsgInfoAvatar *newavatar;
1214
1215         if (avatar == NULL) return NULL;
1216
1217         newavatar = g_new0(MsgInfoAvatar, 1);
1218         newavatar->avatar_id = avatar->avatar_id;
1219         newavatar->avatar_src = g_strdup(avatar->avatar_src);
1220
1221         return newavatar;
1222 }
1223
1224 static void procmsg_msginfoavatar_free(MsgInfoAvatar *avatar)
1225 {
1226         if (avatar != NULL) {
1227                 if (avatar->avatar_src != NULL)
1228                         g_free(avatar->avatar_src);
1229                 g_free(avatar);
1230         }
1231 }
1232
1233 MsgInfo *procmsg_msginfo_copy(MsgInfo *msginfo)
1234 {
1235         MsgInfo *newmsginfo;
1236         GSList *refs;
1237
1238         if (msginfo == NULL) return NULL;
1239
1240         newmsginfo = g_new0(MsgInfo, 1);
1241
1242         newmsginfo->refcnt = 1;
1243
1244 #define MEMBCOPY(mmb)   newmsginfo->mmb = msginfo->mmb
1245 #define MEMBDUP(mmb)    newmsginfo->mmb = msginfo->mmb ? \
1246                         g_strdup(msginfo->mmb) : NULL
1247
1248         MEMBCOPY(msgnum);
1249         MEMBCOPY(size);
1250         MEMBCOPY(mtime);
1251         MEMBCOPY(date_t);
1252
1253         MEMBCOPY(flags);
1254
1255         MEMBDUP(fromname);
1256
1257         MEMBDUP(date);
1258         MEMBDUP(from);
1259         MEMBDUP(to);
1260         MEMBDUP(cc);
1261         MEMBDUP(newsgroups);
1262         MEMBDUP(subject);
1263         MEMBDUP(msgid);
1264         MEMBDUP(inreplyto);
1265         MEMBDUP(xref);
1266
1267         MEMBCOPY(folder);
1268         MEMBCOPY(to_folder);
1269
1270         if (msginfo->extradata) {
1271                 newmsginfo->extradata = g_new0(MsgInfoExtraData, 1);
1272                 if (msginfo->extradata->avatars) {
1273                         newmsginfo->extradata->avatars = slist_copy_deep(msginfo->extradata->avatars,
1274                                                                 (GCopyFunc) procmsg_msginfoavatar_copy);
1275                 }
1276                 MEMBDUP(extradata->dispositionnotificationto);
1277                 MEMBDUP(extradata->returnreceiptto);
1278                 MEMBDUP(extradata->partial_recv);
1279                 MEMBDUP(extradata->account_server);
1280                 MEMBDUP(extradata->account_login);
1281                 MEMBDUP(extradata->list_post);
1282                 MEMBDUP(extradata->list_subscribe);
1283                 MEMBDUP(extradata->list_unsubscribe);
1284                 MEMBDUP(extradata->list_help);
1285                 MEMBDUP(extradata->list_archive);
1286                 MEMBDUP(extradata->list_owner);
1287                 MEMBDUP(extradata->resent_from);
1288         }
1289
1290         refs = msginfo->references;
1291         for (refs = msginfo->references; refs != NULL; refs = refs->next) {
1292                 newmsginfo->references = g_slist_prepend
1293                         (newmsginfo->references, g_strdup(refs->data));
1294         }
1295         newmsginfo->references = g_slist_reverse(newmsginfo->references);
1296
1297         MEMBCOPY(score);
1298         MEMBDUP(plaintext_file);
1299
1300         return newmsginfo;
1301 }
1302
1303 MsgInfo *procmsg_msginfo_get_full_info_from_file(MsgInfo *msginfo, const gchar *file)
1304 {
1305         MsgInfo *full_msginfo;
1306
1307         if (msginfo == NULL) return NULL;
1308
1309         if (!file || !is_file_exist(file)) {
1310                 g_warning("procmsg_msginfo_get_full_info_from_file(): can't get message file.\n");
1311                 return NULL;
1312         }
1313
1314         full_msginfo = procheader_parse_file(file, msginfo->flags, TRUE, FALSE);
1315         if (!full_msginfo) return NULL;
1316
1317         msginfo->total_size = full_msginfo->total_size;
1318         msginfo->planned_download = full_msginfo->planned_download;
1319
1320         if (full_msginfo->extradata) {
1321                 if (!msginfo->extradata)
1322                         msginfo->extradata = g_new0(MsgInfoExtraData, 1);
1323                 if (!msginfo->extradata->list_post)
1324                         msginfo->extradata->list_post = g_strdup(full_msginfo->extradata->list_post);
1325                 if (!msginfo->extradata->list_subscribe)
1326                         msginfo->extradata->list_subscribe = g_strdup(full_msginfo->extradata->list_subscribe);
1327                 if (!msginfo->extradata->list_unsubscribe)
1328                         msginfo->extradata->list_unsubscribe = g_strdup(full_msginfo->extradata->list_unsubscribe);
1329                 if (!msginfo->extradata->list_help)
1330                         msginfo->extradata->list_help = g_strdup(full_msginfo->extradata->list_help);
1331                 if (!msginfo->extradata->list_archive)
1332                         msginfo->extradata->list_archive= g_strdup(full_msginfo->extradata->list_archive);
1333                 if (!msginfo->extradata->list_owner)
1334                         msginfo->extradata->list_owner = g_strdup(full_msginfo->extradata->list_owner);
1335                 if (!msginfo->extradata->avatars)
1336                         msginfo->extradata->avatars = slist_copy_deep(full_msginfo->extradata->avatars,
1337                                                                         (GCopyFunc) procmsg_msginfoavatar_copy);
1338                 if (!msginfo->extradata->dispositionnotificationto)
1339                         msginfo->extradata->dispositionnotificationto =
1340                                 g_strdup(full_msginfo->extradata->dispositionnotificationto);
1341                 if (!msginfo->extradata->returnreceiptto)
1342                         msginfo->extradata->returnreceiptto = g_strdup
1343                                 (full_msginfo->extradata->returnreceiptto);
1344                 if (!msginfo->extradata->partial_recv && full_msginfo->extradata->partial_recv)
1345                         msginfo->extradata->partial_recv = g_strdup
1346                                 (full_msginfo->extradata->partial_recv);
1347                 if (!msginfo->extradata->account_server && full_msginfo->extradata->account_server)
1348                         msginfo->extradata->account_server = g_strdup
1349                                 (full_msginfo->extradata->account_server);
1350                 if (!msginfo->extradata->account_login && full_msginfo->extradata->account_login)
1351                         msginfo->extradata->account_login = g_strdup
1352                                 (full_msginfo->extradata->account_login);
1353                 if (!msginfo->extradata->resent_from && full_msginfo->extradata->resent_from)
1354                         msginfo->extradata->resent_from = g_strdup
1355                                 (full_msginfo->extradata->resent_from);
1356         }
1357         procmsg_msginfo_free(full_msginfo);
1358
1359         return procmsg_msginfo_new_ref(msginfo);
1360 }
1361
1362 MsgInfo *procmsg_msginfo_get_full_info(MsgInfo *msginfo)
1363 {
1364         MsgInfo *full_msginfo;
1365         gchar *file;
1366
1367         if (msginfo == NULL) return NULL;
1368
1369         file = procmsg_get_message_file_path(msginfo);
1370         if (!file || !is_file_exist(file)) {
1371                 g_free(file);
1372                 file = procmsg_get_message_file(msginfo);
1373         }
1374         if (!file || !is_file_exist(file)) {
1375                 g_warning("procmsg_msginfo_get_full_info(): can't get message file.\n");
1376                 return NULL;
1377         }
1378
1379         full_msginfo = procmsg_msginfo_get_full_info_from_file(msginfo, file);
1380         g_free(file);
1381         return full_msginfo;
1382 }
1383
1384 void procmsg_msginfo_free(MsgInfo *msginfo)
1385 {
1386         if (msginfo == NULL) return;
1387
1388         msginfo->refcnt--;
1389         if (msginfo->refcnt > 0)
1390                 return;
1391
1392         if (msginfo->to_folder) {
1393                 msginfo->to_folder->op_count--;
1394                 folder_item_update(msginfo->to_folder, F_ITEM_UPDATE_MSGCNT);
1395         }
1396
1397         g_free(msginfo->fromspace);
1398
1399         g_free(msginfo->fromname);
1400
1401         g_free(msginfo->date);
1402         g_free(msginfo->from);
1403         g_free(msginfo->to);
1404         g_free(msginfo->cc);
1405         g_free(msginfo->newsgroups);
1406         g_free(msginfo->subject);
1407         g_free(msginfo->msgid);
1408         g_free(msginfo->inreplyto);
1409         g_free(msginfo->xref);
1410
1411         if (msginfo->extradata) {
1412                 if (msginfo->extradata->avatars) {
1413                         g_slist_foreach(msginfo->extradata->avatars,
1414                                         (GFunc)procmsg_msginfoavatar_free,
1415                                         NULL);
1416                         g_slist_free(msginfo->extradata->avatars);
1417                 }
1418                 g_free(msginfo->extradata->returnreceiptto);
1419                 g_free(msginfo->extradata->dispositionnotificationto);
1420                 g_free(msginfo->extradata->list_post);
1421                 g_free(msginfo->extradata->list_subscribe);
1422                 g_free(msginfo->extradata->list_unsubscribe);
1423                 g_free(msginfo->extradata->list_help);
1424                 g_free(msginfo->extradata->list_archive);
1425                 g_free(msginfo->extradata->list_owner);
1426                 g_free(msginfo->extradata->partial_recv);
1427                 g_free(msginfo->extradata->account_server);
1428                 g_free(msginfo->extradata->account_login);
1429                 g_free(msginfo->extradata->resent_from);
1430                 g_free(msginfo->extradata);
1431         }
1432         slist_free_strings_full(msginfo->references);
1433         g_slist_free(msginfo->tags);
1434
1435         g_free(msginfo->plaintext_file);
1436
1437         g_free(msginfo);
1438 }
1439
1440 guint procmsg_msginfo_memusage(MsgInfo *msginfo)
1441 {
1442         guint memusage = 0;
1443         GSList *tmp;
1444
1445         memusage += sizeof(MsgInfo);
1446         if (msginfo->fromname)
1447                 memusage += strlen(msginfo->fromname);
1448         if (msginfo->date)
1449                 memusage += strlen(msginfo->date);
1450         if (msginfo->from)
1451                 memusage += strlen(msginfo->from);
1452         if (msginfo->to)
1453                 memusage += strlen(msginfo->to);
1454         if (msginfo->cc)
1455                 memusage += strlen(msginfo->cc);
1456         if (msginfo->newsgroups)
1457                 memusage += strlen(msginfo->newsgroups);
1458         if (msginfo->subject)
1459                 memusage += strlen(msginfo->subject);
1460         if (msginfo->msgid)
1461                 memusage += strlen(msginfo->msgid);
1462         if (msginfo->inreplyto)
1463                 memusage += strlen(msginfo->inreplyto);
1464
1465         for (tmp = msginfo->references; tmp; tmp=tmp->next) {
1466                 gchar *r = (gchar *)tmp->data;
1467                 memusage += r?strlen(r):0 + sizeof(GSList);
1468         }
1469         if (msginfo->fromspace)
1470                 memusage += strlen(msginfo->fromspace);
1471
1472         for (tmp = msginfo->tags; tmp; tmp=tmp->next) {
1473                 memusage += sizeof(GSList);
1474         }
1475         if (msginfo->extradata) {
1476                 memusage += sizeof(MsgInfoExtraData);
1477                 if (msginfo->extradata->avatars) {
1478                         for (tmp = msginfo->extradata->avatars; tmp; tmp = tmp->next) {
1479                                 MsgInfoAvatar *avt = (MsgInfoAvatar *)tmp->data;
1480                                 memusage += (avt->avatar_src)? strlen(avt->avatar_src): 0;
1481                                 memusage += sizeof(MsgInfoAvatar) + sizeof(GSList);
1482                         }
1483                 }
1484                 if (msginfo->extradata->dispositionnotificationto)
1485                         memusage += strlen(msginfo->extradata->dispositionnotificationto);
1486                 if (msginfo->extradata->returnreceiptto)
1487                         memusage += strlen(msginfo->extradata->returnreceiptto);
1488
1489                 if (msginfo->extradata->partial_recv)
1490                         memusage += strlen(msginfo->extradata->partial_recv);
1491                 if (msginfo->extradata->account_server)
1492                         memusage += strlen(msginfo->extradata->account_server);
1493                 if (msginfo->extradata->account_login)
1494                         memusage += strlen(msginfo->extradata->account_login);
1495                 if (msginfo->extradata->resent_from)
1496                         memusage += strlen(msginfo->extradata->resent_from);
1497
1498                 if (msginfo->extradata->list_post)
1499                         memusage += strlen(msginfo->extradata->list_post);
1500                 if (msginfo->extradata->list_subscribe)
1501                         memusage += strlen(msginfo->extradata->list_subscribe);
1502                 if (msginfo->extradata->list_unsubscribe)
1503                         memusage += strlen(msginfo->extradata->list_unsubscribe);
1504                 if (msginfo->extradata->list_help)
1505                         memusage += strlen(msginfo->extradata->list_help);
1506                 if (msginfo->extradata->list_archive)
1507                         memusage += strlen(msginfo->extradata->list_archive);
1508                 if (msginfo->extradata->list_owner)
1509                         memusage += strlen(msginfo->extradata->list_owner);
1510         }
1511         return memusage;
1512 }
1513
1514 static gint procmsg_send_message_queue_full(const gchar *file, gboolean keep_session, gchar **errstr,
1515                                             FolderItem *queue, gint msgnum, gboolean *queued_removed)
1516 {
1517         static HeaderEntry qentry[] = {
1518                                        {"S:",    NULL, FALSE}, /* 0 */
1519                                        {"SSV:",  NULL, FALSE},
1520                                        {"R:",    NULL, FALSE},
1521                                        {"NG:",   NULL, FALSE},
1522                                        {"MAID:", NULL, FALSE},
1523                                        {"NAID:", NULL, FALSE}, /* 5 */
1524                                        {"SCF:",  NULL, FALSE},
1525                                        {"RMID:", NULL, FALSE},
1526                                        {"FMID:", NULL, FALSE},
1527                                        {"X-Claws-Privacy-System:", NULL, FALSE},
1528                                        {"X-Claws-Encrypt:", NULL, FALSE}, /* 10 */
1529                                        {"X-Claws-Encrypt-Data:", NULL, FALSE},
1530                                        {"X-Claws-End-Special-Headers:", NULL, FALSE},
1531                                        {"X-Sylpheed-Privacy-System:", NULL, FALSE},
1532                                        {"X-Sylpheed-Encrypt:", NULL, FALSE},
1533                                        {"X-Sylpheed-Encrypt-Data:", NULL, FALSE}, /* 15 */
1534                                        {"X-Sylpheed-End-Special-Headers:", NULL, FALSE},
1535                                        {NULL,    NULL, FALSE}};
1536         FILE *fp;
1537         gint filepos;
1538         gint mailval = 0, newsval = 0;
1539         gchar *from = NULL;
1540         gchar *smtpserver = NULL;
1541         GSList *to_list = NULL;
1542         GSList *newsgroup_list = NULL;
1543         gchar *savecopyfolder = NULL;
1544         gchar *replymessageid = NULL;
1545         gchar *fwdmessageid = NULL;
1546         gchar buf[BUFFSIZE];
1547         gint hnum;
1548         PrefsAccount *mailac = NULL, *newsac = NULL;
1549         gboolean encrypt = FALSE;
1550         FolderItem *outbox;
1551
1552         cm_return_val_if_fail(file != NULL, -1);
1553
1554         if ((fp = g_fopen(file, "rb")) == NULL) {
1555                 FILE_OP_ERROR(file, "fopen");
1556                 if (errstr) {
1557                         if (*errstr) g_free(*errstr);
1558                         *errstr = g_strdup_printf(_("Couldn't open file %s."), file);
1559                 }
1560                 return -1;
1561         }
1562
1563         while ((hnum = procheader_get_one_field(buf, sizeof(buf), fp, qentry))
1564                != -1) {
1565                 gchar *p = buf + strlen(qentry[hnum].name);
1566
1567                 switch (hnum) {
1568                 case Q_SENDER:
1569                         if (from == NULL)
1570                                 from = g_strdup(p);
1571                         break;
1572                 case Q_SMTPSERVER:
1573                         if (smtpserver == NULL)
1574                                 smtpserver = g_strdup(p);
1575                         break;
1576                 case Q_RECIPIENTS:
1577                         to_list = address_list_append(to_list, p);
1578                         break;
1579                 case Q_NEWSGROUPS:
1580                         newsgroup_list = newsgroup_list_append(newsgroup_list, p);
1581                         break;
1582                 case Q_MAIL_ACCOUNT_ID:
1583                         mailac = account_find_from_id(atoi(p));
1584                         break;
1585                 case Q_NEWS_ACCOUNT_ID:
1586                         newsac = account_find_from_id(atoi(p));
1587                         break;
1588                 case Q_SAVE_COPY_FOLDER:
1589                         if (savecopyfolder == NULL)
1590                                 savecopyfolder = g_strdup(p);
1591                         break;
1592                 case Q_REPLY_MESSAGE_ID:
1593                         if (replymessageid == NULL)
1594                                 replymessageid = g_strdup(p);
1595                         break;
1596                 case Q_FWD_MESSAGE_ID:
1597                         if (fwdmessageid == NULL)
1598                                 fwdmessageid = g_strdup(p);
1599                         break;
1600                 case Q_ENCRYPT:
1601                 case Q_ENCRYPT_OLD:
1602                         if (p[0] == '1')
1603                                 encrypt = TRUE;
1604                         break;
1605                 case Q_CLAWS_HDRS:
1606                 case Q_CLAWS_HDRS_OLD:
1607                         /* end of special headers reached */
1608                         goto send_mail; /* can't "break;break;" */
1609                 }
1610         }
1611 send_mail:
1612         filepos = ftell(fp);
1613         if (filepos < 0) {
1614                 FILE_OP_ERROR(file, "ftell");
1615                 if (errstr) {
1616                         if (*errstr) g_free(*errstr);
1617                         *errstr = g_strdup_printf(_("Couldn't open file %s."), file);
1618                 }
1619                 return -1;
1620         }
1621
1622         if (to_list) {
1623                 debug_print("Sending message by mail\n");
1624                 if (!from) {
1625                         if (errstr) {
1626                                 if (*errstr) g_free(*errstr);
1627                                 *errstr = g_strdup_printf(_("Queued message header is broken."));
1628                         }
1629                         mailval = -1;
1630                 } else if (mailac && mailac->use_mail_command &&
1631                            mailac->mail_command && (* mailac->mail_command)) {
1632                         mailval = send_message_local(mailac->mail_command, fp);
1633                 } else {
1634                         if (!mailac) {
1635                                 mailac = account_find_from_smtp_server(from, smtpserver);
1636                                 if (!mailac) {
1637                                         g_warning("Account not found. "
1638                                                     "Using current account...\n");
1639                                         mailac = cur_account;
1640                                 }
1641                         }
1642
1643                         if (mailac) {
1644                                 mailval = send_message_smtp_full(mailac, to_list, fp, keep_session);
1645                                 if (mailval == -1 && errstr) {
1646                                         if (*errstr) g_free(*errstr);
1647                                         *errstr = g_strdup_printf(_("An error happened during SMTP session."));
1648                                 }
1649                         } else {
1650                                 PrefsAccount tmp_ac;
1651
1652                                 g_warning("Account not found.\n");
1653
1654                                 memset(&tmp_ac, 0, sizeof(PrefsAccount));
1655                                 tmp_ac.address = from;
1656                                 tmp_ac.smtp_server = smtpserver;
1657                                 tmp_ac.smtpport = SMTP_PORT;
1658                                 mailval = send_message_smtp(&tmp_ac, to_list, fp);
1659                                 if (mailval == -1 && errstr) {
1660                                         if (*errstr) g_free(*errstr);
1661                                         *errstr = g_strdup_printf(_("No specific account has been found to "
1662                                                         "send, and an error happened during SMTP session."));
1663                                 }
1664                         }
1665                 }
1666         } else if (!to_list && !newsgroup_list) {
1667                 if (errstr) {
1668                         if (*errstr) g_free(*errstr);
1669                         *errstr = g_strdup(_("Couldn't determine sending information. "
1670                                 "Maybe the email hasn't been generated by Claws Mail."));
1671                 }
1672                 mailval = -1;
1673         }
1674
1675         if (fseek(fp, filepos, SEEK_SET) < 0) {
1676                 FILE_OP_ERROR(file, "fseek");
1677                 mailval = -1;
1678         }
1679
1680         if (newsgroup_list && newsac && (mailval == 0)) {
1681                 Folder *folder;
1682                 gchar *tmp = NULL;
1683                 FILE *tmpfp;
1684
1685                 /* write to temporary file */
1686                 tmp = g_strdup_printf("%s%cnntp%p", get_tmp_dir(),
1687                             G_DIR_SEPARATOR, file);
1688                 if ((tmpfp = g_fopen(tmp, "wb")) == NULL) {
1689                         FILE_OP_ERROR(tmp, "fopen");
1690                         newsval = -1;
1691                         alertpanel_error(_("Couldn't create temporary file for news sending."));
1692                 } else {
1693                         if (change_file_mode_rw(tmpfp, tmp) < 0) {
1694                                 FILE_OP_ERROR(tmp, "chmod");
1695                                 g_warning("can't change file mode\n");
1696                         }
1697
1698                         while ((newsval == 0) && fgets(buf, sizeof(buf), fp) != NULL) {
1699                                 if (fputs(buf, tmpfp) == EOF) {
1700                                         FILE_OP_ERROR(tmp, "fputs");
1701                                         newsval = -1;
1702                                         if (errstr) {
1703                                                 if (*errstr) g_free(*errstr);
1704                                                 *errstr = g_strdup_printf(_("Error when writing temporary file for news sending."));
1705                                         }
1706                                 }
1707                         }
1708                         fclose(tmpfp);
1709
1710                         if (newsval == 0) {
1711                                 debug_print("Sending message by news\n");
1712
1713                                 folder = FOLDER(newsac->folder);
1714
1715                                 newsval = news_post(folder, tmp);
1716                                 if (newsval < 0 && errstr)  {
1717                                         if (*errstr) g_free(*errstr);
1718                                         *errstr = g_strdup_printf(_("Error occurred while posting the message to %s."),
1719                                          newsac->nntp_server);
1720                                 }
1721                         }
1722                         claws_unlink(tmp);
1723                 }
1724                 g_free(tmp);
1725         }
1726
1727         fclose(fp);
1728
1729         /* update session statistics */
1730         if (mailval == 0 && newsval == 0) {
1731                 /* update session stats */
1732                 if (replymessageid)
1733                         session_stats.replied++;
1734                 else if (fwdmessageid)
1735                         session_stats.forwarded++;
1736                 else
1737                         session_stats.sent++;
1738         }
1739
1740         /* save message to outbox */
1741         if (mailval == 0 && newsval == 0 && savecopyfolder) {
1742                 debug_print("saving sent message...\n");
1743
1744                 if (!encrypt || !mailac->save_encrypted_as_clear_text) {
1745                         outbox = folder_find_item_from_identifier(savecopyfolder);
1746                         if (!outbox)
1747                                 outbox = folder_get_default_outbox();
1748
1749                         /* Mail was not saved to outbox before encrypting, save it now. */
1750                         gboolean saved = FALSE;
1751                         *queued_removed = FALSE;
1752                         if (queue && msgnum > 0) {
1753                                 MsgInfo *queued_mail = folder_item_get_msginfo(queue, msgnum);
1754                                 if (folder_item_move_msg(outbox, queued_mail) >= 0) {
1755                                         debug_print("moved queued mail %d to sent folder\n", msgnum);
1756                                         saved = TRUE;
1757                                         *queued_removed = TRUE;
1758                                 } else if (folder_item_copy_msg(outbox, queued_mail) >= 0) {
1759                                         debug_print("copied queued mail %d to sent folder\n", msgnum);
1760                                         saved = TRUE;
1761                                 }
1762                                 procmsg_msginfo_free(queued_mail);
1763                         }
1764                         if (!saved) {
1765                                 debug_print("resaving queued mail to sent folder\n");
1766                                 procmsg_save_to_outbox(outbox, file, TRUE);
1767                         }
1768                 }
1769         }
1770
1771         if (replymessageid != NULL || fwdmessageid != NULL) {
1772                 gchar **tokens;
1773                 FolderItem *item;
1774
1775                 if (replymessageid != NULL)
1776                         tokens = g_strsplit(replymessageid, "\t", 0);
1777                 else
1778                         tokens = g_strsplit(fwdmessageid, "\t", 0);
1779                 item = folder_find_item_from_identifier(tokens[0]);
1780
1781                 /* check if queued message has valid folder and message id */
1782                 if (item != NULL && tokens[2] != NULL) {
1783                         MsgInfo *msginfo;
1784
1785                         msginfo = folder_item_get_msginfo(item, atoi(tokens[1]));
1786
1787                         /* check if referring message exists and has a message id */
1788                         if ((msginfo != NULL) &&
1789                             (msginfo->msgid != NULL) &&
1790                             (strcmp(msginfo->msgid, tokens[2]) != 0)) {
1791                                 procmsg_msginfo_free(msginfo);
1792                                 msginfo = NULL;
1793                         }
1794
1795                         if (msginfo == NULL) {
1796                                 msginfo = folder_item_get_msginfo_by_msgid(item, tokens[2]);
1797                         }
1798
1799                         if (msginfo != NULL) {
1800                                 if (replymessageid != NULL) {
1801                                         MsgPermFlags to_unset = 0;
1802
1803                                         if (prefs_common.mark_as_read_on_new_window)
1804                                                 to_unset = (MSG_NEW|MSG_UNREAD);
1805
1806                                         procmsg_msginfo_unset_flags(msginfo, to_unset, 0);
1807                                         procmsg_msginfo_set_flags(msginfo, MSG_REPLIED, 0);
1808                                 }  else {
1809                                         procmsg_msginfo_set_flags(msginfo, MSG_FORWARDED, 0);
1810                                 }
1811                                 procmsg_msginfo_free(msginfo);
1812                         }
1813                 }
1814                 g_strfreev(tokens);
1815         }
1816
1817         g_free(from);
1818         g_free(smtpserver);
1819         slist_free_strings_full(to_list);
1820         slist_free_strings_full(newsgroup_list);
1821         g_free(savecopyfolder);
1822         g_free(replymessageid);
1823         g_free(fwdmessageid);
1824
1825         return (newsval != 0 ? newsval : mailval);
1826 }
1827
1828 gint procmsg_send_message_queue(const gchar *file, gchar **errstr, FolderItem *queue, gint msgnum, gboolean *queued_removed)
1829 {
1830         gint result = procmsg_send_message_queue_full(file, FALSE, errstr, queue, msgnum, queued_removed);
1831         main_window_set_menu_sensitive(mainwindow_get_mainwindow());
1832         toolbar_main_set_sensitive(mainwindow_get_mainwindow());
1833         return result;
1834 }
1835
1836 gint procmsg_send_message_queue_with_lock(const gchar *file, gchar **errstr, FolderItem *queue, gint msgnum, gboolean *queued_removed)
1837 {
1838         gint val;
1839         if (procmsg_queue_lock(errstr)) {
1840                 val = procmsg_send_message_queue(file, errstr, queue, msgnum, queued_removed);
1841                 procmsg_queue_unlock();
1842                 return val;
1843         }
1844         return -1;
1845 }
1846
1847 static void update_folder_msg_counts(FolderItem *item, MsgInfo *msginfo, MsgPermFlags old_flags)
1848 {
1849         MsgPermFlags new_flags = msginfo->flags.perm_flags;
1850
1851         /* NEW flag */
1852         if (!(old_flags & MSG_NEW) && (new_flags & MSG_NEW)) {
1853                 item->new_msgs++;
1854         }
1855
1856         if ((old_flags & MSG_NEW) && !(new_flags & MSG_NEW)) {
1857                 item->new_msgs--;
1858         }
1859
1860         /* UNREAD flag */
1861         if (!(old_flags & MSG_UNREAD) && (new_flags & MSG_UNREAD)) {
1862                 item->unread_msgs++;
1863                 if (procmsg_msg_has_marked_parent(msginfo))
1864                         item->unreadmarked_msgs++;
1865         }
1866
1867         if ((old_flags & MSG_UNREAD) && !(new_flags & MSG_UNREAD)) {
1868                 item->unread_msgs--;
1869                 if (procmsg_msg_has_marked_parent(msginfo))
1870                         item->unreadmarked_msgs--;
1871         }
1872
1873         /* MARK flag */
1874         if (!(old_flags & MSG_MARKED) && (new_flags & MSG_MARKED)) {
1875                 procmsg_update_unread_children(msginfo, TRUE);
1876                 item->marked_msgs++;
1877         }
1878
1879         if ((old_flags & MSG_MARKED) && !(new_flags & MSG_MARKED)) {
1880                 procmsg_update_unread_children(msginfo, FALSE);
1881                 item->marked_msgs--;
1882         }
1883
1884         if (!(old_flags & MSG_REPLIED) && (new_flags & MSG_REPLIED)) {
1885                 item->replied_msgs++;
1886         }
1887
1888         if ((old_flags & MSG_REPLIED) && !(new_flags & MSG_REPLIED)) {
1889                 item->replied_msgs--;
1890         }
1891
1892         if (!(old_flags & MSG_FORWARDED) && (new_flags & MSG_FORWARDED)) {
1893                 item->forwarded_msgs++;
1894         }
1895
1896         if ((old_flags & MSG_FORWARDED) && !(new_flags & MSG_FORWARDED)) {
1897                 item->forwarded_msgs--;
1898         }
1899
1900         if (!(old_flags & MSG_LOCKED) && (new_flags & MSG_LOCKED)) {
1901                 item->locked_msgs++;
1902         }
1903
1904         if ((old_flags & MSG_LOCKED) && !(new_flags & MSG_LOCKED)) {
1905                 item->locked_msgs--;
1906         }
1907
1908         if ((old_flags & MSG_IGNORE_THREAD) && !(new_flags & MSG_IGNORE_THREAD)) {
1909                 item->ignored_msgs--;
1910         }
1911
1912         if (!(old_flags & MSG_IGNORE_THREAD) && (new_flags & MSG_IGNORE_THREAD)) {
1913                 item->ignored_msgs++;
1914         }
1915
1916         if ((old_flags & MSG_WATCH_THREAD) && !(new_flags & MSG_WATCH_THREAD)) {
1917                 item->watched_msgs--;
1918         }
1919
1920         if (!(old_flags & MSG_WATCH_THREAD) && (new_flags & MSG_WATCH_THREAD)) {
1921                 item->watched_msgs++;
1922         }
1923 }
1924
1925 void procmsg_msginfo_set_flags(MsgInfo *msginfo, MsgPermFlags perm_flags, MsgTmpFlags tmp_flags)
1926 {
1927         FolderItem *item;
1928         MsgInfoUpdate msginfo_update;
1929         MsgPermFlags perm_flags_new, perm_flags_old;
1930         MsgTmpFlags tmp_flags_old;
1931
1932         cm_return_if_fail(msginfo != NULL);
1933         item = msginfo->folder;
1934         cm_return_if_fail(item != NULL);
1935
1936         debug_print("Setting flags for message %d in folder %s\n", msginfo->msgnum, item->path);
1937
1938         /* Perm Flags handling */
1939         perm_flags_old = msginfo->flags.perm_flags;
1940         perm_flags_new = msginfo->flags.perm_flags | perm_flags;
1941         if ((perm_flags & MSG_IGNORE_THREAD) || (perm_flags_old & MSG_IGNORE_THREAD)) {
1942                 perm_flags_new &= ~(MSG_NEW | MSG_UNREAD);
1943         }
1944         if ((perm_flags & MSG_WATCH_THREAD) || (perm_flags_old & MSG_WATCH_THREAD)) {
1945                 perm_flags_new &= ~(MSG_IGNORE_THREAD);
1946         }
1947
1948         if (perm_flags_old != perm_flags_new) {
1949                 folder_item_change_msg_flags(msginfo->folder, msginfo, perm_flags_new);
1950
1951                 update_folder_msg_counts(item, msginfo, perm_flags_old);
1952                 summary_update_unread(mainwindow_get_mainwindow()->summaryview, NULL);
1953         }
1954
1955         /* Tmp flags handling */
1956         tmp_flags_old = msginfo->flags.tmp_flags;
1957         msginfo->flags.tmp_flags |= tmp_flags;
1958
1959         /* update notification */
1960         if ((perm_flags_old != perm_flags_new) || (tmp_flags_old != msginfo->flags.tmp_flags)) {
1961                 msginfo_update.msginfo = msginfo;
1962                 msginfo_update.flags = MSGINFO_UPDATE_FLAGS;
1963                 hooks_invoke(MSGINFO_UPDATE_HOOKLIST, &msginfo_update);
1964                 folder_item_update(msginfo->folder, F_ITEM_UPDATE_MSGCNT);
1965         }
1966 }
1967
1968 void procmsg_msginfo_unset_flags(MsgInfo *msginfo, MsgPermFlags perm_flags, MsgTmpFlags tmp_flags)
1969 {
1970         FolderItem *item;
1971         MsgInfoUpdate msginfo_update;
1972         MsgPermFlags perm_flags_new, perm_flags_old;
1973         MsgTmpFlags tmp_flags_old;
1974
1975         cm_return_if_fail(msginfo != NULL);
1976         item = msginfo->folder;
1977         cm_return_if_fail(item != NULL);
1978
1979         debug_print("Unsetting flags for message %d in folder %s\n", msginfo->msgnum, item->path);
1980
1981         /* Perm Flags handling */
1982         perm_flags_old = msginfo->flags.perm_flags;
1983         perm_flags_new = msginfo->flags.perm_flags & ~perm_flags;
1984
1985         if (perm_flags_old != perm_flags_new) {
1986                 folder_item_change_msg_flags(msginfo->folder, msginfo, perm_flags_new);
1987
1988                 update_folder_msg_counts(item, msginfo, perm_flags_old);
1989         }
1990
1991         /* Tmp flags hanlding */
1992         tmp_flags_old = msginfo->flags.tmp_flags;
1993         msginfo->flags.tmp_flags &= ~tmp_flags;
1994
1995         /* update notification */
1996         if ((perm_flags_old != perm_flags_new) || (tmp_flags_old != msginfo->flags.tmp_flags)) {
1997                 msginfo_update.msginfo = msginfo;
1998                 msginfo_update.flags = MSGINFO_UPDATE_FLAGS;
1999                 hooks_invoke(MSGINFO_UPDATE_HOOKLIST, &msginfo_update);
2000                 folder_item_update(msginfo->folder, F_ITEM_UPDATE_MSGCNT);
2001         }
2002 }
2003
2004 void procmsg_msginfo_change_flags(MsgInfo *msginfo,
2005                                 MsgPermFlags add_perm_flags, MsgTmpFlags add_tmp_flags,
2006                                 MsgPermFlags rem_perm_flags, MsgTmpFlags rem_tmp_flags)
2007 {
2008         FolderItem *item;
2009         MsgInfoUpdate msginfo_update;
2010         MsgPermFlags perm_flags_new, perm_flags_old;
2011         MsgTmpFlags tmp_flags_old;
2012
2013         cm_return_if_fail(msginfo != NULL);
2014         item = msginfo->folder;
2015         cm_return_if_fail(item != NULL);
2016
2017         debug_print("Changing flags for message %d in folder %s\n", msginfo->msgnum, item->path);
2018
2019         /* Perm Flags handling */
2020         perm_flags_old = msginfo->flags.perm_flags;
2021         perm_flags_new = (msginfo->flags.perm_flags & ~rem_perm_flags) | add_perm_flags;
2022         if ((add_perm_flags & MSG_IGNORE_THREAD) || (perm_flags_old & MSG_IGNORE_THREAD)) {
2023                 perm_flags_new &= ~(MSG_NEW | MSG_UNREAD);
2024         }
2025         if ((add_perm_flags & MSG_WATCH_THREAD) || (perm_flags_old & MSG_WATCH_THREAD)) {
2026                 perm_flags_new &= ~(MSG_IGNORE_THREAD);
2027         }
2028
2029         if (perm_flags_old != perm_flags_new) {
2030                 folder_item_change_msg_flags(msginfo->folder, msginfo, perm_flags_new);
2031
2032                 update_folder_msg_counts(item, msginfo, perm_flags_old);
2033
2034         }
2035
2036         /* Tmp flags handling */
2037         tmp_flags_old = msginfo->flags.tmp_flags;
2038         msginfo->flags.tmp_flags &= ~rem_tmp_flags;
2039         msginfo->flags.tmp_flags |= add_tmp_flags;
2040
2041         /* update notification */
2042         if ((perm_flags_old != perm_flags_new) || (tmp_flags_old != msginfo->flags.tmp_flags)) {
2043                 msginfo_update.msginfo = msginfo;
2044                 msginfo_update.flags = MSGINFO_UPDATE_FLAGS;
2045                 hooks_invoke(MSGINFO_UPDATE_HOOKLIST, &msginfo_update);
2046                 folder_item_update(msginfo->folder, F_ITEM_UPDATE_MSGCNT);
2047         }
2048 }
2049
2050 /*!
2051  *\brief        check for flags (e.g. mark) in prior msgs of current thread
2052  *
2053  *\param        info Current message
2054  *\param        perm_flags Flags to be checked
2055  *\param        parentmsgs Hash of prior msgs to avoid loops
2056  *
2057  *\return       gboolean TRUE if perm_flags are found
2058  */
2059 static gboolean procmsg_msg_has_flagged_parent_real(MsgInfo *info,
2060                 MsgPermFlags perm_flags, GHashTable *parentmsgs)
2061 {
2062         MsgInfo *tmp;
2063
2064         cm_return_val_if_fail(info != NULL, FALSE);
2065
2066         if (info != NULL && info->folder != NULL && info->inreplyto != NULL) {
2067                 tmp = folder_item_get_msginfo_by_msgid(info->folder,
2068                                 info->inreplyto);
2069                 if (tmp && (tmp->flags.perm_flags & perm_flags)) {
2070                         procmsg_msginfo_free(tmp);
2071                         return TRUE;
2072                 } else if (tmp != NULL) {
2073                         gboolean result;
2074
2075                         if (g_hash_table_lookup(parentmsgs, info)) {
2076                                 debug_print("loop detected: %d\n",
2077                                         info->msgnum);
2078                                 result = FALSE;
2079                         } else {
2080                                 g_hash_table_insert(parentmsgs, info, "1");
2081                                 result = procmsg_msg_has_flagged_parent_real(
2082                                     tmp, perm_flags, parentmsgs);
2083                         }
2084                         procmsg_msginfo_free(tmp);
2085                         return result;
2086                 } else {
2087                         return FALSE;
2088                 }
2089         } else
2090                 return FALSE;
2091 }
2092
2093 /*!
2094  *\brief        Callback for cleaning up hash of parentmsgs
2095  */
2096 static gboolean parentmsgs_hash_remove(gpointer key,
2097                             gpointer value,
2098                             gpointer user_data)
2099 {
2100         return TRUE;
2101 }
2102
2103 /*!
2104  *\brief        Set up list of parentmsgs
2105  *              See procmsg_msg_has_flagged_parent_real()
2106  */
2107 gboolean procmsg_msg_has_flagged_parent(MsgInfo *info, MsgPermFlags perm_flags)
2108 {
2109         gboolean result;
2110         static GHashTable *parentmsgs = NULL;
2111
2112         if (parentmsgs == NULL)
2113                 parentmsgs = g_hash_table_new(NULL, NULL);
2114
2115         result = procmsg_msg_has_flagged_parent_real(info, perm_flags, parentmsgs);
2116         g_hash_table_foreach_remove(parentmsgs, parentmsgs_hash_remove, NULL);
2117
2118         return result;
2119 }
2120
2121 /*!
2122  *\brief        Check if msgs prior in thread are marked
2123  *              See procmsg_msg_has_flagged_parent_real()
2124  */
2125 gboolean procmsg_msg_has_marked_parent(MsgInfo *info)
2126 {
2127         return procmsg_msg_has_flagged_parent(info, MSG_MARKED);
2128 }
2129
2130
2131 static GSList *procmsg_find_children_func(MsgInfo *info,
2132                                    GSList *children, GSList *all)
2133 {
2134         GSList *cur;
2135
2136         cm_return_val_if_fail(info!=NULL, children);
2137         if (info->msgid == NULL)
2138                 return children;
2139
2140         for (cur = all; cur != NULL; cur = g_slist_next(cur)) {
2141                 MsgInfo *tmp = (MsgInfo *)cur->data;
2142                 if (tmp->inreplyto && !strcmp(tmp->inreplyto, info->msgid)) {
2143                         /* Check if message is already in the list */
2144                         if ((children == NULL) ||
2145                             (g_slist_index(children, tmp) == -1)) {
2146                                 children = g_slist_prepend(children,
2147                                                 procmsg_msginfo_new_ref(tmp));
2148                                 children = procmsg_find_children_func(tmp,
2149                                                         children,
2150                                                         all);
2151                         }
2152                 }
2153         }
2154         return children;
2155 }
2156
2157 static GSList *procmsg_find_children (MsgInfo *info)
2158 {
2159         GSList *children;
2160         GSList *all, *cur;
2161
2162         cm_return_val_if_fail(info!=NULL, NULL);
2163         all = folder_item_get_msg_list(info->folder);
2164         children = procmsg_find_children_func(info, NULL, all);
2165         if (children != NULL) {
2166                 for (cur = all; cur != NULL; cur = g_slist_next(cur)) {
2167                         /* this will not free the used pointers
2168                            created with procmsg_msginfo_new_ref */
2169                         procmsg_msginfo_free((MsgInfo *)cur->data);
2170                 }
2171         }
2172         g_slist_free(all);
2173
2174         return children;
2175 }
2176
2177 static void procmsg_update_unread_children(MsgInfo *info, gboolean newly_marked)
2178 {
2179         GSList *children = procmsg_find_children(info);
2180         GSList *cur;
2181         for (cur = children; cur != NULL; cur = g_slist_next(cur)) {
2182                 MsgInfo *tmp = (MsgInfo *)cur->data;
2183                 if(MSG_IS_UNREAD(tmp->flags) && !MSG_IS_IGNORE_THREAD(tmp->flags)) {
2184                         if(newly_marked)
2185                                 info->folder->unreadmarked_msgs++;
2186                         else
2187                                 info->folder->unreadmarked_msgs--;
2188                         folder_item_update(info->folder, F_ITEM_UPDATE_MSGCNT);
2189                 }
2190                 procmsg_msginfo_free(tmp);
2191         }
2192         g_slist_free(children);
2193 }
2194
2195 /**
2196  * Set the destination folder for a copy or move operation
2197  *
2198  * \param msginfo The message which's destination folder is changed
2199  * \param to_folder The destination folder for the operation
2200  */
2201 void procmsg_msginfo_set_to_folder(MsgInfo *msginfo, FolderItem *to_folder)
2202 {
2203         if(msginfo->to_folder != NULL) {
2204                 msginfo->to_folder->op_count--;
2205                 folder_item_update(msginfo->to_folder, F_ITEM_UPDATE_MSGCNT);
2206         }
2207         msginfo->to_folder = to_folder;
2208         if(to_folder != NULL) {
2209                 to_folder->op_count++;
2210                 folder_item_update(msginfo->to_folder, F_ITEM_UPDATE_MSGCNT);
2211         }
2212 }
2213
2214 /**
2215  * Apply filtering actions to the msginfo
2216  *
2217  * \param msginfo The MsgInfo describing the message that should be filtered
2218  * \return TRUE if the message was moved and MsgInfo is now invalid,
2219  *         FALSE otherwise
2220  */
2221 static gboolean procmsg_msginfo_filter(MsgInfo *msginfo, PrefsAccount* ac_prefs)
2222 {
2223         MailFilteringData mail_filtering_data;
2224
2225         mail_filtering_data.msginfo = msginfo;
2226         mail_filtering_data.msglist = NULL;
2227         mail_filtering_data.filtered = NULL;
2228         mail_filtering_data.unfiltered = NULL;
2229         mail_filtering_data.account = ac_prefs;
2230
2231         if (!ac_prefs || ac_prefs->filterhook_on_recv)
2232                 if (hooks_invoke(MAIL_FILTERING_HOOKLIST, &mail_filtering_data))
2233                 return TRUE;
2234
2235         /* filter if enabled in prefs or move to inbox if not */
2236         if((filtering_rules != NULL) &&
2237                 filter_message_by_msginfo(filtering_rules, msginfo, ac_prefs,
2238                                 FILTERING_INCORPORATION, NULL)) {
2239                 return TRUE;
2240         }
2241
2242         return FALSE;
2243 }
2244
2245 void procmsg_msglist_filter(GSList *list, PrefsAccount *ac,
2246                             GSList **filtered, GSList **unfiltered,
2247                             gboolean do_filter)
2248 {
2249         GSList *cur, *to_do = NULL;
2250         gint total = 0, curnum = 0;
2251         MailFilteringData mail_filtering_data;
2252
2253         cm_return_if_fail(filtered != NULL);
2254         cm_return_if_fail(unfiltered != NULL);
2255
2256         *filtered = NULL;
2257         *unfiltered = NULL;
2258
2259         if (list == NULL)
2260                 return;
2261
2262         total = g_slist_length(list);
2263
2264         if (!do_filter) {
2265                 *filtered = NULL;
2266                 *unfiltered = g_slist_copy(list);
2267                 return;
2268         }
2269
2270         statusbar_print_all(_("Filtering messages...\n"));
2271
2272         mail_filtering_data.msginfo = NULL;
2273         mail_filtering_data.msglist = list;
2274         mail_filtering_data.filtered = NULL;
2275         mail_filtering_data.unfiltered = NULL;
2276         mail_filtering_data.account = ac;
2277
2278         if (!ac || ac->filterhook_on_recv)
2279         hooks_invoke(MAIL_LISTFILTERING_HOOKLIST, &mail_filtering_data);
2280
2281         if (mail_filtering_data.filtered == NULL &&
2282             mail_filtering_data.unfiltered == NULL) {
2283                 /* nothing happened */
2284                 debug_print(MAIL_LISTFILTERING_HOOKLIST " did nothing. filtering whole list normally.\n");
2285                 to_do = list;
2286         }
2287         if (mail_filtering_data.filtered != NULL) {
2288                 /* keep track of what's been filtered by the hooks */
2289                 debug_print(MAIL_LISTFILTERING_HOOKLIST " filtered some stuff. total %d filtered %d unfilt %d.\n",
2290                         g_slist_length(list),
2291                         g_slist_length(mail_filtering_data.filtered),
2292                         g_slist_length(mail_filtering_data.unfiltered));
2293
2294                 *filtered = g_slist_copy(mail_filtering_data.filtered);
2295         }
2296         if (mail_filtering_data.unfiltered != NULL) {
2297                 /* what the hooks didn't handle will go in filtered or
2298                  * unfiltered in the next loop */
2299                 debug_print(MAIL_LISTFILTERING_HOOKLIST " left unfiltered stuff. total %d filtered %d unfilt %d.\n",
2300                         g_slist_length(list),
2301                         g_slist_length(mail_filtering_data.filtered),
2302                         g_slist_length(mail_filtering_data.unfiltered));
2303                 to_do = mail_filtering_data.unfiltered;
2304         }
2305
2306         for (cur = to_do; cur; cur = cur->next) {
2307                 MsgInfo *info = (MsgInfo *)cur->data;
2308                 if (procmsg_msginfo_filter(info, ac))
2309                         *filtered = g_slist_prepend(*filtered, info);
2310                 else
2311                         *unfiltered = g_slist_prepend(*unfiltered, info);
2312                 statusbar_progress_all(curnum++, total, prefs_common.statusbar_update_step);
2313         }
2314
2315         g_slist_free(mail_filtering_data.filtered);
2316         g_slist_free(mail_filtering_data.unfiltered);
2317
2318         *filtered = g_slist_reverse(*filtered);
2319         *unfiltered = g_slist_reverse(*unfiltered);
2320
2321         statusbar_progress_all(0,0,0);
2322         statusbar_pop_all();
2323 }
2324
2325 MsgInfo *procmsg_msginfo_new_from_mimeinfo(MsgInfo *src_msginfo, MimeInfo *mimeinfo)
2326 {
2327         MsgInfo *tmp_msginfo = NULL;
2328         MsgFlags flags = {0, 0};
2329         gchar *tmpfile = get_tmp_file();
2330         FILE *fp = g_fopen(tmpfile, "wb");
2331
2332         if (!mimeinfo || mimeinfo->type != MIMETYPE_MESSAGE ||
2333             g_ascii_strcasecmp(mimeinfo->subtype, "rfc822")) {
2334                 g_warning("procmsg_msginfo_new_from_mimeinfo(): unsuitable mimeinfo");
2335                 if (fp)
2336                         fclose(fp);
2337                 g_free(tmpfile);
2338                 return NULL;
2339         }
2340
2341         if (fp && procmime_write_mimeinfo(mimeinfo, fp) >= 0) {
2342                 fclose(fp);
2343                 fp = NULL;
2344                 tmp_msginfo = procheader_parse_file(
2345                         tmpfile, flags,
2346                         TRUE, FALSE);
2347         }
2348         if (fp)
2349                 fclose(fp);
2350
2351         if (tmp_msginfo != NULL) {
2352                 if (src_msginfo)
2353                         tmp_msginfo->folder = src_msginfo->folder;
2354                 tmp_msginfo->plaintext_file = g_strdup(tmpfile);
2355         } else {
2356                 g_warning("procmsg_msginfo_new_from_mimeinfo(): Can't generate new msginfo");
2357         }
2358
2359         g_free(tmpfile);
2360
2361         return tmp_msginfo;
2362 }
2363
2364 static GSList *spam_learners = NULL;
2365
2366 void procmsg_register_spam_learner (int (*learn_func)(MsgInfo *info, GSList *list, gboolean spam))
2367 {
2368         if (!g_slist_find(spam_learners, learn_func))
2369                 spam_learners = g_slist_append(spam_learners, learn_func);
2370         if (mainwindow_get_mainwindow()) {
2371                 main_window_set_menu_sensitive(mainwindow_get_mainwindow());
2372                 summary_set_menu_sensitive(
2373                         mainwindow_get_mainwindow()->summaryview);
2374                 toolbar_main_set_sensitive(mainwindow_get_mainwindow());
2375         }
2376 }
2377
2378 void procmsg_unregister_spam_learner (int (*learn_func)(MsgInfo *info, GSList *list, gboolean spam))
2379 {
2380         spam_learners = g_slist_remove(spam_learners, learn_func);
2381         if (mainwindow_get_mainwindow()) {
2382                 main_window_set_menu_sensitive(mainwindow_get_mainwindow());
2383                 summary_set_menu_sensitive(
2384                         mainwindow_get_mainwindow()->summaryview);
2385                 toolbar_main_set_sensitive(mainwindow_get_mainwindow());
2386         }
2387 }
2388
2389 gboolean procmsg_spam_can_learn(void)
2390 {
2391         return g_slist_length(spam_learners) > 0;
2392 }
2393
2394 int procmsg_spam_learner_learn (MsgInfo *info, GSList *list, gboolean spam)
2395 {
2396         GSList *cur = spam_learners;
2397         int ret = 0;
2398         for (; cur; cur = cur->next) {
2399                 int ((*func)(MsgInfo *info, GSList *list, gboolean spam)) = cur->data;
2400                 ret |= func(info, list, spam);
2401         }
2402         return ret;
2403 }
2404
2405 static gchar *spam_folder_item = NULL;
2406 static FolderItem * (*procmsg_spam_get_folder_func)(MsgInfo *msginfo) = NULL;
2407 void procmsg_spam_set_folder (const char *item_identifier, FolderItem *(*spam_get_folder_func)(MsgInfo *info))
2408 {
2409         g_free(spam_folder_item);
2410         if (item_identifier)
2411                 spam_folder_item = g_strdup(item_identifier);
2412         else
2413                 spam_folder_item = NULL;
2414         if (spam_get_folder_func != NULL)
2415                 procmsg_spam_get_folder_func = spam_get_folder_func;
2416         else
2417                 procmsg_spam_get_folder_func = NULL;
2418 }
2419
2420 FolderItem *procmsg_spam_get_folder (MsgInfo *msginfo)
2421 {
2422         FolderItem *item = NULL;
2423
2424         if (procmsg_spam_get_folder_func)
2425                 item = procmsg_spam_get_folder_func(msginfo);
2426         if (item == NULL && spam_folder_item)
2427                 item = folder_find_item_from_identifier(spam_folder_item);
2428         if (item == NULL)
2429                 item = folder_get_default_trash();
2430         return item;
2431 }
2432
2433 static void item_has_queued_mails(FolderItem *item, gpointer data)
2434 {
2435         gboolean *result = (gboolean *)data;
2436         if (*result == TRUE)
2437                 return;
2438         if (folder_has_parent_of_type(item, F_QUEUE)) {
2439                 if (item->total_msgs == 0)
2440                         return;
2441                 else {
2442                         GSList *msglist = folder_item_get_msg_list(item);
2443                         GSList *cur;
2444                         for (cur = msglist; cur; cur = cur->next) {
2445                                 MsgInfo *msginfo = (MsgInfo *)cur->data;
2446                                 if (!MSG_IS_DELETED(msginfo->flags) &&
2447                                     !MSG_IS_LOCKED(msginfo->flags)) {
2448                                         *result = TRUE;
2449                                         break;
2450                                 }
2451                         }
2452                         procmsg_msg_list_free(msglist);
2453                 }
2454         }
2455 }
2456
2457 gboolean procmsg_have_queued_mails_fast (void)
2458 {
2459         gboolean result = FALSE;
2460         folder_func_to_all_folders(item_has_queued_mails, &result);
2461         return result;
2462 }
2463
2464 static void item_has_trashed_mails(FolderItem *item, gpointer data)
2465 {
2466         gboolean *result = (gboolean *)data;
2467         if (*result == TRUE)
2468                 return;
2469         if (folder_has_parent_of_type(item, F_TRASH) && item->total_msgs > 0)
2470                 *result = TRUE;
2471 }
2472
2473 gboolean procmsg_have_trashed_mails_fast (void)
2474 {
2475         gboolean result = FALSE;
2476         folder_func_to_all_folders(item_has_trashed_mails, &result);
2477         return result;
2478 }
2479
2480 gchar *procmsg_msginfo_get_tags_str(MsgInfo *msginfo)
2481 {
2482         GSList *cur = NULL;
2483         gchar *tags = NULL;
2484
2485         if (!msginfo)
2486                 return NULL;
2487
2488         if (msginfo->tags == NULL)
2489                 return NULL;
2490         for (cur = msginfo->tags; cur; cur = cur->next) {
2491                 const gchar *tag = tags_get_tag(GPOINTER_TO_INT(cur->data));
2492                 if (!tag)
2493                         continue;
2494                 if (!tags)
2495                         tags = g_strdup(tag);
2496                 else {
2497                         int olen = strlen(tags);
2498                         int nlen = olen + strlen(tag) + 2 /* strlen(", ") */;
2499                         tags = g_realloc(tags, nlen+1);
2500                         if (!tags)
2501                                 return NULL;
2502                         strcpy(tags+olen, ", ");
2503                         strcpy(tags+olen+2, tag);
2504                         tags[nlen]='\0';
2505                 }
2506         }
2507         return tags;
2508 }
2509
2510 void procmsg_msginfo_update_tags(MsgInfo *msginfo, gboolean set, gint id)
2511 {
2512         GSList changed;
2513
2514         if (id == 0)
2515                 return;
2516
2517         if (!set) {
2518                 msginfo->tags = g_slist_remove(
2519                                         msginfo->tags,
2520                                         GINT_TO_POINTER(id));
2521                 changed.data = GINT_TO_POINTER(id);
2522                 changed.next = NULL;
2523                 folder_item_commit_tags(msginfo->folder, msginfo, NULL, &changed);
2524         } else {
2525                 if (!g_slist_find(msginfo->tags, GINT_TO_POINTER(id))) {
2526                         msginfo->tags = g_slist_append(
2527                                         msginfo->tags,
2528                                         GINT_TO_POINTER(id));
2529                 }
2530                 changed.data = GINT_TO_POINTER(id);
2531                 changed.next = NULL;
2532                 folder_item_commit_tags(msginfo->folder, msginfo, &changed, NULL);
2533         }
2534
2535 }
2536
2537 void procmsg_msginfo_clear_tags(MsgInfo *msginfo)
2538 {
2539         GSList *unset = msginfo->tags;
2540         msginfo->tags = NULL;
2541         folder_item_commit_tags(msginfo->folder, msginfo, NULL, unset);
2542         g_slist_free(unset);
2543 }