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
  44 #include <modest-runtime.h>
  45 #include <modest-marshal.h>
  46 #include <modest-protocol-registry.h>
  47 #include <modest-local-folder-info.h>
  48 #include "modest-account-protocol.h"
  49 #include <modest-tny-account.h>
  50 #include <modest-tny-local-folders-account.h>
  51 #include <modest-account-mgr.h>
  52 #include <modest-account-mgr-helpers.h>
  53 #include <widgets/modest-window-mgr.h>
  54 #include <modest-signal-mgr.h>
  55 #include <modest-debug.h>
  56
  57 #include <modest-defs.h>
  58 #include "modest-tny-account-store.h"
  59 #include "modest-tny-platform-factory.h"
  60 #include <tny-gtk-lockable.h>
  61 #include <camel/camel.h>
  62 #include <modest-platform.h>
  63 #include "modest-ui-actions.h"
  64 #include <widgets/modest-account-settings-dialog.h>
  65
  66 #ifdef MODEST_PLATFORM_MAEMO
  67 #include <tny-maemo-conic-device.h>
  68 #include <maemo/modest-maemo-utils.h>
  69 #endif
  70
  71 #include <libgnomevfs/gnome-vfs-volume-monitor.h>
  72
  73 /* 'private'/'protected' functions */
  74 static void    modest_tny_account_store_class_init   (ModestTnyAccountStoreClass *klass);
  75 static void    modest_tny_account_store_finalize     (GObject *obj);
  76 static void    modest_tny_account_store_instance_init (ModestTnyAccountStore *obj);
  77 static void    modest_tny_account_store_init          (gpointer g, gpointer iface_data);
  78 static void    modest_tny_account_store_base_init     (gpointer g_class);
  79
  80 static void    on_account_inserted         (ModestAccountMgr *acc_mgr,
  81                                             const gchar *account,
  82                                             gpointer user_data);
  83
  84 static void   add_existing_accounts       (ModestTnyAccountStore *self);
  85
  86 static void    insert_account              (ModestTnyAccountStore *self,
  87                                             const gchar *account,
  88                                             gboolean notify);
  89
  90 static void    on_account_removed          (ModestAccountMgr *acc_mgr,
  91                                             const gchar *account,
  92                                             gpointer user_data);
  93
  94 static gchar*  get_password                (TnyAccount *account,
  95                                             const gchar * prompt_not_used,
  96                                             gboolean *cancel);
  97
  98 static void    forget_password             (TnyAccount *account);
  99
 100 static void    on_vfs_volume_mounted       (GnomeVFSVolumeMonitor *volume_monitor,
 101                                             GnomeVFSVolume *volume,
 102                                             gpointer user_data);
 103
 104 static void    on_vfs_volume_unmounted     (GnomeVFSVolumeMonitor *volume_monitor,
 105                                             GnomeVFSVolume *volume,
 106                                             gpointer user_data);
 107
 108 static void    forget_password_in_memory (ModestTnyAccountStore *self,
 109                                           const gchar *server_account_name);
 110
 111 static void    add_connection_specific_transport_accounts         (ModestTnyAccountStore *self);
 112
 113 static void    remove_connection_specific_transport_accounts      (ModestTnyAccountStore *self);
 114
 115 static void    connection_status_changed   (TnyAccount *account,
 116                                             TnyConnectionStatus status,
 117                                             gpointer data);
 118
 119 static inline gboolean only_local_accounts        (ModestTnyAccountStore *self);
 120
 121 /* list my signals */
 122 enum {
 123         ACCOUNT_CHANGED_SIGNAL,
 124         ACCOUNT_INSERTED_SIGNAL,
 125         ACCOUNT_REMOVED_SIGNAL,
 126
 127         PASSWORD_REQUESTED_SIGNAL,
 128         LAST_SIGNAL
 129 };
 130
 131 typedef struct _ModestTnyAccountStorePrivate ModestTnyAccountStorePrivate;
 132 struct _ModestTnyAccountStorePrivate {
 133         gchar              *cache_dir;
 134         GHashTable         *password_hash;
 135         ModestAccountMgr   *account_mgr;
 136         TnySessionCamel    *session;
 137         TnyDevice          *device;
 138
 139         GSList *sighandlers;
 140
 141         /* We cache the lists of accounts here */
 142         TnyList             *store_accounts;
 143         TnyList             *transport_accounts;
 144         TnyList             *store_accounts_outboxes;
 145
 146         /* Matches transport accounts and outbox folder */
 147         GHashTable          *outbox_of_transport;
 148
 149         /* is sending mail blocked? */
 150         gboolean send_mail_blocked;
 151 };
 152
 153 #define MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
 154                                                       MODEST_TYPE_TNY_ACCOUNT_STORE, \
 155                                                       ModestTnyAccountStorePrivate))
 156
 157 /* globals */
 158 static GObjectClass *parent_class = NULL;
 159
 160 static guint signals[LAST_SIGNAL] = {0};
 161
 162 GType
 163 modest_tny_account_store_get_type (void)
 164 {
 165         static GType my_type = 0;
 166
 167         if (!my_type) {
 168                 static const GTypeInfo my_info = {
 169                         sizeof(ModestTnyAccountStoreClass),
 170                         modest_tny_account_store_base_init,     /* base init */
 171                         NULL,           /* base finalize */
 172                         (GClassInitFunc) modest_tny_account_store_class_init,
 173                         NULL,           /* class finalize */
 174                         NULL,           /* class data */
 175                         sizeof(ModestTnyAccountStore),
 176                         0,              /* n_preallocs */
 177                         (GInstanceInitFunc) modest_tny_account_store_instance_init,
 178                         NULL
 179                 };
 180
 181                 static const GInterfaceInfo iface_info = {
 182                         (GInterfaceInitFunc) modest_tny_account_store_init,
 183                         NULL,         /* interface_finalize */
 184                         NULL          /* interface_data */
 185                 };
 186                 /* hack hack */
 187                 my_type = g_type_register_static (G_TYPE_OBJECT,
 188                                                   "ModestTnyAccountStore",
 189                                                   &my_info, 0);
 190                 g_type_add_interface_static (my_type, TNY_TYPE_ACCOUNT_STORE,
 191                                              &iface_info);
 192         }
 193         return my_type;
 194 }
 195
 196
 197 static void
 198 modest_tny_account_store_base_init (gpointer g_class)
 199 {
 200         static gboolean tny_account_store_initialized = FALSE;
 201
 202         if (!tny_account_store_initialized) {
 203
 204                 signals[ACCOUNT_CHANGED_SIGNAL] =
 205                         g_signal_new ("account_changed",
 206                                       MODEST_TYPE_TNY_ACCOUNT_STORE,
 207                                       G_SIGNAL_RUN_FIRST,
 208                                       G_STRUCT_OFFSET (ModestTnyAccountStoreClass, account_changed),
 209                                       NULL, NULL,
 210                                       g_cclosure_marshal_VOID__OBJECT,
 211                                       G_TYPE_NONE, 1, TNY_TYPE_ACCOUNT);
 212
 213                 signals[ACCOUNT_INSERTED_SIGNAL] =
 214                         g_signal_new ("account_inserted",
 215                                       MODEST_TYPE_TNY_ACCOUNT_STORE,
 216                                       G_SIGNAL_RUN_FIRST,
 217                                       G_STRUCT_OFFSET (ModestTnyAccountStoreClass, account_inserted),
 218                                       NULL, NULL,
 219                                       g_cclosure_marshal_VOID__OBJECT,
 220                                       G_TYPE_NONE, 1, TNY_TYPE_ACCOUNT);
 221
 222                 signals[ACCOUNT_REMOVED_SIGNAL] =
 223                         g_signal_new ("account_removed",
 224                                       MODEST_TYPE_TNY_ACCOUNT_STORE,
 225                                       G_SIGNAL_RUN_FIRST,
 226                                       G_STRUCT_OFFSET (ModestTnyAccountStoreClass, account_removed),
 227                                       NULL, NULL,
 228                                       g_cclosure_marshal_VOID__OBJECT,
 229                                       G_TYPE_NONE, 1, TNY_TYPE_ACCOUNT);
 230
 231                 signals[PASSWORD_REQUESTED_SIGNAL] =
 232                         g_signal_new ("password_requested",
 233                                       MODEST_TYPE_TNY_ACCOUNT_STORE,
 234                                       G_SIGNAL_RUN_FIRST,
 235                                       G_STRUCT_OFFSET(ModestTnyAccountStoreClass, password_requested),
 236                                       NULL, NULL,
 237                                       modest_marshal_VOID__STRING_POINTER_POINTER_POINTER_POINTER,
 238                                       G_TYPE_NONE, 5, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER,
 239                                       G_TYPE_POINTER);
 240
 241                 tny_account_store_initialized = TRUE;
 242         }
 243 }
 244
 245
 246 static void
 247 modest_tny_account_store_class_init (ModestTnyAccountStoreClass *klass)
 248 {
 249         GObjectClass *gobject_class;
 250         gobject_class = (GObjectClass*) klass;
 251
 252         parent_class            = g_type_class_peek_parent (klass);
 253         gobject_class->finalize = modest_tny_account_store_finalize;
 254
 255         g_type_class_add_private (gobject_class,
 256                                   sizeof(ModestTnyAccountStorePrivate));
 257 }
 258
 259 static void
 260 modest_tny_account_store_instance_init (ModestTnyAccountStore *obj)
 261 {
 262         GnomeVFSVolumeMonitor* monitor = NULL;
 263         ModestTnyAccountStorePrivate *priv;
 264
 265         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(obj);
 266
 267         priv->cache_dir              = NULL;
 268         priv->account_mgr            = NULL;
 269         priv->session                = NULL;
 270         priv->device                 = NULL;
 271         priv->sighandlers            = NULL;
 272         priv->send_mail_blocked      = FALSE;
 273
 274         priv->outbox_of_transport = g_hash_table_new_full (g_direct_hash,
 275                                                            g_direct_equal,
 276                                                            NULL,
 277                                                            NULL);
 278
 279         /* An in-memory store of passwords,
 280          * for passwords that are not remembered in the configuration,
 281          * so they need to be asked for from the user once in each session:
 282          */
 283         priv->password_hash = g_hash_table_new_full (g_str_hash, g_str_equal,
 284                                                      g_free, g_free);
 285
 286         /* Respond to volume mounts and unmounts, such
 287          * as the insertion/removal of the memory card: */
 288         /* This is a singleton, so it does not need to be unrefed. */
 289         monitor = gnome_vfs_get_volume_monitor();
 290
 291         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
 292                                                        G_OBJECT(monitor),
 293                                                        "volume-mounted",
 294                                                        G_CALLBACK(on_vfs_volume_mounted),
 295                                                        obj);
 296         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
 297                                                        G_OBJECT(monitor), "volume-unmounted",
 298                                                        G_CALLBACK(on_vfs_volume_unmounted),
 299                                                        obj);
 300 }
 301
 302 /* disconnect the list of TnyAccounts */
 303 static void
 304 account_verify_last_ref (TnyAccount *account, const gchar *str)
 305 {
 306         gchar *txt;
 307
 308         g_return_if_fail (account && TNY_IS_ACCOUNT(account));
 309
 310         txt = g_strdup_printf ("%s: %s", str ? str : "?", tny_account_get_name(account));
 311         MODEST_DEBUG_VERIFY_OBJECT_LAST_REF(G_OBJECT(account),txt);
 312         g_free (txt);
 313 }
 314
 315 static void
 316 foreach_account_append_to_list (gpointer data,
 317                                 gpointer user_data)
 318 {
 319         TnyList *list;
 320
 321         list = TNY_LIST (user_data);
 322         tny_list_append (list, G_OBJECT (data));
 323 }
 324
 325 /********************************************************************/
 326 /*           Control the state of the MMC local account             */
 327 /********************************************************************/
 328
 329 /** Only call this if the memory card is really mounted.
 330  */
 331 static void
 332 add_mmc_account(ModestTnyAccountStore *self, gboolean emit_insert_signal)
 333 {
 334         ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 335         g_return_if_fail (priv->session);
 336
 337         TnyAccount *mmc_account = modest_tny_account_new_for_local_folders (priv->account_mgr,
 338                                                                             priv->session,
 339                                                                             g_getenv (MODEST_MMC1_VOLUMEPATH_ENV));
 340
 341         /* Add to the list of store accounts */
 342         tny_list_append (priv->store_accounts, G_OBJECT (mmc_account));
 343
 344         if (emit_insert_signal) {
 345                 g_signal_emit (G_OBJECT (self),
 346                                signals [ACCOUNT_INSERTED_SIGNAL],
 347                                0, mmc_account);
 348         }
 349
 350         /* Free */
 351         g_object_unref (mmc_account);
 352 }
 353
 354 static void
 355 on_vfs_volume_mounted(GnomeVFSVolumeMonitor *volume_monitor,
 356                       GnomeVFSVolume *volume,
 357                       gpointer user_data)
 358 {
 359         ModestTnyAccountStore *self;
 360         ModestTnyAccountStorePrivate *priv;
 361         gchar *volume_path_uri;
 362
 363         gchar *uri = NULL;
 364
 365         self = MODEST_TNY_ACCOUNT_STORE(user_data);
 366         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 367
 368         /* Check whether this was the external MMC1 card: */
 369         uri = gnome_vfs_volume_get_activation_uri (volume);
 370
 371         volume_path_uri = g_strconcat (MODEST_MMC1_VOLUMEPATH_URI_PREFIX,
 372                                        g_getenv (MODEST_MMC1_VOLUMEPATH_ENV),
 373                                        NULL);
 374         if (uri && (!strcmp (uri, volume_path_uri))) {
 375                 add_mmc_account (self, TRUE /* emit the insert signal. */);
 376         }
 377
 378         g_free (volume_path_uri);
 379         g_free (uri);
 380 }
 381
 382 static void
 383 on_vfs_volume_unmounted(GnomeVFSVolumeMonitor *volume_monitor,
 384                         GnomeVFSVolume *volume,
 385                         gpointer user_data)
 386 {
 387         ModestTnyAccountStore *self;
 388         ModestTnyAccountStorePrivate *priv;
 389         gchar *uri = NULL;
 390         gchar *volume_path_uri;
 391
 392         self = MODEST_TNY_ACCOUNT_STORE(user_data);
 393         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 394
 395         /* Check whether this was the external MMC1 card: */
 396         uri = gnome_vfs_volume_get_activation_uri (volume);
 397         volume_path_uri = g_strconcat (MODEST_MMC1_VOLUMEPATH_URI_PREFIX,
 398                                        g_getenv (MODEST_MMC1_VOLUMEPATH_ENV),
 399                                        NULL);
 400         if (uri && (strcmp (uri, volume_path_uri) == 0)) {
 401                 TnyAccount *mmc_account = NULL;
 402                 gboolean found = FALSE;
 403                 TnyIterator *iter = NULL;
 404
 405                 iter = tny_list_create_iterator (priv->store_accounts);
 406                 while (!tny_iterator_is_done (iter) && !found) {
 407                         TnyAccount *account;
 408
 409                         account = TNY_ACCOUNT (tny_iterator_get_current (iter));
 410                         if (modest_tny_account_is_memory_card_account (account)) {
 411                                 found = TRUE;
 412                                 mmc_account = g_object_ref (account);
 413                         }
 414                         g_object_unref (account);
 415                         tny_iterator_next (iter);
 416                 }
 417                 g_object_unref (iter);
 418
 419                 if (found) {
 420                         /* Remove from the list */
 421                         tny_list_remove (priv->store_accounts, G_OBJECT (mmc_account));
 422
 423                         /* Notify observers */
 424                         g_signal_emit (G_OBJECT (self),
 425                                        signals [ACCOUNT_REMOVED_SIGNAL],
 426                                        0, mmc_account);
 427
 428                         g_object_unref (mmc_account);
 429                 } else {
 430                         g_warning ("%s: there was no store account for the unmounted MMC",
 431                                    __FUNCTION__);
 432                 }
 433         }
 434         g_free (volume_path_uri);
 435         g_free (uri);
 436 }
 437
 438 /**
 439  * forget_password_in_memory
 440  * @self: a TnyAccountStore instance
 441  * @account: A server account.
 442  *
 443  * Forget any password stored in memory for this account.
 444  * For instance, this should be called when the user has changed the password in the account settings.
 445  */
 446 static void
 447 forget_password_in_memory (ModestTnyAccountStore *self,
 448                            const gchar * server_account_name)
 449 {
 450         ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 451
 452         if (server_account_name && priv->password_hash) {
 453                 g_hash_table_remove (priv->password_hash, server_account_name);
 454         }
 455 }
 456
 457 static void
 458 on_account_changed (ModestAccountMgr *acc_mgr,
 459                     const gchar *account_name,
 460                     TnyAccountType account_type,
 461                     gpointer user_data)
 462 {
 463         ModestTnyAccountStore *self = MODEST_TNY_ACCOUNT_STORE(user_data);
 464         ModestTnyAccountStorePrivate *priv;
 465         TnyList* account_list;
 466         gboolean found = FALSE;
 467         TnyIterator *iter = NULL;
 468
 469         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 470         account_list = (account_type == TNY_ACCOUNT_TYPE_STORE ?
 471                         priv->store_accounts :
 472                         priv->transport_accounts);
 473
 474         iter = tny_list_create_iterator (account_list);
 475         while (!tny_iterator_is_done (iter) && !found) {
 476                 TnyAccount *tny_account;
 477                 tny_account = TNY_ACCOUNT (tny_iterator_get_current (iter));
 478                 if (tny_account) {
 479                         if (!strcmp (tny_account_get_id (tny_account), account_name)) {
 480                                 found = TRUE;
 481                                 modest_tny_account_update_from_account (tny_account, get_password, forget_password);
 482                                 g_signal_emit (G_OBJECT(self), signals[ACCOUNT_CHANGED_SIGNAL], 0, tny_account);
 483                         }
 484                         g_object_unref (tny_account);
 485                 }
 486                 tny_iterator_next (iter);
 487         }
 488
 489         if (iter)
 490                 g_object_unref (iter);
 491 }
 492
 493 static void
 494 show_password_warning_only (const gchar *msg)
 495 {
 496         ModestWindow *main_window =
 497                 modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (), FALSE); /* don't create */
 498
 499         /* Show an explanatory temporary banner: */
 500         if (main_window)
 501                 modest_platform_information_banner (NULL, NULL, msg);
 502 }
 503
 504 static void
 505 show_wrong_password_dialog (TnyAccount *account)
 506 {
 507         if (g_object_get_data (G_OBJECT (account), "connection_specific") != NULL) {
 508                 modest_ui_actions_on_smtp_servers (NULL, NULL);
 509         } else {
 510                 ModestAccountProtocol *proto;
 511                 ModestProtocolType proto_type;
 512                 const gchar *modest_account_name;
 513                 modest_account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (account);
 514
 515                 /* Get proto */
 516                 proto_type = modest_account_mgr_get_store_protocol (modest_runtime_get_account_mgr (),
 517                                                                     modest_account_name);
 518                 proto = (ModestAccountProtocol *)
 519                         modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
 520                                                                        proto_type);
 521
 522                 /* Create and show the dialog */
 523                 if (proto && MODEST_IS_ACCOUNT_PROTOCOL (proto)) {
 524                         ModestAccountSettingsDialog *dialog =
 525                                 modest_account_protocol_get_account_settings_dialog (proto, modest_account_name);
 526                         modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (dialog), NULL);
 527                         gtk_widget_show (GTK_WIDGET (dialog));
 528                 }
 529         }
 530         /* Show an explanatory temporary banner: */
 531         modest_platform_information_banner (NULL, NULL, _("mcen_ib_username_pw_incorrect"));
 532 }
 533
 534 /* This callback will be called by Tinymail when it needs the password
 535  * from the user or the account settings.
 536  * It can also call forget_password() before calling this,
 537  * so that we clear wrong passwords out of our account settings.
 538  * Note that TnyAccount here will be the server account. */
 539 static gchar*
 540 get_password (TnyAccount *account, const gchar * prompt_not_used, gboolean *cancel)
 541 {
 542         ModestTnyAccountStore *self = NULL;
 543         ModestTnyAccountStorePrivate *priv;
 544         gchar *username = NULL;
 545         gchar *pwd = NULL;
 546         gpointer pwd_ptr = NULL;
 547         gboolean already_asked = FALSE;
 548         const gchar *server_account_name;
 549         gchar *url_string;
 550
 551         g_return_val_if_fail (account, NULL);
 552
 553         MODEST_DEBUG_BLOCK(
 554                 g_debug ("%s: prompt (not shown) = %s\n", __FUNCTION__, prompt_not_used);
 555         );
 556
 557         /* Get a reference to myself */
 558         self = MODEST_TNY_ACCOUNT_STORE (g_object_get_data (G_OBJECT(account), "account_store"));
 559         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 560
 561         /* Ensure that we still have this account. It could happen
 562            that a set_online was requested *before* removing an
 563            account, and due to tinymail emits the get_password
 564            function using a g_idle the account could be actually
 565            removed *before* this function was really called */
 566         url_string = tny_account_get_url_string (account);
 567         if (url_string) {
 568                 TnyAccount *tmp_account;
 569
 570                 tmp_account = tny_account_store_find_account (TNY_ACCOUNT_STORE (self),
 571                                                               url_string);
 572                 g_free (url_string);
 573
 574                 if (!tmp_account) {
 575                         *cancel = TRUE;
 576                         return NULL;
 577                 }
 578                 g_object_unref (tmp_account);
 579         }
 580
 581         server_account_name = tny_account_get_id (account);
 582         if (!server_account_name || !self) {
 583                 g_warning ("modest: %s: could not retrieve account_store for account %s",
 584                            __FUNCTION__, server_account_name ? server_account_name : "<NULL>");
 585                 if (cancel)
 586                         *cancel = TRUE;
 587
 588                 return NULL;
 589         }
 590
 591         /* This hash map stores passwords, including passwords that are not stored in gconf. */
 592         /* Is it in the hash? if it's already there, it must be wrong... */
 593         pwd_ptr = (gpointer)&pwd; /* pwd_ptr so the compiler does not complained about
 594                                    * type-punned ptrs...*/
 595         already_asked = priv->password_hash &&
 596                                 g_hash_table_lookup_extended (priv->password_hash,
 597                                                       server_account_name,
 598                                                       NULL,
 599                                                       (gpointer*)&pwd_ptr);
 600         MODEST_DEBUG_BLOCK(
 601                 g_debug ("%s: Already asked = %d\n", __FUNCTION__, already_asked);
 602         );
 603
 604         /* If the password is not already there, try ModestConf */
 605         if (!already_asked) {
 606                 pwd  = modest_account_mgr_get_server_account_password (priv->account_mgr,
 607                                                                        server_account_name);
 608                 g_hash_table_insert (priv->password_hash, g_strdup (server_account_name), g_strdup (pwd));
 609         }
 610
 611         /* If it was already asked, it must have been wrong, so ask again */
 612         if (already_asked || !pwd || strlen(pwd) == 0) {
 613                 gboolean settings_have_password;
 614                 ModestProtocolType protocol_type;
 615
 616                 /* As per the UI spec, if no password was set in the account settings,
 617                  * ask for it now. But if the password is wrong in the account settings,
 618                  * then show a banner and the account settings dialog so it can be corrected:
 619                  */
 620                 settings_have_password =
 621                         modest_account_mgr_get_server_account_has_password (priv->account_mgr, server_account_name);
 622
 623                 protocol_type = modest_tny_account_get_protocol_type (account);
 624
 625                 /* Show an error and after that ask for a password */
 626                 if (modest_protocol_registry_protocol_type_has_tag(modest_runtime_get_protocol_registry (),
 627                                                                    protocol_type, MODEST_PROTOCOL_REGISTRY_TRANSPORT_PROTOCOLS)) {
 628                         gchar *username = NULL, *msg = NULL;
 629                         username = modest_account_mgr_get_server_account_username (priv->account_mgr,
 630                                                                                    server_account_name);
 631                         if (!username || strlen(username) == 0) {
 632                                 msg = g_strdup_printf (_("emev_ni_ui_smtp_userid_invalid"),
 633                                                        tny_account_get_name (account),
 634                                                        tny_account_get_hostname (account));
 635                         } else {
 636                                 gchar *password;
 637                                 password  = modest_account_mgr_get_server_account_password (priv->account_mgr,
 638                                                                                             server_account_name);
 639                                 if (!password || strlen(password) == 0)
 640                                         msg = g_strdup_printf (_("emev_ni_ui_smtp_passwd_invalid"),
 641                                                                tny_account_get_name (account),
 642                                                                tny_account_get_hostname (account));
 643                                 else
 644                                         msg = g_strdup_printf (_("emev_ni_ui_smtp_authentication_fail_error"),
 645                                                                tny_account_get_hostname (account));
 646                                 if (password)
 647                                         g_free (password);
 648                         }
 649                         if (msg) {
 650                                 modest_platform_run_information_dialog (NULL, msg, TRUE);
 651                                 g_free (msg);
 652                         }
 653                         if (username)
 654                                 g_free (username);
 655                 }
 656
 657                 if (settings_have_password) {
 658                         /* The password must be wrong, so show the account settings dialog so it can be corrected: */
 659                         show_wrong_password_dialog (account);
 660
 661                         if (cancel)
 662                                 *cancel = TRUE;
 663
 664                         return NULL;
 665                 }
 666
 667                 /* we don't have it yet. Get the password from the user */
 668                 const gchar* account_id = tny_account_get_id (account);
 669                 gboolean remember = FALSE;
 670                 pwd = NULL;
 671
 672                 if (already_asked) {
 673                         const gchar *msg;
 674                         gboolean username_known =
 675                                 modest_account_mgr_get_server_account_username_has_succeeded(priv->account_mgr,
 676                                                                                              server_account_name);
 677                         /* If the login has ever succeeded then show a specific message */
 678                         if (username_known)
 679                                 msg = _CS ("ecdg_ib_set_password_incorrect");
 680                         else
 681                                 msg = _("mcen_ib_username_pw_incorrect");
 682                         show_password_warning_only (msg);
 683                 }
 684
 685                 /* Request password */
 686                 g_signal_emit (G_OBJECT (self), signals[PASSWORD_REQUESTED_SIGNAL], 0,
 687                                account_id, /* server_account_name */
 688                                &username, &pwd, cancel, &remember);
 689
 690
 691                 if (!*cancel) {
 692                         /* The password will be returned as the result,
 693                          * but we need to tell tinymail about the username too: */
 694
 695                         /* WARNING: I disabled setting username as this can cause locks. Anyway,
 696                          * as now we have the password dialog username entry always dimmed
 697                          * this shouldn't be a problem */
 698
 699                         /* if (username) */
 700                         /*      tny_account_set_user (account, username); */
 701
 702                         /* Do not save the password in gconf, because
 703                          * the UI spec says "The password will never
 704                          * be saved in the account": */
 705
 706                         /* We need to dup the string even knowing that
 707                            it's already a dup of the contents of an
 708                            entry, because it if it's wrong, then camel
 709                            will free it */
 710                         g_hash_table_insert (priv->password_hash, g_strdup (server_account_name), g_strdup(pwd));
 711                 } else {
 712                         g_hash_table_remove (priv->password_hash, server_account_name);
 713
 714                         g_free (pwd);
 715                         pwd = NULL;
 716                 }
 717
 718                 g_free (username);
 719                 username = NULL;
 720         } else
 721                 if (cancel)
 722                         *cancel = FALSE;
 723         return pwd;
 724 }
 725
 726 void
 727 modest_tny_account_store_forget_already_asked (ModestTnyAccountStore *self, TnyAccount *account)
 728 {
 729         g_return_if_fail (account);
 730
 731         ModestTnyAccountStorePrivate *priv;
 732         gchar *pwd = NULL;
 733         gpointer pwd_ptr = NULL;
 734         gboolean already_asked = FALSE;
 735
 736         const gchar *server_account_name = tny_account_get_id (account);
 737
 738         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 739
 740         /* This hash map stores passwords, including passwords that are not stored in gconf. */
 741         pwd_ptr = (gpointer)&pwd; /* pwd_ptr so the compiler does not complained about
 742                                    * type-punned ptrs...*/
 743         already_asked = priv->password_hash &&
 744                                 g_hash_table_lookup_extended (priv->password_hash,
 745                                                       server_account_name,
 746                                                       NULL,
 747                                                       (gpointer*)&pwd_ptr);
 748
 749         if (already_asked) {
 750                 g_hash_table_remove (priv->password_hash, server_account_name);
 751                 g_free (pwd);
 752                 pwd = NULL;
 753         }
 754
 755         return;
 756 }
 757
 758 /* tinymail calls this if the connection failed due to an incorrect password.
 759  * And it seems to call this for any general connection failure. */
 760 static void
 761 forget_password (TnyAccount *account)
 762 {
 763         ModestTnyAccountStore *self;
 764         ModestTnyAccountStorePrivate *priv;
 765         const TnyAccountStore *account_store;
 766         gchar *pwd;
 767         const gchar *key;
 768
 769         account_store = TNY_ACCOUNT_STORE(g_object_get_data (G_OBJECT(account),
 770                                                              "account_store"));
 771         self = MODEST_TNY_ACCOUNT_STORE (account_store);
 772         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 773         key  = tny_account_get_id (account);
 774
 775         /* Do not remove the key, this will allow us to detect that we
 776            have already asked for it at least once */
 777         pwd = g_hash_table_lookup (priv->password_hash, key);
 778         if (pwd) {
 779                 memset (pwd, 0, strlen (pwd));
 780                 g_hash_table_insert (priv->password_hash, g_strdup (key), NULL);
 781         }
 782
 783         /* Remove from configuration system */
 784         /*
 785         modest_account_mgr_unset (priv->account_mgr,
 786                                   key, MODEST_ACCOUNT_PASSWORD, TRUE);
 787         */
 788 }
 789
 790 static void
 791 modest_tny_account_store_finalize (GObject *obj)
 792 {
 793         ModestTnyAccountStore *self        = MODEST_TNY_ACCOUNT_STORE(obj);
 794         ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 795
 796         g_free (priv->cache_dir);
 797         priv->cache_dir = NULL;
 798
 799         if (priv->password_hash) {
 800                 g_hash_table_destroy (priv->password_hash);
 801                 priv->password_hash = NULL;
 802         }
 803
 804         if (priv->outbox_of_transport) {
 805                 g_hash_table_destroy (priv->outbox_of_transport);
 806                 priv->outbox_of_transport = NULL;
 807         }
 808
 809         modest_signal_mgr_disconnect_all_and_destroy (priv->sighandlers);
 810         priv->sighandlers = NULL;
 811
 812         if (priv->account_mgr) {
 813                 g_object_unref (G_OBJECT(priv->account_mgr));
 814                 priv->account_mgr = NULL;
 815         }
 816
 817         if (priv->device) {
 818                 g_object_unref (G_OBJECT(priv->device));
 819                 priv->device = NULL;
 820         }
 821
 822         /* Destroy all accounts. Disconnect all accounts before they are destroyed */
 823         if (priv->store_accounts) {
 824                 tny_list_foreach (priv->store_accounts, (GFunc)account_verify_last_ref, "store");
 825                 g_object_unref (priv->store_accounts);
 826                 priv->store_accounts = NULL;
 827         }
 828
 829         if (priv->transport_accounts) {
 830                 tny_list_foreach (priv->transport_accounts, (GFunc)account_verify_last_ref, "transport");
 831                 g_object_unref (priv->transport_accounts);
 832                 priv->transport_accounts = NULL;
 833         }
 834
 835         if (priv->store_accounts_outboxes) {
 836                 g_object_unref (priv->store_accounts_outboxes);
 837                 priv->store_accounts_outboxes = NULL;
 838         }
 839
 840         if (priv->session) {
 841                 camel_object_unref (CAMEL_OBJECT(priv->session));
 842                 priv->session = NULL;
 843         }
 844
 845         G_OBJECT_CLASS(parent_class)->finalize (obj);
 846 }
 847
 848 gboolean
 849 volume_path_is_mounted (const gchar* path)
 850 {
 851         g_return_val_if_fail (path, FALSE);
 852
 853         gboolean result = FALSE;
 854         gchar * path_as_uri = g_filename_to_uri (path, NULL, NULL);
 855         g_return_val_if_fail (path_as_uri, FALSE);
 856
 857         /* Get the monitor singleton: */
 858         GnomeVFSVolumeMonitor *monitor = gnome_vfs_get_volume_monitor();
 859
 860         /* This seems like a simpler way to do this, but it returns a
 861          * GnomeVFSVolume even if the drive is not mounted: */
 862         /*
 863         GnomeVFSVolume *volume = gnome_vfs_volume_monitor_get_volume_for_path (monitor,
 864                                  g_getenv (MODEST_MMC1_VOLUMEPATH_ENV));
 865         if (volume) {
 866                 gnome_vfs_volume_unref(volume);
 867         }
 868         */
 869
 870         /* Get the mounted volumes from the monitor: */
 871         GList *list = gnome_vfs_volume_monitor_get_mounted_volumes (monitor);
 872         GList *iter = list;
 873         for (iter = list; iter; iter = g_list_next (iter)) {
 874                 GnomeVFSVolume *volume = (GnomeVFSVolume*)iter->data;
 875                 if (volume) {
 876                         /*
 877                         char *display_name =
 878                                 gnome_vfs_volume_get_display_name (volume);
 879                         printf ("volume display name=%s\n", display_name);
 880                         g_free (display_name);
 881                         */
 882
 883                         char *uri =
 884                                 gnome_vfs_volume_get_activation_uri (volume);
 885                         /* printf ("  uri=%s\n", uri); */
 886                         if (uri && (strcmp (uri, path_as_uri) == 0))
 887                                 result = TRUE;
 888
 889                         g_free (uri);
 890
 891                         gnome_vfs_volume_unref (volume);
 892                 }
 893         }
 894
 895         g_list_free (list);
 896
 897         g_free (path_as_uri);
 898
 899         return result;
 900 }
 901
 902 ModestTnyAccountStore*
 903 modest_tny_account_store_new (ModestAccountMgr *account_mgr,
 904                               TnyDevice *device)
 905 {
 906         GObject *obj;
 907         ModestTnyAccountStorePrivate *priv;
 908         TnyAccount *local_account = NULL;
 909         TnyLockable *lockable;
 910
 911         g_return_val_if_fail (account_mgr, NULL);
 912         g_return_val_if_fail (device, NULL);
 913
 914         obj  = G_OBJECT(g_object_new(MODEST_TYPE_TNY_ACCOUNT_STORE, NULL));
 915         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(obj);
 916
 917         priv->account_mgr = g_object_ref (G_OBJECT(account_mgr));
 918         priv->device = g_object_ref (device);
 919
 920         priv->session = tny_session_camel_new (TNY_ACCOUNT_STORE(obj));
 921         if (!priv->session) {
 922                 g_warning ("failed to get TnySessionCamel");
 923                 return NULL;
 924         }
 925
 926         /* Set the ui locker */
 927         lockable = tny_gtk_lockable_new ();
 928         tny_session_camel_set_ui_locker (priv->session, lockable);
 929         g_object_unref (lockable);
 930
 931         /* Connect signals */
 932         priv->sighandlers  =  modest_signal_mgr_connect (priv->sighandlers,
 933                                                          G_OBJECT(account_mgr), "account_inserted",
 934                                                          G_CALLBACK (on_account_inserted), obj);
 935         priv->sighandlers  =  modest_signal_mgr_connect (priv->sighandlers,
 936                                                          G_OBJECT(account_mgr), "account_changed",
 937                                                          G_CALLBACK (on_account_changed), obj);
 938         priv->sighandlers  =  modest_signal_mgr_connect (priv->sighandlers,
 939                                                          G_OBJECT(account_mgr), "account_removed",
 940                                                          G_CALLBACK (on_account_removed), obj);
 941
 942         /* Create the lists of accounts */
 943         priv->store_accounts = tny_simple_list_new ();
 944         priv->transport_accounts = tny_simple_list_new ();
 945         priv->store_accounts_outboxes = tny_simple_list_new ();
 946
 947         /* Create the local folders account */
 948         local_account =
 949                 modest_tny_account_new_for_local_folders (priv->account_mgr, priv->session, NULL);
 950         tny_list_append (priv->store_accounts, G_OBJECT(local_account));
 951         g_object_unref (local_account);
 952
 953         /* Add the other remote accounts. Do this after adding the
 954            local account, because we need to add our outboxes to the
 955            global OUTBOX hosted in the local account */
 956         add_existing_accounts (MODEST_TNY_ACCOUNT_STORE (obj));
 957
 958         /* Add connection-specific transport accounts if there are any
 959            accounts available */
 960         if (!only_local_accounts (MODEST_TNY_ACCOUNT_STORE(obj)))
 961                 add_connection_specific_transport_accounts (MODEST_TNY_ACCOUNT_STORE(obj));
 962
 963         /* This is a singleton, so it does not need to be unrefed. */
 964         if (volume_path_is_mounted (g_getenv (MODEST_MMC1_VOLUMEPATH_ENV))) {
 965                 /* It is mounted: */
 966                 add_mmc_account (MODEST_TNY_ACCOUNT_STORE (obj), FALSE /* don't emit the insert signal. */);
 967         }
 968
 969         return MODEST_TNY_ACCOUNT_STORE(obj);
 970 }
 971
 972 static void
 973 modest_tny_account_store_get_accounts  (TnyAccountStore *self,
 974                                         TnyList *list,
 975                                         TnyGetAccountsRequestType request_type)
 976 {
 977         ModestTnyAccountStorePrivate *priv;
 978
 979         g_return_if_fail (self);
 980         g_return_if_fail (TNY_IS_LIST(list));
 981
 982         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 983
 984         switch (request_type) {
 985         case TNY_ACCOUNT_STORE_BOTH:
 986                 tny_list_foreach (priv->store_accounts, foreach_account_append_to_list, list);
 987                 tny_list_foreach (priv->transport_accounts, foreach_account_append_to_list, list);
 988                 break;
 989         case TNY_ACCOUNT_STORE_STORE_ACCOUNTS:
 990                 tny_list_foreach (priv->store_accounts, foreach_account_append_to_list, list);
 991                 break;
 992         case TNY_ACCOUNT_STORE_TRANSPORT_ACCOUNTS:
 993                 tny_list_foreach (priv->transport_accounts, foreach_account_append_to_list, list);
 994                 break;
 995         default:
 996                 g_return_if_reached ();
 997         }
 998
 999         /* Initialize session. Why do we need this ??? */
1000         tny_session_camel_set_initialized (priv->session);
1001 }
1002
1003
1004 static const gchar*
1005 modest_tny_account_store_get_cache_dir (TnyAccountStore *self)
1006 {
1007         ModestTnyAccountStorePrivate *priv;
1008         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1009
1010         if (!priv->cache_dir)
1011                 priv->cache_dir = g_build_filename (g_get_home_dir(),
1012                                                     MODEST_DIR, MODEST_CACHE_DIR, NULL);
1013         return priv->cache_dir;
1014 }
1015
1016
1017 /*
1018  * callers need to unref
1019  */
1020 static TnyDevice*
1021 modest_tny_account_store_get_device (TnyAccountStore *self)
1022 {
1023         ModestTnyAccountStorePrivate *priv;
1024
1025         g_return_val_if_fail (self, NULL);
1026
1027         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1028
1029         if (priv->device)
1030                 return g_object_ref (G_OBJECT(priv->device));
1031         else
1032                 return NULL;
1033 }
1034
1035
1036 static TnyAccount*
1037 modest_tny_account_store_find_account_by_url (TnyAccountStore *self, const gchar* url_string)
1038 {
1039         return modest_tny_account_store_get_tny_account_by (MODEST_TNY_ACCOUNT_STORE (self),
1040                                                             MODEST_TNY_ACCOUNT_STORE_QUERY_URL,
1041                                                             url_string);
1042 }
1043
1044
1045
1046 static gboolean
1047 modest_tny_account_store_alert (TnyAccountStore *self,
1048                                 TnyAccount *account,
1049                                 TnyAlertType type,
1050                                 gboolean question,
1051                                 GError *error)
1052 {
1053         ModestProtocolType protocol_type = MODEST_PROTOCOL_REGISTRY_TYPE_INVALID;
1054         ModestProtocol *protocol = NULL;
1055         const gchar* server_name = "";
1056         gchar *prompt = NULL;
1057         gboolean retval = TRUE;
1058
1059         /* NOTE: account may be NULL in some cases */
1060         g_return_val_if_fail (error, FALSE);
1061
1062         /* Get the server name: */
1063         if (account) {
1064                 server_name = tny_account_get_hostname (account);
1065                 protocol_type = modest_tny_account_get_protocol_type (account);
1066                 if (protocol_type == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID){
1067                         g_warning("modest: %s: account with id=%s has no proto.\n", __FUNCTION__,
1068                                   tny_account_get_id (account));
1069                         return FALSE;
1070                 }
1071                 protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
1072                                                                           protocol_type);
1073         }
1074
1075         switch (error->code) {
1076         case TNY_SYSTEM_ERROR_CANCEL:
1077                 /* Don't show waste the user's time by showing him a dialog telling
1078                  * him that he has just cancelled something: */
1079                 return TRUE;
1080
1081         case TNY_SERVICE_ERROR_PROTOCOL:
1082                 /* Like a BAD from IMAP (protocol error) */
1083         case TNY_SERVICE_ERROR_LOST_CONNECTION:
1084                 /* Lost the connection with the service */
1085         case TNY_SERVICE_ERROR_UNAVAILABLE:
1086                 /* You must be working online for this operation */
1087         case TNY_SERVICE_ERROR_CONNECT:
1088                 if (protocol) {
1089                         prompt = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_CONNECT_ERROR, server_name);
1090                 }
1091                 if (!prompt) {
1092                         g_return_val_if_reached (FALSE);
1093                 }
1094                 break;
1095
1096         case TNY_SERVICE_ERROR_AUTHENTICATE:
1097                 /* It seems that there's no better error to show with
1098                  * POP and IMAP because TNY_SERVICE_ERROR_AUTHENTICATE
1099                  * may appear if there's a timeout during auth */
1100                 if (protocol) {
1101                         prompt = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_AUTH_ERROR, server_name);
1102                 }
1103                 if (!prompt) {
1104                         g_return_val_if_reached (FALSE);
1105                 }
1106                 break;
1107
1108         case TNY_SERVICE_ERROR_CERTIFICATE:
1109                 /* We'll show the proper dialog later */
1110                 break;
1111
1112         case TNY_SYSTEM_ERROR_MEMORY:
1113                 /* Can't allocate memory for this operation */
1114
1115         case TNY_SERVICE_ERROR_UNKNOWN:
1116                 return FALSE;
1117         default:
1118                 g_debug ("Unexpected error %d", error->code);
1119                 g_return_val_if_reached (FALSE);
1120         }
1121
1122
1123         if (error->code == TNY_SERVICE_ERROR_CERTIFICATE)
1124                 retval = modest_platform_run_certificate_confirmation_dialog (server_name,
1125                                                                               error->message);
1126         else if (error->code == TNY_SERVICE_ERROR_AUTHENTICATE) {
1127                 modest_platform_run_information_dialog (NULL, prompt, TRUE);
1128
1129                 /* Show the account dialog if it was wrong */
1130                 if (error->code == TNY_SERVICE_ERROR_CONNECT ||
1131                     error->code == TNY_SERVICE_ERROR_AUTHENTICATE)
1132                         show_wrong_password_dialog (account);
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 void
1505 connection_status_changed (TnyAccount *account,
1506                            TnyConnectionStatus status,
1507                            gpointer data)
1508 {
1509         /* We do this here and not in the connection policy because we
1510            don't want to do it for every account, just for the
1511            accounts that are interactively added when modest is
1512            runnning */
1513         if (status == TNY_CONNECTION_STATUS_CONNECTED) {
1514                 const gchar *account_name;
1515                 ModestWindow *top_window;
1516                 ModestTnyAccountStorePrivate *priv = NULL;
1517
1518                 priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (data);
1519
1520                 /* Remove this handler */
1521                 priv->sighandlers = modest_signal_mgr_disconnect (priv->sighandlers,
1522                                                                   G_OBJECT (account),
1523                                                                   "connection_status_changed");
1524
1525                 /* Perform a send receive */
1526                 account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (account);
1527                 top_window = modest_window_mgr_get_current_top (modest_runtime_get_window_mgr ());
1528                 modest_ui_actions_do_send_receive (account_name, FALSE, FALSE, TRUE, top_window);
1529         }
1530 }
1531
1532 static TnyAccount*
1533 create_tny_account (ModestTnyAccountStore *self,
1534                     const gchar *name,
1535                     TnyAccountType type,
1536                     gboolean notify)
1537 {
1538         TnyAccount *account = NULL;
1539         ModestTnyAccountStorePrivate *priv = NULL;
1540
1541         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1542
1543         account = modest_tny_account_new_from_account (priv->account_mgr,
1544                                                        name, type,
1545                                                        priv->session,
1546                                                        get_password,
1547                                                        forget_password);
1548
1549         if (account) {
1550                 /* Forget any cached password for the account, so that
1551                    we use a new account if any */
1552                 forget_password_in_memory (self, tny_account_get_id (account));
1553
1554                 /* Install a signal handler that will refresh the
1555                    account the first time it becomes online. Do this
1556                    only if we're adding a new account while the
1557                    program is running (we do not want to do this
1558                    allways) */
1559                 if (type == TNY_ACCOUNT_TYPE_STORE && notify)
1560                         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
1561                                                                        G_OBJECT (account),
1562                                                                        "connection_status_changed",
1563                                                                        G_CALLBACK (connection_status_changed),
1564                                                                        self);
1565
1566                 /* Set the account store */
1567                 g_object_set_data (G_OBJECT(account), "account_store", self);
1568         } else {
1569                 g_printerr ("modest: failed to create account for %s\n", name);
1570         }
1571
1572         return account;
1573 }
1574
1575 typedef struct _AddOutboxInfo {
1576         ModestTnyAccountStore *account_store;
1577         TnyAccount *transport_account;
1578 } AddOutboxInfo;
1579
1580 static void
1581 add_outbox_from_transport_account_to_global_outbox_get_folders_cb (TnyFolderStore *folder_store,
1582                                                                    gboolean cancelled,
1583                                                                    TnyList *list,
1584                                                                    GError *err,
1585                                                                    gpointer userdata)
1586 {
1587         TnyIterator *iter_folders;
1588         TnyFolder *per_account_outbox;
1589         TnyAccount *local_account = NULL;
1590         AddOutboxInfo *info = (AddOutboxInfo *) userdata;
1591         ModestTnyAccountStorePrivate *priv = NULL;
1592         ModestTnyAccountStore *self;
1593
1594         self = MODEST_TNY_ACCOUNT_STORE (info->account_store);
1595         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1596
1597         /* Note that this could happen if there is not enough space
1598            available on disk, then the outbox folder could not be
1599            created */
1600         if (tny_list_get_length (list) != 1) {
1601                 g_warning ("%s: could not create outbox folder (%d folders found)", __FUNCTION__,
1602                            tny_list_get_length (list));
1603                 goto frees;
1604         }
1605
1606         iter_folders = tny_list_create_iterator (list);
1607         per_account_outbox = TNY_FOLDER (tny_iterator_get_current (iter_folders));
1608         g_object_unref (iter_folders);
1609         g_object_unref (list);
1610
1611         /* Add the outbox of the new per-account-local-outbox account
1612            to the global local merged OUTBOX of the local folders
1613            account */
1614         local_account = modest_tny_account_store_get_local_folders_account (info->account_store);
1615         modest_tny_local_folders_account_add_folder_to_outbox (MODEST_TNY_LOCAL_FOLDERS_ACCOUNT (local_account),
1616                                                                per_account_outbox);
1617         /* Add the pair to the hash table */
1618         g_hash_table_insert (priv->outbox_of_transport,
1619                              info->transport_account,
1620                              per_account_outbox);
1621
1622         /* Notify that the local account changed */
1623         g_signal_emit (G_OBJECT (self), signals [ACCOUNT_CHANGED_SIGNAL], 0, local_account);
1624         g_object_unref (local_account);
1625         g_object_unref (per_account_outbox);
1626
1627  frees:
1628         g_object_unref (info->transport_account);
1629         g_slice_free (AddOutboxInfo, info);
1630 }
1631
1632
1633 static void
1634 add_outbox_from_transport_account_to_global_outbox (ModestTnyAccountStore *self,
1635                                                     const gchar *account_name,
1636                                                     TnyAccount *transport_account)
1637 {
1638         TnyList *folders = NULL;
1639         TnyAccount *account_outbox = NULL;
1640         ModestTnyAccountStorePrivate *priv = NULL;
1641         AddOutboxInfo *info;
1642
1643         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1644
1645         /* Create per account local outbox */
1646         account_outbox =
1647                 modest_tny_account_new_for_per_account_local_outbox_folder (priv->account_mgr,
1648                                                                             account_name,
1649                                                                             priv->session);
1650
1651         if (!G_IS_OBJECT (account_outbox)) {
1652                 g_warning ("%s: could not create per account local outbox folder", __FUNCTION__);
1653                 return;
1654         }
1655
1656         tny_list_append (priv->store_accounts_outboxes, G_OBJECT (account_outbox));
1657
1658         /* Get the outbox folder */
1659         folders = tny_simple_list_new ();
1660         info = g_slice_new0 (AddOutboxInfo);
1661         info->account_store = self;
1662         info->transport_account = g_object_ref (transport_account);
1663         tny_folder_store_get_folders_async (TNY_FOLDER_STORE (account_outbox), folders, NULL, FALSE,
1664                                             add_outbox_from_transport_account_to_global_outbox_get_folders_cb, NULL, (gpointer) info);
1665         g_object_unref (account_outbox);
1666 }
1667
1668 /*
1669  * This function will be used for both adding new accounts and for the
1670  * initialization. In the initialization we do not want to emit
1671  * signals so notify will be FALSE, in the case of account additions
1672  * we do want to notify the observers
1673  */
1674 static void
1675 insert_account (ModestTnyAccountStore *self,
1676                 const gchar *account,
1677                 gboolean notify)
1678 {
1679         ModestTnyAccountStorePrivate *priv = NULL;
1680         TnyAccount *store_account = NULL, *transport_account = NULL;
1681
1682         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1683
1684         /* Get the server and the transport account */
1685         store_account = create_tny_account (self, account, TNY_ACCOUNT_TYPE_STORE, notify);
1686         if (!store_account || !TNY_IS_ACCOUNT(store_account)) {
1687                 g_warning ("%s: failed to create store account", __FUNCTION__);
1688                 return;
1689         }
1690
1691         transport_account = create_tny_account (self, account, TNY_ACCOUNT_TYPE_TRANSPORT, notify);
1692         if (!transport_account || !TNY_IS_ACCOUNT(transport_account)) {
1693                 g_warning ("%s: failed to create transport account", __FUNCTION__);
1694                 g_object_unref (store_account);
1695                 return;
1696         }
1697
1698         /* Add accounts to the lists */
1699         tny_list_append (priv->store_accounts, G_OBJECT (store_account));
1700         tny_list_append (priv->transport_accounts, G_OBJECT (transport_account));
1701
1702         /* Create a new pseudo-account with an outbox for this
1703            transport account and add it to the global outbox
1704            in the local account */
1705         add_outbox_from_transport_account_to_global_outbox (self, account, transport_account);
1706
1707         /* Notify the observers. We do it after everything is
1708            created */
1709         if (notify) {
1710                 g_signal_emit (G_OBJECT (self), signals [ACCOUNT_INSERTED_SIGNAL], 0, store_account);
1711                 g_signal_emit (G_OBJECT (self), signals [ACCOUNT_INSERTED_SIGNAL], 0, transport_account);
1712         }
1713
1714         /* Frees */
1715         g_object_unref (store_account);
1716         g_object_unref (transport_account);
1717 }
1718
1719 static inline gboolean
1720 only_local_accounts (ModestTnyAccountStore *self)
1721 {
1722         return (modest_tny_account_store_get_num_remote_accounts (self) > 0) ? FALSE : TRUE;
1723 }
1724
1725 static void
1726 on_account_inserted (ModestAccountMgr *acc_mgr,
1727                      const gchar *account,
1728                      gpointer user_data)
1729 {
1730         gboolean add_specific;
1731
1732         add_specific = only_local_accounts (MODEST_TNY_ACCOUNT_STORE (user_data));
1733
1734         /* Insert the account and notify the observers */
1735         insert_account (MODEST_TNY_ACCOUNT_STORE (user_data), account, TRUE);
1736
1737         /* If it's the first remote account then add the connection
1738            specific SMTP servers as well */
1739         if (add_specific)
1740                 add_connection_specific_transport_accounts (MODEST_TNY_ACCOUNT_STORE (user_data));
1741
1742 }
1743
1744 /* This is the callback of the tny_camel_account_set_online called in
1745    on_account_removed to disconnect the account */
1746 static void
1747 on_account_disconnect_when_removing (TnyCamelAccount *account,
1748                                      gboolean canceled,
1749                                      GError *err,
1750                                      gpointer user_data)
1751 {
1752         ModestTnyAccountStore *self;
1753         ModestTnyAccountStorePrivate *priv;
1754
1755         self = MODEST_TNY_ACCOUNT_STORE (user_data);
1756         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
1757
1758         /* Remove the connection-status-changed handler if it's still there */
1759         if (modest_signal_mgr_is_connected (priv->sighandlers,
1760                                             G_OBJECT (account),
1761                                             "connection_status_changed")) {
1762                 priv->sighandlers = modest_signal_mgr_disconnect (priv->sighandlers,
1763                                                                   G_OBJECT (account),
1764                                                                   "connection_status_changed");
1765         }
1766
1767         /* Cancel all pending operations */
1768         tny_account_cancel (TNY_ACCOUNT (account));
1769
1770         /* Unref the extra reference added by get_server_account */
1771         g_object_unref (account);
1772
1773         /* Clear the cache if it's an store account */
1774         if (TNY_IS_STORE_ACCOUNT (account)) {
1775                 tny_store_account_delete_cache (TNY_STORE_ACCOUNT (account));
1776         } else if (TNY_IS_TRANSPORT_ACCOUNT (account)) {
1777                 ModestTnySendQueue* send_queue;
1778                 send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT (account), FALSE);
1779                 if (TNY_IS_SEND_QUEUE (send_queue)) {
1780                         if (modest_tny_send_queue_sending_in_progress (send_queue))
1781                                 tny_send_queue_cancel (TNY_SEND_QUEUE (send_queue),
1782                                                        TNY_SEND_QUEUE_CANCEL_ACTION_REMOVE,
1783                                                        NULL);
1784                         modest_runtime_remove_send_queue (TNY_TRANSPORT_ACCOUNT (account));
1785                 }
1786         }
1787 }
1788
1789 /*
1790  * We use this one for both removing "normal" and "connection
1791  * specific" transport accounts
1792  */
1793 static void
1794 remove_transport_account (ModestTnyAccountStore *self,
1795                           TnyTransportAccount *transport_account)
1796 {
1797         ModestTnyAccountStorePrivate *priv;
1798         TnyFolder *outbox = NULL;
1799
1800         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
1801
1802         /* Remove it from the list of accounts and notify the
1803            observers. Do not need to wait for account
1804            disconnection */
1805         g_signal_emit (G_OBJECT (self), signals [ACCOUNT_REMOVED_SIGNAL], 0, transport_account);
1806         tny_list_remove (priv->transport_accounts, (GObject *) transport_account);
1807
1808         /* Remove the OUTBOX of the account from the global outbox */
1809         outbox = g_hash_table_lookup (priv->outbox_of_transport, transport_account);
1810
1811         if (TNY_IS_FOLDER (outbox)) {
1812                 TnyAccount *local_account = NULL;
1813                 TnyAccount *outbox_account = tny_folder_get_account (outbox);
1814
1815                 if (outbox_account) {
1816                         tny_list_remove (priv->store_accounts_outboxes, G_OBJECT (outbox_account));
1817                         /* Remove existing emails to send */
1818                         tny_store_account_delete_cache (TNY_STORE_ACCOUNT (outbox_account));
1819                         g_object_unref (outbox_account);
1820                 }
1821
1822                 local_account = modest_tny_account_store_get_local_folders_account (self);
1823                 modest_tny_local_folders_account_remove_folder_from_outbox (MODEST_TNY_LOCAL_FOLDERS_ACCOUNT (local_account),
1824                                                                             outbox);
1825
1826                 g_hash_table_remove (priv->outbox_of_transport, transport_account);
1827
1828                 /* Notify the change in the local account */
1829                 g_signal_emit (G_OBJECT (self), signals [ACCOUNT_CHANGED_SIGNAL], 0, local_account);
1830                 g_object_unref (local_account);
1831         } else {
1832                 g_warning ("Removing a transport account that has no outbox");
1833         }
1834
1835         /* Cancel all pending operations */
1836         tny_account_cancel (TNY_ACCOUNT (transport_account));
1837
1838         /* Disconnect and notify the observers. The callback will free the reference */
1839         tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (transport_account), FALSE,
1840                                       on_account_disconnect_when_removing, self);
1841 }
1842
1843 static gboolean
1844 images_cache_remove_filter (TnyStreamCache *self, const gchar *id, const gchar *account_name)
1845 {
1846         gchar *account_name_with_separator;
1847         gboolean result;
1848         if (account_name == NULL || account_name[0] == '\0')
1849                 return FALSE;
1850
1851         if (id == NULL || id[0] == '\0')
1852                 return FALSE;
1853
1854         account_name_with_separator = g_strconcat (account_name, "__", NULL);
1855
1856         result = (g_str_has_prefix (id, account_name));
1857         g_free (account_name_with_separator);
1858
1859         return result;
1860 }
1861
1862 static void
1863 on_account_removed (ModestAccountMgr *acc_mgr,
1864                     const gchar *account,
1865                     gpointer user_data)
1866 {
1867         TnyAccount *store_account = NULL, *transport_account = NULL;
1868         ModestTnyAccountStore *self;
1869         ModestTnyAccountStorePrivate *priv;
1870         TnyStreamCache *stream_cache;
1871
1872         self = MODEST_TNY_ACCOUNT_STORE (user_data);
1873         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
1874
1875         /* Get the server and the transport account */
1876         store_account =
1877                 modest_tny_account_store_get_server_account (self, account,
1878                                                              TNY_ACCOUNT_TYPE_STORE);
1879         transport_account =
1880                 modest_tny_account_store_get_server_account (self, account,
1881                                                              TNY_ACCOUNT_TYPE_TRANSPORT);
1882
1883         /* If there was any problem creating the account, for example,
1884            with the configuration system this could not exist */
1885         if (TNY_IS_STORE_ACCOUNT(store_account)) {
1886                 /* Forget any cached password for the account */
1887                 forget_password_in_memory (self, tny_account_get_id (store_account));
1888
1889                 /* Remove it from the list of accounts and notify the
1890                    observers. Do not need to wait for account
1891                    disconnection */
1892                 tny_list_remove (priv->store_accounts, (GObject *) store_account);
1893                 g_signal_emit (G_OBJECT (self), signals [ACCOUNT_REMOVED_SIGNAL], 0, store_account);
1894
1895                 /* Cancel all pending operations */
1896                 tny_account_cancel (TNY_ACCOUNT (store_account));
1897
1898                 /* Disconnect before deleting the cache, because the
1899                    disconnection will rewrite the cache to the
1900                    disk */
1901                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (store_account), FALSE,
1902                                               on_account_disconnect_when_removing, self);
1903         } else {
1904                 g_warning ("%s: no store account for account %s\n",
1905                            __FUNCTION__, account);
1906         }
1907
1908         /* If there was any problem creating the account, for example,
1909            with the configuration system this could not exist */
1910         if (TNY_IS_TRANSPORT_ACCOUNT(transport_account)) {
1911
1912                 /* Forget any cached password for the account */
1913                 forget_password_in_memory (self, tny_account_get_id (transport_account));
1914
1915                 /* Remove transport account. It'll free the reference
1916                    added by get_server_account */
1917                 remove_transport_account (self, TNY_TRANSPORT_ACCOUNT (transport_account));
1918         } else {
1919                 g_warning ("%s: no transport account for account %s\n",
1920                            __FUNCTION__, account);
1921         }
1922
1923         /* Remove cached images */
1924         stream_cache = modest_runtime_get_images_cache ();
1925         tny_stream_cache_remove (stream_cache, (TnyStreamCacheRemoveFilter) images_cache_remove_filter, (gpointer) account);
1926
1927         /* If there are no more user accounts then delete the
1928            transport specific SMTP servers */
1929         if (only_local_accounts (self))
1930                 remove_connection_specific_transport_accounts (self);
1931 }
1932
1933 TnyTransportAccount *
1934 modest_tny_account_store_new_connection_specific_transport_account (ModestTnyAccountStore *self,
1935                                                                     const gchar *name)
1936 {
1937         ModestTnyAccountStorePrivate *priv = NULL;
1938         TnyAccount * tny_account = NULL;
1939
1940         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1941
1942         /* Add the account: */
1943         tny_account =
1944                 modest_tny_account_new_from_server_account_name (priv->account_mgr,
1945                                                                  priv->session,
1946                                                                  name,
1947                                                                  get_password,
1948                                                                  forget_password);
1949         if (tny_account) {
1950                 g_object_set_data (G_OBJECT(tny_account),
1951                                    "account_store",
1952                                    (gpointer)self);
1953                 g_object_set_data (G_OBJECT(tny_account),
1954                                    "connection_specific",
1955                                    GINT_TO_POINTER (TRUE));
1956
1957                 tny_list_append (priv->transport_accounts, G_OBJECT (tny_account));
1958                 add_outbox_from_transport_account_to_global_outbox (self,
1959                                                                     name,
1960                                                                     tny_account);
1961
1962         } else
1963                 g_printerr ("modest: failed to create smtp-specific account for %s\n",
1964                             name);
1965
1966         return TNY_TRANSPORT_ACCOUNT (tny_account);
1967 }
1968
1969 static void
1970 foreach_free_string(gpointer data,
1971                     gpointer user_data)
1972 {
1973         g_free (data);
1974 }
1975
1976 static void
1977 add_connection_specific_transport_accounts (ModestTnyAccountStore *self)
1978 {
1979         ModestTnyAccountStorePrivate *priv = NULL;
1980         GSList *list_specifics = NULL, *iter = NULL;
1981         GError *err = NULL;
1982
1983         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
1984
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                         TnyTransportAccount * account = NULL;
2003                         account = modest_tny_account_store_new_connection_specific_transport_account (
2004                                 self, transport_account_name);
2005                         if (account)
2006                                 g_object_unref (account);
2007                 }
2008                 iter = g_slist_next (iter);
2009         }
2010
2011         /* Free the list */
2012         g_slist_foreach (list_specifics, foreach_free_string, NULL);
2013         g_slist_free (list_specifics);
2014 }
2015
2016 static void
2017 remove_connection_specific_transport_accounts (ModestTnyAccountStore *self)
2018 {
2019         ModestTnyAccountStorePrivate *priv = NULL;
2020         GSList *list_specifics = NULL, *iter = NULL;
2021         GError *err = NULL;
2022
2023         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
2024
2025         err = NULL;
2026         list_specifics = modest_conf_get_list (modest_runtime_get_conf (),
2027                                                MODEST_CONF_CONNECTION_SPECIFIC_SMTP_LIST,
2028                                                MODEST_CONF_VALUE_STRING, &err);
2029         if (err) {
2030                 g_error_free (err);
2031                 g_return_if_reached ();
2032                 return;
2033         }
2034
2035         /* Look at each connection-specific transport account for the
2036          * modest account: */
2037         iter = list_specifics;
2038         while (iter) {
2039                 /* The list alternates between the connection name and the transport name: */
2040                 iter = g_slist_next (iter);
2041                 if (iter) {
2042                         const gchar* transport_account_name = (const gchar*) (iter->data);
2043                         TnyAccount * account;
2044                         account = modest_tny_account_store_get_server_account (self,
2045                                                                                transport_account_name,
2046                                                                                TNY_ACCOUNT_TYPE_TRANSPORT);
2047
2048                         /* the call will free the reference */
2049                         if (account)
2050                                 remove_transport_account (self, TNY_TRANSPORT_ACCOUNT (account));
2051                 }
2052                 iter = g_slist_next (iter);
2053         }
2054
2055         /* Free the list */
2056         g_slist_foreach (list_specifics, foreach_free_string, NULL);
2057         g_slist_free (list_specifics);
2058 }
2059
2060
2061 TnyMsg *
2062 modest_tny_account_store_find_msg_in_outboxes (ModestTnyAccountStore *self,
2063                                                const gchar *uri,
2064                                                TnyAccount **ac_out)
2065 {
2066         TnyIterator *acc_iter;
2067         ModestTnyAccountStorePrivate *priv;
2068         TnyMsg *msg = NULL;
2069         TnyAccount *msg_account = NULL;
2070
2071         g_return_val_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (self), NULL);
2072         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
2073
2074         acc_iter = tny_list_create_iterator (priv->store_accounts_outboxes);
2075         while (!msg && !tny_iterator_is_done (acc_iter)) {
2076                 TnyList *folders = tny_simple_list_new ();
2077                 TnyAccount *account = TNY_ACCOUNT (tny_iterator_get_current (acc_iter));
2078                 TnyIterator *folders_iter = NULL;
2079
2080                 tny_folder_store_get_folders (TNY_FOLDER_STORE (account), folders, NULL, FALSE, NULL);
2081                 folders_iter = tny_list_create_iterator (folders);
2082
2083                 while (msg == NULL && !tny_iterator_is_done (folders_iter)) {
2084                         TnyFolder *folder = TNY_FOLDER (tny_iterator_get_current (folders_iter));
2085                         msg = tny_folder_find_msg (folder, uri, NULL);
2086
2087                         if (msg)
2088                                 msg_account = g_object_ref (account);
2089
2090                         g_object_unref (folder);
2091                         tny_iterator_next (folders_iter);
2092                 }
2093                 g_object_unref (folders_iter);
2094
2095                 g_object_unref (folders);
2096                 g_object_unref (account);
2097                 tny_iterator_next (acc_iter);
2098         }
2099
2100         g_object_unref (acc_iter);
2101
2102         if (ac_out != NULL)
2103                 *ac_out = msg_account;
2104
2105         return msg;
2106 }
2107
2108 TnyTransportAccount *
2109 modest_tny_account_store_get_transport_account_from_outbox_header(ModestTnyAccountStore *self, TnyHeader *header)
2110 {
2111         TnyIterator *acc_iter;
2112         ModestTnyAccountStorePrivate *priv;
2113         TnyTransportAccount *header_acc = NULL;
2114         gchar *msg_id;
2115
2116         g_return_val_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (self), NULL);
2117         g_return_val_if_fail (TNY_IS_HEADER (header), NULL);
2118         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
2119         msg_id = modest_tny_send_queue_get_msg_id (header);
2120         acc_iter = tny_list_create_iterator (priv->transport_accounts);
2121         while (!header_acc && !tny_iterator_is_done (acc_iter)) {
2122                 TnyTransportAccount *account = TNY_TRANSPORT_ACCOUNT (tny_iterator_get_current (acc_iter));
2123                 ModestTnySendQueue *send_queue;
2124                 ModestTnySendQueueStatus status;
2125                 send_queue = modest_runtime_get_send_queue(TNY_TRANSPORT_ACCOUNT(account), TRUE);
2126                 if (TNY_IS_SEND_QUEUE (send_queue)) {
2127                         status = modest_tny_send_queue_get_msg_status(send_queue, msg_id);
2128                         if (status != MODEST_TNY_SEND_QUEUE_UNKNOWN)
2129                                 header_acc = g_object_ref(account);
2130                 }
2131                 g_object_unref (account);
2132                 tny_iterator_next (acc_iter);
2133         }
2134         g_object_unref(acc_iter);
2135         g_free (msg_id);
2136
2137         /* New reference */
2138         return header_acc;
2139 }
2140
2141 typedef struct {
2142         ModestTnyAccountStore *account_store;
2143         ModestTnyAccountStoreShutdownCallback callback;
2144         gpointer userdata;
2145         gint pending;
2146 } ShutdownOpData;
2147
2148 static void
2149 account_shutdown_callback (TnyCamelAccount *account, gboolean canceled, GError *err, gpointer userdata)
2150 {
2151         ShutdownOpData *op_data = (ShutdownOpData *) userdata;
2152         op_data->pending--;
2153         if (op_data->pending == 0) {
2154                 if (op_data->callback)
2155                         op_data->callback (op_data->account_store, op_data->userdata);
2156                 g_object_unref (op_data->account_store);
2157                 g_free (op_data);
2158         } else {
2159                 g_object_unref (op_data->account_store);
2160         }
2161 }
2162
2163 static void
2164 account_shutdown (TnyAccount *account, ShutdownOpData *op_data)
2165 {
2166         g_return_if_fail (account && TNY_IS_ACCOUNT(account));
2167
2168         if (TNY_IS_STORE_ACCOUNT (account) &&
2169             !modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account)))
2170                 goto frees;
2171
2172         /* Disconnect account */
2173         if (tny_account_get_connection_status (account) == TNY_CONNECTION_STATUS_CONNECTED) {
2174                 tny_camel_account_set_online (TNY_CAMEL_ACCOUNT(account), FALSE,
2175                                               account_shutdown_callback, op_data);
2176                 return;
2177         }
2178
2179  frees:
2180         op_data->pending--;
2181         g_object_unref (op_data->account_store);
2182 }
2183
2184
2185 void
2186 modest_tny_account_store_shutdown (ModestTnyAccountStore *self,
2187                                    ModestTnyAccountStoreShutdownCallback callback,
2188                                    gpointer userdata)
2189 {
2190         gint i, num_accounts;
2191         ShutdownOpData *op_data;
2192         ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
2193
2194         /* Get references */
2195         num_accounts = tny_list_get_length (priv->store_accounts) +
2196                 tny_list_get_length (priv->transport_accounts);
2197         for (i = 0 ; i < num_accounts ; i++)
2198                 g_object_ref (self);
2199
2200         /* Create the helper object */
2201         op_data = g_new0 (ShutdownOpData, 1);
2202         op_data->callback = callback;
2203         op_data->userdata = userdata;
2204         op_data->pending = num_accounts;
2205         op_data->account_store = self;
2206
2207         /* Destroy all accounts. Disconnect all accounts before they are destroyed */
2208         if (priv->store_accounts) {
2209                 tny_list_foreach (priv->store_accounts, (GFunc)account_shutdown, op_data);
2210         }
2211
2212         if (priv->transport_accounts) {
2213                 tny_list_foreach (priv->transport_accounts, (GFunc)account_shutdown, op_data);
2214         }
2215
2216         if (op_data->pending == 0) {
2217                 if (op_data->callback)
2218                         op_data->callback (op_data->account_store, op_data->userdata);
2219                 g_free (op_data);
2220         }
2221 }
2222
2223 gboolean
2224 modest_tny_account_store_is_send_mail_blocked (ModestTnyAccountStore *self)
2225 {
2226         ModestTnyAccountStorePrivate *priv;
2227
2228         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
2229
2230         return priv->send_mail_blocked;
2231 }
2232
2233 void
2234 modest_tny_account_store_set_send_mail_blocked (ModestTnyAccountStore *self,
2235                                                 gboolean blocked)
2236 {
2237         ModestTnyAccountStorePrivate *priv;
2238
2239         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
2240
2241         priv->send_mail_blocked = blocked;
2242 }
2243
2244 static void
2245 count_remote_accounts (gpointer data, gpointer user_data)
2246 {
2247         TnyFolderStore *account = TNY_FOLDER_STORE (data);
2248         gint *count = (gint *) user_data;
2249
2250         if (modest_tny_folder_store_is_remote (account))
2251                 (*count)++;
2252 }
2253
2254 guint
2255 modest_tny_account_store_get_num_remote_accounts (ModestTnyAccountStore *self)
2256 {
2257         ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
2258         gint count = 0;
2259
2260         /* Count remote accounts */
2261         tny_list_foreach (priv->store_accounts, (GFunc) count_remote_accounts, &count);
2262
2263         return count;
2264 }