src/procmsg.c

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