/*
- * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
- * Copyright (C) 1999-2012 Hiroyuki Yamamoto and the Claws Mail team
+ * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
+ * Copyright (C) 1999-2020 the Claws Mail team and Hiroyuki Yamamoto
*
* 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
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
*/
#ifdef HAVE_CONFIG_H
#include "prefs_account.h"
#include "codeconv.h"
#include "md5.h"
-#include "base64.h"
#include "utils.h"
#include "prefs_common.h"
#include "inputdialog.h"
#include "account.h"
#include "tags.h"
#include "main.h"
+#include "passwordstore.h"
+#include "file-utils.h"
typedef struct _IMAPFolder IMAPFolder;
typedef struct _IMAPSession IMAPSession;
typedef struct _IMAPNameSpace IMAPNameSpace;
typedef struct _IMAPFolderItem IMAPFolderItem;
-#include "prefs_account.h"
-
#define IMAP_FOLDER(obj) ((IMAPFolder *)obj)
#define IMAP_FOLDER_ITEM(obj) ((IMAPFolderItem *)obj)
#define IMAP_SESSION(obj) ((IMAPSession *)obj)
gchar last_seen_separator;
guint refcnt;
guint max_set_size;
- const gchar *search_charset;
+ gchar *search_charset;
gboolean search_charset_supported;
};
const gchar *name);
static gint imap_do_copy_msgs (Folder *folder,
+ FolderItem *dest,
+ MsgInfoList *msglist,
+ GHashTable *relation,
+ gboolean same_dest_ok);
+
+static gint imap_do_remove_msgs (Folder *folder,
FolderItem *dest,
MsgInfoList *msglist,
GHashTable *relation);
IMAPFlags flags,
GSList *tags,
int do_add);
-static gint imap_cmd_expunge (IMAPSession *session, gboolean force);
+static gint imap_cmd_expunge (IMAPSession *session);
static void imap_path_separator_subst (gchar *str,
gchar separator);
FolderItem *item,
MsgInfoList *msglist,
GHashTable *msgflags);
-static gchar *imap_folder_get_path (Folder *folder);
static gchar *imap_item_get_path (Folder *folder,
FolderItem *item);
static MsgInfo *imap_parse_msg(const gchar *file, FolderItem *item);
if (imap_class.idstr == NULL) {
imap_class.type = F_IMAP;
imap_class.idstr = "imap";
- imap_class.uistr = "IMAP4";
+ imap_class.uistr = "IMAP";
imap_class.supports_server_search = TRUE;
/* Folder functions */
imap_class.synchronise = imap_synchronise;
imap_class.remove_cached_msg = imap_remove_cached_msg;
imap_class.commit_tags = imap_commit_tags;
-#ifdef USE_PTREAD
- pthread_mutex_init(&imap_mutex, NULL);
-#endif
}
return &imap_class;
if (rfolder == NULL)
return;
- log_warning(LOG_PROTOCOL, _("IMAP4 connection broken\n"));
+ log_warning(LOG_PROTOCOL, _("IMAP connection broken\n"));
SESSION(session)->state = SESSION_DISCONNECTED;
SESSION(session)->sock = NULL;
}
}
}
+#define MY_LOG_WARNING(concat_cmd, ...) \
+ msg = concat_cmd; \
+ log_warning(LOG_PROTOCOL, msg, __VA_ARGS__); \
+ g_free(msg);
+
static void imap_handle_error(Session *session, const gchar *server, int libetpan_errcode)
{
const gchar *session_server = (session ? session->server : NULL);
+ gchar *msg;
if (session_server == NULL)
session_server = server;
case MAILIMAP_NO_ERROR:
return;
case MAILIMAP_NO_ERROR_AUTHENTICATED:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: authenticated\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("authenticated"), "\n", NULL), session_server)
break;
case MAILIMAP_NO_ERROR_NON_AUTHENTICATED:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: not authenticated\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("not authenticated"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_BAD_STATE:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: bad state\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("bad state"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_STREAM:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: stream error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("stream error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_PARSE:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: parse error "
- "(very probably non-RFC compliance from the server)\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("parse error "
+ "(very probably non-RFC compliance from the server)"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_CONNECTION_REFUSED:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: connection refused\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("connection refused"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_MEMORY:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: memory error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("memory error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_FATAL:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: fatal error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("fatal error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_PROTOCOL:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: protocol error"
- "(very probably non-RFC compliance from the server)\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("protocol error "
+ "(very probably non-RFC compliance from the server)"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_DONT_ACCEPT_CONNECTION:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: connection not accepted\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("connection not accepted"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_APPEND:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: APPEND error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("APPEND error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_NOOP:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: NOOP error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("NOOP error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_LOGOUT:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: LOGOUT error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("LOGOUT error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_CAPABILITY:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: CAPABILITY error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("CAPABILITY error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_CHECK:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: CHECK error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("CHECK error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_CLOSE:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: CLOSE error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("CLOSE error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_EXPUNGE:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: EXPUNGE error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("EXPUNGE error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_COPY:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: COPY error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("COPY error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_UID_COPY:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: UID COPY error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("UID COPY error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_CREATE:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: CREATE error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("CREATE error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_DELETE:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: DELETE error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("DELETE error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_EXAMINE:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: EXAMINE error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("EXAMINE error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_FETCH:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: FETCH error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("FETCH error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_UID_FETCH:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: UID FETCH error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("UID FETCH error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_LIST:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: LIST error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("LIST error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_LOGIN:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: LOGIN error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("LOGIN error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_LSUB:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: LSUB error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("LSUB error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_RENAME:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: RENAME error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("RENAME error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_SEARCH:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: SEARCH error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("SEARCH error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_UID_SEARCH:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: UID SEARCH error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("UID SEARCH error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_SELECT:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: SELECT error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("SELECT error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_STATUS:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: STATUS error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("STATUS error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_STORE:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: STORE error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("STORE error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_UID_STORE:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: UID STORE error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("UID STORE error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_SUBSCRIBE:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: SUBSCRIBE error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("SUBSCRIBE error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_UNSUBSCRIBE:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: UNSUBSCRIBE error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("UNSUBSCRIBE error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_STARTTLS:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: STARTTLS error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("STARTTLS error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_INVAL:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: INVAL error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("INVAL error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_EXTENSION:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: EXTENSION error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("EXTENSION error"), "\n", NULL), session_server)
break;
case MAILIMAP_ERROR_SASL:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: SASL error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("SASL error"), "\n", NULL), session_server)
break;
#ifdef USE_GNUTLS
case MAILIMAP_ERROR_SSL:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: SSL error\n"), session_server);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("SSL/TLS error"), "\n", NULL), session_server)
break;
#endif
default:
- log_warning(LOG_PROTOCOL, _("IMAP error on %s: Unknown error [%d]\n"),
- session_server, libetpan_errcode);
+ MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("Unknown error [%d]"), "\n", NULL),
+ session_server, libetpan_errcode)
break;
}
}
}
+#undef MY_LOG_WARNING
+
static Folder *imap_folder_new(const gchar *name, const gchar *path)
{
Folder *folder;
{
while (imap_folder_get_refcnt(folder) > 0)
gtk_main_iteration();
-
+
+ g_free(IMAP_FOLDER(folder)->search_charset);
+
folder_remote_folder_destroy(REMOTE_FOLDER(folder));
imap_done(folder);
}
folder_remote_folder_init((Folder *)folder, name, path);
IMAP_FOLDER(folder)->max_set_size = IMAP_SET_MAX_COUNT;
IMAP_FOLDER(folder)->search_charset_supported = TRUE;
- IMAP_FOLDER(folder)->search_charset = conv_get_locale_charset_str_no_utf8();
+ IMAP_FOLDER(folder)->search_charset = g_strdup(conv_get_locale_charset_str_no_utf8());
}
static FolderItem *imap_folder_item_new(Folder *folder)
{
struct mailimap_capability_data *capabilities = NULL;
clistiter *cur;
- int result = -1;
+ int result;
if (session->capability != NULL)
return MAILIMAP_NO_ERROR;
- capabilities = imap_threaded_capability(session->folder, &result);
+ result = imap_threaded_capability(session->folder, &capabilities);
if (result != MAILIMAP_NO_ERROR) {
return result;
case IMAP_AUTH_DIGEST_MD5:
ok = imap_cmd_login(session, user, pass, "DIGEST-MD5");
break;
+ case IMAP_AUTH_SCRAM_SHA1:
+ ok = imap_cmd_login(session, user, pass, "SCRAM-SHA-1");
+ break;
+ case IMAP_AUTH_PLAIN:
+ ok = imap_cmd_login(session, user, pass, "PLAIN");
+ break;
case IMAP_AUTH_LOGIN:
ok = imap_cmd_login(session, user, pass, "LOGIN");
break;
+ case IMAP_AUTH_PLAINTEXT:
+ ok = imap_cmd_login(session, user, pass, "plaintext");
+ break;
case IMAP_AUTH_GSSAPI:
ok = imap_cmd_login(session, user, pass, "GSSAPI");
break;
"\t ANONYMOUS %d\n"
"\t CRAM-MD5 %d\n"
"\t DIGEST-MD5 %d\n"
+ "\t SCRAM-SHA-1 %d\n"
+ "\t PLAIN %d\n"
"\t LOGIN %d\n"
"\t GSSAPI %d\n",
imap_has_capability(session, "ANONYMOUS"),
imap_has_capability(session, "CRAM-MD5"),
imap_has_capability(session, "DIGEST-MD5"),
+ imap_has_capability(session, "SCRAM-SHA-1"),
+ imap_has_capability(session, "PLAIN"),
imap_has_capability(session, "LOGIN"),
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_LOGIN && imap_has_capability(session, "DIGEST-MD5"))
ok = imap_cmd_login(session, user, pass, "DIGEST-MD5");
+ if (ok == MAILIMAP_ERROR_LOGIN && imap_has_capability(session, "SCRAM-SHA-1"))
+ ok = imap_cmd_login(session, user, pass, "SCRAM-SHA-1");
+ if (ok == MAILIMAP_ERROR_LOGIN && imap_has_capability(session, "PLAIN"))
+ ok = imap_cmd_login(session, user, pass, "PLAIN");
+ if (ok == MAILIMAP_ERROR_LOGIN && imap_has_capability(session, "LOGIN"))
+ ok = imap_cmd_login(session, user, pass, "LOGIN");
if (ok == MAILIMAP_ERROR_LOGIN && imap_has_capability(session, "GSSAPI"))
ok = imap_cmd_login(session, user, pass, "GSSAPI");
- if (ok == MAILIMAP_ERROR_LOGIN) /* we always try LOGIN before giving up */
- ok = imap_cmd_login(session, user, pass, "LOGIN");
+ if (ok == MAILIMAP_ERROR_LOGIN) /* we always try plaintext login before giving up */
+ ok = imap_cmd_login(session, user, pass, "plaintext");
}
if (ok == MAILIMAP_NO_ERROR)
"DIGEST-MD5 SASL plugin is installed.");
}
+ if (type == IMAP_AUTH_SCRAM_SHA1) {
+ ext_info = _("\n\nSCRAM-SHA-1 logins only work if libetpan has been "
+ "compiled with SASL support and the "
+ "SCRAM SASL plugin is installed.");
+ }
+
+ if (type == IMAP_AUTH_PLAIN) {
+ ext_info = _("\n\nPLAIN logins only work if libetpan has been "
+ "compiled with SASL support and the "
+ "PLAIN SASL plugin is installed.");
+ }
+
+ if (type == IMAP_AUTH_LOGIN) {
+ ext_info = _("\n\nLOGIN logins only work if libetpan has been "
+ "compiled with SASL support and the "
+ "LOGIN SASL plugin is installed.");
+ }
+
if (time(NULL) - last_login_err > 10) {
if (!prefs_common.no_recv_err_panel) {
alertpanel_error_log(_("Connection to %s failed: "
session = NULL;
} else {
rfolder->session = NULL;
- log_warning(LOG_PROTOCOL, _("IMAP4 connection to %s has been"
+ log_warning(LOG_PROTOCOL, _("IMAP connection to %s has been"
" disconnected. Reconnecting...\n"),
folder->account->recv_server);
- statusbar_print_all(_("IMAP4 connection to %s has been"
+ statusbar_print_all(_("IMAP connection to %s has been"
" disconnected. Reconnecting...\n"),
folder->account->recv_server);
SESSION(session)->state = SESSION_DISCONNECTED;
rfolder->session = NULL;
if (!is_fatal(r)) {
imap_threaded_disconnect(session->folder);
- SESSION(session)->state = SESSION_DISCONNECTED;
- SESSION(session)->sock = NULL;
- imap_safe_destroy(session);
}
+ SESSION(session)->state = SESSION_DISCONNECTED;
+ SESSION(session)->sock = NULL;
+ imap_safe_destroy(session);
rfolder->last_failure = time(NULL);
rfolder->connecting = FALSE;
return NULL;
* successfully sent. -- mbp */
if ((time(NULL) - SESSION(session)->last_access_time > SESSION_TIMEOUT_INTERVAL) || session->cancelled) {
/* verify that the session is still alive */
- if ((r = imap_cmd_noop(session)) != MAILIMAP_NO_ERROR) {
+ r = imap_cmd_noop(session);
+
+ if (r != MAILIMAP_NO_ERROR) {
debug_print("disconnected!\n");
if (!is_fatal(r))
session = imap_reconnect_if_possible(folder, session);
else {
rfolder->session = NULL;
rfolder->connecting = FALSE;
+ SESSION(session)->state = SESSION_DISCONNECTED;
+ SESSION(session)->sock = NULL;
+ imap_safe_destroy(session);
session = imap_session_get(folder);
}
}
const PrefsAccount *account)
{
IMAPSession *session;
+ ProxyInfo *proxy_info = NULL;
gushort port;
int r;
int authenticated = FALSE;
if (account->ssl_imap != SSL_NONE) {
if (alertpanel_full(_("Insecure connection"),
_("This connection is configured to be secured "
- "using SSL, but SSL is not available in this "
- "build of Claws Mail. \n\n"
+ "using SSL/TLS, but SSL/TLS is not available "
+ "in this build of Claws Mail. \n\n"
"Do you want to continue connecting to this "
"server? The communication would not be "
"secure."),
- GTK_STOCK_CANCEL, _("Con_tinue connecting"),
- NULL, FALSE, NULL, ALERT_WARNING,
- G_ALERTDEFAULT) != G_ALERTALTERNATE)
+ GTK_STOCK_CANCEL, _("Con_tinue connecting"), NULL,
+ ALERTFOCUS_FIRST, FALSE, NULL, ALERT_WARNING) != G_ALERTALTERNATE)
return NULL;
}
port = account->set_imapport ? account->imapport
#endif
imap_init(folder);
- buf = g_strdup_printf(_("Account '%s': Connecting to IMAP4 server: %s:%d..."),
+ buf = g_strdup_printf(_("Account '%s': Connecting to IMAP server: %s:%d..."),
folder->account->account_name, folder->account->recv_server,
port);
- statuswindow_print_all("%s", buf);
+ statusbar_print_all("%s", buf);
log_message(LOG_PROTOCOL, "%s\n", buf);
g_free(buf);
+ if (account->use_proxy) {
+ if (account->use_default_proxy) {
+ proxy_info = (ProxyInfo *)&(prefs_common.proxy_info);
+ if (proxy_info->use_proxy_auth)
+ proxy_info->proxy_pass = passwd_store_get(PWS_CORE, PWS_CORE_PROXY,
+ PWS_CORE_PROXY_PASS);
+ } else {
+ proxy_info = (ProxyInfo *)&(account->proxy_info);
+ if (proxy_info->use_proxy_auth)
+ proxy_info->proxy_pass = passwd_store_get_account(account->account_id,
+ PWS_ACCOUNT_PROXY_PASS);
+ }
+ }
+
#ifndef G_OS_WIN32
if (account->set_tunnelcmd) {
r = imap_threaded_connect_cmd(folder,
#endif
{
#ifdef USE_GNUTLS
+
if (ssl_type == SSL_TUNNEL) {
r = imap_threaded_connect_ssl(folder,
account->recv_server,
- port);
+ port,
+ proxy_info);
}
else
#endif
{
r = imap_threaded_connect(folder,
account->recv_server,
- port);
+ port,
+ proxy_info);
}
}
- statuswindow_pop_all();
+ statusbar_pop_all();
if (r == MAILIMAP_NO_ERROR_AUTHENTICATED) {
authenticated = TRUE;
}
else {
#ifdef USE_GNUTLS
if (r == MAILIMAP_ERROR_SSL)
- log_error(LOG_PROTOCOL, _("SSL handshake failed\n"));
+ log_error(LOG_PROTOCOL, _("SSL/TLS handshake failed\n"));
else
#endif
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"),
+ alertpanel_error_log(_("Can't connect to IMAP server: %s:%d"),
account->recv_server, port);
} else {
- log_error(LOG_PROTOCOL, _("Can't connect to IMAP4 server: %s:%d\n"),
+ log_error(LOG_PROTOCOL, _("Can't connect to IMAP server: %s:%d\n"),
account->recv_server, port);
}
session_init(SESSION(session), account, FALSE);
SESSION(session)->type = SESSION_IMAP;
SESSION(session)->server = g_strdup(account->recv_server);
- SESSION(session)->port = port;
+ SESSION(session)->port = port;
SESSION(session)->sock = NULL;
-
+ SESSION(session)->proxy_info = proxy_info;
SESSION(session)->destroy = imap_session_destroy;
session->capability = NULL;
-
session->authenticated = authenticated;
session->mbox = NULL;
session->exists = 0;
ok = imap_cmd_starttls(session);
if (ok != MAILIMAP_NO_ERROR) {
- log_warning(LOG_PROTOCOL, _("Can't start TLS session.\n"));
+ log_warning(LOG_PROTOCOL, _("Can't start STARTTLS session.\n"));
if (!is_fatal(ok)) {
SESSION(session)->sock = NULL;
imap_safe_destroy(session);
session->uidplus = FALSE;
session->cmd_count = 1;
}
+ SESSION(session)->use_tls_sni = account->use_tls_sni;
#endif
+
log_message(LOG_PROTOCOL, "IMAP connection is %s-authenticated\n",
(session->authenticated) ? "pre" : "un");
static gint imap_session_authenticate(IMAPSession *session,
PrefsAccount *account)
{
- gchar *pass, *acc_pass;
+ gchar *pass, *acc_pass = NULL;
gboolean failed = FALSE;
gint ok = MAILIMAP_NO_ERROR;
g_return_val_if_fail(account->userid != NULL, MAILIMAP_ERROR_BAD_STATE);
- if (password_get(account->userid, account->recv_server, "imap",
- SESSION(session)->port, &pass)) {
- Xstrdup_a(acc_pass, pass, {g_free(pass); return MAILIMAP_NO_ERROR;});
- g_free(pass);
- } else {
- acc_pass = account->passwd;
+ if (!password_get(account->userid, account->recv_server, "imap",
+ SESSION(session)->port, &acc_pass)) {
+ acc_pass = passwd_store_get_account(account->account_id,
+ PWS_ACCOUNT_RECV);
}
+
try_again:
pass = acc_pass;
if (!pass && account->imap_auth_type != IMAP_AUTH_ANON && account->imap_auth_type != IMAP_AUTH_GSSAPI) {
tmp_pass = input_dialog_query_password_keep(account->recv_server,
account->userid,
&(account->session_passwd));
- if (!tmp_pass)
+ 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 || account->imap_auth_type == IMAP_AUTH_GSSAPI) {
if ((ok = imap_auth(session, account->userid, pass, account->imap_auth_type)) != MAILIMAP_NO_ERROR) {
if (!failed && !is_fatal(ok)) {
- acc_pass = NULL;
+ if (acc_pass != NULL) {
+ memset(acc_pass, 0, strlen(acc_pass));
+ g_free(acc_pass);
+ acc_pass = NULL;
+ }
failed = TRUE;
if (account->session_passwd != NULL) {
g_free(account->session_passwd);
mainwindow_show_error();
} else
alertpanel_error_log(_("Couldn't login to IMAP server %s."), account->recv_server);
- }
+ }
+
+ if (acc_pass != NULL) {
+ memset(acc_pass, 0, strlen(acc_pass));
+ g_free(acc_pass);
+ acc_pass = NULL;
+ }
return ok;
}
- statuswindow_pop_all();
+ if (acc_pass) {
+ memset(acc_pass, 0, strlen(acc_pass));
+ g_free(acc_pass);
+ }
+ statusbar_pop_all();
session->authenticated = TRUE;
return MAILIMAP_NO_ERROR;
}
if (filename == NULL)
return -1;
- fp = g_fopen(filename, "rb");
+ fp = claws_fopen(filename, "rb");
if (!fp)
return -1;
- while (fgets(buf, sizeof (buf), fp) != NULL) {
+ while (claws_fgets(buf, sizeof (buf), fp) != NULL) {
cnt += strlen(buf);
if (!strstr(buf, "\r\n") && strstr(buf, "\n"))
cnt++;
}
- fclose(fp);
+ claws_fclose(fp);
return cnt;
}
-static void imap_remove_cached_msg(Folder *folder, FolderItem *item, MsgInfo *msginfo)
+static gchar *imap_get_cached_filename(FolderItem *item, guint msgnum)
{
gchar *path, *filename;
+ cm_return_val_if_fail(item != NULL, NULL);
+
path = folder_item_get_path(item);
if (!is_dir_exist(path)) {
g_free(path);
- return;
+ return NULL;
}
- filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(msginfo->msgnum), NULL);
+ filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(msgnum), NULL);
+
+ if (is_dir_exist(filename)) {
+ g_free(filename);
+ filename = g_strconcat(path, G_DIR_SEPARATOR_S, ".", itos(msgnum), NULL);
+ }
g_free(path);
+ return filename;
+}
+
+static void imap_remove_cached_msg(Folder *folder, FolderItem *item, MsgInfo *msginfo)
+{
+ gchar *filename;
+
+ filename = imap_get_cached_filename(item, msginfo->msgnum);
+
+ cm_return_if_fail(filename != NULL);
+
if (is_file_exist(filename)) {
claws_unlink(filename);
}
return NULL;
path = folder_item_get_path(item);
- if (!is_dir_exist(path))
+ if (!is_dir_exist(path)) {
+ if(is_file_exist(path))
+ claws_unlink(path);
make_dir_hier(path);
- filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(uid), NULL);
+ }
g_free(path);
+
+ filename = imap_get_cached_filename(item, uid);
debug_print("trying to fetch cached %s\n", filename);
+
if (is_file_exist(filename)) {
/* see whether the local file represents the whole message
* or not. As the IMAP server reports size with \r chars,
if (!cached || !MSG_IS_FULLY_CACHED(cached->flags)) {
have_size = get_file_size_with_crs(filename);
if (cached && (cached->size <= have_size || !body)) {
- procmsg_msginfo_free(cached);
ok = file_strip_crs(filename);
if (ok == 0 && cached && cached->size <= have_size) {
/* we have it all and stripped */
- debug_print("...fully cached in fact; setting flag.\n");
+ debug_print("...fully cached in fact (%u/%"G_GOFFSET_FORMAT"); setting flag.\n",
+ have_size, cached->size);
procmsg_msginfo_set_flags(cached, MSG_FULLY_CACHED, 0);
}
+ procmsg_msginfo_free(&cached);
return filename;
} else if (!cached && time(NULL) - get_file_mtime(filename) < 60) {
debug_print("message not cached and file recent, considering file complete\n");
if (ok == 0)
return filename;
} else {
- procmsg_msginfo_free(cached);
+ procmsg_msginfo_free(&cached);
}
}
if (cached && MSG_IS_FULLY_CACHED(cached->flags)) {
- procmsg_msginfo_free(cached);
+ procmsg_msginfo_free(&cached);
return filename;
}
} else {
MsgInfo *cached = msgcache_get_msg(item->cache,uid);
if (cached) {
procmsg_msginfo_unset_flags(cached, MSG_FULLY_CACHED, 0);
- procmsg_msginfo_free(cached);
+ procmsg_msginfo_free(&cached);
}
}
ok = imap_select(session, IMAP_FOLDER(folder), item,
NULL, NULL, NULL, NULL, NULL, FALSE);
if (ok != MAILIMAP_NO_ERROR) {
- g_warning("can't select mailbox %s\n", item->path);
+ g_warning("can't select mailbox %s", item->path);
g_free(filename);
return NULL;
}
ok = imap_cmd_fetch(session, (guint32)uid, filename, headers, body);
if (ok != MAILIMAP_NO_ERROR) {
- g_warning("can't fetch message %d\n", uid);
+ g_warning("can't fetch message %d", uid);
g_free(filename);
return NULL;
}
MsgInfo *cached = msgcache_get_msg(item->cache,uid);
if (cached) {
procmsg_msginfo_set_flags(cached, MSG_FULLY_CACHED, 0);
- procmsg_msginfo_free(cached);
+ procmsg_msginfo_free(&cached);
}
} else if (ok == -1) {
MsgInfo *cached = msgcache_get_msg(item->cache,uid);
if (cached) {
procmsg_msginfo_unset_flags(cached, MSG_FULLY_CACHED, 0);
- procmsg_msginfo_free(cached);
+ procmsg_msginfo_free(&cached);
}
}
return filename;
static gboolean imap_is_msg_fully_cached(Folder *folder, FolderItem *item, gint uid)
{
- gchar *path, *filename;
+ gchar *filename;
guint size = 0;
MsgInfo *cached = msgcache_get_msg(item->cache,uid);
return FALSE;
if (MSG_IS_FULLY_CACHED(cached->flags)) {
- procmsg_msginfo_free(cached);
+ procmsg_msginfo_free(&cached);
return TRUE;
}
- path = folder_item_get_path(item);
- if (!is_dir_exist(path))
- return FALSE;
- filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(uid), NULL);
- g_free(path);
+ filename = imap_get_cached_filename(item, uid);
+
if (is_file_exist(filename)) {
if (cached && cached->total_size == cached->size) {
/* fast path */
return TRUE;
}
size = get_file_size_with_crs(filename);
- g_free(filename);
}
+ g_free(filename);
+ debug_print("msg %d cached, has size %d, full should be %"G_GOFFSET_FORMAT".\n", uid, size, cached->size);
if (cached && size >= cached->size) {
cached->total_size = cached->size;
procmsg_msginfo_set_flags(cached, MSG_FULLY_CACHED, 0);
- procmsg_msginfo_free(cached);
+ procmsg_msginfo_free(&cached);
return TRUE;
}
if (cached)
- procmsg_msginfo_free(cached);
+ procmsg_msginfo_free(&cached);
return FALSE;
}
return -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 -1;
+ }
statusbar_print_all(_("Adding messages..."));
total = g_slist_length(file_list);
for (cur = file_list; cur != NULL; cur = cur->next) {
&new_uid);
if (ok != MAILIMAP_NO_ERROR) {
- g_warning("can't append message %s\n", real_file);
+ g_warning("can't append message %s", real_file);
g_free(real_file);
g_free(destdir);
statusbar_progress_all(0,0,0);
return result;
}
static gint imap_do_copy_msgs(Folder *folder, FolderItem *dest,
- MsgInfoList *msglist, GHashTable *relation)
+ MsgInfoList *msglist, GHashTable *relation,
+ gboolean same_dest_ok)
{
FolderItem *src;
gchar *destdir;
msginfo = (MsgInfo *)msglist->data;
src = msginfo->folder;
- if (src == dest) {
- g_warning("the src folder is identical to the dest.\n");
+ if (!same_dest_ok && src == dest) {
+ g_warning("the src folder is identical to the dest.");
return -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;
+ }
seq_list = imap_get_lep_set_from_msglist(IMAP_FOLDER(folder), msglist);
uid_hash = g_hash_table_new(g_direct_hash, g_direct_equal);
if (!is_dir_exist(cache_path))
make_dir_hier(cache_path);
if (is_file_exist(real_file) && is_dir_exist(cache_path)) {
- copy_file(real_file, cache_file, TRUE);
- debug_print("copied to cache: %s\n", cache_file);
+ if (copy_file(real_file, cache_file, TRUE) < 0)
+ debug_print("couldn't cache to %s: %s\n", cache_file,
+ strerror(errno));
+ else
+ debug_print("copied to cache: %s\n", cache_file);
}
g_free(real_file);
g_free(cache_file);
msginfo = (MsgInfo *)msglist->data;
g_return_val_if_fail(msginfo->folder != NULL, -1);
- ret = imap_do_copy_msgs(folder, dest, msglist, relation);
+ ret = imap_do_copy_msgs(folder, dest, msglist, relation, FALSE);
return ret;
}
case MATCHCRITERIA_TO_OR_CC:
case MATCHCRITERIA_SUBJECT:
case MATCHCRITERIA_REFERENCES:
+ case MATCHCRITERIA_MESSAGEID:
case MATCHCRITERIA_INREPLYTO:
case MATCHCRITERIA_AGE_GREATER:
case MATCHCRITERIA_AGE_LOWER:
case MATCHCRITERIA_NOT_HEADER: invert = TRUE; matchertype = MATCHCRITERIA_HEADER; break;
case MATCHCRITERIA_NOT_TAG: invert = TRUE; matchertype = MATCHCRITERIA_TAG; break;
case MATCHCRITERIA_NOT_HEADERS_PART: invert = TRUE; matchertype = MATCHCRITERIA_HEADERS_PART; break;
+ case MATCHCRITERIA_NOT_HEADERS_CONT: invert = TRUE; matchertype = MATCHCRITERIA_HEADERS_CONT; break;
case MATCHCRITERIA_NOT_MESSAGE: invert = TRUE; matchertype = MATCHCRITERIA_MESSAGE; break;
case MATCHCRITERIA_NOT_BODY_PART: invert = TRUE; matchertype = MATCHCRITERIA_BODY_PART; break;
case MATCHCRITERIA_NOT_TO_AND_NOT_CC: invert = TRUE; matchertype = MATCHCRITERIA_TO_OR_CC; break;
+ case MATCHCRITERIA_NOT_MESSAGEID: invert = TRUE; matchertype = MATCHCRITERIA_MESSAGEID; break;
case MATCHCRITERIA_NOT_INREPLYTO: invert = TRUE; matchertype = MATCHCRITERIA_INREPLYTO; break;
}
result = imap_search_new(IMAP_SEARCH_CRITERIA_TAG, NULL, RTAG_JUNK, 0);
break;
+ case MATCHCRITERIA_MESSAGEID:
+ result = imap_search_new(IMAP_SEARCH_CRITERIA_HEADER, "Message-ID", match->expr, 0);
+ break;
+
case MATCHCRITERIA_INREPLYTO:
result = imap_search_new(IMAP_SEARCH_CRITERIA_HEADER, "In-Reply-To", match->expr, 0);
break;
break;
case MATCHCRITERIA_HEADERS_PART:
+ case MATCHCRITERIA_HEADERS_CONT:
result = imap_search_and(
imap_search_not(imap_search_new(IMAP_SEARCH_CRITERIA_BODY, NULL, match->expr, 0)),
imap_search_new(IMAP_SEARCH_CRITERIA_MESSAGE, NULL, match->expr, 0)
*msgs = g_slist_prepend(*msgs, GUINT_TO_POINTER(((MsgInfo*) cur->data)->msgnum));
count++;
}
+ procmsg_msg_list_free(list);
+
*msgs = g_slist_reverse(*msgs);
+
return count;
}
if (progress_cb)
progress_cb(progress_data, TRUE, container->total_msgs, 0, container->total_msgs);
+ if (result == MAILIMAP_ERROR_PROTOCOL) {
+ debug_print("Server side search unavailable, using local search\n");
+ imap_handle_error(SESSION(session), NULL, result);
+ return folder_item_search_msgs_local(folder, container, msgs, NULL,
+ predicate, progress_cb, progress_data);
+ }
+
if (result == MAILIMAP_NO_ERROR) {
gint result = 0;
if (IMAP_FOLDER(folder)->search_charset_supported)
return search_msgs(folder, container, msgs, on_server, predicate,
progress_cb, progress_data);
- else
+ else {
+ imap_handle_error(SESSION(session), NULL, result);
return -1;
+ }
} else {
+ imap_handle_error(SESSION(session), NULL, result);
return -1;
}
}
return ok;
}
} /* else we just need to expunge */
- ok = imap_cmd_expunge(session, folder->account->imap_use_trash);
+ ok = imap_cmd_expunge(session);
if (ok != MAILIMAP_NO_ERROR) {
log_warning(LOG_PROTOCOL, _("can't expunge\n"));
g_free(destdir);
imap_scan_required(folder, dest);
g_free(destdir);
- if (ok == MAILIMAP_NO_ERROR)
- return 0;
- else
- return -1;
+
+ return 0;
}
static gint imap_remove_msgs(Folder *folder, FolderItem *dest,
strtailchomp(root_folder, '/');
real_path = imap_get_real_path
(session, IMAP_FOLDER(folder), root_folder, &r);
- if (is_fatal(r))
+ if (is_fatal(r)) {
+ g_free(real_path);
return -1;
+ }
debug_print("IMAP root directory: %s\n", real_path);
/* check if root directory exist */
}
if (!item || ((item->path || root_folder) &&
- strcmp2(item->path, root_folder) != 0)) {
+ g_strcmp0(item->path, root_folder) != 0)) {
folder_tree_destroy(folder);
item = folder_item_new(folder, folder->name, root_folder);
item->folder = folder;
new_item = NULL;
for (cur = item_list; cur != NULL; cur = cur->next) {
FolderItem *cur_item = FOLDER_ITEM(cur->data);
- if (!strcmp2(old_item->path, cur_item->path)) {
+ if (!g_strcmp0(old_item->path, cur_item->path)) {
new_item = cur_item;
break;
}
}
if (!new_item) {
- if (old_item && old_item->path && !strcmp(old_item->path, "INBOX")) {
+ if (old_item && old_item->path && !strcasecmp(old_item->path, "INBOX")) {
debug_print("not removing INBOX\n");
} else {
debug_print("folder '%s' not found. removing...\n",
for (node = item->node->children; node != NULL;
node = node->next) {
- if (!strcmp2(FOLDER_ITEM(node->data)->path,
+ if (!g_strcmp0(FOLDER_ITEM(node->data)->path,
cur_item->path)) {
new_item = FOLDER_ITEM(node->data);
folder_item_destroy(cur_item);
folder_item_append(item, new_item);
}
- if (!strcmp(new_item->path, "INBOX")) {
+ if (!strcasecmp(new_item->path, "INBOX")) {
new_item->stype = F_INBOX;
folder->inbox = new_item;
} else if (!folder_item_parent(item) || item->stype == F_INBOX) {
if (!folder->outbox && !g_ascii_strcasecmp(base, "Sent")) {
new_item->stype = F_OUTBOX;
folder->outbox = new_item;
- } else if (!folder->draft && !g_ascii_strcasecmp(base, "Drafts")) {
+ } else if (!folder->draft && (!g_ascii_strcasecmp(base, "Drafts") || !g_ascii_strcasecmp(base, "Draft"))) {
new_item->stype = F_DRAFT;
folder->draft = new_item;
} else if (!folder->queue && !g_ascii_strcasecmp(base, "Queue")) {
if (r) {
g_free(real_path);
statusbar_pop_all();
+ g_free(tmp);
return NULL;
}
folder_item_destroy(cur_item);
oldlitem = g_list_find_custom(
- child_list, tmp, (GCompareFunc)strcmp2);
+ child_list, tmp, (GCompareFunc)g_strcmp0);
if (oldlitem) {
child_list = g_list_remove_link(child_list, oldlitem);
g_free(oldlitem->data);
new_item = imap_create_folder(folder, item, name);
if (!new_item) {
- g_warning("Can't create '%s'\n", name);
+ g_warning("Can't create '%s'", name);
if (!folder->inbox) return NULL;
new_item = imap_create_folder(folder, folder->inbox, name);
if (!new_item)
- g_warning("Can't create '%s' under INBOX\n", name);
+ g_warning("Can't create '%s' under INBOX", name);
else
new_item->stype = stype;
} else
return new_item;
}
-static gchar *imap_folder_get_path(Folder *folder)
-{
- gchar *folder_path;
-
- g_return_val_if_fail(folder != NULL, NULL);
- g_return_val_if_fail(folder->account != NULL, NULL);
-
- folder_path = g_strconcat(get_imap_cache_dir(),
- G_DIR_SEPARATOR_S,
- folder->account->recv_server,
- G_DIR_SEPARATOR_S,
- folder->account->userid,
- NULL);
-
- return folder_path;
-}
-
#ifdef G_OS_WIN32
static gchar *imap_encode_unsafe_chars(const gchar *str)
{
return NULL;
ret = g_malloc(3*strlen(str)+1);
o_ret = ret;
- for (i = str; *i; i++) {
+ for (i = (gchar *)str; *i; i++) {
switch(*i) {
case ':':
case '|':
gchar *item_path = NULL;
g_return_val_if_fail(folder != NULL, NULL);
+ g_return_val_if_fail(folder->account != NULL, NULL);
g_return_val_if_fail(item != NULL, NULL);
- folder_path = imap_folder_get_path(folder);
+ folder_path = prefs_account_cache_dir(folder->account, FALSE);
g_return_val_if_fail(folder_path != NULL, NULL);
g_return_val_if_fail(parent != NULL, NULL);
g_return_val_if_fail(name != NULL, NULL);
+ if (to_number(name) > 0) {
+ gchar *cached_msg = imap_get_cached_filename(parent, to_number(name));
+ if (is_file_exist(cached_msg)) {
+ if (claws_unlink(cached_msg) != 0) {
+ return NULL;
+ }
+ }
+ }
+
debug_print("getting session...\n");
session = imap_session_get(folder);
if (!session) {
return NULL;
}
- if (!folder_item_parent(parent) && strcmp(name, "INBOX") == 0) {
+ if (!folder_item_parent(parent) && strcasecmp(name, "INBOX") == 0) {
dirpath = g_strdup(name);
}else if (parent->path)
dirpath = g_strconcat(parent->path, "/", name, NULL);
/* remove trailing / for display */
strtailchomp(new_name, '/');
- if (strcmp(dirpath, "INBOX") != 0) {
- GPtrArray *argbuf;
+ if (strcasecmp(dirpath, "INBOX") != 0) {
int r;
clist * lep_list;
- argbuf = g_ptr_array_new();
r = imap_threaded_list(folder, "", imap_path, &lep_list);
if (r != MAILIMAP_NO_ERROR) {
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);
- ptr_array_free_strings(argbuf);
- g_ptr_array_free(argbuf, TRUE);
return 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"));
+ 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, &ok);
if (is_fatal(ok)) {
+ g_free(real_oldpath);
return -1;
}
}
separator = imap_get_path_separator(session, IMAP_FOLDER(folder), item->path, &ok);
- if (is_fatal(ok))
+ if (is_fatal(ok)) {
+ g_free(real_oldpath);
return -1;
- if (strchr(item->path, G_DIR_SEPARATOR)) {
+ }
+ if (strchr(item->path, '/')) {
dirpath = g_path_get_dirname(item->path);
- newpath = g_strconcat(dirpath, G_DIR_SEPARATOR_S, name, NULL);
+ newpath = g_strconcat(dirpath, "/", name, NULL);
g_free(dirpath);
} else
newpath = g_strdup(name);
g_free(path);
return -1;
}
- if (!strcmp(path, "INBOX") && sub == FALSE) {
+ if (!strcasecmp(path, "INBOX") && sub == FALSE) {
g_free(path);
return -1;
}
return -1;
}
path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path, &ok);
- if (is_fatal(ok))
+ if (is_fatal(ok)) {
+ g_free(path);
return -1;
-
+ }
imap_threaded_subscribe(folder, path, FALSE);
selected_folder = (session->mbox != NULL) &&
g_free(path);
cache_dir = folder_item_get_path(item);
if (is_dir_exist(cache_dir) && remove_dir_recursive(cache_dir) < 0)
- g_warning("can't remove directory '%s'\n", cache_dir);
+ g_warning("can't remove directory '%s'", cache_dir);
g_free(cache_dir);
folder_item_remove(item);
return 0;
main_window_reflect_tags_changes(mainwindow_get_mainwindow());
}
- for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
- struct mailimap_set * imapset;
-
- imapset = cur->data;
- mailimap_set_free(imapset);
- }
+ imap_lep_set_free(seq_list);
session_set_access_time(SESSION(session));
stuff->done = TRUE;
remove_all_numbered_files(dir);
g_free(dir);
- debug_print("done.\n");
+ debug_print("Deleting all cached messages done.\n");
}
gchar imap_get_path_separator_for_item(FolderItem *item)
if (!item)
return '/';
folder = item->folder;
-
+
if (!folder)
return '/';
-
+
imap_folder = IMAP_FOLDER(folder);
-
- if (!imap_folder)
- return '/';
-
- debug_print("getting session...");
+
+ debug_print("getting session...\n");
session = imap_session_get(FOLDER(folder));
result = imap_get_path_separator(session, imap_folder, item->path, &ok);
return result;
session->expunge = 0;
real_path = imap_get_real_path(session, folder, path, &ok);
- if (is_fatal(ok))
- return ok;
+ if (is_fatal(ok)) {
+ g_free(real_path);
+ 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,
mailimap_mailbox_data_status_free(data_status);
if (got_values != mask) {
- g_warning("status: incomplete values received (%d)\n", got_values);
+ g_warning("status: incomplete values received (%d)", got_values);
}
return MAILIMAP_NO_ERROR;
}
int r;
gint ok;
- if (!strcmp(type, "LOGIN") && imap_has_capability(session, "LOGINDISABLED")) {
- gint ok = MAILIMAP_ERROR_BAD_STATE;
+ if (!strcmp(type, "plaintext") && imap_has_capability(session, "LOGINDISABLED")) {
+ ok = MAILIMAP_ERROR_BAD_STATE;
if (imap_has_capability(session, "STARTTLS")) {
#ifdef USE_GNUTLS
- log_warning(LOG_PROTOCOL, _("Server requires TLS to log in.\n"));
+ log_warning(LOG_PROTOCOL, _("Server requires STARTTLS to log in.\n"));
ok = imap_cmd_starttls(session);
if (ok != MAILIMAP_NO_ERROR) {
- log_warning(LOG_PROTOCOL, _("Can't start TLS session.\n"));
+ log_warning(LOG_PROTOCOL, _("Can't start STARTTLS session.\n"));
return ok;
} else {
/* refresh capas */
}
#else
log_error(LOG_PROTOCOL, _("Connection to %s failed: "
- "server requires TLS, but Claws Mail "
- "has been compiled without OpenSSL "
+ "server requires STARTTLS, but Claws Mail "
+ "has been compiled without STARTTLS "
"support.\n"),
SESSION(session)->server);
return MAILIMAP_ERROR_LOGIN;
}
}
- log_print(LOG_PROTOCOL, "IMAP4> Logging %s to %s using %s\n",
+ log_print(LOG_PROTOCOL, "IMAP> Logging %s to %s using %s\n",
user,
SESSION(session)->server,
type);
r = imap_threaded_login(session->folder, user, pass, type);
if (r != MAILIMAP_NO_ERROR) {
imap_handle_error(SESSION(session), NULL, r);
- log_print(LOG_PROTOCOL, "IMAP4< Error logging in to %s\n",
+ log_print(LOG_PROTOCOL, "IMAP< Error logging in to %s\n",
SESSION(session)->server);
ok = r;
} else {
- log_print(LOG_PROTOCOL, "IMAP4< Login to %s successful\n",
+ log_print(LOG_PROTOCOL, "IMAP< Login to %s successful\n",
SESSION(session)->server);
ok = MAILIMAP_NO_ERROR;
}
SESSION(session)->server, SESSION(session)->port);
if (r != MAILIMAP_NO_ERROR) {
imap_handle_error(SESSION(session), NULL, r);
- debug_print("starttls err %d\n", r);
+ debug_print("STARTTLS err %d\n", r);
return r;
}
return MAILIMAP_NO_ERROR;
return MAILIMAP_NO_ERROR;
}
-static gint imap_cmd_expunge(IMAPSession *session, gboolean do_expunge)
+static gint imap_cmd_expunge(IMAPSession *session)
{
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 "
if (session == NULL)
return -1;
- return imap_cmd_expunge(session, TRUE);
+ return imap_cmd_expunge(session);
}
static void imap_path_separator_subst(gchar *str, gchar separator)
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);
+ g_warning("path doesn't match: %s, %s", oldpath, item->path);
return TRUE;
}
base = item->path + oldpathlen;
- while (*base == G_DIR_SEPARATOR) base++;
+ while (*base == '/') base++;
if (*base == '\0')
new_itempath = g_strdup(newpath);
else
- new_itempath = g_strconcat(newpath, G_DIR_SEPARATOR_S, base,
+ new_itempath = g_strconcat(newpath, "/", base,
NULL);
real_oldpath = imap_get_real_path(session, IMAP_FOLDER(item->folder), item->path, &ok);
}
if (r == MAILIMAP_NO_ERROR) {
- GSList * fetchuid_list =
- imap_uid_list_from_lep(lep_uidlist, NULL);
+ uidlist = imap_uid_list_from_lep(lep_uidlist, NULL);
mailimap_search_result_free(lep_uidlist);
-
- uidlist = g_slist_concat(fetchuid_list, uidlist);
} else {
carray * lep_uidtab;
if (r != -1) { /* inited */
r = imap_threaded_fetch_uid(folder, 1,
&lep_uidtab);
if (r == MAILIMAP_NO_ERROR) {
- GSList * fetchuid_list =
- imap_uid_list_from_lep_tab(lep_uidtab);
+ uidlist = imap_uid_list_from_lep_tab(lep_uidtab);
imap_fetch_uid_list_free(lep_uidtab);
- uidlist = g_slist_concat(fetchuid_list, uidlist);
}
}
}
g_slist_free(uidlist);
- unlock_session(session); /* locked from imap_get_num_list */
-
return nummsgs;
}
GSList *uidlist = NULL;
gchar *dir;
gint known_list_len = 0;
+ gchar *path;
+
debug_print("get_num_list\n");
g_return_val_if_fail(folder != NULL, -1);
return -1;
}
+ path = folder_item_get_path(_item);
+ if (!is_dir_exist(path)) {
+ if(is_file_exist(path))
+ claws_unlink(path);
+ make_dir_hier(path);
+ }
+ g_free(path);
+
debug_print("getting session...\n");
session = imap_session_get(folder);
g_return_val_if_fail(session != NULL, -1);
- lock_session(session); /* unlocked by get_list_of_uids */
+ lock_session(session);
if (FOLDER_ITEM(item)->path)
- statusbar_print_all(_("Scanning folder %s%c%s..."),
+ statusbar_print_all(_("Scanning folder %s/%s..."),
FOLDER_ITEM(item)->folder->name,
- G_DIR_SEPARATOR,
FOLDER_ITEM(item)->path);
else
statusbar_print_all(_("Scanning folder %s..."),
}
nummsgs = get_list_of_uids(session, folder, item, &uidlist);
+
+ unlock_session(session);
+
/* session could be broken now, in case of fatal error */
debug_print("get_num_list: got %d msgs\n", nummsgs);
return FALSE;
}
- debug_print("exists %d, item->item.total_msgs %d\n",
- exists, item->item.total_msgs);
+ debug_print("exists %d, item->item.total_msgs %d\n"
+ "\tunseen %d, item->item.unread_msgs %d\n"
+ "\tuid_next %d, item->uid_next %d\n"
+ "\tuid_val %d, item->item.mtime %ld\n",
+ exists, item->item.total_msgs, unseen, item->item.unread_msgs,
+ uid_next, item->uid_next, uid_val, (long)(item->item.mtime));
if (exists != item->item.total_msgs
|| unseen != item->item.unread_msgs
|| uid_next != item->uid_next
return ok;
}
- ok = imap_cmd_expunge(session, folder->account->imap_use_trash);
+ ok = imap_cmd_expunge(session);
if (ok != MAILIMAP_NO_ERROR) {
log_warning(LOG_PROTOCOL, _("can't expunge\n"));
/*
* NEW and DELETED flags are not syncronized
* - The NEW/RECENT flags in IMAP folders can not really be directly
- * modified by Sylpheed
- * - The DELETE/DELETED flag in IMAP and Sylpheed don't have the same
+ * modified by Claws Mail
+ * - The DELETE/DELETED flag in IMAP and Claws Mail do not have the same
* meaning, in IMAP it always removes the messages from the FolderItem
- * in Sylpheed it can mean to move the message to trash
+ * in Claws Mail it can mean to move the message to Trash
*/
typedef struct _get_flags_data {
data->full_search = TRUE;
for (cur = tmp; cur; cur = cur->next)
- procmsg_msginfo_free((MsgInfo *)cur->data);
+ procmsg_msginfo_free((MsgInfo **)&(cur->data));
g_slist_free(tmp);
ok = imap_set_message_flags(session, IMAP_FOLDER_ITEM(item),
data->msglist, flags_value, NULL, flags_set);
} else {
- g_warning("can't select mailbox %s\n", item->path);
+ g_warning("can't select mailbox %s", item->path);
}
if (!is_fatal(ok))
ok = imap_set_message_flags(session, IMAP_FOLDER_ITEM(item),
data->msglist, 0, &list, tags_set);
} else {
- g_warning("can't select mailbox %s\n", item->path);
+ g_warning("can't select mailbox %s", item->path);
}
if (!is_fatal(ok))
}
if (!all && dup_name[strlen(dup_name)-1] == '/') {
- dup_name[strlen(dup_name)-1] = '\0';
+ g_free(base);
+ free(dup_name);
+ continue;
}
loc_name = imap_modified_utf7_to_utf8(base, 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 &&
+ if (strcasecmp(dup_name, "INBOX") != 0 &&
((flags & ETPAN_IMAP_MB_NOSELECT) != 0))
new_item->no_select = TRUE;
guint32 uid = 0;
goffset size = 0;
MsgFlags flags = {0, 0};
-
+
if (info->headers == NULL)
return NULL;
MSG_SET_TMP_FLAGS(flags, MSG_DRAFT);
}
flags.perm_flags = info->flags;
-
+
uid = info->uid;
size = (goffset) info->size;
msginfo = procheader_parse_str(info->headers, flags, FALSE, FALSE);
-
+
if (msginfo) {
msginfo->msgnum = uid;
msginfo->size = size;
GList *list;
gboolean short_timeout;
#ifdef HAVE_NETWORKMANAGER_SUPPORT
- GError *error;
-#endif
+ GError *error = NULL;
-#ifdef HAVE_NETWORKMANAGER_SUPPORT
- error = NULL;
short_timeout = !networkmanager_is_online(&error);
if(error) {
short_timeout = TRUE;
_("You have one or more IMAP accounts "
"defined. However this version of "
"Claws Mail has been built without "
- "IMAP support; your IMAP account(s) are "
+ "IMAP support; your IMAP accounts are "
"disabled.\n\n"
"You probably need to "
"install libetpan and recompile "
if (imap_class.idstr == NULL) {
imap_class.type = F_IMAP;
imap_class.idstr = "imap";
- imap_class.uistr = "IMAP4";
+ imap_class.uistr = "IMAP";
imap_class.new_folder = imap_folder_new;
imap_class.create_tree = imap_create_tree;
projects / claws.git / blobdiff