MODEST_TYPE_TNY_ACCOUNT_STORE, \
ModestTnyAccountStorePrivate))
+#define RETRY_ATTEMPTS 3
+
+typedef struct _PwdAttempt {
+ gint count;
+ gchar *pwd;
+} PwdAttempt;
+
/* globals */
static GObjectClass *parent_class = NULL;
g_type_class_add_private (gobject_class,
sizeof(ModestTnyAccountStorePrivate));
}
-
+
+static void
+free_pwd_attempt (gpointer data)
+{
+ PwdAttempt *attempt = (PwdAttempt *) data;
+
+ /* Note that we sometimes insert NULL */
+ if (!attempt)
+ return;
+
+ if (attempt->pwd)
+ g_free (attempt->pwd);
+ g_slice_free (PwdAttempt, attempt);
+}
+
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,
* so they need to be asked for from the user once in each session:
*/
priv->password_hash = g_hash_table_new_full (g_str_hash, g_str_equal,
- g_free, g_free);
+ g_free, free_pwd_attempt);
}
/* disconnect the list of TnyAccounts */
g_object_unref (iter);
}
-static void
-show_password_warning_only (const gchar *msg)
+static void
+show_wrong_password_dialog (TnyAccount *account,
+ gboolean show_banner)
{
- /* Show an explanatory temporary banner: */
- if (modest_window_mgr_get_num_windows (modest_runtime_get_window_mgr ()))
- modest_platform_information_banner (NULL, NULL, msg);
-}
+ g_debug ("%s: %s", __FUNCTION__, tny_account_get_id (account));
-static void
-show_wrong_password_dialog (TnyAccount *account,
- gboolean show_banner)
-{
if (g_object_get_data (G_OBJECT (account), "connection_specific") != NULL) {
modest_ui_actions_on_smtp_servers (NULL, NULL);
} else {
/* Create and show the dialog */
if (proto && MODEST_IS_ACCOUNT_PROTOCOL (proto)) {
+ GtkWindow *parent;
+ ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
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);
+
+ 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));
}
}
ModestTnyAccountStorePrivate *priv;
gchar *username = NULL;
gchar *pwd = NULL;
- gpointer pwd_ptr = NULL;
gboolean already_asked = FALSE;
const gchar *server_account_name;
gchar *url_string;
+ PwdAttempt *attempt = NULL;
+ gpointer attempt_ptr = NULL;
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" */
+ attempt_ptr = (gpointer) &attempt;
+
/* 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,
+ attempt_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));
+ PwdAttempt *new_attempt = g_slice_new0 (PwdAttempt);
+ new_attempt->count = RETRY_ATTEMPTS;
+ new_attempt->pwd = g_strdup (pwd);
+ g_hash_table_insert (priv->password_hash, g_strdup (server_account_name), new_attempt);
+ } else if (attempt) {
+ pwd = g_strdup (attempt->pwd);
+ }
+
+ /* 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 %s",
+ __FUNCTION__, (attempt && (attempt->count > 0)) ? "retrying" : "canceling");
+ if (attempt) {
+ if (attempt->count == 0) {
+ modest_tny_account_store_reset_attempt_count (self, account);
+ if (cancel)
+ *cancel = TRUE;
+ return NULL;
+ } else {
+ return pwd;
+ }
+ } else {
+ 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);
password = modest_account_mgr_get_server_account_password (priv->account_mgr,
server_account_name);
- if (already_asked)
- msg = g_strdup (_("mcen_ib_username_pw_incorrect"));
- 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));
- else
+ } else {
msg = g_strdup_printf (_("emev_ni_ui_smtp_authentication_fail_error"),
tny_account_get_hostname (account));
+ }
if (password)
g_free (password);
}
}
if (username)
g_free (username);
+ } else {
+ if (already_asked) {
+ const gchar *msg;
+ gboolean username_known =
+ modest_account_mgr_get_server_account_username_has_succeeded(priv->account_mgr,
+ server_account_name);
+ /* If the login has ever succeeded then show a specific message */
+ if (username_known)
+ msg = _CS ("ecdg_ib_set_password_incorrect");
+ else
+ msg = _("mcen_ib_username_pw_incorrect");
+ if (modest_window_mgr_get_num_windows (modest_runtime_get_window_mgr ()))
+ modest_platform_information_banner (NULL, NULL, msg);
+ }
}
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) {
+ g_debug ("%s: going to show the dialog. Attempt count is %d", __FUNCTION__, attempt->count);
+ /* The password must be wrong, so show the account settings dialog so it can be corrected: */
+ show_wrong_password_dialog (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 */
+ pwd = NULL;
const gchar* account_id = tny_account_get_id (account);
gboolean remember = FALSE;
- pwd = NULL;
-
- if (already_asked) {
- const gchar *msg;
- gboolean username_known =
- modest_account_mgr_get_server_account_username_has_succeeded(priv->account_mgr,
- server_account_name);
- /* If the login has ever succeeded then show a specific message */
- if (username_known)
- msg = _CS ("ecdg_ib_set_password_incorrect");
- else
- msg = _("mcen_ib_username_pw_incorrect");
- show_password_warning_only (msg);
- }
-
- /* Request password */
g_signal_emit (G_OBJECT (self), signals[PASSWORD_REQUESTED_SIGNAL], 0,
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;
-
+ PwdAttempt *attempt;
+
account_store = TNY_ACCOUNT_STORE(g_object_get_data (G_OBJECT(account),
"account_store"));
self = MODEST_TNY_ACCOUNT_STORE (account_store);
/* Do not remove the key, this will allow us to detect that we
have already asked for it at least once */
- pwd = g_hash_table_lookup (priv->password_hash, key);
- if (pwd) {
- memset (pwd, 0, strlen (pwd));
- g_hash_table_insert (priv->password_hash, g_strdup (key), NULL);
+ attempt = g_hash_table_lookup (priv->password_hash, key);
+ if (attempt) {
+ attempt->count--;
+ g_debug ("%s, remaining %d for account %s", __FUNCTION__, attempt->count, key);
+ if (attempt->count == 0) {
+ if (attempt->pwd)
+ memset (attempt->pwd, 0, strlen (attempt->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;
TnyAccount *local_account = NULL;
TnyLockable *lockable;
GnomeVFSVolumeMonitor* monitor = NULL;
+ gboolean auto_update;
g_return_val_if_fail (account_mgr, NULL);
g_return_val_if_fail (device, NULL);
priv->account_mgr = g_object_ref (G_OBJECT(account_mgr));
priv->device = g_object_ref (device);
+ /* If autoupdate is off then we don't try to connect to the
+ accounts when they're added to the account store*/
+ auto_update = modest_conf_get_bool (modest_runtime_get_conf (),
+ MODEST_CONF_AUTO_UPDATE, NULL);
+ if (!auto_update)
+ tny_device_force_offline (priv->device);
+
priv->session = tny_session_camel_new (TNY_ACCOUNT_STORE(obj));
if (!priv->session) {
g_warning ("failed to get TnySessionCamel");
priv->store_accounts_outboxes = tny_simple_list_new ();
/* Create the local folders account */
- local_account =
+ local_account =
modest_tny_account_new_for_local_folders (priv->account_mgr, priv->session, NULL);
tny_list_append (priv->store_accounts, G_OBJECT(local_account));
g_object_unref (local_account);
add_mmc_account (MODEST_TNY_ACCOUNT_STORE (obj), FALSE /* don't emit the insert signal. */);
}
+ /* Initialize session */
+ tny_session_camel_set_initialized (priv->session);
+
return MODEST_TNY_ACCOUNT_STORE(obj);
}
default:
g_return_if_reached ();
}
-
- /* Initialize session. Why do we need this ??? */
- tny_session_camel_set_initialized (priv->session);
}
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) {
+ g_debug ("%s: %s alert received (%s)", __FUNCTION__,
+ (error->code == TNY_SERVICE_ERROR_CONNECT) ? "connect" : "aunthenticate",
+ error->message);
+
+ 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;
+ }
}
g_debug ("%s: error code %d (%s", __FUNCTION__, error->code, error->message);
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;
return FALSE;
}
}
+
+void
+modest_tny_account_store_reset_attempt_count (ModestTnyAccountStore *self,
+ TnyAccount *account)
+{
+ ModestTnyAccountStorePrivate *priv;
+ PwdAttempt *attempt;
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ /* Reset the count */
+ attempt = g_hash_table_lookup (priv->password_hash, tny_account_get_id (account));
+ if (attempt) {
+ attempt->count = RETRY_ATTEMPTS;
+ g_debug ("%s, reseting the attempt count for account %s", __FUNCTION__, tny_account_get_id (account));
+ }
+}
projects / modest / blobdiff