X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fmodest-tny-account-store.c;h=e4efc5f9e8fad7c1f2a7f78671095b55ce59bafd;hp=bd08cb1c3876c9fb71cf11d69af52908d8495935;hb=2c42f21178287256da1a51613e0653327f49f51e;hpb=e565f583b5b88c4e1cc330f5ed22c39f86525a32

diff --git a/src/modest-tny-account-store.c b/src/modest-tny-account-store.c
index bd08cb1..e4efc5f 100644
--- a/src/modest-tny-account-store.c
+++ b/src/modest-tny-account-store.c
@@ -51,6 +51,7 @@
 #include <modest-account-mgr-helpers.h>
 #include <widgets/modest-window-mgr.h>
 #include <modest-account-settings-dialog.h>
+#include <maemo/modest-maemo-utils.h>
 
 
 #include "modest-tny-account-store.h"
@@ -60,7 +61,7 @@
 
 #ifdef MODEST_PLATFORM_MAEMO
 #include <tny-maemo-conic-device.h>
-#ifdef MODEST_HILDON_VERSION_0
+#ifdef MODEST_HAVE_HILDON0_WIDGETS
 #include <hildon-widgets/hildon-note.h>
 #include <hildon-widgets/hildon-banner.h>
 #else
@@ -81,9 +82,9 @@ static void    modest_tny_account_store_instance_init (ModestTnyAccountStore *ob
 static void    modest_tny_account_store_init          (gpointer g, gpointer iface_data);
 
 
-static void
-get_server_accounts  (TnyAccountStore *self, TnyList *list, TnyAccountType type);
-
+static void    get_server_accounts                    (TnyAccountStore *self, 
+						       TnyList *list, 
+						       TnyAccountType type);
 
 /* list my signals */
 enum {
@@ -96,6 +97,7 @@ typedef struct _ModestTnyAccountStorePrivate ModestTnyAccountStorePrivate;
 struct _ModestTnyAccountStorePrivate {
 	gchar              *cache_dir;	
 	GHashTable         *password_hash;
+	GHashTable         *account_settings_dialog_hash;
 	ModestAccountMgr   *account_mgr;
 	TnySessionCamel    *session;
 	TnyDevice          *device;
@@ -215,6 +217,11 @@ modest_tny_account_store_instance_init (ModestTnyAccountStore *obj)
          */
 	priv->password_hash          = g_hash_table_new_full (g_str_hash, g_str_equal,
 							      g_free, g_free);
+							     
+	/* A hash-map of modest account names to dialog pointers,
+	 * so we can avoid showing the account settings twice for the same modest account: */				      
+	priv->account_settings_dialog_hash = g_hash_table_new_full (g_str_hash, g_str_equal, 
+		g_free, NULL);
 							      
 	/* Respond to volume mounts and unmounts, such 
 	 * as the insertion/removal of the memory card: */
@@ -244,6 +251,23 @@ account_list_free (GSList *accounts)
 	g_slist_free (accounts);
 }
 
+
+
+/* disconnect the list of TnyAccounts */
+static void
+account_list_disconnect (GSList *accounts)
+{
+	GSList *cursor = accounts;
+
+	while (cursor) {
+		if (TNY_IS_CAMEL_ACCOUNT(cursor->data))  /* check twice... */
+			tny_camel_account_set_online (TNY_CAMEL_ACCOUNT(cursor->data), FALSE, NULL);
+		cursor = g_slist_next (cursor);
+	}
+}
+
+
+
 static void
 recreate_all_accounts (ModestTnyAccountStore *self)
 {
@@ -319,30 +343,56 @@ on_vfs_volume_unmounted(GnomeVFSVolumeMonitor *volume_monitor,
 static void
 on_account_removed (ModestAccountMgr *acc_mgr, 
 		    const gchar *account,
-		    gboolean server_account,
+		    gboolean is_server_account,
 		    gpointer user_data)
 {
 	ModestTnyAccountStore *self = MODEST_TNY_ACCOUNT_STORE(user_data);
-	TnyAccount *store_account;
-
+	TnyAccount *server_account;
+	
 	/* Clear the account cache */
-	store_account =
-		modest_tny_account_store_get_server_account (self,
-							     account,
-							     TNY_ACCOUNT_TYPE_STORE);
-	if (store_account) {
-		tny_store_account_delete_cache (TNY_STORE_ACCOUNT (store_account));
-		g_object_unref (store_account);
-	}
+	server_account = modest_tny_account_store_get_tny_account_by  (self, 
+								      MODEST_TNY_ACCOUNT_STORE_QUERY_ID, 
+								      account);
+	if (server_account) {
+		if (TNY_IS_STORE_ACCOUNT (server_account)) {
 
-	/* FIXME: make this more finegrained; changes do not
-	 * really affect _all_ accounts, and some do not
-	 * affect tny accounts at all (such as 'last_update')
-	 */
-	recreate_all_accounts (self);
-	
-	g_signal_emit (G_OBJECT(self), signals[ACCOUNT_UPDATE_SIGNAL], 0,
-		       account);
+			tny_store_account_delete_cache (TNY_STORE_ACCOUNT (server_account));
+		
+			g_signal_emit (G_OBJECT (self), 
+				       tny_account_store_signals [TNY_ACCOUNT_STORE_ACCOUNT_REMOVED], 
+				       0, server_account);
+
+/* 			/\* FIXME: make this more finegrained; changes do not */
+/* 			 * really affect _all_ accounts, and some do not */
+/* 			 * affect tny accounts at all (such as 'last_update') */
+/* 			 *\/ */
+/* 			recreate_all_accounts (self); */
+			
+/* 			g_signal_emit (G_OBJECT(self), signals[ACCOUNT_UPDATE_SIGNAL], 0, */
+/* 				       account); */
+		}
+		g_object_unref (server_account);
+	} else
+		g_printerr ("modest: cannot find server account for %s", account);
+}
+
+/**
+ * modest_tny_account_store_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
+modest_tny_account_store_forget_password_in_memory (ModestTnyAccountStore *self, const gchar * server_account_name)
+{
+	/* printf ("DEBUG: %s\n", __FUNCTION__); */
+	ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+	if (server_account_name && priv->password_hash) {
+		g_hash_table_remove (priv->password_hash, server_account_name);
+	}
 }
 
 static void
@@ -352,17 +402,38 @@ on_account_changed (ModestAccountMgr *acc_mgr, const gchar *account,
 {
 	ModestTnyAccountStore *self = MODEST_TNY_ACCOUNT_STORE(user_data);
 	
-	#if 0
+	/*
+	printf ("DEBUG: %s\n", __FUNCTION__);
+	const GSList *iter = keys;
+	for (iter = keys; iter; iter = g_slist_next (iter)) {
+		printf ("  DEBUG: %s: key=%s\n", __FUNCTION__, (const gchar*)iter->data);
+	}
+	*/
+	
 	/* Ignore the change if it's a change in the last_updated value */
-	if (g_str_has_suffix (key, MODEST_ACCOUNT_LAST_UPDATED))
+	if (g_slist_length ((GSList *)keys) == 1 &&
+		g_str_has_suffix ((const gchar *) keys->data, MODEST_ACCOUNT_LAST_UPDATED)) {
 		return;
-	#endif
+	}
 
 	/* FIXME: make this more finegrained; changes do not really affect _all_
-	 * accounts, and some do not affect tny accounts at all (such as 'last_update')
+	 * accounts
 	 */
-	if (server_account)
-		recreate_all_accounts (self);
+	recreate_all_accounts (self);
+	
+	/* TODO: This doesn't actually work, because
+	 * a) The account name is not sent correctly per key:
+	 * b) We should test the end of the key, not the whole keym
+	 * c) We don't seem to be getting all keys here.
+	 * Instead, we just forget the password for all accounts when we create them, for now.
+	 */
+	#if 0
+	/* If a password has changed, then forget the previously cached password for this account: */
+	if (server_account && keys && g_slist_find_custom ((GSList *)keys, MODEST_ACCOUNT_PASSWORD, (GCompareFunc)strcmp)) {
+		printf ("DEBUG: %s: Forgetting cached password for account ID=%s\n", __FUNCTION__, account);
+		modest_tny_account_store_forget_password_in_memory (self,  account);
+	}
+	#endif
 
 	g_signal_emit (G_OBJECT(self), signals[ACCOUNT_UPDATE_SIGNAL], 0,
 		       account);
@@ -376,77 +447,268 @@ get_account_store_for_account (TnyAccount *account)
 							   "account_store"));
 }
 
+static 
+void on_account_settings_hide (GtkWidget *widget, gpointer user_data)
+{
+	TnyAccount *account = (TnyAccount*)user_data;
+	
+	/* This is easier than using a struct for the user_data: */
+	ModestTnyAccountStore *self = modest_runtime_get_account_store();
+	ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+	
+	const gchar *modest_account_name = 
+			modest_tny_account_get_parent_modest_account_name_for_server_account (account);
+	if (modest_account_name)
+		g_hash_table_remove (priv->account_settings_dialog_hash, modest_account_name);
+}
+
+static 
+gboolean on_idle_wrong_password (gpointer user_data)
+{ 
+	TnyAccount *account = (TnyAccount*)user_data;
+	/* This is easier than using a struct for the user_data: */
+	ModestTnyAccountStore *self = modest_runtime_get_account_store();
+	ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+	
+	const gchar *modest_account_name = 
+			modest_tny_account_get_parent_modest_account_name_for_server_account (account);
+	if (!modest_account_name) {
+		g_warning ("%s: modest_tny_account_get_parent_modest_account_name_for_server_account() failed.\n", 
+			__FUNCTION__);
+			
+		g_object_unref (account);
+		return FALSE;
+	}
+	
+	
+	/* Check whether this window is already open,
+	 * for instance because of a previous get_password() call: 
+	 */
+	gpointer dialog_as_gpointer = NULL;
+	gboolean found = FALSE;
+	if (priv->account_settings_dialog_hash) {
+		found = g_hash_table_lookup_extended (priv->account_settings_dialog_hash,
+			modest_account_name, NULL, (gpointer*)&dialog_as_gpointer);
+	}
+	ModestAccountSettingsDialog *dialog = dialog_as_gpointer;
+					
+	ModestWindow *main_window = 
+				modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ());
+
+	gdk_threads_enter ();
+	gboolean created_dialog = FALSE;
+	if (!found || !dialog) {
+		dialog = modest_account_settings_dialog_new ();
+		modest_account_settings_dialog_set_account_name (dialog, modest_account_name);
+		modest_account_settings_dialog_switch_to_user_info (dialog);
+		
+		g_hash_table_insert (priv->account_settings_dialog_hash, g_strdup (modest_account_name), dialog);
+		
+		created_dialog = TRUE;
+	}
+	
+	/* Show an explanatory temporary banner: */
+	hildon_banner_show_information ( 
+		GTK_WIDGET(dialog), NULL, _("mcen_ib_username_pw_incorrect"));
+		
+	if (created_dialog) {
+		/* Forget it when it closes: */
+		g_signal_connect_object (G_OBJECT (dialog), "hide", G_CALLBACK (on_account_settings_hide), 
+			account, 0);
+			
+		/* Show it and delete it when it closes: */
+		modest_maemo_show_dialog_and_forget (GTK_WINDOW (main_window), GTK_DIALOG (dialog));
+	}
+	else {
+		/* Just show it instead of showing it and deleting it when it closes,
+		 * though it is probably open already: */
+		gtk_window_present (GTK_WINDOW (dialog));
+	}
+	
+	g_object_unref (account);
+	gdk_threads_leave ();
+	
+	return FALSE; /* Dont' call this again. */
+}
+
+typedef struct 
+{
+	GMainLoop *loop;
+	ModestTnyAccountStore* account_store;
+	const gchar* server_account_id;
+	gchar **username;
+	gchar **password;
+	gboolean *cancel;
+	gboolean *remember;
+} IdlePasswordRequest;
+
+static gboolean 
+on_idle_request_password (gpointer user_data)
+{
+	gdk_threads_enter();
+	
+	IdlePasswordRequest* info = (IdlePasswordRequest*)user_data;
+	g_signal_emit (G_OBJECT(info->account_store), signals[PASSWORD_REQUESTED_SIGNAL], 0,
+			       info->server_account_id, /* server_account_name */
+			       info->username, info->password, info->cancel, info->remember);
+			       
+	if (info->loop)
+		g_main_loop_quit (info->loop);
+	
+	gdk_threads_leave();
+	
+	return FALSE; /* Don't call again. */
+}
+
+static void
+request_password_in_main_loop_and_wait (ModestTnyAccountStore *account_store, 
+					 const gchar* server_account_id,
+					 gchar **username,
+					 gchar **password,
+					 gboolean *cancel, 
+					 gboolean *remember)
+{
+	IdlePasswordRequest *data = g_slice_new0 (IdlePasswordRequest);
+	data->account_store = account_store;
+	data->server_account_id = server_account_id;
+	data->username = username;
+	data->password = password;
+	data->cancel = cancel;
+	data->remember = remember;
+
+	data->loop = g_main_loop_new (NULL, FALSE /* not running */);
+	
+	/* Cause the function to be run in an idle-handler, which is always 
+	 * in the main thread:
+	 */
+	g_idle_add (&on_idle_request_password, data);
+	
+	/* This main loop will run until the idle handler has stopped it: */
+	printf ("DEBUG: %s: before g_main_loop_run()\n", __FUNCTION__);
+	GDK_THREADS_LEAVE();
+	g_main_loop_run (data->loop);
+	GDK_THREADS_ENTER();
+	printf ("DEBUG: %s: after g_main_loop_run()\n", __FUNCTION__);
+	printf ("DEBUG: %s: Finished\n", __FUNCTION__);
+	g_main_loop_unref (data->loop);
+
+	g_slice_free (IdlePasswordRequest, data);
+}
+
 /* This callback will be called by Tinymail when it needs the password
- * from the user, for instance if the password was not remembered.
+ * from the user or the account settings.
+ * It can also call forget_password() before calling this,
+ * so that we clear wrong passwords out of our account settings.
  * Note that TnyAccount here will be the server account. */
 static gchar*
-get_password (TnyAccount *account, const gchar *prompt, gboolean *cancel)
+get_password (TnyAccount *account, const gchar * prompt_not_used, gboolean *cancel)
 {
-	/* Initialize the output parameter: */
-	if (cancel)
-	  *cancel = FALSE;
+	/* TODO: Settting cancel to FALSE does not actually cancel everything.
+	 * We still get multiple requests afterwards, so we end up showing the 
+	 * same dialogs repeatedly.
+	 */
+	 
+	printf ("DEBUG: modest: %s: prompt (not shown) = %s\n", __FUNCTION__, prompt_not_used);
 	  
-	const gchar *key;
-	const TnyAccountStore *account_store;
-	ModestTnyAccountStore *self;
+	g_return_val_if_fail (account, NULL);
+	  
+	const TnyAccountStore *account_store = NULL;
+	ModestTnyAccountStore *self = NULL;
 	ModestTnyAccountStorePrivate *priv;
 	gchar *username = NULL;
 	gchar *pwd = NULL;
-	gpointer pwd_ptr;
-	gboolean already_asked;
-	
-	key           = tny_account_get_id (account);
+	gpointer pwd_ptr = NULL;
+	gboolean already_asked = FALSE;
+
+	/* Initialize the output parameter: */
+	if (cancel)
+		*cancel = FALSE;
+		
+	const gchar *server_account_name = tny_account_get_id (account);
 	account_store = TNY_ACCOUNT_STORE(get_account_store_for_account (account));
-	
+
+	if (!server_account_name || !account_store) {
+		g_warning ("modest: %s: could not retrieve account_store for account %s",
+			   __FUNCTION__, server_account_name ? server_account_name : "<NULL>");
+		if (cancel)
+			*cancel = TRUE;
+		
+		return NULL;
+	}
+
 	self = MODEST_TNY_ACCOUNT_STORE (account_store);
-        priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+	priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 	
 	/* 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... */
+	/* 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 = g_hash_table_lookup_extended (priv->password_hash,
-						      key,
+	already_asked = priv->password_hash && 
+				g_hash_table_lookup_extended (priv->password_hash,
+						      server_account_name,
 						      NULL,
 						      (gpointer*)&pwd_ptr);
+						      
+	printf ("DEBUG: modest: %s: Already asked = %d\n", __FUNCTION__, already_asked);
 
-	/* if the password is not already there, try ModestConf */
+	/* If the password is not already there, try ModestConf */
 	if (!already_asked) {
-		pwd  = modest_account_mgr_get_string (priv->account_mgr,
-						      key, MODEST_ACCOUNT_PASSWORD, TRUE);
-		g_hash_table_insert (priv->password_hash, g_strdup (key), g_strdup (pwd));
+		pwd  = modest_server_account_get_password (priv->account_mgr,
+						      server_account_name);
+		g_hash_table_insert (priv->password_hash, g_strdup (server_account_name), g_strdup (pwd));
 	}
 
-	/* if it was already asked, it must have been wrong, so ask again */
-	/* TODO: However, when we supply a wrong password to tinymail, 
-	 * it seems to (at least sometimes) call our alert_func() instead of 
-	 * asking for the password again.
-	 */
+	/* If it was already asked, it must have been wrong, so ask again */
 	if (already_asked || !pwd || strlen(pwd) == 0) {
+		/* 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:
+		 */
+		const gboolean settings_have_password = 
+			modest_server_account_get_has_password (priv->account_mgr, server_account_name);
+		printf ("DEBUG: modest: %s: settings_have_password=%d\n", __FUNCTION__, settings_have_password);
+		if (settings_have_password) {
+	
+			
+			/* The password must be wrong, so show the account settings dialog so it can be corrected: */
+			/* We show it in the main loop, because this function might no tbe in the main loop. */
+			g_object_ref (account); /* unrefed in the idle handler. */
+			g_idle_add (on_idle_wrong_password, account);
+			
+			if (cancel)
+				*cancel = TRUE;
+				
+			return NULL;
+		}
+	
 		/* we don't have it yet. Get the password from the user */
 		const gchar* account_id = tny_account_get_id (account);
 		gboolean remember = FALSE;
 		pwd = NULL;
 		
-		/* Note that we ignore the returned username here,
-		 * because it is enough that it will be stored in gconf 
-		 * by the signal handler. */
-		g_signal_emit (G_OBJECT(self), signals[PASSWORD_REQUESTED_SIGNAL], 0,
-			       account_id, /* server_account_name */
+		request_password_in_main_loop_and_wait (self, account_id, 
 			       &username, &pwd, cancel, &remember);
 		
 		if (!*cancel) {
-			if (remember)
-				modest_account_mgr_set_string (priv->account_mgr,key,
-							       MODEST_ACCOUNT_PASSWORD,
-							       pwd, TRUE);
+			/* The password will be returned as the result,
+			 * but we need to tell tinymail about the username too: */
+			tny_account_set_user (account, username);
+			
+			if (remember) {
+				printf ("%s: Storing username=%s, password=%s\n", 
+					__FUNCTION__, username, pwd);
+				modest_server_account_set_username (priv->account_mgr, server_account_name,
+							       username);
+				modest_server_account_set_password (priv->account_mgr, server_account_name,
+							       pwd);
+			}
 			/* 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 (key), g_strdup(pwd));
+			g_hash_table_insert (priv->password_hash, g_strdup (server_account_name), g_strdup(pwd));
 		} else {
-			g_hash_table_remove (priv->password_hash, key);
+			g_hash_table_remove (priv->password_hash, server_account_name);
 			
 			g_free (pwd);
 			pwd = NULL;
@@ -488,10 +750,25 @@ forget_password (TnyAccount *account)
 	}
 
 	/* Remove from configuration system */
+	/*
 	modest_account_mgr_unset (priv->account_mgr,
 				  key, MODEST_ACCOUNT_PASSWORD, TRUE);
+	*/
 }
 
+static void
+destroy_password_hashtable (ModestTnyAccountStore *self)
+{
+	ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+	
+	g_free (priv->cache_dir);
+	priv->cache_dir = NULL;
+	
+	if (priv->password_hash) {
+		g_hash_table_destroy (priv->password_hash);
+		priv->password_hash = NULL;
+	}
+}
 
 static void
 modest_tny_account_store_finalize (GObject *obj)
@@ -508,6 +785,8 @@ modest_tny_account_store_finalize (GObject *obj)
 		g_hash_table_destroy (priv->password_hash);
 		priv->password_hash = NULL;
 	}
+	
+	destroy_password_hashtable (self);
 
 	if (priv->account_mgr) {
 		g_object_unref (G_OBJECT(priv->account_mgr));
@@ -519,6 +798,12 @@ modest_tny_account_store_finalize (GObject *obj)
 		priv->device = NULL;
 	}
 
+	/* disconnect all accounts when we are destroyed */
+	g_debug ("modest: disconnecting all store accounts");
+	account_list_disconnect (priv->store_accounts);
+	g_debug ("modest: disconnecting all transport accounts");
+	account_list_disconnect (priv->transport_accounts);
+		
 	/* this includes the local folder */
 	account_list_free (priv->store_accounts);
 	priv->store_accounts = NULL;
@@ -540,7 +825,7 @@ modest_tny_account_store_new (ModestAccountMgr *account_mgr, TnyDevice *device)
 
 	GObject *obj;
 	ModestTnyAccountStorePrivate *priv;
- 	TnyList *list; 
+// 	TnyList *list; 
 	
 	g_return_val_if_fail (account_mgr, NULL);
 	g_return_val_if_fail (device, NULL);
@@ -552,17 +837,14 @@ modest_tny_account_store_new (ModestAccountMgr *account_mgr, TnyDevice *device)
 	priv->device = g_object_ref (device);
 	
 	priv->session = tny_session_camel_new (TNY_ACCOUNT_STORE(obj));
+	if (!priv->session) {
+		g_warning ("failed to get TnySessionCamel");
+		return NULL;
+	}
 	
 	tny_session_camel_set_ui_locker (priv->session,	 tny_gtk_lockable_new ());
-	/* FIXME: unref this in the end? */
 	tny_session_camel_set_async_connecting (priv->session, TRUE);
-	
-	/* force a cache fill... ugly */
-	list = TNY_LIST(tny_simple_list_new());
-	tny_account_store_get_accounts (TNY_ACCOUNT_STORE(obj), list,
-					TNY_ACCOUNT_STORE_BOTH);
-	g_object_unref(list);
-	
+		
 	/* Connect signals */
 	g_signal_connect (G_OBJECT(account_mgr), "account_changed",
 				       G_CALLBACK (on_account_changed), obj);
@@ -621,8 +903,9 @@ create_per_account_local_outbox_folders (TnyAccountStore *self)
 				
 		accounts = g_slist_append (accounts, tny_account_outbox); /* cache it */
 	};
-	
-	g_slist_free (account_names);
+
+	modest_account_mgr_free_account_names (account_names);
+	account_names = NULL;
 	
 	priv->store_accounts_outboxes = accounts;
 }
@@ -635,8 +918,6 @@ static void
 get_server_accounts  (TnyAccountStore *self, TnyList *list, TnyAccountType type)
 {
 	g_return_if_fail (self);
-	
-	/* printf ("DEBUG: %s: list=%p, type=%d\n", __FUNCTION__, list, type); */
 		
 	ModestTnyAccountStorePrivate *priv = 
 		MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
@@ -650,8 +931,8 @@ get_server_accounts  (TnyAccountStore *self, TnyList *list, TnyAccountType type)
 			return;
 	}
 	
-	GSList                       *account_names = NULL, *cursor = NULL;
-	GSList                       *accounts = NULL;
+	GSList *account_names = NULL, *cursor = NULL;
+	GSList *accounts = NULL;
 
 	/* These are account names, not server_account names */
 	account_names = modest_account_mgr_account_names (priv->account_mgr,FALSE);
@@ -671,6 +952,15 @@ get_server_accounts  (TnyAccountStore *self, TnyList *list, TnyAccountType type)
 								     get_password,
 								     forget_password);
 			if (tny_account) {
+				/* Forget any cached password for the account,
+				 * so that we use a new account if any.
+				 * TODO: Really we should do this in a more precise way in 
+				 * on_account_changed().
+				 */
+				modest_tny_account_store_forget_password_in_memory (
+					MODEST_TNY_ACCOUNT_STORE (self),  
+					tny_account_get_id (tny_account));
+				
 				g_object_set_data (G_OBJECT(tny_account), "account_store",
 						   (gpointer)self);
 				if (list)
@@ -743,7 +1033,7 @@ get_server_accounts  (TnyAccountStore *self, TnyList *list, TnyAccountType type)
 						TnyAccount * tny_account = NULL;
 						/* Add the account: */
 						tny_account = modest_tny_account_new_from_server_account_name (
-							priv->account_mgr, transport_account_name);
+							priv->account_mgr, priv->session, transport_account_name);
 						if (tny_account) {
 							g_object_set_data (G_OBJECT(tny_account), "account_store",
 									   (gpointer)self);
@@ -763,13 +1053,11 @@ get_server_accounts  (TnyAccountStore *self, TnyList *list, TnyAccountType type)
 			iter_account_names = g_slist_next (iter_account_names);
 		}		
 	}
