#include "prefs_account.h"
#define IMAP_FOLDER(obj) ((IMAPFolder *)obj)
+#define IMAP_FOLDER_ITEM(obj) ((IMAPFolderItem *)obj)
#define IMAP_SESSION(obj) ((IMAPSession *)obj)
struct _IMAPFolder
{
Session session;
+ gboolean authenticated;
+
gchar **capability;
+ gboolean uidplus;
+
gchar *mbox;
- time_t last_access_time;
- gboolean authenticated;
guint cmd_count;
+
+ /* CLAWS */
+ time_t last_access_time;
gboolean folder_content_changed;
guint exists;
};
#define IMAP_ERROR 7
#define IMAPBUFSIZE 8192
-#define IMAPCMDLIMIT 1000
typedef enum
{
#define IMAPS_PORT 993
#endif
+#define IMAP_CMD_LIMIT 1000
+
#define QUOTE_IF_REQUIRED(out, str) \
{ \
if (*str != '"' && strpbrk(str, " \t(){}%*") != NULL) { \
GSList *uid_list;
};
-static Folder *imap_folder_new(const gchar * name, const gchar * path);
-static void imap_folder_destroy(Folder * folder);
-
-static IMAPSession *imap_session_new(const PrefsAccount * account);
-static void imap_session_authenticate(IMAPSession * session,
- const PrefsAccount * account);
-static void imap_session_destroy(Session * session);
-
-static gchar *imap_fetch_msg(Folder * folder, FolderItem * item, gint uid);
-static gint imap_add_msg(Folder * folder,
- FolderItem * dest,
- const gchar * file, MsgFlags * flags);
-static gint imap_add_msgs(Folder * folder, FolderItem * dest,
- GSList * file_list,
- MsgNumberList **newnum_list);
-
-static gint imap_copy_msg(Folder * folder,
- FolderItem * dest, MsgInfo * msginfo);
-
-static gint imap_remove_msg(Folder * folder, FolderItem * item, gint uid);
-static gint imap_remove_all_msg(Folder * folder, FolderItem * item);
-
-static gboolean imap_is_msg_changed(Folder * folder,
- FolderItem * item, MsgInfo * msginfo);
-
-static gint imap_close(Folder * folder, FolderItem * item);
-
-static void imap_scan_tree(Folder * folder);
-
-static gint imap_create_tree(Folder * folder);
-
-static FolderItem *imap_create_folder(Folder * folder,
- FolderItem * parent,
- const gchar * name);
-static gint imap_rename_folder(Folder * folder,
- FolderItem * item, const gchar * name);
-static gint imap_remove_folder(Folder * folder, FolderItem * item);
-
-
static void imap_folder_init (Folder *folder,
const gchar *name,
const gchar *path);
+static Folder *imap_folder_new (const gchar *name,
+ const gchar *path);
+static void imap_folder_destroy (Folder *folder);
+
+static IMAPSession *imap_session_new (const PrefsAccount *account);
+static void imap_session_authenticate(IMAPSession *session,
+ const PrefsAccount *account);
+static void imap_session_destroy (Session *session);
+
+static gchar *imap_fetch_msg (Folder *folder,
+ FolderItem *item,
+ gint uid);
+static gint imap_add_msg (Folder *folder,
+ FolderItem *dest,
+ const gchar *file,
+ MsgFlags *flags);
+static gint imap_add_msgs (Folder *folder,
+ FolderItem *dest,
+ GSList *file_list,
+ GRelation *relation);
+
+static gint imap_copy_msg (Folder *folder,
+ FolderItem *dest,
+ MsgInfo *msginfo);
+static gint imap_copy_msgs (Folder *folder,
+ FolderItem *dest,
+ MsgInfoList *msglist,
+ GRelation *relation);
+
+static gint imap_remove_msg (Folder *folder,
+ FolderItem *item,
+ gint uid);
+static gint imap_remove_all_msg (Folder *folder,
+ FolderItem *item);
+
+static gboolean imap_is_msg_changed (Folder *folder,
+ FolderItem *item,
+ MsgInfo *msginfo);
+
+static gint imap_close (Folder *folder,
+ FolderItem *item);
+
+static gint imap_scan_tree (Folder *folder);
+
+static gint imap_create_tree (Folder *folder);
+
+static FolderItem *imap_create_folder (Folder *folder,
+ FolderItem *parent,
+ const gchar *name);
+static gint imap_rename_folder (Folder *folder,
+ FolderItem *item,
+ const gchar *name);
+static gint imap_remove_folder (Folder *folder,
+ FolderItem *item);
+
static FolderItem *imap_folder_item_new (Folder *folder);
static void imap_folder_item_destroy (Folder *folder,
FolderItem *item);
static IMAPSession *imap_session_get (Folder *folder);
+static gint imap_greeting (IMAPSession *session);
static gint imap_auth (IMAPSession *session,
const gchar *user,
const gchar *pass,
const gchar *real_path,
gchar *separator);
-static void imap_create_missing_folders (Folder *folder);
+static void imap_create_missing_folders (Folder *folder);
static FolderItem *imap_create_special_folder
(Folder *folder,
SpecialFolderItemType stype,
const gchar *name);
-static gint imap_do_copy (Folder *folder,
+static gint imap_do_copy_msgs (Folder *folder,
FolderItem *dest,
- MsgInfo *msginfo,
- gboolean remove_source);
+ MsgInfoList *msglist,
+ GRelation *relation);
static void imap_delete_all_cached_messages (FolderItem *item);
static MsgInfo *imap_parse_envelope (SockInfo *sock,
FolderItem *item,
GString *line_str);
-static gint imap_greeting (IMAPSession *session);
+
static gboolean imap_has_capability (IMAPSession *session,
const gchar *cap);
-void imap_free_capabilities (IMAPSession *session);
-static const IMAPSet numberlist_to_imapset
- (MsgNumberList *list);
+static void imap_free_capabilities (IMAPSession *session);
/* low-level IMAP4rev1 commands */
static gint imap_cmd_authenticate
const gchar *user,
const gchar *pass,
IMAPAuthType type);
-static gint imap_cmd_login (IMAPSession *sock,
+static gint imap_cmd_login (IMAPSession *session,
const gchar *user,
const gchar *pass);
-static gint imap_cmd_logout (IMAPSession *sock);
-static gint imap_cmd_noop (IMAPSession *sock);
-static gint imap_cmd_starttls (IMAPSession *sock);
-static gint imap_cmd_namespace (IMAPSession *sock,
+static gint imap_cmd_logout (IMAPSession *session);
+static gint imap_cmd_noop (IMAPSession *session);
+static gint imap_cmd_starttls (IMAPSession *session);
+static gint imap_cmd_namespace (IMAPSession *session,
gchar **ns_str);
static gint imap_cmd_list (IMAPSession *session,
const gchar *ref,
const gchar *mailbox,
GPtrArray *argbuf);
-static gint imap_cmd_do_select (IMAPSession *sock,
+static gint imap_cmd_do_select (IMAPSession *session,
const gchar *folder,
gboolean examine,
gint *exists,
gint *recent,
gint *unseen,
guint32 *uid_validity);
-static gint imap_cmd_select (IMAPSession *sock,
+static gint imap_cmd_select (IMAPSession *session,
const gchar *folder,
gint *exists,
gint *recent,
gint *unseen,
guint32 *uid_validity);
-static gint imap_cmd_examine (IMAPSession *sock,
+static gint imap_cmd_examine (IMAPSession *session,
const gchar *folder,
gint *exists,
gint *recent,
static gint imap_cmd_rename (IMAPSession *sock,
const gchar *oldfolder,
const gchar *newfolder);
-static gint imap_cmd_delete (IMAPSession *sock,
+static gint imap_cmd_delete (IMAPSession *session,
const gchar *folder);
-static gint imap_cmd_envelope (IMAPSession *sock,
+static gint imap_cmd_envelope (IMAPSession *session,
IMAPSet set);
static gint imap_cmd_fetch (IMAPSession *sock,
guint32 uid,
const gchar *destfolder,
const gchar *file,
IMAPFlags flags,
- gint32 *newuid);
-static gint imap_cmd_copy (IMAPSession *session,
- gint32 msgnum,
- const gchar *destfolder,
- gint32 *new_uid);
-static gint imap_cmd_store (IMAPSession *sock,
+ guint32 *new_uid);
+static gint imap_cmd_copy (IMAPSession *session,
+ const gchar *seq_set,
+ const gchar *destfolder,
+ GRelation *uid_mapping);
+static gint imap_cmd_store (IMAPSession *session,
IMAPSet set,
gchar *sub_cmd);
-static gint imap_cmd_expunge (IMAPSession *sock);
-static gint imap_cmd_close (IMAPSession *session);
+static gint imap_cmd_expunge (IMAPSession *session,
+ IMAPSet seq_set);
+static gint imap_cmd_close (IMAPSession *session);
static gint imap_cmd_ok (IMAPSession *session,
GPtrArray *argbuf);
-static void imap_gen_send (IMAPSession *sock,
+static void imap_gen_send (IMAPSession *session,
const gchar *format, ...);
-static gint imap_gen_recv (IMAPSession *sock,
- gchar **buf);
+static gint imap_gen_recv (IMAPSession *session,
+ gchar **ret);
/* misc utility functions */
static gchar *strchr_cpy (const gchar *src,
static gchar *imap_modified_utf7_to_locale (const gchar *mutf7_str);
static gchar *imap_locale_to_modified_utf7 (const gchar *from);
+static GSList *imap_get_seq_set_from_numlist (MsgNumberList *msglist);
+static GSList *imap_get_seq_set_from_msglist (MsgInfoList *msglist);
+static void imap_seq_set_free (GSList *seq_list);
+
static gboolean imap_rename_folder_func (GNode *node,
gpointer data);
static gint imap_get_num_list (Folder *folder,
FolderItem *item,
- GSList **list);
+ GSList **list,
+ gboolean *old_uids_valid);
static GSList *imap_get_msginfos (Folder *folder,
FolderItem *item,
GSList *msgnum_list);
static MsgInfo *imap_get_msginfo (Folder *folder,
FolderItem *item,
gint num);
-static gboolean imap_check_msgnum_validity (Folder *folder,
+static gboolean imap_scan_required (Folder *folder,
FolderItem *item);
static void imap_change_flags (Folder *folder,
FolderItem *item,
static gchar *imap_item_get_path (Folder *folder,
FolderItem *item);
-FolderClass imap_class =
+static FolderClass imap_class =
{
F_IMAP,
"imap",
NULL,
NULL,
NULL,
- imap_check_msgnum_validity,
+ imap_scan_required,
/* Message functions */
imap_get_msginfo,
imap_add_msg,
imap_add_msgs,
imap_copy_msg,
- NULL,
+ imap_copy_msgs,
imap_remove_msg,
imap_remove_all_msg,
imap_is_msg_changed,
return &imap_class;
}
-Folder *imap_folder_new(const gchar *name, const gchar *path)
+static Folder *imap_folder_new(const gchar *name, const gchar *path)
{
Folder *folder;
return folder;
}
-void imap_folder_destroy(Folder *folder)
+static void imap_folder_destroy(Folder *folder)
{
gchar *dir;
g_node_traverse(folder->node, G_IN_ORDER, G_TRAVERSE_ALL, -1, imap_reset_uid_lists_func, NULL);
}
+/* Send CAPABILITY, and examine the server's response to see whether this
+ * connection is pre-authenticated or not and build a list of CAPABILITIES. */
+static gint imap_greeting(IMAPSession *session)
+{
+ gchar *capstr;
+ GPtrArray *argbuf;
+
+ imap_gen_send(session, "CAPABILITY");
+
+ argbuf = g_ptr_array_new();
+
+ if (imap_cmd_ok(session, argbuf) != IMAP_SUCCESS ||
+ ((capstr = search_array_str(argbuf, "CAPABILITY ")) == NULL)) {
+ ptr_array_free_strings(argbuf);
+ g_ptr_array_free(argbuf, TRUE);
+ return -1;
+ }
+
+ session->authenticated = search_array_str(argbuf, "PREAUTH") != NULL;
+
+ capstr += strlen("CAPABILITY ");
+
+ IMAP_SESSION(session)->capability = g_strsplit(capstr, " ", 0);
+
+ ptr_array_free_strings(argbuf);
+ g_ptr_array_free(argbuf, TRUE);
+
+ if (imap_has_capability(session, "UIDPLUS"))
+ session->uidplus = TRUE;
+
+ return 0;
+}
+
static gint imap_auth(IMAPSession *session, const gchar *user, const gchar *pass,
IMAPAuthType type)
{
+ gint ok;
+
if (type == 0 || type == IMAP_AUTH_LOGIN)
- return imap_cmd_login(session, user, pass);
+ ok = imap_cmd_login(session, user, pass);
else
- return imap_cmd_authenticate(session, user, pass, type);
+ ok = imap_cmd_authenticate(session, user, pass, type);
+
+ if (ok == IMAP_SUCCESS)
+ session->authenticated = TRUE;
+
+ return ok;
}
static IMAPSession *imap_session_get(Folder *folder)
return IMAP_SESSION(session);
}
-IMAPSession *imap_session_new(const PrefsAccount *account)
+static IMAPSession *imap_session_new(const PrefsAccount *account)
{
IMAPSession *session;
SockInfo *imap_sock;
session->capability = NULL;
- session->mbox = NULL;
session->authenticated = FALSE;
+ session->mbox = NULL;
session->cmd_count = 0;
/* Only need to log in if the connection was not PREAUTH */
}
#if USE_OPENSSL
- if (account->ssl_imap == SSL_STARTTLS && imap_has_capability(session, "STARTTLS")) {
+ if (account->ssl_imap == SSL_STARTTLS &&
+ imap_has_capability(session, "STARTTLS")) {
gint ok;
ok = imap_cmd_starttls(session);
session_destroy(SESSION(session));
return NULL;
}
- if (!ssl_init_socket_with_method(SESSION(session)->sock, SSL_METHOD_TLSv1)) {
+ if (!ssl_init_socket_with_method(SESSION(session)->sock,
+ SSL_METHOD_TLSv1)) {
session_destroy(SESSION(session));
return NULL;
}
imap_free_capabilities(session);
session->authenticated = FALSE;
+ session->uidplus = FALSE;
session->cmd_count = 1;
if (imap_greeting(session) != IMAP_SUCCESS) {
return session;
}
-void imap_session_authenticate(IMAPSession *session, const PrefsAccount *account)
+static void imap_session_authenticate(IMAPSession *session,
+ const PrefsAccount *account)
{
gchar *pass;
session->authenticated = TRUE;
}
-void imap_session_destroy(Session *session)
+static void imap_session_destroy(Session *session)
{
+ imap_free_capabilities(IMAP_SESSION(session));
+ g_free(IMAP_SESSION(session)->mbox);
sock_close(session->sock);
session->sock = NULL;
-
- g_free(IMAP_SESSION(session)->mbox);
- imap_free_capabilities(IMAP_SESSION(session));
}
-gchar *imap_fetch_msg(Folder *folder, FolderItem *item, gint uid)
+static gchar *imap_fetch_msg(Folder *folder, FolderItem *item, gint uid)
{
gchar *path, *filename;
IMAPSession *session;
make_dir_hier(path);
filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(uid), NULL);
g_free(path);
-
+
if (is_file_exist(filename)) {
debug_print("message %d has been already cached.\n", uid);
return filename;
return filename;
}
-gint imap_add_msg(Folder *folder, FolderItem *dest, const gchar *file, MsgFlags *flags)
+static gint imap_add_msg(Folder *folder, FolderItem *dest,
+ const gchar *file, MsgFlags *flags)
{
gint ret;
GSList file_list;
MsgFileInfo fileinfo;
- MsgNumberList *msgnum_list = NULL;
g_return_val_if_fail(file != NULL, -1);
+ fileinfo.msginfo = NULL;
fileinfo.file = (gchar *)file;
fileinfo.flags = flags;
file_list.data = &fileinfo;
file_list.next = NULL;
- ret = imap_add_msgs(folder, dest, &file_list, &msgnum_list);
- g_slist_free(msgnum_list);
+ ret = imap_add_msgs(folder, dest, &file_list, NULL);
return ret;
}
-gint imap_add_msgs(Folder *folder, FolderItem *dest, GSList *file_list,
- MsgNumberList **newnum_list)
+static gint imap_add_msgs(Folder *folder, FolderItem *dest, GSList *file_list,
+ GRelation *relation)
{
gchar *destdir;
IMAPSession *session;
guint32 last_uid = 0;
GSList *cur;
MsgFileInfo *fileinfo;
- gint ok, newnum;
+ gint ok;
g_return_val_if_fail(folder != NULL, -1);
g_return_val_if_fail(dest != NULL, -1);
for (cur = file_list; cur != NULL; cur = cur->next) {
IMAPFlags iflags = 0;
+ guint32 new_uid = 0;
fileinfo = (MsgFileInfo *)cur->data;
dest->stype == F_TRASH)
iflags |= IMAP_FLAG_SEEN;
- ok = imap_cmd_append(session, destdir, fileinfo->file, iflags, &newnum);
+ ok = imap_cmd_append(session, destdir, fileinfo->file, iflags,
+ &new_uid);
if (ok != IMAP_SUCCESS) {
g_warning("can't append message %s\n", fileinfo->file);
return -1;
}
- *newnum_list = g_slist_append(*newnum_list, GINT_TO_POINTER(newnum));
- if (newnum > last_uid)
- last_uid = newnum;
+ 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)
+ last_uid = new_uid;
}
g_free(destdir);
return last_uid;
}
-static gint imap_do_copy(Folder *folder, FolderItem *dest, MsgInfo *msginfo,
- gboolean remove_source)
+static gint imap_do_copy_msgs(Folder *folder, FolderItem *dest,
+ MsgInfoList *msglist, GRelation *relation)
{
+ FolderItem *src;
gchar *destdir;
+ GSList *seq_list, *cur;
+ MsgInfo *msginfo;
IMAPSession *session;
- guint32 newuid = 0;
- gint ok;
+ gint ok = IMAP_SUCCESS;
+ GRelation *uid_mapping;
+ gint last_num = 0;
g_return_val_if_fail(folder != NULL, -1);
- g_return_val_if_fail(FOLDER_CLASS(folder) == &imap_class, -1);
g_return_val_if_fail(dest != NULL, -1);
- g_return_val_if_fail(msginfo != NULL, -1);
+ g_return_val_if_fail(msglist != NULL, -1);
session = imap_session_get(folder);
if (!session) return -1;
- if (msginfo->folder == dest) {
+ msginfo = (MsgInfo *)msglist->data;
+
+ src = msginfo->folder;
+ if (src == dest) {
g_warning("the src folder is identical to the dest.\n");
return -1;
}
- destdir = imap_get_real_path(IMAP_FOLDER(folder), dest->path);
-
- /* ensure source folder selected */
ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
NULL, NULL, NULL, NULL);
if (ok != IMAP_SUCCESS)
- return -1;
-
- if (remove_source)
- debug_print("Moving message %s%c%d to %s ...\n",
- msginfo->folder->path, G_DIR_SEPARATOR,
- msginfo->msgnum, destdir);
- else
- debug_print("Copying message %s%c%d to %s ...\n",
- msginfo->folder->path, G_DIR_SEPARATOR,
- msginfo->msgnum, destdir);
+ return ok;
- ok = imap_cmd_copy(session, msginfo->msgnum, destdir, &newuid);
+ destdir = imap_get_real_path(IMAP_FOLDER(folder), dest->path);
+ seq_list = imap_get_seq_set_from_msglist(msglist);
+ uid_mapping = g_relation_new(2);
+ g_relation_index(uid_mapping, 0, g_direct_hash, g_direct_equal);
+
+ for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
+ gchar *seq_set = (gchar *)cur->data;
- if (ok == IMAP_SUCCESS && remove_source) {
- MsgNumberList numlist;
+ debug_print("Copying message %s%c[%s] to %s ...\n",
+ src->path, G_DIR_SEPARATOR,
+ seq_set, destdir);
- numlist.next = NULL;
- numlist.data = GINT_TO_POINTER(msginfo->msgnum);
-
- imap_set_message_flags(session, &numlist,
- IMAP_FLAG_DELETED, TRUE);
- ok = imap_cmd_expunge(session);
+ ok = imap_cmd_copy(session, seq_set, destdir, uid_mapping);
+ if (ok != IMAP_SUCCESS) {
+ g_relation_destroy(uid_mapping);
+ imap_seq_set_free(seq_list);
+ return -1;
+ }
}
+ for (cur = msglist; cur != NULL; cur = g_slist_next(cur)) {
+ MsgInfo *msginfo = (MsgInfo *)cur->data;
+ GTuples *tuples;
+
+ tuples = g_relation_select(uid_mapping,
+ GINT_TO_POINTER(msginfo->msgnum),
+ 0);
+ if (tuples->len > 0) {
+ gint num = GPOINTER_TO_INT(g_tuples_index(tuples, 0, 1));
+ g_relation_insert(relation, msginfo,
+ GPOINTER_TO_INT(num));
+ if (num > last_num)
+ last_num = num;
+ } else
+ g_relation_insert(relation, msginfo,
+ GPOINTER_TO_INT(0));
+ g_tuples_destroy(tuples);
+ }
+
+ imap_seq_set_free(seq_list);
+
g_free(destdir);
if (ok == IMAP_SUCCESS)
- return newuid;
+ return last_num;
else
return -1;
}
-gint imap_copy_msg(Folder *folder, FolderItem *dest, MsgInfo *msginfo)
+static gint imap_copy_msg(Folder *folder, FolderItem *dest, MsgInfo *msginfo)
{
- gchar *srcfile;
- gint ret = 0;
+ GSList msglist;
+
+ g_return_val_if_fail(msginfo != NULL, -1);
+
+ msglist.data = msginfo;
+ msglist.next = NULL;
+
+ return imap_copy_msgs(folder, dest, &msglist, NULL);
+}
+
+static gint imap_copy_msgs(Folder *folder, FolderItem *dest,
+ MsgInfoList *msglist, GRelation *relation)
+{
+ MsgInfo *msginfo;
+ GSList *file_list;
+ gint ret;
g_return_val_if_fail(folder != NULL, -1);
g_return_val_if_fail(dest != NULL, -1);
- g_return_val_if_fail(msginfo != NULL, -1);
+ g_return_val_if_fail(msglist != NULL, -1);
+
+ msginfo = (MsgInfo *)msglist->data;
g_return_val_if_fail(msginfo->folder != NULL, -1);
if (folder == msginfo->folder->folder)
- return imap_do_copy(folder, dest, msginfo, FALSE);
+ return imap_do_copy_msgs(folder, dest, msglist, relation);
- srcfile = procmsg_get_message_file(msginfo);
- if (!srcfile) return -1;
+ file_list = procmsg_get_message_file_list(msglist);
+ g_return_val_if_fail(file_list != NULL, -1);
- ret = imap_add_msg(folder, dest, srcfile, NULL);
+ ret = imap_add_msgs(folder, dest, file_list, relation);
- g_free(srcfile);
+ procmsg_message_file_list_free(file_list);
return ret;
}
-gint imap_remove_msg(Folder *folder, FolderItem *item, gint uid)
+static gint imap_remove_msg(Folder *folder, FolderItem *item, gint uid)
{
gint ok;
IMAPSession *session;
return ok;
}
- ok = imap_cmd_expunge(session);
+ if (!session->uidplus) {
+ ok = imap_cmd_expunge(session, NULL);
+ } else {
+ gchar *uidstr;
+
+ uidstr = g_strdup_printf("%u", uid);
+ ok = imap_cmd_expunge(session, uidstr);
+ g_free(uidstr);
+ }
if (ok != IMAP_SUCCESS) {
log_warning(_("can't expunge\n"));
return ok;
}
+ IMAP_FOLDER_ITEM(item)->uid_list = g_slist_remove(
+ IMAP_FOLDER_ITEM(item)->uid_list, numlist.data);
dir = folder_item_get_path(item);
if (is_dir_exist(dir))
remove_numbered_files(dir, uid, uid);
return IMAP_SUCCESS;
}
-gint imap_remove_all_msg(Folder *folder, FolderItem *item)
+static gint imap_remove_all_msg(Folder *folder, FolderItem *item)
{
- gint exists, recent, unseen;
- guint32 uid_validity;
gint ok;
IMAPSession *session;
gchar *dir;
if (!session) return -1;
ok = imap_select(session, IMAP_FOLDER(folder), item->path,
- &exists, &recent, &unseen, &uid_validity);
+ NULL, NULL, NULL, NULL);
if (ok != IMAP_SUCCESS)
return ok;
- if (exists == 0)
- return IMAP_SUCCESS;
- imap_gen_send(session,
- "STORE 1:%d +FLAGS (\\Deleted)", exists);
+ imap_gen_send(session, "STORE 1:* +FLAGS.SILENT (\\Deleted)");
ok = imap_cmd_ok(session, NULL);
if (ok != IMAP_SUCCESS) {
- log_warning(_("can't set deleted flags: 1:%d\n"), exists);
+ log_warning(_("can't set deleted flags: 1:*\n"));
return ok;
}
- ok = imap_cmd_expunge(session);
+ ok = imap_cmd_expunge(session, NULL);
if (ok != IMAP_SUCCESS) {
log_warning(_("can't expunge\n"));
return ok;
return IMAP_SUCCESS;
}
-gboolean imap_is_msg_changed(Folder *folder, FolderItem *item, MsgInfo *msginfo)
+static gboolean imap_is_msg_changed(Folder *folder, FolderItem *item,
+ MsgInfo *msginfo)
{
/* TODO: properly implement this method */
return FALSE;
}
-gint imap_close(Folder *folder, FolderItem *item)
+static gint imap_close(Folder *folder, FolderItem *item)
{
gint ok;
IMAPSession *session;
g_return_val_if_fail(folder != NULL, -1);
+ g_return_val_if_fail(item != NULL, -1);
+ g_return_val_if_fail(item->path != NULL, -1);
session = imap_session_get(folder);
if (!session) return -1;
if (session->mbox) {
+ if (strcmp2(session->mbox, item->path) != 0) return -1;
+
ok = imap_cmd_close(session);
if (ok != IMAP_SUCCESS)
log_warning(_("can't close folder\n"));
return 0;
}
-void imap_scan_tree(Folder *folder)
+static gint imap_scan_tree(Folder *folder)
{
- FolderItem *item;
+ FolderItem *item = NULL;
IMAPSession *session;
gchar *root_folder = NULL;
- g_return_if_fail(folder != NULL);
- g_return_if_fail(folder->account != NULL);
+ g_return_val_if_fail(folder != NULL, -1);
+ g_return_val_if_fail(folder->account != NULL, -1);
session = imap_session_get(folder);
if (!session) {
folder_tree_destroy(folder);
item = folder_item_new(folder, folder->name, NULL);
item->folder = folder;
- folder->node = g_node_new(item);
+ folder->node = item->node = g_node_new(item);
}
- return;
+ return -1;
}
if (folder->account->imap_dir && *folder->account->imap_dir) {
- Xstrdup_a(root_folder, folder->account->imap_dir, return);
+ gchar *real_path;
+
+ Xstrdup_a(root_folder, folder->account->imap_dir, return -1);
strtailchomp(root_folder, '/');
- debug_print("IMAP root directory: %s\n", root_folder);
+ extract_quote(root_folder, '"');
+ real_path = imap_get_real_path
+ (IMAP_FOLDER(folder), root_folder);
+ debug_print("IMAP root directory: %s\n", real_path);
+ if (imap_status(session, IMAP_FOLDER(folder), root_folder,
+ NULL, NULL, NULL, NULL, NULL)
+ != IMAP_SUCCESS) {
+ if (imap_cmd_create(session, real_path)
+ != IMAP_SUCCESS) {
+ log_warning(_("can't create root folder %s\n"),
+ real_path);
+ g_free(real_path);
+ return -1;
+ }
+ }
+ g_free(real_path);
}
- item = folder_item_new(folder, folder->name, root_folder);
- item->folder = folder;
- item->no_select = TRUE;
- folder->node = g_node_new(item);
-
- imap_scan_tree_recursive(session, item);
+ if (folder->node)
+ item = FOLDER_ITEM(folder->node->data);
+ if (!item || ((item->path || root_folder) &&
+ strcmp2(item->path, root_folder) != 0)) {
+ folder_tree_destroy(folder);
+ item = folder_item_new(folder, folder->name, root_folder);
+ item->folder = folder;
+ folder->node = item->node = g_node_new(item);
+ }
+ imap_scan_tree_recursive(session, FOLDER_ITEM(folder->node->data));
imap_create_missing_folders(folder);
+
+ return 0;
}
static gint imap_scan_tree_recursive(IMAPSession *session, FolderItem *item)
IMAPFolder *imapfolder;
FolderItem *new_item;
GSList *item_list, *cur;
+ GNode *node;
gchar *real_path;
gchar *wildcard_path;
gchar separator;
g_return_val_if_fail(item->folder != NULL, -1);
g_return_val_if_fail(item->no_sub == FALSE, -1);
- folder = FOLDER(item->folder);
+ folder = item->folder;
imapfolder = IMAP_FOLDER(folder);
separator = imap_get_path_separator(imapfolder, item->path);
- if (item->folder->ui_func)
- item->folder->ui_func(folder, item, folder->ui_func_data);
+ if (folder->ui_func)
+ folder->ui_func(folder, item, folder->ui_func_data);
if (item->path) {
wildcard[0] = separator;
item_list = imap_parse_list(imapfolder, session, real_path, NULL);
g_free(real_path);
+ node = item->node->children;
+ while (node != NULL) {
+ FolderItem *old_item = FOLDER_ITEM(node->data);
+ GNode *next = node->next;
+
+ new_item = NULL;
+ for (cur = item_list; cur != NULL; cur = cur->next) {
+ FolderItem *cur_item = FOLDER_ITEM(cur->data);
+ if (!strcmp2(old_item->path, cur_item->path)) {
+ new_item = cur_item;
+ break;
+ }
+ }
+ if (!new_item) {
+ debug_print("folder '%s' not found. removing...\n",
+ old_item->path);
+ folder_item_remove(old_item);
+ } else {
+ old_item->no_sub = new_item->no_sub;
+ old_item->no_select = new_item->no_select;
+ if (old_item->no_sub == TRUE && node->children) {
+ debug_print("folder '%s' doesn't have "
+ "subfolders. removing...\n",
+ old_item->path);
+ folder_item_remove_children(old_item);
+ }
+ }
+
+ node = next;
+ }
+
for (cur = item_list; cur != NULL; cur = cur->next) {
- new_item = cur->data;
- if (!strcmp(new_item->path, "INBOX")) {
- if (!folder->inbox) {
- new_item->stype = F_INBOX;
- item->folder->inbox = new_item;
- } else {
- folder_item_destroy(new_item);
- continue;
+ 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,
+ cur_item->path)) {
+ new_item = FOLDER_ITEM(node->data);
+ folder_item_destroy(cur_item);
+ cur_item = NULL;
+ break;
}
+ }
+ if (!new_item) {
+ new_item = cur_item;
+ debug_print("new folder '%s' found.\n", new_item->path);
+ folder_item_append(item, new_item);
+ }
+
+ if (!strcmp(new_item->path, "INBOX")) {
+ new_item->stype = F_INBOX;
+ folder->inbox = new_item;
} else if (!item->parent || item->stype == F_INBOX) {
gchar *base;
folder->trash = new_item;
}
}
- folder_item_append(item, new_item);
+
if (new_item->no_sub == FALSE)
imap_scan_tree_recursive(session, new_item);
}
+ g_slist_free(item_list);
+
return IMAP_SUCCESS;
}
strretchomp(buf);
if (buf[0] != '*' || buf[1] != ' ') {
log_print("IMAP4< %s\n", buf);
+ if (sscanf(buf, "%*d %16s", buf) < 1 ||
+ strcmp(buf, "OK") != 0)
+ log_warning(_("error occurred while getting LIST.\n"));
+
break;
}
debug_print("IMAP4< %s\n", buf);
item_list = g_slist_append(item_list, new_item);
- debug_print("folder %s has been added.\n", loc_path);
+ debug_print("folder '%s' found.\n", loc_path);
g_free(loc_path);
g_free(loc_name);
}
return item_list;
}
-gint imap_create_tree(Folder *folder)
+static gint imap_create_tree(Folder *folder)
{
g_return_val_if_fail(folder != NULL, -1);
g_return_val_if_fail(folder->node != NULL, -1);
return path;
}
-FolderItem *imap_create_folder(Folder *folder, FolderItem *parent,
+static FolderItem *imap_create_folder(Folder *folder, FolderItem *parent,
const gchar *name)
{
gchar *dirpath, *imap_path;
return new_item;
}
-gint imap_rename_folder(Folder *folder, FolderItem *item, const gchar *name)
+static gint imap_rename_folder(Folder *folder, FolderItem *item,
+ const gchar *name)
{
gchar *dirpath;
gchar *newpath;
gchar *real_oldpath;
gchar *real_newpath;
- GNode *node;
gchar *paths[2];
gchar *old_cache_dir;
gchar *new_cache_dir;
old_cache_dir = folder_item_get_path(item);
- node = g_node_find(item->folder->node, G_PRE_ORDER, G_TRAVERSE_ALL,
- item);
paths[0] = g_strdup(item->path);
paths[1] = newpath;
- g_node_traverse(node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
+ g_node_traverse(item->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
imap_rename_folder_func, paths);
if (is_dir_exist(old_cache_dir)) {
return 0;
}
-gint imap_remove_folder(Folder *folder, FolderItem *item)
+static gint imap_remove_folder(Folder *folder, FolderItem *item)
{
gint ok;
IMAPSession *session;
GSList *llast = NULL;
GString *str;
MsgInfo *msginfo;
+ GSList *seq_list, *cur;
IMAPSet imapset;
g_return_val_if_fail(session != NULL, NULL);
g_return_val_if_fail(item->folder != NULL, NULL);
g_return_val_if_fail(FOLDER_CLASS(item->folder) == &imap_class, NULL);
- imapset = numberlist_to_imapset(numlist);
- while (imapset != NULL) {
+ seq_list = imap_get_seq_set_from_numlist(numlist);
+ for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
+ imapset = cur->data;
+
if (imap_cmd_envelope(session, imapset)
!= IMAP_SUCCESS) {
log_warning(_("can't get envelope\n"));
}
g_string_free(str, TRUE);
- imapset = numberlist_to_imapset(NULL);
}
+ imap_seq_set_free(seq_list);
return newlist;
}
if (!path) path = "";
- Xstrcat_a(tmp_path, path, "/", return NULL);
-
for (; ns_list != NULL; ns_list = ns_list->next) {
IMAPNameSpace *tmp_ns = ns_list->data;
+ Xstrcat_a(tmp_path, path, "/", return namespace);
Xstrdup_a(name, tmp_ns->name, return namespace);
- if (tmp_ns->separator && tmp_ns->separator != '/')
+ if (tmp_ns->separator && tmp_ns->separator != '/') {
+ subst_char(tmp_path, tmp_ns->separator, '/');
subst_char(name, tmp_ns->separator, '/');
+ }
if (strncmp(tmp_path, name, strlen(name)) == 0)
namespace = tmp_ns;
}
cur_pos = strchr_cpy(cur_pos + 1, '}', buf, sizeof(buf));
len = atoi(buf);
- g_return_val_if_fail(len > 0, cur_pos);
+ g_return_val_if_fail(len >= 0, cur_pos);
g_string_truncate(str, 0);
cur_pos = str->str;
cur_pos = strchr_cpy(cur_pos + 1, '}', buf, sizeof(buf));
len = atoi(buf);
- g_return_val_if_fail(len > 0, cur_pos);
+ g_return_val_if_fail(len >= 0, cur_pos);
g_string_truncate(str, 0);
cur_pos = str->str;
if (IMAP_IS_DELETED(flags)) g_string_append(str, "\\Deleted ");
if (IMAP_IS_DRAFT(flags)) g_string_append(str, "\\Draft");
- if (str->str[str->len - 1] == ' ')
+ if (str->len > 0 && str->str[str->len - 1] == ' ')
g_string_truncate(str, str->len - 1);
ret = str->str;
gchar *cmd;
gchar *flag_str;
gint ok;
+ GSList *seq_list, *cur;
IMAPSet imapset;
flag_str = imap_get_flag_str(flags);
flag_str, ")", NULL);
g_free(flag_str);
- imapset = numberlist_to_imapset(numlist);
- while (imapset != NULL) {
+ seq_list = imap_get_seq_set_from_numlist(numlist);
+ for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
+ imapset = cur->data;
+
ok = imap_cmd_store(session, imapset, cmd);
- imapset = numberlist_to_imapset(NULL);
}
+ imap_seq_set_free(seq_list);
g_free(cmd);
return ok;
gchar *real_path;
gchar *real_path_;
gint ok;
- GPtrArray *argbuf;
+ GPtrArray *argbuf = NULL;
gchar *str;
- *messages = *recent = *uid_next = *uid_validity = *unseen = 0;
-
- argbuf = g_ptr_array_new();
+ if (messages && recent && uid_next && uid_validity && unseen) {
+ *messages = *recent = *uid_next = *uid_validity = *unseen = 0;
+ argbuf = g_ptr_array_new();
+ }
real_path = imap_get_real_path(folder, path);
QUOTE_IF_REQUIRED(real_path_, real_path);
imap_gen_send(session, "STATUS %s "
- "(MESSAGES RECENT UIDNEXT UIDVALIDITY UNSEEN)",
- real_path_);
+ "(MESSAGES RECENT UIDNEXT UIDVALIDITY UNSEEN)",
+ real_path_);
ok = imap_cmd_ok(session, argbuf);
- if (ok != IMAP_SUCCESS) THROW(ok);
+ if (ok != IMAP_SUCCESS || !argbuf) THROW(ok);
str = search_array_str(argbuf, "STATUS");
if (!str) THROW(IMAP_ERROR);
catch:
g_free(real_path);
- ptr_array_free_strings(argbuf);
- g_ptr_array_free(argbuf, TRUE);
+ if (argbuf) {
+ ptr_array_free_strings(argbuf);
+ g_ptr_array_free(argbuf, TRUE);
+ }
return ok;
}
#undef THROW
+static gboolean imap_has_capability(IMAPSession *session, const gchar *cap)
+{
+ gchar **p;
+
+ for (p = session->capability; *p != NULL; ++p) {
+ if (!g_strcasecmp(*p, cap))
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static void imap_free_capabilities(IMAPSession *session)
+{
+ g_strfreev(session->capability);
+ session->capability = NULL;
+}
/* low-level IMAP4rev1 commands */
{
gchar *auth_type;
gint ok;
- gchar *buf;
+ gchar *buf = NULL;
gchar *challenge;
gint challenge_len;
gchar hexdigest[33];
challenge = g_malloc(strlen(buf + 2) + 1);
challenge_len = base64_decode(challenge, buf + 2, -1);
challenge[challenge_len] = '\0';
- log_print("IMAP< [Decoded: %s]\n", challenge);
g_free(buf);
+ log_print("IMAP< [Decoded: %s]\n", challenge);
md5_hex_hmac(hexdigest, challenge, challenge_len, pass, strlen(pass));
g_free(challenge);
return imap_cmd_ok(session, NULL);
}
-/* Send CAPABILITY, and examine the server's response to see whether this
- * connection is pre-authenticated or not and build a list of CAPABILITIES. */
-static gint imap_greeting(IMAPSession *session)
-{
- gchar *capstr;
- GPtrArray *argbuf;
-
- imap_gen_send(session, "CAPABILITY");
-
- argbuf = g_ptr_array_new();
-
- if (imap_cmd_ok(session, argbuf) != IMAP_SUCCESS ||
- ((capstr = search_array_str(argbuf, "CAPABILITY ")) == NULL)) {
- ptr_array_free_strings(argbuf);
- g_ptr_array_free(argbuf, TRUE);
- return -1;
- }
-
- session->authenticated = search_array_str(argbuf, "PREAUTH") != NULL;
-
- capstr += strlen("CAPABILITY ");
-
- IMAP_SESSION(session)->capability = g_strsplit(capstr, " ", 0);
-
- ptr_array_free_strings(argbuf);
- g_ptr_array_free(argbuf, TRUE);
-
- return 0;
-}
-
-static gboolean imap_has_capability(IMAPSession *session, const gchar *cap)
-{
- gchar **p;
-
- for (p = session->capability; *p != NULL; ++p)
- if (g_strcasecmp(*p, cap) == 0)
- return TRUE;
-
- return FALSE;
-}
-
-void imap_free_capabilities(IMAPSession *session)
-{
- g_strfreev(session->capability);
- session->capability = NULL;
-}
-
-static const IMAPSet numberlist_to_imapset(MsgNumberList *list)
-{
- static GString *imapset = NULL;
- static MsgNumberList *numlist, *elem;
- guint first, last, next;
-
- if (imapset == NULL)
- imapset = g_string_sized_new(256);
- else
- g_string_truncate(imapset, 0);
-
- if (list != NULL) {
- g_slist_free(numlist);
- numlist = g_slist_copy(list);
- numlist = g_slist_sort(numlist, g_int_compare);
- } else if (numlist == NULL) {
- return NULL;
- }
-
- first = GPOINTER_TO_INT(numlist->data);
- last = first;
- for(elem = g_slist_next(numlist); elem != NULL; elem = g_slist_next(elem)) {
- next = GPOINTER_TO_INT(elem->data);
-
- if(next != (last + 1)) {
- if (imapset->len > 0)
- g_string_append(imapset, ",");
- if (first == last)
- g_string_sprintfa(imapset, "%d", first);
- else
- g_string_sprintfa(imapset, "%d:%d", first, last);
-
- if (imapset->len > IMAPCMDLIMIT) {
- last = 0;
- break;
- }
-
- first = next;
- }
- last = next;
- }
- if (last != 0) {
- if (imapset->len > 0)
- g_string_append(imapset, ",");
- if (first == last)
- g_string_sprintfa(imapset, "%d", first);
- else
- g_string_sprintfa(imapset, "%d:%d", first, last);
-
- g_slist_free(numlist);
- numlist = NULL;
- } else {
- MsgNumberList *remaining;
-
- remaining = elem->next;
- remaining = g_slist_prepend(remaining, elem->data);
- elem->next = NULL;
- g_slist_free(numlist);
- numlist = remaining;
- }
-
- return imapset->str;
-}
-
static gint imap_cmd_noop(IMAPSession *session)
{
imap_gen_send(session, "NOOP");
return imap_cmd_ok(session, NULL);
}
-static gint imap_cmd_search(IMAPSession *session, const gchar *criteria, GSList **list)
+static gint imap_cmd_search(IMAPSession *session, const gchar *criteria,
+ GSList **list)
{
gint ok;
gchar *uidlist;
return IMAP_SUCCESS;
}
-static gint imap_cmd_fetch(IMAPSession *session, guint32 uid, const gchar *filename)
+static gint imap_cmd_fetch(IMAPSession *session, guint32 uid,
+ const gchar *filename)
{
gint ok;
- gchar *buf;
+ gchar *buf = NULL;
gchar *cur_pos;
gchar size_str[32];
glong size_num;
imap_gen_send(session, "UID FETCH %d BODY.PEEK[]", uid);
- while ((ok = imap_gen_recv(session, &buf))
- == IMAP_SUCCESS) {
+ while ((ok = imap_gen_recv(session, &buf)) == IMAP_SUCCESS) {
if (buf[0] != '*' || buf[1] != ' ') {
g_free(buf);
return IMAP_ERROR;
}
- if (strstr(buf, "FETCH") != NULL)
- break;
+ if (strstr(buf, "FETCH") != NULL) break;
g_free(buf);
}
if (ok != IMAP_SUCCESS) {
return ok;
}
- cur_pos = strchr(buf, '{');
- if (cur_pos == NULL) {
- g_free(buf);
- return IMAP_ERROR;
+#define RETURN_ERROR_IF_FAIL(cond) \
+ if (!(cond)) { \
+ g_free(buf); \
+ return IMAP_ERROR; \
}
+ cur_pos = strchr(buf, '{');
+ RETURN_ERROR_IF_FAIL(cur_pos != NULL);
cur_pos = strchr_cpy(cur_pos + 1, '}', size_str, sizeof(size_str));
- if (cur_pos == NULL) {
- g_free(buf);
- return IMAP_ERROR;
- }
+ RETURN_ERROR_IF_FAIL(cur_pos != NULL);
size_num = atol(size_str);
- g_return_val_if_fail(size_num > 0, IMAP_ERROR);
+ RETURN_ERROR_IF_FAIL(size_num >= 0);
- if (*cur_pos != '\0') {
- g_free(buf);
- return IMAP_ERROR;
- }
+ RETURN_ERROR_IF_FAIL(*cur_pos == '\0');
- if (recv_bytes_write_to_file(SESSION(session)->sock, size_num, filename) != 0) {
- g_free(buf);
+#undef RETURN_ERROR_IF_FAIL
+
+ g_free(buf);
+
+ if (recv_bytes_write_to_file(SESSION(session)->sock,
+ size_num, filename) != 0)
return IMAP_ERROR;
- }
if (imap_gen_recv(session, &buf) != IMAP_SUCCESS) {
g_free(buf);
g_free(buf);
return IMAP_ERROR;
}
-
g_free(buf);
+
ok = imap_cmd_ok(session, NULL);
return ok;
}
static gint imap_cmd_append(IMAPSession *session, const gchar *destfolder,
- const gchar *file, IMAPFlags flags, gint32 *new_uid)
+ const gchar *file, IMAPFlags flags,
+ guint32 *new_uid)
{
gint ok;
- gint size, newuid;
+ gint size;
gchar *destfolder_;
gchar *flag_str;
- gchar buf[BUFFSIZE], *imapbuf;
+ guint32 new_uid_;
+ gchar *ret = NULL;
+ gchar buf[BUFFSIZE];
FILE *fp;
- GPtrArray *reply;
- gchar *okmsginfo;
+ GPtrArray *argbuf;
+ gchar *resp_str;
g_return_val_if_fail(file != NULL, IMAP_ERROR);
destfolder_, flag_str, size);
g_free(flag_str);
- ok = imap_gen_recv(session, &imapbuf);
- if (ok != IMAP_SUCCESS || imapbuf[0] != '+' || imapbuf[1] != ' ') {
+ ok = imap_gen_recv(session, &ret);
+ if (ok != IMAP_SUCCESS || ret[0] != '+' || ret[1] != ' ') {
log_warning(_("can't append %s to %s\n"), file, destfolder_);
- g_free(imapbuf);
+ g_free(ret);
fclose(fp);
return IMAP_ERROR;
}
- g_free(imapbuf);
+ g_free(ret);
log_print("IMAP4> %s\n", _("(sending file...)"));
fclose(fp);
- reply = g_ptr_array_new();
+ if (new_uid != NULL)
+ *new_uid = 0;
+
+ if (new_uid != NULL && session->uidplus) {
+ argbuf = g_ptr_array_new();
+
+ ok = imap_cmd_ok(session, argbuf);
+ if ((ok == IMAP_SUCCESS) && (argbuf->len > 0)) {
+ resp_str = g_ptr_array_index(argbuf, argbuf->len - 1);
+ if (resp_str &&
+ sscanf(resp_str, "%*u OK [APPENDUID %*u %u]",
+ &new_uid_) == 1) {
+ *new_uid = new_uid_;
+ }
+ }
+
+ ptr_array_free_strings(argbuf);
+ g_ptr_array_free(argbuf, TRUE);
+ } else
+ ok = imap_cmd_ok(session, NULL);
- *new_uid = 0;
- ok = imap_cmd_ok(session, reply);
if (ok != IMAP_SUCCESS)
- log_warning(_("can't append message to %s\n"), destfolder_);
- else if (
- (new_uid != NULL) &&
- (imap_has_capability(session, "UIDPLUS") && reply->len > 0) &&
- ((okmsginfo = g_ptr_array_index(reply, reply->len - 1)) != NULL) &&
- (sscanf(okmsginfo, "%*u OK [APPENDUID %*u %u]", &newuid) == 1)) {
- *new_uid = newuid;
- }
+ log_warning(_("can't append message to %s\n"),
+ destfolder_);
- ptr_array_free_strings(reply);
- g_ptr_array_free(reply, TRUE);
return ok;
}
+static MsgNumberList *imapset_to_numlist(IMAPSet imapset)
+{
+ gchar **ranges, **range;
+ guint32 low, high;
+ MsgNumberList *uids = NULL;
+
+ ranges = g_strsplit(imapset, ",", 0);
+ for (range = ranges; *range != NULL; range++) {
+ printf("%s\n", *range);
+ if(sscanf(*range, "%u:%u", &low, &high) == 1)
+ uids = g_slist_prepend(uids, GINT_TO_POINTER(low));
+ else {
+ int i;
+ for (i = low; i <= high; i++)
+ uids = g_slist_prepend(uids, GINT_TO_POINTER(i));
+ }
+ }
+ uids = g_slist_reverse(uids);
+ g_strfreev(ranges);
+
+ return uids;
+}
-static gint imap_cmd_copy(IMAPSession * session,
- gint32 msgnum,
- const gchar * destfolder, gint32 * new_uid)
+static gint imap_cmd_copy(IMAPSession *session, const gchar *seq_set,
+ const gchar *destfolder, GRelation *uid_mapping)
{
gint ok;
- gint32 olduid, newuid;
- gchar *okmsginfo;
gchar *destfolder_;
- GPtrArray *reply;
-
- g_return_val_if_fail(destfolder != NULL, IMAP_ERROR);
+
g_return_val_if_fail(session != NULL, IMAP_ERROR);
- g_return_val_if_fail(new_uid != NULL, IMAP_ERROR);
+ g_return_val_if_fail(seq_set != NULL, IMAP_ERROR);
+ g_return_val_if_fail(destfolder != NULL, IMAP_ERROR);
QUOTE_IF_REQUIRED(destfolder_, destfolder);
- imap_gen_send(session, "UID COPY %d %s", msgnum, destfolder_);
+ imap_gen_send(session, "UID COPY %s %s", seq_set, destfolder_);
+
+ if (uid_mapping != NULL && session->uidplus) {
+ GPtrArray *reply;
+ gchar *resp_str = NULL, *olduids_str, *newuids_str;
+ MsgNumberList *olduids, *old_cur, *newuids, *new_cur;
+
+ reply = g_ptr_array_new();
+ ok = imap_cmd_ok(session, reply);
+ if ((ok == IMAP_SUCCESS) && (reply->len > 0)) {
+ resp_str = g_ptr_array_index(reply, reply->len - 1);
+ if (resp_str) {
+ olduids_str = g_new0(gchar, strlen(resp_str));
+ newuids_str = g_new0(gchar, strlen(resp_str));
+ if (sscanf(resp_str, "%*s OK [COPYUID %*u %[0-9,:] %[0-9,:]]",
+ olduids_str, newuids_str) == 2) {
+ olduids = imapset_to_numlist(olduids_str);
+ newuids = imapset_to_numlist(newuids_str);
+
+ old_cur = olduids;
+ new_cur = newuids;
+ while(old_cur != NULL && new_cur != NULL) {
+ g_relation_insert(uid_mapping,
+ GPOINTER_TO_INT(old_cur->data),
+ GPOINTER_TO_INT(new_cur->data));
+ old_cur = g_slist_next(old_cur);
+ new_cur = g_slist_next(new_cur);
+ }
- reply = g_ptr_array_new();
+ g_slist_free(olduids);
+ g_slist_free(newuids);
+ }
+ g_free(olduids_str);
+ g_free(newuids_str);
+ }
+ }
+ ptr_array_free_strings(reply);
+ g_ptr_array_free(reply, TRUE);
+ } else
+ ok = imap_cmd_ok(session, NULL);
- *new_uid = 0;
- ok = imap_cmd_ok(session, reply);
if (ok != IMAP_SUCCESS)
- log_warning(_("can't copy %d to %s\n"), msgnum, destfolder_);
- else if (imap_has_capability(session, "UIDPLUS") && reply->len > 0)
- if ((okmsginfo = g_ptr_array_index(reply, reply->len - 1)) != NULL &&
- sscanf(okmsginfo, "%*u OK [COPYUID %*u %u %u]", &olduid, &newuid) == 2 &&
- olduid == msgnum)
- *new_uid = newuid;
-
- ptr_array_free_strings(reply);
- g_ptr_array_free(reply, TRUE);
+ log_warning(_("can't copy %s to %s\n"), seq_set, destfolder_);
+
return ok;
}
return IMAP_SUCCESS;
}
-static gint imap_cmd_store(IMAPSession *session, IMAPSet set,
+static gint imap_cmd_store(IMAPSession *session, IMAPSet seq_set,
gchar *sub_cmd)
{
gint ok;
- imap_gen_send(session, "UID STORE %s %s",
- set, sub_cmd);
+ imap_gen_send(session, "UID STORE %s %s", seq_set, sub_cmd);
if ((ok = imap_cmd_ok(session, NULL)) != IMAP_SUCCESS) {
log_warning(_("error while imap command: STORE %s %s\n"),
- set, sub_cmd);
+ seq_set, sub_cmd);
return ok;
}
return IMAP_SUCCESS;
}
-static gint imap_cmd_expunge(IMAPSession *session)
+static gint imap_cmd_expunge(IMAPSession *session, IMAPSet seq_set)
{
gint ok;
- imap_gen_send(session, "EXPUNGE");
+ if (seq_set && session->uidplus)
+ imap_gen_send(session, "UID EXPUNGE %s", seq_set);
+ else
+ imap_gen_send(session, "EXPUNGE");
if ((ok = imap_cmd_ok(session, NULL)) != IMAP_SUCCESS) {
log_warning(_("error while imap command: EXPUNGE\n"));
return ok;
g_free(buf);
}
-static gint imap_gen_recv(IMAPSession *session, gchar **buf)
+static gint imap_gen_recv(IMAPSession *session, gchar **ret)
{
- if ((*buf = sock_getline(SESSION(session)->sock)) == NULL)
+ if ((*ret = sock_getline(SESSION(session)->sock)) == NULL)
return IMAP_SOCKET;
- strretchomp(*buf);
+ strretchomp(*ret);
- log_print("IMAP4< %s\n", *buf);
+ log_print("IMAP4< %s\n", *ret);
return IMAP_SUCCESS;
}
#endif /* !HAVE_ICONV */
}
+static GSList *imap_get_seq_set_from_numlist(MsgNumberList *numlist)
+{
+ GString *str;
+ GSList *sorted_list, *cur;
+ guint first, last, next;
+ gchar *ret_str;
+ GSList *ret_list = NULL;
+
+ if (numlist == NULL)
+ return NULL;
+
+ str = g_string_sized_new(256);
+
+ sorted_list = g_slist_copy(numlist);
+ sorted_list = g_slist_sort(sorted_list, g_int_compare);
+
+ first = GPOINTER_TO_INT(sorted_list->data);
+
+ for (cur = sorted_list; cur != NULL; cur = g_slist_next(cur)) {
+ last = GPOINTER_TO_INT(cur->data);
+ if (cur->next)
+ next = GPOINTER_TO_INT(cur->next->data);
+ else
+ next = 0;
+
+ if (last + 1 != next || next == 0) {
+ if (str->len > 0)
+ g_string_append_c(str, ',');
+ if (first == last)
+ g_string_sprintfa(str, "%u", first);
+ else
+ g_string_sprintfa(str, "%u:%u", first, last);
+
+ first = next;
+
+ if (str->len > IMAP_CMD_LIMIT) {
+ ret_str = g_strdup(str->str);
+ ret_list = g_slist_append(ret_list, ret_str);
+ g_string_truncate(str, 0);
+ }
+ }
+ }
+
+ if (str->len > 0) {
+ ret_str = g_strdup(str->str);
+ ret_list = g_slist_append(ret_list, ret_str);
+ }
+
+ g_slist_free(sorted_list);
+ g_string_free(str, TRUE);
+
+ return ret_list;
+}
+
+static GSList *imap_get_seq_set_from_msglist(MsgInfoList *msglist)
+{
+ MsgNumberList *numlist = NULL;
+ MsgInfoList *cur;
+ GSList *seq_list;
+
+ 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));
+ }
+ seq_list = imap_get_seq_set_from_numlist(numlist);
+ g_slist_free(numlist);
+
+ return seq_list;
+}
+
+static void imap_seq_set_free(GSList *seq_list)
+{
+ slist_free_strings(seq_list);
+ g_slist_free(seq_list);
+}
+
+
static gboolean imap_rename_folder_func(GNode *node, gpointer data)
{
FolderItem *item = node->data;
return nummsgs;
}
-gint imap_get_num_list(Folder *folder, FolderItem *_item, GSList **msgnum_list)
+gint imap_get_num_list(Folder *folder, FolderItem *_item, GSList **msgnum_list, gboolean *old_uids_valid)
{
IMAPFolderItem *item = (IMAPFolderItem *)_item;
IMAPSession *session;
- gint ok, nummsgs = 0, exists, recent, unseen, uid_val, uid_next;
+ gint ok, nummsgs = 0, exists, recent, uid_val, uid_next, unseen;
GSList *uidlist;
gchar *dir;
gboolean selected_folder;
if (ok != IMAP_SUCCESS)
return -1;
exists = session->exists;
+
+ *old_uids_valid = TRUE;
} else {
ok = imap_status(session, IMAP_FOLDER(folder), item->item.path,
&exists, &recent, &uid_next, &uid_val, &unseen);
if (ok != IMAP_SUCCESS)
return -1;
+
+ if(item->item.mtime == uid_val)
+ *old_uids_valid = TRUE;
+ else {
+ *old_uids_valid = FALSE;
+
+ debug_print("Freeing imap uid cache\n");
+ item->lastuid = 0;
+ g_slist_free(item->uid_list);
+ item->uid_list = NULL;
+
+ item->item.mtime = uid_val;
+
+ imap_delete_all_cached_messages((FolderItem *)item);
+ }
}
+ 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) ||
item->uid_list = NULL;
}
}
- if (!selected_folder)
- item->uid_next = uid_next;
if (exists == 0) {
*msgnum_list = NULL;
return msginfo;
}
-gboolean imap_check_msgnum_validity(Folder *folder, FolderItem *_item)
+gboolean imap_scan_required(Folder *folder, FolderItem *_item)
{
IMAPSession *session;
IMAPFolderItem *item = (IMAPFolderItem *)_item;
gint ok, exists = 0, recent = 0, unseen = 0;
- guint32 uid_next, uid_validity = 0;
+ guint32 uid_next, uid_val = 0;
+ gboolean selected_folder;
g_return_val_if_fail(folder != NULL, FALSE);
g_return_val_if_fail(item != NULL, FALSE);
g_return_val_if_fail(item->item.folder != NULL, FALSE);
g_return_val_if_fail(FOLDER_CLASS(item->item.folder) == &imap_class, FALSE);
+ if (item->item.path == NULL)
+ return FALSE;
+
session = imap_session_get(folder);
g_return_val_if_fail(session != NULL, FALSE);
- ok = imap_status(session, IMAP_FOLDER(folder), item->item.path,
- &exists, &recent, &uid_next, &uid_validity, &unseen);
- if (ok != IMAP_SUCCESS)
- return FALSE;
-
- if(item->item.mtime == uid_validity)
- return TRUE;
+ selected_folder = (session->mbox != NULL) &&
+ (!strcmp(session->mbox, item->item.path));
+ if (selected_folder) {
+ ok = imap_cmd_noop(session);
+ if (ok != IMAP_SUCCESS)
+ return FALSE;
- debug_print("Freeing imap uid cache\n");
- item->lastuid = 0;
- g_slist_free(item->uid_list);
- item->uid_list = NULL;
-
- item->item.mtime = uid_validity;
+ if (session->folder_content_changed)
+ return TRUE;
+ } else {
+ ok = imap_status(session, IMAP_FOLDER(folder), item->item.path,
+ &exists, &recent, &uid_next, &uid_val, &unseen);
+ if (ok != IMAP_SUCCESS)
+ return FALSE;
- imap_delete_all_cached_messages((FolderItem *)item);
+ if ((uid_next != item->uid_next) || (exists < item->item.total_msgs))
+ return TRUE;
+ }
return FALSE;
}
projects / claws.git / blobdiff