/*
* Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
- * Copyright (C) 1999-2004 Hiroyuki Yamamoto
+ * Copyright (C) 1999-2005 Hiroyuki Yamamoto
*
* 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 "news.h"
#include "hooks.h"
#include "msgcache.h"
+#include "partial_download.h"
+
+static gint procmsg_send_message_queue_full(const gchar *file, gboolean keep_session);
+
+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,
+};
GHashTable *procmsg_msg_hash_table_create(GSList *mlist)
{
GRelation *subject_relation;
MsgInfo *msginfo;
const gchar *msgid;
+ GSList *reflist;
root = g_node_new(NULL);
msgid_table = g_hash_table_new(g_str_hash, g_str_equal);
/* complete the unfinished threads */
for (node = root->children; node != NULL; ) {
- parent = NULL;
next = node->next;
msginfo = (MsgInfo *)node->data;
- if (msginfo->inreplyto) {
+ parent = NULL;
+
+ 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)) {
- g_node_unlink(node);
- g_node_insert_before
- (parent, parent->children, node);
- }
+
+ /* 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);
}
+
node = next;
}
return root;
}
-void procmsg_move_messages(GSList *mlist)
+gint procmsg_move_messages(GSList *mlist)
{
GSList *cur, *movelist = NULL;
MsgInfo *msginfo;
FolderItem *dest = NULL;
+ gint retval = 0;
- if (!mlist) return;
+ if (!mlist) return 0;
folder_item_update_freeze();
}
if (movelist) {
- folder_item_move_msgs(dest, movelist);
+ retval = folder_item_move_msgs(dest, movelist);
g_slist_free(movelist);
}
folder_item_update_thaw();
+ return retval;
}
void procmsg_copy_messages(GSList *mlist)
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;
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;
{"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("header \"List-Id\"", H_LIST_ID);
extract_list_id_str(*key);
} else if (hentry[H_X_SEQUENCE].body != NULL) {
- guchar *p;
+ gchar *p;
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 \"Sender\"", 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;
}
/*!
*/
gint procmsg_send_queue(FolderItem *queue, gboolean save_msgs)
{
- gint ret = 1, count = 0;
+ gint sent = 0, err = 0;
GSList *list, *elem;
+ GSList *sorted_list = NULL;
+ GNode *node, *next;
if (!queue)
queue = folder_get_default_queue();
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)) < 0) {
g_warning("Sending queued message %d failed.\n",
msginfo->msgnum);
- ret = -1;
+ err++;
} else {
/* CLAWS:
* We save in procmsg_send_message_queue because
(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);
+ if (res < 0)
+ err = -res;
+ else
+ sent += res;
+ node = next;
+ }
+ }
+
+ 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;
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, &flag, TRUE)) < 0) {
g_warning("can't save message\n");
- unlink(tmp);
+ g_unlink(tmp);
return -1;
}
} else {
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);
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(msginfo->fromspace);
- g_free(msginfo->references);
g_free(msginfo->returnreceiptto);
g_free(msginfo->dispositionnotificationto);
g_free(msginfo->xface);
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->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)
{
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},
{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");
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;
}
}
filepos = ftell(fp);
+ if (encrypt) {
+ MimeInfo *mimeinfo;
+
+ save_clear_text = (mailac != NULL && mailac->save_encrypted_as_clear_text);
+
+ 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);
+ 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) {
}
if (mailac)
- mailval = send_message_smtp(mailac, to_list, fp);
+ mailval = send_message_smtp_full(mailac, to_list, fp, keep_session);
else {
PrefsAccount tmp_ac;
}
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."));
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) {
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)
+{
+ return procmsg_send_message_queue_full(file, FALSE);
+}
+
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;
}
/* 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);
+ }
+}
+
+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);
+ }
}
/*!
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)) {
+ hooks_invoke(MAIL_POSTFILTERING_HOOKLIST, msginfo);
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)) {
+ hooks_invoke(MAIL_POSTFILTERING_HOOKLIST, msginfo);
return TRUE;
-
+ }
+
+ hooks_invoke(MAIL_POSTFILTERING_HOOKLIST, msginfo);
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) {
+ 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;
+}