-	
-	g_slist_free (account_names);
+
+	/* free the account_names */
+	modest_account_mgr_free_account_names (account_names);
 	account_names = NULL;
-	
-	/* TODO: Delete the strings in the GSList */
-	
-	
+
 	/* We also create a per-account local outbox folder (a _store_ account) 
 	 * for each _transport_ account. */
 	if (type == TNY_ACCOUNT_TYPE_TRANSPORT) {
@@ -806,11 +1094,13 @@ get_server_accounts  (TnyAccountStore *self, TnyList *list, TnyAccountType type)
 				g_object_ref (outbox_account);
 				accounts = g_slist_append (accounts, outbox_account);
 			}
+		}
+		
+		/* Add a merged folder, merging all the per-account outbox folders: */
+		modest_tny_local_folders_account_add_merged_outbox_folders (
+			MODEST_TNY_LOCAL_FOLDERS_ACCOUNT (tny_account), priv->store_accounts_outboxes);
 			
-			/* Add a merged folder, merging all the per-account outbox folders: */
-			modest_tny_local_folders_account_add_merged_outbox_folders (
-				MODEST_TNY_LOCAL_FOLDERS_ACCOUNT (tny_account), priv->store_accounts_outboxes);
-	
+		if (priv->store_accounts_outboxes) {
 			/* We have finished with this temporary list, so free it: */
 			account_list_free (priv->store_accounts_outboxes);
 			priv->store_accounts_outboxes = NULL;
@@ -847,6 +1137,9 @@ modest_tny_account_store_get_accounts  (TnyAccountStore *self, TnyList *list,
 						       TNY_ACCOUNT_STORE_STORE_ACCOUNTS);
 		modest_tny_account_store_get_accounts (self, list,
 						       TNY_ACCOUNT_STORE_TRANSPORT_ACCOUNTS);
+
+		tny_session_camel_set_initialized (priv->session);
+
 		return;
 	}
 	
