2007-04-27 Murray Cumming <murrayc@murrayc.com>
[modest] / 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-account.h>
34 #include <tny-account-store.h>
35 #include <tny-store-account.h>
36 #include <tny-transport-account.h>
37 #include <tny-simple-list.h>
38 #include <tny-account-store.h>
39 #include <tny-maemo-conic-device.h> /* For ConIcIap */
40 #include <tny-camel-transport-account.h>
41 #include <tny-camel-imap-store-account.h>
42 #include <tny-camel-pop-store-account.h>
43 #include <modest-runtime.h>
44 #include <modest-marshal.h>
45 #include <modest-protocol-info.h>
46 #include <modest-local-folder-info.h>
47 #include <modest-tny-account.h>
48 #include <modest-account-mgr.h>
49 #include <modest-account-mgr-helpers.h>
50
51 #include "modest-tny-account-store.h"
52 #include "modest-tny-platform-factory.h"
53 #include <tny-gtk-lockable.h>
54 #include <camel/camel.h>
55
56 /* 'private'/'protected' functions */
57 static void modest_tny_account_store_class_init   (ModestTnyAccountStoreClass *klass);
58 //static void modest_tny_account_store_init         (ModestTnyAccountStore *obj);
59 static void modest_tny_account_store_finalize     (GObject *obj);
60
61 /* implementations for tny-account-store-iface */
62 static void    modest_tny_account_store_instance_init (ModestTnyAccountStore *obj);
63 static void    modest_tny_account_store_init          (gpointer g, gpointer iface_data);
64
65
66 /* list my signals */
67 enum {
68         ACCOUNT_UPDATE_SIGNAL,
69         PASSWORD_REQUESTED_SIGNAL,
70         LAST_SIGNAL
71 };
72
73 typedef struct _ModestTnyAccountStorePrivate ModestTnyAccountStorePrivate;
74 struct _ModestTnyAccountStorePrivate {
75         gchar              *cache_dir;  
76         GHashTable         *password_hash;
77         ModestAccountMgr   *account_mgr;
78         TnySessionCamel    *session;
79         TnyDevice          *device;
80         
81         /* we cache them here */
82         GSList             *store_accounts;
83         GSList             *transport_accounts;
84 };
85
86 #define MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
87                                                       MODEST_TYPE_TNY_ACCOUNT_STORE, \
88                                                       ModestTnyAccountStorePrivate))
89
90 /* globals */
91 static GObjectClass *parent_class = NULL;
92
93 static guint signals[LAST_SIGNAL] = {0};
94
95 GType
96 modest_tny_account_store_get_type (void)
97 {
98         static GType my_type = 0;
99
100         if (!my_type) {
101                 static const GTypeInfo my_info = {
102                         sizeof(ModestTnyAccountStoreClass),
103                         NULL,           /* base init */
104                         NULL,           /* base finalize */
105                         (GClassInitFunc) modest_tny_account_store_class_init,
106                         NULL,           /* class finalize */
107                         NULL,           /* class data */
108                         sizeof(ModestTnyAccountStore),
109                         0,              /* n_preallocs */
110                         (GInstanceInitFunc) modest_tny_account_store_instance_init,
111                         NULL
112                 };
113
114                 static const GInterfaceInfo iface_info = {
115                         (GInterfaceInitFunc) modest_tny_account_store_init,
116                         NULL,         /* interface_finalize */
117                         NULL          /* interface_data */
118                 };
119                 /* hack hack */
120                 my_type = g_type_register_static (G_TYPE_OBJECT,
121                                                   "ModestTnyAccountStore",
122                                                   &my_info, 0);
123                 g_type_add_interface_static (my_type, TNY_TYPE_ACCOUNT_STORE,
124                                              &iface_info);
125         }
126         return my_type;
127 }
128
129 static void
130 modest_tny_account_store_class_init (ModestTnyAccountStoreClass *klass)
131 {
132         GObjectClass *gobject_class;
133         gobject_class = (GObjectClass*) klass;
134
135         parent_class            = g_type_class_peek_parent (klass);
136         gobject_class->finalize = modest_tny_account_store_finalize;
137
138         g_type_class_add_private (gobject_class,
139                                   sizeof(ModestTnyAccountStorePrivate));
140
141          signals[ACCOUNT_UPDATE_SIGNAL] =
142                 g_signal_new ("account_update",
143                               G_TYPE_FROM_CLASS (gobject_class),
144                               G_SIGNAL_RUN_FIRST,
145                               G_STRUCT_OFFSET(ModestTnyAccountStoreClass, account_update),
146                               NULL, NULL,
147                               g_cclosure_marshal_VOID__STRING,
148                               G_TYPE_NONE, 1, G_TYPE_STRING);
149          
150          signals[PASSWORD_REQUESTED_SIGNAL] =
151                  g_signal_new ("password_requested",
152                                G_TYPE_FROM_CLASS (gobject_class),
153                                G_SIGNAL_RUN_FIRST,
154                                G_STRUCT_OFFSET(ModestTnyAccountStoreClass, password_requested),
155                                NULL, NULL,
156                                modest_marshal_VOID__STRING_POINTER_POINTER_POINTER,
157                                G_TYPE_NONE, 4, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_POINTER,
158                                G_TYPE_POINTER);
159 }
160
161
162 static void
163 modest_tny_account_store_instance_init (ModestTnyAccountStore *obj)
164 {
165         ModestTnyAccountStorePrivate *priv =
166                 MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(obj);
167
168         priv->cache_dir              = NULL;
169         priv->account_mgr            = NULL;
170         priv->session                = NULL;
171         priv->device                 = NULL;
172         
173         priv->password_hash          = g_hash_table_new_full (g_str_hash, g_str_equal,
174                                                               g_free, g_free);
175 }
176
177
178
179 static void
180 account_list_free (GSList *accounts)
181 {
182         GSList *cursor = accounts;
183
184         while (cursor) {
185                 /* TODO: This uses cursor->data after causing it to be freed,
186                  * as valgrind shows.
187                  * It's not clear what is being attempted here. murrayc */
188                 g_object_unref (G_OBJECT(cursor->data));
189                 if (G_IS_OBJECT(cursor->data)) { /* check twice... */
190                         const gchar *id = tny_account_get_id(TNY_ACCOUNT(cursor->data));
191                         modest_runtime_verify_object_death(cursor->data,id);
192                 }                       
193                 cursor = cursor->next;
194         }
195         g_slist_free (accounts);
196 }
197
198
199 static void
200 on_account_removed (ModestAccountMgr *acc_mgr, const gchar *account, gboolean server_account,
201                     gpointer user_data)
202 {
203         ModestTnyAccountStore *self        = MODEST_TNY_ACCOUNT_STORE(user_data);
204         ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
205
206         /* FIXME: make this more finegrained; changes do not really affect _all_
207          * accounts, and some do not affect tny accounts at all (such as 'last_update')
208          */
209         
210         
211         account_list_free (priv->store_accounts);
212         priv->store_accounts = NULL;
213         
214         account_list_free (priv->transport_accounts);
215         priv->transport_accounts = NULL;
216         
217         g_signal_emit (G_OBJECT(self), signals[ACCOUNT_UPDATE_SIGNAL], 0,
218                        account);
219 }
220
221
222 static void
223 on_account_changed (ModestAccountMgr *acc_mgr, const gchar *account, gboolean server_account,
224                     const gchar *key, gpointer user_data)
225 {
226         ModestTnyAccountStore *self = MODEST_TNY_ACCOUNT_STORE(user_data);
227         ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
228         
229         /* FIXME: make this more finegrained; changes do not really affect _all_
230          * accounts, and some do not affect tny accounts at all (such as 'last_update')
231          */
232         if (priv->store_accounts) {
233                 account_list_free (priv->store_accounts);
234                 priv->store_accounts = NULL;
235         }
236         
237         if (priv->transport_accounts) {
238                 account_list_free (priv->transport_accounts);
239                 priv->transport_accounts = NULL;
240         }
241
242         g_signal_emit (G_OBJECT(self), signals[ACCOUNT_UPDATE_SIGNAL], 0,
243                        account);
244 }
245
246
247 static ModestTnyAccountStore*
248 get_account_store_for_account (TnyAccount *account)
249 {
250         return MODEST_TNY_ACCOUNT_STORE(g_object_get_data (G_OBJECT(account),
251                                                            "account_store"));
252 }
253
254 static gchar*
255 get_password (TnyAccount *account, const gchar *prompt, gboolean *cancel)
256 {
257         const gchar *key;
258         const TnyAccountStore *account_store;
259         ModestTnyAccountStore *self;
260         ModestTnyAccountStorePrivate *priv;
261         gchar *pwd = NULL;
262         gpointer pwd_ptr;
263         gboolean already_asked;
264         
265         key           = tny_account_get_id (account);
266         account_store = TNY_ACCOUNT_STORE(get_account_store_for_account (account));
267         
268         self = MODEST_TNY_ACCOUNT_STORE (account_store);
269         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
270         
271         /* is it in the hash? if it's already there, it must be wrong... */
272         pwd_ptr = (gpointer)&pwd; /* pwd_ptr so the compiler does not complained about
273                                    * type-punned ptrs...*/
274         already_asked = g_hash_table_lookup_extended (priv->password_hash,
275                                                       key,
276                                                       NULL,
277                                                       (gpointer*)&pwd_ptr);
278
279         /* if the password is not already there, try ModestConf */
280         if (!already_asked) {
281                 pwd  = modest_account_mgr_get_string (priv->account_mgr,
282                                                       key, MODEST_ACCOUNT_PASSWORD,TRUE);
283                 g_hash_table_insert (priv->password_hash, g_strdup (key), g_strdup (pwd));
284         }
285
286         /* if it was already asked, it must have been wrong, so ask again */
287         if (already_asked || !pwd || strlen(pwd) == 0) {
288
289                 /* we don't have it yet. Get the password from the user */
290                 const gchar* name = tny_account_get_name (account);
291                 gboolean remember = FALSE;
292                 pwd = NULL;
293                 
294                 g_signal_emit (G_OBJECT(self), signals[PASSWORD_REQUESTED_SIGNAL], 0,
295                                name, &pwd, cancel, &remember);
296                 
297                 if (!*cancel) {
298                         if (remember)
299                                 modest_account_mgr_set_string (priv->account_mgr,key,
300                                                                MODEST_ACCOUNT_PASSWORD,
301                                                                pwd, TRUE);
302                         /* We need to dup the string even knowing that
303                            it's already a dup of the contents of an
304                            entry, because it if it's wrong, then camel
305                            will free it */
306                         g_hash_table_insert (priv->password_hash, g_strdup (key), g_strdup(pwd));
307                 } else {
308                         g_hash_table_remove (priv->password_hash, key);
309                         g_free (pwd);
310                         pwd = NULL;
311                 }
312         } else
313                 *cancel = FALSE;
314  
315         return pwd;
316 }
317
318
319 static void
320 forget_password (TnyAccount *account)
321 {
322         ModestTnyAccountStore *self;
323         ModestTnyAccountStorePrivate *priv;
324         const TnyAccountStore *account_store;
325         gchar *pwd;
326         const gchar *key;
327         
328         account_store = TNY_ACCOUNT_STORE(get_account_store_for_account (account));
329         self = MODEST_TNY_ACCOUNT_STORE (account_store);
330         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
331         key  = tny_account_get_id (account);
332
333         /* Do not remove the key, this will allow us to detect that we
334            have already asked for it at least once */
335         pwd = g_hash_table_lookup (priv->password_hash, key);
336         if (pwd) {
337                 memset (pwd, 0, strlen (pwd));
338                 g_hash_table_insert (priv->password_hash, g_strdup (key), NULL);
339         }
340
341         /* Remove from configuration system */
342         modest_account_mgr_unset (priv->account_mgr,
343                                   key, MODEST_ACCOUNT_PASSWORD, TRUE);
344 }
345
346
347 static void
348 modest_tny_account_store_finalize (GObject *obj)
349 {
350         ModestTnyAccountStore *self        = MODEST_TNY_ACCOUNT_STORE(obj);
351         ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
352         
353         //gboolean debug = modest_runtime_get_debug_flags() & MODEST_RUNTIME_DEBUG_DEBUG_OBJECTS;
354
355         g_free (priv->cache_dir);
356         priv->cache_dir = NULL;
357         
358         if (priv->password_hash) {
359                 g_hash_table_destroy (priv->password_hash);
360                 priv->password_hash = NULL;
361         }
362
363         if (priv->account_mgr) {
364                 g_object_unref (G_OBJECT(priv->account_mgr));
365                 priv->account_mgr = NULL;
366         }
367
368         if (priv->device) {
369                 g_object_unref (G_OBJECT(priv->device));
370                 priv->device = NULL;
371         }
372
373         /* this includes the local folder */
374         account_list_free (priv->store_accounts);
375         priv->store_accounts = NULL;
376         
377         account_list_free (priv->transport_accounts);
378         priv->transport_accounts = NULL;
379
380         if (priv->session) {
381                 camel_object_unref (CAMEL_OBJECT(priv->session));
382                 modest_runtime_verify_object_death(priv->session, "");
383                 priv->session = NULL;
384         }
385         
386         G_OBJECT_CLASS(parent_class)->finalize (obj);
387 }
388
389
390 ModestTnyAccountStore*
391 modest_tny_account_store_new (ModestAccountMgr *account_mgr, TnyDevice *device) {
392
393         GObject *obj;
394         ModestTnyAccountStorePrivate *priv;
395         TnyList *list; 
396         
397         g_return_val_if_fail (account_mgr, NULL);
398         g_return_val_if_fail (device, NULL);
399
400         obj  = G_OBJECT(g_object_new(MODEST_TYPE_TNY_ACCOUNT_STORE, NULL));
401         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(obj);
402
403         priv->account_mgr = g_object_ref (G_OBJECT(account_mgr));
404         priv->device = g_object_ref (device);
405         
406         priv->session = tny_session_camel_new (TNY_ACCOUNT_STORE(obj));
407         
408         tny_session_camel_set_ui_locker (priv->session,  tny_gtk_lockable_new ());
409         /* FIXME: unref this in the end? */
410         tny_session_camel_set_async_connecting (priv->session, TRUE);
411         
412         /* force a cache fill... ugly */
413         list = TNY_LIST(tny_simple_list_new());
414         tny_account_store_get_accounts (TNY_ACCOUNT_STORE(obj), list,
415                                         TNY_ACCOUNT_STORE_BOTH);
416         g_object_unref(list);
417         
418         /* Connect signals */
419         g_signal_connect (G_OBJECT(account_mgr), "account_changed",
420                                        G_CALLBACK (on_account_changed), obj);
421         g_signal_connect (G_OBJECT(account_mgr), "account_removed",
422                                        G_CALLBACK (on_account_removed), obj);
423
424         return MODEST_TNY_ACCOUNT_STORE(obj);
425 }
426
427
428 static void
429 get_cached_accounts (TnyAccountStore *self, TnyList *list, TnyAccountType type)
430 {
431         ModestTnyAccountStorePrivate *priv;
432         GSList                       *accounts, *cursor;
433         
434         priv     = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
435         accounts = (type == TNY_ACCOUNT_TYPE_STORE ? priv->store_accounts : priv->transport_accounts);
436
437         cursor = accounts;
438         while (cursor) {
439                 tny_list_prepend (list, G_OBJECT(cursor->data));
440                 cursor = cursor->next;
441         }
442 }
443
444
445
446 /* this function fills the TnyList, and also returns a GSList of the accounts,
447  * for caching purposes
448  */
449 static GSList*
450 get_accounts  (TnyAccountStore *self, TnyList *list, TnyAccountType type)
451 {
452         ModestTnyAccountStorePrivate *priv;
453         GSList                       *account_names, *cursor;
454         GSList                       *accounts = NULL;
455         
456         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
457  
458         account_names = modest_account_mgr_account_names (priv->account_mgr);
459         
460         for (cursor = account_names; cursor; cursor = cursor->next) {
461                 
462                 gchar *account_name = (gchar*)cursor->data;
463                 
464                 /* only return enabled accounts */
465                 if (modest_account_mgr_get_enabled(priv->account_mgr, account_name)) {
466                         TnyAccount *tny_account = 
467                                 modest_tny_account_new_from_account (priv->account_mgr,
468                                                                      account_name,
469                                                                      type, priv->session,
470                                                                      get_password,
471                                                                      forget_password);
472                         if (tny_account) {
473                                 g_object_set_data (G_OBJECT(tny_account), "account_store",
474                                                    (gpointer)self);
475                                 tny_list_prepend (list, G_OBJECT(tny_account));
476                                 accounts = g_slist_append (accounts, tny_account); /* cache it */
477                         } else
478                                 g_printerr ("modest: failed to create account for %s\n",
479                                             account_name);
480                 }
481                 g_free (account_name);
482         }
483         g_slist_free (account_names);
484
485         /* also, add the local folder pseudo-account */
486         if (type == TNY_ACCOUNT_TYPE_STORE) {
487                 TnyAccount *tny_account =
488                         modest_tny_account_new_for_local_folders (priv->account_mgr, priv->session);
489                 tny_list_prepend (list, G_OBJECT(tny_account));
490                 accounts = g_slist_append (accounts, tny_account); /* cache it */
491         }       
492         return accounts;
493 }       
494
495
496 static void
497 modest_tny_account_store_get_accounts  (TnyAccountStore *self, TnyList *list,
498                                         TnyGetAccountsRequestType request_type)
499 {
500         ModestTnyAccountStorePrivate *priv;
501         
502         g_return_if_fail (self);
503         g_return_if_fail (TNY_IS_LIST(list));
504         
505         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
506         
507         if (request_type == TNY_ACCOUNT_STORE_BOTH) {
508                 modest_tny_account_store_get_accounts (self, list,
509                                                        TNY_ACCOUNT_STORE_STORE_ACCOUNTS);
510                 modest_tny_account_store_get_accounts (self, list,
511                                                        TNY_ACCOUNT_STORE_TRANSPORT_ACCOUNTS);
512                 return;
513         }
514         
515         if (request_type == TNY_ACCOUNT_STORE_STORE_ACCOUNTS)  {
516                 
517                 if (!priv->store_accounts)
518                         priv->store_accounts = get_accounts (self, list, TNY_ACCOUNT_TYPE_STORE);
519                 else
520                         get_cached_accounts (self, list, TNY_ACCOUNT_TYPE_STORE);
521
522         } else if (request_type == TNY_ACCOUNT_STORE_TRANSPORT_ACCOUNTS) {
523
524                 if (!priv->transport_accounts)
525                         priv->transport_accounts =
526                                 get_accounts (self, list, TNY_ACCOUNT_TYPE_TRANSPORT);
527                 else
528                         get_cached_accounts (self, list, TNY_ACCOUNT_TYPE_TRANSPORT);
529         } else
530                 g_return_if_reached (); /* incorrect req type */
531 }
532
533
534 static const gchar*
535 modest_tny_account_store_get_cache_dir (TnyAccountStore *self)
536 {
537         ModestTnyAccountStorePrivate *priv;
538         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
539         
540         if (!priv->cache_dir)
541                 priv->cache_dir = g_build_filename (g_get_home_dir(), 
542                                                     MODEST_DIR, MODEST_CACHE_DIR, NULL);
543         return priv->cache_dir;
544 }
545
546
547 /*
548  * callers need to unref
549  */
550 static TnyDevice*
551 modest_tny_account_store_get_device (TnyAccountStore *self)
552 {
553         ModestTnyAccountStorePrivate *priv;
554
555         g_return_val_if_fail (self, NULL);
556         
557         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
558
559         if (priv->device)
560                 return g_object_ref (G_OBJECT(priv->device));
561         else
562                 return NULL;
563 }
564
565
566 static TnyAccount*
567 modest_tny_account_store_find_account_by_url (TnyAccountStore *self, const gchar* url_string)
568 {
569         TnyAccount *account = NULL;
570         ModestTnyAccountStorePrivate *priv;     
571         GSList *cursor;
572         
573         g_return_val_if_fail (self, NULL);
574         g_return_val_if_fail (url_string, NULL);
575         
576         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
577
578         for (cursor = priv->store_accounts; cursor ; cursor = cursor->next) {
579                 if (tny_account_matches_url_string (TNY_ACCOUNT(cursor->data), url_string)) {
580                         account = TNY_ACCOUNT(cursor->data);
581                         break;
582                 }
583         }
584
585         if (!account) {
586                 for (cursor = priv->transport_accounts; !account && cursor ; cursor = cursor->next) {
587                         if (tny_account_matches_url_string (TNY_ACCOUNT(cursor->data), url_string)) {
588                                 account = TNY_ACCOUNT(cursor->data);
589                                 break;
590                         }
591                 }
592         }
593
594         if (account)
595                 g_object_ref (G_OBJECT(account));
596
597         return account;
598 }
599
600
601
602 static gboolean
603 modest_tny_account_store_alert (TnyAccountStore *self, TnyAlertType type,
604                                 const gchar *prompt)
605 {
606         GtkMessageType gtktype;
607         gboolean retval = FALSE;
608         GtkWidget *dialog;
609
610         switch (type)
611         {
612                 case TNY_ALERT_TYPE_INFO:
613                 gtktype = GTK_MESSAGE_INFO;
614                 break;
615                 case TNY_ALERT_TYPE_WARNING:
616                 gtktype = GTK_MESSAGE_WARNING;
617                 break;
618                 case TNY_ALERT_TYPE_ERROR:
619                 default:
620                 gtktype = GTK_MESSAGE_ERROR;
621                 break;
622         }
623
624         dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL,
625                 gtktype, GTK_BUTTONS_YES_NO, prompt);
626
627         if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_YES)
628                 retval = TRUE;
629
630         gtk_widget_destroy (dialog);
631
632         return retval;
633 }
634
635
636
637 static void
638 modest_tny_account_store_add_store_account  (TnyAccountStore *self,
639                                              TnyStoreAccount *account)
640 {
641         /* we should not need this...*/
642         g_printerr ("modest: add_store_account_func not implemented\n");
643 }
644
645
646 static void
647 modest_tny_account_store_add_transport_account  (TnyAccountStore *self,
648                                                  TnyTransportAccount *account)
649 {       
650         /* we should not need this...*/
651         g_printerr ("modest: add_transport_account_func not implemented\n");
652 }
653
654
655
656 static void
657 modest_tny_account_store_init (gpointer g, gpointer iface_data)
658 {
659         TnyAccountStoreIface *klass;
660
661         g_return_if_fail (g);
662
663         klass = (TnyAccountStoreIface *)g;
664
665         klass->get_accounts_func =
666                 modest_tny_account_store_get_accounts;
667         klass->add_transport_account_func =
668                 modest_tny_account_store_add_transport_account;
669         klass->add_store_account_func =
670                 modest_tny_account_store_add_store_account;
671         klass->get_cache_dir_func =
672                 modest_tny_account_store_get_cache_dir;
673         klass->get_device_func =
674                 modest_tny_account_store_get_device;
675         klass->alert_func =
676                 modest_tny_account_store_alert;
677         klass->find_account_func =
678                 modest_tny_account_store_find_account_by_url;
679 }
680
681 void
682 modest_tny_account_store_set_get_pass_func (ModestTnyAccountStore *self,
683                                             ModestTnyGetPassFunc func)
684 {
685         /* not implemented, we use signals */
686         g_printerr ("modest: set_get_pass_func not implemented\n");
687 }
688
689 TnySessionCamel*
690 tny_account_store_get_session  (TnyAccountStore *self)
691 {
692         g_return_val_if_fail (self, NULL);
693         return MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self)->session;
694 }
695
696
697 TnyAccount*
698 modest_tny_account_store_get_tny_account_by_id  (ModestTnyAccountStore *self, const gchar *id)
699 {
700         TnyAccount *account = NULL;
701         ModestTnyAccountStorePrivate *priv;     
702         GSList *cursor;
703
704         g_return_val_if_fail (self, NULL);
705         g_return_val_if_fail (id, NULL);
706         
707         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
708
709         for (cursor = priv->store_accounts; cursor ; cursor = cursor->next) {
710                 const gchar *acc_id = tny_account_get_id (TNY_ACCOUNT(cursor->data));
711                 if (acc_id && strcmp (acc_id, id) == 0) { 
712                         account = TNY_ACCOUNT(cursor->data);
713                         break;
714                 }
715         }
716
717         /* if we already found something, no need to search the transport accounts */
718         for (cursor = priv->transport_accounts; !account && cursor ; cursor = cursor->next) {
719                 const gchar *acc_id = tny_account_get_id (TNY_ACCOUNT(cursor->data));
720                 if (acc_id && strcmp (acc_id, id) == 0) {
721                         account = TNY_ACCOUNT(cursor->data);
722                         break;
723                 }
724         }
725
726         if (account)
727                 g_object_ref (G_OBJECT(account));
728         
729         return account;
730 }
731
732 TnyAccount*
733 modest_tny_account_store_get_tny_account_by_account (ModestTnyAccountStore *self,
734                                                      const gchar *account_name,
735                                                      TnyAccountType type)
736 {
737         TnyAccount *account = NULL;
738         ModestAccountData *account_data;
739         const gchar *id = NULL;
740         ModestTnyAccountStorePrivate *priv;     
741
742         g_return_val_if_fail (self, NULL);
743         g_return_val_if_fail (account_name, NULL);
744         g_return_val_if_fail (type == TNY_ACCOUNT_TYPE_STORE || type == TNY_ACCOUNT_TYPE_TRANSPORT,
745                               NULL);
746         
747         priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
748         
749         account_data = modest_account_mgr_get_account_data (priv->account_mgr, account_name);
750         if (!account_data) {
751                 g_printerr ("modest: cannot get account data for account '%s'\n", account_name);
752                 return NULL;
753         }
754
755         if (type == TNY_ACCOUNT_TYPE_STORE && account_data->store_account)
756                 id = account_data->store_account->account_name;
757         else if (account_data->transport_account)
758                 id = account_data->transport_account->account_name;
759
760         if (!id)
761                 g_printerr ("modest: could not get an id for account %s\n",
762                             account_name);
763         else    
764                 account = modest_tny_account_store_get_tny_account_by_id (self, id);
765
766         if (!account)
767                 g_printerr ("modest: could not get tny %s account for %s (id=%s)\n",
768                             type == TNY_ACCOUNT_TYPE_STORE? "store" : "transport",
769                             account_name, id ? id : "<none>");
770
771         modest_account_mgr_free_account_data (priv->account_mgr, account_data);
772         return account; 
773 }
774
775 static TnyAccount* get_smtp_specific_transport_account_for_open_connection (ModestTnyAccountStore *self, const gchar *account_name)
776 {
777         /* Get the current connection: */
778         TnyDevice *device = modest_runtime_get_device ();
779         
780         if (!tny_device_is_online (device))
781                 return NULL;
782
783         g_assert (TNY_IS_MAEMO_CONIC_DEVICE (device));
784         TnyMaemoConicDevice *maemo_device = TNY_MAEMO_CONIC_DEVICE (device);    
785         const gchar* iap_id = tny_maemo_conic_device_get_current_iap_id (maemo_device);
786         if (!iap_id)
787                 return NULL;
788                 
789         ConIcIap* connection = tny_maemo_conic_device_get_iap (maemo_device, iap_id);
790         if (!connection)
791                 return NULL;
792                 
793         const gchar *connection_name = con_ic_iap_get_name (connection);
794         if (!connection_name)
795                 return NULL;
796         
797         /*  Get the connection-specific transport acccount, if any: */
798         ModestAccountMgr *account_manager = modest_runtime_get_account_mgr ();
799         gchar* server_account_name = modest_account_mgr_get_connection_specific_smtp (account_manager, 
800                 account_name, connection_name);
801                 
802         if (!server_account_name)
803                 return NULL; /* No connection-specific SMTP server was specified for this connection. */
804                 
805         TnyAccount* account = modest_tny_account_store_get_tny_account_by_id (self, server_account_name);
806         g_free (server_account_name);   
807
808         /* Unref the get()ed object, as required by the tny_maemo_conic_device_get_iap() documentation. */
809         g_object_unref (connection);
810         
811         return account;
812 }
813
814                                                                  
815 TnyAccount* modest_tny_account_store_get_transport_account_for_open_connection (ModestTnyAccountStore *self,
816                                                                  const gchar *account_name)
817 {
818         /*  Get the connection-specific transport acccount, if any: */
819         TnyAccount *account = get_smtp_specific_transport_account_for_open_connection (self, account_name);
820                         
821         /* If there is no connection-specific transport account (the common case), 
822          * just get the regular transport account: */
823         if (!account) {         
824                 account = modest_tny_account_store_get_tny_account_by_account (self, account_name, 
825                                                      TNY_ACCOUNT_TYPE_TRANSPORT);
826         }
827                              
828         return account;
829 }