/*
* 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
#include "imap.h"
#include "imap_gtk.h"
#include "inc.h"
+#include "xml.h"
#ifdef HAVE_LIBETPAN
gboolean folder_content_changed;
guint exists;
Folder * folder;
+ gboolean busy;
};
struct _IMAPNameSpace
guint32 c_uid_next;
guint32 c_uid_validity;
gint c_unseen;
+
+ GHashTable *flags_set_table;
+ GHashTable *flags_unset_table;
};
+static XMLTag *imap_item_get_xml(Folder *folder, FolderItem *item);
+static void imap_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag);
+
static void imap_folder_init (Folder *folder,
const gchar *name,
const gchar *path);
static void imap_lep_set_free(GSList *seq_list);
static struct mailimap_flag_list * imap_flag_to_lep(IMAPFlags flags);
-
-static GHashTable *flags_set_table = NULL;
-static GHashTable *flags_unset_table = NULL;
typedef struct _hashtable_data {
IMAPSession *session;
GSList *msglist;
+ IMAPFolderItem *item;
} hashtable_data;
static FolderClass imap_class;
imap_class.close = imap_close;
imap_class.get_num_list = imap_get_num_list;
imap_class.scan_required = imap_scan_required;
+ imap_class.set_xml = folder_set_xml;
+ imap_class.get_xml = folder_get_xml;
+ imap_class.item_set_xml = imap_item_set_xml;
+ imap_class.item_get_xml = imap_item_get_xml;
/* Message functions */
imap_class.get_msginfo = imap_get_msginfo;
static void imap_folder_destroy(Folder *folder)
{
- gchar *dir;
-
while (imap_folder_get_refcnt(folder) > 0)
gtk_main_iteration();
- dir = imap_folder_get_path(folder);
- if (is_dir_exist(dir))
- remove_dir_recursive(dir);
- g_free(dir);
-
folder_remote_folder_destroy(REMOTE_FOLDER(folder));
imap_done(folder);
}
IMAPFolderItem *item = (IMAPFolderItem *)node->data;
item->lastuid = 0;
- item->uid_next = 0;
g_slist_free(item->uid_list);
item->uid_list = NULL;
imap_get_capabilities(session);
switch(type) {
+ case IMAP_AUTH_ANON:
+ ok = imap_cmd_login(session, user, pass, "ANONYMOUS");
+ break;
case IMAP_AUTH_CRAM_MD5:
ok = imap_cmd_login(session, user, pass, "CRAM-MD5");
break;
break;
default:
debug_print("capabilities:\n"
+ "\t ANONYMOUS %d\n"
"\t CRAM-MD5 %d\n"
"\t LOGIN %d\n",
+ imap_has_capability(session, "ANONYMOUS"),
imap_has_capability(session, "CRAM-MD5"),
imap_has_capability(session, "LOGIN"));
if (imap_has_capability(session, "CRAM-MD5"))
return session;
}
+#define lock_session() {\
+ debug_print("locking session\n"); \
+ session->busy = TRUE;\
+}
+
+#define unlock_session() {\
+ debug_print("unlocking session\n"); \
+ session->busy = FALSE;\
+}
+
static IMAPSession *imap_session_get(Folder *folder)
{
RemoteFolder *rfolder = REMOTE_FOLDER(folder);
IMAPSession *session = NULL;
+ static time_t last_failure = 0;
g_return_val_if_fail(folder != NULL, NULL);
g_return_val_if_fail(FOLDER_CLASS(folder) == &imap_class, NULL);
g_return_val_if_fail(folder->account != NULL, NULL);
- if (prefs_common.work_offline && !inc_offline_should_override()) {
+ if (prefs_common.work_offline &&
+ !inc_offline_should_override(
+ _("Sylpheed-Claws needs network access in order "
+ "to access the IMAP server."))) {
return NULL;
}
/* Make sure we have a session */
if (rfolder->session != NULL) {
session = IMAP_SESSION(rfolder->session);
+ /* don't do that yet...
+ if (session->busy) {
+ return NULL;
+ } */
} else {
imap_reset_uid_lists(folder);
+ if (time(NULL) - last_failure <= 2)
+ return NULL;
session = imap_session_new(folder, folder->account);
}
- if(session == NULL)
+ if(session == NULL) {
+ last_failure = time(NULL);
return NULL;
+ }
/* Make sure session is authenticated */
if (!IMAP_SESSION(session)->authenticated)
if (!IMAP_SESSION(session)->authenticated) {
session_destroy(SESSION(session));
rfolder->session = NULL;
+ last_failure = time(NULL);
return NULL;
}
"Do you want to continue connecting to this "
"server? The communication would not be "
"secure."),
- _("Con_tinue connecting"),
- GTK_STOCK_CANCEL, NULL,
- FALSE, NULL, ALERT_WARNING,
- G_ALERTALTERNATE) != G_ALERTDEFAULT)
+ GTK_STOCK_CANCEL, _("Con_tinue connecting"),
+ NULL, FALSE, NULL, ALERT_WARNING,
+ G_ALERTDEFAULT) != G_ALERTALTERNATE)
return NULL;
}
port = account->set_imapport ? account->imapport
g_return_if_fail(account->userid != NULL);
pass = account->passwd;
- if (!pass) {
+ if (!pass && account->imap_auth_type != IMAP_AUTH_ANON) {
gchar *tmp_pass;
tmp_pass = input_dialog_query_password(account->recv_server, account->userid);
if (!tmp_pass)
- tmp_pass = g_strdup(""); /* allow empty password */
+ return;
Xstrdup_a(pass, tmp_pass, {g_free(tmp_pass); return;});
g_free(tmp_pass);
+ } else if (account->imap_auth_type == IMAP_AUTH_ANON) {
+ pass = "";
}
statusbar_print_all(_("Connecting to IMAP4 server %s...\n"),
account->recv_server);
make_dir_hier(path);
filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(uid), NULL);
g_free(path);
-
+ debug_print("trying to fetch cached %s\n", filename);
if (is_file_exist(filename)) {
/* see whether the local file represents the whole message
* or not. As the IMAP server reports size with \r chars,
if (cached)
debug_print("message %d has been already %scached (%d/%d).\n", uid,
- have_size == cached->size ? "fully ":"",
+ have_size >= cached->size ? "fully ":"",
have_size, (int)cached->size);
- if (cached && (cached->size == have_size || !body)) {
+ if (cached && (cached->size <= have_size || !body)) {
procmsg_msginfo_free(cached);
procmsg_msginfo_free(msginfo);
file_strip_crs(filename);
return filename;
+ } else if (!cached) {
+ debug_print("message not cached, considering file complete\n");
+ procmsg_msginfo_free(msginfo);
+ file_strip_crs(filename);
+ return filename;
} else {
procmsg_msginfo_free(cached);
procmsg_msginfo_free(msginfo);
}
session = imap_session_get(folder);
+
if (!session) {
g_free(filename);
return NULL;
}
+ lock_session();
+
debug_print("IMAP fetching messages\n");
ok = imap_select(session, IMAP_FOLDER(folder), item->path,
NULL, NULL, NULL, NULL, FALSE);
if (ok != IMAP_SUCCESS) {
g_warning("can't select mailbox %s\n", item->path);
g_free(filename);
+ unlock_session();
return NULL;
}
if (ok != IMAP_SUCCESS) {
g_warning("can't fetch message %d\n", uid);
g_free(filename);
+ unlock_session();
return NULL;
}
+ unlock_session();
file_strip_crs(filename);
return filename;
}
if (!session) {
return -1;
}
+ lock_session();
destdir = imap_get_real_path(IMAP_FOLDER(folder), dest->path);
statusbar_print_all(_("Adding messages..."));
IMAPFlags iflags = 0;
guint32 new_uid = 0;
gchar *real_file = NULL;
- gboolean file_is_tmp = FALSE;
fileinfo = (MsgFileInfo *)cur->data;
statusbar_progress_all(curnum, total, 1);
iflags |= IMAP_FLAG_SEEN;
}
- if (fileinfo->flags) {
- if ((MSG_IS_QUEUED(*fileinfo->flags)
- || MSG_IS_DRAFT(*fileinfo->flags))
- && !folder_has_parent_of_type(dest, F_QUEUE)
- && !folder_has_parent_of_type(dest, F_DRAFT)) {
- real_file = get_tmp_file();
- file_is_tmp = TRUE;
- if (procmsg_remove_special_headers(
- fileinfo->file,
- real_file) !=0) {
- g_free(real_file);
- g_free(destdir);
- return -1;
- }
- }
- }
if (real_file == NULL)
real_file = g_strdup(fileinfo->file);
if (ok != IMAP_SUCCESS) {
g_warning("can't append message %s\n", real_file);
- if (file_is_tmp)
- g_unlink(real_file);
g_free(real_file);
g_free(destdir);
+ unlock_session();
+ statusbar_progress_all(0,0,0);
+ statusbar_pop_all();
return -1;
+ } else {
+ debug_print("appended new message as %d\n", new_uid);
+ /* put the local file in the imapcache, so that we don't
+ * have to fetch it back later. */
+ if (new_uid > 0) {
+ gchar *cache_path = folder_item_get_path(dest);
+ if (!is_dir_exist(cache_path))
+ make_dir_hier(cache_path);
+ if (is_dir_exist(cache_path)) {
+ gchar *cache_file = g_strconcat(
+ cache_path, G_DIR_SEPARATOR_S,
+ itos(new_uid), NULL);
+ copy_file(real_file, cache_file, TRUE);
+ debug_print("copied to cache: %s\n", cache_file);
+ g_free(cache_file);
+ }
+ g_free(cache_path);
+ }
}
if (relation != NULL)
g_relation_insert(relation, fileinfo->msginfo != NULL ?
(gpointer) fileinfo->msginfo : (gpointer) fileinfo,
GINT_TO_POINTER(dest->last_num + 1));
- if (last_uid < new_uid)
+ if (new_uid == 0) {
+ new_uid = dest->last_num+1;
+ }
+ if (last_uid < new_uid) {
last_uid = new_uid;
- if (file_is_tmp)
- g_unlink(real_file);
+ }
+
+ g_free(real_file);
}
statusbar_progress_all(0,0,0);
statusbar_pop_all();
-
+
+ imap_cmd_expunge(session);
+ unlock_session();
+
g_free(destdir);
return last_uid;
if (!session) {
return -1;
}
+ lock_session();
msginfo = (MsgInfo *)msglist->data;
src = msginfo->folder;
if (src == dest) {
g_warning("the src folder is identical to the dest.\n");
+ unlock_session();
return -1;
}
+ if (src->folder != dest->folder) {
+ GSList *infolist = NULL, *cur;
+ int res = -1;
+ for (cur = msglist; cur; cur = cur->next) {
+ msginfo = (MsgInfo *)cur->data;
+ MsgFileInfo *fileinfo = g_new0(MsgFileInfo, 1);
+ fileinfo->file = procmsg_get_message_file(msginfo);
+ fileinfo->flags = &(msginfo->flags);
+ infolist = g_slist_prepend(infolist, fileinfo);
+ }
+ infolist = g_slist_reverse(infolist);
+ res = folder_item_add_msgs(dest, infolist, FALSE);
+ for (cur = infolist; cur; cur = cur->next) {
+ MsgFileInfo *info = (MsgFileInfo *)cur->data;
+ g_free(info->file);
+ g_free(info);
+ }
+ g_slist_free(infolist);
+ return res;
+ }
+
ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
NULL, NULL, NULL, NULL, FALSE);
if (ok != IMAP_SUCCESS) {
+ unlock_session();
return ok;
}
if (ok != IMAP_SUCCESS) {
g_relation_destroy(uid_mapping);
imap_lep_set_free(seq_list);
+ unlock_session();
return -1;
}
}
g_slist_free(IMAP_FOLDER_ITEM(dest)->uid_list);
IMAP_FOLDER_ITEM(dest)->uid_list = NULL;
+ unlock_session();
if (ok == IMAP_SUCCESS)
return last_num;
else
MsgInfoList *msglist, GRelation *relation)
{
MsgInfo *msginfo;
- GSList *file_list;
gint ret;
g_return_val_if_fail(folder != NULL, -1);
msginfo = (MsgInfo *)msglist->data;
g_return_val_if_fail(msginfo->folder != NULL, -1);
- if (folder == msginfo->folder->folder &&
- !folder_has_parent_of_type(msginfo->folder, F_DRAFT) &&
- !folder_has_parent_of_type(msginfo->folder, F_QUEUE)) {
- ret = imap_do_copy_msgs(folder, dest, msglist, relation);
- return ret;
- }
-
- file_list = procmsg_get_message_file_list(msglist);
- g_return_val_if_fail(file_list != NULL, -1);
-
- ret = imap_add_msgs(folder, dest, file_list, relation);
-
- procmsg_message_file_list_free(file_list);
-
+ ret = imap_do_copy_msgs(folder, dest, msglist, relation);
return ret;
}
static gint imap_do_remove_msgs(Folder *folder, FolderItem *dest,
MsgInfoList *msglist, GRelation *relation)
{
- gchar *destdir;
+ gchar *destdir, *dir;
GSList *numlist = NULL, *cur;
MsgInfo *msginfo;
IMAPSession *session;
if (!session) {
return -1;
}
+ lock_session();
msginfo = (MsgInfo *)msglist->data;
ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
NULL, NULL, NULL, NULL, FALSE);
if (ok != IMAP_SUCCESS) {
+ unlock_session();
return ok;
}
for (cur = msglist; cur; cur = cur->next) {
msginfo = (MsgInfo *)cur->data;
if (!MSG_IS_DELETED(msginfo->flags))
- numlist = g_slist_append(numlist, GINT_TO_POINTER(msginfo->msgnum));
+ numlist = g_slist_prepend(numlist, GINT_TO_POINTER(msginfo->msgnum));
}
+ numlist = g_slist_reverse(numlist);
uid_mapping = g_relation_new(2);
g_relation_index(uid_mapping, 0, g_direct_hash, g_direct_equal);
numlist, IMAP_FLAG_DELETED, TRUE);
if (ok != IMAP_SUCCESS) {
log_warning(_("can't set deleted flags\n"));
+ unlock_session();
return ok;
}
ok = imap_cmd_expunge(session);
if (ok != IMAP_SUCCESS) {
log_warning(_("can't expunge\n"));
+ unlock_session();
return ok;
}
+ dir = folder_item_get_path(msginfo->folder);
+ if (is_dir_exist(dir)) {
+ for (cur = msglist; cur; cur = cur->next) {
+ msginfo = (MsgInfo *)cur->data;
+ remove_numbered_files(dir, msginfo->msgnum, msginfo->msgnum);
+ }
+ }
+ g_free(dir);
+
g_relation_destroy(uid_mapping);
g_slist_free(numlist);
g_free(destdir);
-
+ unlock_session();
if (ok == IMAP_SUCCESS)
return 0;
else
return -1;
}
+ lock_session();
if (folder->account->imap_dir && *folder->account->imap_dir) {
gchar *real_path;
int r;
clist * lep_list;
- Xstrdup_a(root_folder, folder->account->imap_dir, {return -1;});
+ Xstrdup_a(root_folder, folder->account->imap_dir, {unlock_session();return -1;});
extract_quote(root_folder, '"');
subst_char(root_folder,
imap_get_path_separator(IMAP_FOLDER(folder),
item->folder = folder;
folder->node = item->node = g_node_new(item);
}
+ unlock_session();
return -1;
}
mailimap_list_result_free(lep_list);
imap_scan_tree_recursive(session, FOLDER_ITEM(folder->node->data));
imap_create_missing_folders(folder);
+ unlock_session();
return 0;
}
return NULL;
}
+ lock_session();
if (!folder_item_parent(parent) && strcmp(name, "INBOX") == 0) {
dirpath = g_strdup(name);
}else if (parent->path)
else if (folder->account->imap_dir && *folder->account->imap_dir) {
gchar *imap_dir;
- Xstrdup_a(imap_dir, folder->account->imap_dir, {return NULL;});
+ Xstrdup_a(imap_dir, folder->account->imap_dir, {unlock_session();return NULL;});
strtailchomp(imap_dir, '/');
dirpath = g_strconcat(imap_dir, "/", name, NULL);
} else
strtailchomp(dirpath, '/');
Xstrdup_a(new_name, name, {
- g_free(dirpath);
+ g_free(dirpath);
+ unlock_session();
return NULL;});
separator = imap_get_path_separator(IMAP_FOLDER(folder), imap_path);
g_free(dirpath);
ptr_array_free_strings(argbuf);
g_ptr_array_free(argbuf, TRUE);
+ unlock_session();
return NULL;
}
log_warning(_("can't create mailbox\n"));
g_free(imap_path);
g_free(dirpath);
+ unlock_session();
return NULL;
}
r = imap_threaded_list(folder, "", imap_path, &lep_list);
if (!is_dir_exist(dirpath))
make_dir_hier(dirpath);
g_free(dirpath);
-
+ unlock_session();
return new_item;
}
g_return_val_if_fail(item->path != NULL, -1);
g_return_val_if_fail(name != NULL, -1);
+ session = imap_session_get(folder);
+ if (!session) {
+ return -1;
+ }
+ lock_session();
+
if (strchr(name, imap_get_path_separator(IMAP_FOLDER(folder), item->path)) != NULL) {
g_warning(_("New folder name must not contain the namespace "
"path separator"));
+ unlock_session();
return -1;
}
- session = imap_session_get(folder);
- if (!session) {
- return -1;
- }
real_oldpath = imap_get_real_path(IMAP_FOLDER(folder), item->path);
g_free(session->mbox);
&exists, &recent, &unseen, &uid_validity, FALSE);
if (ok != IMAP_SUCCESS) {
g_free(real_oldpath);
+ unlock_session();
return -1;
}
g_free(real_oldpath);
g_free(newpath);
g_free(real_newpath);
+ unlock_session();
return -1;
}
g_free(newpath);
g_free(real_oldpath);
g_free(real_newpath);
-
+ unlock_session();
return 0;
}
IMAPSession *session;
gchar *path;
gchar *cache_dir;
- gint exists, recent, unseen;
- guint32 uid_validity;
g_return_val_if_fail(folder != NULL, -1);
g_return_val_if_fail(item != NULL, -1);
if (!session) {
return -1;
}
+ lock_session();
path = imap_get_real_path(IMAP_FOLDER(folder), item->path);
- ok = imap_cmd_examine(session, "INBOX",
- &exists, &recent, &unseen, &uid_validity, FALSE);
- if (ok != IMAP_SUCCESS) {
- g_free(path);
- return -1;
- }
-
ok = imap_cmd_delete(session, path);
if (ok != IMAP_SUCCESS) {
gchar *tmp = g_strdup_printf("%s%c", path,
if (ok != IMAP_SUCCESS) {
log_warning(_("can't delete mailbox\n"));
g_free(path);
+ unlock_session();
return -1;
}
g_warning("can't remove directory '%s'\n", cache_dir);
g_free(cache_dir);
folder_item_remove(item);
-
+ unlock_session();
return 0;
}
if (r != MAILIMAP_NO_ERROR)
continue;
+ session_set_access_time(SESSION(session));
+
count = 0;
for(i = 0 ; i < carray_count(env_list) ; i ++) {
struct imap_fetch_env_info * info;
info = carray_get(env_list, i);
msginfo = imap_envelope_from_lep(info, item);
+ if (msginfo == NULL)
+ continue;
msginfo->folder = item;
if (!newlist)
llast = newlist = g_slist_append(newlist, msginfo);
imap_fetch_env_free(env_list);
}
+ for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
+ struct mailimap_set * imapset;
+
+ imapset = cur->data;
+ mailimap_set_free(imapset);
+ }
+
session_set_access_time(SESSION(session));
stuff->done = TRUE;
return newlist;
data->numlist = newlist;
data->cur += count;
- if (prefs_common.work_offline && !inc_offline_should_override()) {
+ if (prefs_common.work_offline &&
+ !inc_offline_should_override(
+ _("Sylpheed-Claws needs network access in order "
+ "to access the IMAP server."))) {
g_free(data);
return NULL;
}
return NULL;
}
+gchar imap_get_path_separator_for_item(FolderItem *item)
+{
+ Folder *folder = NULL;
+ IMAPFolder *imap_folder = NULL;
+ if (!item)
+ return '/';
+ folder = item->folder;
+
+ if (!folder)
+ return '/';
+
+ imap_folder = IMAP_FOLDER(folder);
+
+ if (!imap_folder)
+ return '/';
+
+ return imap_get_path_separator(imap_folder, item->path);
+}
static gchar imap_get_path_separator(IMAPFolder *folder, const gchar *path)
{
IMAPNameSpace *namespace;
gchar separator = '/';
+ IMAPSession *session = imap_session_get(FOLDER(folder));
+ g_return_val_if_fail(session != NULL, '/');
if (folder->last_seen_separator == 0) {
clist * lep_list;
real_path = imap_get_real_path(folder, path);
-#if 0
- if (time(NULL) - item->last_update >= 5 && item->last_update != 1) {
- /* do the full stuff */
- item->last_update = 1; /* force update */
- debug_print("updating everything\n");
- r = imap_status(session, folder, path, item,
- &item->c_messages, &item->c_uid_next,
- &item->c_uid_validity, &item->c_unseen, block);
- if (r != MAILIMAP_NO_ERROR) {
- debug_print("status err %d\n", r);
- return IMAP_ERROR;
- }
- item->last_update = time(NULL);
- if (messages)
- *messages = item->c_messages;
- if (uid_next)
- *uid_next = item->c_uid_next;
- if (uid_validity)
- *uid_validity = item->c_uid_validity;
- if (unseen)
- *unseen = item->c_unseen;
- return 0;
- } else if (time(NULL) - item->last_update < 5) {
- /* return cached stuff */
- debug_print("using cache\n");
- if (messages)
- *messages = item->c_messages;
- if (uid_next)
- *uid_next = item->c_uid_next;
- if (uid_validity)
- *uid_validity = item->c_uid_validity;
- if (unseen)
- *unseen = item->c_unseen;
- return 0;
- }
-#endif
-
- /* if we get there, we're updating cache */
-
if (messages) {
mask |= 1 << 0;
}
/* low-level IMAP4rev1 commands */
-#if 0
-static gint imap_cmd_authenticate(IMAPSession *session, const gchar *user,
- const gchar *pass, IMAPAuthType type)
-{
- gchar *auth_type;
- gint ok;
- gchar *buf = NULL;
- gchar *challenge;
- gint challenge_len;
- gchar hexdigest[33];
- gchar *response;
- gchar *response64;
-
- auth_type = "CRAM-MD5";
-
- imap_gen_send(session, "AUTHENTICATE %s", auth_type);
- ok = imap_gen_recv(session, &buf);
- if (ok != IMAP_SUCCESS || buf[0] != '+' || buf[1] != ' ') {
- g_free(buf);
- return IMAP_ERROR;
- }
-
- challenge = g_malloc(strlen(buf + 2) + 1);
- challenge_len = base64_decode(challenge, buf + 2, -1);
- challenge[challenge_len] = '\0';
- g_free(buf);
-
- md5_hex_hmac(hexdigest, challenge, challenge_len, pass, strlen(pass));
- g_free(challenge);
-
- response = g_strdup_printf("%s %s", user, hexdigest);
- response64 = g_malloc((strlen(response) + 3) * 2 + 1);
- base64_encode(response64, response, strlen(response));
- g_free(response);
-
- sock_puts(SESSION(session)->sock, response64);
- ok = imap_cmd_ok(session, NULL);
- if (ok != IMAP_SUCCESS)
- log_warning(_("IMAP4 authentication failed.\n"));
-
- return ok;
-}
-#endif
-
static gint imap_cmd_login(IMAPSession *session,
const gchar *user, const gchar *pass,
const gchar *type)
type);
r = imap_threaded_login(session->folder, user, pass, type);
if (r != MAILIMAP_NO_ERROR) {
- log_error("IMAP4< Error logging in to %s\n",
+ log_print("IMAP4< Error logging in to %s\n",
SESSION(session)->server);
ok = IMAP_ERROR;
} else {
+ log_print("IMAP4< Login to %s successful\n",
+ SESSION(session)->server);
ok = IMAP_SUCCESS;
}
return ok;
{
int r;
- r = imap_threaded_starttls(session->folder);
+ r = imap_threaded_starttls(session->folder,
+ SESSION(session)->server, SESSION(session)->port);
if (r != MAILIMAP_NO_ERROR) {
debug_print("starttls err %d\n", r);
return IMAP_ERROR;
data->headers = headers;
data->body = body;
- if (prefs_common.work_offline && !inc_offline_should_override()) {
+ if (prefs_common.work_offline &&
+ !inc_offline_should_override(
+ _("Sylpheed-Claws needs network access in order "
+ "to access the IMAP server."))) {
g_free(data);
return -1;
}
flag_list = imap_flag_to_lep(flags);
r = imap_threaded_append(session->folder, destfolder,
- file, flag_list);
- if (new_uid != NULL)
- *new_uid = 0;
+ file, flag_list, new_uid);
+ mailimap_flag_list_free(flag_list);
if (r != MAILIMAP_NO_ERROR) {
debug_print("append err %d\n", r);
mailimap_store_att_flags_new_remove_flags_silent(flag_list);
r = imap_threaded_store(session->folder, set, store_att_flags);
+ mailimap_store_att_flags_free(store_att_flags);
if (r != MAILIMAP_NO_ERROR) {
return IMAP_ERROR;
{
int r;
- if (prefs_common.work_offline && !inc_offline_should_override()) {
+ if (prefs_common.work_offline &&
+ !inc_offline_should_override(
+ _("Sylpheed-Claws needs network access in order "
+ "to access the IMAP server."))) {
return -1;
}
typedef struct _get_list_uid_data {
Folder *folder;
+ IMAPSession *session;
IMAPFolderItem *item;
GSList **msgnum_list;
gboolean done;
clist * lep_uidlist;
int r;
- session = imap_session_get(folder);
+ session = stuff->session;
if (session == NULL) {
stuff->done = TRUE;
return GINT_TO_POINTER(-1);
}
-
+ /* no session locking here, it's already locked by caller */
ok = imap_select(session, IMAP_FOLDER(folder), item->item.path,
NULL, NULL, NULL, NULL, TRUE);
if (ok != IMAP_SUCCESS) {
r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_SIMPLE, set,
&lep_uidlist);
+ mailimap_set_free(set);
+
if (r == MAILIMAP_NO_ERROR) {
GSList * fetchuid_list;
fetchuid_list =
imap_uid_list_from_lep(lep_uidlist);
+ mailimap_search_result_free(lep_uidlist);
+
uidlist = g_slist_concat(fetchuid_list, uidlist);
}
else {
if (r == MAILIMAP_NO_ERROR) {
fetchuid_list =
imap_uid_list_from_lep_tab(lep_uidtab);
+ imap_fetch_uid_list_free(lep_uidtab);
uidlist = g_slist_concat(fetchuid_list, uidlist);
}
}
}
}
g_slist_free(uidlist);
-
stuff->done = TRUE;
return GINT_TO_POINTER(nummsgs);
}
-static gint get_list_of_uids(Folder *folder, IMAPFolderItem *item, GSList **msgnum_list)
+static gint get_list_of_uids(IMAPSession *session, Folder *folder, IMAPFolderItem *item, GSList **msgnum_list)
{
gint result;
get_list_uid_data *data = g_new0(get_list_uid_data, 1);
data->folder = folder;
data->item = item;
data->msgnum_list = msgnum_list;
-
- if (prefs_common.work_offline && !inc_offline_should_override()) {
+ data->session = session;
+ if (prefs_common.work_offline &&
+ !inc_offline_should_override(
+ _("Sylpheed-Claws needs network access in order "
+ "to access the IMAP server."))) {
g_free(data);
return -1;
}
{
IMAPFolderItem *item = (IMAPFolderItem *)_item;
IMAPSession *session;
- gint ok, nummsgs = 0, exists, uid_val, uid_next;
+ gint ok, nummsgs = 0, exists, uid_val, uid_next = 0;
GSList *uidlist = NULL;
gchar *dir;
gboolean selected_folder;
session = imap_session_get(folder);
g_return_val_if_fail(session != NULL, -1);
+ lock_session();
- statusbar_print_all("Scanning %s...\n", FOLDER_ITEM(item)->path
- ? FOLDER_ITEM(item)->path:"");
+ if (FOLDER_ITEM(item)->path)
+ statusbar_print_all(_("Scanning folder %s%c%s ..."),
+ FOLDER_ITEM(item)->folder->name,
+ G_DIR_SEPARATOR,
+ FOLDER_ITEM(item)->path);
+ else
+ statusbar_print_all(_("Scanning folder %s ..."),
+ FOLDER_ITEM(item)->folder->name);
selected_folder = (session->mbox != NULL) &&
(!strcmp(session->mbox, item->item.path));
- if (selected_folder) {
+ if (selected_folder && time(NULL) - item->use_cache < 2) {
ok = imap_cmd_noop(session);
if (ok != IMAP_SUCCESS) {
debug_print("disconnected!\n");
session = imap_reconnect_if_possible(folder, session);
if (session == NULL) {
statusbar_pop_all();
+ unlock_session();
return -1;
}
}
exists = session->exists;
+ uid_next = item->c_uid_next;
+ uid_val = item->c_uid_validity;
*old_uids_valid = TRUE;
} else {
if (item->use_cache && time(NULL) - item->use_cache < 2) {
ok = imap_status(session, IMAP_FOLDER(folder), item->item.path, item,
&exists, &uid_next, &uid_val, NULL, FALSE);
}
+ item->item.last_num = uid_next - 1;
+
item->use_cache = (time_t)0;
if (ok != IMAP_SUCCESS) {
statusbar_pop_all();
+ unlock_session();
return -1;
}
if(item->item.mtime == uid_val)
else {
*old_uids_valid = FALSE;
- debug_print("Freeing imap uid cache\n");
+ debug_print("Freeing imap uid cache (%d != %d)\n",
+ item->item.mtime, uid_val);
item->lastuid = 0;
g_slist_free(item->uid_list);
item->uid_list = NULL;
}
}
- if (!selected_folder)
- item->uid_next = uid_next;
-
/* If old uid_next matches new uid_next we can be sure no message
was added to the folder */
- if (( selected_folder && !session->folder_content_changed) ||
- (!selected_folder && uid_next == item->uid_next)) {
+ debug_print("uid_next is %d and item->uid_next %d \n",
+ uid_next, item->uid_next);
+ if (uid_next == item->uid_next) {
nummsgs = g_slist_length(item->uid_list);
/* If number of messages is still the same we
we discard our cache to start a new scan to find
out which numbers have been removed */
if (exists == nummsgs) {
+ debug_print("exists == nummsgs\n");
*msgnum_list = g_slist_copy(item->uid_list);
statusbar_pop_all();
+ unlock_session();
return nummsgs;
} else if (exists < nummsgs) {
debug_print("Freeing imap uid cache");
if (exists == 0) {
*msgnum_list = NULL;
statusbar_pop_all();
+ unlock_session();
return 0;
}
- nummsgs = get_list_of_uids(folder, item, &uidlist);
+ nummsgs = get_list_of_uids(session, folder, item, &uidlist);
if (nummsgs < 0) {
statusbar_pop_all();
+ unlock_session();
return -1;
}
g_slist_free(*msgnum_list);
- nummsgs = get_list_of_uids(folder, item, &uidlist);
+ nummsgs = get_list_of_uids(session, folder, item, &uidlist);
}
*msgnum_list = uidlist;
remove_numbered_files_not_in_list(dir, *msgnum_list);
g_free(dir);
+ item->uid_next = uid_next;
+
debug_print("get_num_list - ok - %i\n", nummsgs);
statusbar_pop_all();
+ unlock_session();
return nummsgs;
}
session = imap_session_get(folder);
g_return_val_if_fail(session != NULL, NULL);
-
+ lock_session();
debug_print("IMAP getting msginfos\n");
ok = imap_select(session, IMAP_FOLDER(folder), item->path,
NULL, NULL, NULL, NULL, FALSE);
- if (ok != IMAP_SUCCESS)
+ if (ok != IMAP_SUCCESS) {
+ unlock_session();
return NULL;
-
+ }
if (!(folder_has_parent_of_type(item, F_DRAFT) ||
folder_has_parent_of_type(item, F_QUEUE))) {
ret = g_slist_concat(ret,
imap_get_uncached_messages(session, item,
msgnum_list));
} else {
- MsgNumberList *sorted_list, *elem;
+ MsgNumberList *sorted_list, *elem, *llast = NULL;
gint startnum, lastnum;
sorted_list = g_slist_sort(g_slist_copy(msgnum_list), g_int_compare);
startnum = lastnum = GPOINTER_TO_INT(sorted_list->data);
+ llast = g_slist_last(ret);
for (elem = sorted_list;; elem = g_slist_next(elem)) {
guint num = 0;
MsgInfo *msginfo = imap_parse_msg(file, item);
if (msginfo != NULL) {
msginfo->msgnum = i;
- ret = g_slist_append(ret, msginfo);
+ if (llast == NULL)
+ llast = ret = g_slist_append(ret, msginfo);
+ else {
+ llast = g_slist_append(llast, msginfo);
+ llast = llast->next;
+ }
}
g_free(file);
}
+ session_set_access_time(SESSION(session));
}
if (elem == NULL)
g_slist_free(sorted_list);
}
-
+ unlock_session();
return ret;
}
session = imap_session_get(folder);
g_return_val_if_fail(session != NULL, FALSE);
-
+ lock_session();
selected_folder = (session->mbox != NULL) &&
(!strcmp(session->mbox, item->item.path));
- if (selected_folder) {
+ if (selected_folder && time(NULL) - item->use_cache < 2) {
ok = imap_cmd_noop(session);
if (ok != IMAP_SUCCESS) {
debug_print("disconnected!\n");
session = imap_reconnect_if_possible(folder, session);
if (session == NULL)
return FALSE;
+ lock_session();
}
if (session->folder_content_changed
- || session->exists != item->item.total_msgs)
+ || session->exists != item->item.total_msgs) {
+ unlock_session();
return TRUE;
+ }
} else {
ok = imap_status(session, IMAP_FOLDER(folder), item->item.path, IMAP_FOLDER_ITEM(item),
&exists, &uid_next, &uid_val, &unseen, FALSE);
- if (ok != IMAP_SUCCESS)
+ if (ok != IMAP_SUCCESS) {
+ unlock_session();
return FALSE;
+ }
item->use_cache = time(NULL);
item->c_messages = exists;
item->c_uid_next = uid_next;
item->c_uid_validity = uid_val;
item->c_unseen = unseen;
-
- if ((uid_next != item->uid_next) || (exists != item->item.total_msgs))
+ item->item.last_num = uid_next - 1;
+ debug_print("uidnext %d, item->uid_next %d, exists %d, item->item.total_msgs %d\n",
+ uid_next, item->uid_next, exists, item->item.total_msgs);
+ if ((uid_next != item->uid_next) || (exists != item->item.total_msgs)
+ || unseen != item->item.unread_msgs || uid_val != item->item.mtime) {
+ unlock_session();
return TRUE;
+ }
}
-
+ unlock_session();
return FALSE;
}
if (!session) {
return;
}
- if ((ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
- NULL, NULL, NULL, NULL, FALSE)) != IMAP_SUCCESS) {
- return;
- }
if (!MSG_IS_MARKED(msginfo->flags) && (newflags & MSG_MARKED))
flags_set |= IMAP_FLAG_FLAGGED;
if ( MSG_IS_DELETED(msginfo->flags) && !(newflags & MSG_DELETED))
flags_unset |= IMAP_FLAG_DELETED;
+ if (!flags_set && !flags_unset) {
+ /* the changed flags were not translatable to IMAP-speak.
+ * like MSG_POSTFILTERED, so just apply. */
+ msginfo->flags.perm_flags = newflags;
+ return;
+ }
+
+ lock_session();
+ if ((ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
+ NULL, NULL, NULL, NULL, FALSE)) != IMAP_SUCCESS) {
+ unlock_session();
+ return;
+ }
numlist.next = NULL;
numlist.data = GINT_TO_POINTER(msginfo->msgnum);
*/
debug_print("IMAP batch mode on, deferring flags change\n");
if (flags_set) {
- ht_data = g_hash_table_lookup(flags_set_table, GINT_TO_POINTER(flags_set));
+ ht_data = g_hash_table_lookup(IMAP_FOLDER_ITEM(item)->flags_set_table,
+ GINT_TO_POINTER(flags_set));
if (ht_data == NULL) {
ht_data = g_new0(hashtable_data, 1);
ht_data->session = session;
- g_hash_table_insert(flags_set_table, GINT_TO_POINTER(flags_set), ht_data);
+ ht_data->item = IMAP_FOLDER_ITEM(item);
+ g_hash_table_insert(IMAP_FOLDER_ITEM(item)->flags_set_table,
+ GINT_TO_POINTER(flags_set), ht_data);
}
if (!g_slist_find(ht_data->msglist, GINT_TO_POINTER(msginfo->msgnum)))
ht_data->msglist = g_slist_prepend(ht_data->msglist, GINT_TO_POINTER(msginfo->msgnum));
}
if (flags_unset) {
- ht_data = g_hash_table_lookup(flags_unset_table, GINT_TO_POINTER(flags_unset));
+ ht_data = g_hash_table_lookup(IMAP_FOLDER_ITEM(item)->flags_unset_table,
+ GINT_TO_POINTER(flags_unset));
if (ht_data == NULL) {
ht_data = g_new0(hashtable_data, 1);
ht_data->session = session;
- g_hash_table_insert(flags_unset_table, GINT_TO_POINTER(flags_unset), ht_data);
+ ht_data->item = IMAP_FOLDER_ITEM(item);
+ g_hash_table_insert(IMAP_FOLDER_ITEM(item)->flags_unset_table,
+ GINT_TO_POINTER(flags_unset), ht_data);
}
if (!g_slist_find(ht_data->msglist, GINT_TO_POINTER(msginfo->msgnum)))
- ht_data->msglist = g_slist_prepend(ht_data->msglist, GINT_TO_POINTER(msginfo->msgnum));
+ ht_data->msglist = g_slist_prepend(ht_data->msglist,
+ GINT_TO_POINTER(msginfo->msgnum));
}
} else {
debug_print("IMAP changing flags\n");
if (flags_set) {
ok = imap_set_message_flags(session, &numlist, flags_set, TRUE);
if (ok != IMAP_SUCCESS) {
+ unlock_session();
return;
}
}
if (flags_unset) {
ok = imap_set_message_flags(session, &numlist, flags_unset, FALSE);
if (ok != IMAP_SUCCESS) {
+ unlock_session();
return;
}
}
}
msginfo->flags.perm_flags = newflags;
-
+ unlock_session();
return;
}
session = imap_session_get(folder);
if (!session) return -1;
-
+ lock_session();
ok = imap_select(session, IMAP_FOLDER(folder), item->path,
NULL, NULL, NULL, NULL, FALSE);
- if (ok != IMAP_SUCCESS)
+ if (ok != IMAP_SUCCESS) {
+ unlock_session();
return ok;
-
+ }
numlist.next = NULL;
numlist.data = GINT_TO_POINTER(uid);
&numlist, IMAP_FLAG_DELETED, TRUE);
if (ok != IMAP_SUCCESS) {
log_warning(_("can't set deleted flags: %d\n"), uid);
+ unlock_session();
return ok;
}
}
if (ok != IMAP_SUCCESS) {
log_warning(_("can't expunge\n"));
+ unlock_session();
return ok;
}
if (is_dir_exist(dir))
remove_numbered_files(dir, uid, uid);
g_free(dir);
-
+ unlock_session();
return IMAP_SUCCESS;
}
stuff->done = TRUE;
return GINT_TO_POINTER(-1);
}
-
+ lock_session();
selected_folder = (session->mbox != NULL) &&
(!strcmp(session->mbox, item->path));
&exists_cnt, NULL, &unseen_cnt, NULL, TRUE);
if (ok != IMAP_SUCCESS) {
stuff->done = TRUE;
+ unlock_session();
return GINT_TO_POINTER(-1);
}
imapset = cur->data;
if (reverse_seen) {
r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_SEEN,
- imapset, &lep_uidlist);
+ full_search ? NULL:imapset, &lep_uidlist);
}
else {
r = imap_threaded_search(folder,
IMAP_SEARCH_TYPE_UNSEEN,
- imapset, &lep_uidlist);
+ full_search ? NULL:imapset, &lep_uidlist);
}
if (r == MAILIMAP_NO_ERROR) {
GSList * uidlist;
unseen = g_slist_concat(unseen, uidlist);
}
- r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_ANSWERED,
- imapset, &lep_uidlist);
- if (r == MAILIMAP_NO_ERROR) {
- GSList * uidlist;
-
- uidlist = imap_uid_list_from_lep(lep_uidlist);
- mailimap_search_result_free(lep_uidlist);
-
- answered = g_slist_concat(answered, uidlist);
- }
-
r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_FLAGGED,
- imapset, &lep_uidlist);
+ full_search ? NULL:imapset, &lep_uidlist);
if (r == MAILIMAP_NO_ERROR) {
GSList * uidlist;
-
+
uidlist = imap_uid_list_from_lep(lep_uidlist);
mailimap_search_result_free(lep_uidlist);
-
+
flagged = g_slist_concat(flagged, uidlist);
}
-
- r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_DELETED,
- imapset, &lep_uidlist);
- if (r == MAILIMAP_NO_ERROR) {
- GSList * uidlist;
-
- uidlist = imap_uid_list_from_lep(lep_uidlist);
- mailimap_search_result_free(lep_uidlist);
-
- deleted = g_slist_concat(deleted, uidlist);
+
+ if (item->opened || item->processing_pending || item == folder->inbox) {
+ r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_ANSWERED,
+ full_search ? NULL:imapset, &lep_uidlist);
+ if (r == MAILIMAP_NO_ERROR) {
+ GSList * uidlist;
+
+ uidlist = imap_uid_list_from_lep(lep_uidlist);
+ mailimap_search_result_free(lep_uidlist);
+
+ answered = g_slist_concat(answered, uidlist);
+ }
+
+ r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_DELETED,
+ full_search ? NULL:imapset, &lep_uidlist);
+ if (r == MAILIMAP_NO_ERROR) {
+ GSList * uidlist;
+
+ uidlist = imap_uid_list_from_lep(lep_uidlist);
+ mailimap_search_result_free(lep_uidlist);
+
+ deleted = g_slist_concat(deleted, uidlist);
+ }
}
}
msginfo = (MsgInfo *) elem->data;
flags = msginfo->flags.perm_flags;
wasnew = (flags & MSG_NEW);
- flags &= ~((reverse_seen ? 0 : MSG_UNREAD | MSG_NEW) | MSG_REPLIED | MSG_MARKED);
+ if (item->opened || item->processing_pending || item == folder->inbox) {
+ flags &= ~((reverse_seen ? 0 : MSG_UNREAD | MSG_NEW) | MSG_REPLIED | MSG_MARKED);
+ } else {
+ flags &= ~((reverse_seen ? 0 : MSG_UNREAD | MSG_NEW | MSG_MARKED));
+ }
if (reverse_seen)
flags |= MSG_UNREAD | (wasnew ? MSG_NEW : 0);
if (gslist_find_next_num(&p_unseen, msginfo->msgnum) == msginfo->msgnum) {
flags &= ~(MSG_UNREAD | MSG_NEW);
}
}
- if (gslist_find_next_num(&p_answered, msginfo->msgnum) == msginfo->msgnum)
- flags |= MSG_REPLIED;
- else
- flags &= ~MSG_REPLIED;
+
if (gslist_find_next_num(&p_flagged, msginfo->msgnum) == msginfo->msgnum)
flags |= MSG_MARKED;
else
flags &= ~MSG_MARKED;
- if (gslist_find_next_num(&p_deleted, msginfo->msgnum) == msginfo->msgnum)
- flags |= MSG_DELETED;
- else
- flags &= ~MSG_DELETED;
+
+ if (item->opened || item->processing_pending || item == folder->inbox) {
+ if (gslist_find_next_num(&p_answered, msginfo->msgnum) == msginfo->msgnum)
+ flags |= MSG_REPLIED;
+ else
+ flags &= ~MSG_REPLIED;
+ if (gslist_find_next_num(&p_deleted, msginfo->msgnum) == msginfo->msgnum)
+ flags |= MSG_DELETED;
+ else
+ flags &= ~MSG_DELETED;
+ }
g_relation_insert(msgflags, msginfo, GINT_TO_POINTER(flags));
}
g_string_free(cmd_buf, TRUE);
stuff->done = TRUE;
+ unlock_session();
return GINT_TO_POINTER(0);
}
GSList *tmp = NULL, *cur;
- if (prefs_common.work_offline && !inc_offline_should_override()) {
+ if (prefs_common.work_offline &&
+ !inc_offline_should_override(
+ _("Sylpheed-Claws needs network access in order "
+ "to access the IMAP server."))) {
g_free(data);
return -1;
}
tmp = folder_item_get_msg_list(item);
- if (g_slist_length(tmp) == g_slist_length(msginfo_list))
+ if (g_slist_length(tmp) <= g_slist_length(msginfo_list))
data->full_search = TRUE;
for (cur = tmp; cur; cur = cur->next)
gboolean flags_set = GPOINTER_TO_INT(user_data);
gint flags_value = GPOINTER_TO_INT(key);
hashtable_data *data = (hashtable_data *)value;
-
+ IMAPFolderItem *_item = data->item;
+ FolderItem *item = (FolderItem *)_item;
+ gint ok = IMAP_ERROR;
+ IMAPSession *session = imap_session_get(item->folder);
+
data->msglist = g_slist_reverse(data->msglist);
debug_print("IMAP %ssetting flags to %d for %d messages\n",
flags_set?"":"un",
flags_value,
g_slist_length(data->msglist));
- imap_set_message_flags(data->session, data->msglist, flags_value, flags_set);
+ if (session) {
+ lock_session();
+ ok = imap_select(session, IMAP_FOLDER(item->folder), item->path,
+ NULL, NULL, NULL, NULL, FALSE);
+ }
+ if (ok == IMAP_SUCCESS) {
+ imap_set_message_flags(data->session, data->msglist, flags_value, flags_set);
+ } else {
+ g_warning("can't select mailbox %s\n", item->path);
+ }
+ if (session)
+ unlock_session();
g_slist_free(data->msglist);
g_free(data);
return TRUE;
}
-static void process_hashtable(void)
+static void process_hashtable(IMAPFolderItem *item)
{
- if (flags_set_table) {
- g_hash_table_foreach_remove(flags_set_table, process_flags, GINT_TO_POINTER(TRUE));
- g_free(flags_set_table);
- flags_set_table = NULL;
+ if (item->flags_set_table) {
+ g_hash_table_foreach_remove(item->flags_set_table, process_flags, GINT_TO_POINTER(TRUE));
+ g_hash_table_destroy(item->flags_set_table);
+ item->flags_set_table = NULL;
}
- if (flags_unset_table) {
- g_hash_table_foreach_remove(flags_unset_table, process_flags, GINT_TO_POINTER(FALSE));
- g_free(flags_unset_table);
- flags_unset_table = NULL;
+ if (item->flags_unset_table) {
+ g_hash_table_foreach_remove(item->flags_unset_table, process_flags, GINT_TO_POINTER(FALSE));
+ g_hash_table_destroy(item->flags_unset_table);
+ item->flags_unset_table = NULL;
}
}
-static IMAPFolderItem *batching_item = NULL;
-
static void imap_set_batch (Folder *folder, FolderItem *_item, gboolean batch)
{
IMAPFolderItem *item = (IMAPFolderItem *)_item;
g_return_if_fail(item != NULL);
- if (batch && batching_item != NULL) {
- g_warning("already batching on %s\n", batching_item->item.path);
- return;
- }
-
if (item->batching == batch)
return;
- item->batching = batch;
-
- batching_item = batch?item:NULL;
-
if (batch) {
+ item->batching = TRUE;
debug_print("IMAP switching to batch mode\n");
- if (flags_set_table) {
- g_warning("flags_set_table non-null but we just entered batch mode!\n");
- flags_set_table = NULL;
+ if (!item->flags_set_table) {
+ item->flags_set_table = g_hash_table_new(NULL, g_direct_equal);
}
- if (flags_unset_table) {
- g_warning("flags_unset_table non-null but we just entered batch mode!\n");
- flags_unset_table = NULL;
+ if (!item->flags_unset_table) {
+ item->flags_unset_table = g_hash_table_new(NULL, g_direct_equal);
}
- flags_set_table = g_hash_table_new(NULL, g_direct_equal);
- flags_unset_table = g_hash_table_new(NULL, g_direct_equal);
} else {
debug_print("IMAP switching away from batch mode\n");
/* process stuff */
- process_hashtable();
+ process_hashtable(item);
+ item->batching = FALSE;
}
}
clist * list, const gchar * real_path, gboolean all)
{
clistiter * iter;
- GSList * item_list;
-
- item_list = NULL;
+ GSList * item_list = NULL, *llast = NULL;
for(iter = clist_begin(list) ; iter != NULL ;
iter = clist_next(iter)) {
((flags & ETPAN_IMAP_MB_NOSELECT) != 0))
new_item->no_select = TRUE;
- item_list = g_slist_append(item_list, new_item);
-
+ if (item_list == NULL)
+ llast = item_list = g_slist_append(item_list, new_item);
+ else {
+ llast = g_slist_append(llast, new_item);
+ llast = llast->next;
+ }
debug_print("folder '%s' found.\n", loc_path);
g_free(base);
g_free(loc_path);
{
GSList *sorted_list, *cur;
guint first, last, next;
- GSList *ret_list = NULL;
+ GSList *ret_list = NULL, *llast = NULL;
unsigned int count;
struct mailimap_set * current_set;
unsigned int item_count;
first = next;
if (count >= IMAP_SET_MAX_COUNT) {
- ret_list = g_slist_append(ret_list,
+ if (ret_list == NULL)
+ llast = ret_list = g_slist_append(ret_list,
current_set);
+ else {
+ llast = g_slist_append(llast, current_set);
+ llast = llast->next;
+ }
current_set = mailimap_set_new_empty();
count = 0;
item_count = 0;
for (cur = msglist; cur != NULL; cur = g_slist_next(cur)) {
MsgInfo *msginfo = (MsgInfo *) cur->data;
- numlist = g_slist_append(numlist, GINT_TO_POINTER(msginfo->msgnum));
+ numlist = g_slist_prepend(numlist, GINT_TO_POINTER(msginfo->msgnum));
}
+ numlist = g_slist_reverse(numlist);
seq_list = imap_get_lep_set_from_numlist(numlist);
g_slist_free(numlist);
uint32_t * puid;
puid = clist_content(iter);
- result = g_slist_append(result, GINT_TO_POINTER(* puid));
+ result = g_slist_prepend(result, GINT_TO_POINTER(* puid));
}
+ result = g_slist_reverse(result);
return result;
}
uint32_t * puid;
puid = carray_get(list, i);
- result = g_slist_append(result, GINT_TO_POINTER(* puid));
+ result = g_slist_prepend(result, GINT_TO_POINTER(* puid));
}
-
+ result = g_slist_reverse(result);
return result;
}
size_t size = 0;
MsgFlags flags = {0, 0};
+ if (info->headers == NULL)
+ return NULL;
+
MSG_SET_TMP_FLAGS(flags, MSG_IMAP);
if (folder_has_parent_of_type(item, F_QUEUE)) {
MSG_SET_TMP_FLAGS(flags, MSG_QUEUED);
static FolderClass imap_class;
+static XMLTag *imap_item_get_xml(Folder *folder, FolderItem *item);
+static void imap_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag);
+
static Folder *imap_folder_new (const gchar *name,
const gchar *path)
{
return -1;
}
+gchar imap_get_path_separator_for_item(FolderItem *item)
+{
+ return '/';
+}
+
FolderClass *imap_get_class(void)
{
if (imap_class.idstr == NULL) {
imap_class.create_tree = imap_create_tree;
imap_class.create_folder = imap_create_folder;
imap_class.rename_folder = imap_rename_folder;
+
+ imap_class.set_xml = folder_set_xml;
+ imap_class.get_xml = folder_get_xml;
+ imap_class.item_set_xml = imap_item_set_xml;
+ imap_class.item_get_xml = imap_item_get_xml;
/* nothing implemented */
}
{
imap_gtk_synchronise(item);
}
+
+static void imap_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag)
+{
+#ifdef HAVE_LIBETPAN
+ GList *cur;
+#endif
+ folder_item_set_xml(folder, item, tag);
+
+#ifdef HAVE_LIBETPAN
+ for (cur = tag->attr; cur != NULL; cur = g_list_next(cur)) {
+ XMLAttr *attr = (XMLAttr *) cur->data;
+
+ if (!attr || !attr->name || !attr->value) continue;
+ if (!strcmp(attr->name, "uidnext"))
+ IMAP_FOLDER_ITEM(item)->uid_next = atoi(attr->value);
+ }
+#endif
+}
+
+static XMLTag *imap_item_get_xml(Folder *folder, FolderItem *item)
+{
+ XMLTag *tag;
+
+ tag = folder_item_get_xml(folder, item);
+
+#ifdef HAVE_LIBETPAN
+ xml_tag_add_attr(tag, xml_attr_new_int("uidnext",
+ IMAP_FOLDER_ITEM(item)->uid_next));
+
+#endif
+ return tag;
+}