@@ -855,12 +1148,16 @@ modest_tny_account_store_get_accounts  (TnyAccountStore *self, TnyList *list,
 			get_server_accounts (self, list, TNY_ACCOUNT_TYPE_STORE);
 		else
 			get_cached_accounts (self, list, TNY_ACCOUNT_TYPE_STORE);
+
+		tny_session_camel_set_initialized (priv->session);
 		
 	} else if (request_type == TNY_ACCOUNT_STORE_TRANSPORT_ACCOUNTS) {
 		if (!priv->transport_accounts)
 			get_server_accounts (self, list, TNY_ACCOUNT_TYPE_TRANSPORT);
 		else
 			get_cached_accounts (self, list, TNY_ACCOUNT_TYPE_TRANSPORT);
+
+		tny_session_camel_set_initialized (priv->session);
 	} else
 		g_return_if_reached (); /* incorrect req type */
 }
@@ -901,60 +1198,106 @@ modest_tny_account_store_get_device (TnyAccountStore *self)
 static TnyAccount*
 modest_tny_account_store_find_account_by_url (TnyAccountStore *self, const gchar* url_string)
 {
-	TnyAccount *account = NULL;
-	ModestTnyAccountStorePrivate *priv;	
-	GSList *cursor;
-	
-	g_return_val_if_fail (self, NULL);
-	g_return_val_if_fail (url_string, NULL);
-	
-	priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
-
-	for (cursor = priv->store_accounts; cursor ; cursor = cursor->next) {
-		if (tny_account_matches_url_string (TNY_ACCOUNT(cursor->data), url_string)) {
-			account = TNY_ACCOUNT(cursor->data);
-			break;
-		}
-	}
-
-	if (!account) {
-		for (cursor = priv->transport_accounts; !account && cursor ; cursor = cursor->next) {
-			if (tny_account_matches_url_string (TNY_ACCOUNT(cursor->data), url_string)) {
-				account = TNY_ACCOUNT(cursor->data);
-				break;
-			}
-		}
-	}
-
-	if (account)
-		g_object_ref (G_OBJECT(account));
-
-	return account;
+	return modest_tny_account_store_get_tny_account_by (MODEST_TNY_ACCOUNT_STORE (self), 
+							    MODEST_TNY_ACCOUNT_STORE_QUERY_URL,
+							    url_string);
 }
 
 
 
 static gboolean
