git.maemo.org Git - modest/blob - src/modest-tny-account-store.c

   1 /* Copyright (c) 2006, Nokia Corporation
   2  * All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  * * Redistributions of source code must retain the above copyright
   9  *   notice, this list of conditions and the following disclaimer.
  10  * * Redistributions in binary form must reproduce the above copyright
  11  *   notice, this list of conditions and the following disclaimer in the
  12  *   documentation and/or other materials provided with the distribution.
  13  * * Neither the name of the Nokia Corporation nor the names of its
  14  *   contributors may be used to endorse or promote products derived from
  15  *   this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  18  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  21  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  25  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  26  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  27  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include <string.h>
  31 #include <glib/gi18n.h>
  32
  33 #include <tny-error.h>
  34 #include <tny-account.h>
  35 #include <tny-account-store.h>
  36 #include <tny-store-account.h>
  37 #include <tny-transport-account.h>
  38 #include <tny-simple-list.h>
  39 #include <tny-account-store.h>
  40 #include <tny-camel-transport-account.h>
  41 #include <tny-camel-imap-store-account.h>
  42 #include <tny-camel-pop-store-account.h>
  43 #include "modest-text-utils.h"
  44 #include <modest-runtime.h>
  45 #include <modest-marshal.h>
  46 #include <modest-protocol-registry.h>
  47 #include <modest-local-folder-info.h>
  48 #include "modest-account-protocol.h"
  49 #include <modest-tny-account.h>
  50 #include <modest-tny-local-folders-account.h>
  51 #include <modest-account-mgr.h>
  52 #include <modest-account-mgr-helpers.h>
  53 #include <widgets/modest-window-mgr.h>
  54 #include <modest-signal-mgr.h>
  55 #include <modest-debug.h>
  56
  57 #include <modest-defs.h>
  58 #include "modest-tny-account-store.h"
  59 #include "modest-tny-platform-factory.h"
  60 #include <tny-gtk-lockable.h>
  61 #include <camel/camel.h>
  62 #include <modest-platform.h>
  63 #include "modest-ui-actions.h"
  64 #include <widgets/modest-account-settings-dialog.h>
  65
  66 #ifdef MODEST_PLATFORM_MAEMO
  67 #include <tny-maemo-conic-device.h>
  68 #include <maemo/modest-maemo-utils.h>
  69 #endif
  70
  71 #include <libgnomevfs/gnome-vfs-volume-monitor.h>
  72
  73 /* 'private'/'protected' functions */
  74 static void    modest_tny_account_store_class_init   (ModestTnyAccountStoreClass *klass);
  75 static void    modest_tny_account_store_finalize     (GObject *obj);
  76 static void    modest_tny_account_store_instance_init (ModestTnyAccountStore *obj);
  77 static void    modest_tny_account_store_init          (gpointer g, gpointer iface_data);
  78 static void    modest_tny_account_store_base_init     (gpointer g_class);
  79
  80 static void    on_account_inserted         (ModestAccountMgr *acc_mgr,
  81                                             const gchar *account,
  82                                             gpointer user_data);
  83
  84 static void   add_existing_accounts       (ModestTnyAccountStore *self);
  85
  86 static void    insert_account              (ModestTnyAccountStore *self,
  87                                             const gchar *account,
  88                                             gboolean notify);
  89
  90 static void    on_account_removed          (ModestAccountMgr *acc_mgr,
  91                                             const gchar *account,
  92                                             gpointer user_data);
  93
  94 static gchar*  get_password                (TnyAccount *account,
  95                                             const gchar * prompt_not_used,
  96                                             gboolean *cancel);
  97
  98 static void    forget_password             (TnyAccount *account);
  99
 100 static void    on_vfs_volume_mounted       (GnomeVFSVolumeMonitor *volume_monitor,
 101                                             GnomeVFSVolume *volume,
 102                                             gpointer user_data);
 103
 104 static void    on_vfs_volume_unmounted     (GnomeVFSVolumeMonitor *volume_monitor,
 105                                             GnomeVFSVolume *volume,
 106                                             gpointer user_data);
 107
 108 static void    forget_password_in_memory (ModestTnyAccountStore *self,
 109                                           const gchar *server_account_name);
 110
 111 static void    add_connection_specific_transport_accounts         (ModestTnyAccountStore *self);
 112
 113 static void    remove_connection_specific_transport_accounts      (ModestTnyAccountStore *self);
 114
 115 static inline gboolean only_local_accounts        (ModestTnyAccountStore *self);
 116
 117 /* list my signals */
 118 enum {
 119         ACCOUNT_CHANGED_SIGNAL,
 120         ACCOUNT_INSERTED_SIGNAL,
 121         ACCOUNT_REMOVED_SIGNAL,
 122
 123         PASSWORD_REQUESTED_SIGNAL,
 124         LAST_SIGNAL
 125 };
 126
 127 typedef struct _ModestTnyAccountStorePrivate ModestTnyAccountStorePrivate;
 128 struct _ModestTnyAccountStorePrivate {
 129         gchar              *cache_dir;
 130         GHashTable         *password_hash;
 131         ModestAccountMgr   *account_mgr;
 132         TnySessionCamel    *session;
 133         TnyDevice          *device;
 134
 135         GSList *sighandlers;
 136
 137         /* We cache the lists of accounts here */
 138         TnyList             *store_accounts;
 139         TnyList             *transport_accounts;
 140         TnyList             *store_accounts_outboxes;
 141
 142         /* Matches transport accounts and outbox folder */
 143         GHashTable          *outbox_of_transport;
 144
 145         /* is sending mail blocked? */
 146         gboolean send_mail_blocked;
 147 };
 148
 149 #define MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
 150                                                       MODEST_TYPE_TNY_ACCOUNT_STORE, \
 151                                                       ModestTnyAccountStorePrivate))
 152
 153 /* globals */
 154 static GObjectClass *parent_class = NULL;
 155
 156 static guint signals[LAST_SIGNAL] = {0};
 157
 158 GType
 159 modest_tny_account_store_get_type (void)
 160 {
 161         static GType my_type = 0;
 162
 163         if (!my_type) {
 164                 static const GTypeInfo my_info = {
 165                         sizeof(ModestTnyAccountStoreClass),
 166                         modest_tny_account_store_base_init,     /* base init */
 167                         NULL,           /* base finalize */
 168                         (GClassInitFunc) modest_tny_account_store_class_init,
 169                         NULL,           /* class finalize */
 170                         NULL,           /* class data */
 171                         sizeof(ModestTnyAccountStore),
 172                         0,              /* n_preallocs */
 173                         (GInstanceInitFunc) modest_tny_account_store_instance_init,
 174                         NULL
 175                 };
 176
 177                 static const GInterfaceInfo iface_info = {
 178                         (GInterfaceInitFunc) modest_tny_account_store_init,
 179                         NULL,         /* interface_finalize */
 180                         NULL          /* interface_data */
 181                 };
 182                 /* hack hack */
 183                 my_type = g_type_register_static (G_TYPE_OBJECT,
 184                                                   "ModestTnyAccountStore",
 185                                                   &my_info, 0);
 186                 g_type_add_interface_static (my_type, TNY_TYPE_ACCOUNT_STORE,
 187                                              &iface_info);
 188         }
 189         return my_type;
 190 }
 191
 192
 193 static void
 194 modest_tny_account_store_base_init (gpointer g_class)
 195 {
 196         static gboolean tny_account_store_initialized = FALSE;
 197
 198         if (!tny_account_store_initialized) {
 199
 200                 signals[ACCOUNT_CHANGED_SIGNAL] =
 201                         g_signal_new ("account_changed",
 202                                       MODEST_TYPE_TNY_ACCOUNT_STORE,
 203                                       G_SIGNAL_RUN_FIRST,
 204                                       G_STRUCT_OFFSET (ModestTnyAccountStoreClass, account_changed),
 205                                       NULL, NULL,
 206                                       g_cclosure_marshal_VOID__OBJECT,
 207                                       G_TYPE_NONE, 1, TNY_TYPE_ACCOUNT);
 208
 209                 signals[ACCOUNT_INSERTED_SIGNAL] =
 210                         g_signal_new ("account_inserted",
 211                                       MODEST_TYPE_TNY_ACCOUNT_STORE,
 212                                       G_SIGNAL_RUN_FIRST,
 213                                       G_STRUCT_OFFSET (ModestTnyAccountStoreClass, account_inserted),
 214                                       NULL, NULL,
 215                                       g_cclosure_marshal_VOID__OBJECT,
 216                                       G_TYPE_NONE, 1, TNY_TYPE_ACCOUNT);
 217
 218                 signals[ACCOUNT_REMOVED_SIGNAL] =
 219                         g_signal_new ("account_removed",
 220                                       MODEST_TYPE_TNY_ACCOUNT_STORE,
 221                                       G_SIGNAL_RUN_FIRST,
 222                                       G_STRUCT_OFFSET (ModestTnyAccountStoreClass, account_removed),
 223                                       NULL, NULL,
 224                                       g_cclosure_marshal_VOID__OBJECT,
 225                                       G_TYPE_NONE, 1, TNY_TYPE_ACCOUNT);
 226
 227                 signals[PASSWORD_REQUESTED_SIGNAL] =
 228                         g_signal_new ("password_requested",
 229                                       MODEST_TYPE_TNY_ACCOUNT_STORE,
 230                                       G_SIGNAL_RUN_FIRST,
 231                                       G_STRUCT_OFFSET(ModestTnyAccountStoreClass, password_requested),
 232                                       NULL, NULL,
 233                                       modest_marshal_VOID__STRING_POINTER_POINTER_POINTER_POINTER,
 234                                       G_TYPE_NONE, 5, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER,
 235                                       G_TYPE_POINTER);
 236
 237                 tny_account_store_initialized = TRUE;
 238         }
 239 }
 240
 241
 242 static void
 243 modest_tny_account_store_class_init (ModestTnyAccountStoreClass *klass)
 244 {
 245         GObjectClass *gobject_class;
 246         gobject_class = (GObjectClass*) klass;
 247
 248         parent_class            = g_type_class_peek_parent (klass);
 249         gobject_class->finalize = modest_tny_account_store_finalize;
 250
 251         g_type_class_add_private (gobject_class,
 252                                   sizeof(ModestTnyAccountStorePrivate));
 253 }
 254
 255 static void
 256 modest_tny_account_store_instance_init (ModestTnyAccountStore *obj)
 257 {
 258         GnomeVFSVolumeMonitor* monitor = NULL;
 259         ModestTnyAccountStorePrivate *priv;
 260
 261         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(obj);
 262
 263         priv->cache_dir              = NULL;
 264         priv->account_mgr            = NULL;
 265         priv->session                = NULL;
 266         priv->device                 = NULL;
 267         priv->sighandlers            = NULL;
 268         priv->send_mail_blocked      = FALSE;
 269
 270         priv->outbox_of_transport = g_hash_table_new_full (g_direct_hash,
 271                                                            g_direct_equal,
 272                                                            NULL,
 273                                                            NULL);
 274
 275         /* An in-memory store of passwords,
 276          * for passwords that are not remembered in the configuration,
 277          * so they need to be asked for from the user once in each session:
 278          */
 279         priv->password_hash = g_hash_table_new_full (g_str_hash, g_str_equal,
 280                                                      g_free, g_free);
 281
 282         /* Respond to volume mounts and unmounts, such
 283          * as the insertion/removal of the memory card: */
 284         /* This is a singleton, so it does not need to be unrefed. */
 285         monitor = gnome_vfs_get_volume_monitor();
 286
 287         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
 288                                                        G_OBJECT(monitor),
 289                                                        "volume-mounted",
 290                                                        G_CALLBACK(on_vfs_volume_mounted),
 291                                                        obj);
 292         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
 293                                                        G_OBJECT(monitor), "volume-unmounted",
 294                                                        G_CALLBACK(on_vfs_volume_unmounted),
 295                                                        obj);
 296 }
 297
 298 /* disconnect the list of TnyAccounts */
 299 static void
 300 account_verify_last_ref (TnyAccount *account, const gchar *str)
 301 {
 302         gchar *txt;
 303
 304         g_return_if_fail (account && TNY_IS_ACCOUNT(account));
 305
 306         txt = g_strdup_printf ("%s: %s", str ? str : "?", tny_account_get_name(account));
 307         MODEST_DEBUG_VERIFY_OBJECT_LAST_REF(G_OBJECT(account),txt);
 308         g_free (txt);
 309 }
 310
 311 static void
 312 foreach_account_append_to_list (gpointer data,
 313                                 gpointer user_data)
 314 {
 315         TnyList *list;
 316
 317         list = TNY_LIST (user_data);
 318         tny_list_append (list, G_OBJECT (data));
 319 }
 320
 321 /********************************************************************/
 322 /*           Control the state of the MMC local account             */
 323 /********************************************************************/
 324
 325 /** Only call this if the memory card is really mounted.
 326  */
 327 static void
 328 add_mmc_account(ModestTnyAccountStore *self, gboolean emit_insert_signal)
 329 {
 330         ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 331         g_return_if_fail (priv->session);
 332
 333         TnyAccount *mmc_account = modest_tny_account_new_for_local_folders (priv->account_mgr,
 334                                                                             priv->session,
 335                                                                             g_getenv (MODEST_MMC1_VOLUMEPATH_ENV));
 336
 337         /* Add to the list of store accounts */
 338         tny_list_append (priv->store_accounts, G_OBJECT (mmc_account));
 339
 340         if (emit_insert_signal) {
 341                 g_signal_emit (G_OBJECT (self),
 342                                signals [ACCOUNT_INSERTED_SIGNAL],
 343                                0, mmc_account);
 344         }
 345
 346         /* Free */
 347         g_object_unref (mmc_account);
 348 }
 349
 350 static void
 351 on_vfs_volume_mounted(GnomeVFSVolumeMonitor *volume_monitor,
 352                       GnomeVFSVolume *volume,
 353                       gpointer user_data)
 354 {
 355         ModestTnyAccountStore *self;
 356         ModestTnyAccountStorePrivate *priv;
 357         gchar *volume_path_uri;
 358
 359         gchar *uri = NULL;
 360
 361         self = MODEST_TNY_ACCOUNT_STORE(user_data);
 362         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 363
 364         /* Check whether this was the external MMC1 card: */
 365         uri = gnome_vfs_volume_get_activation_uri (volume);
 366
 367         volume_path_uri = g_strconcat (MODEST_MMC1_VOLUMEPATH_URI_PREFIX,
 368                                        g_getenv (MODEST_MMC1_VOLUMEPATH_ENV),
 369                                        NULL);
 370         if (uri && (!strcmp (uri, volume_path_uri))) {
 371                 add_mmc_account (self, TRUE /* emit the insert signal. */);
 372         }
 373
 374         g_free (volume_path_uri);
 375         g_free (uri);
 376 }
 377
 378 static void
 379 on_vfs_volume_unmounted(GnomeVFSVolumeMonitor *volume_monitor,
 380                         GnomeVFSVolume *volume,
 381                         gpointer user_data)
 382 {
 383         ModestTnyAccountStore *self;
 384         ModestTnyAccountStorePrivate *priv;
 385         gchar *uri = NULL;
 386         gchar *volume_path_uri;
 387
 388         self = MODEST_TNY_ACCOUNT_STORE(user_data);
 389         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 390
 391         /* Check whether this was the external MMC1 card: */
 392         uri = gnome_vfs_volume_get_activation_uri (volume);
 393         volume_path_uri = g_strconcat (MODEST_MMC1_VOLUMEPATH_URI_PREFIX,
 394                                        g_getenv (MODEST_MMC1_VOLUMEPATH_ENV),
 395                                        NULL);
 396         if (uri && (strcmp (uri, volume_path_uri) == 0)) {
 397                 TnyAccount *mmc_account = NULL;
 398                 gboolean found = FALSE;
 399                 TnyIterator *iter = NULL;
 400
 401                 iter = tny_list_create_iterator (priv->store_accounts);
 402                 while (!tny_iterator_is_done (iter) && !found) {
 403                         TnyAccount *account;
 404
 405                         account = TNY_ACCOUNT (tny_iterator_get_current (iter));
 406                         if (modest_tny_account_is_memory_card_account (account)) {
 407                                 found = TRUE;
 408                                 mmc_account = g_object_ref (account);
 409                         }
 410                         g_object_unref (account);
 411                         tny_iterator_next (iter);
 412                 }
 413                 g_object_unref (iter);
 414
 415                 if (found) {
 416                         /* Remove from the list */
 417                         tny_list_remove (priv->store_accounts, G_OBJECT (mmc_account));
 418
 419                         /* Notify observers */
 420                         g_signal_emit (G_OBJECT (self),
 421                                        signals [ACCOUNT_REMOVED_SIGNAL],
 422                                        0, mmc_account);
 423
 424                         g_object_unref (mmc_account);
 425                 } else {
 426                         g_warning ("%s: there was no store account for the unmounted MMC",
 427                                    __FUNCTION__);
 428                 }
 429         }
 430         g_free (volume_path_uri);
 431         g_free (uri);
 432 }
 433
 434 /**
 435  * forget_password_in_memory
 436  * @self: a TnyAccountStore instance
 437  * @account: A server account.
 438  *
 439  * Forget any password stored in memory for this account.
 440  * For instance, this should be called when the user has changed the password in the account settings.
 441  */
 442 static void
 443 forget_password_in_memory (ModestTnyAccountStore *self,
 444                            const gchar * server_account_name)
 445 {
 446         ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 447
 448         if (server_account_name && priv->password_hash) {
 449                 g_hash_table_remove (priv->password_hash, server_account_name);
 450         }
 451 }
 452
 453 static void
 454 on_account_changed (ModestAccountMgr *acc_mgr,
 455                     const gchar *account_name,
 456                     TnyAccountType account_type,
 457                     gpointer user_data)
 458 {
 459         ModestTnyAccountStore *self = MODEST_TNY_ACCOUNT_STORE(user_data);
 460         ModestTnyAccountStorePrivate *priv;
 461         TnyList* account_list;
 462         gboolean found = FALSE;
 463         TnyIterator *iter = NULL;
 464
 465         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 466         account_list = (account_type == TNY_ACCOUNT_TYPE_STORE ?
 467                         priv->store_accounts :
 468                         priv->transport_accounts);
 469
 470         iter = tny_list_create_iterator (account_list);
 471         while (!tny_iterator_is_done (iter) && !found) {
 472                 TnyAccount *tny_account;
 473                 tny_account = TNY_ACCOUNT (tny_iterator_get_current (iter));
 474                 if (tny_account) {
 475                         if (!strcmp (tny_account_get_id (tny_account), account_name)) {
 476                                 found = TRUE;
 477                                 modest_tny_account_update_from_account (tny_account, get_password, forget_password);
 478                                 g_signal_emit (G_OBJECT(self), signals[ACCOUNT_CHANGED_SIGNAL], 0, tny_account);
 479                         }
 480                         g_object_unref (tny_account);
 481                 }
 482                 tny_iterator_next (iter);
 483         }
 484
 485         if (iter)
 486                 g_object_unref (iter);
 487 }
 488
 489 static void
 490 show_password_warning_only (const gchar *msg)
 491 {
 492         /* Show an explanatory temporary banner: */
 493         if (modest_window_mgr_get_num_windows (modest_runtime_get_window_mgr ()))
 494                 modest_platform_information_banner (NULL, NULL, msg);
 495 }
 496
 497 static void
 498 show_wrong_password_dialog (TnyAccount *account)
 499 {
 500         if (g_object_get_data (G_OBJECT (account), "connection_specific") != NULL) {
 501                 modest_ui_actions_on_smtp_servers (NULL, NULL);
 502         } else {
 503                 ModestAccountProtocol *proto;
 504                 ModestProtocolType proto_type;
 505                 const gchar *modest_account_name;
 506                 modest_account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (account);
 507
 508                 /* Get proto */
 509                 proto_type = modest_account_mgr_get_store_protocol (modest_runtime_get_account_mgr (),
 510                                                                     modest_account_name);
 511                 proto = (ModestAccountProtocol *)
 512                         modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
 513                                                                        proto_type);
 514
 515                 /* Create and show the dialog */
 516                 if (proto && MODEST_IS_ACCOUNT_PROTOCOL (proto)) {
 517                         ModestAccountSettingsDialog *dialog =
 518                                 modest_account_protocol_get_account_settings_dialog (proto, modest_account_name);
 519                         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (dialog), NULL);
 520                         gtk_widget_show (GTK_WIDGET (dialog));
 521                 }
 522         }
 523         /* Show an explanatory temporary banner: */
 524         modest_platform_information_banner (NULL, NULL, _("mcen_ib_username_pw_incorrect"));
 525 }
 526
 527 /* This callback will be called by Tinymail when it needs the password
 528  * from the user or the account settings.
 529  * It can also call forget_password() before calling this,
 530  * so that we clear wrong passwords out of our account settings.
 531  * Note that TnyAccount here will be the server account. */
 532 static gchar*
 533 get_password (TnyAccount *account, const gchar * prompt_not_used, gboolean *cancel)
 534 {
 535         ModestTnyAccountStore *self = NULL;
 536         ModestTnyAccountStorePrivate *priv;
 537         gchar *username = NULL;
 538         gchar *pwd = NULL;
 539         gpointer pwd_ptr = NULL;
 540         gboolean already_asked = FALSE;
 541         const gchar *server_account_name;
 542         gchar *url_string;
 543
 544         g_return_val_if_fail (account, NULL);
 545
 546         MODEST_DEBUG_BLOCK(
 547                 g_debug ("%s: prompt (not shown) = %s\n", __FUNCTION__, prompt_not_used);
 548         );
 549
 550         /* Get a reference to myself */
 551         self = MODEST_TNY_ACCOUNT_STORE (g_object_get_data (G_OBJECT(account), "account_store"));
 552         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 553
 554         /* Ensure that we still have this account. It could happen
 555            that a set_online was requested *before* removing an
 556            account, and due to tinymail emits the get_password
 557            function using a g_idle the account could be actually
 558            removed *before* this function was really called */
 559         url_string = tny_account_get_url_string (account);
 560         if (url_string) {
 561                 TnyAccount *tmp_account;
 562
 563                 tmp_account = tny_account_store_find_account (TNY_ACCOUNT_STORE (self),
 564                                                               url_string);
 565                 g_free (url_string);
 566
 567                 if (!tmp_account) {
 568                         *cancel = TRUE;
 569                         return NULL;
 570                 }
 571                 g_object_unref (tmp_account);
 572         }
 573
 574         server_account_name = tny_account_get_id (account);
 575         if (!server_account_name || !self) {
 576                 g_warning ("modest: %s: could not retrieve account_store for account %s",
 577                            __FUNCTION__, server_account_name ? server_account_name : "<NULL>");
 578                 if (cancel)
 579                         *cancel = TRUE;
 580
 581                 return NULL;
 582         }
 583
 584         /* This hash map stores passwords, including passwords that are not stored in gconf. */
 585         /* Is it in the hash? if it's already there, it must be wrong... */
 586         pwd_ptr = (gpointer)&pwd; /* pwd_ptr so the compiler does not complained about
 587                                    * type-punned ptrs...*/
 588         already_asked = priv->password_hash &&
 589                                 g_hash_table_lookup_extended (priv->password_hash,
 590                                                       server_account_name,
 591                                                       NULL,
 592                                                       (gpointer*)&pwd_ptr);
 593         MODEST_DEBUG_BLOCK(
 594                 g_debug ("%s: Already asked = %d\n", __FUNCTION__, already_asked);
 595         );
 596
 597         /* If the password is not already there, try ModestConf */
 598         if (!already_asked) {
 599                 pwd  = modest_account_mgr_get_server_account_password (priv->account_mgr,
 600                                                                        server_account_name);
 601                 g_hash_table_insert (priv->password_hash, g_strdup (server_account_name), g_strdup (pwd));
 602         }
 603
 604         /* If it was already asked, it must have been wrong, so ask again */
 605         if (already_asked || !pwd || strlen(pwd) == 0) {
 606                 gboolean settings_have_password;
 607                 ModestProtocolType protocol_type;
 608
 609                 /* As per the UI spec, if no password was set in the account settings,
 610                  * ask for it now. But if the password is wrong in the account settings,
 611                  * then show a banner and the account settings dialog so it can be corrected:
 612                  */
 613                 settings_have_password =
 614                         modest_account_mgr_get_server_account_has_password (priv->account_mgr, server_account_name);
 615
 616                 protocol_type = modest_tny_account_get_protocol_type (account);
 617
 618                 /* Show an error and after that ask for a password */
 619                 if (modest_protocol_registry_protocol_type_has_tag(modest_runtime_get_protocol_registry (),
 620                                                                    protocol_type, MODEST_PROTOCOL_REGISTRY_TRANSPORT_PROTOCOLS)) {
 621                         gchar *username = NULL, *msg = NULL;
 622                         username = modest_account_mgr_get_server_account_username (priv->account_mgr,
 623                                                                                    server_account_name);
 624                         if (!username || strlen(username) == 0) {
 625                                 msg = g_strdup_printf (_("emev_ni_ui_smtp_userid_invalid"),
 626                                                        tny_account_get_name (account),
 627                                                        tny_account_get_hostname (account));
 628                         } else {
 629                                 gchar *password;
 630                                 password  = modest_account_mgr_get_server_account_password (priv->account_mgr,
 631                                                                                             server_account_name);
 632
 633                                 if (already_asked)
 634                                         msg = g_strdup (_("mcen_ib_username_pw_incorrect"));
 635                                 else if (!password || strlen(password) == 0)
 636                                         msg = g_strdup_printf (_("emev_ni_ui_smtp_passwd_invalid"),
 637                                                                tny_account_get_name (account),
 638                                                                tny_account_get_hostname (account));
 639                                 else
 640                                         msg = g_strdup_printf (_("emev_ni_ui_smtp_authentication_fail_error"),
 641                                                                tny_account_get_hostname (account));
 642                                 if (password)
 643                                         g_free (password);
 644                         }
 645                         if (msg) {
 646                                 modest_platform_run_information_dialog (NULL, msg, TRUE);
 647                                 g_free (msg);
 648                         }
 649                         if (username)
 650                                 g_free (username);
 651                 }
 652
 653                 if (settings_have_password) {
 654                         /* The password must be wrong, so show the account settings dialog so it can be corrected: */
 655                         show_wrong_password_dialog (account);
 656
 657                         if (cancel)
 658                                 *cancel = TRUE;
 659
 660                         return NULL;
 661                 }
 662
 663                 /* we don't have it yet. Get the password from the user */
 664                 const gchar* account_id = tny_account_get_id (account);
 665                 gboolean remember = FALSE;
 666                 pwd = NULL;
 667
 668                 if (already_asked) {
 669                         const gchar *msg;
 670                         gboolean username_known =
 671                                 modest_account_mgr_get_server_account_username_has_succeeded(priv->account_mgr,
 672                                                                                              server_account_name);
 673                         /* If the login has ever succeeded then show a specific message */
 674                         if (username_known)
 675                                 msg = _CS ("ecdg_ib_set_password_incorrect");
 676                         else
 677                                 msg = _("mcen_ib_username_pw_incorrect");
 678                         show_password_warning_only (msg);
 679                 }
 680
 681                 /* Request password */
 682                 g_signal_emit (G_OBJECT (self), signals[PASSWORD_REQUESTED_SIGNAL], 0,
 683                                account_id, /* server_account_name */
 684                                &username, &pwd, cancel, &remember);
 685
 686
 687                 if (!*cancel) {
 688                         /* The password will be returned as the result,
 689                          * but we need to tell tinymail about the username too: */
 690
 691                         /* WARNING: I disabled setting username as this can cause locks. Anyway,
 692                          * as now we have the password dialog username entry always dimmed
 693                          * this shouldn't be a problem */
 694
 695                         /* if (username) */
 696                         /*      tny_account_set_user (account, username); */
 697
 698                         /* Do not save the password in gconf, because
 699                          * the UI spec says "The password will never
 700                          * be saved in the account": */
 701
 702                         /* We need to dup the string even knowing that
 703                            it's already a dup of the contents of an
 704                            entry, because it if it's wrong, then camel
 705                            will free it */
 706                         g_hash_table_insert (priv->password_hash, g_strdup (server_account_name), g_strdup(pwd));
 707                 } else {
 708                         g_hash_table_remove (priv->password_hash, server_account_name);
 709
 710                         g_free (pwd);
 711                         pwd = NULL;
 712                 }
 713
 714                 g_free (username);
 715                 username = NULL;
 716         } else
 717                 if (cancel)
 718                         *cancel = FALSE;
 719         return pwd;
 720 }
 721
 722 void
 723 modest_tny_account_store_forget_already_asked (ModestTnyAccountStore *self, TnyAccount *account)
 724 {
 725         g_return_if_fail (account);
 726
 727         ModestTnyAccountStorePrivate *priv;
 728         gchar *pwd = NULL;
 729         gpointer pwd_ptr = NULL;
 730         gboolean already_asked = FALSE;
 731
 732         const gchar *server_account_name = tny_account_get_id (account);
 733
 734         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 735
 736         /* This hash map stores passwords, including passwords that are not stored in gconf. */
 737         pwd_ptr = (gpointer)&pwd; /* pwd_ptr so the compiler does not complained about
 738                                    * type-punned ptrs...*/
 739         already_asked = priv->password_hash &&
 740                                 g_hash_table_lookup_extended (priv->password_hash,
 741                                                       server_account_name,
 742                                                       NULL,
 743                                                       (gpointer*)&pwd_ptr);
 744
 745         if (already_asked) {
 746                 g_hash_table_remove (priv->password_hash, server_account_name);
 747                 g_free (pwd);
 748                 pwd = NULL;
 749         }
 750
 751         return;
 752 }
 753
 754 /* tinymail calls this if the connection failed due to an incorrect password.
 755  * And it seems to call this for any general connection failure. */
 756 static void
 757 forget_password (TnyAccount *account)
 758 {
 759         ModestTnyAccountStore *self;
 760         ModestTnyAccountStorePrivate *priv;
 761         const TnyAccountStore *account_store;
 762         gchar *pwd;
 763         const gchar *key;
 764
 765         account_store = TNY_ACCOUNT_STORE(g_object_get_data (G_OBJECT(account),
 766                                                              "account_store"));
 767         self = MODEST_TNY_ACCOUNT_STORE (account_store);
 768         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 769         key  = tny_account_get_id (account);
 770
 771         /* Do not remove the key, this will allow us to detect that we
 772            have already asked for it at least once */
 773         pwd = g_hash_table_lookup (priv->password_hash, key);
 774         if (pwd) {
 775                 memset (pwd, 0, strlen (pwd));
 776                 g_hash_table_insert (priv->password_hash, g_strdup (key), NULL);
 777         }
 778
 779         /* Remove from configuration system */
 780         /*
 781         modest_account_mgr_unset (priv->account_mgr,
 782                                   key, MODEST_ACCOUNT_PASSWORD, TRUE);
 783         */
 784 }
 785
 786 static void
 787 modest_tny_account_store_finalize (GObject *obj)
 788 {
 789         ModestTnyAccountStore *self        = MODEST_TNY_ACCOUNT_STORE(obj);
 790         ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 791
 792         g_free (priv->cache_dir);
 793         priv->cache_dir = NULL;
 794
 795         if (priv->password_hash) {
 796                 g_hash_table_destroy (priv->password_hash);
 797                 priv->password_hash = NULL;
 798         }
 799
 800         if (priv->outbox_of_transport) {
 801                 g_hash_table_destroy (priv->outbox_of_transport);
 802                 priv->outbox_of_transport = NULL;
 803         }
 804
 805         modest_signal_mgr_disconnect_all_and_destroy (priv->sighandlers);
 806         priv->sighandlers = NULL;
 807
 808         if (priv->account_mgr) {
 809                 g_object_unref (G_OBJECT(priv->account_mgr));
 810                 priv->account_mgr = NULL;
 811         }
 812
 813         if (priv->device) {
 814                 g_object_unref (G_OBJECT(priv->device));
 815                 priv->device = NULL;
 816         }
 817
 818         /* Destroy all accounts. Disconnect all accounts before they are destroyed */
 819         if (priv->store_accounts) {
 820                 tny_list_foreach (priv->store_accounts, (GFunc)account_verify_last_ref, "store");
 821                 g_object_unref (priv->store_accounts);
 822                 priv->store_accounts = NULL;
 823         }
 824
 825         if (priv->transport_accounts) {
 826                 tny_list_foreach (priv->transport_accounts, (GFunc)account_verify_last_ref, "transport");
 827                 g_object_unref (priv->transport_accounts);
 828                 priv->transport_accounts = NULL;
 829         }
 830
 831         if (priv->store_accounts_outboxes) {
 832                 g_object_unref (priv->store_accounts_outboxes);
 833                 priv->store_accounts_outboxes = NULL;
 834         }
 835
 836         if (priv->session) {
 837                 camel_object_unref (CAMEL_OBJECT(priv->session));
 838                 priv->session = NULL;
 839         }
 840
 841         G_OBJECT_CLASS(parent_class)->finalize (obj);
 842 }
 843
 844 gboolean
 845 volume_path_is_mounted (const gchar* path)
 846 {
 847         g_return_val_if_fail (path, FALSE);
 848
 849         gboolean result = FALSE;
 850         gchar * path_as_uri = g_filename_to_uri (path, NULL, NULL);
 851         g_return_val_if_fail (path_as_uri, FALSE);
 852
 853         /* Get the monitor singleton: */
 854         GnomeVFSVolumeMonitor *monitor = gnome_vfs_get_volume_monitor();
 855
 856         /* This seems like a simpler way to do this, but it returns a
 857          * GnomeVFSVolume even if the drive is not mounted: */
 858         /*
 859         GnomeVFSVolume *volume = gnome_vfs_volume_monitor_get_volume_for_path (monitor,
 860                                  g_getenv (MODEST_MMC1_VOLUMEPATH_ENV));
 861         if (volume) {
 862                 gnome_vfs_volume_unref(volume);
 863         }
 864         */
 865
 866         /* Get the mounted volumes from the monitor: */
 867         GList *list = gnome_vfs_volume_monitor_get_mounted_volumes (monitor);
 868         GList *iter = list;
 869         for (iter = list; iter; iter = g_list_next (iter)) {
 870                 GnomeVFSVolume *volume = (GnomeVFSVolume*)iter->data;
 871                 if (volume) {
 872                         /*
 873                         char *display_name =
 874                                 gnome_vfs_volume_get_display_name (volume);
 875                         printf ("volume display name=%s\n", display_name);
 876                         g_free (display_name);
 877                         */
 878
 879                         char *uri =
 880                                 gnome_vfs_volume_get_activation_uri (volume);
 881                         /* printf ("  uri=%s\n", uri); */
 882                         if (uri && (strcmp (uri, path_as_uri) == 0))
 883                                 result = TRUE;
 884
 885                         g_free (uri);
 886
 887                         gnome_vfs_volume_unref (volume);
 888                 }
 889         }
 890
 891         g_list_free (list);
 892
 893         g_free (path_as_uri);
 894
 895         return result;
 896 }
 897
 898 ModestTnyAccountStore*
 899 modest_tny_account_store_new (ModestAccountMgr *account_mgr,
 900                               TnyDevice *device)
 901 {
 902         GObject *obj;
 903         ModestTnyAccountStorePrivate *priv;
 904         TnyAccount *local_account = NULL;
 905         TnyLockable *lockable;
 906
 907         g_return_val_if_fail (account_mgr, NULL);
 908         g_return_val_if_fail (device, NULL);
 909
 910         obj  = G_OBJECT(g_object_new(MODEST_TYPE_TNY_ACCOUNT_STORE, NULL));
 911         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(obj);
 912
 913         priv->account_mgr = g_object_ref (G_OBJECT(account_mgr));
 914         priv->device = g_object_ref (device);
 915
 916         priv->session = tny_session_camel_new (TNY_ACCOUNT_STORE(obj));
 917         if (!priv->session) {
 918                 g_warning ("failed to get TnySessionCamel");
 919                 return NULL;
 920         }
 921
 922         /* Set the ui locker */
 923         lockable = tny_gtk_lockable_new ();
 924         tny_session_camel_set_ui_locker (priv->session, lockable);
 925         g_object_unref (lockable);
 926
 927         /* Connect signals */
 928         priv->sighandlers  =  modest_signal_mgr_connect (priv->sighandlers,
 929                                                          G_OBJECT(account_mgr), "account_inserted",
 930                                                          G_CALLBACK (on_account_inserted), obj);
 931         priv->sighandlers  =  modest_signal_mgr_connect (priv->sighandlers,
 932                                                          G_OBJECT(account_mgr), "account_changed",
 933                                                          G_CALLBACK (on_account_changed), obj);
 934         priv->sighandlers  =  modest_signal_mgr_connect (priv->sighandlers,
 935                                                          G_OBJECT(account_mgr), "account_removed",
 936                                                          G_CALLBACK (on_account_removed), obj);
 937
 938         /* Create the lists of accounts */
 939         priv->store_accounts = tny_simple_list_new ();
 940         priv->transport_accounts = tny_simple_list_new ();
 941         priv->store_accounts_outboxes = tny_simple_list_new ();
 942
 943         /* Create the local folders account */
 944         local_account =
 945                 modest_tny_account_new_for_local_folders (priv->account_mgr, priv->session, NULL);
 946         tny_list_append (priv->store_accounts, G_OBJECT(local_account));
 947         g_object_unref (local_account);
 948
 949         /* Add the other remote accounts. Do this after adding the
 950            local account, because we need to add our outboxes to the
 951            global OUTBOX hosted in the local account */
 952         add_existing_accounts (MODEST_TNY_ACCOUNT_STORE (obj));
 953
 954         /* Add connection-specific transport accounts if there are any
 955            accounts available */
 956         if (!only_local_accounts (MODEST_TNY_ACCOUNT_STORE(obj)))
 957                 add_connection_specific_transport_accounts (MODEST_TNY_ACCOUNT_STORE(obj));
 958
 959         /* This is a singleton, so it does not need to be unrefed. */
 960         if (volume_path_is_mounted (g_getenv (MODEST_MMC1_VOLUMEPATH_ENV))) {
 961                 /* It is mounted: */
 962                 add_mmc_account (MODEST_TNY_ACCOUNT_STORE (obj), FALSE /* don't emit the insert signal. */);
 963         }
 964
 965         return MODEST_TNY_ACCOUNT_STORE(obj);
 966 }
 967
 968 static void
 969 modest_tny_account_store_get_accounts  (TnyAccountStore *self,
 970                                         TnyList *list,
 971                                         TnyGetAccountsRequestType request_type)
 972 {
 973         ModestTnyAccountStorePrivate *priv;
 974
 975         g_return_if_fail (self);
 976         g_return_if_fail (TNY_IS_LIST(list));
 977
 978         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 979
 980         switch (request_type) {
 981         case TNY_ACCOUNT_STORE_BOTH:
 982                 tny_list_foreach (priv->store_accounts, foreach_account_append_to_list, list);
 983                 tny_list_foreach (priv->transport_accounts, foreach_account_append_to_list, list);
 984                 break;
 985         case TNY_ACCOUNT_STORE_STORE_ACCOUNTS:
 986                 tny_list_foreach (priv->store_accounts, foreach_account_append_to_list, list);
 987                 break;
 988         case TNY_ACCOUNT_STORE_TRANSPORT_ACCOUNTS:
 989                 tny_list_foreach (priv->transport_accounts, foreach_account_append_to_list, list);
 990                 break;
 991         default:
 992                 g_return_if_reached ();
 993         }
 994
 995         /* Initialize session. Why do we need this ??? */
 996         tny_session_camel_set_initialized (priv->session);
 997 }
 998
 999
