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