-modest_tny_account_store_alert (TnyAccountStore *self, TnyAlertType type,
+modest_tny_account_store_alert (TnyAccountStore *self, TnyAccount *account, TnyAlertType type,
 				gboolean question, const GError *error)
 {
-	/* TODO: It would be nice to know what account caused this error. */
-	
 	g_return_val_if_fail (error, FALSE);
 
 	if ((error->domain != TNY_ACCOUNT_ERROR) 
 		&& (error->domain != TNY_ACCOUNT_STORE_ERROR)) {
-		g_warning("%s: Unexpected error domain: != TNY_ACCOUNT_ERROR: %d, message=%s", 
+		g_warning("modest: %s: Unexpected error domain: != TNY_ACCOUNT_ERROR: %d, message=%s", 
 			__FUNCTION__, error->domain, error->message); 
+			
 		return FALSE;
 	}
 	
-	/* printf("DEBUG: %s: error->message=%s\n", __FUNCTION__, error->message); */
+	printf("DEBUG: %s: GError code: %d, message=%s\n", 
+				__FUNCTION__, error->code, error->message);
+	
+	/* Get the server name: */
+	const gchar* server_name = NULL;
+	if (account && TNY_IS_ACCOUNT (account)) {
+		server_name = tny_account_get_hostname (account);
+		printf ("modest: %s: account name = %s, server_name=%s\n", __FUNCTION__, 
+			tny_account_get_id (account), server_name);
+	}
 	
-
+	if (!server_name)
+		server_name = _("Unknown Server");	
+		
+	ModestTransportStoreProtocol proto = MODEST_PROTOCOL_STORE_POP; /* Arbitrary default. */
+	if (account) {
+		const gchar *proto_name = tny_account_get_proto (account);
+		if (proto_name)
+			proto = modest_protocol_info_get_transport_store_protocol (proto_name);
+		else {
+			g_warning("modest: %s: account with id=%s has no proto.\n", __FUNCTION__, 
+				tny_account_get_id (account));
+		}
+	}
+		
 	/* const gchar *prompt = NULL; */
 	gchar *prompt = NULL;
 	switch (error->code) {
+		case TNY_ACCOUNT_STORE_ERROR_CANCEL_ALERT:
+		case TNY_ACCOUNT_ERROR_TRY_CONNECT_USER_CANCEL:
+			/* Don't show waste the user's time by showing him a dialog telling 
+			 * him that he has just cancelled something: */
+			g_debug ("%s: Handling GError domain=%d, code=%d (cancelled) without showing a dialog, message=%s", 
+ 				__FUNCTION__, error->domain, error->code, error->message);
+			prompt = NULL;
+			break;
+			
+		case TNY_ACCOUNT_ERROR_TRY_CONNECT_HOST_LOOKUP_FAILED:
+			/* TODO: Show the appropriate message, depending on whether it's POP or IMAP: */
+			g_debug ("%s: Handling GError domain=%d, code=%d (lookup failed), message=%s", 
+ 				__FUNCTION__, error->domain, error->code, error->message);
+ 				
+ 			switch (proto) {
+ 				case MODEST_PROTOCOL_STORE_POP:
+					prompt = g_strdup_printf (_("emev_ni_ui_pop3_msg_connect_error"), server_name);
+					break;
+				case MODEST_PROTOCOL_STORE_IMAP:
+					prompt = g_strdup_printf (_("emev_ni_ui_imap_connect_server_error"), server_name);
+					break;
+				case MODEST_PROTOCOL_TRANSPORT_SMTP:
+				default: /* Arbitrary default. */
+					prompt = g_strdup_printf (_("emev_ib_ui_smtp_server_invalid"), server_name);
+					break;
+ 			}
+	
+			/*
+			prompt = g_strdup_printf(
+				_("Incorrect Account Settings:\n Host lookup failed.%s"), 
+				error->message);
+			*/
+			break;
+			
+		case TNY_ACCOUNT_ERROR_TRY_CONNECT_AUTHENTICATION_NOT_SUPPORTED:
+			g_debug ("%s: Handling GError domain=%d, code=%d (authentication not supported), message=%s", 
+ 				__FUNCTION__, error->domain, error->code, error->message);
+			/* TODO: This needs a logical ID for the string: */
+			prompt = g_strdup_printf(
+				_("Incorrect Account Settings:\nThe secure authentication method is not supported.\n%s"), 
+				error->message);
+			break;
+			
+		case TNY_ACCOUNT_ERROR_TRY_CONNECT_CERTIFICATE:
+			g_debug ("%s: Handling GError domain=%d, code=%d (certificatae), message=%s", 
+ 				__FUNCTION__, error->domain, error->code, error->message);
+			prompt = g_strdup_printf(
+				_("Certificate Problem:\n%s"), 
+				error->message);
+			break;
+		
 		case TNY_ACCOUNT_ERROR_TRY_CONNECT:
 		/* The tinymail camel implementation just sends us this for almost 
 		 * everything, so we have to guess at the cause.
@@ -964,54 +1307,23 @@ modest_tny_account_store_alert (TnyAccountStore *self, TnyAlertType type,
 		 * specific dialog messages from Chapter 12 of the UI spec.
 		 */
 		case TNY_ACCOUNT_STORE_ERROR_UNKNOWN_ALERT: 
-		    g_debug ("%s: Handling GError domain=%d, code=%d, message=%s", 
-				__FUNCTION__, error->domain, error->code, error->message);
+			/* This debug output is useful. Please keep it uncommented until 
+			 * we have fixed the problems in this function: */
+			g_debug ("%s: Handling GError domain=%d, code=%d, message=%s", 
+ 				__FUNCTION__, error->domain, error->code, error->message);
 			
 			/* TODO: Remove the internal error message for the real release.
 			 * This is just so the testers can give us more information: */
 			/* prompt = _("Modest account not yet fully configured."); */
 			prompt = g_strdup_printf(
-				"%s\n (Internal error message, often very misleading:\n%s", 
+				"%s\n (Internal error message, often very misleading):\n%s", 
 				_("Incorrect Account Settings"), 
 				error->message);
 				
-			/* TODO: If we can ever determine that the problem is a wrong password:
-			 * In this case, the UI spec wants us to show a banner, and then 
-			 * open the Account Settings dialog. */
-			/* Note: Sometimes, the get_password() function seems to be called again 
-			 * when a password is wrong, but sometimes this alert_func is called. */
-			#if 0
-			GtkWidget *parent_widget = 
-				GTK_WIDGET (
-					modest_window_mgr_get_main_window (
-						modest_runtime_get_window_mgr ()));
-			
-			hildon_banner_show_information (
-				parent_widget,
-				NULL /* icon name */,
-				_("mcen_ib_username_pw_incorrect") );
-				
-			/* Show the Account Settings window: */
-			ModestAccountSettingsDialog *dialog = modest_account_settings_dialog_new ();
-			/* TODO: Get the account somehow. Maybe tinymail should send it with the signal. */
-			const gchar* modest_account_name = 
-				modest_tny_account_get_parent_modest_account_name_for_server_account (account);
-			g_assert (modest_account_name);
-			modest_account_settings_dialog_set_account_name (dialog, 
-				modest_account_name);
-			
-			gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (self));
-			gtk_dialog_run (GTK_DIALOG (dialog));
-			gtk_widget_destroy (GTK_WIDGET (dialog));
-			#endif
+			/* Note: If the password was wrong then get_password() would be called again,
+			 * instead of this vfunc being called. */
 			 
 			break;
-			
-		//TODO: We have started receiving errors of 
-		//domain=TNY_ACCOUNT_ERROR, code=TNY_ACCOUNT_ERROR_TRY_CONNECT, message="Canceled".
-		//If this is really a result of us cancelling our own operation then 
-		//a) this probably shouldn't be an error, and
-		//b) should have its own error code.
 		
 		default:
 			g_warning ("%s: Unhandled GError code: %d, message=%s", 
@@ -1053,7 +1365,7 @@ modest_tny_account_store_alert (TnyAccountStore *self, TnyAlertType type,
 		break;
 	}
 	
-	GtkWidget *dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL,
+	GtkWidget *dialog = gtk_message_dialog_new (NULL, 0,
 		gtktype, GTK_BUTTONS_YES_NO, prompt);
 #endif /* #ifdef MODEST_PLATFORM_MAEMO */
 
@@ -1061,7 +1373,7 @@ modest_tny_account_store_alert (TnyAccountStore *self, TnyAlertType type,
 	const int response = gtk_dialog_run (GTK_DIALOG (dialog));
 	if (question) {
 		retval = (response == GTK_RESPONSE_YES) ||
-				 (response == GTK_RESPONSE_OK);	
+				 (response == GTK_RESPONSE_OK);
 	}
 
 	gtk_widget_destroy (dialog);
@@ -1112,38 +1424,91 @@ modest_tny_account_store_get_session  (TnyAccountStore *self)
 }
 
 
+
 TnyAccount*
-modest_tny_account_store_get_tny_account_by_id  (ModestTnyAccountStore *self, const gchar *id)
+modest_tny_account_store_get_tny_account_by (ModestTnyAccountStore *self, 
+					     ModestTnyAccountStoreQueryType type,
+					     const gchar *str)
 {
 	TnyAccount *account = NULL;
 	ModestTnyAccountStorePrivate *priv;	
 	GSList *cursor;
-
+	const gchar *val = NULL;
+	TnyList* list; 
+	
+	
 	g_return_val_if_fail (self, NULL);
-	g_return_val_if_fail (id, NULL);
+	g_return_val_if_fail (str, NULL);
 	
 	priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 
+	/* fill the caches, as that may not have happened yet */
+	list = TNY_LIST(tny_simple_list_new());
+	modest_tny_account_store_get_accounts  (TNY_ACCOUNT_STORE(self),
+						list, TNY_ACCOUNT_STORE_BOTH);
+	g_object_unref (list);
 
+	
+	
+	/* Search in store accounts */
 	for (cursor = priv->store_accounts; cursor ; cursor = cursor->next) {
-		const gchar *acc_id = tny_account_get_id (TNY_ACCOUNT(cursor->data));
-		if (acc_id && strcmp (acc_id, id) == 0) {
-			account = TNY_ACCOUNT(cursor->data);
+		switch (type) {
+		case MODEST_TNY_ACCOUNT_STORE_QUERY_ID:
+			val = tny_account_get_id (TNY_ACCOUNT(cursor->data));
 			break;
+		case MODEST_TNY_ACCOUNT_STORE_QUERY_URL:
+			val = tny_account_get_url_string (TNY_ACCOUNT(cursor->data));
+			break;
+		}
+		
+		if (type == MODEST_TNY_ACCOUNT_STORE_QUERY_URL && 
+		    tny_account_matches_url_string (TNY_ACCOUNT(cursor->data), str)) {
+			account = TNY_ACCOUNT (cursor->data);
+			goto end;
+		} else {
+			if (strcmp (val, str) == 0) {
+				account = TNY_ACCOUNT(cursor->data);
+				goto end;
+			}
 		}
 	}
 		
 	/* if we already found something, no need to search the transport accounts */
 	for (cursor = priv->transport_accounts; !account && cursor ; cursor = cursor->next) {
-		const gchar *acc_id = tny_account_get_id (TNY_ACCOUNT(cursor->data));
-		if (acc_id && strcmp (acc_id, id) == 0) {
-			account = TNY_ACCOUNT(cursor->data);
+		switch (type) {
+		case MODEST_TNY_ACCOUNT_STORE_QUERY_ID:
+			val = tny_account_get_id (TNY_ACCOUNT(cursor->data));
 			break;
+		case MODEST_TNY_ACCOUNT_STORE_QUERY_URL:
+			val = tny_account_get_url_string (TNY_ACCOUNT(cursor->data));
+			break;
+		}
+		
+		if (type == MODEST_TNY_ACCOUNT_STORE_QUERY_URL && 
+		    tny_account_matches_url_string (TNY_ACCOUNT(cursor->data), val)) {
+			account = TNY_ACCOUNT (cursor->data);
+			goto end;
+		} else {
+			if (strcmp (val, str) == 0) {
+				account = TNY_ACCOUNT(cursor->data);
+				goto end;
+			}
 		}
 	}
-
+ end:
 	if (account)
 		g_object_ref (G_OBJECT(account));
+	else {
+		/* Warn if nothing was found. This is generally unusual. */
+		switch (type) {
+		case MODEST_TNY_ACCOUNT_STORE_QUERY_ID:
+			g_warning("%s: Failed to find account with ID=%s\n", __FUNCTION__, str);
+			break;
+		case MODEST_TNY_ACCOUNT_STORE_QUERY_URL:
+			g_warning("%s: Failed to find account with URL=%s\n", __FUNCTION__, str);
+			break;
+		}
+	}
 	
 	return account;
 }
@@ -1174,16 +1539,16 @@ modest_tny_account_store_get_server_account (ModestTnyAccountStore *self,
 		}
 	} else {
 		ModestAccountData *account_data;
-
 		account_data = modest_account_mgr_get_account_data (priv->account_mgr, account_name);
 		if (!account_data) {
-			g_printerr ("modest: %s: cannot get account data for account '%s'\n", __FUNCTION__, account_name);
+			g_printerr ("modest: %s: cannot get account data for account '%s'\n", __FUNCTION__,
+				    account_name);
 			return NULL;
 		}
 
 		if (type == TNY_ACCOUNT_TYPE_STORE && account_data->store_account)
 			id = g_strdup (account_data->store_account->account_name);
-		else if (account_data->transport_account)
+		else if (type == TNY_ACCOUNT_TYPE_TRANSPORT && account_data->transport_account)
 			id = g_strdup (account_data->transport_account->account_name);
 
 		modest_account_mgr_free_account_data (priv->account_mgr, account_data);
@@ -1193,12 +1558,14 @@ modest_tny_account_store_get_server_account (ModestTnyAccountStore *self,
 		g_printerr ("modest: could not get an id for account %s\n",
 			    account_name);
 	else 	
-		account = modest_tny_account_store_get_tny_account_by_id (self, id);
+		account = modest_tny_account_store_get_tny_account_by (self, 
+								       MODEST_TNY_ACCOUNT_STORE_QUERY_ID, id);
 
 	if (!account)
 		g_printerr ("modest: could not get tny %s account for %s (id=%s)\n",
 			    type == TNY_ACCOUNT_TYPE_STORE ? "store" : "transport",
 			    account_name, id ? id : "<none>");
+	g_free (id);
 
 	return account;	
 }
@@ -1213,6 +1580,10 @@ get_smtp_specific_transport_account_for_open_connection (ModestTnyAccountStore *
 	if (!tny_device_is_online (device))
 		return NULL;
 
+	g_return_val_if_fail (self, NULL);
+	g_return_val_if_fail (account_name, NULL);
+	
+	
 #ifdef MODEST_PLATFORM_MAEMO
 	g_assert (TNY_IS_MAEMO_CONIC_DEVICE (device));
 	TnyMaemoConicDevice *maemo_device = TNY_MAEMO_CONIC_DEVICE (device);	
@@ -1240,7 +1611,9 @@ get_smtp_specific_transport_account_for_open_connection (ModestTnyAccountStore *
 		return NULL; /* No connection-specific SMTP server was specified for this connection. */
 	}
 		
-	TnyAccount* account = modest_tny_account_store_get_tny_account_by_id (self, server_account_name);
+	TnyAccount* account = modest_tny_account_store_get_tny_account_by (self, 
+									   MODEST_TNY_ACCOUNT_STORE_QUERY_ID, 
+									   server_account_name);
 
 	/* printf ("DEBUG: %s: account=%p\n", __FUNCTION__, account); */
 	g_free (server_account_name);	
@@ -1259,8 +1632,15 @@ TnyAccount*
 modest_tny_account_store_get_transport_account_for_open_connection (ModestTnyAccountStore *self,
 								    const gchar *account_name)
 {
+	g_return_val_if_fail (self, NULL);
+	g_return_val_if_fail (account_name, NULL);
+
+	if (!account_name || !self)
+		return NULL;
+	
 	/*  Get the connection-specific transport acccount, if any: */
-	TnyAccount *account = get_smtp_specific_transport_account_for_open_connection (self, account_name);
+	TnyAccount *account =
+		get_smtp_specific_transport_account_for_open_connection (self, account_name);
 			
 	/* If there is no connection-specific transport account (the common case), 
 	 * just get the regular transport account: */
@@ -1278,14 +1658,30 @@ modest_tny_account_store_get_transport_account_for_open_connection (ModestTnyAcc
 	return account;
 }
 
-gboolean modest_tny_account_is_virtual_local_folders (TnyAccount *self)
+gboolean
+modest_tny_account_is_virtual_local_folders (TnyAccount *self)
 {
 	/* We should make this more sophisticated if we ever use ModestTnyLocalFoldersAccount 
 	 * for anything else. */
 	return MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (self);
 }
 
-TnyAccount* modest_tny_account_store_get_local_folders_account (TnyAccountStore *self)
+
+gboolean
+modest_tny_account_is_memory_card_account (TnyAccount *self)
+{
+	if (!self)
+		return FALSE;
+
+	const gchar* account_id = tny_account_get_id (self);
+	if (!account_id)
+		return FALSE;
+	
+	return (strcmp (account_id, MODEST_MMC_ACCOUNT_ID) == 0);
+}
+
+TnyAccount*
+modest_tny_account_store_get_local_folders_account (TnyAccountStore *self)
 {
 	TnyAccount *account = NULL;
 	ModestTnyAccountStorePrivate *priv;	
@@ -1308,3 +1704,5 @@ TnyAccount* modest_tny_account_store_get_local_folders_account (TnyAccountStore
 	
 	return account;
 }
+
+