#include <modest-platform.h>
#include "modest-ui-actions.h"
#include <widgets/modest-account-settings-dialog.h>
+#include <tny-camel-bs-msg-receive-strategy.h>
+#include <modest-tny-msg.h>
#ifdef MODEST_PLATFORM_MAEMO
#include <tny-maemo-conic-device.h>
GnomeVFSVolume *volume,
gpointer user_data);
-static void forget_password_in_memory (ModestTnyAccountStore *self,
- const gchar *server_account_name);
-
static void add_connection_specific_transport_accounts (ModestTnyAccountStore *self);
static void remove_connection_specific_transport_accounts (ModestTnyAccountStore *self);
g_type_class_add_private (gobject_class,
sizeof(ModestTnyAccountStorePrivate));
}
-
+
static void
modest_tny_account_store_instance_init (ModestTnyAccountStore *obj)
{
priv->device = NULL;
priv->sighandlers = NULL;
priv->send_mail_blocked = FALSE;
-
+
priv->outbox_of_transport = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
NULL,
g_free (uri);
}
-/**
- * forget_password_in_memory
- * @self: a TnyAccountStore instance
- * @account: A server account.
- *
- * Forget any password stored in memory for this account.
- * For instance, this should be called when the user has changed the password in the account settings.
- */
-static void
-forget_password_in_memory (ModestTnyAccountStore *self,
+void
+modest_tny_account_store_forget_password_in_memory (ModestTnyAccountStore *self,
const gchar * server_account_name)
{
ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
- if (server_account_name && priv->password_hash) {
+ if (server_account_name && priv->password_hash)
g_hash_table_remove (priv->password_hash, server_account_name);
- }
}
static void
g_object_unref (iter);
}
-static void
-show_wrong_password_dialog (TnyAccount *account,
+static void
+show_wrong_password_dialog (TnyAccountStore *self,
+ TnyAccount *account,
gboolean show_banner)
-{
+{
+ TnyDevice *device;
+ gboolean is_online;
+
+ g_debug ("%s: %s", __FUNCTION__, tny_account_get_id (account));
+
+ device = tny_account_store_get_device (self);
+ is_online = tny_device_is_online (device);
+ g_object_unref (device);
+
+ if (!is_online) {
+ g_debug ("%s: not showing the acc settings dialog. Device OFFLINE", __FUNCTION__);
+ return;
+ }
+
+ if (modest_window_mgr_get_num_windows (modest_runtime_get_window_mgr ()) == 0) {
+ g_debug ("%s: not showing the account settings dialog. NO windows", __FUNCTION__);
+ return;
+ }
+
if (g_object_get_data (G_OBJECT (account), "connection_specific") != NULL) {
modest_ui_actions_on_smtp_servers (NULL, NULL);
} else {
if (proto && MODEST_IS_ACCOUNT_PROTOCOL (proto)) {
ModestAccountSettingsDialog *dialog =
modest_account_protocol_get_account_settings_dialog (proto, modest_account_name);
- modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (dialog), NULL);
- gtk_widget_show (GTK_WIDGET (dialog));
+
+ if (dialog) {
+ ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
+ GtkWindow *parent = modest_window_mgr_get_modal (mgr);
+ if (!parent)
+ parent = (GtkWindow *) modest_window_mgr_get_current_top (mgr);
+
+ modest_window_mgr_set_modal (mgr, GTK_WINDOW (dialog), parent);
+ gtk_widget_show (GTK_WIDGET (dialog));
+ }
}
}
/* Show an explanatory temporary banner: */
ModestTnyAccountStorePrivate *priv;
gchar *username = NULL;
gchar *pwd = NULL;
- gpointer pwd_ptr = NULL;
+ gpointer pwd_ptr;
gboolean already_asked = FALSE;
const gchar *server_account_name;
gchar *url_string;
g_return_val_if_fail (account, NULL);
-
- MODEST_DEBUG_BLOCK(
- g_debug ("%s: prompt (not shown) = %s\n", __FUNCTION__, prompt_not_used);
- );
+
+ g_debug ("%s: %s", __FUNCTION__, prompt_not_used);
/* Get a reference to myself */
self = MODEST_TNY_ACCOUNT_STORE (g_object_get_data (G_OBJECT(account), "account_store"));
return NULL;
}
+ /* We need to do this to avoid "dereferencing type-punned pointer will break strict-aliasing rules" */
+ pwd_ptr = (gpointer) &pwd;
+
/* This hash map stores passwords, including passwords that are not stored in gconf. */
/* Is it in the hash? if it's already there, it must be wrong... */
- pwd_ptr = (gpointer)&pwd; /* pwd_ptr so the compiler does not complained about
- * type-punned ptrs...*/
- already_asked = priv->password_hash &&
- g_hash_table_lookup_extended (priv->password_hash,
- server_account_name,
- NULL,
- (gpointer*)&pwd_ptr);
- MODEST_DEBUG_BLOCK(
- g_debug ("%s: Already asked = %d\n", __FUNCTION__, already_asked);
- );
+ already_asked = priv->password_hash && g_hash_table_lookup_extended (priv->password_hash,
+ server_account_name,
+ NULL,
+ pwd_ptr);
/* If the password is not already there, try ModestConf */
if (!already_asked) {
pwd = modest_account_mgr_get_server_account_password (priv->account_mgr,
server_account_name);
g_hash_table_insert (priv->password_hash, g_strdup (server_account_name), g_strdup (pwd));
+ } else {
+ /* We need to get it again because forget_password has cleared it */
+ pwd = modest_account_mgr_get_server_account_password (priv->account_mgr, server_account_name);
+ }
+
+ /* This is horrible but we need it until we don't get a proper
+ fix into tinymail. Thing is that tinymail incorrectly asks
+ for password when the connection to the server failed due a
+ timeout (slow network connection, firewalls...). In those
+ cases it makes no sense to ask the user. It's better just
+ to cancel cleanly */
+ if (g_strstr_len (prompt_not_used, -1, "Connection timed out")) {
+ g_debug ("%s, Incorrect get_password with connection issue", __FUNCTION__);
+ modest_tny_account_store_forget_password_in_memory (self, tny_account_get_id (account));
+ if (cancel)
+ *cancel = TRUE;
+ return NULL;
}
/* If it was already asked, it must have been wrong, so ask again */
gboolean settings_have_password;
ModestProtocolType protocol_type;
- /* As per the UI spec, if no password was set in the account settings,
- * ask for it now. But if the password is wrong in the account settings,
+ /* As per the UI spec, if no password was set in the account settings,
+ * ask for it now. But if the password is wrong in the account settings,
* then show a banner and the account settings dialog so it can be corrected:
*/
- settings_have_password =
+ settings_have_password =
modest_account_mgr_get_server_account_has_password (priv->account_mgr, server_account_name);
protocol_type = modest_tny_account_get_protocol_type (account);
if (modest_protocol_registry_protocol_type_has_tag(modest_runtime_get_protocol_registry (),
protocol_type, MODEST_PROTOCOL_REGISTRY_TRANSPORT_PROTOCOLS)) {
gchar *username = NULL, *msg = NULL;
- gboolean is_banner = FALSE;
username = modest_account_mgr_get_server_account_username (priv->account_mgr,
server_account_name);
if (!username || strlen(username) == 0) {
password = modest_account_mgr_get_server_account_password (priv->account_mgr,
server_account_name);
- if (already_asked) {
- msg = g_strdup (_CS("ecdg_ib_set_password_incorrect"));
- is_banner = TRUE;
- } else if (!password || strlen(password) == 0) {
+ if (!password || strlen(password) == 0) {
msg = g_strdup_printf (_("emev_ni_ui_smtp_passwd_invalid"),
tny_account_get_name (account),
tny_account_get_hostname (account));
g_free (password);
}
if (msg) {
- if (is_banner)
- modest_platform_information_banner (NULL, NULL, msg);
- else
- modest_platform_run_information_dialog (NULL, msg, TRUE);
+ modest_platform_run_information_dialog (NULL, msg, TRUE);
g_free (msg);
}
if (username)
}
if (settings_have_password) {
- /* The password must be wrong, so show the account settings dialog so it can be corrected: */
- show_wrong_password_dialog (account, TRUE);
+ if (pwd) {
+ /* The password must be wrong, so show
+ the account settings dialog so it
+ can be corrected: */
+ g_debug ("%s: going to show the settings dialog", __FUNCTION__);
+ show_wrong_password_dialog ((TnyAccountStore *) self, account, TRUE);
- if (cancel)
- *cancel = TRUE;
+ if (cancel)
+ *cancel = TRUE;
- return NULL;
+ return NULL;
+ } else {
+ /* Get the password from the account settings */
+ return modest_account_mgr_get_server_account_password (priv->account_mgr,
+ server_account_name);
+ }
}
/* we don't have it yet. Get the password from the user */
account_id, /* server_account_name */
&username, &pwd, cancel, &remember);
- if (!*cancel) {
- /* The password will be returned as the result,
- * but we need to tell tinymail about the username too: */
-
- /* WARNING: I disabled setting username as this can cause locks. Anyway,
- * as now we have the password dialog username entry always dimmed
- * this shouldn't be a problem */
-
- /* if (username) */
- /* tny_account_set_user (account, username); */
-
- /* Do not save the password in gconf, because
- * the UI spec says "The password will never
- * be saved in the account": */
-
- /* We need to dup the string even knowing that
- it's already a dup of the contents of an
- entry, because it if it's wrong, then camel
- will free it */
- g_hash_table_insert (priv->password_hash, g_strdup (server_account_name), g_strdup(pwd));
- } else {
+ if (*cancel) {
g_hash_table_remove (priv->password_hash, server_account_name);
-
g_free (pwd);
pwd = NULL;
}
g_free (username);
username = NULL;
- } else
+ } else {
if (cancel)
- *cancel = FALSE;
+ *cancel = FALSE;
+ }
return pwd;
}
(gpointer*)&pwd_ptr);
if (already_asked) {
- g_hash_table_remove (priv->password_hash, server_account_name);
+ g_hash_table_remove (priv->password_hash, server_account_name);
g_free (pwd);
pwd = NULL;
}
ModestTnyAccountStore *self;
ModestTnyAccountStorePrivate *priv;
const TnyAccountStore *account_store;
- gchar *pwd;
const gchar *key;
-
+ gchar *pwd;
+
account_store = TNY_ACCOUNT_STORE(g_object_get_data (G_OBJECT(account),
"account_store"));
self = MODEST_TNY_ACCOUNT_STORE (account_store);
have already asked for it at least once */
pwd = g_hash_table_lookup (priv->password_hash, key);
if (pwd) {
+ g_debug ("%s, forgetting %s for account %s", __FUNCTION__, pwd, key);
memset (pwd, 0, strlen (pwd));
g_hash_table_insert (priv->password_hash, g_strdup (key), NULL);
}
-
- /* Remove from configuration system */
- /*
- modest_account_mgr_unset (priv->account_mgr,
- key, MODEST_ACCOUNT_PASSWORD, TRUE);
- */
}
static void
g_free (priv->cache_dir);
priv->cache_dir = NULL;
-
+
if (priv->password_hash) {
g_hash_table_destroy (priv->password_hash);
priv->password_hash = NULL;
return result;
}
+static void _bodies_filter (TnyMsg *msg, TnyList *list)
+{
+ TnyMimePart *html_part, *text_part;
+
+ html_part = modest_tny_msg_find_body_part (msg, TRUE);
+ text_part = modest_tny_msg_find_body_part (msg, FALSE);
+
+ if (text_part && TNY_IS_MIME_PART (text_part) && html_part == text_part) {
+ g_object_unref (text_part);
+ text_part = NULL;
+ }
+
+ if (html_part && TNY_IS_MIME_PART (html_part)) {
+ tny_list_prepend (list, G_OBJECT (html_part));
+ g_object_unref (html_part);
+ }
+
+ if (text_part && TNY_IS_MIME_PART (text_part)) {
+ tny_list_prepend (list, G_OBJECT (text_part));
+ g_object_unref (text_part);
+ }
+}
+
+
ModestTnyAccountStore*
modest_tny_account_store_new (ModestAccountMgr *account_mgr,
TnyDevice *device)
g_return_val_if_fail (account_mgr, NULL);
g_return_val_if_fail (device, NULL);
+ tny_camel_bs_msg_receive_strategy_set_global_bodies_filter (
+ (TnyCamelBsMsgReceiveStrategyBodiesFilter) _bodies_filter);
+
obj = G_OBJECT(g_object_new(MODEST_TYPE_TNY_ACCOUNT_STORE, NULL));
priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(obj);
gboolean retval = TRUE;
/* NOTE: account may be NULL in some cases */
- g_return_val_if_fail (error, FALSE);
+ if (!error)
+ return FALSE;
/* Get the server name: */
if (account) {
else if (error->code == TNY_SERVICE_ERROR_AUTHENTICATE ||
error->code == TNY_SERVICE_ERROR_CONNECT) {
TnyDevice *device = modest_runtime_get_device ();
-
- modest_platform_run_information_dialog (NULL, prompt, TRUE);
-
- /* Show the account dialog. Checking the online status
- allows us to minimize the number of times that we
- incorrectly show the dialog */
- if (tny_device_is_online (device))
- show_wrong_password_dialog (account,
- (error->code == TNY_SERVICE_ERROR_CONNECT) ? FALSE : TRUE);
-
- retval = TRUE;
+ gboolean success;
+
+ /* If we get the connection error after establishing a
+ proper connection then do not show the dialog as we
+ are probably behind a firewall, or in a network
+ with connection issues. We just keep this code to
+ detect situations were the user does not enter the
+ server info properly */
+ success = modest_account_mgr_get_server_account_username_has_succeeded (modest_runtime_get_account_mgr (),
+ tny_account_get_id (account));
+
+ if (!success) {
+ gboolean show_banner;
+
+ g_debug ("%s: %s alert received (%s)", __FUNCTION__,
+ (error->code == TNY_SERVICE_ERROR_CONNECT) ? "connect" : "aunthenticate",
+ error->message);
+
+ if (tny_device_is_online (device) &&
+ modest_window_mgr_get_num_windows (modest_runtime_get_window_mgr ()))
+ modest_platform_run_information_dialog (NULL, prompt, TRUE);
+
+ /* Show the account dialog */
+ show_banner = (error->code == TNY_SERVICE_ERROR_CONNECT) ? FALSE : TRUE;
+ g_debug ("%s: going to show settings dialog", __FUNCTION__);
+ show_wrong_password_dialog (self, account, show_banner);
+ retval = TRUE;
+ }
}
g_debug ("%s: error code %d (%s", __FUNCTION__, error->code, error->message);
if (account) {
/* Forget any cached password for the account, so that
we use a new account if any */
- forget_password_in_memory (self, tny_account_get_id (account));
+ modest_tny_account_store_forget_password_in_memory (self, tny_account_get_id (account));
/* Set the account store */
g_object_set_data (G_OBJECT(account), "account_store", self);
with the configuration system this could not exist */
if (TNY_IS_STORE_ACCOUNT(store_account)) {
/* Forget any cached password for the account */
- forget_password_in_memory (self, tny_account_get_id (store_account));
+ modest_tny_account_store_forget_password_in_memory (self, tny_account_get_id (store_account));
/* Remove it from the list of accounts and notify the
observers. Do not need to wait for account
if (TNY_IS_TRANSPORT_ACCOUNT(transport_account)) {
/* Forget any cached password for the account */
- forget_password_in_memory (self, tny_account_get_id (transport_account));
+ modest_tny_account_store_forget_password_in_memory (self, tny_account_get_id (transport_account));
/* Remove transport account. It'll free the reference
added by get_server_account */
op_data->callback (op_data->account_store, op_data->userdata);
g_object_unref (op_data->account_store);
g_free (op_data);
- } else {
- g_object_unref (op_data->account_store);
}
}
g_return_if_fail (account && TNY_IS_ACCOUNT(account));
if (TNY_IS_STORE_ACCOUNT (account) &&
- !modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account)))
- goto frees;
-
- /* Disconnect account */
- if (tny_account_get_connection_status (account) == TNY_CONNECTION_STATUS_CONNECTED) {
- tny_camel_account_set_online (TNY_CAMEL_ACCOUNT(account), FALSE,
- account_shutdown_callback, op_data);
+ !modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account))) {
+ op_data->pending--;
return;
}
- frees:
- op_data->pending--;
- g_object_unref (op_data->account_store);
+ /* Disconnect account */
+ tny_camel_account_set_online (TNY_CAMEL_ACCOUNT(account), FALSE,
+ account_shutdown_callback, op_data);
+
}
ModestTnyAccountStoreShutdownCallback callback,
gpointer userdata)
{
- gint i, num_accounts;
+ gint num_accounts;
ShutdownOpData *op_data;
ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
if (priv->transport_accounts)
num_accounts += tny_list_get_length (priv->transport_accounts);
- for (i = 0 ; i < num_accounts ; i++)
- g_object_ref (self);
-
/* Create the helper object */
op_data = g_new0 (ShutdownOpData, 1);
op_data->callback = callback;
op_data->userdata = userdata;
op_data->pending = num_accounts;
- op_data->account_store = self;
+ op_data->account_store = g_object_ref (self);
+
+ /* Force the TnyDevice to be offline. This way new
+ undesired connections won't be initiated */
+ tny_device_force_offline (priv->device);
/* Destroy all accounts. Disconnect all accounts before they are destroyed */
if (priv->store_accounts) {
if (op_data->pending == 0) {
if (op_data->callback)
op_data->callback (op_data->account_store, op_data->userdata);
+ g_object_unref (op_data->account_store);
g_free (op_data);
}
}
gboolean
+modest_tny_account_store_is_shutdown (ModestTnyAccountStore *self)
+{
+ ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
+ TnyIterator *iter;
+ gboolean found;
+
+ found = FALSE;
+
+ for (iter = tny_list_create_iterator (priv->store_accounts);
+ !found && !tny_iterator_is_done (iter);
+ tny_iterator_next (iter)) {
+ TnyAccount *account;
+
+ account = (TnyAccount *) tny_iterator_get_current (iter);
+ if (TNY_IS_ACCOUNT (account)) {
+ found = (tny_account_get_connection_status (account) == TNY_CONNECTION_STATUS_CONNECTED) ||
+ (tny_account_get_connection_status (account) == TNY_CONNECTION_STATUS_RECONNECTING);
+ }
+ g_object_unref (account);
+ }
+ g_object_unref (iter);
+
+ if (found)
+ return !found;
+
+ for (iter = tny_list_create_iterator (priv->transport_accounts);
+ !found && !tny_iterator_is_done (iter);
+ tny_iterator_next (iter)) {
+ TnyAccount *account;
+
+ account = (TnyAccount *) tny_iterator_get_current (iter);
+ if (TNY_IS_ACCOUNT (account)) {
+ found = (tny_account_get_connection_status (account) == TNY_CONNECTION_STATUS_CONNECTED) ||
+ (tny_account_get_connection_status (account) == TNY_CONNECTION_STATUS_RECONNECTING);
+ }
+ g_object_unref (account);
+ }
+ g_object_unref (iter);
+
+ return !found;
+
+}
+
+
+gboolean
modest_tny_account_store_is_send_mail_blocked (ModestTnyAccountStore *self)
{
ModestTnyAccountStorePrivate *priv;