*
* 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.
*/
#ifdef HAVE_CONFIG_H
gboolean folder_content_changed;
guint exists;
Folder * folder;
+ gboolean busy;
};
struct _IMAPNameSpace
guint uid_next;
GSList *uid_list;
gboolean batching;
+
+ time_t use_cache;
+ gint c_messages;
+ guint32 c_uid_next;
+ guint32 c_uid_validity;
+ gint c_unseen;
+
+ GHashTable *flags_set_table;
+ GHashTable *flags_unset_table;
};
static void imap_folder_init (Folder *folder,
static gint imap_status (IMAPSession *session,
IMAPFolder *folder,
const gchar *path,
+ IMAPFolderItem *item,
gint *messages,
- gint *recent,
guint32 *uid_next,
guint32 *uid_validity,
gint *unseen,
/* data types conversion libetpan <-> sylpheed */
static GSList * imap_list_from_lep(IMAPFolder * folder,
- clist * list, const gchar * real_path);
+ clist * list, const gchar * real_path, gboolean all);
static GSList * imap_get_lep_set_from_numlist(MsgNumberList *numlist);
static GSList * imap_get_lep_set_from_msglist(MsgInfoList *msglist);
static GSList * imap_uid_list_from_lep(clist * list);
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;
}
if (time(NULL) - last_login_err > 10) {
- alertpanel_error(_("Connection to %s failed: login refused.%s"),
+ if (!prefs_common.no_recv_err_panel) {
+ alertpanel_error(_("Connection to %s failed: "
+ "login refused.%s"),
SESSION(session)->server, ext_info);
+ } else {
+ log_error(_("Connection to %s failed: "
+ "login refused.%s\n"),
+ SESSION(session)->server, ext_info);
+ }
}
last_login_err = time(NULL);
}
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);
/* 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);
session = imap_session_new(folder, folder->account);
return NULL;
}
-#if 0
- /* Make sure we have parsed the IMAP namespace */
- imap_parse_namespace(IMAP_SESSION(session),
- IMAP_FOLDER(folder));
-#endif
-
/* I think the point of this code is to avoid sending a
* keepalive if we've used the session recently and therefore
* think it's still alive. Unfortunately, most of the code
"Do you want to continue connecting to this "
"server? The communication would not be "
"secure."),
- _("Continue connecting"),
+ _("Con_tinue connecting"),
GTK_STOCK_CANCEL, NULL,
FALSE, NULL, ALERT_WARNING,
G_ALERTALTERNATE) != G_ALERTDEFAULT)
alertpanel_error(_("Can't connect to IMAP4 server: %s:%d"),
account->recv_server, port);
} else {
- log_error(_("Can't connect to IMAP4 server: %s:%d"),
+ log_error(_("Can't connect to IMAP4 server: %s:%d\n"),
account->recv_server, port);
}
}
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;
}
GSList *cur;
MsgFileInfo *fileinfo;
gint ok;
+ gint curnum = 0, total = 0;
g_return_val_if_fail(folder != NULL, -1);
if (!session) {
return -1;
}
+ lock_session();
destdir = imap_get_real_path(IMAP_FOLDER(folder), dest->path);
+ statusbar_print_all(_("Adding messages..."));
+ total = g_slist_length(file_list);
for (cur = file_list; cur != NULL; cur = cur->next) {
IMAPFlags iflags = 0;
guint32 new_uid = 0;
gboolean file_is_tmp = FALSE;
fileinfo = (MsgFileInfo *)cur->data;
+ statusbar_progress_all(curnum, total, 1);
+ curnum++;
+
if (fileinfo->flags) {
if (MSG_IS_MARKED(*fileinfo->flags))
iflags |= IMAP_FLAG_FLAGGED;
real_file) !=0) {
g_free(real_file);
g_free(destdir);
+ unlock_session();
return -1;
}
}
g_unlink(real_file);
g_free(real_file);
g_free(destdir);
+ unlock_session();
+ statusbar_progress_all(0,0,0);
+ statusbar_pop_all();
return -1;
}
if (file_is_tmp)
g_unlink(real_file);
}
-
+ statusbar_progress_all(0,0,0);
+ statusbar_pop_all();
+
+ unlock_session();
+
g_free(destdir);
return last_uid;
gint ok = IMAP_SUCCESS;
GRelation *uid_mapping;
gint last_num = 0;
-
+
g_return_val_if_fail(folder != NULL, -1);
g_return_val_if_fail(dest != NULL, -1);
g_return_val_if_fail(msglist != NULL, -1);
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;
}
ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
NULL, NULL, NULL, NULL, FALSE);
if (ok != IMAP_SUCCESS) {
+ unlock_session();
return ok;
}
uid_mapping = g_relation_new(2);
g_relation_index(uid_mapping, 0, g_direct_hash, g_direct_equal);
+ statusbar_print_all(_("Copying messages..."));
for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
struct mailimap_set * seq_set;
-
seq_set = cur->data;
-
+
debug_print("Copying messages from %s to %s ...\n",
src->path, destdir);
if (ok != IMAP_SUCCESS) {
g_relation_destroy(uid_mapping);
imap_lep_set_free(seq_list);
+ unlock_session();
return -1;
}
}
GPOINTER_TO_INT(0));
g_tuples_destroy(tuples);
}
+ statusbar_pop_all();
g_relation_destroy(uid_mapping);
imap_lep_set_free(seq_list);
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)
{
gchar *destdir;
- GSList *seq_list = NULL, *cur;
+ GSList *numlist = NULL, *cur;
MsgInfo *msginfo;
IMAPSession *session;
gint ok = IMAP_SUCCESS;
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;
}
destdir = imap_get_real_path(IMAP_FOLDER(folder), dest->path);
for (cur = msglist; cur; cur = cur->next) {
msginfo = (MsgInfo *)cur->data;
- seq_list = g_slist_append(seq_list, GINT_TO_POINTER(msginfo->msgnum));
+ if (!MSG_IS_DELETED(msginfo->flags))
+ numlist = g_slist_append(numlist, GINT_TO_POINTER(msginfo->msgnum));
}
uid_mapping = g_relation_new(2);
ok = imap_set_message_flags
(IMAP_SESSION(REMOTE_FOLDER(folder)->session),
- seq_list, IMAP_FLAG_DELETED, TRUE);
+ 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;
}
g_relation_destroy(uid_mapping);
- g_slist_free(seq_list);
+ 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);
g_free(real_path);
imap_scan_tree_recursive(session, FOLDER_ITEM(folder->node->data));
imap_create_missing_folders(folder);
+ unlock_session();
return 0;
}
}
else {
item_list = imap_list_from_lep(imapfolder,
- lep_list, real_path);
+ lep_list, real_path, FALSE);
mailimap_list_result_free(lep_list);
}
for (cur = item_list; cur != NULL; cur = cur->next) {
FolderItem *cur_item = FOLDER_ITEM(cur->data);
new_item = NULL;
+
for (node = item->node->children; node != NULL;
node = node->next) {
if (!strcmp2(FOLDER_ITEM(node->data)->path,
gchar *new_name;
const gchar *p;
gint ok;
-
+ gboolean no_select = FALSE, no_sub = FALSE;
+
g_return_val_if_fail(folder != NULL, NULL);
g_return_val_if_fail(folder->account != NULL, NULL);
g_return_val_if_fail(parent != NULL, NULL);
return NULL;
}
- if (!folder_item_parent(parent) && strcmp(name, "INBOX") == 0)
+ lock_session();
+ if (!folder_item_parent(parent) && strcmp(name, "INBOX") == 0) {
dirpath = g_strdup(name);
- else if (parent->path)
+ }else if (parent->path)
dirpath = g_strconcat(parent->path, "/", name, NULL);
else if ((p = strchr(name, '/')) != NULL && *(p + 1) != '\0')
dirpath = g_strdup(name);
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
dirpath = g_strdup(name);
+
+
/* keep trailing directory separator to create a folder that contains
sub folder */
imap_path = imap_utf8_to_modified_utf7(dirpath);
+
strtailchomp(dirpath, '/');
Xstrdup_a(new_name, name, {
- g_free(dirpath);
+ g_free(dirpath);
+ unlock_session();
return NULL;});
- strtailchomp(new_name, '/');
separator = imap_get_path_separator(IMAP_FOLDER(folder), imap_path);
imap_path_separator_subst(imap_path, separator);
- subst_char(new_name, '/', separator);
+ /* remove trailing / for display */
+ strtailchomp(new_name, '/');
- if (strcmp(name, "INBOX") != 0) {
+ if (strcmp(dirpath, "INBOX") != 0) {
GPtrArray *argbuf;
gboolean exist = FALSE;
int r;
g_free(dirpath);
ptr_array_free_strings(argbuf);
g_ptr_array_free(argbuf, TRUE);
+ unlock_session();
return NULL;
}
if (clist_count(lep_list) > 0)
exist = TRUE;
-
+ mailimap_list_result_free(lep_list);
+ lep_list = NULL;
if (!exist) {
ok = imap_cmd_create(session, imap_path);
if (ok != IMAP_SUCCESS) {
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 (r == MAILIMAP_NO_ERROR) {
+ GSList *item_list = imap_list_from_lep(IMAP_FOLDER(folder),
+ lep_list, dirpath, TRUE);
+ if (item_list) {
+ FolderItem *cur_item = FOLDER_ITEM(item_list->data);
+ no_select = cur_item->no_select;
+ no_sub = cur_item->no_sub;
+ g_slist_free(item_list);
+ }
+ mailimap_list_result_free(lep_list);
+ }
+
+ }
+ } else {
+ clist *lep_list;
+ int r;
+ /* just get flags */
+ r = imap_threaded_list(folder, "", "INBOX", &lep_list);
+ if (r == MAILIMAP_NO_ERROR) {
+ GSList *item_list = imap_list_from_lep(IMAP_FOLDER(folder),
+ lep_list, dirpath, TRUE);
+ if (item_list) {
+ FolderItem *cur_item = FOLDER_ITEM(item_list->data);
+ no_select = cur_item->no_select;
+ no_sub = cur_item->no_sub;
+ g_slist_free(item_list);
+ }
+ mailimap_list_result_free(lep_list);
}
}
new_item = folder_item_new(folder, new_name, dirpath);
+ new_item->no_select = no_select;
+ new_item->no_sub = no_sub;
folder_item_append(parent, new_item);
g_free(imap_path);
g_free(dirpath);
if (!is_dir_exist(dirpath))
make_dir_hier(dirpath);
g_free(dirpath);
-
+ unlock_session();
return new_item;
}
if (!session) {
return -1;
}
+ lock_session();
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;
}
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);
+ unlock_session();
return -1;
}
ok = imap_cmd_delete(session, path);
+ if (ok != IMAP_SUCCESS) {
+ gchar *tmp = g_strdup_printf("%s%c", path,
+ imap_get_path_separator(IMAP_FOLDER(folder), path));
+ g_free(path);
+ path = tmp;
+ ok = imap_cmd_delete(session, 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;
}
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);
gint exists_, recent_, unseen_;
guint32 uid_validity_;
- if (!exists || !recent || !unseen || !uid_validity) {
+ if (!exists && !recent && !unseen && !uid_validity) {
if (session->mbox && strcmp(session->mbox, path) == 0)
return IMAP_SUCCESS;
+ }
+ if (!exists)
exists = &exists_;
+ if (!recent)
recent = &recent_;
+ if (!unseen)
unseen = &unseen_;
+ if (!uid_validity)
uid_validity = &uid_validity_;
- }
g_free(session->mbox);
session->mbox = NULL;
}
static gint imap_status(IMAPSession *session, IMAPFolder *folder,
- const gchar *path,
- gint *messages, gint *recent,
+ const gchar *path, IMAPFolderItem *item,
+ gint *messages,
guint32 *uid_next, guint32 *uid_validity,
gint *unseen, gboolean block)
{
struct mailimap_mailbox_data_status * data_status;
int got_values;
gchar *real_path;
-
+ guint mask = 0;
+
real_path = imap_get_real_path(folder, path);
- r = imap_threaded_status(FOLDER(folder), real_path, &data_status);
+#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;
+ }
+ if (uid_next) {
+ mask |= 1 << 2;
+ }
+ if (uid_validity) {
+ mask |= 1 << 3;
+ }
+ if (unseen) {
+ mask |= 1 << 4;
+ }
+ r = imap_threaded_status(FOLDER(folder), real_path,
+ &data_status, mask);
+
g_free(real_path);
if (r != MAILIMAP_NO_ERROR) {
debug_print("status err %d\n", r);
got_values |= 1 << 0;
break;
- case MAILIMAP_STATUS_ATT_RECENT:
- * recent = info->st_value;
- got_values |= 1 << 1;
- break;
-
case MAILIMAP_STATUS_ATT_UIDNEXT:
* uid_next = info->st_value;
got_values |= 1 << 2;
}
mailimap_mailbox_data_status_free(data_status);
- if (got_values != ((1 << 4) + (1 << 3) +
- (1 << 2) + (1 << 1) + (1 << 0))) {
+ if (got_values != mask) {
debug_print("status: incomplete values received (%d)\n", got_values);
return IMAP_ERROR;
}
g_return_val_if_fail(file != NULL, IMAP_ERROR);
flag_list = imap_flag_to_lep(flags);
- statusbar_print_all(_("Adding messages..."));
r = imap_threaded_append(session->folder, destfolder,
file, flag_list);
- statusbar_pop_all();
if (new_uid != NULL)
*new_uid = 0;
g_return_val_if_fail(set != NULL, IMAP_ERROR);
g_return_val_if_fail(destfolder != NULL, IMAP_ERROR);
- statusbar_print_all(_("Copying messages..."));
r = imap_threaded_copy(session->folder, set, destfolder);
- statusbar_pop_all();
if (r != MAILIMAP_NO_ERROR) {
return IMAP_ERROR;
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) {
uidlist = NULL;
set = mailimap_set_new_interval(item->lastuid + 1, 0);
+
r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_SIMPLE, set,
&lep_uidlist);
if (r == MAILIMAP_NO_ERROR) {
}
}
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;
-
+ data->session = session;
if (prefs_common.work_offline && !inc_offline_should_override()) {
g_free(data);
return -1;
{
IMAPFolderItem *item = (IMAPFolderItem *)_item;
IMAPSession *session;
- gint ok, nummsgs = 0, exists, recent, uid_val, uid_next, unseen;
+ gint ok, nummsgs = 0, exists, uid_val, uid_next;
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:"");
session = imap_reconnect_if_possible(folder, session);
if (session == NULL) {
statusbar_pop_all();
+ unlock_session();
return -1;
}
}
*old_uids_valid = TRUE;
} else {
- ok = imap_status(session, IMAP_FOLDER(folder), item->item.path,
- &exists, &recent, &uid_next, &uid_val, &unseen, FALSE);
+ if (item->use_cache && time(NULL) - item->use_cache < 2) {
+ exists = item->c_messages;
+ uid_next = item->c_uid_next;
+ uid_val = item->c_uid_validity;
+ ok = IMAP_SUCCESS;
+ debug_print("using cache %d %d %d\n", exists, uid_next, uid_val);
+ } else {
+ ok = imap_status(session, IMAP_FOLDER(folder), item->item.path, item,
+ &exists, &uid_next, &uid_val, NULL, FALSE);
+ }
+ item->use_cache = (time_t)0;
if (ok != IMAP_SUCCESS) {
statusbar_pop_all();
+ unlock_session();
return -1;
}
if(item->item.mtime == uid_val)
if (exists == nummsgs) {
*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;
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,
g_slist_free(sorted_list);
}
-
+ unlock_session();
return ret;
}
{
IMAPSession *session;
IMAPFolderItem *item = (IMAPFolderItem *)_item;
- gint ok, exists = 0, recent = 0, unseen = 0;
- guint32 uid_next, uid_val = 0;
+ gint ok, exists = 0, unseen = 0;
+ guint32 uid_next, uid_val;
gboolean selected_folder;
g_return_val_if_fail(folder != NULL, FALSE);
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) {
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,
- &exists, &recent, &uid_next, &uid_val, &unseen, FALSE);
- if (ok != IMAP_SUCCESS)
+ 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) {
+ unlock_session();
return FALSE;
+ }
- if ((uid_next != item->uid_next) || (exists != item->item.total_msgs))
+ 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)) {
+ unlock_session();
return TRUE;
+ }
}
-
+ unlock_session();
return FALSE;
}
if (!session) {
return;
}
+ lock_session();
if ((ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
NULL, NULL, NULL, NULL, FALSE)) != IMAP_SUCCESS) {
+ unlock_session();
return;
}
*/
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;
}
FolderItem *item;
MsgInfoList *msginfo_list;
GRelation *msgflags;
+ gboolean full_search;
gboolean done;
} get_flags_data;
FolderItem *item = stuff->item;
MsgInfoList *msginfo_list = stuff->msginfo_list;
GRelation *msgflags = stuff->msgflags;
+ gboolean full_search = stuff->full_search;
IMAPSession *session;
- GSList *sorted_list;
+ GSList *sorted_list = NULL;
GSList *unseen = NULL, *answered = NULL, *flagged = NULL, *deleted = NULL;
GSList *p_unseen, *p_answered, *p_flagged, *p_deleted;
GSList *elem;
gboolean reverse_seen = FALSE;
GString *cmd_buf;
gint ok;
- gint exists_cnt, recent_cnt, unseen_cnt, uid_next;
- guint32 uidvalidity;
+ gint exists_cnt, unseen_cnt;
gboolean selected_folder;
if (folder == NULL || item == NULL) {
stuff->done = TRUE;
return GINT_TO_POINTER(-1);
}
- if (msginfo_list == NULL) {
- stuff->done = TRUE;
- return GINT_TO_POINTER(0);
- }
session = imap_session_get(folder);
if (session == NULL) {
stuff->done = TRUE;
return GINT_TO_POINTER(-1);
}
-
+ lock_session();
selected_folder = (session->mbox != NULL) &&
(!strcmp(session->mbox, item->path));
if (!selected_folder) {
- ok = imap_status(session, IMAP_FOLDER(folder), item->path,
- &exists_cnt, &recent_cnt, &uid_next, &uidvalidity, &unseen_cnt, TRUE);
ok = imap_select(session, IMAP_FOLDER(folder), item->path,
- NULL, NULL, NULL, NULL, TRUE);
+ &exists_cnt, NULL, &unseen_cnt, NULL, TRUE);
if (ok != IMAP_SUCCESS) {
stuff->done = TRUE;
+ unlock_session();
return GINT_TO_POINTER(-1);
}
cmd_buf = g_string_new(NULL);
sorted_list = g_slist_sort(g_slist_copy(msginfo_list), compare_msginfo);
-
- seq_list = imap_get_lep_set_from_msglist(msginfo_list);
+ if (!full_search) {
+ seq_list = imap_get_lep_set_from_msglist(msginfo_list);
+ } else {
+ struct mailimap_set * set;
+ set = mailimap_set_new_interval(1, 0);
+ seq_list = g_slist_append(NULL, set);
+ }
for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
struct mailimap_set * imapset;
g_string_free(cmd_buf, TRUE);
stuff->done = TRUE;
+ unlock_session();
return GINT_TO_POINTER(0);
}
data->item = item;
data->msginfo_list = msginfo_list;
data->msgflags = msgflags;
+ data->full_search = FALSE;
+ GSList *tmp = NULL, *cur;
+
if (prefs_common.work_offline && !inc_offline_should_override()) {
g_free(data);
return -1;
}
+ tmp = folder_item_get_msg_list(item);
+
+ if (g_slist_length(tmp) == g_slist_length(msginfo_list))
+ data->full_search = TRUE;
+
+ for (cur = tmp; cur; cur = cur->next)
+ procmsg_msginfo_free((MsgInfo *)cur->data);
+
+ g_slist_free(tmp);
+
result = GPOINTER_TO_INT(imap_get_flags_thread(data));
g_free(data);
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_free(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_free(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;
}
}
}
static GSList * imap_list_from_lep(IMAPFolder * folder,
- clist * list, const gchar * real_path)
+ clist * list, const gchar * real_path, gboolean all)
{
clistiter * iter;
GSList * item_list;
FolderItem *new_item;
mb = clist_content(iter);
-
+
+ if (mb == NULL)
+ continue;
+
flags = 0;
if (mb->mb_flag != NULL)
flags = imap_flags_to_flags(mb->mb_flag);
continue;
}
- if (strcmp(dup_name, real_path) == 0) {
+ if (!all && strcmp(dup_name, real_path) == 0) {
g_free(base);
free(dup_name);
continue;
}
- if (dup_name[strlen(dup_name)-1] == '/') {
+ if (!all && dup_name[strlen(dup_name)-1] == '/') {
g_free(base);
free(dup_name);
continue;
continue;
item_count ++;
-
+
last = GPOINTER_TO_INT(cur->data);
if (cur->next)
next = GPOINTER_TO_INT(cur->next->data);
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);
projects / claws.git / blobdiff