1000 static const gchar*
1001 modest_tny_account_store_get_cache_dir (TnyAccountStore *self)
1002 {
1003         ModestTnyAccountStorePrivate *priv;
1004         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1005
1006         if (!priv->cache_dir)
1007                 priv->cache_dir = g_build_filename (g_get_home_dir(),
1008                                                     MODEST_DIR, MODEST_CACHE_DIR, NULL);
1009         return priv->cache_dir;
1010 }
1011
1012
1013 /*
1014  * callers need to unref
1015  */
1016 static TnyDevice*
1017 modest_tny_account_store_get_device (TnyAccountStore *self)
1018 {
1019         ModestTnyAccountStorePrivate *priv;
1020
1021         g_return_val_if_fail (self, NULL);
1022
1023         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1024
1025         if (priv->device)
1026                 return g_object_ref (G_OBJECT(priv->device));
1027         else
1028                 return NULL;
1029 }
1030
1031
1032 static TnyAccount*
1033 modest_tny_account_store_find_account_by_url (TnyAccountStore *self, const gchar* url_string)
1034 {
1035         return modest_tny_account_store_get_tny_account_by (MODEST_TNY_ACCOUNT_STORE (self),
1036                                                             MODEST_TNY_ACCOUNT_STORE_QUERY_URL,
1037                                                             url_string);
1038 }
1039
1040
1041
1042 static gboolean
1043 modest_tny_account_store_alert (TnyAccountStore *self,
1044                                 TnyAccount *account,
1045                                 TnyAlertType type,
1046                                 gboolean question,
1047                                 GError *error)
1048 {
1049         ModestProtocolType protocol_type = MODEST_PROTOCOL_REGISTRY_TYPE_INVALID;
1050         ModestProtocol *protocol = NULL;
1051         const gchar* server_name = "";
1052         gchar *prompt = NULL;
1053         gboolean retval = TRUE;
1054
1055         /* NOTE: account may be NULL in some cases */
1056         g_return_val_if_fail (error, FALSE);
1057
1058         /* Get the server name: */
1059         if (account) {
1060                 server_name = tny_account_get_hostname (account);
1061                 protocol_type = modest_tny_account_get_protocol_type (account);
1062                 if (protocol_type == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID){
1063                         g_warning("modest: %s: account with id=%s has no proto.\n", __FUNCTION__,
1064                                   tny_account_get_id (account));
1065                         return FALSE;
1066                 }
1067                 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
1068                                                                           protocol_type);
1069         }
1070
1071         switch (error->code) {
1072         case TNY_SYSTEM_ERROR_CANCEL:
1073                 /* Don't show waste the user's time by showing him a dialog telling
1074                  * him that he has just cancelled something: */
1075                 return TRUE;
1076
1077         case TNY_SERVICE_ERROR_PROTOCOL:
1078                 /* Like a BAD from IMAP (protocol error) */
1079         case TNY_SERVICE_ERROR_LOST_CONNECTION:
1080                 /* Lost the connection with the service */
1081         case TNY_SERVICE_ERROR_UNAVAILABLE:
1082                 /* You must be working online for this operation */
1083         case TNY_SERVICE_ERROR_CONNECT:
1084                 if (protocol) {
1085                         prompt = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_CONNECT_ERROR, server_name);
1086                 }
1087                 if (!prompt) {
1088                         g_return_val_if_reached (FALSE);
1089                 }
1090                 break;
1091
1092         case TNY_SERVICE_ERROR_AUTHENTICATE:
1093                 /* It seems that there's no better error to show with
1094                  * POP and IMAP because TNY_SERVICE_ERROR_AUTHENTICATE
1095                  * may appear if there's a timeout during auth */
1096                 if (protocol) {
1097                         prompt = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_AUTH_ERROR, server_name);
1098                 }
1099                 if (!prompt) {
1100                         g_return_val_if_reached (FALSE);
1101                 }
1102                 break;
1103
1104         case TNY_SERVICE_ERROR_CERTIFICATE:
1105                 /* We'll show the proper dialog later */
1106                 break;
1107
1108         case TNY_SYSTEM_ERROR_MEMORY:
1109                 /* Can't allocate memory for this operation */
1110
1111         case TNY_SERVICE_ERROR_UNKNOWN:
1112                 return FALSE;
1113         default:
1114                 g_debug ("Unexpected error %d", error->code);
1115                 g_return_val_if_reached (FALSE);
1116         }
1117
1118
1119         if (error->code == TNY_SERVICE_ERROR_CERTIFICATE)
1120                 retval = modest_platform_run_certificate_confirmation_dialog (server_name,
1121                                                                               error->message);
1122         else if (error->code == TNY_SERVICE_ERROR_AUTHENTICATE ||
1123                  error->code == TNY_SERVICE_ERROR_CONNECT) {
1124
1125                 modest_platform_run_information_dialog (NULL, prompt, TRUE);
1126
1127                 /* Show the account dialog if it was wrong */
1128                 if (error->code == TNY_SERVICE_ERROR_AUTHENTICATE)
1129                         show_wrong_password_dialog (account);
1130
1131                 retval = TRUE;
1132         }
1133
1134         g_debug ("%s: error code %d (%s", __FUNCTION__, error->code, error->message);
1135
1136         if (prompt)
1137                 g_free (prompt);
1138
1139         return retval;
1140 }
1141
1142
1143 static void
1144 modest_tny_account_store_init (gpointer g, gpointer iface_data)
1145 {
1146         TnyAccountStoreIface *klass;
1147
1148         g_return_if_fail (g);
1149
1150         klass = (TnyAccountStoreIface *)g;
1151
1152         klass->get_accounts =
1153                 modest_tny_account_store_get_accounts;
1154         klass->get_cache_dir =
1155                 modest_tny_account_store_get_cache_dir;
1156         klass->get_device =
1157                 modest_tny_account_store_get_device;
1158         klass->alert =
1159                 modest_tny_account_store_alert;
1160         klass->find_account =
1161                 modest_tny_account_store_find_account_by_url;
1162 }
1163
1164 void
1165 modest_tny_account_store_set_get_pass_func (ModestTnyAccountStore *self,
1166                                             ModestTnyGetPassFunc func)
1167 {
1168         /* not implemented, we use signals */
1169         g_printerr ("modest: set_get_pass_func not implemented\n");
1170 }
1171
1172 TnySessionCamel*
1173 modest_tny_account_store_get_session  (TnyAccountStore *self)
1174 {
1175         g_return_val_if_fail (self, NULL);
1176         return MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self)->session;
1177 }
1178
1179 static TnyAccount*
1180 get_tny_account_by (TnyList *accounts,
1181                     ModestTnyAccountStoreQueryType type,
1182                     const gchar *str)
1183 {
1184         TnyIterator *iter = NULL;
1185         gboolean found = FALSE;
1186         TnyAccount *retval = NULL;
1187
1188         g_return_val_if_fail (TNY_IS_LIST(accounts), NULL);
1189
1190         if (tny_list_get_length(accounts) == 0) {
1191                 g_warning ("%s: account list is empty", __FUNCTION__);
1192                 return NULL;
1193         }
1194
1195         iter = tny_list_create_iterator (accounts);
1196         while (!tny_iterator_is_done (iter) && !found) {
1197                 TnyAccount *tmp_account = NULL;
1198                 const gchar *val = NULL;
1199
1200                 tmp_account = TNY_ACCOUNT (tny_iterator_get_current (iter));
1201                 if (!TNY_IS_ACCOUNT(tmp_account)) {
1202                         g_warning ("%s: not a valid account", __FUNCTION__);
1203                         tmp_account = NULL;
1204                         break;
1205                 }
1206
1207                 switch (type) {
1208                 case MODEST_TNY_ACCOUNT_STORE_QUERY_ID:
1209                         val = tny_account_get_id (tmp_account);
1210                         break;
1211                 case MODEST_TNY_ACCOUNT_STORE_QUERY_URL:
1212                         val = tny_account_get_url_string (tmp_account);
1213                         break;
1214                 }
1215
1216                 if (type == MODEST_TNY_ACCOUNT_STORE_QUERY_URL &&
1217                     tny_account_matches_url_string (tmp_account, str)) {
1218                         retval = g_object_ref (tmp_account);
1219                         found = TRUE;
1220                 } else {
1221                         if (val && str && strcmp (val, str) == 0) {
1222                                 retval = g_object_ref (tmp_account);
1223                                 found = TRUE;
1224                         }
1225                 }
1226                 g_object_unref (tmp_account);
1227                 tny_iterator_next (iter);
1228         }
1229         g_object_unref (iter);
1230
1231         return retval;
1232 }
1233
1234 TnyAccount*
1235 modest_tny_account_store_get_tny_account_by (ModestTnyAccountStore *self,
1236                                              ModestTnyAccountStoreQueryType type,
1237                                              const gchar *str)
1238 {
1239         TnyAccount *account = NULL;
1240         ModestTnyAccountStorePrivate *priv;
1241
1242         g_return_val_if_fail (self, NULL);
1243         g_return_val_if_fail (str, NULL);
1244
1245         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1246
1247         /* Search in store accounts */
1248         account = get_tny_account_by (priv->store_accounts, type, str);
1249
1250         /* If we already found something, no need to search the transport accounts */
1251         if (!account) {
1252                 account = get_tny_account_by (priv->transport_accounts, type, str);
1253
1254                 /* If we already found something, no need to search the
1255                    per-account outbox accounts */
1256                 if (!account)
1257                         account = get_tny_account_by (priv->store_accounts_outboxes, type, str);
1258         }
1259
1260         /* Warn if nothing was found. This is generally unusual. */
1261         if (!account) {
1262                 g_warning("%s: Failed to find account with %s=%s\n",
1263                           __FUNCTION__,
1264                           (type == MODEST_TNY_ACCOUNT_STORE_QUERY_ID) ? "ID" : "URL",
1265                           str);
1266         }
1267
1268         /* Returns a new reference to the account if found */
1269         return account;
1270 }
1271
1272
1273 TnyAccount*
1274 modest_tny_account_store_get_server_account (ModestTnyAccountStore *self,
1275                                              const gchar *account_name,
1276                                              TnyAccountType type)
1277 {
1278         ModestTnyAccountStorePrivate *priv = NULL;
1279         TnyAccount *retval = NULL;
1280         TnyList *account_list = NULL;
1281         TnyIterator *iter = NULL;
1282         gboolean found;
1283
1284         g_return_val_if_fail (self, NULL);
1285         g_return_val_if_fail (account_name, NULL);
1286         g_return_val_if_fail (type == TNY_ACCOUNT_TYPE_STORE ||
1287                               type == TNY_ACCOUNT_TYPE_TRANSPORT,
1288                               NULL);
1289
1290         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1291
1292         account_list = (type == TNY_ACCOUNT_TYPE_STORE) ?
1293                 priv->store_accounts :
1294                 priv->transport_accounts;
1295
1296         if (!account_list) {
1297                 g_printerr ("%s: No server accounts of type %s\n", __FUNCTION__,
1298                         (type == TNY_ACCOUNT_TYPE_STORE) ? "store" : "transport");
1299                 return NULL;
1300         }
1301
1302         /* Look for the server account */
1303         found = FALSE;
1304         iter = tny_list_create_iterator (account_list);
1305         while (!tny_iterator_is_done (iter) && !found) {
1306                 const gchar *modest_acc_name;
1307                 TnyAccount *tmp_account;
1308
1309                 tmp_account = TNY_ACCOUNT (tny_iterator_get_current (iter));
1310                 modest_acc_name =
1311                         modest_tny_account_get_parent_modest_account_name_for_server_account (tmp_account);
1312
1313                 if (account_name && modest_acc_name && !strcmp (account_name, modest_acc_name)) {
1314                         found = TRUE;
1315                         retval = g_object_ref (tmp_account);
1316                 }
1317                 /* Free and continue */
1318                 g_object_unref (tmp_account);
1319                 tny_iterator_next (iter);
1320         }
1321         g_object_unref (iter);
1322
1323         if (!found) {
1324                 g_printerr ("modest: %s: could not get tny %s account for %s\n." \
1325                             "Number of server accounts of this type=%d\n", __FUNCTION__,
1326                             (type == TNY_ACCOUNT_TYPE_STORE) ? "store" : "transport",
1327                             account_name, tny_list_get_length (account_list));
1328         }
1329
1330         /* Returns a new reference */
1331         return retval;
1332 }
1333
1334 TnyAccount*
1335 modest_tny_account_store_get_smtp_specific_transport_account_for_open_connection (
1336         ModestTnyAccountStore *self, const gchar *account_name)
1337 {
1338         TnyDevice *device;
1339
1340         g_return_val_if_fail (self && MODEST_IS_TNY_ACCOUNT_STORE(self), NULL);
1341         g_return_val_if_fail (account_name, NULL);
1342
1343         /* Get the current connection: */
1344         device = modest_runtime_get_device ();
1345
1346         if (!device) {
1347                 g_warning ("%s: could not get device", __FUNCTION__);
1348                 return NULL;
1349         }
1350
1351         if (!tny_device_is_online (device))
1352                 return NULL;
1353
1354 #ifdef MODEST_HAVE_CONIC
1355         g_return_val_if_fail (TNY_IS_MAEMO_CONIC_DEVICE (device), NULL);
1356
1357         TnyMaemoConicDevice *maemo_device = TNY_MAEMO_CONIC_DEVICE (device);
1358         const gchar* iap_id = tny_maemo_conic_device_get_current_iap_id (maemo_device);
1359         /* printf ("DEBUG: %s: iap_id=%s\n", __FUNCTION__, iap_id); */
1360         if (!iap_id)
1361                 return NULL;
1362
1363         ConIcIap* connection = tny_maemo_conic_device_get_iap (maemo_device, iap_id);
1364         if (!connection)
1365                 return NULL;
1366
1367         const gchar *connection_id = con_ic_iap_get_id (connection);
1368         /* printf ("DEBUG: %s: connection_id=%s\n", __FUNCTION__, connection_id); */
1369         if (!connection_id)
1370                 return NULL;
1371
1372         /*  Get the connection-specific transport acccount, if any: */
1373         ModestAccountMgr *account_manager = modest_runtime_get_account_mgr ();
1374
1375         /* Check if this account has connection-specific SMTP enabled */
1376         if (!modest_account_mgr_get_use_connection_specific_smtp (account_manager, account_name)) {
1377                 return NULL;
1378         }
1379
1380         gchar* server_account_name = modest_account_mgr_get_connection_specific_smtp (account_manager,
1381                 connection_id);
1382
1383         /* printf ("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
1384         if (!server_account_name) {
1385                 return NULL; /* No connection-specific SMTP server was specified for this connection. */
1386         }
1387
1388         TnyAccount* account = modest_tny_account_store_get_tny_account_by (self,
1389                                                                            MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
1390                                                                            server_account_name);
1391
1392         /* printf ("DEBUG: %s: account=%p\n", __FUNCTION__, account); */
1393         g_free (server_account_name);
1394
1395         /* Unref the get()ed object, as required by the tny_maemo_conic_device_get_iap() documentation. */
1396         g_object_unref (connection);
1397
1398         return account;
1399 #else
1400         return NULL; /* TODO: Implement this for GNOME, instead of just Maemo? */
1401 #endif /* MODEST_HAVE_CONIC */
1402 }
1403
1404
1405 TnyAccount*
1406 modest_tny_account_store_get_transport_account_for_open_connection (ModestTnyAccountStore *self,
1407                                                                     const gchar *account_name)
1408 {
1409         g_return_val_if_fail (self, NULL);
1410         g_return_val_if_fail (account_name, NULL);
1411
1412         if (!account_name || !self)
1413                 return NULL;
1414
1415         /*  Get the connection-specific transport acccount, if any: */
1416         /* Note: This gives us a reference: */
1417         TnyAccount *account =
1418                 modest_tny_account_store_get_smtp_specific_transport_account_for_open_connection (self, account_name);
1419
1420         /* If there is no connection-specific transport account (the common case),
1421          * just get the regular transport account: */
1422         if (!account) {
1423                 /* The special local folders don't have transport accounts. */
1424                 if (strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID) == 0)
1425                         account = NULL;
1426                 else {
1427                         /* Note: This gives us a reference: */
1428                         account = modest_tny_account_store_get_server_account (self, account_name,
1429                                                      TNY_ACCOUNT_TYPE_TRANSPORT);
1430                 }
1431         }
1432
1433         /* returns a reference. */
1434         return account;
1435 }
1436
1437 TnyAccount*
1438 modest_tny_account_store_get_local_folders_account (ModestTnyAccountStore *self)
1439 {
1440         TnyAccount *account = NULL;
1441         ModestTnyAccountStorePrivate *priv;
1442         TnyIterator *iter;
1443         gboolean found;
1444
1445         g_return_val_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (self), NULL);
1446
1447         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1448
1449         found = FALSE;
1450         iter = tny_list_create_iterator (priv->store_accounts);
1451         while (!tny_iterator_is_done (iter) && !found) {
1452                 TnyAccount *tmp_account;
1453
1454                 tmp_account = TNY_ACCOUNT (tny_iterator_get_current (iter));
1455                 if (modest_tny_account_is_virtual_local_folders (tmp_account)) {
1456                         account = g_object_ref (tmp_account);
1457                         found = TRUE;
1458                 }
1459                 g_object_unref (tmp_account);
1460                 tny_iterator_next (iter);
1461         }
1462         g_object_unref (iter);
1463
1464         /* Returns a new reference to the account */
1465         return account;
1466 }
1467
1468 TnyAccount*
1469 modest_tny_account_store_get_mmc_folders_account (ModestTnyAccountStore *self)
1470 {
1471         g_return_val_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (self), NULL);
1472
1473         /* New reference */
1474         return modest_tny_account_store_get_tny_account_by (self, MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
1475                                                             MODEST_MMC_ACCOUNT_ID);
1476
1477 }
1478
1479 /*********************************************************************************/
1480 static void
1481 add_existing_accounts (ModestTnyAccountStore *self)
1482 {
1483         GSList *account_names = NULL, *iter = NULL;
1484         ModestTnyAccountStorePrivate *priv = NULL;
1485
1486         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1487
1488         /* These are account names, not server_account names */
1489         account_names = modest_account_mgr_account_names (priv->account_mgr, FALSE);
1490
1491         for (iter = account_names; iter != NULL; iter = g_slist_next (iter)) {
1492                 const gchar *account_name = (const gchar*) iter->data;
1493
1494                 /* Insert all enabled accounts without notifying */
1495                 if (modest_account_mgr_get_enabled (priv->account_mgr, account_name))
1496                         insert_account (self, account_name, FALSE);
1497         }
1498         modest_account_mgr_free_account_names (account_names);
1499 }
1500
1501 static TnyAccount*
1502 create_tny_account (ModestTnyAccountStore *self,
1503                     const gchar *name,
1504                     TnyAccountType type,
1505                     gboolean notify)
1506 {
1507         TnyAccount *account = NULL;
1508         ModestTnyAccountStorePrivate *priv = NULL;
1509
1510         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1511
1512         account = modest_tny_account_new_from_account (priv->account_mgr,
1513                                                        name, type,
1514                                                        priv->session,
1515                                                        get_password,
1516                                                        forget_password);
1517
1518         if (account) {
1519                 /* Forget any cached password for the account, so that
1520                    we use a new account if any */
1521                 forget_password_in_memory (self, tny_account_get_id (account));
1522
1523                 /* Set the account store */
1524                 g_object_set_data (G_OBJECT(account), "account_store", self);
1525         } else {
1526                 g_printerr ("modest: failed to create account for %s\n", name);
1527         }
1528
1529         return account;
1530 }
1531
1532 typedef struct _AddOutboxInfo {
1533         ModestTnyAccountStore *account_store;
1534         TnyAccount *transport_account;
1535 } AddOutboxInfo;
1536
1537 static void
1538 add_outbox_from_transport_account_to_global_outbox_get_folders_cb (TnyFolderStore *folder_store,
1539                                                                    gboolean cancelled,
1540                                                                    TnyList *list,
1541                                                                    GError *err,
1542                                                                    gpointer userdata)
1543 {
1544         TnyIterator *iter_folders;
1545         TnyFolder *per_account_outbox;
1546         TnyAccount *local_account = NULL;
1547         AddOutboxInfo *info = (AddOutboxInfo *) userdata;
1548         ModestTnyAccountStorePrivate *priv = NULL;
1549         ModestTnyAccountStore *self;
1550
1551         self = MODEST_TNY_ACCOUNT_STORE (info->account_store);
1552         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1553
1554         /* Note that this could happen if there is not enough space
1555            available on disk, then the outbox folder could not be
1556            created */
1557         if (tny_list_get_length (list) != 1) {
1558                 g_warning ("%s: could not create outbox folder (%d folders found)", __FUNCTION__,
1559                            tny_list_get_length (list));
1560                 goto frees;
1561         }
1562
1563         iter_folders = tny_list_create_iterator (list);
1564         per_account_outbox = TNY_FOLDER (tny_iterator_get_current (iter_folders));
1565         g_object_unref (iter_folders);
1566         g_object_unref (list);
1567
1568         /* Add the outbox of the new per-account-local-outbox account
1569            to the global local merged OUTBOX of the local folders
1570            account */
1571         local_account = modest_tny_account_store_get_local_folders_account (info->account_store);
1572         modest_tny_local_folders_account_add_folder_to_outbox (MODEST_TNY_LOCAL_FOLDERS_ACCOUNT (local_account),
1573                                                                per_account_outbox);
1574         /* Add the pair to the hash table */
1575         g_hash_table_insert (priv->outbox_of_transport,
1576                              info->transport_account,
1577                              per_account_outbox);
1578
1579         /* Notify that the local account changed */
1580         g_signal_emit (G_OBJECT (self), signals [ACCOUNT_CHANGED_SIGNAL], 0, local_account);
1581         g_object_unref (local_account);
1582         g_object_unref (per_account_outbox);
1583
1584  frees:
1585         g_object_unref (info->transport_account);
1586         g_slice_free (AddOutboxInfo, info);
1587 }
1588
1589
1590 static void
1591 add_outbox_from_transport_account_to_global_outbox (ModestTnyAccountStore *self,
1592                                                     const gchar *account_name,
1593                                                     TnyAccount *transport_account)
1594 {
1595         TnyList *folders = NULL;
1596         TnyAccount *account_outbox = NULL;
1597         ModestTnyAccountStorePrivate *priv = NULL;
1598         AddOutboxInfo *info;
1599
1600         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1601
1602         /* Create per account local outbox */
1603         account_outbox =
1604                 modest_tny_account_new_for_per_account_local_outbox_folder (priv->account_mgr,
1605                                                                             account_name,
1606                                                                             priv->session);
1607
1608         if (!G_IS_OBJECT (account_outbox)) {
1609                 g_warning ("%s: could not create per account local outbox folder", __FUNCTION__);
1610                 return;
1611         }
1612
1613         tny_list_append (priv->store_accounts_outboxes, G_OBJECT (account_outbox));
1614
1615         /* Get the outbox folder */
1616         folders = tny_simple_list_new ();
1617         info = g_slice_new0 (AddOutboxInfo);
1618         info->account_store = self;
1619         info->transport_account = g_object_ref (transport_account);
1620         tny_folder_store_get_folders_async (TNY_FOLDER_STORE (account_outbox), folders, NULL, FALSE,
1621                                             add_outbox_from_transport_account_to_global_outbox_get_folders_cb, NULL, (gpointer) info);
1622         g_object_unref (account_outbox);
1623 }
1624
1625 /*
1626  * This function will be used for both adding new accounts and for the
1627  * initialization. In the initialization we do not want to emit
1628  * signals so notify will be FALSE, in the case of account additions
1629  * we do want to notify the observers
1630  */
1631 static void
1632 insert_account (ModestTnyAccountStore *self,
1633                 const gchar *account,
1634                 gboolean notify)
1635 {
1636         ModestTnyAccountStorePrivate *priv = NULL;
1637         TnyAccount *store_account = NULL, *transport_account = NULL;
1638
1639         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1640
1641         /* Get the server and the transport account */
1642         store_account = create_tny_account (self, account, TNY_ACCOUNT_TYPE_STORE, notify);
1643         if (!store_account || !TNY_IS_ACCOUNT(store_account)) {
1644                 g_warning ("%s: failed to create store account", __FUNCTION__);
1645                 return;
1646         }
1647
1648         transport_account = create_tny_account (self, account, TNY_ACCOUNT_TYPE_TRANSPORT, notify);
1649         if (!transport_account || !TNY_IS_ACCOUNT(transport_account)) {
1650                 g_warning ("%s: failed to create transport account", __FUNCTION__);
1651                 g_object_unref (store_account);
1652                 return;
1653         }
1654
1655         /* Add accounts to the lists */
1656         tny_list_append (priv->store_accounts, G_OBJECT (store_account));
1657         tny_list_append (priv->transport_accounts, G_OBJECT (transport_account));
1658
1659         /* Create a new pseudo-account with an outbox for this
1660            transport account and add it to the global outbox
1661            in the local account */
1662         add_outbox_from_transport_account_to_global_outbox (self, account, transport_account);
1663
1664         /* Notify the observers. We do it after everything is
1665            created */
1666         if (notify) {
1667                 g_signal_emit (G_OBJECT (self), signals [ACCOUNT_INSERTED_SIGNAL], 0, store_account);
1668                 g_signal_emit (G_OBJECT (self), signals [ACCOUNT_INSERTED_SIGNAL], 0, transport_account);
1669         }
1670
1671         /* Frees */
1672         g_object_unref (store_account);
1673         g_object_unref (transport_account);
1674 }
1675
1676 static inline gboolean
1677 only_local_accounts (ModestTnyAccountStore *self)
1678 {
1679         return (modest_tny_account_store_get_num_remote_accounts (self) > 0) ? FALSE : TRUE;
1680 }
1681
1682 static void
1683 on_account_inserted (ModestAccountMgr *acc_mgr,
1684                      const gchar *account,
1685                      gpointer user_data)
1686 {
1687         gboolean add_specific;
1688
1689         add_specific = only_local_accounts (MODEST_TNY_ACCOUNT_STORE (user_data));
1690
1691         /* Insert the account and notify the observers */
1692         insert_account (MODEST_TNY_ACCOUNT_STORE (user_data), account, TRUE);
1693
1694         /* If it's the first remote account then add the connection
1695            specific SMTP servers as well */
1696         if (add_specific)
1697                 add_connection_specific_transport_accounts (MODEST_TNY_ACCOUNT_STORE (user_data));
1698
1699 }
1700
1701 /* This is the callback of the tny_camel_account_set_online called in
1702    on_account_removed to disconnect the account */
1703 static void
1704 on_account_disconnect_when_removing (TnyCamelAccount *account,
1705                                      gboolean canceled,
1706                                      GError *err,
1707                                      gpointer user_data)
1708 {
1709         ModestTnyAccountStore *self;
1710         ModestTnyAccountStorePrivate *priv;
1711
1712         self = MODEST_TNY_ACCOUNT_STORE (user_data);
1713         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
1714
1715         /* Cancel all pending operations */
1716         tny_account_cancel (TNY_ACCOUNT (account));
1717
1718         /* Unref the extra reference added by get_server_account */
1719         g_object_unref (account);
1720
1721         /* Clear the cache if it's an store account */
1722         if (TNY_IS_STORE_ACCOUNT (account)) {
1723                 tny_store_account_delete_cache (TNY_STORE_ACCOUNT (account));
1724         } else if (TNY_IS_TRANSPORT_ACCOUNT (account)) {
1725                 ModestTnySendQueue* send_queue;
1726                 send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT (account), FALSE);
1727                 if (TNY_IS_SEND_QUEUE (send_queue)) {
1728                         if (modest_tny_send_queue_sending_in_progress (send_queue))
1729                                 tny_send_queue_cancel (TNY_SEND_QUEUE (send_queue),
1730                                                        TNY_SEND_QUEUE_CANCEL_ACTION_REMOVE,
1731                                                        NULL);
1732                         modest_runtime_remove_send_queue (TNY_TRANSPORT_ACCOUNT (account));
1733                 }
1734         }
1735 }
1736
1737 /*
1738  * We use this one for both removing "normal" and "connection
1739  * specific" transport accounts
1740  */
1741 static void
1742 remove_transport_account (ModestTnyAccountStore *self,
1743                           TnyTransportAccount *transport_account)
1744 {
1745         ModestTnyAccountStorePrivate *priv;
1746         TnyFolder *outbox = NULL;
1747
1748         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
1749
1750         /* Remove it from the list of accounts and notify the
1751            observers. Do not need to wait for account
1752            disconnection */
1753         g_signal_emit (G_OBJECT (self), signals [ACCOUNT_REMOVED_SIGNAL], 0, transport_account);
1754         tny_list_remove (priv->transport_accounts, (GObject *) transport_account);
1755
1756         /* Remove the OUTBOX of the account from the global outbox */
1757         outbox = g_hash_table_lookup (priv->outbox_of_transport, transport_account);
1758
1759         if (TNY_IS_FOLDER (outbox)) {
1760                 TnyAccount *local_account = NULL;
1761                 TnyAccount *outbox_account = tny_folder_get_account (outbox);
1762
1763                 if (outbox_account) {
1764                         tny_list_remove (priv->store_accounts_outboxes, G_OBJECT (outbox_account));
1765                         /* Remove existing emails to send */
1766                         tny_store_account_delete_cache (TNY_STORE_ACCOUNT (outbox_account));
1767                         g_object_unref (outbox_account);
1768                 }
1769
1770                 local_account = modest_tny_account_store_get_local_folders_account (self);
1771                 modest_tny_local_folders_account_remove_folder_from_outbox (MODEST_TNY_LOCAL_FOLDERS_ACCOUNT (local_account),
1772                                                                             outbox);
1773
1774                 g_hash_table_remove (priv->outbox_of_transport, transport_account);
1775
1776                 /* Notify the change in the local account */
1777                 g_signal_emit (G_OBJECT (self), signals [ACCOUNT_CHANGED_SIGNAL], 0, local_account);
1778                 g_object_unref (local_account);
1779         } else {
1780                 g_warning ("Removing a transport account that has no outbox");
1781         }
1782
1783         /* Cancel all pending operations */
1784         tny_account_cancel (TNY_ACCOUNT (transport_account));
1785
1786         /* Disconnect and notify the observers. The callback will free the reference */
1787         tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (transport_account), FALSE,
1788                                       on_account_disconnect_when_removing, self);
1789 }
1790
1791 static gboolean
1792 images_cache_remove_filter (TnyStreamCache *self, const gchar *id, const gchar *account_name)
1793 {
1794         gchar *account_name_with_separator;
1795         gboolean result;
1796         if (account_name == NULL || account_name[0] == '\0')
1797                 return FALSE;
1798
1799         if (id == NULL || id[0] == '\0')
1800                 return FALSE;
1801
1802         account_name_with_separator = g_strconcat (account_name, "__", NULL);
1803
1804         result = (g_str_has_prefix (id, account_name));
1805         g_free (account_name_with_separator);
1806
1807         return result;
1808 }
1809
1810 static void
1811 on_account_removed (ModestAccountMgr *acc_mgr,
1812                     const gchar *account,
1813                     gpointer user_data)
1814 {
1815         TnyAccount *store_account = NULL, *transport_account = NULL;
1816         ModestTnyAccountStore *self;
1817         ModestTnyAccountStorePrivate *priv;
1818         TnyStreamCache *stream_cache;
1819
1820         self = MODEST_TNY_ACCOUNT_STORE (user_data);
1821         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
1822
1823         /* Get the server and the transport account */
1824         store_account =
1825                 modest_tny_account_store_get_server_account (self, account,
1826                                                              TNY_ACCOUNT_TYPE_STORE);
1827         transport_account =
1828                 modest_tny_account_store_get_server_account (self, account,
1829                                                              TNY_ACCOUNT_TYPE_TRANSPORT);
1830
1831         /* If there was any problem creating the account, for example,
1832            with the configuration system this could not exist */
1833         if (TNY_IS_STORE_ACCOUNT(store_account)) {
1834                 /* Forget any cached password for the account */
1835                 forget_password_in_memory (self, tny_account_get_id (store_account));
1836
1837                 /* Remove it from the list of accounts and notify the
1838                    observers. Do not need to wait for account
1839                    disconnection */
1840                 tny_list_remove (priv->store_accounts, (GObject *) store_account);
1841                 g_signal_emit (G_OBJECT (self), signals [ACCOUNT_REMOVED_SIGNAL], 0, store_account);
1842
1843                 /* Cancel all pending operations */
1844                 tny_account_cancel (TNY_ACCOUNT (store_account));
1845
1846                 /* Disconnect before deleting the cache, because the
1847                    disconnection will rewrite the cache to the
1848                    disk */
1849                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (store_account), FALSE,
1850                                               on_account_disconnect_when_removing, self);
1851         } else {
1852                 g_warning ("%s: no store account for account %s\n",
1853                            __FUNCTION__, account);
1854         }
1855
1856         /* If there was any problem creating the account, for example,
1857            with the configuration system this could not exist */
1858         if (TNY_IS_TRANSPORT_ACCOUNT(transport_account)) {
1859
1860                 /* Forget any cached password for the account */
1861                 forget_password_in_memory (self, tny_account_get_id (transport_account));
1862
1863                 /* Remove transport account. It'll free the reference
1864                    added by get_server_account */
1865                 remove_transport_account (self, TNY_TRANSPORT_ACCOUNT (transport_account));
1866         } else {
1867                 g_warning ("%s: no transport account for account %s\n",
1868                            __FUNCTION__, account);
1869         }
1870
1871         /* Remove cached images */
1872         stream_cache = modest_runtime_get_images_cache ();
1873         tny_stream_cache_remove (stream_cache, (TnyStreamCacheRemoveFilter) images_cache_remove_filter, (gpointer) account);
1874
1875         /* If there are no more user accounts then delete the
1876            transport specific SMTP servers */
1877         if (only_local_accounts (self))
1878                 remove_connection_specific_transport_accounts (self);
1879 }
1880
1881 TnyTransportAccount *
1882 modest_tny_account_store_new_connection_specific_transport_account (ModestTnyAccountStore *self,
1883                                                                     const gchar *name)
1884 {
1885         ModestTnyAccountStorePrivate *priv = NULL;
1886         TnyAccount * tny_account = NULL;
1887
1888         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1889
1890         /* Add the account: */
1891         tny_account =
1892                 modest_tny_account_new_from_server_account_name (priv->account_mgr,
1893                                                                  priv->session,
1894                                                                  name,
1895                                                                  get_password,
1896                                                                  forget_password);
1897         if (tny_account) {
1898                 g_object_set_data (G_OBJECT(tny_account),
1899                                    "account_store",
1900                                    (gpointer)self);
1901                 g_object_set_data (G_OBJECT(tny_account),
1902                                    "connection_specific",
1903                                    GINT_TO_POINTER (TRUE));
1904
1905                 tny_list_append (priv->transport_accounts, G_OBJECT (tny_account));
1906                 add_outbox_from_transport_account_to_global_outbox (self,
1907                                                                     name,
1908                                                                     tny_account);
1909
1910         } else
1911                 g_printerr ("modest: failed to create smtp-specific account for %s\n",
1912                             name);
1913
1914         return TNY_TRANSPORT_ACCOUNT (tny_account);
1915 }
1916
1917 static void
1918 foreach_free_string(gpointer data,
1919                     gpointer user_data)
1920 {
1921         g_free (data);
1922 }
1923
1924 static void
1925 add_connection_specific_transport_accounts (ModestTnyAccountStore *self)
1926 {
1927         ModestTnyAccountStorePrivate *priv = NULL;
1928         GSList *list_specifics = NULL, *iter = NULL;
1929         GError *err = NULL;
1930
1931         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1932
1933         list_specifics = modest_conf_get_list (modest_runtime_get_conf (),
1934                                                MODEST_CONF_CONNECTION_SPECIFIC_SMTP_LIST,
1935                                                MODEST_CONF_VALUE_STRING, &err);
1936         if (err) {
1937                 g_error_free (err);
1938                 g_return_if_reached ();
1939                 return;
1940         }
1941
1942         /* Look at each connection-specific transport account for the
1943          * modest account: */
1944         iter = list_specifics;
1945         while (iter) {
1946                 /* The list alternates between the connection name and the transport name: */
1947                 iter = g_slist_next (iter);
1948                 if (iter) {
1949                         const gchar* transport_account_name = (const gchar*) (iter->data);
1950                         TnyTransportAccount * account = NULL;
1951                         account = modest_tny_account_store_new_connection_specific_transport_account (
1952                                 self, transport_account_name);
1953                         if (account)
1954                                 g_object_unref (account);
1955                 }
1956                 iter = g_slist_next (iter);
1957         }
1958
1959         /* Free the list */
1960         g_slist_foreach (list_specifics, foreach_free_string, NULL);
1961         g_slist_free (list_specifics);
1962 }
1963
1964 static void
1965 remove_connection_specific_transport_accounts (ModestTnyAccountStore *self)
1966 {
1967         ModestTnyAccountStorePrivate *priv = NULL;
1968         GSList *list_specifics = NULL, *iter = NULL;
1969         GError *err = NULL;
1970
1971         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1972
1973         err = NULL;
1974         list_specifics = modest_conf_get_list (modest_runtime_get_conf (),
1975                                                MODEST_CONF_CONNECTION_SPECIFIC_SMTP_LIST,
1976                                                MODEST_CONF_VALUE_STRING, &err);
1977         if (err) {
1978                 g_error_free (err);
1979                 g_return_if_reached ();
1980                 return;
1981         }
1982
1983         /* Look at each connection-specific transport account for the
1984          * modest account: */
1985         iter = list_specifics;
1986         while (iter) {
1987                 /* The list alternates between the connection name and the transport name: */
1988                 iter = g_slist_next (iter);
1989                 if (iter) {
1990                         const gchar* transport_account_name = (const gchar*) (iter->data);
1991                         TnyAccount * account;
1992                         account = modest_tny_account_store_get_server_account (self,
1993                                                                                transport_account_name,
1994                                                                                TNY_ACCOUNT_TYPE_TRANSPORT);
1995
1996                         /* the call will free the reference */
1997                         if (account)
1998                                 remove_transport_account (self, TNY_TRANSPORT_ACCOUNT (account));
1999                 }
2000                 iter = g_slist_next (iter);
2001         }
2002
2003         /* Free the list */
2004         g_slist_foreach (list_specifics, foreach_free_string, NULL);
2005         g_slist_free (list_specifics);
2006 }
2007
2008
2009 TnyMsg *
2010 modest_tny_account_store_find_msg_in_outboxes (ModestTnyAccountStore *self,
2011                                                const gchar *uri,
2012                                                TnyAccount **ac_out)
2013 {
2014         TnyIterator *acc_iter;
2015         ModestTnyAccountStorePrivate *priv;
2016         TnyMsg *msg = NULL;
2017         TnyAccount *msg_account = NULL;
2018
2019         g_return_val_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (self), NULL);
2020         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
2021
2022         acc_iter = tny_list_create_iterator (priv->store_accounts_outboxes);
2023         while (!msg && !tny_iterator_is_done (acc_iter)) {
2024                 TnyList *folders = tny_simple_list_new ();
2025                 TnyAccount *account = TNY_ACCOUNT (tny_iterator_get_current (acc_iter));
2026                 TnyIterator *folders_iter = NULL;
2027
2028                 tny_folder_store_get_folders (TNY_FOLDER_STORE (account), folders, NULL, FALSE, NULL);
2029                 folders_iter = tny_list_create_iterator (folders);
2030
2031                 while (msg == NULL && !tny_iterator_is_done (folders_iter)) {
2032                         TnyFolder *folder = TNY_FOLDER (tny_iterator_get_current (folders_iter));
2033                         msg = tny_folder_find_msg (folder, uri, NULL);
2034
2035                         if (msg)
2036                                 msg_account = g_object_ref (account);
2037
2038                         g_object_unref (folder);
2039                         tny_iterator_next (folders_iter);
2040                 }
2041                 g_object_unref (folders_iter);
2042
2043                 g_object_unref (folders);
2044                 g_object_unref (account);
2045                 tny_iterator_next (acc_iter);
2046         }
2047
2048         g_object_unref (acc_iter);
2049
2050         if (ac_out != NULL)
2051                 *ac_out = msg_account;
2052
2053         return msg;
2054 }
2055
2056 TnyTransportAccount *
2057 modest_tny_account_store_get_transport_account_from_outbox_header(ModestTnyAccountStore *self, TnyHeader *header)
2058 {
2059         TnyIterator *acc_iter;
2060         ModestTnyAccountStorePrivate *priv;
2061         TnyTransportAccount *header_acc = NULL;
2062         gchar *msg_id;
2063
2064         g_return_val_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (self), NULL);
2065         g_return_val_if_fail (TNY_IS_HEADER (header), NULL);
2066         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
2067         msg_id = modest_tny_send_queue_get_msg_id (header);
2068         acc_iter = tny_list_create_iterator (priv->transport_accounts);
2069         while (!header_acc && !tny_iterator_is_done (acc_iter)) {
2070                 TnyTransportAccount *account = TNY_TRANSPORT_ACCOUNT (tny_iterator_get_current (acc_iter));
2071                 ModestTnySendQueue *send_queue;
2072                 ModestTnySendQueueStatus status;
2073                 send_queue = modest_runtime_get_send_queue(TNY_TRANSPORT_ACCOUNT(account), TRUE);
2074                 if (TNY_IS_SEND_QUEUE (send_queue)) {
2075                         status = modest_tny_send_queue_get_msg_status(send_queue, msg_id);
2076                         if (status != MODEST_TNY_SEND_QUEUE_UNKNOWN)
2077                                 header_acc = g_object_ref(account);
2078                 }
2079                 g_object_unref (account);
2080                 tny_iterator_next (acc_iter);
2081         }
2082         g_object_unref(acc_iter);
2083         g_free (msg_id);
2084
2085         /* New reference */
2086         return header_acc;
2087 }
2088
2089 typedef struct {
2090         ModestTnyAccountStore *account_store;
2091         ModestTnyAccountStoreShutdownCallback callback;
2092         gpointer userdata;
2093         gint pending;
2094 } ShutdownOpData;
2095
2096 static void
2097 account_shutdown_callback (TnyCamelAccount *account, gboolean canceled, GError *err, gpointer userdata)
2098 {
2099         ShutdownOpData *op_data = (ShutdownOpData *) userdata;
2100         op_data->pending--;
2101         if (op_data->pending == 0) {
2102                 if (op_data->callback)
2103                         op_data->callback (op_data->account_store, op_data->userdata);
2104                 g_object_unref (op_data->account_store);
2105                 g_free (op_data);
2106         } else {
2107                 g_object_unref (op_data->account_store);
2108         }
2109 }
2110
2111 static void
2112 account_shutdown (TnyAccount *account, ShutdownOpData *op_data)
2113 {
2114         g_return_if_fail (account && TNY_IS_ACCOUNT(account));
2115
2116         if (TNY_IS_STORE_ACCOUNT (account) &&
2117             !modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account)))
2118                 goto frees;
2119
2120         /* Disconnect account */
2121         if (tny_account_get_connection_status (account) == TNY_CONNECTION_STATUS_CONNECTED) {
2122                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT(account), FALSE,
2123                                               account_shutdown_callback, op_data);
2124                 return;
2125         }
2126
2127  frees:
2128         op_data->pending--;
2129         g_object_unref (op_data->account_store);
2130 }
2131
2132
2133 void
2134 modest_tny_account_store_shutdown (ModestTnyAccountStore *self,
2135                                    ModestTnyAccountStoreShutdownCallback callback,
2136                                    gpointer userdata)
2137 {
2138         gint i, num_accounts;
2139         ShutdownOpData *op_data;
2140         ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
2141
2142         /* Get references */
2143         num_accounts = tny_list_get_length (priv->store_accounts) +
2144                 tny_list_get_length (priv->transport_accounts);
2145         for (i = 0 ; i < num_accounts ; i++)
2146                 g_object_ref (self);
2147
2148         /* Create the helper object */
2149         op_data = g_new0 (ShutdownOpData, 1);
2150         op_data->callback = callback;
2151         op_data->userdata = userdata;
2152         op_data->pending = num_accounts;
2153         op_data->account_store = self;
2154
2155         /* Destroy all accounts. Disconnect all accounts before they are destroyed */
2156         if (priv->store_accounts) {
2157                 tny_list_foreach (priv->store_accounts, (GFunc)account_shutdown, op_data);
2158         }
2159
2160         if (priv->transport_accounts) {
2161                 tny_list_foreach (priv->transport_accounts, (GFunc)account_shutdown, op_data);
2162         }
2163
2164         if (op_data->pending == 0) {
2165                 if (op_data->callback)
2166                         op_data->callback (op_data->account_store, op_data->userdata);
2167                 g_free (op_data);
2168         }
2169 }
2170
2171 gboolean
2172 modest_tny_account_store_is_send_mail_blocked (ModestTnyAccountStore *self)
2173 {
2174         ModestTnyAccountStorePrivate *priv;
2175
2176         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
2177
2178         return priv->send_mail_blocked;
2179 }
2180
2181 void
2182 modest_tny_account_store_set_send_mail_blocked (ModestTnyAccountStore *self,
2183                                                 gboolean blocked)
2184 {
2185         ModestTnyAccountStorePrivate *priv;
2186
2187         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
2188
2189         priv->send_mail_blocked = blocked;
2190 }
2191
2192 static void
2193 count_remote_accounts (gpointer data, gpointer user_data)
2194 {
2195         TnyFolderStore *account = TNY_FOLDER_STORE (data);
2196         gint *count = (gint *) user_data;
2197
2198         if (modest_tny_folder_store_is_remote (account))
2199                 (*count)++;
2200 }
2201
2202 guint
2203 modest_tny_account_store_get_num_remote_accounts (ModestTnyAccountStore *self)
2204 {
2205         ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
2206         gint count = 0;
2207
2208         /* Count remote accounts */
2209         tny_list_foreach (priv->store_accounts, (GFunc) count_remote_accounts, &count);
2210
2211         return count;
2212 }