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