#define IMAP_IS_DELETED(flags) ((flags & IMAP_FLAG_DELETED) != 0)
#define IMAP_IS_DRAFT(flags) ((flags & IMAP_FLAG_DRAFT) != 0)
#define IMAP_IS_FORWARDED(flags) ((flags & IMAP_FLAG_FORWARDED) != 0)
+#define IMAP_IS_SPAM(flags) ((flags & IMAP_FLAG_SPAM) != 0)
+#define IMAP_IS_HAM(flags) ((flags & IMAP_FLAG_HAM) != 0)
#define IMAP4_PORT 143
static IMAPSession *imap_session_new (Folder *folder,
const PrefsAccount *account);
-static gint imap_session_authenticate(IMAPSession *session,
- const PrefsAccount *account);
+static gint imap_session_authenticate(IMAPSession *session,
+ PrefsAccount *account);
static void imap_session_destroy (Session *session);
static gchar *imap_fetch_msg (Folder *folder,
static gchar imap_get_path_separator (IMAPSession *session,
IMAPFolder *folder,
- const gchar *path);
+ const gchar *path,
+ gint *ok);
static gchar *imap_get_real_path (IMAPSession *session,
IMAPFolder *folder,
- const gchar *path);
+ const gchar *path,
+ gint *ok);
#ifdef HAVE_LIBETPAN
static void imap_synchronise (FolderItem *item, gint days);
#endif
return;
if (!session)
return;
- rfolder->session = NULL;
log_warning(LOG_PROTOCOL, _("IMAP4 connection broken\n"));
SESSION(session)->state = SESSION_DISCONNECTED;
SESSION(session)->sock = NULL;
- session_destroy(SESSION(session));
}
static gboolean is_fatal(int libetpan_errcode)
static void imap_handle_error(Session *session, int libetpan_errcode)
{
+ const gchar *session_server = (session ? session->server:"(null)");
switch(libetpan_errcode) {
case MAILIMAP_NO_ERROR:
return;
case MAILIMAP_NO_ERROR_AUTHENTICATED:
- log_warning(LOG_PROTOCOL, _("IMAP error: authenticated\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: authenticated\n"), session_server);
break;
case MAILIMAP_NO_ERROR_NON_AUTHENTICATED:
- log_warning(LOG_PROTOCOL, _("IMAP error: not authenticated\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: not authenticated\n"), session_server);
break;
case MAILIMAP_ERROR_BAD_STATE:
- log_warning(LOG_PROTOCOL, _("IMAP error: bad state\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: bad state\n"), session_server);
break;
case MAILIMAP_ERROR_STREAM:
- log_warning(LOG_PROTOCOL, _("IMAP error: stream error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: stream error\n"), session_server);
break;
case MAILIMAP_ERROR_PARSE:
- log_warning(LOG_PROTOCOL, _("IMAP error: parse error "
- "(very probably non-RFC compliance from the server)\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: parse error "
+ "(very probably non-RFC compliance from the server)\n"), session_server);
break;
case MAILIMAP_ERROR_CONNECTION_REFUSED:
- log_warning(LOG_PROTOCOL, _("IMAP error: connection refused\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: connection refused\n"), session_server);
break;
case MAILIMAP_ERROR_MEMORY:
- log_warning(LOG_PROTOCOL, _("IMAP error: memory error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: memory error\n"), session_server);
break;
case MAILIMAP_ERROR_FATAL:
- log_warning(LOG_PROTOCOL, _("IMAP error: fatal error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: fatal error\n"), session_server);
break;
case MAILIMAP_ERROR_PROTOCOL:
- log_warning(LOG_PROTOCOL, _("IMAP error: protocol error"
- "(very probably non-RFC compliance from the server)\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: protocol error"
+ "(very probably non-RFC compliance from the server)\n"), session_server);
break;
case MAILIMAP_ERROR_DONT_ACCEPT_CONNECTION:
- log_warning(LOG_PROTOCOL, _("IMAP error: connection not accepted\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: connection not accepted\n"), session_server);
break;
case MAILIMAP_ERROR_APPEND:
- log_warning(LOG_PROTOCOL, _("IMAP error: APPEND error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: APPEND error\n"), session_server);
break;
case MAILIMAP_ERROR_NOOP:
- log_warning(LOG_PROTOCOL, _("IMAP error: NOOP error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: NOOP error\n"), session_server);
break;
case MAILIMAP_ERROR_LOGOUT:
- log_warning(LOG_PROTOCOL, _("IMAP error: LOGOUT error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: LOGOUT error\n"), session_server);
break;
case MAILIMAP_ERROR_CAPABILITY:
- log_warning(LOG_PROTOCOL, _("IMAP error: CAPABILITY error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: CAPABILITY error\n"), session_server);
break;
case MAILIMAP_ERROR_CHECK:
- log_warning(LOG_PROTOCOL, _("IMAP error: CHECK error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: CHECK error\n"), session_server);
break;
case MAILIMAP_ERROR_CLOSE:
- log_warning(LOG_PROTOCOL, _("IMAP error: CLOSE error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: CLOSE error\n"), session_server);
break;
case MAILIMAP_ERROR_EXPUNGE:
- log_warning(LOG_PROTOCOL, _("IMAP error: EXPUNGE error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: EXPUNGE error\n"), session_server);
break;
case MAILIMAP_ERROR_COPY:
- log_warning(LOG_PROTOCOL, _("IMAP error: COPY error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: COPY error\n"), session_server);
break;
case MAILIMAP_ERROR_UID_COPY:
- log_warning(LOG_PROTOCOL, _("IMAP error: UID COPY error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: UID COPY error\n"), session_server);
break;
case MAILIMAP_ERROR_CREATE:
- log_warning(LOG_PROTOCOL, _("IMAP error: CREATE error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: CREATE error\n"), session_server);
break;
case MAILIMAP_ERROR_DELETE:
- log_warning(LOG_PROTOCOL, _("IMAP error: DELETE error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: DELETE error\n"), session_server);
break;
case MAILIMAP_ERROR_EXAMINE:
- log_warning(LOG_PROTOCOL, _("IMAP error: EXAMINE error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: EXAMINE error\n"), session_server);
break;
case MAILIMAP_ERROR_FETCH:
- log_warning(LOG_PROTOCOL, _("IMAP error: FETCH error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: FETCH error\n"), session_server);
break;
case MAILIMAP_ERROR_UID_FETCH:
- log_warning(LOG_PROTOCOL, _("IMAP error: UID FETCH error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: UID FETCH error\n"), session_server);
break;
case MAILIMAP_ERROR_LIST:
- log_warning(LOG_PROTOCOL, _("IMAP error: LIST error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: LIST error\n"), session_server);
break;
case MAILIMAP_ERROR_LOGIN:
- log_warning(LOG_PROTOCOL, _("IMAP error: LOGIN error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: LOGIN error\n"), session_server);
break;
case MAILIMAP_ERROR_LSUB:
- log_warning(LOG_PROTOCOL, _("IMAP error: LSUB error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: LSUB error\n"), session_server);
break;
case MAILIMAP_ERROR_RENAME:
- log_warning(LOG_PROTOCOL, _("IMAP error: RENAME error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: RENAME error\n"), session_server);
break;
case MAILIMAP_ERROR_SEARCH:
- log_warning(LOG_PROTOCOL, _("IMAP error: SEARCH error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: SEARCH error\n"), session_server);
break;
case MAILIMAP_ERROR_UID_SEARCH:
- log_warning(LOG_PROTOCOL, _("IMAP error: UID SEARCH error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: UID SEARCH error\n"), session_server);
break;
case MAILIMAP_ERROR_SELECT:
- log_warning(LOG_PROTOCOL, _("IMAP error: SELECT error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: SELECT error\n"), session_server);
break;
case MAILIMAP_ERROR_STATUS:
- log_warning(LOG_PROTOCOL, _("IMAP error: STATUS error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: STATUS error\n"), session_server);
break;
case MAILIMAP_ERROR_STORE:
- log_warning(LOG_PROTOCOL, _("IMAP error: STORE error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: STORE error\n"), session_server);
break;
case MAILIMAP_ERROR_UID_STORE:
- log_warning(LOG_PROTOCOL, _("IMAP error: UID STORE error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: UID STORE error\n"), session_server);
break;
case MAILIMAP_ERROR_SUBSCRIBE:
- log_warning(LOG_PROTOCOL, _("IMAP error: SUBSCRIBE error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: SUBSCRIBE error\n"), session_server);
break;
case MAILIMAP_ERROR_UNSUBSCRIBE:
- log_warning(LOG_PROTOCOL, _("IMAP error: UNSUBSCRIBE error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: UNSUBSCRIBE error\n"), session_server);
break;
case MAILIMAP_ERROR_STARTTLS:
- log_warning(LOG_PROTOCOL, _("IMAP error: STARTTLS error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: STARTTLS error\n"), session_server);
break;
case MAILIMAP_ERROR_INVAL:
- log_warning(LOG_PROTOCOL, _("IMAP error: INVAL error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: INVAL error\n"), session_server);
break;
case MAILIMAP_ERROR_EXTENSION:
- log_warning(LOG_PROTOCOL, _("IMAP error: EXTENSION error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: EXTENSION error\n"), session_server);
break;
case MAILIMAP_ERROR_SASL:
- log_warning(LOG_PROTOCOL, _("IMAP error: SASL error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: SASL error\n"), session_server);
break;
-#if (LIBETPAN_VERSION_MAJOR > 0 || LIBETPAN_VERSION_MINOR > 48)
#if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
case MAILIMAP_ERROR_SSL:
- log_warning(LOG_PROTOCOL, _("IMAP error: SSL error\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: SSL error\n"), session_server);
break;
-#endif
#endif
default:
- log_warning(LOG_PROTOCOL, _("IMAP error: Unknown error [%d]\n"),
- libetpan_errcode);
+ log_warning(LOG_PROTOCOL, _("IMAP error on %s: Unknown error [%d]\n"),
+ session_server, libetpan_errcode);
break;
}
capabilities = imap_threaded_capability(session->folder, &result);
if (result != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), result);
- return MAILIMAP_ERROR_CAPABILITY;
+ return result;
}
if (capabilities == NULL) {
static gint imap_auth(IMAPSession *session, const gchar *user, const gchar *pass,
IMAPAuthType type)
{
- gint ok = MAILIMAP_ERROR_BAD_STATE;
+ gint ok = MAILIMAP_ERROR_LOGIN;
static time_t last_login_err = 0;
gchar *ext_info = "";
int r;
+ gchar *server = NULL;
if ((r = imap_get_capabilities(session)) != MAILIMAP_NO_ERROR) {
imap_handle_error(SESSION(session), r);
return r;
}
+ server = g_strdup(SESSION(session)->server);
switch(type) {
case IMAP_AUTH_ANON:
ok = imap_cmd_login(session, user, pass, "ANONYMOUS");
imap_has_capability(session, "GSSAPI"));
if (imap_has_capability(session, "CRAM-MD5"))
ok = imap_cmd_login(session, user, pass, "CRAM-MD5");
- if ((ok == MAILIMAP_ERROR_BAD_STATE ||
- ok == MAILIMAP_ERROR_LOGIN) && imap_has_capability(session, "DIGEST-MD5"))
+ if (ok == MAILIMAP_ERROR_LOGIN && imap_has_capability(session, "DIGEST-MD5"))
ok = imap_cmd_login(session, user, pass, "DIGEST-MD5");
- if ((ok == MAILIMAP_ERROR_BAD_STATE ||
- ok == MAILIMAP_ERROR_LOGIN) && imap_has_capability(session, "GSSAPI"))
+ if (ok == MAILIMAP_ERROR_LOGIN && imap_has_capability(session, "GSSAPI"))
ok = imap_cmd_login(session, user, pass, "GSSAPI");
- if (ok == MAILIMAP_ERROR_BAD_STATE||
- ok == MAILIMAP_ERROR_LOGIN) /* we always try LOGIN before giving up */
+ if (ok == MAILIMAP_ERROR_LOGIN) /* we always try LOGIN before giving up */
ok = imap_cmd_login(session, user, pass, "LOGIN");
}
if (!prefs_common.no_recv_err_panel) {
alertpanel_error_log(_("Connection to %s failed: "
"login refused.%s"),
- SESSION(session)->server, ext_info);
+ server, ext_info);
} else {
log_error(LOG_PROTOCOL, _("Connection to %s failed: "
"login refused.%s\n"),
- SESSION(session)->server, ext_info);
+ server, ext_info);
}
}
last_login_err = time(NULL);
}
+ g_free(server);
return ok;
}
}
/* Make sure we have a session */
- if (rfolder->session != NULL) {
+ if (rfolder->session != NULL && rfolder->session->state != SESSION_DISCONNECTED) {
session = IMAP_SESSION(rfolder->session);
+ } else if (rfolder->session != NULL && rfolder->session->state == SESSION_DISCONNECTED) {
+ session_destroy(SESSION(rfolder->session));
+ rfolder->session = NULL;
+ goto new_conn;
} else if (rfolder->connecting) {
debug_print("already connecting\n");
return NULL;
} else {
+new_conn:
imap_reset_uid_lists(folder);
if (time(NULL) - rfolder->last_failure <= 2)
return NULL;
authenticated = FALSE;
}
else {
-#if (LIBETPAN_VERSION_MAJOR > 0 || LIBETPAN_VERSION_MINOR > 48)
#if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
if (r == MAILIMAP_ERROR_SSL)
log_error(LOG_PROTOCOL, _("SSL handshake failed\n"));
else
-#endif
#endif
imap_handle_error(NULL, r);
}
session = g_new0(IMAPSession, 1);
- session_init(SESSION(session));
+ session_init(SESSION(session), account, FALSE);
SESSION(session)->type = SESSION_IMAP;
SESSION(session)->server = g_strdup(account->recv_server);
SESSION(session)->port = port;
}
static gint imap_session_authenticate(IMAPSession *session,
- const PrefsAccount *account)
+ PrefsAccount *account)
{
gchar *pass, *acc_pass;
gboolean failed = FALSE;
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(account->recv_server, account->userid);
+ tmp_pass = input_dialog_query_password_keep(account->recv_server,
+ account->userid,
+ &(account->session_passwd));
if (!tmp_pass)
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"),
if (!failed && !is_fatal(ok)) {
acc_pass = NULL;
failed = TRUE;
+ if (account->session_passwd != NULL) {
+ g_free(account->session_passwd);
+ account->session_passwd = NULL;
+ }
goto try_again;
} else {
if (prefs_common.no_recv_err_panel) {
- log_error(LOG_PROTOCOL, _("Couldn't login to IMAP server %s."), account->recv_server);
+ log_error(LOG_PROTOCOL, _("Couldn't login to IMAP server %s.\n"), account->recv_server);
mainwindow_show_error();
} else
alertpanel_error_log(_("Couldn't login to IMAP server %s."), account->recv_server);
if (filename == NULL)
return -1;
- fp = fopen(filename, "rb");
+ fp = g_fopen(filename, "rb");
if (!fp)
return -1;
NULL, NULL, NULL, NULL, &can_create_tags, FALSE);
if (ok != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), ok);
return;
}
for (cur = tags_set; cur; cur = cur->next) {
gint cur_tag = GPOINTER_TO_INT(cur->data);
const gchar *str = tags_get_tag(cur_tag);
- list_set = g_slist_prepend(list_set, g_strdup(str));
+ if (strcmp(str, "$Forwarded") && strcmp(str, "Junk") && strcmp(str, "NonJunk") && strcmp(str, "NotJunk") && strcmp(str, "NoJunk") && strcmp(str, "Junk") )
+ list_set = g_slist_prepend(list_set, g_strdup(str));
}
if (list_set) {
ok = imap_set_message_flags(session,
for (cur = tags_unset; cur; cur = cur->next) {
gint cur_tag = GPOINTER_TO_INT(cur->data);
const gchar *str = tags_get_tag(cur_tag);
- list_unset = g_slist_prepend(list_unset, g_strdup(str));
+ if (strcmp(str, "$Forwarded") && strcmp(str, "Junk") && strcmp(str, "NonJunk") && strcmp(str, "NotJunk") && strcmp(str, "NoJunk") && strcmp(str, "Junk") )
+ list_unset = g_slist_prepend(list_unset, g_strdup(str));
}
if (list_unset) {
ok = imap_set_message_flags(session,
if (!session) {
return -1;
}
- destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path);
-
+ destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path, &ok);
+ if (is_fatal(ok))
+ return -1;
statusbar_print_all(_("Adding messages..."));
total = g_slist_length(file_list);
for (cur = file_list; cur != NULL; cur = cur->next) {
iflags |= IMAP_FLAG_ANSWERED;
if (MSG_IS_FORWARDED(*fileinfo->flags))
iflags |= IMAP_FLAG_FORWARDED;
+ if (MSG_IS_SPAM(*fileinfo->flags))
+ iflags |= IMAP_FLAG_SPAM;
+ else
+ iflags |= IMAP_FLAG_HAM;
if (!MSG_IS_UNREAD(*fileinfo->flags))
iflags |= IMAP_FLAG_SEEN;
unlock_session(session);
- destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path);
+ destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path, &ok);
+
+ if (is_fatal(ok))
+ 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);
return ok;
}
- destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path);
+ destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path, &ok);
+ if (is_fatal(ok))
+ return ok;
for (cur = msglist; cur; cur = cur->next) {
msginfo = (MsgInfo *)cur->data;
if (!MSG_IS_DELETED(msginfo->flags))
extract_quote(root_folder, '"');
subst_char(root_folder,
imap_get_path_separator(session, IMAP_FOLDER(folder),
- root_folder),
+ root_folder, &r),
'/');
+ if (is_fatal(r))
+ return -1;
strtailchomp(root_folder, '/');
real_path = imap_get_real_path
- (session, IMAP_FOLDER(folder), root_folder);
+ (session, IMAP_FOLDER(folder), root_folder, &r);
+ if (is_fatal(r))
+ return -1;
debug_print("IMAP root directory: %s\n", real_path);
/* check if root directory exist */
folder = item->folder;
imapfolder = IMAP_FOLDER(folder);
- separator = imap_get_path_separator(session, imapfolder, item->path);
+ separator = imap_get_path_separator(session, imapfolder, item->path, &r);
+ if (is_fatal(r))
+ return r;
if (folder->ui_func)
folder->ui_func(folder, item, folder->ui_func_data);
wildcard[0] = separator;
wildcard[1] = '%';
wildcard[2] = '\0';
- real_path = imap_get_real_path(session, imapfolder, item->path);
+ real_path = imap_get_real_path(session, imapfolder, item->path, &r);
+ if (is_fatal(r))
+ return r;
} else {
wildcard[0] = '%';
wildcard[1] = '\0';
if (r != MAILIMAP_NO_ERROR) {
imap_handle_error(SESSION(session), r);
item_list = NULL;
+ return r;
}
else {
item_list = imap_list_from_lep(imapfolder,
if (!session)
return NULL;
- separator = imap_get_path_separator(session, IMAP_FOLDER(folder), item->path);
+ separator = imap_get_path_separator(session, IMAP_FOLDER(folder), item->path, &r);
+ if (is_fatal(r))
+ return NULL;
if (item->path) {
wildcard[0] = separator;
wildcard[1] = '%';
wildcard[2] = '\0';
- real_path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path);
+ real_path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path, &r);
+ if (is_fatal(r))
+ return NULL;
} else {
wildcard[0] = '%';
wildcard[1] = '\0';
}
child_list = g_list_prepend(child_list,
imap_get_real_path(session,
- IMAP_FOLDER(folder), cur_item->path));
-
+ IMAP_FOLDER(folder), cur_item->path, &r));
+ if (is_fatal(r)) {
+ statusbar_pop_all();
+ return NULL;
+ }
folder_item_destroy(cur_item);
}
child_list = g_list_reverse(child_list);
FolderItem *cur_item = FOLDER_ITEM(cur->data);
GList *oldlitem = NULL;
gchar *tmp = imap_get_real_path(session,
- IMAP_FOLDER(folder), cur_item->path);
+ IMAP_FOLDER(folder), cur_item->path, &r);
+ if (r) {
+ statusbar_pop_all();
+ return NULL;
+ }
folder_item_destroy(cur_item);
oldlitem = g_list_find_custom(
child_list, tmp, (GCompareFunc)strcmp2);
return folder_path;
}
+#ifdef G_OS_WIN32
+static gchar *imap_encode_unsafe_chars(const gchar *str)
+{
+ gchar *ret = NULL, *o_ret;
+ gchar *i;
+ if (!str)
+ return NULL;
+ ret = g_malloc(3*strlen(str)+1);
+ o_ret = ret;
+ for (i = str; *i; i++) {
+ switch(*i) {
+ case ':':
+ case '|':
+ case '<':
+ case '>':
+ case '*':
+ case '?':
+ case '#':
+ *ret++ = '%';
+ *ret++ = '0'+(*i/10);
+ *ret++ = '0'+(*i%10);
+ break;
+ default:
+ *ret++ = *i;
+ }
+ }
+ *ret++ = '\0';
+ return o_ret;
+}
+#endif
static gchar *imap_item_get_path(Folder *folder, FolderItem *item)
{
gchar *folder_path, *path;
-
+ gchar *item_path = NULL;
+
g_return_val_if_fail(folder != NULL, NULL);
g_return_val_if_fail(item != NULL, NULL);
folder_path = imap_folder_get_path(folder);
g_return_val_if_fail(folder_path != NULL, NULL);
- if (folder_path[0] == G_DIR_SEPARATOR) {
- if (item->path)
+
+#ifdef G_OS_UNIX
+ item_path = g_strdup(item->path);
+#else
+ item_path = imap_encode_unsafe_chars(item->path);
+#endif
+
+ if (g_path_is_absolute(folder_path)) {
+ if (item_path)
path = g_strconcat(folder_path, G_DIR_SEPARATOR_S,
- item->path, NULL);
+ item_path, NULL);
else
path = g_strdup(folder_path);
} else {
- if (item->path)
+ if (item_path)
path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
folder_path, G_DIR_SEPARATOR_S,
- item->path, NULL);
+ item_path, NULL);
else
path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
folder_path, NULL);
}
g_free(folder_path);
+ g_free(item_path);
+#ifdef G_OS_WIN32
+ while (strchr(path, '/'))
+ *strchr(path, '/') = '\\';
+#endif
return path;
}
g_free(dirpath);
return NULL;});
- separator = imap_get_path_separator(session, IMAP_FOLDER(folder), imap_path);
+ separator = imap_get_path_separator(session, IMAP_FOLDER(folder), imap_path, &ok);
+ if (is_fatal(ok))
+ return NULL;
imap_path_separator_subst(imap_path, separator);
/* remove trailing / for display */
strtailchomp(new_name, '/');
return -1;
}
- if (strchr(name, imap_get_path_separator(session, IMAP_FOLDER(folder), item->path)) != NULL) {
+ if (strchr(name, imap_get_path_separator(session, IMAP_FOLDER(folder), item->path, &ok)) != NULL ||
+ is_fatal(ok)) {
g_warning(_("New folder name must not contain the namespace "
"path separator"));
return -1;
}
- real_oldpath = imap_get_real_path(session, IMAP_FOLDER(folder), item->path);
+ real_oldpath = imap_get_real_path(session, IMAP_FOLDER(folder), item->path, &ok);
+ if (is_fatal(ok)) {
+ return -1;
+ }
g_free(session->mbox);
session->mbox = NULL;
return -1;
}
- separator = imap_get_path_separator(session, IMAP_FOLDER(folder), item->path);
+ separator = imap_get_path_separator(session, IMAP_FOLDER(folder), item->path, &ok);
+ if (is_fatal(ok))
+ return -1;
if (strchr(item->path, G_DIR_SEPARATOR)) {
dirpath = g_path_get_dirname(item->path);
newpath = g_strconcat(dirpath, G_DIR_SEPARATOR_S, name, NULL);
return -1;
}
if (item && item->path) {
- path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path);
- if (!path)
+ path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path, &r);
+ if (!path || is_fatal(r))
return -1;
if (!strcmp(path, "INBOX") && sub == FALSE)
return -1;
if (!session) {
return -1;
}
- path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path);
+ path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path, &ok);
+ if (is_fatal(ok))
+ return -1;
imap_threaded_subscribe(folder, path, FALSE);
ok = imap_cmd_close(session);
if (ok != MAILIMAP_NO_ERROR) {
debug_print("close err %d\n", ok);
- imap_handle_error(SESSION(session), ok);
return ok;
}
}
ok = imap_cmd_delete(session, path);
- if (ok != MAILIMAP_NO_ERROR) {
+ if (ok != MAILIMAP_NO_ERROR && !is_fatal(ok)) {
gchar *tmp = g_strdup_printf("%s%c", path,
- imap_get_path_separator(session, IMAP_FOLDER(folder), path));
+ imap_get_path_separator(session, IMAP_FOLDER(folder), path, &ok));
g_free(path);
path = tmp;
- ok = imap_cmd_delete(session, path);
+ if (!is_fatal(ok))
+ ok = imap_cmd_delete(session, path);
}
if (ok != MAILIMAP_NO_ERROR) {
IMAPFolder *imap_folder = NULL;
IMAPSession *session = NULL;
gchar result = '/';
-
+ gint ok;
if (!item)
return '/';
folder = item->folder;
debug_print("getting session...");
session = imap_session_get(FOLDER(folder));
- result = imap_get_path_separator(session, imap_folder, item->path);
+ result = imap_get_path_separator(session, imap_folder, item->path, &ok);
return result;
}
-static gchar imap_refresh_path_separator(IMAPSession *session, IMAPFolder *folder, const gchar *subfolder)
+static gchar imap_refresh_path_separator(IMAPSession *session, IMAPFolder *folder, const gchar *subfolder, gint *ok)
{
clist * lep_list;
int r;
if (r != MAILIMAP_NO_ERROR) {
imap_handle_error(SESSION(session), r);
log_warning(LOG_PROTOCOL, _("LIST failed\n"));
+ *ok = r;
return '\0';
}
separator = mb->mb_delimiter;
debug_print("got separator: %c\n", folder->last_seen_separator);
}
+ *ok = MAILIMAP_NO_ERROR;
mailimap_list_result_free(lep_list);
return separator;
}
-static gchar imap_get_path_separator(IMAPSession *session, IMAPFolder *folder, const gchar *path)
+static gchar imap_get_path_separator(IMAPSession *session, IMAPFolder *folder, const gchar *path, gint *ok)
{
gchar separator = '/';
if (folder->last_seen_separator == 0) {
- folder->last_seen_separator = imap_refresh_path_separator(session, folder, "");
+ folder->last_seen_separator = imap_refresh_path_separator(session, folder, "", ok);
}
if (folder->last_seen_separator == 0) {
- folder->last_seen_separator = imap_refresh_path_separator(session, folder, "INBOX");
+ folder->last_seen_separator = imap_refresh_path_separator(session, folder, "INBOX", ok);
}
if (folder->last_seen_separator != 0) {
return separator;
}
-static gchar *imap_get_real_path(IMAPSession *session, IMAPFolder *folder, const gchar *path)
+static gchar *imap_get_real_path(IMAPSession *session, IMAPFolder *folder, const gchar *path, gint *ok)
{
gchar *real_path;
gchar separator;
g_return_val_if_fail(path != NULL, NULL);
real_path = imap_utf8_to_modified_utf7(path, FALSE);
- separator = imap_get_path_separator(session, folder, path);
+ separator = imap_get_path_separator(session, folder, path, ok);
imap_path_separator_subst(real_path, separator);
return real_path;
session->recent = 0;
session->expunge = 0;
- real_path = imap_get_real_path(session, folder, path);
-
+ real_path = imap_get_real_path(session, folder, path, &ok);
+ if (is_fatal(ok))
+ return ok;
g_slist_free(IMAP_FOLDER_ITEM(item)->ok_flags);
IMAP_FOLDER_ITEM(item)->ok_flags = NULL;
ok = imap_cmd_select(session, real_path,
gchar *real_path;
guint mask = 0;
- real_path = imap_get_real_path(session, folder, path);
+ real_path = imap_get_real_path(session, folder, path, &r);
+ if (is_fatal(r))
+ return r;
if (messages) {
mask |= 1 << 0;
!strcmp(session->mbox, item->item.path)) {
r = imap_cmd_close(session);
if (r != MAILIMAP_NO_ERROR) {
- imap_handle_error(SESSION(session), r);
debug_print("close err %d\n", r);
return r;
}
"has been compiled without OpenSSL "
"support.\n"),
SESSION(session)->server);
- return MAILIMAP_ERROR_BAD_STATE;
+ return MAILIMAP_ERROR_LOGIN;
#endif
} else {
log_error(LOG_PROTOCOL, _("Server logins are disabled.\n"));
- return MAILIMAP_ERROR_BAD_STATE;
+ return MAILIMAP_ERROR_LOGIN;
}
}
r = imap_threaded_create(session->folder, folder);
if (r != MAILIMAP_NO_ERROR) {
imap_handle_error(SESSION(session), r);
-
return r;
}
if (r != MAILIMAP_NO_ERROR) {
imap_handle_error(SESSION(session), r);
debug_print("fetch err %d\n", r);
- return GINT_TO_POINTER(MAILIMAP_ERROR_BAD_STATE);
+ return GINT_TO_POINTER(r);
}
return GINT_TO_POINTER(MAILIMAP_NO_ERROR);
}
gchar *new_itempath;
gint oldpathlen;
IMAPSession *session = imap_session_get(item->folder);
-
+ gint ok;
oldpathlen = strlen(oldpath);
if (strncmp(oldpath, item->path, oldpathlen) != 0) {
g_warning("path doesn't match: %s, %s\n", oldpath, item->path);
new_itempath = g_strconcat(newpath, G_DIR_SEPARATOR_S, base,
NULL);
- real_oldpath = imap_get_real_path(session, IMAP_FOLDER(item->folder), item->path);
+ real_oldpath = imap_get_real_path(session, IMAP_FOLDER(item->folder), item->path, &ok);
g_free(item->path);
item->path = new_itempath;
- real_newpath = imap_get_real_path(session, IMAP_FOLDER(item->folder), item->path);
+ real_newpath = imap_get_real_path(session, IMAP_FOLDER(item->folder), item->path, &ok);
imap_threaded_subscribe(item->folder, real_oldpath, FALSE);
imap_threaded_subscribe(item->folder, real_newpath, TRUE);
if ( MSG_IS_FORWARDED(msginfo->flags) && !(newflags & MSG_FORWARDED))
flags_unset |= IMAP_FLAG_FORWARDED;
+ if (!MSG_IS_SPAM(msginfo->flags) && (newflags & MSG_SPAM)) {
+ flags_set |= IMAP_FLAG_SPAM;
+ flags_unset |= IMAP_FLAG_HAM;
+ }
+ if ( MSG_IS_SPAM(msginfo->flags) && !(newflags & MSG_SPAM)) {
+ flags_set |= IMAP_FLAG_HAM;
+ flags_unset |= IMAP_FLAG_SPAM;
+ }
if (!MSG_IS_DELETED(msginfo->flags) && (newflags & MSG_DELETED))
flags_set |= IMAP_FLAG_DELETED;
if ( MSG_IS_DELETED(msginfo->flags) && !(newflags & MSG_DELETED))
GHashTable *tags_hash = NULL;
gboolean full_search = stuff->full_search;
GSList *sorted_list = NULL;
- GSList *unseen = NULL, *answered = NULL, *flagged = NULL, *deleted = NULL, *forwarded = NULL;
+ GSList *unseen = NULL, *answered = NULL, *flagged = NULL, *deleted = NULL, *forwarded = NULL, *spam = NULL;
GSList *seq_list, *cur;
gboolean reverse_seen = FALSE;
gboolean selected_folder;
}
}
+ if (flag_ok(IMAP_FOLDER_ITEM(fitem), IMAP_FLAG_SPAM)) {
+ r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_SPAM,
+ full_search ? NULL:imapset, &lep_uidlist);
+ if (r == MAILIMAP_NO_ERROR) {
+ GSList * uidlist;
+
+ uidlist = imap_uid_list_from_lep(lep_uidlist);
+ mailimap_search_result_free(lep_uidlist);
+
+ spam = g_slist_concat(spam, uidlist);
+ } else {
+ imap_handle_error(SESSION(session), r);
+ goto bail;
+ }
+ }
+
r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_DELETED,
full_search ? NULL:imapset, &lep_uidlist);
if (r == MAILIMAP_NO_ERROR) {
msginfo = (MsgInfo *) elem->data;
flags = msginfo->flags.perm_flags;
wasnew = (flags & MSG_NEW);
- oldflags = flags & ~(MSG_NEW|MSG_UNREAD|MSG_REPLIED|MSG_FORWARDED|MSG_MARKED|MSG_DELETED);
+ oldflags = flags & ~(MSG_NEW|MSG_UNREAD|MSG_REPLIED|MSG_FORWARDED|MSG_MARKED|MSG_DELETED|MSG_SPAM);
if (folder->account && folder->account->low_bandwidth) {
if (fitem->opened || fitem->processing_pending || fitem == folder->inbox) {
- flags &= ~((reverse_seen ? 0 : MSG_UNREAD | MSG_NEW) | MSG_REPLIED | MSG_FORWARDED | MSG_MARKED);
+ flags &= ~((reverse_seen ? 0 : MSG_UNREAD | MSG_NEW) | MSG_REPLIED | MSG_FORWARDED | MSG_MARKED | MSG_SPAM);
} else {
flags &= ~((reverse_seen ? 0 : MSG_UNREAD | MSG_NEW | MSG_MARKED));
}
flags |= MSG_FORWARDED;
else
flags &= ~MSG_FORWARDED;
+ if (gslist_find_next_num(&spam, msginfo->msgnum) == msginfo->msgnum)
+ flags |= MSG_SPAM;
+ else
+ flags &= ~MSG_SPAM;
if (gslist_find_next_num(&deleted, msginfo->msgnum) == msginfo->msgnum)
flags |= MSG_DELETED;
else
g_slist_free(deleted);
g_slist_free(answered);
g_slist_free(forwarded);
+ g_slist_free(spam);
g_slist_free(unseen);
g_slist_free(sorted_list);
{
MsgInfo *msginfo = NULL;
guint32 uid = 0;
- size_t size = 0;
+ goffset size = 0;
MsgFlags flags = {0, 0};
if (info->headers == NULL)
flags.perm_flags = info->flags;
uid = info->uid;
- size = info->size;
+ size = (goffset) info->size;
msginfo = procheader_parse_str(info->headers, flags, FALSE, FALSE);
if (msginfo) {
if (IMAP_IS_FORWARDED(flags) && flag_ok(item, IMAP_FLAG_FORWARDED))
mailimap_flag_list_add(flag_list,
mailimap_flag_new_flag_keyword(strdup("$Forwarded")));
+ if (IMAP_IS_SPAM(flags) && flag_ok(item, IMAP_FLAG_SPAM))
+ mailimap_flag_list_add(flag_list,
+ mailimap_flag_new_flag_keyword(strdup("Junk")));
+ else if (IMAP_IS_HAM(flags) && flag_ok(item, IMAP_FLAG_HAM))
+ mailimap_flag_list_add(flag_list,
+ mailimap_flag_new_flag_keyword(strdup("NonJunk")));
for (; cur; cur = cur->next) {
gchar *enc_str =
projects / claws.git / blobdiff