/*
* Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
- * Copyright (C) 1999-2006 Hiroyuki Yamamoto and the Sylpheed-Claws team
+ * Copyright (C) 1999-2012 Hiroyuki Yamamoto and the Claws Mail 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
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* GNU General Public License for more details.
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
*/
#include "defs.h"
#include "mainwindow.h"
#include "summaryview.h"
#include "log.h"
+#include "tags.h"
#include "timing.h"
+#include "inc.h"
+#include "privacy.h"
-static gint procmsg_send_message_queue_full(const gchar *file, gboolean keep_session);
+extern SessionStats session_stats;
+static gint procmsg_send_message_queue_full(const gchar *file, gboolean keep_session, gchar **errstr,
+ FolderItem *queue, gint msgnum, gboolean *queued_removed);
+static void procmsg_update_unread_children (MsgInfo *info,
+ gboolean newly_marked);
enum
{
Q_SENDER = 0,
Q_PRIVACY_SYSTEM = 9,
Q_ENCRYPT = 10,
Q_ENCRYPT_DATA = 11,
+ Q_CLAWS_HDRS = 12,
+ Q_PRIVACY_SYSTEM_OLD = 13,
+ Q_ENCRYPT_OLD = 14,
+ Q_ENCRYPT_DATA_OLD = 15,
+ Q_CLAWS_HDRS_OLD = 16,
};
-GHashTable *procmsg_msg_hash_table_create(GSList *mlist)
-{
- GHashTable *msg_table;
-
- if (mlist == NULL) return NULL;
-
- msg_table = g_hash_table_new(NULL, g_direct_equal);
- procmsg_msg_hash_table_append(msg_table, mlist);
-
- return msg_table;
-}
-
-void procmsg_msg_hash_table_append(GHashTable *msg_table, GSList *mlist)
+void procmsg_msg_list_free(GSList *mlist)
{
GSList *cur;
MsgInfo *msginfo;
- if (msg_table == NULL || mlist == NULL) return;
-
for (cur = mlist; cur != NULL; cur = cur->next) {
msginfo = (MsgInfo *)cur->data;
-
- g_hash_table_insert(msg_table,
- GUINT_TO_POINTER(msginfo->msgnum),
- msginfo);
- }
-}
-
-GHashTable *procmsg_to_folder_hash_table_create(GSList *mlist)
-{
- GHashTable *msg_table;
- GSList *cur;
- MsgInfo *msginfo;
-
- if (mlist == NULL) return NULL;
-
- msg_table = g_hash_table_new(NULL, g_direct_equal);
-
- for (cur = mlist; cur != NULL; cur = cur->next) {
- msginfo = (MsgInfo *)cur->data;
- g_hash_table_insert(msg_table, msginfo->to_folder, msginfo);
+ procmsg_msginfo_free(msginfo);
}
-
- return msg_table;
+ g_slist_free(mlist);
}
-gint procmsg_get_last_num_in_msg_list(GSList *mlist)
+MsgNumberList *procmsg_get_number_list_for_msgs(MsgInfoList *msglist)
{
- GSList *cur;
- MsgInfo *msginfo;
- gint last = 0;
+ GSList *cur = NULL;
+ GSList *nums = NULL;
- for (cur = mlist; cur != NULL; cur = cur->next) {
- msginfo = (MsgInfo *)cur->data;
- if (msginfo && msginfo->msgnum > last)
- last = msginfo->msgnum;
+ for (cur = msglist; cur; cur = cur->next) {
+ MsgInfo *msg = (MsgInfo *)cur->data;
+ nums = g_slist_prepend(nums, GUINT_TO_POINTER(msg->msgnum));
}
- return last;
-}
-
-void procmsg_msg_list_free(GSList *mlist)
-{
- GSList *cur;
- MsgInfo *msginfo;
-
- for (cur = mlist; cur != NULL; cur = cur->next) {
- msginfo = (MsgInfo *)cur->data;
- procmsg_msginfo_free(msginfo);
- }
- g_slist_free(mlist);
+ return g_slist_reverse(nums);
}
struct MarkSum {
/* CLAWS subject threading:
in the first round it inserts subject lines in a
- relation (subject <-> node)
+ hashtable (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
+ hashtable. 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)
+ days old (see subject_hashtable_lookup)
*/
-static void subject_relation_insert(GRelation *relation, GNode *node)
+static void subject_hashtable_insert(GHashTable *hashtable, GNode *node)
{
gchar *subject;
MsgInfo *msginfo;
+ GSList *list = NULL;
- g_return_if_fail(relation != NULL);
- g_return_if_fail(node != NULL);
+ cm_return_if_fail(hashtable != NULL);
+ cm_return_if_fail(node != NULL);
msginfo = (MsgInfo *) node->data;
- g_return_if_fail(msginfo != NULL);
+ cm_return_if_fail(msginfo != NULL);
subject = msginfo->subject;
if (subject == NULL)
return;
+
subject += subject_get_prefix_length(subject);
- g_relation_insert(relation, subject, node);
+ list = g_hash_table_lookup(hashtable, subject);
+ list = g_slist_prepend(list, node);
+ g_hash_table_insert(hashtable, subject, list);
}
-static GNode *subject_relation_lookup(GRelation *relation, MsgInfo *msginfo)
+static GNode *subject_hashtable_lookup(GHashTable *hashtable, MsgInfo *msginfo)
{
gchar *subject;
- GTuples *tuples;
- GNode *node = NULL;
+ GSList *list, *cur;
+ GNode *node = NULL, *hashtable_node = NULL;
gint prefix_length;
+ MsgInfo *hashtable_msginfo = NULL, *best_msginfo = NULL;
+ gboolean match;
- g_return_val_if_fail(relation != NULL, NULL);
+ cm_return_val_if_fail(hashtable != NULL, NULL);
subject = msginfo->subject;
if (subject == NULL)
return NULL;
subject += prefix_length;
- tuples = g_relation_select(relation, subject, 0);
- if (tuples == NULL)
+ list = g_hash_table_lookup(hashtable, subject);
+ if (list == NULL)
return NULL;
- 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;
+ /* check all nodes with the same subject to find the best parent */
+ for (cur = list; cur; cur = cur->next) {
+ hashtable_node = (GNode *)cur->data;
+ hashtable_msginfo = (MsgInfo *) hashtable_node->data;
+ match = FALSE;
+
+ /* best node should be the oldest in the found nodes */
+ /* parent node must not be older then msginfo */
+ if ((hashtable_msginfo->date_t < msginfo->date_t) &&
+ ((best_msginfo == NULL) ||
+ (best_msginfo->date_t > hashtable_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, hashtable_msginfo->date_t)) >
+ prefs_common.thread_by_subject_max_age * 3600 * 24)
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;
- }
- }
+ /* can add new tests for all matching
+ nodes found by subject */
+
+ if (match) {
+ node = hashtable_node;
+ best_msginfo = hashtable_msginfo;
+ }
}
- g_tuples_destroy(tuples);
return node;
}
+static void subject_hashtable_free(gpointer key, gpointer value, gpointer data)
+{
+ g_slist_free(value);
+}
+
/* return the reversed thread tree */
GNode *procmsg_get_thread_tree(GSList *mlist)
{
GNode *root, *parent, *node, *next;
GHashTable *msgid_table;
- GRelation *subject_relation;
+ GHashTable *subject_hashtable = NULL;
MsgInfo *msginfo;
const gchar *msgid;
GSList *reflist;
- START_TIMING("procmsg_get_thread_tree");
+ START_TIMING("");
root = g_node_new(NULL);
msgid_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);
+
+ if (prefs_common.thread_by_subject) {
+ subject_hashtable = g_hash_table_new(g_str_hash, g_str_equal);
+ }
for (; mlist != NULL; mlist = mlist->next) {
msginfo = (MsgInfo *)mlist->data;
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) */
+ /* CLAWS: add subject to hashtable (without prefix) */
if (prefs_common.thread_by_subject) {
- subject_relation_insert(subject_relation, node);
+ subject_hashtable_insert(subject_hashtable, node);
}
}
}
if (prefs_common.thread_by_subject) {
- START_TIMING("procmsg_get_thread_tree(1)");
+ START_TIMING("thread by subject");
for (node = root->children; node && node != NULL;) {
next = node->next;
msginfo = (MsgInfo *) node->data;
- parent = subject_relation_lookup(subject_relation, msginfo);
+ parent = subject_hashtable_lookup(subject_hashtable, msginfo);
/* the node may already be threaded by IN-REPLY-TO, so go up
* in the tree to
END_TIMING();
}
- g_relation_destroy(subject_relation);
+ if (prefs_common.thread_by_subject)
+ {
+ g_hash_table_foreach(subject_hashtable, subject_hashtable_free, NULL);
+ g_hash_table_destroy(subject_hashtable);
+ }
+
g_hash_table_destroy(msgid_table);
END_TIMING();
return root;
{
gchar *file;
- g_return_val_if_fail(msginfo != NULL, NULL);
+ cm_return_val_if_fail(msginfo != NULL, NULL);
if (msginfo->plaintext_file)
file = g_strdup(msginfo->plaintext_file);
{
gchar *filename = NULL;
- g_return_val_if_fail(msginfo != NULL, NULL);
+ cm_return_val_if_fail(msginfo != NULL, NULL);
filename = folder_item_fetch_msg(msginfo->folder, msginfo->msgnum);
if (!filename)
{
gchar *filename = NULL;
- g_return_val_if_fail(msginfo != NULL, NULL);
+ cm_return_val_if_fail(msginfo != NULL, NULL);
filename = folder_item_fetch_msg_full(msginfo->folder, msginfo->msgnum,
headers, body);
FILE *fp;
gchar *file;
- g_return_val_if_fail(msginfo != NULL, NULL);
-
+ cm_return_val_if_fail(msginfo != NULL, NULL);
+
file = procmsg_get_message_file_path(msginfo);
- g_return_val_if_fail(file != NULL, NULL);
+ cm_return_val_if_fail(file != NULL, NULL);
if (!is_file_exist(file)) {
g_free(file);
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-Claws-End-Special-Headers: 1",
+ strlen("X-Claws-End-Special-Headers:"))) ||
+ (!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;
+ }
+ }
}
return fp;
FILE *fp;
- g_return_if_fail(msginfo != NULL);
- g_return_if_fail(header != NULL);
- g_return_if_fail(key != NULL);
+ cm_return_if_fail(msginfo != NULL);
+ cm_return_if_fail(header != NULL);
+ cm_return_if_fail(key != NULL);
*header = NULL;
*key = NULL;
hentry[idx].body = NULL; \
}
- if (hentry[H_X_BEENTHERE].body != NULL) {
+ if (hentry[H_LIST_ID].body != NULL) {
+ SET_FILTER_KEY("header \"List-Id\"", H_LIST_ID);
+ extract_list_id_str(*key);
+ } else if (hentry[H_X_BEENTHERE].body != NULL) {
SET_FILTER_KEY("header \"X-BeenThere\"", H_X_BEENTHERE);
} else if (hentry[H_X_ML_NAME].body != NULL) {
SET_FILTER_KEY("header \"X-ML-Name\"", H_X_ML_NAME);
SET_FILTER_KEY("header \"X-List\"", H_X_LIST);
} else if (hentry[H_X_MAILING_LIST].body != NULL) {
SET_FILTER_KEY("header \"X-Mailing-List\"", H_X_MAILING_LIST);
- } else if (hentry[H_LIST_ID].body != NULL) {
- SET_FILTER_KEY("header \"List-Id\"", H_LIST_ID);
- extract_list_id_str(*key);
- } else if (hentry[H_X_SEQUENCE].body != NULL) {
+ } else if (hentry[H_X_SEQUENCE].body != NULL) {
gchar *p;
SET_FILTER_KEY("X-Sequence", H_X_SEQUENCE);
}
}
-void procmsg_empty_trash(FolderItem *trash)
+static void procmsg_empty_trash(FolderItem *trash)
{
GNode *node, *next;
GSList *cur;
for (cur = mlist ; cur != NULL ; cur = cur->next) {
MsgInfo * msginfo = (MsgInfo *) cur->data;
- if (MSG_IS_LOCKED(msginfo->flags))
+ if (MSG_IS_LOCKED(msginfo->flags)) {
+ procmsg_msginfo_free(msginfo);
continue;
+ }
if (msginfo->total_size != 0 &&
msginfo->size != (off_t)msginfo->total_size)
partial_mark_for_delete(msginfo);
{"SCF:", NULL, FALSE},
{"RMID:", NULL, FALSE},
{"FMID:", NULL, FALSE},
+ {"X-Claws-Privacy-System:", NULL, FALSE},
+ {"X-Claws-Encrypt:", NULL, FALSE},
+ {"X-Claws-Encrypt-Data:", NULL, FALSE},
+ {"X-Claws-End-Special-Headers", 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);
+ cm_return_val_if_fail(file != NULL, NULL);
if ((fp = g_fopen(file, "rb")) == NULL) {
FILE_OP_ERROR(file, "fopen");
return mailac;
}
+gchar *procmsg_msginfo_get_identifier(MsgInfo *msginfo)
+{
+ gchar *folder_id;
+ const gchar *msgid;
+ gchar *id;
+
+ cm_return_val_if_fail(msginfo != NULL, NULL);
+ folder_id = folder_item_get_identifier(msginfo->folder);
+ msgid = msginfo->msgid;
+
+ id = g_strconcat(folder_id, G_DIR_SEPARATOR_S, msgid, NULL);
+
+ g_free(folder_id);
+
+ return id;
+}
+
+MsgInfo *procmsg_get_msginfo_from_identifier(const gchar *id)
+{
+ gchar *folder_id = g_strdup(id);
+ gchar *separator = strrchr(folder_id, G_DIR_SEPARATOR);
+ const gchar *msgid;
+ FolderItem *item;
+ MsgInfo *msginfo;
+
+ if (separator == NULL) {
+ g_free(folder_id);
+ return NULL;
+ }
+
+ *separator = '\0';
+ msgid = separator + 1;
+
+ item = folder_find_item_from_identifier(folder_id);
+
+ if (item == NULL) {
+ g_free(folder_id);
+ return NULL;
+ }
+
+ msginfo = folder_item_get_msginfo_by_msgid(item, msgid);
+ g_free(folder_id);
+
+ return msginfo;
+}
+
static GSList *procmsg_list_sort_by_account(FolderItem *queue, GSList *list)
{
GSList *result = NULL;
g_slist_free(orig);
for (cur = result; cur; cur = cur->next)
- debug_print("sort after %s\n", ((MsgInfo *)cur->data)->from);
+ debug_print("sort after %s\n", ((MsgInfo *)cur->data)->from);
debug_print("\n");
{
gchar *file = folder_item_fetch_msg(queue, msginfo->msgnum);
PrefsAccount *ac = procmsg_get_account_from_file(file);
- GSList *cur = elem;
+ GSList *cur;
g_free(file);
for (cur = elem; cur; cur = cur->next) {
MsgInfo *cur_msginfo = (MsgInfo *)cur->data;
return TRUE;
}
+static gboolean send_queue_lock = FALSE;
+
+gboolean procmsg_queue_lock(char **errstr)
+{
+ if (send_queue_lock) {
+ /* Avoid having to translate two similar strings */
+ log_warning(LOG_PROTOCOL, "%s\n", _("Already trying to send."));
+ if (errstr) {
+ if (*errstr) g_free(*errstr);
+ *errstr = g_strdup_printf(_("Already trying to send."));
+ }
+ return FALSE;
+ }
+ send_queue_lock = TRUE;
+ return TRUE;
+}
+void procmsg_queue_unlock(void)
+{
+ send_queue_lock = FALSE;
+}
/*!
*\brief Send messages in queue
*
*\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 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 (!procmsg_queue_lock(errstr)) {
+ main_window_set_menu_sensitive(mainwindow_get_mainwindow());
+ toolbar_main_set_sensitive(mainwindow_get_mainwindow());
return -1;
}
- send_queue_lock = TRUE;
+ inc_lock();
if (!queue)
queue = folder_get_default_queue();
- g_return_val_if_fail(queue != NULL, -1);
+
+ if (queue == NULL) {
+ procmsg_queue_unlock();
+ inc_unlock();
+ return -1;
+ }
+
+ main_window_set_menu_sensitive(mainwindow_get_mainwindow());
+ toolbar_main_set_sensitive(mainwindow_get_mainwindow());
folder_item_scan(queue);
list = folder_item_get_msg_list(queue);
MsgInfo *msginfo;
msginfo = (MsgInfo *)(elem->data);
- if (!MSG_IS_LOCKED(msginfo->flags)) {
+ if (!MSG_IS_LOCKED(msginfo->flags) && !MSG_IS_DELETED(msginfo->flags)) {
file = folder_item_fetch_msg(queue, msginfo->msgnum);
if (file) {
+ gboolean queued_removed = FALSE;
if (procmsg_send_message_queue_full(file,
- !procmsg_is_last_for_account(queue, msginfo, elem)) < 0) {
+ !procmsg_is_last_for_account(queue, msginfo, elem),
+ errstr, queue, msginfo->msgnum, &queued_removed) < 0) {
g_warning("Sending queued message %d failed.\n",
msginfo->msgnum);
err++;
} else {
sent++;
- folder_item_remove_msg(queue, msginfo->msgnum);
+ if (!queued_removed)
+ folder_item_remove_msg(queue, msginfo->msgnum);
}
g_free(file);
}
while (node != NULL) {
int res = 0;
next = node->next;
- res = procmsg_send_queue(FOLDER_ITEM(node->data), save_msgs);
+ send_queue_lock = FALSE;
+ res = procmsg_send_queue(FOLDER_ITEM(node->data), save_msgs, errstr);
+ send_queue_lock = TRUE;
if (res < 0)
err = -res;
else
node = next;
}
}
- send_queue_lock = FALSE;
+ procmsg_queue_unlock();
+ inc_unlock();
+ main_window_set_menu_sensitive(mainwindow_get_mainwindow());
+ toolbar_main_set_sensitive(mainwindow_get_mainwindow());
+
return (err != 0 ? -err : sent);
}
+gboolean procmsg_is_sending(void)
+{
+ return send_queue_lock;
+}
+
/*!
*\brief Determine if a queue folder is empty
*
gboolean res = FALSE;
if (!queue)
queue = folder_get_default_queue();
- g_return_val_if_fail(queue != NULL, TRUE);
+ cm_return_val_if_fail(queue != NULL, TRUE);
folder_item_scan(queue);
list = folder_item_get_msg_list(queue);
fclose(fp);
return -1;
}
- while (fgets(buf, sizeof(buf), fp) != NULL)
+ while (fgets(buf, sizeof(buf), fp) != NULL) {
+ /* new way */
+ if ((!strncmp(buf, "X-Claws-End-Special-Headers: 1",
+ strlen("X-Claws-End-Special-Headers:"))) ||
+ (!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);
return 0;
}
-gint procmsg_save_to_outbox(FolderItem *outbox, const gchar *file,
+static gint procmsg_save_to_outbox(FolderItem *outbox, const gchar *file,
gboolean is_queued)
{
gint num;
if (!outbox)
outbox = folder_get_default_outbox();
- g_return_val_if_fail(outbox != NULL, -1);
+ cm_return_val_if_fail(outbox != NULL, -1);
/* remove queueing headers */
if (is_queued) {
folder_item_scan(outbox);
if ((num = folder_item_add_msg(outbox, tmp, &flag, TRUE)) < 0) {
g_warning("can't save message\n");
- g_unlink(tmp);
+ claws_unlink(tmp);
return -1;
}
} else {
g_warning("can't save message\n");
return -1;
}
- return -1;
}
msginfo = folder_item_get_msginfo(outbox, num); /* refcnt++ */
tmp_msginfo = procmsg_msginfo_get_full_info(msginfo); /* refcnt++ */
procmsg_msginfo_unset_flags(msginfo, ~0, 0);
procmsg_msginfo_free(msginfo); /* refcnt-- */
/* tmp_msginfo == msginfo */
- if (tmp_msginfo && (msginfo->dispositionnotificationto ||
- msginfo->returnreceiptto)) {
+ if (tmp_msginfo && msginfo->extradata &&
+ (msginfo->extradata->dispositionnotificationto ||
+ msginfo->extradata->returnreceiptto)) {
procmsg_msginfo_set_flags(msginfo, MSG_RETRCPT_SENT, 0);
- procmsg_msginfo_free(msginfo); /* refcnt-- */
}
+ procmsg_msginfo_free(tmp_msginfo); /* refcnt-- */
}
return 0;
}
+
void procmsg_print_message(MsgInfo *msginfo, const gchar *cmdline)
{
static const gchar *def_cmd = "lpr %s";
FILE *tmpfp, *prfp;
gchar buf[1024];
gchar *p;
+ int r;
- g_return_if_fail(msginfo);
+ cm_return_if_fail(msginfo);
if (procmime_msginfo_is_encrypted(msginfo))
tmpfp = procmime_get_first_encrypted_text_content(msginfo);
return;
}
- if (msginfo->date) fprintf(prfp, "Date: %s\n", msginfo->date);
- if (msginfo->from) fprintf(prfp, "From: %s\n", msginfo->from);
- if (msginfo->to) fprintf(prfp, "To: %s\n", msginfo->to);
- if (msginfo->cc) fprintf(prfp, "Cc: %s\n", msginfo->cc);
- if (msginfo->newsgroups)
- fprintf(prfp, "Newsgroups: %s\n", msginfo->newsgroups);
- if (msginfo->subject) fprintf(prfp, "Subject: %s\n", msginfo->subject);
- fputc('\n', prfp);
+ if (msginfo->date) { r = fprintf(prfp, "Date: %s\n", msginfo->date); if (r < 0) goto fpferr; }
+ if (msginfo->from) { r = fprintf(prfp, "From: %s\n", msginfo->from); if (r < 0) goto fpferr; }
+ if (msginfo->to) { r = fprintf(prfp, "To: %s\n", msginfo->to); if (r < 0) goto fpferr; }
+ if (msginfo->cc) { r = fprintf(prfp, "Cc: %s\n", msginfo->cc); if (r < 0) goto fpferr; }
+ if (msginfo->newsgroups) {
+ r = fprintf(prfp, "Newsgroups: %s\n", msginfo->newsgroups); if (r < 0) goto fpferr;
+ }
+ if (msginfo->subject) { r = fprintf(prfp, "Subject: %s\n", msginfo->subject); if (r < 0) goto fpferr; }
+ if (fputc('\n', prfp) == EOF) goto fpferr;
- while (fgets(buf, sizeof(buf), tmpfp) != NULL)
- fputs(buf, prfp);
+ while (fgets(buf, sizeof(buf), tmpfp) != NULL) {
+ r = fputs(buf, prfp);
+ if (r == EOF) goto fpferr;
+ }
fclose(prfp);
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);
}
g_free(prtmp);
g_strchomp(buf);
- if (buf[strlen(buf) - 1] != '&') strcat(buf, "&");
- system(buf);
+ if (buf[strlen(buf) - 1] != '&')
+ strncat(buf, "&", sizeof(buf) - strlen(buf) - 1);
+ if (system(buf) == -1)
+ g_warning("system(%s) failed.", buf);
+ return;
+fpferr:
+ FILE_OP_ERROR(prtmp, "fprintf/fputc/fputs");
+ g_free(prtmp);
+ fclose(tmpfp);
+ fclose(prfp);
}
MsgInfo *procmsg_msginfo_new_ref(MsgInfo *msginfo)
MEMBCOPY(folder);
MEMBCOPY(to_folder);
- MEMBDUP(face);
- MEMBDUP(xface);
- MEMBDUP(dispositionnotificationto);
- MEMBDUP(returnreceiptto);
+ if (msginfo->extradata) {
+ newmsginfo->extradata = g_new0(MsgInfoExtraData, 1);
+ MEMBDUP(extradata->face);
+ MEMBDUP(extradata->xface);
+ MEMBDUP(extradata->dispositionnotificationto);
+ MEMBDUP(extradata->returnreceiptto);
+ MEMBDUP(extradata->partial_recv);
+ MEMBDUP(extradata->account_server);
+ MEMBDUP(extradata->account_login);
+ MEMBDUP(extradata->list_post);
+ MEMBDUP(extradata->list_subscribe);
+ MEMBDUP(extradata->list_unsubscribe);
+ MEMBDUP(extradata->list_help);
+ MEMBDUP(extradata->list_archive);
+ MEMBDUP(extradata->list_owner);
+ }
refs = msginfo->references;
for (refs = msginfo->references; refs != NULL; refs = refs->next) {
return newmsginfo;
}
+MsgInfo *procmsg_msginfo_get_full_info_from_file(MsgInfo *msginfo, const gchar *file)
+{
+ MsgInfo *full_msginfo;
+
+ if (msginfo == NULL) return NULL;
+
+ if (!file || !is_file_exist(file)) {
+ g_warning("procmsg_msginfo_get_full_info_from_file(): can't get message file.\n");
+ return NULL;
+ }
+
+ full_msginfo = procheader_parse_file(file, msginfo->flags, TRUE, FALSE);
+ if (!full_msginfo) return NULL;
+
+ msginfo->total_size = full_msginfo->total_size;
+ msginfo->planned_download = full_msginfo->planned_download;
+
+ if (full_msginfo->extradata) {
+ if (!msginfo->extradata)
+ msginfo->extradata = g_new0(MsgInfoExtraData, 1);
+ if (!msginfo->extradata->list_post)
+ msginfo->extradata->list_post = g_strdup(full_msginfo->extradata->list_post);
+ if (!msginfo->extradata->list_subscribe)
+ msginfo->extradata->list_subscribe = g_strdup(full_msginfo->extradata->list_subscribe);
+ if (!msginfo->extradata->list_unsubscribe)
+ msginfo->extradata->list_unsubscribe = g_strdup(full_msginfo->extradata->list_unsubscribe);
+ if (!msginfo->extradata->list_help)
+ msginfo->extradata->list_help = g_strdup(full_msginfo->extradata->list_help);
+ if (!msginfo->extradata->list_archive)
+ msginfo->extradata->list_archive= g_strdup(full_msginfo->extradata->list_archive);
+ if (!msginfo->extradata->list_owner)
+ msginfo->extradata->list_owner = g_strdup(full_msginfo->extradata->list_owner);
+ if (!msginfo->extradata->xface)
+ msginfo->extradata->xface = g_strdup(full_msginfo->extradata->xface);
+ if (!msginfo->extradata->face)
+ msginfo->extradata->face = g_strdup(full_msginfo->extradata->face);
+ if (!msginfo->extradata->dispositionnotificationto)
+ msginfo->extradata->dispositionnotificationto =
+ g_strdup(full_msginfo->extradata->dispositionnotificationto);
+ if (!msginfo->extradata->returnreceiptto)
+ msginfo->extradata->returnreceiptto = g_strdup
+ (full_msginfo->extradata->returnreceiptto);
+ if (!msginfo->extradata->partial_recv && full_msginfo->extradata->partial_recv)
+ msginfo->extradata->partial_recv = g_strdup
+ (full_msginfo->extradata->partial_recv);
+ if (!msginfo->extradata->account_server && full_msginfo->extradata->account_server)
+ msginfo->extradata->account_server = g_strdup
+ (full_msginfo->extradata->account_server);
+ if (!msginfo->extradata->account_login && full_msginfo->extradata->account_login)
+ msginfo->extradata->account_login = g_strdup
+ (full_msginfo->extradata->account_login);
+ }
+ procmsg_msginfo_free(full_msginfo);
+
+ return procmsg_msginfo_new_ref(msginfo);
+}
+
MsgInfo *procmsg_msginfo_get_full_info(MsgInfo *msginfo)
{
MsgInfo *full_msginfo;
return NULL;
}
- full_msginfo = procheader_parse_file(file, msginfo->flags, TRUE, FALSE);
+ full_msginfo = procmsg_msginfo_get_full_info_from_file(msginfo, file);
g_free(file);
- if (!full_msginfo) return NULL;
-
- /* 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);
+ return full_msginfo;
}
void procmsg_msginfo_free(MsgInfo *msginfo)
}
g_free(msginfo->fromspace);
- 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);
+ if (msginfo->extradata) {
+ g_free(msginfo->extradata->returnreceiptto);
+ g_free(msginfo->extradata->dispositionnotificationto);
+ g_free(msginfo->extradata->xface);
+ g_free(msginfo->extradata->face);
+ g_free(msginfo->extradata->list_post);
+ g_free(msginfo->extradata->list_subscribe);
+ g_free(msginfo->extradata->list_unsubscribe);
+ g_free(msginfo->extradata->list_help);
+ g_free(msginfo->extradata->list_archive);
+ g_free(msginfo->extradata->list_owner);
+ g_free(msginfo->extradata->partial_recv);
+ g_free(msginfo->extradata->account_server);
+ g_free(msginfo->extradata->account_login);
+ g_free(msginfo->extradata);
+ }
+ slist_free_strings_full(msginfo->references);
+ g_slist_free(msginfo->tags);
g_free(msginfo->plaintext_file);
guint procmsg_msginfo_memusage(MsgInfo *msginfo)
{
guint memusage = 0;
- GSList *refs;
+ GSList *tmp;
memusage += sizeof(MsgInfo);
if (msginfo->fromname)
memusage += strlen(msginfo->msgid);
if (msginfo->inreplyto)
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);
- for (refs = msginfo->references; refs; refs=refs->next) {
- gchar *r = (gchar *)refs->data;
- memusage += r?strlen(r):0;
+
+ for (tmp = msginfo->references; tmp; tmp=tmp->next) {
+ gchar *r = (gchar *)tmp->data;
+ memusage += r?strlen(r):0 + sizeof(GSList);
}
if (msginfo->fromspace)
memusage += strlen(msginfo->fromspace);
+ for (tmp = msginfo->tags; tmp; tmp=tmp->next) {
+ memusage += sizeof(GSList);
+ }
+ if (msginfo->extradata) {
+ memusage += sizeof(MsgInfoExtraData);
+ if (msginfo->extradata->xface)
+ memusage += strlen(msginfo->extradata->xface);
+ if (msginfo->extradata->face)
+ memusage += strlen(msginfo->extradata->face);
+ if (msginfo->extradata->dispositionnotificationto)
+ memusage += strlen(msginfo->extradata->dispositionnotificationto);
+ if (msginfo->extradata->returnreceiptto)
+ memusage += strlen(msginfo->extradata->returnreceiptto);
+
+ if (msginfo->extradata->partial_recv)
+ memusage += strlen(msginfo->extradata->partial_recv);
+ if (msginfo->extradata->account_server)
+ memusage += strlen(msginfo->extradata->account_server);
+ if (msginfo->extradata->account_login)
+ memusage += strlen(msginfo->extradata->account_login);
+
+ if (msginfo->extradata->list_post)
+ memusage += strlen(msginfo->extradata->list_post);
+ if (msginfo->extradata->list_subscribe)
+ memusage += strlen(msginfo->extradata->list_subscribe);
+ if (msginfo->extradata->list_unsubscribe)
+ memusage += strlen(msginfo->extradata->list_unsubscribe);
+ if (msginfo->extradata->list_help)
+ memusage += strlen(msginfo->extradata->list_help);
+ if (msginfo->extradata->list_archive)
+ memusage += strlen(msginfo->extradata->list_archive);
+ if (msginfo->extradata->list_owner)
+ memusage += strlen(msginfo->extradata->list_owner);
+ }
return memusage;
}
-gint procmsg_cmp_msgnum_for_sort(gconstpointer a, gconstpointer b)
-{
- const MsgInfo *msginfo1 = a;
- const MsgInfo *msginfo2 = b;
-
- if (!msginfo1)
- return -1;
- if (!msginfo2)
- return -1;
-
- return msginfo1->msgnum - msginfo2->msgnum;
-}
-
-static gint procmsg_send_message_queue_full(const gchar *file, gboolean keep_session)
+static gint procmsg_send_message_queue_full(const gchar *file, gboolean keep_session, gchar **errstr,
+ FolderItem *queue, gint msgnum, gboolean *queued_removed)
{
static HeaderEntry qentry[] = {{"S:", NULL, FALSE},
{"SSV:", NULL, FALSE},
{"SCF:", NULL, FALSE},
{"RMID:", NULL, FALSE},
{"FMID:", NULL, FALSE},
+ {"X-Claws-Privacy-System:", NULL, FALSE},
+ {"X-Claws-Encrypt:", NULL, FALSE},
+ {"X-Claws-Encrypt-Data:", NULL, FALSE},
+ {"X-Claws-End-Special-Headers:", 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;
gboolean save_clear_text = TRUE;
gchar *tmp_enc_file = NULL;
- int local = 0;
-
- g_return_val_if_fail(file != NULL, -1);
+ cm_return_val_if_fail(file != NULL, -1);
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;
}
fwdmessageid = g_strdup(p);
break;
case Q_PRIVACY_SYSTEM:
+ case Q_PRIVACY_SYSTEM_OLD:
if (privacy_system == NULL)
privacy_system = g_strdup(p);
break;
case Q_ENCRYPT:
+ case Q_ENCRYPT_OLD:
if (p[0] == '1')
encrypt = TRUE;
break;
case Q_ENCRYPT_DATA:
+ case Q_ENCRYPT_DATA_OLD:
if (encrypt_data == NULL)
encrypt_data = g_strdup(p);
break;
+ case Q_CLAWS_HDRS:
+ case Q_CLAWS_HDRS_OLD:
+ /* end of special headers reached */
+ goto send_mail; /* can't "break;break;" */
}
}
+send_mail:
filepos = ftell(fp);
if (encrypt) {
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);
+ slist_free_strings_full(to_list);
+ slist_free_strings_full(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;
}
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 (!mailac) {
mailac = account_find_from_smtp_server(from, smtpserver);
}
}
- if (mailac)
+ if (mailac) {
mailval = send_message_smtp_full(mailac, to_list, fp, keep_session);
- else {
+ 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)
+ } else if (!to_list && !newsgroup_list) {
+ if (errstr) {
+ if (*errstr) g_free(*errstr);
+ *errstr = g_strdup(_("Couldn't determine sending information. "
+ "Maybe the email hasn't been generated by Claws Mail."));
+ }
mailval = -1;
-
+ }
fseek(fp, filepos, SEEK_SET);
- if (newsgroup_list && (mailval == 0)) {
+ if (newsgroup_list && newsac && (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);
+ tmp = g_strdup_printf("%s%cnntp%p", get_tmp_dir(),
+ G_DIR_SEPARATOR, file);
if ((tmpfp = g_fopen(tmp, "wb")) == NULL) {
FILE_OP_ERROR(tmp, "fopen");
newsval = -1;
- alertpanel_error(_("Could not create temporary file for news sending."));
+ alertpanel_error(_("Couldn't create temporary file for news sending."));
} else {
if (change_file_mode_rw(tmpfp, tmp) < 0) {
FILE_OP_ERROR(tmp, "chmod");
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);
+ }
}
- g_unlink(tmp);
+ claws_unlink(tmp);
}
g_free(tmp);
}
fclose(fp);
+ /* update session statistics */
+ if (mailval == 0 && newsval == 0) {
+ /* update session stats */
+ if (replymessageid)
+ session_stats.replied++;
+ else if (fwdmessageid)
+ session_stats.forwarded++;
+ else
+ session_stats.sent++;
+ }
+
/* save message to outbox */
if (mailval == 0 && newsval == 0 && savecopyfolder) {
FolderItem *outbox;
outbox = folder_get_default_outbox();
if (save_clear_text || tmp_enc_file == NULL) {
- procmsg_save_to_outbox(outbox, file, TRUE);
+ gboolean saved = FALSE;
+ *queued_removed = FALSE;
+ if (queue && msgnum > 0) {
+ MsgInfo *queued_mail = folder_item_get_msginfo(queue, msgnum);
+ if (folder_item_move_msg(outbox, queued_mail) >= 0) {
+ debug_print("moved queued mail %d to sent folder\n", msgnum);
+ saved = TRUE;
+ *queued_removed = TRUE;
+ } else if (folder_item_copy_msg(outbox, queued_mail) >= 0) {
+ debug_print("copied queued mail %d to sent folder\n", msgnum);
+ saved = TRUE;
+ }
+ procmsg_msginfo_free(queued_mail);
+ }
+ if (!saved) {
+ debug_print("resaving clear text queued mail to sent folder\n");
+ procmsg_save_to_outbox(outbox, file, TRUE);
+ }
} else {
+ debug_print("saving encrpyted queued mail to sent folder\n");
procmsg_save_to_outbox(outbox, tmp_enc_file, FALSE);
}
}
if (tmp_enc_file != NULL) {
- g_unlink(tmp_enc_file);
+ claws_unlink(tmp_enc_file);
free(tmp_enc_file);
tmp_enc_file = NULL;
}
if (msginfo != NULL) {
if (replymessageid != NULL) {
- procmsg_msginfo_unset_flags(msginfo, MSG_FORWARDED, 0);
+ MsgPermFlags to_unset = 0;
+
+ if (prefs_common.mark_as_read_on_new_window)
+ to_unset = (MSG_NEW|MSG_UNREAD);
+
+ procmsg_msginfo_unset_flags(msginfo, to_unset, 0);
procmsg_msginfo_set_flags(msginfo, MSG_REPLIED, 0);
} else {
- procmsg_msginfo_unset_flags(msginfo, MSG_REPLIED, 0);
procmsg_msginfo_set_flags(msginfo, MSG_FORWARDED, 0);
}
procmsg_msginfo_free(msginfo);
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);
+ slist_free_strings_full(to_list);
+ slist_free_strings_full(newsgroup_list);
g_free(savecopyfolder);
g_free(replymessageid);
g_free(fwdmessageid);
return (newsval != 0 ? newsval : mailval);
}
-gint procmsg_send_message_queue(const gchar *file)
+gint procmsg_send_message_queue(const gchar *file, gchar **errstr, FolderItem *queue, gint msgnum, gboolean *queued_removed)
+{
+ gint result = procmsg_send_message_queue_full(file, FALSE, errstr, queue, msgnum, queued_removed);
+ main_window_set_menu_sensitive(mainwindow_get_mainwindow());
+ toolbar_main_set_sensitive(mainwindow_get_mainwindow());
+ return result;
+}
+
+gint procmsg_send_message_queue_with_lock(const gchar *file, gchar **errstr, FolderItem *queue, gint msgnum, gboolean *queued_removed)
{
- return procmsg_send_message_queue_full(file, FALSE);
+ gint val;
+ if (procmsg_queue_lock(errstr)) {
+ val = procmsg_send_message_queue(file, errstr, queue, msgnum, queued_removed);
+ procmsg_queue_unlock();
+ return val;
+ }
+ return -1;
}
static void update_folder_msg_counts(FolderItem *item, MsgInfo *msginfo, MsgPermFlags old_flags)
procmsg_update_unread_children(msginfo, FALSE);
item->marked_msgs--;
}
+
+ if (!(old_flags & MSG_REPLIED) && (new_flags & MSG_REPLIED)) {
+ item->replied_msgs++;
+ }
+
+ if ((old_flags & MSG_REPLIED) && !(new_flags & MSG_REPLIED)) {
+ item->replied_msgs--;
+ }
+
+ if (!(old_flags & MSG_FORWARDED) && (new_flags & MSG_FORWARDED)) {
+ item->forwarded_msgs++;
+ }
+
+ if ((old_flags & MSG_FORWARDED) && !(new_flags & MSG_FORWARDED)) {
+ item->forwarded_msgs--;
+ }
+
+ if (!(old_flags & MSG_LOCKED) && (new_flags & MSG_LOCKED)) {
+ item->locked_msgs++;
+ }
+
+ if ((old_flags & MSG_LOCKED) && !(new_flags & MSG_LOCKED)) {
+ item->locked_msgs--;
+ }
+
+ if ((old_flags & MSG_IGNORE_THREAD) && !(new_flags & MSG_IGNORE_THREAD)) {
+ item->ignored_msgs--;
+ }
+
+ if (!(old_flags & MSG_IGNORE_THREAD) && (new_flags & MSG_IGNORE_THREAD)) {
+ item->ignored_msgs++;
+ }
+
+ if ((old_flags & MSG_WATCH_THREAD) && !(new_flags & MSG_WATCH_THREAD)) {
+ item->watched_msgs--;
+ }
+
+ if (!(old_flags & MSG_WATCH_THREAD) && (new_flags & MSG_WATCH_THREAD)) {
+ item->watched_msgs++;
+ }
}
void procmsg_msginfo_set_flags(MsgInfo *msginfo, MsgPermFlags perm_flags, MsgTmpFlags tmp_flags)
MsgPermFlags perm_flags_new, perm_flags_old;
MsgTmpFlags tmp_flags_old;
- g_return_if_fail(msginfo != NULL);
+ cm_return_if_fail(msginfo != NULL);
item = msginfo->folder;
- g_return_if_fail(item != NULL);
+ cm_return_if_fail(item != NULL);
debug_print("Setting flags for message %d in folder %s\n", msginfo->msgnum, item->path);
if ((perm_flags & MSG_IGNORE_THREAD) || (perm_flags_old & MSG_IGNORE_THREAD)) {
perm_flags_new &= ~(MSG_NEW | MSG_UNREAD);
}
+ if ((perm_flags & MSG_WATCH_THREAD) || (perm_flags_old & MSG_WATCH_THREAD)) {
+ perm_flags_new &= ~(MSG_IGNORE_THREAD);
+ }
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);
-
+ summary_update_unread(mainwindow_get_mainwindow()->summaryview, NULL);
}
/* Tmp flags handling */
MsgPermFlags perm_flags_new, perm_flags_old;
MsgTmpFlags tmp_flags_old;
- g_return_if_fail(msginfo != NULL);
+ cm_return_if_fail(msginfo != NULL);
item = msginfo->folder;
- g_return_if_fail(item != NULL);
+ cm_return_if_fail(item != NULL);
debug_print("Unsetting flags for message %d in folder %s\n", msginfo->msgnum, item->path);
MsgPermFlags perm_flags_new, perm_flags_old;
MsgTmpFlags tmp_flags_old;
- g_return_if_fail(msginfo != NULL);
+ cm_return_if_fail(msginfo != NULL);
item = msginfo->folder;
- g_return_if_fail(item != NULL);
+ cm_return_if_fail(item != NULL);
debug_print("Changing flags for message %d in folder %s\n", msginfo->msgnum, item->path);
if ((add_perm_flags & MSG_IGNORE_THREAD) || (perm_flags_old & MSG_IGNORE_THREAD)) {
perm_flags_new &= ~(MSG_NEW | MSG_UNREAD);
}
+ if ((add_perm_flags & MSG_WATCH_THREAD) || (perm_flags_old & MSG_WATCH_THREAD)) {
+ perm_flags_new &= ~(MSG_IGNORE_THREAD);
+ }
if (perm_flags_old != perm_flags_new) {
folder_item_change_msg_flags(msginfo->folder, msginfo, perm_flags_new);
*
*\return gboolean TRUE if perm_flags are found
*/
-gboolean procmsg_msg_has_flagged_parent_real(MsgInfo *info,
+static gboolean procmsg_msg_has_flagged_parent_real(MsgInfo *info,
MsgPermFlags perm_flags, GHashTable *parentmsgs)
{
MsgInfo *tmp;
- g_return_val_if_fail(info != NULL, FALSE);
+ cm_return_val_if_fail(info != NULL, FALSE);
if (info != NULL && info->folder != NULL && info->inreplyto != NULL) {
tmp = folder_item_get_msginfo_by_msgid(info->folder,
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");
/*!
*\brief Callback for cleaning up hash of parentmsgs
*/
-gboolean parentmsgs_hash_remove(gpointer key,
+static gboolean parentmsgs_hash_remove(gpointer key,
gpointer value,
gpointer user_data)
{
gboolean procmsg_msg_has_flagged_parent(MsgInfo *info, MsgPermFlags perm_flags)
{
gboolean result;
- GHashTable *parentmsgs = g_hash_table_new(NULL, NULL);
+ static GHashTable *parentmsgs = NULL;
+
+ if (parentmsgs == NULL)
+ parentmsgs = g_hash_table_new(NULL, NULL);
result = procmsg_msg_has_flagged_parent_real(info, perm_flags, parentmsgs);
g_hash_table_foreach_remove(parentmsgs, parentmsgs_hash_remove, NULL);
- g_hash_table_destroy(parentmsgs);
+
return result;
}
}
-GSList *procmsg_find_children_func(MsgInfo *info,
+static GSList *procmsg_find_children_func(MsgInfo *info,
GSList *children, GSList *all)
{
GSList *cur;
- g_return_val_if_fail(info!=NULL, children);
+ cm_return_val_if_fail(info!=NULL, children);
if (info->msgid == NULL)
return children;
return children;
}
-GSList *procmsg_find_children (MsgInfo *info)
+static GSList *procmsg_find_children (MsgInfo *info)
{
GSList *children;
GSList *all, *cur;
- g_return_val_if_fail(info!=NULL, NULL);
+ cm_return_val_if_fail(info!=NULL, NULL);
all = folder_item_get_msg_list(info->folder);
children = procmsg_find_children_func(info, NULL, all);
if (children != NULL) {
return children;
}
-void procmsg_update_unread_children(MsgInfo *info, gboolean newly_marked)
+static void procmsg_update_unread_children(MsgInfo *info, gboolean newly_marked)
{
GSList *children = procmsg_find_children(info);
GSList *cur;
* \return TRUE if the message was moved and MsgInfo is now invalid,
* FALSE otherwise
*/
-gboolean procmsg_msginfo_filter(MsgInfo *msginfo)
+static gboolean procmsg_msginfo_filter(MsgInfo *msginfo, PrefsAccount* ac_prefs)
{
MailFilteringData mail_filtering_data;
mail_filtering_data.msginfo = msginfo;
- if (hooks_invoke(MAIL_FILTERING_HOOKLIST, &mail_filtering_data)) {
+ mail_filtering_data.msglist = NULL;
+ mail_filtering_data.filtered = NULL;
+ mail_filtering_data.unfiltered = NULL;
+ mail_filtering_data.account = ac_prefs;
+
+ if (!ac_prefs || ac_prefs->filterhook_on_recv)
+ if (hooks_invoke(MAIL_FILTERING_HOOKLIST, &mail_filtering_data))
return TRUE;
- }
/* filter if enabled in prefs or move to inbox if not */
if((filtering_rules != NULL) &&
- filter_message_by_msginfo(filtering_rules, msginfo)) {
+ filter_message_by_msginfo(filtering_rules, msginfo, ac_prefs,
+ FILTERING_INCORPORATION, NULL)) {
return TRUE;
}
return FALSE;
}
+void procmsg_msglist_filter(GSList *list, PrefsAccount *ac,
+ GSList **filtered, GSList **unfiltered,
+ gboolean do_filter)
+{
+ GSList *cur, *to_do = NULL;
+ gint total = 0, curnum = 0;
+ MailFilteringData mail_filtering_data;
+
+ cm_return_if_fail(filtered != NULL);
+ cm_return_if_fail(unfiltered != NULL);
+
+ *filtered = NULL;
+ *unfiltered = NULL;
+
+ if (list == NULL)
+ return;
+
+ total = g_slist_length(list);
+
+ if (!do_filter) {
+ *filtered = NULL;
+ *unfiltered = g_slist_copy(list);
+ return;
+ }
+
+ statusbar_print_all(_("Filtering messages...\n"));
+
+ mail_filtering_data.msginfo = NULL;
+ mail_filtering_data.msglist = list;
+ mail_filtering_data.filtered = NULL;
+ mail_filtering_data.unfiltered = NULL;
+ mail_filtering_data.account = ac;
+
+ if (!ac || ac->filterhook_on_recv)
+ hooks_invoke(MAIL_LISTFILTERING_HOOKLIST, &mail_filtering_data);
+
+ if (mail_filtering_data.filtered == NULL &&
+ mail_filtering_data.unfiltered == NULL) {
+ /* nothing happened */
+ debug_print(MAIL_LISTFILTERING_HOOKLIST " did nothing. filtering whole list normally.\n");
+ to_do = list;
+ }
+ if (mail_filtering_data.filtered != NULL) {
+ /* keep track of what's been filtered by the hooks */
+ debug_print(MAIL_LISTFILTERING_HOOKLIST " filtered some stuff. total %d filtered %d unfilt %d.\n",
+ g_slist_length(list),
+ g_slist_length(mail_filtering_data.filtered),
+ g_slist_length(mail_filtering_data.unfiltered));
+
+ *filtered = g_slist_copy(mail_filtering_data.filtered);
+ }
+ if (mail_filtering_data.unfiltered != NULL) {
+ /* what the hooks didn't handle will go in filtered or
+ * unfiltered in the next loop */
+ debug_print(MAIL_LISTFILTERING_HOOKLIST " left unfiltered stuff. total %d filtered %d unfilt %d.\n",
+ g_slist_length(list),
+ g_slist_length(mail_filtering_data.filtered),
+ g_slist_length(mail_filtering_data.unfiltered));
+ to_do = mail_filtering_data.unfiltered;
+ }
+
+ for (cur = to_do; cur; cur = cur->next) {
+ MsgInfo *info = (MsgInfo *)cur->data;
+ if (procmsg_msginfo_filter(info, ac))
+ *filtered = g_slist_prepend(*filtered, info);
+ else
+ *unfiltered = g_slist_prepend(*unfiltered, info);
+ statusbar_progress_all(curnum++, total, prefs_common.statusbar_update_step);
+ }
+
+ g_slist_free(mail_filtering_data.filtered);
+ g_slist_free(mail_filtering_data.unfiltered);
+
+ *filtered = g_slist_reverse(*filtered);
+ *unfiltered = g_slist_reverse(*unfiltered);
+
+ statusbar_progress_all(0,0,0);
+ statusbar_pop_all();
+}
+
MsgInfo *procmsg_msginfo_new_from_mimeinfo(MsgInfo *src_msginfo, MimeInfo *mimeinfo)
{
MsgInfo *tmp_msginfo = NULL;
}
static gchar *spam_folder_item = NULL;
-void procmsg_spam_set_folder (const char *item_identifier)
+static FolderItem * (*procmsg_spam_get_folder_func)(MsgInfo *msginfo) = NULL;
+void procmsg_spam_set_folder (const char *item_identifier, FolderItem *(*spam_get_folder_func)(MsgInfo *info))
{
g_free(spam_folder_item);
if (item_identifier)
spam_folder_item = g_strdup(item_identifier);
else
spam_folder_item = NULL;
+ if (spam_get_folder_func != NULL)
+ procmsg_spam_get_folder_func = spam_get_folder_func;
+ else
+ procmsg_spam_get_folder_func = NULL;
+}
+
+FolderItem *procmsg_spam_get_folder (MsgInfo *msginfo)
+{
+ FolderItem *item = NULL;
+
+ if (procmsg_spam_get_folder_func)
+ item = procmsg_spam_get_folder_func(msginfo);
+ if (item == NULL && spam_folder_item)
+ item = folder_find_item_from_identifier(spam_folder_item);
+ if (item == NULL)
+ item = folder_get_default_trash();
+ return item;
+}
+
+static void item_has_queued_mails(FolderItem *item, gpointer data)
+{
+ gboolean *result = (gboolean *)data;
+ if (*result == TRUE)
+ return;
+ if (folder_has_parent_of_type(item, F_QUEUE)) {
+ if (item->total_msgs == 0)
+ return;
+ else {
+ GSList *msglist = folder_item_get_msg_list(item);
+ GSList *cur;
+ for (cur = msglist; cur; cur = cur->next) {
+ MsgInfo *msginfo = (MsgInfo *)cur->data;
+ if (!MSG_IS_DELETED(msginfo->flags) &&
+ !MSG_IS_LOCKED(msginfo->flags)) {
+ *result = TRUE;
+ break;
+ }
+ }
+ procmsg_msg_list_free(msglist);
+ }
+ }
+}
+
+gboolean procmsg_have_queued_mails_fast (void)
+{
+ gboolean result = FALSE;
+ folder_func_to_all_folders(item_has_queued_mails, &result);
+ return result;
+}
+
+static void item_has_trashed_mails(FolderItem *item, gpointer data)
+{
+ gboolean *result = (gboolean *)data;
+ if (*result == TRUE)
+ return;
+ if (folder_has_parent_of_type(item, F_TRASH) && item->total_msgs > 0)
+ *result = TRUE;
+}
+
+gboolean procmsg_have_trashed_mails_fast (void)
+{
+ gboolean result = FALSE;
+ folder_func_to_all_folders(item_has_trashed_mails, &result);
+ return result;
+}
+
+gchar *procmsg_msginfo_get_tags_str(MsgInfo *msginfo)
+{
+ GSList *cur = NULL;
+ gchar *tags = NULL;
+
+ if (!msginfo)
+ return NULL;
+
+ if (msginfo->tags == NULL)
+ return NULL;
+ for (cur = msginfo->tags; cur; cur = cur->next) {
+ const gchar *tag = tags_get_tag(GPOINTER_TO_INT(cur->data));
+ if (!tag)
+ continue;
+ if (!tags)
+ tags = g_strdup(tag);
+ else {
+ int olen = strlen(tags);
+ int nlen = olen + strlen(tag) + 2 /* strlen(", ") */;
+ tags = g_realloc(tags, nlen+1);
+ if (!tags)
+ return NULL;
+ strcpy(tags+olen, ", ");
+ strcpy(tags+olen+2, tag);
+ tags[nlen]='\0';
+ }
+ }
+ return tags;
+}
+
+void procmsg_msginfo_update_tags(MsgInfo *msginfo, gboolean set, gint id)
+{
+ GSList changed;
+
+ if (id == 0)
+ return;
+
+ if (!set) {
+ msginfo->tags = g_slist_remove(
+ msginfo->tags,
+ GINT_TO_POINTER(id));
+ changed.data = GINT_TO_POINTER(id);
+ changed.next = NULL;
+ folder_item_commit_tags(msginfo->folder, msginfo, NULL, &changed);
+ } else {
+ if (!g_slist_find(msginfo->tags, GINT_TO_POINTER(id))) {
+ msginfo->tags = g_slist_append(
+ msginfo->tags,
+ GINT_TO_POINTER(id));
+ }
+ changed.data = GINT_TO_POINTER(id);
+ changed.next = NULL;
+ folder_item_commit_tags(msginfo->folder, msginfo, &changed, NULL);
+ }
+
}
-FolderItem *procmsg_spam_get_folder (void)
+void procmsg_msginfo_clear_tags(MsgInfo *msginfo)
{
- FolderItem *item = spam_folder_item ? folder_find_item_from_identifier(spam_folder_item) : NULL;
- return item ? item : folder_get_default_trash();
+ GSList *unset = msginfo->tags;
+ msginfo->tags = NULL;
+ folder_item_commit_tags(msginfo->folder, msginfo, NULL, unset);
+ g_slist_free(unset);
}
projects / claws.git / blobdiff