/*
* Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
- * Copyright (C) 1999-2003 Hiroyuki Yamamoto
+ * Copyright (C) 1999-2006 Hiroyuki Yamamoto and the Sylpheed-Claws team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "defs.h"
#include <glib.h>
+#include <glib/gi18n.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
-#include "intl.h"
#include "main.h"
#include "utils.h"
#include "procmsg.h"
#include "folder.h"
#include "prefs_common.h"
#include "account.h"
-#if USE_GPGME
-# include "rfc2015.h"
-#endif
#include "alertpanel.h"
#include "news.h"
#include "hooks.h"
#include "msgcache.h"
+#include "partial_download.h"
+#include "mainwindow.h"
+#include "summaryview.h"
+#include "log.h"
+#include "timing.h"
+
+static gint procmsg_send_message_queue_full(const gchar *file, gboolean keep_session, gchar **errstr);
+
+enum
+{
+ Q_SENDER = 0,
+ Q_SMTPSERVER = 1,
+ Q_RECIPIENTS = 2,
+ Q_NEWSGROUPS = 3,
+ Q_MAIL_ACCOUNT_ID = 4,
+ Q_NEWS_ACCOUNT_ID = 5,
+ Q_SAVE_COPY_FOLDER = 6,
+ Q_REPLY_MESSAGE_ID = 7,
+ Q_FWD_MESSAGE_ID = 8,
+ Q_PRIVACY_SYSTEM = 9,
+ Q_ENCRYPT = 10,
+ Q_ENCRYPT_DATA = 11,
+ Q_SYLPHEED_HDRS = 12,
+};
GHashTable *procmsg_msg_hash_table_create(GSList *mlist)
{
gint first;
};
-static gboolean procmsg_ignore_node(GNode *node, gpointer data)
+/* CLAWS subject threading:
+
+ in the first round it inserts subject lines in a
+ relation (subject <-> node)
+
+ the second round finishes the threads by attaching
+ matching subject lines to the one found in the
+ relation. will use the oldest node with the same
+ subject that is not more then thread_by_subject_max_age
+ days old (see subject_relation_lookup)
+*/
+
+static void subject_relation_insert(GRelation *relation, GNode *node)
+{
+ gchar *subject;
+ MsgInfo *msginfo;
+
+ g_return_if_fail(relation != NULL);
+ g_return_if_fail(node != NULL);
+ msginfo = (MsgInfo *) node->data;
+ g_return_if_fail(msginfo != NULL);
+
+ subject = msginfo->subject;
+ if (subject == NULL)
+ return;
+ subject += subject_get_prefix_length(subject);
+
+ g_relation_insert(relation, subject, node);
+}
+
+static GNode *subject_relation_lookup(GRelation *relation, MsgInfo *msginfo)
{
- MsgInfo *msginfo = (MsgInfo *)node->data;
+ gchar *subject;
+ GTuples *tuples;
+ GNode *node = NULL;
+ gint prefix_length;
+
+ g_return_val_if_fail(relation != NULL, NULL);
+
+ subject = msginfo->subject;
+ if (subject == NULL)
+ return NULL;
+ prefix_length = subject_get_prefix_length(subject);
+ if (prefix_length <= 0)
+ return NULL;
+ subject += prefix_length;
- procmsg_msginfo_unset_flags(msginfo, MSG_NEW | MSG_UNREAD, 0);
- procmsg_msginfo_set_flags(msginfo, MSG_IGNORE_THREAD, 0);
+ tuples = g_relation_select(relation, subject, 0);
+ if (tuples == NULL)
+ return NULL;
- return FALSE;
+ if (tuples->len > 0) {
+ int i;
+ GNode *relation_node;
+ MsgInfo *relation_msginfo = NULL, *best_msginfo = NULL;
+ gboolean match;
+
+ /* check all nodes with the same subject to find the best parent */
+ for (i = 0; i < tuples->len; i++) {
+ relation_node = (GNode *) g_tuples_index(tuples, i, 1);
+ relation_msginfo = (MsgInfo *) relation_node->data;
+ match = FALSE;
+
+ /* best node should be the oldest in the found nodes */
+ /* parent node must not be older then msginfo */
+ if ((relation_msginfo->date_t < msginfo->date_t) &&
+ ((best_msginfo == NULL) ||
+ (best_msginfo->date_t > relation_msginfo->date_t)))
+ match = TRUE;
+
+ /* parent node must not be more then thread_by_subject_max_age
+ days older then msginfo */
+ if (abs(difftime(msginfo->date_t, relation_msginfo->date_t)) >
+ prefs_common.thread_by_subject_max_age * 3600 * 24)
+ match = FALSE;
+
+ /* can add new tests for all matching
+ nodes found by subject */
+
+ if (match) {
+ node = relation_node;
+ best_msginfo = relation_msginfo;
+ }
+ }
+ }
+
+ g_tuples_destroy(tuples);
+ return node;
}
/* return the reversed thread tree */
GNode *procmsg_get_thread_tree(GSList *mlist)
{
- GNode *root, *parent, *node, *next, *last;
+ GNode *root, *parent, *node, *next;
GHashTable *msgid_table;
- GHashTable *subject_table;
+ GRelation *subject_relation;
MsgInfo *msginfo;
const gchar *msgid;
- const gchar *subject;
- GNode *found_subject;
-
+ GSList *reflist;
+ START_TIMING("procmsg_get_thread_tree");
root = g_node_new(NULL);
msgid_table = g_hash_table_new(g_str_hash, g_str_equal);
- subject_table = g_hash_table_new(g_str_hash, g_str_equal);
+ subject_relation = g_relation_new(2);
+ g_relation_index(subject_relation, 0, g_str_hash, g_str_equal);
for (; mlist != NULL; mlist = mlist->next) {
msginfo = (MsgInfo *)mlist->data;
parent = g_hash_table_lookup(msgid_table, msginfo->inreplyto);
if (parent == NULL) {
parent = root;
- } else {
- if (MSG_IS_IGNORE_THREAD(((MsgInfo *)parent->data)->flags) && !MSG_IS_IGNORE_THREAD(msginfo->flags)) {
- procmsg_msginfo_unset_flags(msginfo, MSG_NEW | MSG_UNREAD, 0);
- procmsg_msginfo_set_flags(msginfo, MSG_IGNORE_THREAD, 0);
- }
}
}
node = g_node_insert_data_before
(parent, parent == root ? parent->children : NULL,
msginfo);
- if ((msgid = msginfo->msgid) &&
- g_hash_table_lookup(msgid_table, msgid) == NULL)
+ if ((msgid = msginfo->msgid) && g_hash_table_lookup(msgid_table, msgid) == NULL)
g_hash_table_insert(msgid_table, (gchar *)msgid, node);
+ /* CLAWS: add subject to relation (without prefix) */
if (prefs_common.thread_by_subject) {
- subject = msginfo->subject;
- subject += subject_get_reply_prefix_length(subject);
- found_subject = subject_table_lookup_clean(subject_table,
- (gchar *) subject);
- if (found_subject == NULL)
- subject_table_insert_clean(subject_table, (gchar *) subject,
- node);
- else {
- /* replace if msg in table is older than current one
- * can add here more stuff. */
- if ( ((MsgInfo*)(found_subject->data))->date_t >
- ((MsgInfo*)(node->data))->date_t ) {
- subject_table_remove_clean(subject_table, (gchar *) subject);
- subject_table_insert_clean(subject_table, (gchar *) subject, node);
- }
- }
+ subject_relation_insert(subject_relation, node);
}
}
next = node->next;
msginfo = (MsgInfo *)node->data;
parent = NULL;
- if (msginfo->inreplyto)
+
+ if (msginfo->inreplyto)
parent = g_hash_table_lookup(msgid_table, msginfo->inreplyto);
- /* node should not be the parent, and node should not be an ancestor
- * of parent (circular reference) */
- if (parent && parent != node
- && !g_node_is_ancestor(node, parent)) {
+
+ /* try looking for the indirect parent */
+ if (!parent && msginfo->references) {
+ for (reflist = msginfo->references;
+ reflist != NULL; reflist = reflist->next)
+ if ((parent = g_hash_table_lookup
+ (msgid_table, reflist->data)) != NULL)
+ break;
+ }
+
+ /* node should not be the parent, and node should not
+ be an ancestor of parent (circular reference) */
+ if (parent && parent != node &&
+ !g_node_is_ancestor(node, parent)) {
g_node_unlink(node);
g_node_insert_before
(parent, parent->children, node);
- /* CLAWS: ignore thread */
- if (MSG_IS_IGNORE_THREAD(((MsgInfo *)parent->data)->flags) && !MSG_IS_IGNORE_THREAD(msginfo->flags)) {
- g_node_traverse(node, G_PRE_ORDER, G_TRAVERSE_ALL, -1, procmsg_ignore_node, NULL);
- }
}
- last = node; /* CLAWS: need to have the last one for subject threading */
+
node = next;
}
- /* CLAWS: now see if the first level (below root) still has some nodes that can be
- * threaded by subject line. we need to handle this in a special way to prevent
- * circular reference from a node that has already been threaded by IN-REPLY-TO
- * but is also in the subject line hash table */
if (prefs_common.thread_by_subject) {
- for (node = last; node && node != NULL;) {
- next = node->prev;
+ START_TIMING("procmsg_get_thread_tree(1)");
+ for (node = root->children; node && node != NULL;) {
+ next = node->next;
msginfo = (MsgInfo *) node->data;
- subject = msginfo->subject + subject_get_reply_prefix_length(msginfo->subject);
- parent = subject_table_lookup_clean(subject_table, (gchar *) subject);
- /* the node may already be threaded by IN-REPLY-TO,
- so go up in the tree to find the parent node */
+ parent = subject_relation_lookup(subject_relation, msginfo);
+
+ /* the node may already be threaded by IN-REPLY-TO, so go up
+ * in the tree to
+ find the parent node */
if (parent != NULL) {
if (g_node_is_ancestor(node, parent))
parent = NULL;
if (parent == node)
parent = NULL;
- /* Make new thread parent if too old compared to previous one; probably
- * breaks ignoring threads for subject threading. This still isn't
- * accurate because the tree isn't sorted by date. */
- if (parent && abs(difftime(msginfo->date_t, ((MsgInfo *)parent->data)->date_t)) >
- prefs_common.thread_by_subject_max_age * 3600 * 24) {
- subject_table_remove_clean(subject_table, (gchar *) subject);
- subject_table_insert_clean(subject_table, (gchar *) subject, node);
- parent = NULL;
- }
}
-
+
if (parent) {
g_node_unlink(node);
g_node_append(parent, node);
- /* CLAWS: ignore thread */
- if (MSG_IS_IGNORE_THREAD(((MsgInfo *)parent->data)->flags) && !MSG_IS_IGNORE_THREAD(msginfo->flags)) {
- g_node_traverse(node, G_PRE_ORDER, G_TRAVERSE_ALL, -1, procmsg_ignore_node, NULL);
- }
}
+
node = next;
}
+ END_TIMING();
}
- g_hash_table_destroy(subject_table);
+ g_relation_destroy(subject_relation);
g_hash_table_destroy(msgid_table);
-
+ END_TIMING();
return root;
}
-void procmsg_move_messages(GSList *mlist)
+gint procmsg_move_messages(GSList *mlist)
{
GSList *cur, *movelist = NULL;
MsgInfo *msginfo;
FolderItem *dest = NULL;
-
- if (!mlist) return;
+ gint retval = 0;
+ gboolean finished = TRUE;
+ if (!mlist) return 0;
folder_item_update_freeze();
+next_folder:
for (cur = mlist; cur != NULL; cur = cur->next) {
msginfo = (MsgInfo *)cur->data;
+ if (!msginfo->to_folder) {
+ continue;
+ } else {
+ finished = FALSE;
+ }
if (!dest) {
dest = msginfo->to_folder;
- movelist = g_slist_append(movelist, msginfo);
+ movelist = g_slist_prepend(movelist, msginfo);
} else if (dest == msginfo->to_folder) {
- movelist = g_slist_append(movelist, msginfo);
+ movelist = g_slist_prepend(movelist, msginfo);
} else {
- folder_item_move_msgs_with_dest(dest, movelist);
- g_slist_free(movelist);
- movelist = NULL;
- dest = msginfo->to_folder;
- movelist = g_slist_append(movelist, msginfo);
+ continue;
}
procmsg_msginfo_set_to_folder(msginfo, NULL);
}
-
if (movelist) {
- folder_item_move_msgs_with_dest(dest, movelist);
+ movelist = g_slist_reverse(movelist);
+ retval |= folder_item_move_msgs(dest, movelist);
g_slist_free(movelist);
+ movelist = NULL;
+ }
+ if (finished == FALSE) {
+ finished = TRUE;
+ dest = NULL;
+ goto next_folder;
}
folder_item_update_thaw();
+ return retval;
}
void procmsg_copy_messages(GSList *mlist)
GSList *cur, *copylist = NULL;
MsgInfo *msginfo;
FolderItem *dest = NULL;
-
+ gboolean finished = TRUE;
if (!mlist) return;
folder_item_update_freeze();
+next_folder:
for (cur = mlist; cur != NULL; cur = cur->next) {
msginfo = (MsgInfo *)cur->data;
+ if (!msginfo->to_folder) {
+ continue;
+ } else {
+ finished = FALSE;
+ }
if (!dest) {
dest = msginfo->to_folder;
- copylist = g_slist_append(copylist, msginfo);
+ copylist = g_slist_prepend(copylist, msginfo);
} else if (dest == msginfo->to_folder) {
- copylist = g_slist_append(copylist, msginfo);
+ copylist = g_slist_prepend(copylist, msginfo);
} else {
- folder_item_copy_msgs_with_dest(dest, copylist);
- g_slist_free(copylist);
- copylist = NULL;
- dest = msginfo->to_folder;
- copylist = g_slist_append(copylist, msginfo);
+ continue;
}
procmsg_msginfo_set_to_folder(msginfo, NULL);
}
-
if (copylist) {
- folder_item_copy_msgs_with_dest(dest, copylist);
+ copylist = g_slist_reverse(copylist);
+ folder_item_copy_msgs(dest, copylist);
g_slist_free(copylist);
+ copylist = NULL;
+ }
+ if (finished == FALSE) {
+ finished = TRUE;
+ dest = NULL;
+ goto next_folder;
}
folder_item_update_thaw();
filename = folder_item_fetch_msg(msginfo->folder, msginfo->msgnum);
if (!filename)
- g_warning("can't fetch message %d\n", msginfo->msgnum);
+ debug_print("can't fetch message %d\n", msginfo->msgnum);
+
+ return filename;
+}
+
+gchar *procmsg_get_message_file_full(MsgInfo *msginfo, gboolean headers, gboolean body)
+{
+ gchar *filename = NULL;
+
+ g_return_val_if_fail(msginfo != NULL, NULL);
+
+ filename = folder_item_fetch_msg_full(msginfo->folder, msginfo->msgnum,
+ headers, body);
+ if (!filename)
+ debug_print("can't fetch message %d\n", msginfo->msgnum);
return filename;
}
+GSList *procmsg_get_message_file_list(GSList *mlist)
+{
+ GSList *file_list = NULL;
+ MsgInfo *msginfo;
+ MsgFileInfo *fileinfo;
+ gchar *file;
+
+ while (mlist != NULL) {
+ msginfo = (MsgInfo *)mlist->data;
+ file = procmsg_get_message_file(msginfo);
+ if (!file) {
+ procmsg_message_file_list_free(file_list);
+ return NULL;
+ }
+ fileinfo = g_new(MsgFileInfo, 1);
+ fileinfo->msginfo = procmsg_msginfo_new_ref(msginfo);
+ fileinfo->file = file;
+ fileinfo->flags = g_new(MsgFlags, 1);
+ *fileinfo->flags = msginfo->flags;
+ file_list = g_slist_prepend(file_list, fileinfo);
+ mlist = mlist->next;
+ }
+
+ file_list = g_slist_reverse(file_list);
+
+ return file_list;
+}
+
+void procmsg_message_file_list_free(MsgInfoList *file_list)
+{
+ GSList *cur;
+ MsgFileInfo *fileinfo;
+
+ for (cur = file_list; cur != NULL; cur = cur->next) {
+ fileinfo = (MsgFileInfo *)cur->data;
+ procmsg_msginfo_free(fileinfo->msginfo);
+ g_free(fileinfo->file);
+ g_free(fileinfo->flags);
+ g_free(fileinfo);
+ }
+
+ g_slist_free(file_list);
+}
+
FILE *procmsg_open_message(MsgInfo *msginfo)
{
FILE *fp;
if (!is_file_exist(file)) {
g_free(file);
file = procmsg_get_message_file(msginfo);
- g_return_val_if_fail(file != NULL, NULL);
+ if (!file)
+ return NULL;
}
- if ((fp = fopen(file, "rb")) == NULL) {
+ if ((fp = g_fopen(file, "rb")) == NULL) {
FILE_OP_ERROR(file, "fopen");
g_free(file);
return NULL;
if (MSG_IS_QUEUED(msginfo->flags) || MSG_IS_DRAFT(msginfo->flags)) {
gchar buf[BUFFSIZE];
- while (fgets(buf, sizeof(buf), fp) != NULL)
+ while (fgets(buf, sizeof(buf), fp) != NULL) {
+ /* new way */
+ if (!strncmp(buf, "X-Sylpheed-End-Special-Headers: 1",
+ strlen("X-Sylpheed-End-Special-Headers:")))
+ break;
+ /* old way */
if (buf[0] == '\r' || buf[0] == '\n') break;
- }
-
- return fp;
-}
-
-#if USE_GPGME
-FILE *procmsg_open_message_decrypted(MsgInfo *msginfo, MimeInfo **mimeinfo)
-{
- FILE *fp;
- MimeInfo *mimeinfo_;
- glong fpos;
-
- g_return_val_if_fail(msginfo != NULL, NULL);
-
- if (mimeinfo) *mimeinfo = NULL;
-
- if ((fp = procmsg_open_message(msginfo)) == NULL) return NULL;
-
- mimeinfo_ = procmime_scan_mime_header(fp);
- if (!mimeinfo_) {
- fclose(fp);
- return NULL;
- }
-
- if (!MSG_IS_ENCRYPTED(msginfo->flags) &&
- rfc2015_is_encrypted(mimeinfo_)) {
- MSG_SET_TMP_FLAGS(msginfo->flags, MSG_ENCRYPTED);
- }
-
- if (MSG_IS_ENCRYPTED(msginfo->flags) &&
- !msginfo->plaintext_file &&
- !msginfo->decryption_failed) {
- fpos = ftell(fp);
- rfc2015_decrypt_message(msginfo, mimeinfo_, fp);
- if (msginfo->plaintext_file &&
- !msginfo->decryption_failed) {
- fclose(fp);
- procmime_mimeinfo_free_all(mimeinfo_);
- if ((fp = procmsg_open_message(msginfo)) == NULL)
- return NULL;
- mimeinfo_ = procmime_scan_mime_header(fp);
- if (!mimeinfo_) {
- fclose(fp);
- return NULL;
+ /* from other mailers */
+ if (!strncmp(buf, "Date: ", 6)
+ || !strncmp(buf, "To: ", 4)
+ || !strncmp(buf, "From: ", 6)
+ || !strncmp(buf, "Subject: ", 9)) {
+ rewind(fp);
+ break;
}
- } else {
- if (fseek(fp, fpos, SEEK_SET) < 0)
- perror("fseek");
}
}
- if (mimeinfo) *mimeinfo = mimeinfo_;
return fp;
}
-#endif
gboolean procmsg_msg_exist(MsgInfo *msginfo)
{
{"X-Mailing-list:", NULL, TRUE},
{"List-Id:", NULL, TRUE},
{"X-Sequence:", NULL, TRUE},
+ {"Sender:", NULL, TRUE},
+ {"List-Post:", NULL, TRUE},
{NULL, NULL, FALSE}};
enum
{
H_X_LIST = 2,
H_X_MAILING_LIST = 3,
H_LIST_ID = 4,
- H_X_SEQUENCE = 5
+ H_X_SEQUENCE = 5,
+ H_SENDER = 6,
+ H_LIST_POST = 7
};
FILE *fp;
SET_FILTER_KEY("X-Sequence", H_X_SEQUENCE);
p = *key;
while (*p != '\0') {
- while (*p != '\0' && !isspace(*p)) p++;
- while (isspace(*p)) p++;
- if (isdigit(*p)) {
+ while (*p != '\0' && !g_ascii_isspace(*p)) p++;
+ while (g_ascii_isspace(*p)) p++;
+ if (g_ascii_isdigit(*p)) {
*p = '\0';
break;
}
}
g_strstrip(*key);
+ } else if (hentry[H_SENDER].body != NULL) {
+ SET_FILTER_KEY("header \"Sender\"", H_SENDER);
+ } else if (hentry[H_LIST_POST].body != NULL) {
+ SET_FILTER_KEY("header \"List-Post\"", H_LIST_POST);
+ } else if (msginfo->to) {
+ *header = g_strdup("to");
+ *key = g_strdup(msginfo->to);
} else if (msginfo->subject) {
*header = g_strdup("subject");
*key = g_strdup(msginfo->subject);
hentry[H_X_MAILING_LIST].body = NULL;
g_free(hentry[H_LIST_ID].body);
hentry[H_LIST_ID].body = NULL;
+ g_free(hentry[H_SENDER].body);
+ hentry[H_SENDER].body = NULL;
+ g_free(hentry[H_LIST_POST].body);
+ hentry[H_LIST_POST].body = NULL;
break;
case FILTER_BY_FROM:
}
}
-void procmsg_empty_trash(void)
+void procmsg_empty_trash(FolderItem *trash)
+{
+ GNode *node, *next;
+
+ if (!trash ||
+ (trash->stype != F_TRASH &&
+ !folder_has_parent_of_type(trash, F_TRASH)))
+ return;
+
+ if (trash && trash->total_msgs > 0) {
+ GSList *mlist = folder_item_get_msg_list(trash);
+ GSList *cur;
+ for (cur = mlist ; cur != NULL ; cur = cur->next) {
+ MsgInfo * msginfo = (MsgInfo *) cur->data;
+ if (MSG_IS_LOCKED(msginfo->flags))
+ continue;
+ if (msginfo->total_size != 0 &&
+ msginfo->size != (off_t)msginfo->total_size)
+ partial_mark_for_delete(msginfo);
+
+ procmsg_msginfo_free(msginfo);
+ }
+ g_slist_free(mlist);
+ folder_item_remove_all_msg(trash);
+ }
+
+ if (!trash->node || !trash->node->children)
+ return;
+
+ node = trash->node->children;
+ while (node != NULL) {
+ next = node->next;
+ procmsg_empty_trash(FOLDER_ITEM(node->data));
+ node = next;
+ }
+}
+
+void procmsg_empty_all_trash(void)
{
FolderItem *trash;
GList *cur;
for (cur = folder_get_list(); cur != NULL; cur = cur->next) {
- trash = FOLDER(cur->data)->trash;
- if (trash && trash->total_msgs > 0)
- folder_item_remove_all_msg(trash);
+ Folder *folder = FOLDER(cur->data);
+ trash = folder->trash;
+ procmsg_empty_trash(trash);
+ if (folder->account && folder->account->set_trash_folder &&
+ folder_find_item_from_identifier(folder->account->trash_folder))
+ procmsg_empty_trash(
+ folder_find_item_from_identifier(folder->account->trash_folder));
+ }
+}
+
+static PrefsAccount *procmsg_get_account_from_file(const gchar *file)
+{
+ PrefsAccount *mailac = NULL;
+ FILE *fp;
+ int hnum;
+ gchar buf[BUFFSIZE];
+ static HeaderEntry qentry[] = {{"S:", NULL, FALSE},
+ {"SSV:", NULL, FALSE},
+ {"R:", NULL, FALSE},
+ {"NG:", NULL, FALSE},
+ {"MAID:", NULL, FALSE},
+ {"NAID:", NULL, FALSE},
+ {"SCF:", NULL, FALSE},
+ {"RMID:", NULL, FALSE},
+ {"FMID:", NULL, FALSE},
+ {"X-Sylpheed-Privacy-System:", NULL, FALSE},
+ {"X-Sylpheed-Encrypt:", NULL, FALSE},
+ {"X-Sylpheed-Encrypt-Data:", NULL, FALSE},
+ {NULL, NULL, FALSE}};
+
+ g_return_val_if_fail(file != NULL, NULL);
+
+ if ((fp = g_fopen(file, "rb")) == NULL) {
+ FILE_OP_ERROR(file, "fopen");
+ return NULL;
+ }
+
+ while ((hnum = procheader_get_one_field(buf, sizeof(buf), fp, qentry))
+ != -1) {
+ gchar *p = buf + strlen(qentry[hnum].name);
+
+ if (hnum == Q_MAIL_ACCOUNT_ID) {
+ mailac = account_find_from_id(atoi(p));
+ break;
+ }
}
+ fclose(fp);
+ return mailac;
+}
+
+static GSList *procmsg_list_sort_by_account(FolderItem *queue, GSList *list)
+{
+ GSList *result = NULL;
+ GSList *orig = NULL;
+ PrefsAccount *last_account = NULL;
+ MsgInfo *msg = NULL;
+ GSList *cur = NULL;
+ gboolean nothing_to_sort = TRUE;
+
+ if (!list)
+ return NULL;
+
+ orig = g_slist_copy(list);
+
+ msg = (MsgInfo *)orig->data;
+
+ for (cur = orig; cur; cur = cur->next)
+ debug_print("sort before %s\n", ((MsgInfo *)cur->data)->from);
+
+ debug_print("\n");
+
+parse_again:
+ nothing_to_sort = TRUE;
+ cur = orig;
+ while (cur) {
+ gchar *file = NULL;
+ PrefsAccount *ac = NULL;
+ msg = (MsgInfo *)cur->data;
+ file = folder_item_fetch_msg(queue, msg->msgnum);
+ ac = procmsg_get_account_from_file(file);
+ g_free(file);
+
+ if (last_account == NULL || (ac != NULL && ac == last_account)) {
+ result = g_slist_append(result, msg);
+ orig = g_slist_remove(orig, msg);
+ last_account = ac;
+ nothing_to_sort = FALSE;
+ goto parse_again;
+ }
+ cur = cur->next;
+ }
+
+ if (orig || g_slist_length(orig)) {
+ if (!last_account && nothing_to_sort) {
+ /* can't find an account for the rest of the list */
+ cur = orig;
+ while (cur) {
+ result = g_slist_append(result, cur->data);
+ cur = cur->next;
+ }
+ } else {
+ last_account = NULL;
+ goto parse_again;
+ }
+ }
+
+ g_slist_free(orig);
+
+ for (cur = result; cur; cur = cur->next)
+ debug_print("sort after %s\n", ((MsgInfo *)cur->data)->from);
+
+ debug_print("\n");
+
+ return result;
+}
+
+static gboolean procmsg_is_last_for_account(FolderItem *queue, MsgInfo *msginfo, GSList *elem)
+{
+ gchar *file = folder_item_fetch_msg(queue, msginfo->msgnum);
+ PrefsAccount *ac = procmsg_get_account_from_file(file);
+ GSList *cur = elem;
+ g_free(file);
+ for (cur = elem; cur; cur = cur->next) {
+ MsgInfo *cur_msginfo = (MsgInfo *)cur->data;
+ file = folder_item_fetch_msg(queue, cur_msginfo->msgnum);
+
+ if (cur_msginfo != msginfo && !MSG_IS_LOCKED(cur_msginfo->flags)) {
+ if (procmsg_get_account_from_file(file) == ac) {
+ g_free(file);
+ return FALSE;
+ }
+ }
+
+ g_free(file);
+ }
+ return TRUE;
}
/*!
*\return Number of messages sent, negative if an error occurred
* positive if no error occurred
*/
-gint procmsg_send_queue(FolderItem *queue, gboolean save_msgs)
+gint procmsg_send_queue(FolderItem *queue, gboolean save_msgs, gchar **errstr)
{
- gint ret = 1, count = 0;
+ gint sent = 0, err = 0;
GSList *list, *elem;
-
+ GSList *sorted_list = NULL;
+ GNode *node, *next;
+ static gboolean send_queue_lock = FALSE;
+
+ if (send_queue_lock) {
+ log_error(_("Already trying to send\n"));
+ if (errstr) {
+ if (*errstr) g_free(*errstr);
+ *errstr = g_strdup_printf(_("Already trying to send."));
+ }
+ return -1;
+ }
+ send_queue_lock = TRUE;
if (!queue)
queue = folder_get_default_queue();
g_return_val_if_fail(queue != NULL, -1);
folder_item_scan(queue);
list = folder_item_get_msg_list(queue);
- for (elem = list; elem != NULL; elem = elem->next) {
+ /* sort the list per sender account; this helps reusing the same SMTP server */
+ sorted_list = procmsg_list_sort_by_account(queue, list);
+
+ for (elem = sorted_list; elem != NULL; elem = elem->next) {
gchar *file;
MsgInfo *msginfo;
-
+
msginfo = (MsgInfo *)(elem->data);
if (!MSG_IS_LOCKED(msginfo->flags)) {
file = folder_item_fetch_msg(queue, msginfo->msgnum);
if (file) {
- if (procmsg_send_message_queue(file) < 0) {
+ if (procmsg_send_message_queue_full(file,
+ !procmsg_is_last_for_account(queue, msginfo, elem),
+ errstr) < 0) {
g_warning("Sending queued message %d failed.\n",
msginfo->msgnum);
- ret = -1;
+ err++;
} else {
- /* CLAWS:
- * We save in procmsg_send_message_queue because
- * we need the destination folder from the queue
- * header
-
- if (save_msgs)
- procmsg_save_to_outbox
- (queue->folder->outbox,
- file, TRUE);
- */
- count++;
+ sent++;
folder_item_remove_msg(queue, msginfo->msgnum);
}
g_free(file);
procmsg_msginfo_free(msginfo);
}
- return ret * count;
+ g_slist_free(sorted_list);
+ folder_item_scan(queue);
+
+ if (queue->node && queue->node->children) {
+ node = queue->node->children;
+ while (node != NULL) {
+ int res = 0;
+ next = node->next;
+ res = procmsg_send_queue(FOLDER_ITEM(node->data), save_msgs, errstr);
+ if (res < 0)
+ err = -res;
+ else
+ sent += res;
+ node = next;
+ }
+ }
+ send_queue_lock = FALSE;
+ return (err != 0 ? -err : sent);
+}
+
+/*!
+ *\brief Determine if a queue folder is empty
+ *
+ *\param queue Queue folder to process
+ *
+ *\return TRUE if the queue folder is empty, otherwise return FALSE
+ */
+gboolean procmsg_queue_is_empty(FolderItem *queue)
+{
+ GSList *list;
+ gboolean res = FALSE;
+ if (!queue)
+ queue = folder_get_default_queue();
+ g_return_val_if_fail(queue != NULL, TRUE);
+
+ folder_item_scan(queue);
+ list = folder_item_get_msg_list(queue);
+ res = (list == NULL);
+ procmsg_msg_list_free(list);
+
+ if (res == TRUE) {
+ GNode *node, *next;
+ if (queue->node && queue->node->children) {
+ node = queue->node->children;
+ while (node != NULL) {
+ next = node->next;
+ if (!procmsg_queue_is_empty(FOLDER_ITEM(node->data)))
+ return FALSE;
+ node = next;
+ }
+ }
+ }
+ return res;
}
gint procmsg_remove_special_headers(const gchar *in, const gchar *out)
FILE *fp, *outfp;
gchar buf[BUFFSIZE];
- if ((fp = fopen(in, "rb")) == NULL) {
+ if ((fp = g_fopen(in, "rb")) == NULL) {
FILE_OP_ERROR(in, "fopen");
return -1;
}
- if ((outfp = fopen(out, "wb")) == NULL) {
+ if ((outfp = g_fopen(out, "wb")) == NULL) {
FILE_OP_ERROR(out, "fopen");
fclose(fp);
return -1;
}
- while (fgets(buf, sizeof(buf), fp) != NULL)
+ while (fgets(buf, sizeof(buf), fp) != NULL) {
+ /* new way */
+ if (!strncmp(buf, "X-Sylpheed-End-Special-Headers: 1",
+ strlen("X-Sylpheed-End-Special-Headers:")))
+ break;
+ /* old way */
if (buf[0] == '\r' || buf[0] == '\n') break;
+ /* from other mailers */
+ if (!strncmp(buf, "Date: ", 6)
+ || !strncmp(buf, "To: ", 4)
+ || !strncmp(buf, "From: ", 6)
+ || !strncmp(buf, "Subject: ", 9)) {
+ rewind(fp);
+ break;
+ }
+ }
while (fgets(buf, sizeof(buf), fp) != NULL)
fputs(buf, outfp);
fclose(outfp);
fclose(fp);
return 0;
-
}
+
gint procmsg_save_to_outbox(FolderItem *outbox, const gchar *file,
gboolean is_queued)
{
gint num;
- MsgInfo *msginfo;
+ MsgInfo *msginfo, *tmp_msginfo;
+ MsgFlags flag = {0, 0};
debug_print("saving sent message...\n");
gchar tmp[MAXPATHLEN + 1];
g_snprintf(tmp, sizeof(tmp), "%s%ctmpmsg.out.%08x",
- get_rc_dir(), G_DIR_SEPARATOR, (guint)random());
+ get_rc_dir(), G_DIR_SEPARATOR, (guint) rand());
if (procmsg_remove_special_headers(file, tmp) !=0)
return -1;
folder_item_scan(outbox);
- if ((num = folder_item_add_msg(outbox, tmp, TRUE)) < 0) {
+ if ((num = folder_item_add_msg(outbox, tmp, &flag, TRUE)) < 0) {
g_warning("can't save message\n");
- unlink(tmp);
+ g_unlink(tmp);
return -1;
}
} else {
folder_item_scan(outbox);
- if ((num = folder_item_add_msg(outbox, file, FALSE)) < 0) {
+ if ((num = folder_item_add_msg
+ (outbox, file, &flag, FALSE)) < 0) {
g_warning("can't save message\n");
return -1;
}
- return -1;
+ return 0;
}
- msginfo = folder_item_get_msginfo(outbox, num);
+ msginfo = folder_item_get_msginfo(outbox, num); /* refcnt++ */
+ tmp_msginfo = procmsg_msginfo_get_full_info(msginfo); /* refcnt++ */
if (msginfo != NULL) {
- procmsg_msginfo_unset_flags(msginfo, ~0, 0);
- procmsg_msginfo_free(msginfo);
+ procmsg_msginfo_unset_flags(msginfo, ~0, 0);
+ procmsg_msginfo_free(msginfo); /* refcnt-- */
+ /* tmp_msginfo == msginfo */
+ if (tmp_msginfo && (msginfo->dispositionnotificationto ||
+ msginfo->returnreceiptto)) {
+ procmsg_msginfo_set_flags(msginfo, MSG_RETRCPT_SENT, 0);
+ procmsg_msginfo_free(msginfo); /* refcnt-- */
+ }
}
- folder_item_update(outbox, TRUE);
return 0;
}
g_return_if_fail(msginfo);
- if ((tmpfp = procmime_get_first_text_content(msginfo)) == NULL) {
+ if (procmime_msginfo_is_encrypted(msginfo))
+ tmpfp = procmime_get_first_encrypted_text_content(msginfo);
+ else
+ tmpfp = procmime_get_first_text_content(msginfo);
+ if (tmpfp == NULL) {
g_warning("Can't get text part\n");
return;
}
prtmp = g_strdup_printf("%s%cprinttmp.%08x",
get_mime_tmp_dir(), G_DIR_SEPARATOR, id++);
- if ((prfp = fopen(prtmp, "wb")) == NULL) {
+ if ((prfp = g_fopen(prtmp, "wb")) == NULL) {
FILE_OP_ERROR(prtmp, "fopen");
g_free(prtmp);
fclose(tmpfp);
g_snprintf(buf, sizeof(buf) - 1, cmdline, prtmp);
else {
if (cmdline)
- g_warning("Print command line is invalid: `%s'\n",
+ g_warning("Print command line is invalid: '%s'\n",
cmdline);
g_snprintf(buf, sizeof(buf) - 1, def_cmd, prtmp);
}
MsgInfo *procmsg_msginfo_copy(MsgInfo *msginfo)
{
MsgInfo *newmsginfo;
+ GSList *refs;
if (msginfo == NULL) return NULL;
MEMBCOPY(size);
MEMBCOPY(mtime);
MEMBCOPY(date_t);
+
MEMBCOPY(flags);
MEMBDUP(fromname);
MEMBCOPY(folder);
MEMBCOPY(to_folder);
+ MEMBDUP(face);
MEMBDUP(xface);
MEMBDUP(dispositionnotificationto);
MEMBDUP(returnreceiptto);
- MEMBDUP(references);
+
+ refs = msginfo->references;
+ for (refs = msginfo->references; refs != NULL; refs = refs->next) {
+ newmsginfo->references = g_slist_prepend
+ (newmsginfo->references, g_strdup(refs->data));
+ }
+ newmsginfo->references = g_slist_reverse(newmsginfo->references);
MEMBCOPY(score);
- MEMBCOPY(threadscore);
+ MEMBDUP(plaintext_file);
return newmsginfo;
}
if (msginfo == NULL) return NULL;
- file = procmsg_get_message_file(msginfo);
- if (!file) {
+ file = procmsg_get_message_file_path(msginfo);
+ if (!file || !is_file_exist(file)) {
+ g_free(file);
+ file = procmsg_get_message_file(msginfo);
+ }
+ if (!file || !is_file_exist(file)) {
g_warning("procmsg_msginfo_get_full_info(): can't get message file.\n");
return NULL;
}
g_free(file);
if (!full_msginfo) return NULL;
- full_msginfo->msgnum = msginfo->msgnum;
- full_msginfo->size = msginfo->size;
- full_msginfo->mtime = msginfo->mtime;
- full_msginfo->folder = msginfo->folder;
-#if USE_GPGME
- full_msginfo->plaintext_file = g_strdup(msginfo->plaintext_file);
- full_msginfo->decryption_failed = msginfo->decryption_failed;
-#endif
- procmsg_msginfo_set_to_folder(full_msginfo, msginfo->to_folder);
-
- return full_msginfo;
+ /* CLAWS: make sure we add the missing members; see:
+ * procheader.c::procheader_get_headernames() */
+ if (!msginfo->list_post)
+ msginfo->list_post = g_strdup(full_msginfo->list_post);
+ if (!msginfo->list_subscribe)
+ msginfo->list_subscribe = g_strdup(full_msginfo->list_subscribe);
+ if (!msginfo->list_unsubscribe)
+ msginfo->list_unsubscribe = g_strdup(full_msginfo->list_unsubscribe);
+ if (!msginfo->list_help)
+ msginfo->list_help = g_strdup(full_msginfo->list_help);
+ if (!msginfo->list_archive)
+ msginfo->list_archive= g_strdup(full_msginfo->list_archive);
+ if (!msginfo->list_owner)
+ msginfo->list_owner = g_strdup(full_msginfo->list_owner);
+ if (!msginfo->xface)
+ msginfo->xface = g_strdup(full_msginfo->xface);
+ if (!msginfo->face)
+ msginfo->face = g_strdup(full_msginfo->face);
+ if (!msginfo->dispositionnotificationto)
+ msginfo->dispositionnotificationto =
+ g_strdup(full_msginfo->dispositionnotificationto);
+ if (!msginfo->returnreceiptto)
+ msginfo->returnreceiptto = g_strdup
+ (full_msginfo->returnreceiptto);
+ if (!msginfo->partial_recv && full_msginfo->partial_recv)
+ msginfo->partial_recv = g_strdup
+ (full_msginfo->partial_recv);
+ msginfo->total_size = full_msginfo->total_size;
+ if (!msginfo->account_server && full_msginfo->account_server)
+ msginfo->account_server = g_strdup
+ (full_msginfo->account_server);
+ if (!msginfo->account_login && full_msginfo->account_login)
+ msginfo->account_login = g_strdup
+ (full_msginfo->account_login);
+ msginfo->planned_download = full_msginfo->planned_download;
+ procmsg_msginfo_free(full_msginfo);
+
+ return procmsg_msginfo_new_ref(msginfo);
}
void procmsg_msginfo_free(MsgInfo *msginfo)
if (msginfo->refcnt > 0)
return;
- debug_print("freeing msginfo %d in %s\n", msginfo->msgnum, msginfo->folder ? msginfo->folder->path : "(nil)");
-
if (msginfo->to_folder) {
msginfo->to_folder->op_count--;
folder_item_update(msginfo->to_folder, F_ITEM_UPDATE_MSGCNT);
}
g_free(msginfo->fromspace);
- g_free(msginfo->references);
g_free(msginfo->returnreceiptto);
g_free(msginfo->dispositionnotificationto);
g_free(msginfo->xface);
+ g_free(msginfo->face);
g_free(msginfo->fromname);
g_free(msginfo->inreplyto);
g_free(msginfo->xref);
+ g_free(msginfo->list_post);
+ g_free(msginfo->list_subscribe);
+ g_free(msginfo->list_unsubscribe);
+ g_free(msginfo->list_help);
+ g_free(msginfo->list_archive);
+ g_free(msginfo->list_owner);
+
+ g_free(msginfo->partial_recv);
+ g_free(msginfo->account_server);
+ g_free(msginfo->account_login);
+
+ slist_free_strings(msginfo->references);
+ g_slist_free(msginfo->references);
+
+ g_free(msginfo->plaintext_file);
+
g_free(msginfo);
}
guint procmsg_msginfo_memusage(MsgInfo *msginfo)
{
guint memusage = 0;
+ GSList *refs;
memusage += sizeof(MsgInfo);
if (msginfo->fromname)
memusage += strlen(msginfo->inreplyto);
if (msginfo->xface)
memusage += strlen(msginfo->xface);
+ if (msginfo->face)
+ memusage += strlen(msginfo->face);
if (msginfo->dispositionnotificationto)
memusage += strlen(msginfo->dispositionnotificationto);
if (msginfo->returnreceiptto)
memusage += strlen(msginfo->returnreceiptto);
- if (msginfo->references)
- memusage += strlen(msginfo->references);
+ for (refs = msginfo->references; refs; refs=refs->next) {
+ gchar *r = (gchar *)refs->data;
+ memusage += r?strlen(r):0;
+ }
if (msginfo->fromspace)
memusage += strlen(msginfo->fromspace);
return msginfo1->msgnum - msginfo2->msgnum;
}
-enum
-{
- Q_SENDER = 0,
- Q_SMTPSERVER = 1,
- Q_RECIPIENTS = 2,
- Q_NEWSGROUPS = 3,
- Q_MAIL_ACCOUNT_ID = 4,
- Q_NEWS_ACCOUNT_ID = 5,
- Q_SAVE_COPY_FOLDER = 6,
- Q_REPLY_MESSAGE_ID = 7,
- Q_FWD_MESSAGE_ID = 8
-};
-
-gint procmsg_send_message_queue(const gchar *file)
+static gint procmsg_send_message_queue_full(const gchar *file, gboolean keep_session, gchar **errstr)
{
static HeaderEntry qentry[] = {{"S:", NULL, FALSE},
{"SSV:", NULL, FALSE},
{"SCF:", NULL, FALSE},
{"RMID:", NULL, FALSE},
{"FMID:", NULL, FALSE},
+ {"X-Sylpheed-Privacy-System:", NULL, FALSE},
+ {"X-Sylpheed-Encrypt:", NULL, FALSE},
+ {"X-Sylpheed-Encrypt-Data:", NULL, FALSE},
+ {"X-Sylpheed-End-Special-Headers:", NULL, FALSE},
{NULL, NULL, FALSE}};
FILE *fp;
gint filepos;
gchar *savecopyfolder = NULL;
gchar *replymessageid = NULL;
gchar *fwdmessageid = NULL;
+ gchar *privacy_system = NULL;
+ gboolean encrypt = FALSE;
+ gchar *encrypt_data = NULL;
gchar buf[BUFFSIZE];
gint hnum;
PrefsAccount *mailac = NULL, *newsac = NULL;
+ gboolean save_clear_text = TRUE;
+ gchar *tmp_enc_file = NULL;
+
int local = 0;
g_return_val_if_fail(file != NULL, -1);
- if ((fp = fopen(file, "rb")) == NULL) {
+ if ((fp = g_fopen(file, "rb")) == NULL) {
FILE_OP_ERROR(file, "fopen");
+ if (errstr) {
+ if (*errstr) g_free(*errstr);
+ *errstr = g_strdup_printf(_("Couldn't open file %s."), file);
+ }
return -1;
}
switch (hnum) {
case Q_SENDER:
- if (!from) from = g_strdup(p);
+ if (from == NULL)
+ from = g_strdup(p);
break;
case Q_SMTPSERVER:
- if (!smtpserver) smtpserver = g_strdup(p);
+ if (smtpserver == NULL)
+ smtpserver = g_strdup(p);
break;
case Q_RECIPIENTS:
to_list = address_list_append(to_list, p);
newsac = account_find_from_id(atoi(p));
break;
case Q_SAVE_COPY_FOLDER:
- if (!savecopyfolder) savecopyfolder = g_strdup(p);
+ if (savecopyfolder == NULL)
+ savecopyfolder = g_strdup(p);
break;
case Q_REPLY_MESSAGE_ID:
- if (!replymessageid) replymessageid = g_strdup(p);
+ if (replymessageid == NULL)
+ replymessageid = g_strdup(p);
break;
case Q_FWD_MESSAGE_ID:
- if (!fwdmessageid) fwdmessageid = g_strdup(p);
+ if (fwdmessageid == NULL)
+ fwdmessageid = g_strdup(p);
+ break;
+ case Q_PRIVACY_SYSTEM:
+ if (privacy_system == NULL)
+ privacy_system = g_strdup(p);
+ break;
+ case Q_ENCRYPT:
+ if (p[0] == '1')
+ encrypt = TRUE;
break;
+ case Q_ENCRYPT_DATA:
+ if (encrypt_data == NULL)
+ encrypt_data = g_strdup(p);
+ break;
+ case Q_SYLPHEED_HDRS:
+ /* end of special headers reached */
+ goto send_mail; /* can't "break;break;" */
}
}
+send_mail:
filepos = ftell(fp);
+ if (encrypt) {
+ MimeInfo *mimeinfo;
+
+ if (mailac && mailac->save_encrypted_as_clear_text
+ && !mailac->encrypt_to_self)
+ save_clear_text = TRUE;
+ else
+ save_clear_text = FALSE;
+
+ fclose(fp);
+ fp = NULL;
+
+ mimeinfo = procmime_scan_queue_file(file);
+ if (!privacy_encrypt(privacy_system, mimeinfo, encrypt_data)
+ || (fp = my_tmpfile()) == NULL
+ || procmime_write_mimeinfo(mimeinfo, fp) < 0) {
+ if (fp)
+ fclose(fp);
+ procmime_mimeinfo_free_all(mimeinfo);
+ g_free(from);
+ g_free(smtpserver);
+ slist_free_strings(to_list);
+ g_slist_free(to_list);
+ slist_free_strings(newsgroup_list);
+ g_slist_free(newsgroup_list);
+ g_free(savecopyfolder);
+ g_free(replymessageid);
+ g_free(fwdmessageid);
+ g_free(privacy_system);
+ g_free(encrypt_data);
+ if (errstr) {
+ if (*errstr) g_free(*errstr);
+ *errstr = g_strdup_printf(_("Couldn't encrypt the email: %s"),
+ privacy_get_error());
+ }
+ return -1;
+ }
+
+ rewind(fp);
+ if (!save_clear_text) {
+ gchar *content = NULL;
+ FILE *tmpfp = get_tmpfile_in_dir(get_mime_tmp_dir(), &tmp_enc_file);
+ if (tmpfp) {
+ fclose(tmpfp);
+
+ content = file_read_stream_to_str(fp);
+ rewind(fp);
+
+ str_write_to_file(content, tmp_enc_file);
+ g_free(content);
+ } else {
+ g_warning("couldn't get tempfile\n");
+ }
+ }
+
+ procmime_mimeinfo_free_all(mimeinfo);
+
+ filepos = 0;
+ }
+
if (to_list) {
debug_print("Sending message by mail\n");
if (!from) {
- g_warning("Queued message header is broken.\n");
+ if (errstr) {
+ if (*errstr) g_free(*errstr);
+ *errstr = g_strdup_printf(_("Queued message header is broken."));
+ }
mailval = -1;
} else if (mailac && mailac->use_mail_command &&
mailac->mail_command && (* mailac->mail_command)) {
mailval = send_message_local(mailac->mail_command, fp);
local = 1;
- } else if (prefs_common.use_extsend && prefs_common.extsend_cmd) {
- mailval = send_message_local(prefs_common.extsend_cmd, fp);
- local = 1;
} else {
if (!mailac) {
mailac = account_find_from_smtp_server(from, smtpserver);
}
}
- if (mailac)
- mailval = send_message_smtp(mailac, to_list, fp);
- else {
+ if (mailac) {
+ mailval = send_message_smtp_full(mailac, to_list, fp, keep_session);
+ if (mailval == -1 && errstr) {
+ if (*errstr) g_free(*errstr);
+ *errstr = g_strdup_printf(_("An error happened during SMTP session."));
+ }
+ } else {
PrefsAccount tmp_ac;
g_warning("Account not found.\n");
tmp_ac.smtp_server = smtpserver;
tmp_ac.smtpport = SMTP_PORT;
mailval = send_message_smtp(&tmp_ac, to_list, fp);
+ if (mailval == -1 && errstr) {
+ if (*errstr) g_free(*errstr);
+ *errstr = g_strdup_printf(_("No specific account has been found to "
+ "send, and an error happened during SMTP session."));
+ }
}
}
+ } else if (!to_list && !newsgroup_list) {
+ if (errstr) {
+ if (*errstr) g_free(*errstr);
+ *errstr = g_strdup(_("Couldn't determine sending informations. "
+ "Maybe the email hasn't been generated by Sylpheed-Claws."));
+ }
+ mailval = -1;
}
fseek(fp, filepos, SEEK_SET);
- if (newsgroup_list && (newsval == 0)) {
+ if (newsgroup_list && (mailval == 0)) {
Folder *folder;
gchar *tmp = NULL;
FILE *tmpfp;
/* write to temporary file */
tmp = g_strdup_printf("%s%ctmp%d", g_get_tmp_dir(),
G_DIR_SEPARATOR, (gint)file);
- if ((tmpfp = fopen(tmp, "wb")) == NULL) {
+ if ((tmpfp = g_fopen(tmp, "wb")) == NULL) {
FILE_OP_ERROR(tmp, "fopen");
newsval = -1;
alertpanel_error(_("Could not create temporary file for news sending."));
if (fputs(buf, tmpfp) == EOF) {
FILE_OP_ERROR(tmp, "fputs");
newsval = -1;
- alertpanel_error(_("Error when writing temporary file for news sending."));
+ if (errstr) {
+ if (*errstr) g_free(*errstr);
+ *errstr = g_strdup_printf(_("Error when writing temporary file for news sending."));
+ }
}
}
fclose(tmpfp);
folder = FOLDER(newsac->folder);
newsval = news_post(folder, tmp);
- if (newsval < 0) {
- alertpanel_error(_("Error occurred while posting the message to %s ."),
- newsac->nntp_server);
- }
+ if (newsval < 0 && errstr) {
+ if (*errstr) g_free(*errstr);
+ *errstr = g_strdup_printf(_("Error occurred while posting the message to %s."),
+ newsac->nntp_server);
+ }
}
- unlink(tmp);
+ g_unlink(tmp);
}
g_free(tmp);
}
- slist_free_strings(to_list);
- g_slist_free(to_list);
- slist_free_strings(newsgroup_list);
- g_slist_free(newsgroup_list);
- g_free(from);
- g_free(smtpserver);
fclose(fp);
/* save message to outbox */
outbox = folder_find_item_from_identifier(savecopyfolder);
if (!outbox)
outbox = folder_get_default_outbox();
+
+ if (save_clear_text || tmp_enc_file == NULL) {
+ procmsg_save_to_outbox(outbox, file, TRUE);
+ } else {
+ procmsg_save_to_outbox(outbox, tmp_enc_file, FALSE);
+ }
+ }
- procmsg_save_to_outbox(outbox, file, TRUE);
+ if (tmp_enc_file != NULL) {
+ g_unlink(tmp_enc_file);
+ free(tmp_enc_file);
+ tmp_enc_file = NULL;
}
if (replymessageid != NULL || fwdmessageid != NULL) {
FolderItem *item;
if (replymessageid != NULL)
- tokens = g_strsplit(replymessageid, "\x7f", 0);
+ tokens = g_strsplit(replymessageid, "\t", 0);
else
- tokens = g_strsplit(fwdmessageid, "\x7f", 0);
+ tokens = g_strsplit(fwdmessageid, "\t", 0);
item = folder_find_item_from_identifier(tokens[0]);
/* check if queued message has valid folder and message id */
if (replymessageid != NULL) {
procmsg_msginfo_unset_flags(msginfo, MSG_FORWARDED, 0);
procmsg_msginfo_set_flags(msginfo, MSG_REPLIED, 0);
- }
- else {
+ } else {
procmsg_msginfo_unset_flags(msginfo, MSG_REPLIED, 0);
procmsg_msginfo_set_flags(msginfo, MSG_FORWARDED, 0);
}
g_strfreev(tokens);
}
+ g_free(from);
+ g_free(smtpserver);
+ slist_free_strings(to_list);
+ g_slist_free(to_list);
+ slist_free_strings(newsgroup_list);
+ g_slist_free(newsgroup_list);
g_free(savecopyfolder);
g_free(replymessageid);
g_free(fwdmessageid);
-
+ g_free(privacy_system);
+ g_free(encrypt_data);
+
return (newsval != 0 ? newsval : mailval);
}
+gint procmsg_send_message_queue(const gchar *file, gchar **errstr)
+{
+ return procmsg_send_message_queue_full(file, FALSE, errstr);
+}
+
static void update_folder_msg_counts(FolderItem *item, MsgInfo *msginfo, MsgPermFlags old_flags)
{
MsgPermFlags new_flags = msginfo->flags.perm_flags;
/* MARK flag */
if (!(old_flags & MSG_MARKED) && (new_flags & MSG_MARKED)) {
procmsg_update_unread_children(msginfo, TRUE);
+ item->marked_msgs++;
}
if ((old_flags & MSG_MARKED) && !(new_flags & MSG_MARKED)) {
procmsg_update_unread_children(msginfo, FALSE);
+ item->marked_msgs--;
}
}
FolderItem *item;
MsgInfoUpdate msginfo_update;
MsgPermFlags perm_flags_new, perm_flags_old;
+ MsgTmpFlags tmp_flags_old;
g_return_if_fail(msginfo != NULL);
item = msginfo->folder;
update_folder_msg_counts(item, msginfo, perm_flags_old);
+ }
+
+ /* Tmp flags handling */
+ tmp_flags_old = msginfo->flags.tmp_flags;
+ msginfo->flags.tmp_flags |= tmp_flags;
+
+ /* update notification */
+ if ((perm_flags_old != perm_flags_new) || (tmp_flags_old != msginfo->flags.tmp_flags)) {
msginfo_update.msginfo = msginfo;
+ msginfo_update.flags = MSGINFO_UPDATE_FLAGS;
hooks_invoke(MSGINFO_UPDATE_HOOKLIST, &msginfo_update);
folder_item_update(msginfo->folder, F_ITEM_UPDATE_MSGCNT);
}
-
- /* Tmp flags hanlding */
- msginfo->flags.tmp_flags |= tmp_flags;
}
void procmsg_msginfo_unset_flags(MsgInfo *msginfo, MsgPermFlags perm_flags, MsgTmpFlags tmp_flags)
FolderItem *item;
MsgInfoUpdate msginfo_update;
MsgPermFlags perm_flags_new, perm_flags_old;
+ MsgTmpFlags tmp_flags_old;
g_return_if_fail(msginfo != NULL);
item = msginfo->folder;
folder_item_change_msg_flags(msginfo->folder, msginfo, perm_flags_new);
update_folder_msg_counts(item, msginfo, perm_flags_old);
+ }
+
+ /* Tmp flags hanlding */
+ tmp_flags_old = msginfo->flags.tmp_flags;
+ msginfo->flags.tmp_flags &= ~tmp_flags;
+ /* update notification */
+ if ((perm_flags_old != perm_flags_new) || (tmp_flags_old != msginfo->flags.tmp_flags)) {
msginfo_update.msginfo = msginfo;
+ msginfo_update.flags = MSGINFO_UPDATE_FLAGS;
hooks_invoke(MSGINFO_UPDATE_HOOKLIST, &msginfo_update);
folder_item_update(msginfo->folder, F_ITEM_UPDATE_MSGCNT);
}
+}
- /* Tmp flags hanlding */
- msginfo->flags.tmp_flags &= ~tmp_flags;
+void procmsg_msginfo_change_flags(MsgInfo *msginfo,
+ MsgPermFlags add_perm_flags, MsgTmpFlags add_tmp_flags,
+ MsgPermFlags rem_perm_flags, MsgTmpFlags rem_tmp_flags)
+{
+ FolderItem *item;
+ MsgInfoUpdate msginfo_update;
+ MsgPermFlags perm_flags_new, perm_flags_old;
+ MsgTmpFlags tmp_flags_old;
+
+ g_return_if_fail(msginfo != NULL);
+ item = msginfo->folder;
+ g_return_if_fail(item != NULL);
+
+ debug_print("Changing flags for message %d in folder %s\n", msginfo->msgnum, item->path);
+
+ /* Perm Flags handling */
+ perm_flags_old = msginfo->flags.perm_flags;
+ perm_flags_new = (msginfo->flags.perm_flags & ~rem_perm_flags) | add_perm_flags;
+ if ((add_perm_flags & MSG_IGNORE_THREAD) || (perm_flags_old & MSG_IGNORE_THREAD)) {
+ perm_flags_new &= ~(MSG_NEW | MSG_UNREAD);
+ }
+
+ if (perm_flags_old != perm_flags_new) {
+ folder_item_change_msg_flags(msginfo->folder, msginfo, perm_flags_new);
+
+ update_folder_msg_counts(item, msginfo, perm_flags_old);
+
+ }
+
+ /* Tmp flags handling */
+ tmp_flags_old = msginfo->flags.tmp_flags;
+ msginfo->flags.tmp_flags &= ~rem_tmp_flags;
+ msginfo->flags.tmp_flags |= add_tmp_flags;
+
+ /* update notification */
+ if ((perm_flags_old != perm_flags_new) || (tmp_flags_old != msginfo->flags.tmp_flags)) {
+ msginfo_update.msginfo = msginfo;
+ msginfo_update.flags = MSGINFO_UPDATE_FLAGS;
+ hooks_invoke(MSGINFO_UPDATE_HOOKLIST, &msginfo_update);
+ folder_item_update(msginfo->folder, F_ITEM_UPDATE_MSGCNT);
+ }
}
/*!
gboolean result;
if (g_hash_table_lookup(parentmsgs, info)) {
- debug_print("loop detected: %s%c%d\n",
- folder_item_get_path(info->folder),
- G_DIR_SEPARATOR, info->msgnum);
+ debug_print("loop detected: %d\n",
+ info->msgnum);
result = FALSE;
} else {
g_hash_table_insert(parentmsgs, info, "1");
MailFilteringData mail_filtering_data;
mail_filtering_data.msginfo = msginfo;
- if (hooks_invoke(MAIL_FILTERING_HOOKLIST, &mail_filtering_data))
+ if (hooks_invoke(MAIL_FILTERING_HOOKLIST, &mail_filtering_data)) {
return TRUE;
+ }
/* filter if enabled in prefs or move to inbox if not */
- if((global_processing != NULL) &&
- filter_message_by_msginfo(global_processing, msginfo))
+ if((filtering_rules != NULL) &&
+ filter_message_by_msginfo(filtering_rules, msginfo)) {
return TRUE;
-
+ }
+
return FALSE;
}
+
+MsgInfo *procmsg_msginfo_new_from_mimeinfo(MsgInfo *src_msginfo, MimeInfo *mimeinfo)
+{
+ MsgInfo *tmp_msginfo = NULL;
+ MsgFlags flags = {0, 0};
+ gchar *tmpfile = get_tmp_file();
+ FILE *fp = g_fopen(tmpfile, "wb");
+
+ if (!mimeinfo || mimeinfo->type != MIMETYPE_MESSAGE ||
+ g_ascii_strcasecmp(mimeinfo->subtype, "rfc822")) {
+ g_warning("procmsg_msginfo_new_from_mimeinfo(): unsuitable mimeinfo");
+ if (fp)
+ fclose(fp);
+ g_free(tmpfile);
+ return NULL;
+ }
+
+ if (fp && procmime_write_mimeinfo(mimeinfo, fp) >= 0) {
+ fclose(fp);
+ fp = NULL;
+ tmp_msginfo = procheader_parse_file(
+ tmpfile, flags,
+ TRUE, FALSE);
+ }
+ if (fp)
+ fclose(fp);
+
+ if (tmp_msginfo != NULL) {
+ if (src_msginfo)
+ tmp_msginfo->folder = src_msginfo->folder;
+ tmp_msginfo->plaintext_file = g_strdup(tmpfile);
+ } else {
+ g_warning("procmsg_msginfo_new_from_mimeinfo(): Can't generate new msginfo");
+ }
+
+ g_free(tmpfile);
+
+ return tmp_msginfo;
+}
+
+static GSList *spam_learners = NULL;
+
+void procmsg_register_spam_learner (int (*learn_func)(MsgInfo *info, GSList *list, gboolean spam))
+{
+ if (!g_slist_find(spam_learners, learn_func))
+ spam_learners = g_slist_append(spam_learners, learn_func);
+ if (mainwindow_get_mainwindow()) {
+ main_window_set_menu_sensitive(mainwindow_get_mainwindow());
+ summary_set_menu_sensitive(
+ mainwindow_get_mainwindow()->summaryview);
+ toolbar_main_set_sensitive(mainwindow_get_mainwindow());
+ }
+}
+
+void procmsg_unregister_spam_learner (int (*learn_func)(MsgInfo *info, GSList *list, gboolean spam))
+{
+ spam_learners = g_slist_remove(spam_learners, learn_func);
+ if (mainwindow_get_mainwindow()) {
+ main_window_set_menu_sensitive(mainwindow_get_mainwindow());
+ summary_set_menu_sensitive(
+ mainwindow_get_mainwindow()->summaryview);
+ toolbar_main_set_sensitive(mainwindow_get_mainwindow());
+ }
+}
+
+gboolean procmsg_spam_can_learn(void)
+{
+ return g_slist_length(spam_learners) > 0;
+}
+
+int procmsg_spam_learner_learn (MsgInfo *info, GSList *list, gboolean spam)
+{
+ GSList *cur = spam_learners;
+ int ret = 0;
+ for (; cur; cur = cur->next) {
+ int ((*func)(MsgInfo *info, GSList *list, gboolean spam)) = cur->data;
+ ret |= func(info, list, spam);
+ }
+ return ret;
+}
+
+static gchar *spam_folder_item = NULL;
+void procmsg_spam_set_folder (const char *item_identifier)
+{
+ g_free(spam_folder_item);
+ if (item_identifier)
+ spam_folder_item = g_strdup(item_identifier);
+ else
+ spam_folder_item = NULL;
+}
+
+FolderItem *procmsg_spam_get_folder (void)
+{
+ FolderItem *item = spam_folder_item ? folder_find_item_from_identifier(spam_folder_item) : NULL;
+ return item ? item : folder_get_default_trash();
+}
projects / claws.git / blobdiff