#include <stdlib.h>
#include <dirent.h>
#include <unistd.h>
+#include <ctype.h>
#include "intl.h"
#include "imap.h"
static gint imap_cmd_count = 0;
-static IMAPSession *imap_session_connect_if_not (Folder *folder);
+static IMAPSession *imap_session_get (Folder *folder);
static gint imap_do_copy (Folder *folder,
FolderItem *dest,
MsgInfo *msginfo,
gboolean remove_source);
static gint imap_do_copy_msgs_with_dest (Folder *folder,
- FolderItem *dest,
+ FolderItem *dest,
GSList *msglist,
gboolean remove_source);
static GSList *imap_get_uncached_messages (IMAPSession *session,
FolderItem *item,
- gint first,
- gint last);
+ guint32 first_uid,
+ guint32 last_uid);
static GSList *imap_delete_cached_messages (GSList *mlist,
- gint first,
- gint last);
+ FolderItem *item,
+ guint32 first_uid,
+ guint32 last_uid);
static void imap_delete_all_cached_messages (FolderItem *item);
static SockInfo *imap_open (const gchar *server,
gushort port,
gchar *buf);
-static gint imap_set_article_flags (IMAPSession *session,
- gint first,
- gint last,
+static gint imap_set_message_flags (IMAPSession *session,
+ guint32 first_uid,
+ guint32 last_uid,
IMAPFlags flag,
gboolean is_set);
+static gint imap_select (IMAPSession *session,
+ IMAPFolder *folder,
+ const gchar *path,
+ gint *exists,
+ gint *recent,
+ gint *unseen,
+ guint32 *uid_validity);
+static gint imap_get_uid (IMAPSession *session,
+ gint msgnum,
+ guint32 *uid);
+#if 0
+static gint imap_status_uidnext (IMAPSession *session,
+ IMAPFolder *folder,
+ const gchar *path,
+ guint32 *uid_next);
+#endif
-static gchar *imap_parse_atom (SockInfo *sock,
- gchar *src,
- gchar *dest,
- gchar *orig_buf);
-static gchar *imap_parse_one_address (SockInfo *sock,
- gchar *start,
- gchar *out_from_str,
- gchar *out_fromname_str,
- gchar *orig_buf);
-static gchar *imap_parse_address (SockInfo *sock,
- gchar *start,
- gchar **out_from_str,
- gchar **out_fromname_str,
- gchar *orig_buf);
+static void imap_parse_namespace (IMAPSession *session,
+ IMAPFolder *folder);
+static IMAPNameSpace *imap_find_namespace (IMAPFolder *folder,
+ const gchar *path);
+
+static gchar *imap_parse_atom (SockInfo *sock,
+ gchar *src,
+ gchar *dest,
+ gchar *orig_buf);
+static gchar *imap_parse_one_address (SockInfo *sock,
+ gchar *start,
+ gchar *out_from_str,
+ gchar *out_fromname_str,
+ gchar *orig_buf);
+static gchar *imap_parse_address (SockInfo *sock,
+ gchar *start,
+ gchar **out_from_str,
+ gchar **out_fromname_str,
+ gchar *orig_buf);
static MsgFlags imap_parse_flags (const gchar *flag_str);
-static MsgInfo *imap_parse_envelope (SockInfo *sock,
- gchar *line_str);
+static MsgInfo *imap_parse_envelope (SockInfo *sock,
+ gchar *line_str);
/* low-level IMAP4rev1 commands */
static gint imap_cmd_login (SockInfo *sock,
const gchar *pass);
static gint imap_cmd_logout (SockInfo *sock);
static gint imap_cmd_noop (SockInfo *sock);
+static gint imap_cmd_namespace (SockInfo *sock,
+ gchar **ns_str);
static gint imap_cmd_select (SockInfo *sock,
const gchar *folder,
gint *exists,
gint *recent,
gint *unseen,
- gulong *uid);
+ guint32 *uid_validity);
static gint imap_cmd_status (SockInfo *sock,
const gchar *folder,
- const gchar *status);
+ const gchar *status,
+ gint *value);
static gint imap_cmd_create (SockInfo *sock,
const gchar *folder);
static gint imap_cmd_delete (SockInfo *sock,
const gchar *folder);
static gint imap_cmd_envelope (SockInfo *sock,
- gint first,
- gint last);
+ guint32 first_uid,
+ guint32 last_uid);
#if 0
static gint imap_cmd_search (SockInfo *sock,
GSList *numlist);
#endif
static gint imap_cmd_fetch (SockInfo *sock,
- gint num,
+ guint32 uid,
const gchar *filename);
static gint imap_cmd_append (SockInfo *sock,
const gchar *destfolder,
const gchar *file);
static gint imap_cmd_copy (SockInfo *sock,
- gint num,
+ guint32 uid,
const gchar *destfolder);
static gint imap_cmd_store (SockInfo *sock,
- gint first,
- gint last,
+ guint32 first_uid,
+ guint32 last_uid,
gchar *sub_cmd);
static gint imap_cmd_expunge (SockInfo *sock);
gint size);
/* misc utility functions */
-static gchar *strchr_cpy (const gchar *src,
- gchar ch,
- gchar *dest,
- gint len);
-static gchar *search_array_contain_str (GPtrArray *array,
- gchar *str);
-static void imap_path_subst_slash_to_dot(gchar *str);
-
-
-static IMAPSession *imap_session_connect_if_not(Folder *folder)
+static gchar *strchr_cpy (const gchar *src,
+ gchar ch,
+ gchar *dest,
+ gint len);
+static gchar *search_array_contain_str (GPtrArray *array,
+ gchar *str);
+static void imap_path_separator_subst (gchar *str,
+ gchar separator);
+
+static IMAPSession *imap_session_get(Folder *folder)
{
RemoteFolder *rfolder = REMOTE_FOLDER(folder);
IMAP4_PORT,
folder->account->userid,
folder->account->passwd);
+ if (rfolder->session)
+ imap_parse_namespace(IMAP_SESSION(rfolder->session),
+ IMAP_FOLDER(folder));
statusbar_pop_all();
return IMAP_SESSION(rfolder->session);
}
imap_session_new(folder->account->recv_server,
IMAP4_PORT, folder->account->userid,
folder->account->passwd);
+ if (rfolder->session)
+ imap_parse_namespace(IMAP_SESSION(rfolder->session),
+ IMAP_FOLDER(folder));
}
statusbar_pop_all();
}
}
+#define THROW goto catch
+
GSList *imap_get_msg_list(Folder *folder, FolderItem *item, gboolean use_cache)
{
GSList *mlist = NULL;
IMAPSession *session;
- gint ok, exists = 0, recent = 0, unseen = 0, begin = 1;
- gulong uid = 0, last_uid;
+ gint ok, exists = 0, recent = 0, unseen = 0;
+ guint32 uid_validity = 0;
+ guint32 first_uid = 0, last_uid = 0, begin;
g_return_val_if_fail(folder != NULL, NULL);
g_return_val_if_fail(item != NULL, NULL);
g_return_val_if_fail(folder->type == F_IMAP, NULL);
g_return_val_if_fail(folder->account != NULL, NULL);
- session = imap_session_connect_if_not(folder);
+ session = imap_session_get(folder);
if (!session) {
mlist = procmsg_read_cache(item, FALSE);
return mlist;
}
- last_uid = item->mtime;
-
- ok = imap_cmd_select(SESSION(session)->sock, item->path,
- &exists, &recent, &unseen, &uid);
- if (ok != IMAP_SUCCESS) {
- log_warning(_("can't select folder: %s\n"), item->path);
+ ok = imap_select(session, IMAP_FOLDER(folder), item->path,
+ &exists, &recent, &unseen, &uid_validity);
+ if (ok != IMAP_SUCCESS) THROW;
+ if (exists > 0) {
+ ok = imap_get_uid(session, 1, &first_uid);
+ if (ok != IMAP_SUCCESS) THROW;
+ if (1 != exists) {
+ ok = imap_get_uid(session, exists, &last_uid);
+ if (ok != IMAP_SUCCESS) THROW;
+ } else
+ last_uid = first_uid;
+ } else {
+ imap_delete_all_cached_messages(item);
statusbar_pop_all();
return NULL;
}
if (use_cache) {
- gint cache_last;
+ guint32 cache_last;
mlist = procmsg_read_cache(item, FALSE);
procmsg_set_flags(mlist, item);
cache_last = procmsg_get_last_num_in_cache(mlist);
/* calculating the range of envelope to get */
- if (exists < cache_last) {
- /* some messages are deleted (get all) */
- begin = 1;
- } else if (exists == cache_last) {
- if (last_uid != 0 && last_uid != uid) {
- /* some recent but deleted (get all) */
- begin = 1;
- } else {
- /* mailbox unchanged (get none)*/
- begin = -1;
- }
+ if (item->mtime != uid_validity) {
+ /* mailbox is changed (get all) */
+ begin = first_uid;
+ } else if (last_uid < cache_last) {
+ /* mailbox is changed (get all) */
+ begin = first_uid;
+ } else if (last_uid == cache_last) {
+ /* mailbox unchanged (get none)*/
+ begin = 0;
} else {
- if (exists == cache_last + recent) {
- /* some recent */
- begin = cache_last + 1;
- } else {
- /* some recent but deleted (get all) */
- begin = 1;
- }
+ begin = cache_last + 1;
}
- item->mtime = uid;
+ item->mtime = uid_validity;
+
+ if (first_uid > 0 && last_uid > 0) {
+ mlist = imap_delete_cached_messages(mlist, item,
+ 0, first_uid - 1);
+ mlist = imap_delete_cached_messages(mlist, item,
+ last_uid + 1,
+ UINT_MAX);
+ }
+ if (begin > 0)
+ mlist = imap_delete_cached_messages(mlist, item,
+ begin, UINT_MAX);
+ } else {
+ imap_delete_all_cached_messages(item);
+ begin = first_uid;
}
- if (1 < begin && begin <= exists) {
+ if (begin > 0 && begin <= last_uid) {
GSList *newlist;
-
- newlist = imap_get_uncached_messages
- (session, item, begin, exists);
- imap_delete_cached_messages(mlist, begin, INT_MAX);
+ newlist = imap_get_uncached_messages(session, item,
+ begin, last_uid);
mlist = g_slist_concat(mlist, newlist);
- } else if (begin == 1) {
- if (begin <= exists)
- mlist = imap_get_uncached_messages
- (session, item, begin, exists);
- imap_delete_all_cached_messages(item);
}
- item->last_num = exists;
+ item->last_num = last_uid;
+catch:
statusbar_pop_all();
-
return mlist;
}
-gchar *imap_fetch_msg(Folder *folder, FolderItem *item, gint num)
+#undef THROW
+
+gchar *imap_fetch_msg(Folder *folder, FolderItem *item, gint uid)
{
gchar *path, *filename;
IMAPSession *session;
g_return_val_if_fail(folder != NULL, NULL);
g_return_val_if_fail(item != NULL, NULL);
- session = imap_session_connect_if_not(folder);
-
path = folder_item_get_path(item);
- filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(num), NULL);
+ 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"), num);
+ debug_print(_("message %d has been already cached.\n"), uid);
return filename;
}
+ session = imap_session_get(folder);
if (!session) {
g_free(filename);
return NULL;
}
- debug_print(_("getting message %d...\n"), num);
- ok = imap_cmd_fetch(SESSION(session)->sock, num, filename);
+ debug_print(_("getting message %d...\n"), uid);
+ ok = imap_cmd_fetch(SESSION(session)->sock, (guint32)uid, filename);
statusbar_pop_all();
if (ok != IMAP_SUCCESS) {
- g_warning(_("can't fetch message %d\n"), num);
+ g_warning(_("can't fetch message %d\n"), uid);
g_free(filename);
return NULL;
}
g_return_val_if_fail(dest != NULL, -1);
g_return_val_if_fail(file != NULL, -1);
- session = imap_session_connect_if_not(folder);
+ session = imap_session_get(folder);
if (!session)
return -1;
{
gchar *destdir;
IMAPSession *session;
+ IMAPNameSpace *namespace;
+ gint ok;
g_return_val_if_fail(folder != NULL, -1);
+ g_return_val_if_fail(folder->type == F_IMAP, -1);
g_return_val_if_fail(dest != NULL, -1);
g_return_val_if_fail(msginfo != NULL, -1);
- session = imap_session_connect_if_not(folder);
+ session = imap_session_get(folder);
if (!session) return -1;
if (msginfo->folder == dest) {
}
Xstrdup_a(destdir, dest->path, return -1);
- /* imap_path_subst_slash_to_dot(destdir); */
+ namespace = imap_find_namespace(IMAP_FOLDER(folder), destdir);
+ if (namespace && namespace->separator)
+ imap_path_separator_subst(destdir, namespace->separator);
- debug_print(_("%s message %s%c%d to %s ...\n"),
- remove_source ? "Moving" : "Copying",
- msginfo->folder->path, G_DIR_SEPARATOR,
- msginfo->msgnum, destdir);
+ 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);
- imap_cmd_copy(SESSION(session)->sock, msginfo->msgnum, destdir);
+ ok = imap_cmd_copy(SESSION(session)->sock, msginfo->msgnum, destdir);
- if (remove_source) {
- imap_set_article_flags(session, msginfo->msgnum, msginfo->msgnum,
+ if (ok == IMAP_SUCCESS && remove_source) {
+ imap_set_message_flags(session, msginfo->msgnum, msginfo->msgnum,
IMAP_FLAG_DELETED, TRUE);
imap_cmd_expunge(SESSION(session)->sock);
}
- return IMAP_SUCCESS;
+ statusbar_pop_all();
+ return ok;
}
-static gint imap_do_copy_msgs_with_dest(Folder *folder, FolderItem *dest,
+static gint imap_do_copy_msgs_with_dest(Folder *folder, FolderItem *dest,
GSList *msglist,
gboolean remove_source)
{
GSList *cur;
MsgInfo *msginfo;
IMAPSession *session;
+ IMAPNameSpace *namespace;
+ gint ok;
g_return_val_if_fail(folder != NULL, -1);
g_return_val_if_fail(dest != NULL, -1);
g_return_val_if_fail(msglist != NULL, -1);
- session = imap_session_connect_if_not(folder);
+ session = imap_session_get(folder);
if (!session) return -1;
Xstrdup_a(destdir, dest->path, return -1);
- /* imap_path_subst_slash_to_dot(destdir); */
+ namespace = imap_find_namespace(IMAP_FOLDER(folder), destdir);
+ if (namespace && namespace->separator)
+ imap_path_separator_subst(destdir, namespace->separator);
for (cur = msglist; cur != NULL; cur = cur->next) {
msginfo = (MsgInfo *)cur->data;
continue;
}
- debug_print(_("%s message %s%c%d to %s ...\n"),
- remove_source ? "Moving" : "Copying",
- msginfo->folder->path, G_DIR_SEPARATOR,
- msginfo->msgnum, destdir);
+ 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);
- imap_cmd_copy(SESSION(session)->sock, msginfo->msgnum,
- destdir);
+ ok = imap_cmd_copy(SESSION(session)->sock, msginfo->msgnum,
+ destdir);
- if (remove_source) {
- imap_set_article_flags
+ if (ok == IMAP_SUCCESS && remove_source) {
+ imap_set_message_flags
(session, msginfo->msgnum, msginfo->msgnum,
IMAP_FLAG_DELETED, TRUE);
}
if (remove_source)
imap_cmd_expunge(SESSION(session)->sock);
+ statusbar_pop_all();
return IMAP_SUCCESS;
-
}
gint imap_move_msg(Folder *folder, FolderItem *dest, MsgInfo *msginfo)
return imap_do_copy(folder, dest, msginfo, TRUE);
}
-gint imap_move_msgs_with_dest(Folder *folder, FolderItem *dest,
+gint imap_move_msgs_with_dest(Folder *folder, FolderItem *dest,
GSList *msglist)
{
return imap_do_copy_msgs_with_dest(folder, dest, msglist, TRUE);
return imap_do_copy(folder, dest, msginfo, FALSE);
}
-gint imap_copy_msgs_with_dest(Folder *folder, FolderItem *dest,
+gint imap_copy_msgs_with_dest(Folder *folder, FolderItem *dest,
GSList *msglist)
{
return imap_do_copy_msgs_with_dest(folder, dest, msglist, FALSE);
}
-gint imap_remove_msg(Folder *folder, FolderItem *item, gint num)
+gint imap_remove_msg(Folder *folder, FolderItem *item, gint uid)
{
gint exists, recent, unseen;
- gulong uid;
+ guint32 uid_validity;
gint ok;
IMAPSession *session;
g_return_val_if_fail(folder != NULL, -1);
+ g_return_val_if_fail(folder->type == F_IMAP, -1);
g_return_val_if_fail(item != NULL, -1);
- g_return_val_if_fail(num > 0 && num <= item->last_num, -1);
- session = imap_session_connect_if_not(folder);
+ session = imap_session_get(folder);
if (!session) return -1;
- ok = imap_cmd_select(SESSION(session)->sock, item->path,
- &exists, &recent, &unseen, &uid);
- if (ok != IMAP_SUCCESS) {
- log_warning(_("can't select folder: %s\n"), item->path);
+ ok = imap_select(session, IMAP_FOLDER(folder), item->path,
+ &exists, &recent, &unseen, &uid_validity);
+ statusbar_pop_all();
+ if (ok != IMAP_SUCCESS)
return ok;
- }
- ok = imap_set_article_flags(IMAP_SESSION(REMOTE_FOLDER(folder)->session),
- num, num, IMAP_FLAG_DELETED, TRUE);
+ ok = imap_set_message_flags
+ (IMAP_SESSION(REMOTE_FOLDER(folder)->session),
+ (guint32)uid, (guint32)uid, IMAP_FLAG_DELETED, TRUE);
+ statusbar_pop_all();
if (ok != IMAP_SUCCESS) {
- log_warning(_("can't set deleted flags: %d\n"), num);
+ log_warning(_("can't set deleted flags: %d\n"), uid);
return ok;
}
ok = imap_cmd_expunge(SESSION(session)->sock);
+ statusbar_pop_all();
if (ok != IMAP_SUCCESS) {
log_warning(_("can't expunge\n"));
return ok;
gint imap_remove_all_msg(Folder *folder, FolderItem *item)
{
gint exists, recent, unseen;
- gulong uid;
+ guint32 uid_validity;
gint ok;
IMAPSession *session;
g_return_val_if_fail(folder != NULL, -1);
g_return_val_if_fail(item != NULL, -1);
- session = imap_session_connect_if_not(folder);
+ session = imap_session_get(folder);
if (!session) return -1;
- ok = imap_cmd_select(SESSION(session)->sock, item->path,
- &exists, &recent, &unseen, &uid);
- if (ok != IMAP_SUCCESS) {
- log_warning(_("can't select folder: %s\n"), item->path);
+ ok = imap_select(session, IMAP_FOLDER(folder), item->path,
+ &exists, &recent, &unseen, &uid_validity);
+ statusbar_pop_all();
+ if (ok != IMAP_SUCCESS)
return ok;
- }
+ if (exists == 0)
+ return IMAP_SUCCESS;
- ok = imap_set_article_flags(session, 1, exists,
+ ok = imap_set_message_flags(session, 1, exists,
IMAP_FLAG_DELETED, TRUE);
+ statusbar_pop_all();
if (ok != IMAP_SUCCESS) {
log_warning(_("can't set deleted flags: 1:%d\n"), exists);
return ok;
}
ok = imap_cmd_expunge(SESSION(session)->sock);
+ statusbar_pop_all();
if (ok != IMAP_SUCCESS) {
log_warning(_("can't expunge\n"));
return ok;
{
}
+gint imap_create_tree(Folder *folder)
+{
+ IMAPFolder *imapfolder = IMAP_FOLDER(folder);
+ FolderItem *item;
+ FolderItem *new_item;
+ gchar *trash_path;
+
+ g_return_val_if_fail(folder != NULL, -1);
+ g_return_val_if_fail(folder->node != NULL, -1);
+ g_return_val_if_fail(folder->node->data != NULL, -1);
+
+ imap_session_get(folder);
+
+ item = FOLDER_ITEM(folder->node->data);
+
+ new_item = folder_item_new("INBOX", "INBOX");
+ new_item->stype = F_INBOX;
+ folder_item_append(item, new_item);
+ folder->inbox = new_item;
+
+ if (imapfolder->namespace && imapfolder->namespace->data) {
+ IMAPNameSpace *namespace;
+
+ namespace = (IMAPNameSpace *)imapfolder->namespace->data;
+ if (*namespace->name == '\0')
+ trash_path = g_strdup("trash");
+ else {
+ gchar *name;
+
+ Xstrdup_a(name, namespace->name, return -1);
+ strtailchomp(name, namespace->separator);
+ trash_path = g_strdup_printf
+ ("%s%c%s",
+ name, namespace->separator, "trash");
+ }
+ } else
+ trash_path = g_strdup("trash");
+
+ new_item = imap_create_folder(folder, item, trash_path);
+
+ if (!new_item) {
+ new_item = folder_item_new("Trash", trash_path);
+ folder_item_append(item, new_item);
+ } else {
+ g_free(new_item->name);
+ new_item->name = g_strdup("Trash");
+ }
+ new_item->stype = F_TRASH;
+ folder->trash = new_item;
+
+ g_free(trash_path);
+ return 0;
+}
+
FolderItem *imap_create_folder(Folder *folder, FolderItem *parent,
const gchar *name)
{
gchar *dirpath, *imappath;
IMAPSession *session;
+ IMAPNameSpace *namespace;
FolderItem *new_item;
+ gchar *new_name;
gint ok;
g_return_val_if_fail(folder != NULL, NULL);
g_return_val_if_fail(parent != NULL, NULL);
g_return_val_if_fail(name != NULL, NULL);
- session = imap_session_connect_if_not(folder);
+ session = imap_session_get(folder);
if (!session) return NULL;
if (parent->path)
else
dirpath = g_strdup(name);
- imappath = g_strdup(dirpath);
- /* imap_path_subst_slash_to_dot(imappath); */
+ Xstrdup_a(imappath, dirpath, {g_free(dirpath); return NULL;});
+ Xstrdup_a(new_name, name, {g_free(dirpath); return NULL;});
+ namespace = imap_find_namespace(IMAP_FOLDER(folder), imappath);
+ if (namespace && namespace->separator) {
+ imap_path_separator_subst(imappath, namespace->separator);
+ imap_path_separator_subst(new_name, namespace->separator);
+ strtailchomp(dirpath, '/');
+ strtailchomp(new_name, namespace->separator);
+ }
if (strcmp(name, "INBOX") != 0) {
ok = imap_cmd_status(SESSION(session)->sock, imappath,
- "MESSAGES");
+ "MESSAGES", NULL);
if (ok != IMAP_SUCCESS) {
ok = imap_cmd_create(SESSION(session)->sock, imappath);
statusbar_pop_all();
if (ok != IMAP_SUCCESS) {
log_warning(_("can't create mailbox\n"));
- g_free(imappath);
g_free(dirpath);
return NULL;
}
statusbar_pop_all();
}
- new_item = folder_item_new(name, dirpath);
+ new_item = folder_item_new(new_name, dirpath);
folder_item_append(parent, new_item);
- g_free(imappath);
g_free(dirpath);
return new_item;
{
gint ok;
IMAPSession *session;
+ IMAPNameSpace *namespace;
+ gchar *path;
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_connect_if_not(folder);
+ session = imap_session_get(folder);
if (!session) return -1;
- ok = imap_cmd_delete(SESSION(session)->sock, item->path);
+ Xstrdup_a(path, item->path, return -1);
+ namespace = imap_find_namespace(IMAP_FOLDER(folder), path);
+ if (namespace && namespace->separator)
+ imap_path_separator_subst(path, namespace->separator);
+
+ ok = imap_cmd_delete(SESSION(session)->sock, path);
statusbar_pop_all();
if (ok != IMAP_SUCCESS) {
log_warning(_("can't delete mailbox\n"));
static GSList *imap_get_uncached_messages(IMAPSession *session,
FolderItem *item,
- gint first, gint last)
+ guint32 first_uid, guint32 last_uid)
{
gchar buf[IMAPBUFSIZE];
GSList *newlist = NULL;
g_return_val_if_fail(item != NULL, NULL);
g_return_val_if_fail(item->folder != NULL, NULL);
g_return_val_if_fail(item->folder->type == F_IMAP, NULL);
- g_return_val_if_fail(first <= last, NULL);
+ g_return_val_if_fail(first_uid <= last_uid, NULL);
- if (imap_cmd_envelope(SESSION(session)->sock, first, last)
+ if (imap_cmd_envelope(SESSION(session)->sock, first_uid, last_uid)
!= IMAP_SUCCESS) {
log_warning(_("can't get envelope\n"));
return NULL;
return newlist;
}
-static GSList *imap_delete_cached_messages(GSList *mlist,
- gint first, gint last)
+static GSList *imap_delete_cached_messages(GSList *mlist, FolderItem *item,
+ guint32 first_uid, guint32 last_uid)
{
GSList *cur, *next;
MsgInfo *msginfo;
- gchar *cache_file;
+ gchar *dir;
+
+ g_return_val_if_fail(item != NULL, mlist);
+ g_return_val_if_fail(item->folder != NULL, mlist);
+ g_return_val_if_fail(item->folder->type == F_IMAP, mlist);
+
+ debug_print(_("Deleting cached messages %d - %d ... "),
+ first_uid, last_uid);
+
+ dir = folder_item_get_path(item);
+ remove_numbered_files(dir, first_uid, last_uid);
+ g_free(dir);
for (cur = mlist; cur != NULL; ) {
next = cur->next;
msginfo = (MsgInfo *)cur->data;
- if (msginfo != NULL && first <= msginfo->msgnum &&
- msginfo->msgnum <= last) {
- debug_print(_("deleting message %d...\n"),
- msginfo->msgnum);
-
- cache_file = procmsg_get_message_file_path(msginfo);
- if (is_file_exist(cache_file)) unlink(cache_file);
- g_free(cache_file);
-
+ if (msginfo != NULL && first_uid <= msginfo->msgnum &&
+ msginfo->msgnum <= last_uid) {
procmsg_msginfo_free(msginfo);
mlist = g_slist_remove(mlist, msginfo);
}
cur = next;
}
+ debug_print(_("done.\n"));
+
return mlist;
}
g_return_if_fail(item->folder != NULL);
g_return_if_fail(item->folder->type == F_IMAP);
- debug_print(_("\tDeleting all cached messages... "));
+ debug_print(_("Deleting all cached messages... "));
dir = folder_item_get_path(item);
remove_all_numbered_files(dir);
return sock;
}
+#define THROW goto catch
+
+static void imap_parse_namespace(IMAPSession *session, IMAPFolder *folder)
+{
+ gchar *ns_str;
+ gchar *name;
+ gchar *separator;
+ gchar *p;
+ IMAPNameSpace *namespace;
+ GList *ns_list = NULL;
+
+ g_return_if_fail(session != NULL);
+ g_return_if_fail(folder != NULL);
+
+ if (folder->namespace != NULL) return;
+
+ if (imap_cmd_namespace(SESSION(session)->sock, &ns_str)
+ != IMAP_SUCCESS) {
+ log_warning(_("can't get namespace\n"));
+ return;
+ }
+
+ /* get the first element */
+ extract_one_parenthesis_with_skip_quote(ns_str, '"', '(', ')');
+ g_strstrip(ns_str);
+ p = ns_str;
+
+ while (*p != '\0') {
+ /* parse ("#foo" "/") */
+
+ while (*p && *p != '(') p++;
+ if (*p == '\0') THROW;
+ p++;
+
+ while (*p && *p != '"') p++;
+ if (*p == '\0') THROW;
+ p++;
+ name = p;
+
+ while (*p && *p != '"') p++;
+ if (*p == '\0') THROW;
+ *p = '\0';
+ p++;
+
+ while (*p && isspace(*p)) p++;
+ if (*p == '\0') THROW;
+ if (strncmp(p, "NIL", 3) == 0)
+ separator = NULL;
+ else if (*p == '"') {
+ p++;
+ separator = p;
+ while (*p && *p != '"') p++;
+ if (*p == '\0') THROW;
+ *p = '\0';
+ p++;
+ } else THROW;
+
+ while (*p && *p != ')') p++;
+ if (*p == '\0') THROW;
+ p++;
+
+ namespace = g_new(IMAPNameSpace, 1);
+ namespace->name = g_strdup(name);
+ namespace->separator = separator ? separator[0] : '\0';
+ ns_list = g_list_append(ns_list, namespace);
+ IMAP_FOLDER(folder)->namespace = ns_list;
+ }
+
+catch:
+ g_free(ns_str);
+ return;
+}
+
+#undef THROW
+
+static IMAPNameSpace *imap_find_namespace(IMAPFolder *folder,
+ const gchar *path)
+{
+ IMAPNameSpace *namespace = NULL;
+ GList *ns_list;
+ gchar *name;
+
+ g_return_val_if_fail(folder != NULL, NULL);
+ g_return_val_if_fail(path != NULL, NULL);
+
+ ns_list = folder->namespace;
+
+ for (; ns_list != NULL; ns_list = ns_list->next) {
+ IMAPNameSpace *tmp_ns = ns_list->data;
+
+ Xstrdup_a(name, tmp_ns->name, return namespace);
+ if (tmp_ns->separator && tmp_ns->separator != '/')
+ subst_char(name, tmp_ns->separator, '/');
+ if (strncmp(path, name, strlen(name)) == 0)
+ namespace = tmp_ns;
+ }
+
+ return namespace;
+}
+
static gchar *imap_parse_atom(SockInfo *sock, gchar *src, gchar *dest,
gchar *orig_buf)
{
gchar *orig_buf)
{
gchar buf[IMAPBUFSIZE];
+ gchar *userid;
+ gchar *domain;
gchar *cur_pos = start;
cur_pos = imap_parse_atom(sock, cur_pos, buf, orig_buf);
- conv_unmime_header(out_fromname_str, 256, buf, NULL);
-
- if (out_fromname_str[0] != '\0') {
- strcat(out_from_str, "\"");
- strcat(out_from_str, out_fromname_str);
- strcat(out_from_str, "\"");
- }
+ conv_unmime_header(out_fromname_str, IMAPBUFSIZE, buf, NULL);
cur_pos = imap_parse_atom(sock, cur_pos, buf, orig_buf);
- strcat(out_from_str, " <");
-
cur_pos = imap_parse_atom(sock, cur_pos, buf, orig_buf);
- strcat(out_from_str, buf);
+ Xstrdup_a(userid, buf, return cur_pos + 1);
cur_pos = imap_parse_atom(sock, cur_pos, buf, orig_buf);
- strcat(out_from_str, "@");
- strcat(out_from_str, buf);
- strcat(out_from_str, ">");
+ Xstrdup_a(domain, buf, return cur_pos + 1);
+
+ if (out_fromname_str[0] != '\0') {
+ g_snprintf(out_from_str, IMAPBUFSIZE, "\"%s\" <%s@%s>",
+ out_fromname_str, userid, domain);
+ } else {
+ g_snprintf(out_from_str, IMAPBUFSIZE, "%s@%s",
+ userid, domain);
+ strcpy(out_fromname_str, out_from_str);
+ }
while (*cur_pos == ' ') cur_pos++;
gchar tmp[IMAPBUFSIZE];
gchar *cur_pos;
gint msgnum;
+ guint32 uid;
size_t size;
gchar *date = NULL;
time_t date_t;
PARSE_ONE_ELEMENT(' ');
g_return_val_if_fail(!strcmp(buf, "FETCH"), NULL);
+ g_return_val_if_fail(*cur_pos == '(', NULL);
+ cur_pos++;
+
PARSE_ONE_ELEMENT(' ');
- g_return_val_if_fail(!strcmp(buf, "(FLAGS"), NULL);
+ g_return_val_if_fail(!strcmp(buf, "UID"), NULL);
+ PARSE_ONE_ELEMENT(' ');
+ uid = strtoul(buf, NULL, 10);
+ PARSE_ONE_ELEMENT(' ');
+ g_return_val_if_fail(!strcmp(buf, "FLAGS"), NULL);
PARSE_ONE_ELEMENT(')');
g_return_val_if_fail(*buf == '(', NULL);
flags = imap_parse_flags(buf + 1);
g_return_val_if_fail(*cur_pos == ' ', NULL);
- g_return_val_if_fail
- ((cur_pos = strchr_cpy(cur_pos + 1, ' ', buf, sizeof(buf))),
- NULL);
- g_return_val_if_fail(!strcmp(buf, "RFC822.SIZE"), NULL);
+ cur_pos++;
+ PARSE_ONE_ELEMENT(' ');
+ g_return_val_if_fail(!strcmp(buf, "RFC822.SIZE"), NULL);
PARSE_ONE_ELEMENT(' ');
size = atoi(buf);
}
msginfo = g_new0(MsgInfo, 1);
- msginfo->msgnum = msgnum;
+ msginfo->msgnum = uid;
msginfo->size = size;
msginfo->date = g_strdup(date);
msginfo->date_t = date_t;
return msginfo;
}
-static gint imap_set_article_flags(IMAPSession *session,
- gint first,
- gint last,
+static gint imap_set_message_flags(IMAPSession *session,
+ guint32 first_uid,
+ guint32 last_uid,
IMAPFlags flags,
gboolean is_set)
{
g_string_append_c(buf, ')');
- ok = imap_cmd_store(SESSION(session)->sock, first, last, buf->str);
+ ok = imap_cmd_store(SESSION(session)->sock, first_uid, last_uid,
+ buf->str);
g_string_free(buf, TRUE);
return ok;
}
+static gint imap_select(IMAPSession *session, IMAPFolder *folder,
+ const gchar *path,
+ gint *exists, gint *recent, gint *unseen,
+ guint32 *uid_validity)
+{
+ gchar *real_path;
+ IMAPNameSpace *namespace;
+ gint ok;
+ Xstrdup_a(real_path, path, return -1);
+ namespace = imap_find_namespace(folder, path);
+ if (namespace && namespace->separator)
+ imap_path_separator_subst(real_path, namespace->separator);
+
+ ok = imap_cmd_select(SESSION(session)->sock, real_path,
+ exists, recent, unseen, uid_validity);
+ if (ok != IMAP_SUCCESS)
+ log_warning(_("can't select folder: %s\n"), real_path);
+
+ return ok;
+}
+
+#define THROW(err) { ok = err; goto catch; }
+
+static gint imap_get_uid(IMAPSession *session, gint msgnum, guint32 *uid)
+{
+ gint ok;
+ GPtrArray *argbuf;
+ gchar *str;
+ gint num;
+
+ *uid = 0;
+ argbuf = g_ptr_array_new();
+
+ imap_cmd_gen_send(SESSION(session)->sock, "FETCH %d (UID)", msgnum);
+ if ((ok = imap_cmd_ok(SESSION(session)->sock, argbuf)) != IMAP_SUCCESS)
+ THROW(ok);
+
+ str = search_array_contain_str(argbuf, "FETCH");
+ if (!str) THROW(IMAP_ERROR);
+
+ if (sscanf(str, "%d FETCH (UID %d)", &num, uid) != 2 ||
+ num != msgnum) {
+ g_warning("imap_get_uid(): invalid FETCH line.\n");
+ THROW(IMAP_ERROR);
+ }
+
+catch:
+ ptr_array_free_strings(argbuf);
+ g_ptr_array_free(argbuf, TRUE);
+
+ return ok;
+}
+
+#undef THROW
+
+#if 0
+static gint imap_status_uidnext(IMAPSession *session, IMAPFolder *folder,
+ const gchar *path, guint32 *uid_next)
+{
+ gchar *real_path;
+ IMAPNameSpace *namespace;
+ gint ok;
+
+ Xstrdup_a(real_path, path, return -1);
+ namespace = imap_find_namespace(folder, path);
+ if (namespace && namespace->separator)
+ imap_path_separator_subst(real_path, namespace->separator);
+
+ ok = imap_cmd_status(SESSION(session)->sock, real_path,
+ "UIDNEXT", uid_next);
+ if (ok != IMAP_SUCCESS)
+ log_warning(_("can't get the next uid of folder: %s\n"),
+ real_path);
+
+ return ok;
+}
+#endif
+
+
+/* low-level IMAP4rev1 commands */
static gint imap_cmd_login(SockInfo *sock,
const gchar *user, const gchar *pass)
{
gint ok;
- imap_cmd_gen_send(sock, "LOGIN \"%s\" %s", user, pass);
+ if (strchr(user, ' ') != NULL)
+ imap_cmd_gen_send(sock, "LOGIN \"%s\" %s", user, pass);
+ else
+ imap_cmd_gen_send(sock, "LOGIN %s %s", user, pass);
+
ok = imap_cmd_ok(sock, NULL);
if (ok != IMAP_SUCCESS)
log_warning(_("IMAP4 login failed.\n"));
return imap_cmd_ok(sock, NULL);
}
+#define THROW(err) { ok = err; goto catch; }
+
+static gint imap_cmd_namespace(SockInfo *sock, gchar **ns_str)
+{
+ gint ok;
+ GPtrArray *argbuf;
+ gchar *str;
+
+ argbuf = g_ptr_array_new();
+
+ imap_cmd_gen_send(sock, "NAMESPACE");
+ if ((ok = imap_cmd_ok(sock, argbuf)) != IMAP_SUCCESS) THROW(ok);
+
+ str = search_array_contain_str(argbuf, "NAMESPACE");
+ if (!str) THROW(IMAP_ERROR);
+
+ *ns_str = g_strdup(str);
+
+catch:
+ ptr_array_free_strings(argbuf);
+ g_ptr_array_free(argbuf, TRUE);
+
+ return ok;
+}
+
+#undef THROW
+#define THROW goto catch
+
static gint imap_cmd_select(SockInfo *sock, const gchar *folder,
gint *exists, gint *recent, gint *unseen,
- gulong *uid)
+ guint32 *uid_validity)
{
gint ok;
gchar *resp_str;
GPtrArray *argbuf;
- gchar *imappath;
- *exists = *recent = *unseen = *uid = 0;
+ *exists = *recent = *unseen = *uid_validity = 0;
argbuf = g_ptr_array_new();
- Xstrdup_a(imappath, folder, return -1);
- /* imap_path_subst_slash_to_dot(imappath); */
+ if (strchr(folder, ' ') != NULL)
+ imap_cmd_gen_send(sock, "SELECT \"%s\"", folder);
+ else
+ imap_cmd_gen_send(sock, "SELECT %s", folder);
- imap_cmd_gen_send(sock, "SELECT \"%s\"", imappath);
- if ((ok = imap_cmd_ok(sock, argbuf)) != IMAP_SUCCESS)
- goto bail;
+ if ((ok = imap_cmd_ok(sock, argbuf)) != IMAP_SUCCESS) THROW;
resp_str = search_array_contain_str(argbuf, "EXISTS");
if (resp_str) {
if (sscanf(resp_str,"%d EXISTS", exists) != 1) {
g_warning("imap_select(): invalid EXISTS line.\n");
- goto bail;
+ THROW;
}
}
if (resp_str) {
if (sscanf(resp_str, "%d RECENT", recent) != 1) {
g_warning("imap_select(): invalid RECENT line.\n");
- goto bail;
+ THROW;
}
}
resp_str = search_array_contain_str(argbuf, "UIDVALIDITY");
if (resp_str) {
- if (sscanf(resp_str, "OK [UIDVALIDITY %lu] ", uid) != 1) {
+ if (sscanf(resp_str, "OK [UIDVALIDITY %u] ", uid_validity)
+ != 1) {
g_warning("imap_select(): invalid UIDVALIDITY line.\n");
- goto bail;
+ THROW;
}
}
if (resp_str) {
if (sscanf(resp_str, "OK [UNSEEN %d] ", unseen) != 1) {
g_warning("imap_select(): invalid UNSEEN line.\n");
- goto bail;
+ THROW;
}
}
-bail:
+catch:
ptr_array_free_strings(argbuf);
g_ptr_array_free(argbuf, TRUE);
}
static gint imap_cmd_status(SockInfo *sock, const gchar *folder,
- const gchar *status)
+ const gchar *status, gint *value)
{
- imap_cmd_gen_send(sock, "STATUS \"%s\" (%s)", folder, status);
- return imap_cmd_ok(sock, NULL);
+ gint ok;
+ GPtrArray *argbuf;
+ gchar *str;
+
+ *value = 0;
+ argbuf = g_ptr_array_new();
+
+ if (strchr(folder, ' ') != NULL)
+ imap_cmd_gen_send(sock, "STATUS \"%s\" (%s)", folder, status);
+ else
+ imap_cmd_gen_send(sock, "STATUS %s (%s)", folder, status);
+
+ if ((ok = imap_cmd_ok(sock, argbuf)) != IMAP_SUCCESS) THROW;
+
+ str = search_array_contain_str(argbuf, "STATUS");
+ if (!str) THROW;
+ str = strchr(str, '(');
+ if (!str) THROW;
+ str++;
+ if (strncmp(str, status, strlen(status)) != 0) THROW;
+ str += strlen(status);
+ if (*str != ' ') THROW;
+ str++;
+ *value = atoi(str);
+
+catch:
+ ptr_array_free_strings(argbuf);
+ g_ptr_array_free(argbuf, TRUE);
+
+ return ok;
}
+#undef THROW
+
static gint imap_cmd_create(SockInfo *sock, const gchar *folder)
{
- imap_cmd_gen_send(sock, "CREATE \"%s\"", folder);
+ if (strchr(folder, ' ') != NULL)
+ imap_cmd_gen_send(sock, "CREATE \"%s\"", folder);
+ else
+ imap_cmd_gen_send(sock, "CREATE %s", folder);
+
return imap_cmd_ok(sock, NULL);
}
static gint imap_cmd_delete(SockInfo *sock, const gchar *folder)
{
- imap_cmd_gen_send(sock, "DELETE \"%s\"", folder);
+ if (strchr(folder, ' ') != NULL)
+ imap_cmd_gen_send(sock, "DELETE \"%s\"", folder);
+ else
+ imap_cmd_gen_send(sock, "DELETE %s", folder);
+
return imap_cmd_ok(sock, NULL);
}
-static gint imap_cmd_fetch(SockInfo *sock, gint num, const gchar *filename)
+static gint imap_cmd_fetch(SockInfo *sock, guint32 uid, const gchar *filename)
{
gint ok;
gchar buf[IMAPBUFSIZE];
g_return_val_if_fail(filename != NULL, IMAP_ERROR);
- imap_cmd_gen_send(sock, "FETCH %d BODY[]", num);
+ imap_cmd_gen_send(sock, "UID FETCH %d BODY[]", uid);
if (sock_gets(sock, buf, sizeof(buf)) < 0)
return IMAP_ERROR;
if (imap_cmd_gen_recv(sock, buf, sizeof(buf)) != IMAP_SUCCESS)
return IMAP_ERROR;
- if (buf[0] != ')')
+ if (buf[0] == '\0' || buf[strlen(buf) - 1] != ')')
return IMAP_ERROR;
ok = imap_cmd_ok(sock, NULL);
g_return_val_if_fail(file != NULL, IMAP_ERROR);
+ size = get_file_size(file);
imap_cmd_gen_send(sock, "APPEND %s {%d}", destfolder, size);
ok = imap_cmd_ok(sock, NULL);
if (ok != IMAP_SUCCESS) {
return ok;
}
-static gint imap_cmd_copy(SockInfo *sock, gint num, const gchar *destfolder)
+static gint imap_cmd_copy(SockInfo *sock, guint32 uid, const gchar *destfolder)
{
gint ok;
g_return_val_if_fail(destfolder != NULL, IMAP_ERROR);
- imap_cmd_gen_send(sock, "COPY %d %s", num, destfolder);
+ if (strchr(destfolder, ' ') != NULL)
+ imap_cmd_gen_send(sock, "UID COPY %d \"%s\"", uid, destfolder);
+ else
+ imap_cmd_gen_send(sock, "UID COPY %d %s", uid, destfolder);
+
ok = imap_cmd_ok(sock, NULL);
if (ok != IMAP_SUCCESS) {
- log_warning(_("can't copy %d to %s\n"), num, destfolder);
+ log_warning(_("can't copy %d to %s\n"), uid, destfolder);
return -1;
}
return ok;
}
-
-gint imap_cmd_envelope(SockInfo *sock, gint first, gint last)
+gint imap_cmd_envelope(SockInfo *sock, guint32 first_uid, guint32 last_uid)
{
- imap_cmd_gen_send(sock, "FETCH %d:%d (FLAGS RFC822.SIZE ENVELOPE)",
- first, last);
+ imap_cmd_gen_send
+ (sock, "UID FETCH %d:%d (UID FLAGS RFC822.SIZE ENVELOPE)",
+ first_uid, last_uid);
return IMAP_SUCCESS;
}
-static gint imap_cmd_store(SockInfo *sock, gint first, gint last,
+static gint imap_cmd_store(SockInfo *sock, guint32 first_uid, guint32 last_uid,
gchar *sub_cmd)
{
gint ok;
- imap_cmd_gen_send(sock, "STORE %d:%d %s", first, last, sub_cmd);
+ imap_cmd_gen_send(sock, "UID STORE %d:%d %s",
+ first_uid, last_uid, sub_cmd);
if ((ok = imap_cmd_ok(sock, NULL)) != IMAP_SUCCESS) {
log_warning(_("error while imap command: STORE %d:%d %s\n"),
- first, last, sub_cmd);
+ first_uid, last_uid, sub_cmd);
return ok;
}
g_snprintf(buf, sizeof(buf), "%d %s\r\n", imap_cmd_count, tmp);
if (!strncasecmp(tmp, "LOGIN ", 6) && (p = strchr(tmp + 6, ' '))) {
- *(p + 1) = '\0';
+ *p = '\0';
log_print("IMAP4> %d %s ********\n", imap_cmd_count, tmp);
} else
log_print("IMAP4> %d %s\n", imap_cmd_count, tmp);
return NULL;
}
-static void imap_path_subst_slash_to_dot(gchar *str)
+static void imap_path_separator_subst(gchar *str, gchar separator)
{
- subst_char(str, '/', '.');
+ if (separator && separator != '/')
+ subst_char(str, '/', separator);
}
projects / claws.git / blobdiff