1 /* Copyright (c) 2006, Nokia Corporation
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
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.
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.
31 #include <modest-marshal.h>
32 #include <modest-account-mgr.h>
33 #include <modest-account-mgr-priv.h>
34 #include <modest-account-mgr-helpers.h>
36 /* 'private'/'protected' functions */
37 static void modest_account_mgr_class_init (ModestAccountMgrClass * klass);
38 static void modest_account_mgr_init (ModestAccountMgr * obj);
39 static void modest_account_mgr_finalize (GObject * obj);
43 ACCOUNT_CHANGED_SIGNAL,
44 ACCOUNT_REMOVED_SIGNAL,
50 static GObjectClass *parent_class = NULL;
51 static guint signals[LAST_SIGNAL] = {0};
53 /* We signal key changes in batches, every X seconds: */
55 on_timeout_notify_changes (gpointer data)
57 ModestAccountMgr *self = MODEST_ACCOUNT_MGR (data);
58 ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
60 /* TODO: Also store the account names, and notify one list for each account,
61 * if anything uses the account names. */
63 if (priv->changed_conf_keys) {
64 gchar *default_account =
65 modest_account_mgr_get_default_account (self);
67 g_signal_emit (G_OBJECT(self), signals[ACCOUNT_CHANGED_SIGNAL], 0,
68 default_account, priv->changed_conf_keys, FALSE);
70 g_free (default_account);
72 g_slist_foreach (priv->changed_conf_keys, (GFunc) g_free, NULL);
73 g_slist_free (priv->changed_conf_keys);
74 priv->changed_conf_keys = NULL;
77 return TRUE; /* Call this again later. */
81 on_key_change (ModestConf *conf, const gchar *key, ModestConfEvent event, gpointer user_data)
83 /* printf("DEBUG: %s: key=%s\n", __FUNCTION__, key); */
85 ModestAccountMgr *self = MODEST_ACCOUNT_MGR (user_data);
86 ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
88 /* there is only one not-really-account key which will still emit
89 * a signal: a change in MODEST_CONF_DEFAULT_ACCOUNT */
90 if (key && strcmp (key, MODEST_CONF_DEFAULT_ACCOUNT) == 0) {
91 /* Get the default account instead. */
93 /* Store the key for later notification in our timeout callback.
94 * Notifying for every key change would cause unnecessary work: */
95 priv->changed_conf_keys = g_slist_append (NULL,
96 (gpointer) g_strdup (key));
99 gboolean is_account_key = FALSE;
100 gboolean is_server_account = FALSE;
101 gchar* account = _modest_account_mgr_account_from_key (key, &is_account_key, &is_server_account);
103 /* if this is not an account-related key change, ignore */
107 /* account was removed -- emit this, even if the account was
108 disabled. This should not happen unless the user directly
110 if (is_account_key && event == MODEST_CONF_EVENT_KEY_UNSET) {
111 g_signal_emit (G_OBJECT(self), signals[ACCOUNT_REMOVED_SIGNAL], 0,
112 account, is_server_account);
117 /* is this account enabled? */
118 gboolean enabled = FALSE;
119 if (is_server_account)
122 enabled = modest_account_mgr_get_enabled (self, account);
124 /* Notify is server account was changed, default account was changed
125 * or when enabled/disabled changes:
128 g_str_has_suffix (key, MODEST_ACCOUNT_ENABLED) ||
129 strcmp (key, MODEST_CONF_DEFAULT_ACCOUNT) == 0) {
130 /* Store the key for later notification in our timeout callback.
131 * Notifying for every key change would cause unnecessary work: */
132 priv->changed_conf_keys = g_slist_append (NULL,
133 (gpointer) g_strdup (key));
141 modest_account_mgr_get_type (void)
143 static GType my_type = 0;
146 static const GTypeInfo my_info = {
147 sizeof (ModestAccountMgrClass),
148 NULL, /* base init */
149 NULL, /* base finalize */
150 (GClassInitFunc) modest_account_mgr_class_init,
151 NULL, /* class finalize */
152 NULL, /* class data */
153 sizeof (ModestAccountMgr),
155 (GInstanceInitFunc) modest_account_mgr_init,
159 my_type = g_type_register_static (G_TYPE_OBJECT,
167 modest_account_mgr_class_init (ModestAccountMgrClass * klass)
169 GObjectClass *gobject_class;
170 gobject_class = (GObjectClass *) klass;
172 parent_class = g_type_class_peek_parent (klass);
173 gobject_class->finalize = modest_account_mgr_finalize;
175 g_type_class_add_private (gobject_class,
176 sizeof (ModestAccountMgrPrivate));
178 /* signal definitions */
179 signals[ACCOUNT_REMOVED_SIGNAL] =
180 g_signal_new ("account_removed",
181 G_TYPE_FROM_CLASS (klass),
183 G_STRUCT_OFFSET(ModestAccountMgrClass,account_removed),
185 modest_marshal_VOID__STRING_BOOLEAN,
186 G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_BOOLEAN);
187 signals[ACCOUNT_CHANGED_SIGNAL] =
188 g_signal_new ("account_changed",
189 G_TYPE_FROM_CLASS (klass),
191 G_STRUCT_OFFSET(ModestAccountMgrClass,account_changed),
193 modest_marshal_VOID__STRING_POINTER_BOOLEAN,
194 G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_BOOLEAN);
199 modest_account_mgr_init (ModestAccountMgr * obj)
201 ModestAccountMgrPrivate *priv =
202 MODEST_ACCOUNT_MGR_GET_PRIVATE (obj);
204 priv->modest_conf = NULL;
206 priv->timeout = g_timeout_add (1000 /* milliseconds */, on_timeout_notify_changes, obj);
210 modest_account_mgr_finalize (GObject * obj)
212 ModestAccountMgrPrivate *priv =
213 MODEST_ACCOUNT_MGR_GET_PRIVATE (obj);
215 if (priv->modest_conf) {
216 g_object_unref (G_OBJECT(priv->modest_conf));
217 priv->modest_conf = NULL;
221 g_source_remove (priv->timeout);
223 if (priv->changed_conf_keys) {
224 g_slist_foreach (priv->changed_conf_keys, (GFunc) g_free, NULL);
225 g_slist_free (priv->changed_conf_keys);
228 G_OBJECT_CLASS(parent_class)->finalize (obj);
233 modest_account_mgr_new (ModestConf *conf)
236 ModestAccountMgrPrivate *priv;
238 g_return_val_if_fail (conf, NULL);
240 obj = G_OBJECT (g_object_new (MODEST_TYPE_ACCOUNT_MGR, NULL));
241 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (obj);
243 g_object_ref (G_OBJECT(conf));
244 priv->modest_conf = conf;
246 g_signal_connect (G_OBJECT (conf), "key_changed",
247 G_CALLBACK (on_key_change),
250 return MODEST_ACCOUNT_MGR (obj);
255 null_means_empty (const gchar * str)
257 return str ? str : "";
262 modest_account_mgr_add_account (ModestAccountMgr *self,
264 const gchar *store_account,
265 const gchar *transport_account,
268 ModestAccountMgrPrivate *priv;
271 gchar *default_account;
274 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
275 g_return_val_if_fail (name, FALSE);
276 g_return_val_if_fail (strchr(name, '/') == NULL, FALSE);
278 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
281 * we create the account by adding an account 'dir', with the name <name>,
282 * and in that the 'display_name' string key
284 key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_DISPLAY_NAME, FALSE);
285 if (modest_account_mgr_account_exists (self, key, FALSE)) {
286 g_printerr ("modest: account already exists\n");
291 ok = modest_conf_set_string (priv->modest_conf, key, name, &err);
294 g_printerr ("modest: cannot set display name\n");
296 g_printerr ("modest: Error adding account conf: %s\n", err->message);
303 key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_STORE_ACCOUNT, FALSE);
304 ok = modest_conf_set_string (priv->modest_conf, key, store_account, &err);
307 g_printerr ("modest: failed to set store account '%s'\n",
310 g_printerr ("modest: Error adding store account conf: %s\n", err->message);
318 if (transport_account) {
319 key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_TRANSPORT_ACCOUNT,
321 ok = modest_conf_set_string (priv->modest_conf, key, transport_account, &err);
324 g_printerr ("modest: failed to set transport account '%s'\n",
327 g_printerr ("modest: Error adding transport account conf: %s\n", err->message);
334 /* Make sure that leave-messages-on-server is enabled by default,
335 * as per the UI spec, though it is only meaningful for accounts using POP.
336 * (possibly this gconf key should be under the server account): */
337 modest_account_mgr_set_bool (self, name,
338 MODEST_ACCOUNT_LEAVE_ON_SERVER, TRUE, FALSE /* not server account */);
341 modest_account_mgr_set_enabled (self, name, enabled);
343 /* if no default account has been defined yet, do so now */
344 default_account = modest_account_mgr_get_default_account (self);
345 if (!default_account)
346 modest_account_mgr_set_default_account (self, name);
347 g_free (default_account);
356 modest_account_mgr_add_server_account (ModestAccountMgr * self,
357 const gchar * name, const gchar *hostname,
359 const gchar * username, const gchar * password,
360 ModestTransportStoreProtocol proto,
361 ModestConnectionProtocol security,
362 ModestAuthProtocol auth)
364 ModestAccountMgrPrivate *priv;
369 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
370 g_return_val_if_fail (name, FALSE);
371 g_return_val_if_fail (strchr(name, '/') == NULL, FALSE);
373 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
376 key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_HOSTNAME, TRUE);
377 if (modest_conf_key_exists (priv->modest_conf, key, &err)) {
378 g_printerr ("modest: server account '%s' already exists\n", name);
385 modest_conf_set_string (priv->modest_conf, key, null_means_empty(hostname), &err);
387 g_printerr ("modest: failed to set %s: %s\n", key, err->message);
396 key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_USERNAME, TRUE);
397 ok = modest_conf_set_string (priv->modest_conf, key, null_means_empty (username), &err);
399 g_printerr ("modest: failed to set %s: %s\n", key, err->message);
409 key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_PASSWORD, TRUE);
410 ok = modest_conf_set_string (priv->modest_conf, key, null_means_empty (password), &err);
412 g_printerr ("modest: failed to set %s: %s\n", key, err->message);
421 key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_PROTO, TRUE);
422 ok = modest_conf_set_string (priv->modest_conf, key,
423 modest_protocol_info_get_transport_store_protocol_name(proto),
426 g_printerr ("modest: failed to set %s: %s\n", key, err->message);
436 key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_PORT, TRUE);
437 ok = modest_conf_set_int (priv->modest_conf, key, portnumber, &err);
439 g_printerr ("modest: failed to set %s: %s\n", key, err->message);
449 key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_AUTH_MECH, TRUE);
450 ok = modest_conf_set_string (priv->modest_conf, key,
451 modest_protocol_info_get_auth_protocol_name (auth),
454 g_printerr ("modest: failed to set %s: %s\n", key, err->message);
462 /* Add the security settings: */
463 modest_server_account_set_security (self, name, security);
467 g_printerr ("modest: failed to add server account\n");
474 /** modest_account_mgr_add_server_account_uri:
475 * Only used for mbox and maildir accounts.
478 modest_account_mgr_add_server_account_uri (ModestAccountMgr * self,
479 const gchar *name, ModestTransportStoreProtocol proto,
482 ModestAccountMgrPrivate *priv;
486 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
487 g_return_val_if_fail (name, FALSE);
488 g_return_val_if_fail (strchr(name, '/') == NULL, FALSE);
489 g_return_val_if_fail (uri, FALSE);
491 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
495 key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_PROTO, TRUE);
496 ok = modest_conf_set_string (priv->modest_conf, key,
497 modest_protocol_info_get_transport_store_protocol_name(proto),
502 g_printerr ("modest: failed to set proto\n");
507 key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_URI, TRUE);
508 ok = modest_conf_set_string (priv->modest_conf, key, uri, NULL);
512 g_printerr ("modest: failed to set uri\n");
521 modest_account_mgr_remove_account (ModestAccountMgr * self,
522 const gchar* name, gboolean server_account)
524 ModestAccountMgrPrivate *priv;
529 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
530 g_return_val_if_fail (name, FALSE);
532 if (!modest_account_mgr_account_exists (self, name, server_account)) {
533 g_printerr ("modest: %s: account '%s' does not exist\n", __FUNCTION__, name);
537 /* Notify the observers. We need to do that here because they
538 could need to use the configuration keys before deleting
539 them, i.e., the account store will delete the cache. We
540 only notify about removals of modest accounts */
542 g_signal_emit (G_OBJECT(self), signals[ACCOUNT_REMOVED_SIGNAL], 0,
543 name, server_account);
545 /* in case we're deleting an account, also delete the dependent store and transport account */
546 if (!server_account) {
547 gchar *server_account_name;
549 server_account_name = modest_account_mgr_get_string (self, name, MODEST_ACCOUNT_STORE_ACCOUNT,
551 if (server_account_name) {
552 if (!modest_account_mgr_remove_account (self, server_account_name, TRUE))
553 g_printerr ("modest: failed to remove store account '%s' (%s)\n",
554 server_account_name, name);
555 g_free (server_account_name);
557 g_printerr ("modest: could not find the store account for %s\n", name);
559 server_account_name = modest_account_mgr_get_string (self, name, MODEST_ACCOUNT_TRANSPORT_ACCOUNT,
561 if (server_account_name) {
562 if (!modest_account_mgr_remove_account (self, server_account_name, TRUE))
563 g_printerr ("modest: failed to remove transport account '%s' (%s)\n",
564 server_account_name, name);
565 g_free (server_account_name);
567 g_printerr ("modest: could not find the transport account for %s\n", name);
570 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
571 key = _modest_account_mgr_get_account_keyname (name, NULL, server_account);
573 retval = modest_conf_remove_key (priv->modest_conf, key, &err);
577 g_printerr ("modest: error removing key: %s\n", err->message);
581 /* If this was the default, then remove that setting: */
582 if (!server_account) {
583 gchar *default_account_name = modest_account_mgr_get_default_account (self);
584 if (default_account_name && (strcmp (default_account_name, name) == 0))
585 modest_account_mgr_unset_default_account (self);
586 g_free (default_account_name);
594 /* strip the first /n/ character from each element
595 * caller must make sure all elements are strings with
596 * length >= n, and also that data can be freed.
600 strip_prefix_from_elements (GSList * lst, guint n)
603 memmove (lst->data, lst->data + n,
604 strlen(lst->data) - n + 1);
612 modest_account_mgr_search_server_accounts (ModestAccountMgr * self,
613 const gchar * account_name,
614 ModestTransportStoreProtocol proto)
618 ModestAccountMgrPrivate *priv;
622 g_return_val_if_fail (self, NULL);
624 key = _modest_account_mgr_get_account_keyname (account_name, NULL, TRUE);
625 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
627 /* get the list of all server accounts */
628 accounts = modest_conf_list_subkeys (priv->modest_conf, key, &err);
630 g_printerr ("modest: failed to get subkeys for '%s' (%s)\n", key,
636 /* filter out the ones with the wrong protocol */
637 /* we could optimize for unknown proto / unknown type, but it will only
638 * make the code more complex */
641 gchar *account = _modest_account_mgr_account_from_key ((gchar*)cursor->data, NULL, NULL);
642 gchar *acc_proto = modest_account_mgr_get_string (self, account, MODEST_ACCOUNT_PROTO,TRUE);
643 ModestTransportStoreProtocol this_proto =
644 modest_protocol_info_get_transport_store_protocol (acc_proto);
645 if (this_proto != MODEST_PROTOCOL_TRANSPORT_STORE_UNKNOWN && this_proto != proto) {
646 GSList *nxt = cursor->next;
647 accounts = g_slist_delete_link (accounts, cursor);
650 cursor = cursor->next;
656 /* +1 because we must remove the ending '/' as well */
657 strip_prefix_from_elements (accounts, strlen(key)+1);
663 modest_account_mgr_account_names (ModestAccountMgr * self, gboolean only_enabled)
666 ModestAccountMgrPrivate *priv;
669 const size_t prefix_len = strlen (MODEST_ACCOUNT_NAMESPACE "/");
671 g_return_val_if_fail (self, NULL);
673 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
675 accounts = modest_conf_list_subkeys (priv->modest_conf,
676 MODEST_ACCOUNT_NAMESPACE, &err);
678 g_printerr ("modest: failed to get subkeys (%s): %s\n",
679 MODEST_ACCOUNT_NAMESPACE, err->message);
681 return NULL; /* assume accounts did not get value when err is set...*/
684 strip_prefix_from_elements (accounts, prefix_len);
686 GSList *result = NULL;
688 /* Unescape the keys to get the account names: */
689 GSList *iter = accounts;
694 const gchar* account_name_key = (const gchar*)iter->data;
695 /* printf ("DEBUG: %s: account_name_key=%s\n", __FUNCTION__, account_name_key); */
696 gchar* unescaped_name = account_name_key ?
697 modest_conf_key_unescape (account_name_key)
699 /* printf (" DEBUG: %s: unescaped name=%s\n", __FUNCTION__, unescaped_name); */
703 if (unescaped_name &&
704 !modest_account_mgr_get_enabled (self, unescaped_name)) {
710 result = g_slist_append (result, unescaped_name);
713 g_free (unescaped_name);
716 iter = g_slist_next (iter);
719 /* TODO: Free the strings too? */
720 g_slist_free (accounts);
728 modest_account_mgr_get_string (ModestAccountMgr *self, const gchar *name,
729 const gchar *key, gboolean server_account) {
731 ModestAccountMgrPrivate *priv;
737 g_return_val_if_fail (self, NULL);
738 g_return_val_if_fail (name, NULL);
739 g_return_val_if_fail (key, NULL);
741 keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
743 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
744 retval = modest_conf_get_string (priv->modest_conf, keyname, &err);
746 g_printerr ("modest: error getting string '%s': %s\n", keyname, err->message);
757 modest_account_mgr_get_password (ModestAccountMgr *self, const gchar *name,
758 const gchar *key, gboolean server_account)
760 return modest_account_mgr_get_string (self, name, key, server_account);
767 modest_account_mgr_get_int (ModestAccountMgr *self, const gchar *name, const gchar *key,
768 gboolean server_account)
770 ModestAccountMgrPrivate *priv;
776 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), -1);
777 g_return_val_if_fail (name, -1);
778 g_return_val_if_fail (key, -1);
780 keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
782 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
783 retval = modest_conf_get_int (priv->modest_conf, keyname, &err);
785 g_printerr ("modest: error getting int '%s': %s\n", keyname, err->message);
797 modest_account_mgr_get_bool (ModestAccountMgr * self, const gchar *account,
798 const gchar * key, gboolean server_account)
800 ModestAccountMgrPrivate *priv;
806 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
807 g_return_val_if_fail (account, FALSE);
808 g_return_val_if_fail (key, FALSE);
810 keyname = _modest_account_mgr_get_account_keyname (account, key, server_account);
812 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
813 retval = modest_conf_get_bool (priv->modest_conf, keyname, &err);
815 g_printerr ("modest: error getting bool '%s': %s\n", keyname, err->message);
827 modest_account_mgr_get_list (ModestAccountMgr *self, const gchar *name,
828 const gchar *key, ModestConfValueType list_type,
829 gboolean server_account)
831 ModestAccountMgrPrivate *priv;
837 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), NULL);
838 g_return_val_if_fail (name, NULL);
839 g_return_val_if_fail (key, NULL);
841 keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
843 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
844 retval = modest_conf_get_list (priv->modest_conf, keyname, list_type, &err);
846 g_printerr ("modest: error getting list '%s': %s\n", keyname,
858 modest_account_mgr_set_string (ModestAccountMgr * self, const gchar * name,
859 const gchar * key, const gchar * val, gboolean server_account)
861 ModestAccountMgrPrivate *priv;
867 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
868 g_return_val_if_fail (name, FALSE);
869 g_return_val_if_fail (key, FALSE);
871 keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
873 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
875 retval = modest_conf_set_string (priv->modest_conf, keyname, val, &err);
877 g_printerr ("modest: error setting string '%s': %s\n", keyname, err->message);
887 modest_account_mgr_set_password (ModestAccountMgr * self, const gchar * name,
888 const gchar * key, const gchar * val, gboolean server_account)
890 return modest_account_mgr_set_password (self, name, key, val, server_account);
896 modest_account_mgr_set_int (ModestAccountMgr * self, const gchar * name,
897 const gchar * key, int val, gboolean server_account)
899 ModestAccountMgrPrivate *priv;
905 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
906 g_return_val_if_fail (name, FALSE);
907 g_return_val_if_fail (key, FALSE);
909 keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
911 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
913 retval = modest_conf_set_int (priv->modest_conf, keyname, val, &err);
915 g_printerr ("modest: error setting int '%s': %s\n", keyname, err->message);
926 modest_account_mgr_set_bool (ModestAccountMgr * self, const gchar * name,
927 const gchar * key, gboolean val, gboolean server_account)
929 ModestAccountMgrPrivate *priv;
935 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
936 g_return_val_if_fail (name, FALSE);
937 g_return_val_if_fail (key, FALSE);
939 keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
941 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
943 retval = modest_conf_set_bool (priv->modest_conf, keyname, val, &err);
945 g_printerr ("modest: error setting bool '%s': %s\n", keyname, err->message);
955 modest_account_mgr_set_list (ModestAccountMgr *self,
959 ModestConfValueType list_type,
960 gboolean server_account)
962 ModestAccountMgrPrivate *priv;
967 g_return_val_if_fail (self, FALSE);
968 g_return_val_if_fail (name, FALSE);
969 g_return_val_if_fail (key, FALSE);
970 g_return_val_if_fail (val, FALSE);
972 keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
974 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
975 retval = modest_conf_set_list (priv->modest_conf, keyname, val, list_type, &err);
977 g_printerr ("modest: error setting list '%s': %s\n", keyname, err->message);
987 modest_account_mgr_account_exists (ModestAccountMgr * self, const gchar * name,
988 gboolean server_account)
990 ModestAccountMgrPrivate *priv;
996 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
997 g_return_val_if_fail (name, FALSE);
999 keyname = _modest_account_mgr_get_account_keyname (name, NULL, server_account);
1001 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
1002 retval = modest_conf_key_exists (priv->modest_conf, keyname, &err);
1004 g_printerr ("modest: error determining existance of '%s': %s\n", keyname,
1013 gboolean modest_account_mgr_account_with_display_name_exists (ModestAccountMgr *self,
1014 const gchar *display_name)
1016 GSList *account_names = NULL;
1017 GSList *cursor = NULL;
1019 cursor = account_names = modest_account_mgr_account_names (self,
1020 TRUE /* enabled accounts, because disabled accounts are not user visible. */);
1022 gboolean found = FALSE;
1024 /* Look at each non-server account to check their display names; */
1026 const gchar * account_name = (gchar*)cursor->data;
1028 ModestAccountData *account_data = modest_account_mgr_get_account_data (self, account_name);
1029 if (!account_data) {
1030 g_printerr ("modest: failed to get account data for %s\n", account_name);
1034 if(account_data->display_name && (strcmp (account_data->display_name, display_name) == 0)) {
1039 modest_account_mgr_free_account_data (self, account_data);
1040 cursor = cursor->next;
1042 g_slist_free (account_names);
1051 modest_account_mgr_unset (ModestAccountMgr *self, const gchar *name,
1052 const gchar *key, gboolean server_account)
1054 ModestAccountMgrPrivate *priv;
1060 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
1061 g_return_val_if_fail (name, FALSE);
1062 g_return_val_if_fail (key, FALSE);
1064 keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
1066 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
1067 retval = modest_conf_remove_key (priv->modest_conf, keyname, &err);
1069 g_printerr ("modest: error unsetting'%s': %s\n", keyname,
1079 _modest_account_mgr_account_from_key (const gchar *key, gboolean *is_account_key, gboolean *is_server_account)
1081 /* Initialize input parameters: */
1083 *is_account_key = FALSE;
1085 if (is_server_account)
1086 *is_server_account = FALSE;
1088 const gchar* account_ns = MODEST_ACCOUNT_NAMESPACE "/";
1089 const gchar* server_account_ns = MODEST_SERVER_ACCOUNT_NAMESPACE "/";
1091 gchar *account = NULL;
1093 /* determine whether it's an account or a server account,
1094 * based on the prefix */
1095 if (g_str_has_prefix (key, account_ns)) {
1097 if (is_server_account)
1098 *is_server_account = FALSE;
1100 account = g_strdup (key + strlen (account_ns));
1102 } else if (g_str_has_prefix (key, server_account_ns)) {
1104 if (is_server_account)
1105 *is_server_account = TRUE;
1107 account = g_strdup (key + strlen (server_account_ns));
1111 /* if there are any slashes left in the key, it's not
1112 * the toplevel entry for an account
1114 cursor = strstr(account, "/");
1116 if (is_account_key && cursor)
1117 *is_account_key = TRUE;
1119 /* put a NULL where the first slash was */
1124 /* The key is an escaped string, so unescape it to get the actual account name: */
1125 gchar *unescaped_name = modest_conf_key_unescape (account);
1127 return unescaped_name;
1134 /* must be freed by caller */
1136 _modest_account_mgr_get_account_keyname (const gchar *account_name, const gchar * name, gboolean server_account)
1138 gchar *retval = NULL;
1140 gchar *namespace = server_account ? MODEST_SERVER_ACCOUNT_NAMESPACE : MODEST_ACCOUNT_NAMESPACE;
1143 return g_strdup (namespace);
1145 /* Always escape the conf keys, so that it is acceptable to gconf: */
1146 gchar *escaped_account_name = account_name ? modest_conf_key_escape (account_name) : NULL;
1147 gchar *escaped_name = name ? modest_conf_key_escape (name) : NULL;
1149 if (escaped_account_name && escaped_name)
1150 retval = g_strconcat (namespace, "/", escaped_account_name, "/", escaped_name, NULL);
1151 else if (escaped_account_name)
1152 retval = g_strconcat (namespace, "/", escaped_account_name, NULL);
1155 if (!modest_conf_key_is_valid (retval)) {
1156 g_warning ("%s: Generated conf key was invalid: %s", __FUNCTION__, retval);
1161 g_free (escaped_name);
1162 g_free (escaped_account_name);