/*
* Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
- * Copyright (C) 1999-2005 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 "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);
+static gint procmsg_send_message_queue_full(const gchar *file, gboolean keep_session, gchar **errstr);
enum
{
Q_PRIVACY_SYSTEM = 9,
Q_ENCRYPT = 10,
Q_ENCRYPT_DATA = 11,
+ Q_SYLPHEED_HDRS = 12,
};
GHashTable *procmsg_msg_hash_table_create(GSList *mlist)
MsgInfo *msginfo;
const gchar *msgid;
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_relation = g_relation_new(2);
}
if (prefs_common.thread_by_subject) {
+ START_TIMING("procmsg_get_thread_tree(1)");
for (node = root->children; node && node != NULL;) {
next = node->next;
msginfo = (MsgInfo *) node->data;
node = next;
}
+ END_TIMING();
}
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(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(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(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) {
+ 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();
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;
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;
+ /* 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;
{"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 \"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(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;
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)
GList *cur;
for (cur = folder_get_list(); cur != NULL; cur = cur->next) {
- trash = FOLDER(cur->data)->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));
}
}
g_return_val_if_fail(file != NULL, NULL);
- if ((fp = fopen(file, "rb")) == NULL) {
+ if ((fp = g_fopen(file, "rb")) == NULL) {
FILE_OP_ERROR(file, "fopen");
return NULL;
}
nothing_to_sort = TRUE;
cur = orig;
while (cur) {
- gchar *file;
- PrefsAccount *ac = procmsg_get_account_from_file(file);
+ 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)) {
g_free(file);
for (cur = elem; cur; cur = cur->next) {
MsgInfo *cur_msginfo = (MsgInfo *)cur->data;
- PrefsAccount *cur_ac = NULL;
file = folder_item_fetch_msg(queue, cur_msginfo->msgnum);
if (cur_msginfo != msginfo && !MSG_IS_LOCKED(cur_msginfo->flags)) {
*\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 (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);
file = folder_item_fetch_msg(queue, msginfo->msgnum);
if (file) {
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) < 0) {
g_warning("Sending queued message %d failed.\n",
msginfo->msgnum);
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);
- */
sent++;
folder_item_remove_msg(queue, msginfo->msgnum);
}
}
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)
{
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_warning("can't save message\n");
return -1;
}
- return -1;
+ return 0;
}
msginfo = folder_item_get_msginfo(outbox, num); /* refcnt++ */
tmp_msginfo = procmsg_msginfo_get_full_info(msginfo); /* refcnt++ */
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);
}
MEMBCOPY(folder);
MEMBCOPY(to_folder);
+ MEMBDUP(face);
MEMBDUP(xface);
MEMBDUP(dispositionnotificationto);
MEMBDUP(returnreceiptto);
newmsginfo->references = g_slist_reverse(newmsginfo->references);
MEMBCOPY(score);
- MEMBCOPY(threadscore);
MEMBDUP(plaintext_file);
return newmsginfo;
/* 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);
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);
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);
-#warning FIXME: Calculate size of references list
-#if 0
- if (msginfo->references)
- memusage += strlen(msginfo->references);
-#endif
+ 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;
}
-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)
{
static HeaderEntry qentry[] = {{"S:", NULL, FALSE},
{"SSV:", 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;
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;
}
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;
- save_clear_text = (mailac != NULL && mailac->save_encrypted_as_clear_text);
+ 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;
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)) {
}
}
- 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) {
+ 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);
/* 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);
}
}
if (tmp_enc_file != NULL) {
- unlink(tmp_enc_file);
+ g_unlink(tmp_enc_file);
free(tmp_enc_file);
tmp_enc_file = 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 */
return (newsval != 0 ? newsval : mailval);
}
-gint procmsg_send_message_queue(const gchar *file)
+gint procmsg_send_message_queue(const gchar *file, gchar **errstr)
{
- return procmsg_send_message_queue_full(file, FALSE);
+ return procmsg_send_message_queue_full(file, FALSE, errstr);
}
static void update_folder_msg_counts(FolderItem *item, MsgInfo *msginfo, MsgPermFlags old_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--;
}
}
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 */
+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 &= ~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)) {
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((filtering_rules != NULL) &&
- filter_message_by_msginfo(filtering_rules, msginfo))
+ filter_message_by_msginfo(filtering_rules, msginfo)) {
return TRUE;
-
+ }
+
return FALSE;
}
{
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 (mimeinfo->content == MIMECONTENT_MEM) {
- gchar *tmpfile = get_tmp_file();
- str_write_to_file(mimeinfo->data.mem, tmpfile);
- g_free(mimeinfo->data.mem);
- mimeinfo->content == MIMECONTENT_FILE;
- mimeinfo->data.filename = g_strdup(tmpfile);
- g_free(tmpfile);
+
+ if (fp && procmime_write_mimeinfo(mimeinfo, fp) >= 0) {
+ fclose(fp);
+ fp = NULL;
+ tmp_msginfo = procheader_parse_file(
+ tmpfile, flags,
+ TRUE, FALSE);
}
-
- tmp_msginfo = procheader_parse_file(mimeinfo->data.filename,
- flags, TRUE, FALSE);
+ if (fp)
+ fclose(fp);
if (tmp_msginfo != NULL) {
- tmp_msginfo->folder = src_msginfo->folder;
- tmp_msginfo->plaintext_file = g_strdup(mimeinfo->data.filename);
+ 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();
+}