/*
* Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
- * Copyright (C) 1999-2007 Hiroyuki Yamamoto and the Claws Mail team
+ * Copyright (C) 1999-2009 Hiroyuki Yamamoto and the Claws Mail team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
# include <iconv.h>
#endif
-#if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
+#ifdef USE_GNUTLS
# include "ssl.h"
#endif
#define IMAP4_PORT 143
-#if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
+#ifdef USE_GNUTLS
#define IMAPS_PORT 993
#endif
static gint imap_add_msgs (Folder *folder,
FolderItem *dest,
GSList *file_list,
- GRelation *relation);
+ GHashTable *relation);
static gint imap_copy_msg (Folder *folder,
FolderItem *dest,
static gint imap_copy_msgs (Folder *folder,
FolderItem *dest,
MsgInfoList *msglist,
- GRelation *relation);
+ GHashTable *relation);
static gint imap_remove_msg (Folder *folder,
FolderItem *item,
static gint imap_remove_msgs (Folder *folder,
FolderItem *dest,
MsgInfoList *msglist,
- GRelation *relation);
+ GHashTable *relation);
+static gint imap_expunge (Folder *folder,
+ FolderItem *dest);
static gint imap_remove_all_msg (Folder *folder,
FolderItem *item);
static gint imap_do_copy_msgs (Folder *folder,
FolderItem *dest,
MsgInfoList *msglist,
- GRelation *relation);
+ GHashTable *relation);
static void imap_delete_all_cached_messages (FolderItem *item);
static void imap_set_batch (Folder *folder,
const gchar *pass,
const gchar *type);
static gint imap_cmd_noop (IMAPSession *session);
-#if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
+#ifdef USE_GNUTLS
static gint imap_cmd_starttls (IMAPSession *session);
#endif
static gint imap_cmd_select (IMAPSession *session,
static gint imap_cmd_copy (IMAPSession *session,
struct mailimap_set * set,
const gchar *destfolder,
- GRelation *uid_mapping,
struct mailimap_set ** source,
struct mailimap_set ** dest);
static gint imap_cmd_store (IMAPSession *session,
IMAPFlags flags,
GSList *tags,
int do_add);
-static gint imap_cmd_expunge (IMAPSession *session);
+static gint imap_cmd_expunge (IMAPSession *session, gboolean force);
static void imap_path_separator_subst (gchar *str,
gchar separator);
static gint imap_get_flags (Folder *folder,
FolderItem *item,
MsgInfoList *msglist,
- GRelation *msgflags);
+ GHashTable *msgflags);
static gchar *imap_folder_get_path (Folder *folder);
static gchar *imap_item_get_path (Folder *folder,
FolderItem *item);
imap_class.copy_msgs = imap_copy_msgs;
imap_class.remove_msg = imap_remove_msg;
imap_class.remove_msgs = imap_remove_msgs;
+ imap_class.expunge = imap_expunge;
imap_class.remove_all_msg = imap_remove_all_msg;
imap_class.is_msg_changed = imap_is_msg_changed;
imap_class.change_flags = imap_change_flags;
static void imap_disc_session_destroy(IMAPSession *session)
{
- RemoteFolder *rfolder = REMOTE_FOLDER(IMAP_SESSION(session)->folder);
-
- if (!rfolder)
+ RemoteFolder *rfolder = NULL;
+
+ if (session == NULL)
return;
- if (!session)
+
+ rfolder = REMOTE_FOLDER(IMAP_SESSION(session)->folder);
+
+ if (rfolder == NULL)
return;
log_warning(LOG_PROTOCOL, _("IMAP4 connection broken\n"));
SESSION(session)->state = SESSION_DISCONNECTED;
}
}
-static void imap_handle_error(Session *session, int libetpan_errcode)
+static void imap_handle_error(Session *session, const gchar *server, int libetpan_errcode)
{
- const gchar *session_server = (session ? session->server:"(null)");
+ const gchar *session_server = (session ? session->server : NULL);
+
+ if (session_server == NULL)
+ session_server = server;
+ if (session_server == NULL)
+ session_server = "(null)";
+
switch(libetpan_errcode) {
case MAILIMAP_NO_ERROR:
return;
case MAILIMAP_ERROR_SASL:
log_warning(LOG_PROTOCOL, _("IMAP error on %s: SASL error\n"), session_server);
break;
-#if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
+#ifdef USE_GNUTLS
case MAILIMAP_ERROR_SSL:
log_warning(LOG_PROTOCOL, _("IMAP error on %s: SSL error\n"), session_server);
break;
return result;
}
- if (capabilities == NULL) {
+ if (capabilities == NULL || capabilities->cap_list == NULL) {
return MAILIMAP_NO_ERROR;
}
int r;
gchar *server = NULL;
if ((r = imap_get_capabilities(session)) != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
return r;
}
server = g_strdup(SESSION(session)->server);
int r;
int authenticated = FALSE;
-#if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
+#ifdef USE_GNUTLS
/* FIXME: IMAP over SSL only... */
SSLType ssl_type;
else
#endif
{
-#if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
+#ifdef USE_GNUTLS
if (ssl_type == SSL_TUNNEL) {
r = imap_threaded_connect_ssl(folder,
account->recv_server,
authenticated = FALSE;
}
else {
-#if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
+#ifdef USE_GNUTLS
if (r == MAILIMAP_ERROR_SSL)
log_error(LOG_PROTOCOL, _("SSL handshake failed\n"));
else
#endif
- imap_handle_error(NULL, r);
+ imap_handle_error(NULL, account->recv_server, r);
if(!prefs_common.no_recv_err_panel) {
alertpanel_error_log(_("Can't connect to IMAP4 server: %s:%d"),
session->folder = folder;
IMAP_FOLDER(session->folder)->last_seen_separator = 0;
-#if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
+#ifdef USE_GNUTLS
if (account->ssl_imap == SSL_STARTTLS) {
gint ok;
acc_pass = account->passwd;
try_again:
pass = acc_pass;
- if (!pass && account->imap_auth_type != IMAP_AUTH_ANON) {
+ if (!pass && account->imap_auth_type != IMAP_AUTH_ANON && account->imap_auth_type != IMAP_AUTH_GSSAPI) {
gchar *tmp_pass;
tmp_pass = input_dialog_query_password_keep(account->recv_server,
account->userid,
return MAILIMAP_NO_ERROR;
Xstrdup_a(pass, tmp_pass, {g_free(tmp_pass); return MAILIMAP_NO_ERROR;});
g_free(tmp_pass);
- } else if (account->imap_auth_type == IMAP_AUTH_ANON) {
+ } else if (account->imap_auth_type == IMAP_AUTH_ANON || account->imap_auth_type == IMAP_AUTH_GSSAPI) {
pass = "";
}
statuswindow_print_all(_("Connecting to IMAP4 server %s...\n"),
}
static gint imap_add_msgs(Folder *folder, FolderItem *dest, GSList *file_list,
- GRelation *relation)
+ GHashTable *relation)
{
gchar *destdir;
IMAPSession *session;
}
if (relation != NULL)
- g_relation_insert(relation, fileinfo->msginfo != NULL ?
+ g_hash_table_insert(relation, fileinfo->msginfo != NULL ?
(gpointer) fileinfo->msginfo : (gpointer) fileinfo,
GINT_TO_POINTER(new_uid));
if (last_uid < new_uid) {
int start, end, t;
GSList *cur;
+ if (!set || !set->set_list)
+ return NULL;
+
for (list = clist_begin(set->set_list); list; list = clist_next(list)) {
struct mailimap_set_item *item = (struct mailimap_set_item *)clist_content(list);
start = item->set_first;
return result;
}
static gint imap_do_copy_msgs(Folder *folder, FolderItem *dest,
- MsgInfoList *msglist, GRelation *relation)
+ MsgInfoList *msglist, GHashTable *relation)
{
FolderItem *src;
gchar *destdir;
MsgInfo *msginfo;
IMAPSession *session;
gint ok = MAILIMAP_NO_ERROR;
- GRelation *uid_mapping;
+ GHashTable *uid_hash;
gint last_num = 0;
gboolean single = FALSE;
return ok;
seq_list = imap_get_lep_set_from_msglist(IMAP_FOLDER(folder), msglist);
- uid_mapping = g_relation_new(2);
- g_relation_index(uid_mapping, 0, g_direct_hash, g_direct_equal);
+ uid_hash = g_hash_table_new(g_direct_hash, g_direct_equal);
statusbar_print_all(_("Copying messages..."));
for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
src->path, destdir);
lock_session(session); /* unlocked later in the function */
- ok = imap_cmd_copy(session, seq_set, destdir, uid_mapping,
+ ok = imap_cmd_copy(session, seq_set, destdir,
&source, &dest);
if (is_fatal(ok)) {
for (s_cur = s_list, d_cur = d_list;
s_cur && d_cur;
s_cur = s_cur->next, d_cur = d_cur->next) {
- g_relation_insert(uid_mapping, s_cur->data, d_cur->data);
+ g_hash_table_insert(uid_hash, s_cur->data, d_cur->data);
}
} else {
mailimap_set_free(dest);
if (ok != MAILIMAP_NO_ERROR) {
- g_relation_destroy(uid_mapping);
+ g_hash_table_destroy(uid_hash);
imap_lep_set_free(seq_list);
statusbar_pop_all();
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 hashval;
+
+ hashval = g_hash_table_lookup(uid_hash, GINT_TO_POINTER(msginfo->msgnum));
+
+ if (hashval != NULL) {
+ gint num = GPOINTER_TO_INT(hashval);
+ g_hash_table_insert(relation, msginfo,
GINT_TO_POINTER(num));
if (num > last_num)
last_num = num;
g_free(cache_path);
}
} else
- g_relation_insert(relation, msginfo,
+ g_hash_table_insert(relation, msginfo,
GINT_TO_POINTER(0));
- g_tuples_destroy(tuples);
}
statusbar_pop_all();
- g_relation_destroy(uid_mapping);
+ g_hash_table_destroy(uid_hash);
imap_lep_set_free(seq_list);
g_free(destdir);
}
static gint imap_copy_msgs(Folder *folder, FolderItem *dest,
- MsgInfoList *msglist, GRelation *relation)
+ MsgInfoList *msglist, GHashTable *relation)
{
MsgInfo *msginfo;
gint ret;
static gint imap_do_remove_msgs(Folder *folder, FolderItem *dest,
- MsgInfoList *msglist, GRelation *relation)
+ MsgInfoList *msglist, GHashTable *relation)
{
gchar *destdir, *dir;
GSList *numlist = NULL, *cur;
MsgInfo *msginfo;
IMAPSession *session;
gint ok = MAILIMAP_NO_ERROR;
- GRelation *uid_mapping;
g_return_val_if_fail(folder != NULL, -1);
g_return_val_if_fail(dest != NULL, -1);
}
destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path, &ok);
- if (is_fatal(ok))
+ if (is_fatal(ok)) {
+ g_free(destdir);
return ok;
+ }
for (cur = msglist; cur; cur = cur->next) {
msginfo = (MsgInfo *)cur->data;
if (!MSG_IS_DELETED(msginfo->flags))
}
numlist = g_slist_reverse(numlist);
- uid_mapping = g_relation_new(2);
- g_relation_index(uid_mapping, 0, g_direct_hash, g_direct_equal);
-
if (numlist != NULL) {
ok = imap_set_message_flags
(session, IMAP_FOLDER_ITEM(msginfo->folder), numlist, IMAP_FLAG_DELETED, NULL, TRUE);
if (ok != MAILIMAP_NO_ERROR) {
log_warning(LOG_PROTOCOL, _("can't set deleted flags\n"));
+ g_free(destdir);
return ok;
}
} /* else we just need to expunge */
- ok = imap_cmd_expunge(session);
+ ok = imap_cmd_expunge(session, folder->account->imap_use_trash);
if (ok != MAILIMAP_NO_ERROR) {
log_warning(LOG_PROTOCOL, _("can't expunge\n"));
+ g_free(destdir);
return ok;
}
}
g_free(dir);
- g_relation_destroy(uid_mapping);
g_slist_free(numlist);
imap_scan_required(folder, dest);
}
static gint imap_remove_msgs(Folder *folder, FolderItem *dest,
- MsgInfoList *msglist, GRelation *relation)
+ MsgInfoList *msglist, GHashTable *relation)
{
MsgInfo *msginfo;
if (folder->account->imap_dir && *folder->account->imap_dir) {
gchar *real_path;
- int r;
+ int r = MAILIMAP_NO_ERROR;
clist * lep_list;
Xstrdup_a(root_folder, folder->account->imap_dir, {return -1;});
&lep_list);
if (r != MAILIMAP_NO_ERROR)
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
if ((r != MAILIMAP_NO_ERROR) || (clist_count(lep_list) == 0)) {
if (!folder->node) {
gchar separator;
gchar wildcard[3];
clist * lep_list;
- int r;
+ int r = MAILIMAP_NO_ERROR;
g_return_val_if_fail(item != NULL, -1);
g_return_val_if_fail(item->folder != NULL, -1);
wildcard[1] = '%';
wildcard[2] = '\0';
real_path = imap_get_real_path(session, imapfolder, item->path, &r);
- if (is_fatal(r))
+ if (is_fatal(r)) {
+ g_free(real_path);
return r;
+ }
} else {
wildcard[0] = '%';
wildcard[1] = '\0';
r = imap_threaded_list(folder, "", wildcard_path, &lep_list);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
item_list = NULL;
+ g_free(real_path);
return r;
}
else {
GSList *item_list = NULL, *cur;
GList *child_list = NULL, *tmplist = NULL;
GSList *sub_list = NULL;
- int r;
+ int r = MAILIMAP_NO_ERROR;
if (!session)
return NULL;
wildcard[1] = '%';
wildcard[2] = '\0';
real_path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path, &r);
- if (is_fatal(r))
+ if (is_fatal(r)) {
+ g_free(real_path);
return NULL;
+ }
} else {
wildcard[0] = '%';
wildcard[1] = '\0';
r = imap_threaded_list(folder, "", wildcard_path, &lep_list);
if (r) {
+ g_free(real_path);
statusbar_pop_all();
return NULL;
}
imap_get_real_path(session,
IMAP_FOLDER(folder), cur_item->path, &r));
if (is_fatal(r)) {
+ g_free(real_path);
statusbar_pop_all();
return NULL;
}
if (unsubs_only) {
r = imap_threaded_lsub(folder, "", wildcard_path, &lep_list);
if (r) {
+ g_free(real_path);
statusbar_pop_all();
return NULL;
}
gchar *tmp = imap_get_real_path(session,
IMAP_FOLDER(folder), cur_item->path, &r);
if (r) {
+ g_free(real_path);
statusbar_pop_all();
return NULL;
}
}
}
+ g_free(real_path);
statusbar_pop_all();
return child_list;
gchar separator;
gchar *new_name;
const gchar *p;
- gint ok;
+ gint ok = MAILIMAP_NO_ERROR;
gboolean no_select = FALSE, no_sub = FALSE;
gboolean exist = FALSE;
strtailchomp(dirpath, '/');
Xstrdup_a(new_name, name, {
g_free(dirpath);
+ g_free(imap_path);
return NULL;});
separator = imap_get_path_separator(session, IMAP_FOLDER(folder), imap_path, &ok);
- if (is_fatal(ok))
+ if (is_fatal(ok)) {
+ g_free(imap_path);
return NULL;
+ }
imap_path_separator_subst(imap_path, separator);
/* remove trailing / for display */
strtailchomp(new_name, '/');
argbuf = g_ptr_array_new();
r = imap_threaded_list(folder, "", imap_path, &lep_list);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
log_warning(LOG_PROTOCOL, _("can't create mailbox: LIST failed\n"));
g_free(imap_path);
g_free(dirpath);
}
mailimap_list_result_free(lep_list);
} else {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
}
}
imap_threaded_subscribe(folder, imap_path, TRUE);
}
mailimap_list_result_free(lep_list);
} else {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
}
}
gchar *new_cache_dir;
IMAPSession *session;
gchar separator;
- gint ok;
+ gint ok = MAILIMAP_NO_ERROR;
gint exists, recent, unseen;
guint32 uid_validity;
if (is_dir_exist(old_cache_dir)) {
new_cache_dir = folder_item_get_path(item);
- if (rename(old_cache_dir, new_cache_dir) < 0) {
+ if (g_rename(old_cache_dir, new_cache_dir) < 0) {
FILE_OP_ERROR(old_cache_dir, "rename");
}
g_free(new_cache_dir);
gint imap_subscribe(Folder *folder, FolderItem *item, gchar *rpath, gboolean sub)
{
gchar *path;
- gint r = -1;
+ gint r = MAILIMAP_NO_ERROR;
IMAPSession *session;
debug_print("getting session...\n");
}
if (item && item->path) {
path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path, &r);
- if (!path || is_fatal(r))
+ if (!path)
return -1;
- if (!strcmp(path, "INBOX") && sub == FALSE)
+ if (is_fatal(r)) {
+ g_free(path);
return -1;
+ }
+ if (!strcmp(path, "INBOX") && sub == FALSE) {
+ g_free(path);
+ return -1;
+ }
debug_print("%ssubscribing %s\n", sub?"":"un", path);
r = imap_threaded_subscribe(folder, path, sub);
g_free(path);
static gint imap_remove_folder_real(Folder *folder, FolderItem *item)
{
- gint ok;
+ gint ok = MAILIMAP_NO_ERROR;
IMAPSession *session;
gchar *path;
gchar *cache_dir;
}
ok = imap_cmd_delete(session, path);
if (ok != MAILIMAP_NO_ERROR && !is_fatal(ok)) {
- gchar *tmp = g_strdup_printf("%s%c", path,
+ gchar *tmp = NULL;
+
+ ok = MAILIMAP_NO_ERROR;
+ tmp = g_strdup_printf("%s%c", path,
imap_get_path_separator(session, IMAP_FOLDER(folder), path, &ok));
g_free(path);
path = tmp;
r = imap_threaded_fetch_env(session->folder,
imapset, &env_list);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
if (is_fatal(r)) {
stuff->ok = r;
return NULL;
g_slist_free(tags);
continue;
}
- if (tags != NULL) {
- g_slist_free(msginfo->tags);
- msginfo->tags = NULL;
- }
+ g_slist_free(msginfo->tags);
+ msginfo->tags = NULL;
+
for (cur = tags; cur; cur = cur->next) {
gchar *real_tag = imap_modified_utf7_to_utf8(cur->data, TRUE);
gint id = 0;
got_alien_tags = TRUE;
}
if (!g_slist_find(msginfo->tags, GINT_TO_POINTER(id))) {
- msginfo->tags = g_slist_append(
+ msginfo->tags = g_slist_prepend(
msginfo->tags,
GINT_TO_POINTER(id));
}
g_free(real_tag);
}
+ if (msginfo->tags)
+ msginfo->tags = g_slist_reverse(msginfo->tags);
slist_free_strings(tags);
g_slist_free(tags);
msginfo->folder = item;
IMAPFolder *imap_folder = NULL;
IMAPSession *session = NULL;
gchar result = '/';
- gint ok;
+ gint ok = MAILIMAP_NO_ERROR;
if (!item)
return '/';
folder = item->folder;
r = imap_threaded_list((Folder *)folder, "", subfolder, &lep_list);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
log_warning(LOG_PROTOCOL, _("LIST failed\n"));
*ok = r;
return '\0';
}
- if (clist_count(lep_list) > 0) {
+ if (lep_list != NULL && clist_count(lep_list) > 0) {
clistiter * iter = clist_begin(lep_list);
struct mailimap_mailbox_list * mb;
mb = clist_content(iter);
static gchar imap_get_path_separator(IMAPSession *session, IMAPFolder *folder, const gchar *path, gint *ok)
{
gchar separator = '/';
-
+ *ok = MAILIMAP_NO_ERROR;
if (folder->last_seen_separator == 0) {
folder->last_seen_separator = imap_refresh_path_separator(session, folder, "", ok);
}
static gchar *imap_get_real_path(IMAPSession *session, IMAPFolder *folder, const gchar *path, gint *ok)
{
- gchar *real_path;
+ gchar *real_path = NULL;
gchar separator;
-
+
g_return_val_if_fail(folder != NULL, NULL);
g_return_val_if_fail(path != NULL, NULL);
+ *ok = MAILIMAP_NO_ERROR;
+
real_path = imap_utf8_to_modified_utf7(path, FALSE);
separator = imap_get_path_separator(session, folder, path, ok);
- imap_path_separator_subst(real_path, separator);
+ if (*ok == MAILIMAP_NO_ERROR)
+ imap_path_separator_subst(real_path, separator);
return real_path;
}
for(cur = seq_list ; cur != NULL ; cur = g_slist_next(cur)) {
struct mailimap_set * imapset = (struct mailimap_set *)cur->data;
- struct mailimap_set_item *set_item = clist_content(
- clist_begin(imapset->set_list));
+ struct mailimap_set_item *set_item = NULL;
+
+ if (imapset->set_list)
+ set_item = clist_content(clist_begin(imapset->set_list));
+ else
+ continue;
+
+ if (set_item == NULL)
+ continue;
statusbar_progress_all(set_item->set_first, total, 1);
gboolean block)
{
gchar *real_path;
- gint ok;
+ gint ok = MAILIMAP_NO_ERROR;
gint exists_, recent_, unseen_;
guint32 uid_validity_;
gint can_create_flags_;
guint32 *uid_next, guint32 *uid_validity,
gint *unseen, gboolean block)
{
- int r;
+ int r = MAILIMAP_NO_ERROR;
clistiter * iter;
struct mailimap_mailbox_data_status * data_status;
int got_values;
guint mask = 0;
real_path = imap_get_real_path(session, folder, path, &r);
- if (is_fatal(r))
+ if (is_fatal(r)) {
+ g_free(real_path);
return r;
-
+ }
if (messages) {
mask |= 1 << 0;
*messages = 0;
r = imap_cmd_close(session);
if (r != MAILIMAP_NO_ERROR) {
debug_print("close err %d\n", r);
+ g_free(real_path);
return r;
}
}
g_free(real_path);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
debug_print("status err %d\n", r);
return r;
}
- if (data_status->st_info_list == NULL) {
- mailimap_mailbox_data_status_free(data_status);
- debug_print("status->st_info_list == NULL\n");
+ if (data_status == NULL || data_status->st_info_list == NULL) {
+ debug_print("data_status %p\n", data_status);
+ if (data_status) {
+ debug_print("data_status->st_info_list %p\n", data_status->st_info_list);
+ mailimap_mailbox_data_status_free(data_status);
+ }
return MAILIMAP_ERROR_BAD_STATE;
}
got_values = 0;
- for(iter = clist_begin(data_status->st_info_list) ; iter != NULL ;
- iter = clist_next(iter)) {
- struct mailimap_status_info * info;
-
- info = clist_content(iter);
- switch (info->st_att) {
- case MAILIMAP_STATUS_ATT_MESSAGES:
- if (messages) {
- * messages = info->st_value;
- got_values |= 1 << 0;
- }
- break;
-
- case MAILIMAP_STATUS_ATT_UIDNEXT:
- if (uid_next) {
- * uid_next = info->st_value;
- got_values |= 1 << 2;
- }
- break;
-
- case MAILIMAP_STATUS_ATT_UIDVALIDITY:
- if (uid_validity) {
- * uid_validity = info->st_value;
- got_values |= 1 << 3;
- }
- break;
-
- case MAILIMAP_STATUS_ATT_UNSEEN:
- if (unseen) {
- * unseen = info->st_value;
- got_values |= 1 << 4;
+ if (data_status->st_info_list) {
+ for(iter = clist_begin(data_status->st_info_list) ; iter != NULL ;
+ iter = clist_next(iter)) {
+ struct mailimap_status_info * info;
+
+ info = clist_content(iter);
+ switch (info->st_att) {
+ case MAILIMAP_STATUS_ATT_MESSAGES:
+ if (messages) {
+ * messages = info->st_value;
+ got_values |= 1 << 0;
+ }
+ break;
+
+ case MAILIMAP_STATUS_ATT_UIDNEXT:
+ if (uid_next) {
+ * uid_next = info->st_value;
+ got_values |= 1 << 2;
+ }
+ break;
+
+ case MAILIMAP_STATUS_ATT_UIDVALIDITY:
+ if (uid_validity) {
+ * uid_validity = info->st_value;
+ got_values |= 1 << 3;
+ }
+ break;
+
+ case MAILIMAP_STATUS_ATT_UNSEEN:
+ if (unseen) {
+ * unseen = info->st_value;
+ got_values |= 1 << 4;
+ }
+ break;
}
- break;
}
}
mailimap_mailbox_data_status_free(data_status);
if (!strcmp(type, "LOGIN") && imap_has_capability(session, "LOGINDISABLED")) {
gint ok = MAILIMAP_ERROR_BAD_STATE;
if (imap_has_capability(session, "STARTTLS")) {
-#if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
+#ifdef USE_GNUTLS
log_warning(LOG_PROTOCOL, _("Server requires TLS to log in.\n"));
ok = imap_cmd_starttls(session);
if (ok != MAILIMAP_NO_ERROR) {
/* refresh capas */
imap_free_capabilities(session);
if ((r = imap_get_capabilities(session)) != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
log_warning(LOG_PROTOCOL, _("Can't refresh capabilities.\n"));
return r;
}
type);
r = imap_threaded_login(session->folder, user, pass, type);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
log_print(LOG_PROTOCOL, "IMAP4< Error logging in to %s\n",
SESSION(session)->server);
ok = r;
r = imap_threaded_noop(session->folder, &exists, &recent, &expunge, &unseen, &uidnext, &uidval);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
debug_print("noop err %d\n", r);
return r;
}
return MAILIMAP_NO_ERROR;
}
-#if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
+#ifdef USE_GNUTLS
static gint imap_cmd_starttls(IMAPSession *session)
{
int r;
r = imap_threaded_starttls(session->folder,
SESSION(session)->server, SESSION(session)->port);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
debug_print("starttls err %d\n", r);
return r;
}
r = imap_threaded_select(session->folder, folder,
exists, recent, unseen, uid_validity, can_create_flags, ok_flags);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
debug_print("select err %d\n", r);
return r;
}
r = imap_threaded_close(session->folder);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
debug_print("close err %d\n", r);
return r;
}
r = imap_threaded_examine(session->folder, folder,
exists, recent, unseen, uid_validity);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
debug_print("examine err %d\n", r);
return r;
r = imap_threaded_create(session->folder, folder);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
return r;
}
r = imap_threaded_rename(session->folder, old_folder,
new_folder);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
return r;
}
r = imap_threaded_delete(session->folder, folder);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
return r;
}
uid, 0, filename);
}
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
debug_print("fetch err %d\n", r);
return GINT_TO_POINTER(r);
}
struct mailimap_flag_list * flag_list;
int r;
- g_return_val_if_fail(file != NULL, MAILIMAP_ERROR_BAD_STATE);
+ cm_return_val_if_fail(file != NULL, MAILIMAP_ERROR_BAD_STATE);
flag_list = imap_flag_to_lep(item, flags, NULL);
lock_session(session);
mailimap_flag_list_free(flag_list);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
debug_print("append err %d\n", r);
return r;
}
}
static gint imap_cmd_copy(IMAPSession *session, struct mailimap_set * set,
- const gchar *destfolder, GRelation *uid_mapping,
+ const gchar *destfolder,
struct mailimap_set **source, struct mailimap_set **dest)
{
int r;
r = imap_threaded_copy(session->folder, set, destfolder, source, dest);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
return r;
}
r = imap_threaded_store(session->folder, set, store_att_flags);
mailimap_store_att_flags_free(store_att_flags);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
return r;
}
return MAILIMAP_NO_ERROR;
}
-static gint imap_cmd_expunge(IMAPSession *session)
+static gint imap_cmd_expunge(IMAPSession *session, gboolean do_expunge)
{
int r;
+ if (!do_expunge)
+ return MAILIMAP_NO_ERROR;
+
if (prefs_common.work_offline &&
!inc_offline_should_override(FALSE,
_("Claws Mail needs network access in order "
r = imap_threaded_expunge(session->folder);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
return r;
}
return MAILIMAP_NO_ERROR;
}
+gint imap_expunge(Folder *folder, FolderItem *item)
+{
+ IMAPSession *session = imap_session_get(folder);
+ if (session == NULL)
+ return -1;
+
+ return imap_cmd_expunge(session, TRUE);
+}
+
static void imap_path_separator_subst(gchar *str, gchar separator)
{
gchar *p;
gchar *new_itempath;
gint oldpathlen;
IMAPSession *session = imap_session_get(item->folder);
- gint ok;
+ gint ok = MAILIMAP_NO_ERROR;
oldpathlen = strlen(oldpath);
if (strncmp(oldpath, item->path, oldpathlen) != 0) {
g_warning("path doesn't match: %s, %s\n", oldpath, item->path);
} else {
carray * lep_uidtab;
if (r != -1) { /* inited */
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
if (is_fatal(r))
return -1;
}
}
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
return -1;
}
return ok;
}
- if (!session->uidplus) {
- ok = imap_cmd_expunge(session);
- } else {
- gchar *uidstr;
+ ok = imap_cmd_expunge(session, folder->account->imap_use_trash);
- uidstr = g_strdup_printf("%u", uid);
- ok = imap_cmd_expunge(session);
- g_free(uidstr);
- }
if (ok != MAILIMAP_NO_ERROR) {
log_warning(LOG_PROTOCOL, _("can't expunge\n"));
return ok;
Folder *folder;
FolderItem *item;
MsgInfoList *msginfo_list;
- GRelation *msgflags;
+ GHashTable *msgflags;
gboolean full_search;
gboolean done;
} get_flags_data;
Folder *folder = stuff->folder;
FolderItem *fitem = (FolderItem *) stuff->item;
MsgInfoList *msginfo_list = stuff->msginfo_list;
- GRelation *msgflags = stuff->msgflags;
+ GHashTable *msgflags = stuff->msgflags;
GSList *elem;
carray * lep_uidtab;
IMAPSession *session;
unseen = g_slist_concat(unseen, uidlist);
} else {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
goto bail;
}
flagged = g_slist_concat(flagged, uidlist);
} else {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
goto bail;
}
answered = g_slist_concat(answered, uidlist);
} else {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
goto bail;
}
forwarded = g_slist_concat(forwarded, uidlist);
} else {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
goto bail;
}
}
spam = g_slist_concat(spam, uidlist);
} else {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
goto bail;
}
}
deleted = g_slist_concat(deleted, uidlist);
} else {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
goto bail;
}
}
imap_flags_hash_from_lep_uid_flags_tab(lep_uidtab, flags_hash, tags_hash);
imap_fetch_uid_flags_list_free(lep_uidtab);
} else {
- imap_handle_error(SESSION(session), r);
+ imap_handle_error(SESSION(session), NULL, r);
goto bail;
}
}
}
}
- g_relation_insert(msgflags, msginfo, GINT_TO_POINTER(flags));
+ g_hash_table_insert(msgflags, msginfo, GINT_TO_POINTER(flags));
}
if (got_alien_tags) {
}
static gint imap_get_flags(Folder *folder, FolderItem *item,
- MsgInfoList *msginfo_list, GRelation *msgflags)
+ MsgInfoList *msginfo_list, GHashTable *msgflags)
{
gint result;
get_flags_data *data = g_new0(get_flags_data, 1);
}
}
- for(cur = clist_begin(imap_flags->mbf_oflags) ; cur != NULL ;
- cur = clist_next(cur)) {
- struct mailimap_mbx_list_oflag * oflag;
-
- oflag = clist_content(cur);
-
- switch (oflag->of_type) {
- case MAILIMAP_MBX_LIST_OFLAG_NOINFERIORS:
- flags |= ETPAN_IMAP_MB_NOINFERIORS;
- break;
+ if (imap_flags->mbf_oflags) {
+ for(cur = clist_begin(imap_flags->mbf_oflags) ; cur != NULL ;
+ cur = clist_next(cur)) {
+ struct mailimap_mbx_list_oflag * oflag;
+
+ oflag = clist_content(cur);
+
+ switch (oflag->of_type) {
+ case MAILIMAP_MBX_LIST_OFLAG_NOINFERIORS:
+ flags |= ETPAN_IMAP_MB_NOINFERIORS;
+ break;
+ }
}
- }
-
+ }
return flags;
}
clistiter * iter;
GSList * item_list = NULL, *llast = NULL;
- for(iter = clist_begin(list) ; iter != NULL ;
- iter = clist_next(iter)) {
- struct mailimap_mailbox_list * mb;
- int flags;
- char delimiter;
- char * name;
- char * dup_name;
- gchar * base;
- gchar * loc_name;
- gchar * loc_path;
- FolderItem *new_item;
-
- mb = clist_content(iter);
+ if (list) {
+ for(iter = clist_begin(list) ; iter != NULL ;
+ iter = clist_next(iter)) {
+ struct mailimap_mailbox_list * mb;
+ int flags;
+ char delimiter;
+ char * name;
+ char * dup_name;
+ gchar * base;
+ gchar * loc_name;
+ gchar * loc_path;
+ FolderItem *new_item;
+
+ mb = clist_content(iter);
+
+ if (mb == NULL)
+ continue;
- if (mb == NULL)
- continue;
+ flags = 0;
+ if (mb->mb_flag != NULL)
+ flags = imap_flags_to_flags(mb->mb_flag);
- flags = 0;
- if (mb->mb_flag != NULL)
- flags = imap_flags_to_flags(mb->mb_flag);
-
- delimiter = mb->mb_delimiter;
- name = mb->mb_name;
-
- dup_name = strdup(name);
- if (delimiter != '\0')
- subst_char(dup_name, delimiter, '/');
-
- base = g_path_get_basename(dup_name);
- if (base[0] == '.') {
- g_free(base);
- free(dup_name);
- continue;
- }
- if (!all && path_cmp(name, real_path) == 0) {
+ delimiter = mb->mb_delimiter;
+ name = mb->mb_name;
+
+ dup_name = strdup(name);
+ if (delimiter != '\0')
+ subst_char(dup_name, delimiter, '/');
+
+ base = g_path_get_basename(dup_name);
+ if (base[0] == '.') {
+ g_free(base);
+ free(dup_name);
+ continue;
+ }
+ if (!all && path_cmp(name, real_path) == 0) {
+ g_free(base);
+ free(dup_name);
+ continue;
+ }
+
+ if (!all && dup_name[strlen(dup_name)-1] == '/') {
+ dup_name[strlen(dup_name)-1] = '\0';
+ }
+
+ loc_name = imap_modified_utf7_to_utf8(base, FALSE);
+ loc_path = imap_modified_utf7_to_utf8(dup_name, FALSE);
+
+ new_item = folder_item_new(FOLDER(folder), loc_name, loc_path);
+ if ((flags & ETPAN_IMAP_MB_NOINFERIORS) != 0)
+ new_item->no_sub = TRUE;
+ if (strcmp(dup_name, "INBOX") != 0 &&
+ ((flags & ETPAN_IMAP_MB_NOSELECT) != 0))
+ new_item->no_select = TRUE;
+
+ if (item_list == NULL)
+ llast = item_list = g_slist_append(item_list, new_item);
+ else {
+ llast = g_slist_append(llast, new_item);
+ llast = llast->next;
+ }
+ debug_print("folder '%s' found.\n", loc_path);
g_free(base);
- free(dup_name);
- continue;
- }
+ g_free(loc_path);
+ g_free(loc_name);
- if (!all && dup_name[strlen(dup_name)-1] == '/') {
- dup_name[strlen(dup_name)-1] = '\0';
- }
-
- loc_name = imap_modified_utf7_to_utf8(base, FALSE);
- loc_path = imap_modified_utf7_to_utf8(dup_name, FALSE);
-
- new_item = folder_item_new(FOLDER(folder), loc_name, loc_path);
- if ((flags & ETPAN_IMAP_MB_NOINFERIORS) != 0)
- new_item->no_sub = TRUE;
- if (strcmp(dup_name, "INBOX") != 0 &&
- ((flags & ETPAN_IMAP_MB_NOSELECT) != 0))
- new_item->no_select = TRUE;
-
- if (item_list == NULL)
- llast = item_list = g_slist_append(item_list, new_item);
- else {
- llast = g_slist_append(llast, new_item);
- llast = llast->next;
+ free(dup_name);
}
- debug_print("folder '%s' found.\n", loc_path);
- g_free(base);
- g_free(loc_path);
- g_free(loc_name);
-
- free(dup_name);
- }
-
+ }
return item_list;
}
result = NULL;
- for(iter = clist_begin(list) ; iter != NULL ;
- iter = clist_next(iter)) {
- uint32_t * puid;
-
- puid = clist_content(iter);
- result = g_slist_prepend(result, GINT_TO_POINTER(* puid));
- }
-
- result = g_slist_reverse(result);
+ if (list) {
+ for(iter = clist_begin(list) ; iter != NULL ;
+ iter = clist_next(iter)) {
+ uint32_t * puid;
+
+ puid = clist_content(iter);
+ result = g_slist_prepend(result, GINT_TO_POINTER(* puid));
+ }
+ result = g_slist_reverse(result);
+ }
return result;
}
((IMAPFolder *)folder)->refcnt++;
}
-void imap_disconnect_all(void)
+void imap_disconnect_all(gboolean have_connectivity)
{
GList *list;
gboolean short_timeout;
RemoteFolder *folder = (RemoteFolder *)account->folder;
if (folder && folder->session) {
IMAPSession *session = (IMAPSession *)folder->session;
- imap_threaded_disconnect(FOLDER(folder));
+ if (have_connectivity)
+ imap_threaded_disconnect(FOLDER(folder));
SESSION(session)->state = SESSION_DISCONNECTED;
SESSION(session)->sock = NULL;
session_destroy(SESSION(session));
return &imap_class;
}
-void imap_disconnect_all(void)
+void imap_disconnect_all(gboolean have_connectivity)
{
}
unsigned long ucs4, utf16, bitbuf;
unsigned char base64[256];
const char *src;
- char *dst, *res = malloc(2*strlen(mbox)+1);
+ char *dst, *res = g_malloc(2*strlen(mbox)+1);
bitbuf = 0;
dst = res;
unsigned long ucs4 = 0, bitbuf = 0;
/* initialize hex lookup table */
- char *dst, *res = malloc(2*strlen(src)+1);
+ char *dst, *res;
+
+ if (!src) return NULL;
+
+ res = malloc(2*strlen(src)+1);
dst = res;
if(!dst) return NULL;
projects / claws.git / blobdiff