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

   1 /* modest-account-mgr.c */
   2
   3 /* insert (c)/licensing information) */
   4
   5 #include <string.h>
   6 #include "modest-marshal.h"
   7 #include "modest-account-keys.h"
   8 #include "modest-account-mgr.h"
   9
  10 /* 'private'/'protected' functions */
  11 static void modest_account_mgr_class_init (ModestAccountMgrClass * klass);
  12 static void modest_account_mgr_init (ModestAccountMgr * obj);
  13 static void modest_account_mgr_finalize (GObject * obj);
  14
  15 static gchar *get_account_keyname (const gchar * accname, const gchar * name);
  16 static gchar *get_server_account_keyname (const gchar * accname,
  17                                           const gchar * name);
  18
  19 /* list my signals */
  20 enum {
  21         ACCOUNT_CHANGE_SIGNAL,
  22         ACCOUNT_REMOVE_SIGNAL,
  23         ACCOUNT_ADD_SIGNAL,
  24         LAST_SIGNAL
  25 };
  26
  27 typedef struct _ModestAccountMgrPrivate ModestAccountMgrPrivate;
  28 struct _ModestAccountMgrPrivate {
  29         ModestConf *modest_conf;
  30         GSList *current_accounts;
  31 };
  32
  33 #define MODEST_ACCOUNT_MGR_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  34                                                 MODEST_TYPE_ACCOUNT_MGR, \
  35                                                 ModestAccountMgrPrivate))
  36 /* globals */
  37 static GObjectClass *parent_class = NULL;
  38
  39 static guint signals[LAST_SIGNAL] = {0};
  40
  41
  42 static GSList *
  43 delete_account_from_list (GSList *list, const gchar *name)
  44 {
  45         GSList *iter, *result;
  46
  47         iter = list;
  48         result = list;
  49         while (iter) {
  50                 if (!strcmp (name, iter->data)) {
  51                         result = g_slist_delete_link (list, iter);
  52                         break;
  53                 }
  54
  55                 iter = g_slist_next (iter);
  56         }
  57         return result;
  58 }
  59
  60 static GSList *
  61 find_account_in_list (GSList *list, const gchar *name)
  62 {
  63         GSList *iter, *result;
  64
  65         iter = list;
  66         result = list;
  67         while (iter) {
  68                 if (!strcmp (name, iter->data)) {
  69                         return iter;
  70                         break;
  71                 }
  72
  73                 iter = g_slist_next (iter);
  74         }
  75         return NULL;
  76 }
  77
  78 /* Map configuration changes to account changes.
  79  * Doing this here makes sure all changes are available and external changes
  80  * are covered as well. */
  81
  82 static void
  83 modest_account_mgr_check_change (ModestConf *conf, const gchar *key,
  84                                  const gchar *new_value, gpointer user_data)
  85 {
  86         ModestAccountMgr *amgr = user_data;
  87         ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (amgr);
  88
  89         if ((strlen (key) > strlen (MODEST_SERVER_ACCOUNT_NAMESPACE "/")
  90              && g_str_has_prefix (key, MODEST_SERVER_ACCOUNT_NAMESPACE))) {
  91                 gchar *subkey = g_strdup(key + strlen (MODEST_SERVER_ACCOUNT_NAMESPACE "/"));
  92
  93                 if (! strstr (subkey, "/")) {/* no more '/' means an account was modified */
  94                         if (new_value)  {
  95                                  /* covers only one case of two */
  96                                  /*
  97                                 priv->current_accounts =
  98                                         g_slist_prepend (priv->current_accounts, g_strdup (subkey));
  99                                 g_signal_emit (amgr, signals[ACCOUNT_ADD_SIGNAL], 0, subkey);
 100                                 */
 101                         } else {
 102                                 priv->current_accounts =
 103                                         delete_account_from_list (priv->current_accounts, subkey);
 104
 105                                 g_signal_emit (amgr, signals[ACCOUNT_REMOVE_SIGNAL], 0, subkey);
 106                         }
 107                 } else {
 108                         gchar *param;
 109
 110                         param = strstr (subkey, "/");
 111                         param [0] = 0;
 112                         param++;
 113
 114                         /* that's the second case for a new account */
 115                         if (!find_account_in_list (priv->current_accounts, subkey) && strstr (param, MODEST_ACCOUNT_PROTO)) {
 116                                 priv->current_accounts =
 117                                         g_slist_prepend (priv->current_accounts, g_strdup (subkey));
 118                                 g_signal_emit (amgr, signals[ACCOUNT_ADD_SIGNAL], 0, subkey);
 119                         }
 120
 121                         g_signal_emit (amgr, signals[ACCOUNT_CHANGE_SIGNAL], 0, subkey, param, new_value);
 122                 }
 123
 124                 g_free (subkey);
 125         }
 126 }
 127
 128
 129 GType
 130 modest_account_mgr_get_type (void)
 131 {
 132         static GType my_type = 0;
 133
 134         if (!my_type) {
 135                 static const GTypeInfo my_info = {
 136                         sizeof (ModestAccountMgrClass),
 137                         NULL,   /* base init */
 138                         NULL,   /* base finalize */
 139                         (GClassInitFunc) modest_account_mgr_class_init,
 140                         NULL,   /* class finalize */
 141                         NULL,   /* class data */
 142                         sizeof (ModestAccountMgr),
 143                         1,      /* n_preallocs */
 144                         (GInstanceInitFunc) modest_account_mgr_init,
 145                 };
 146
 147                 my_type = g_type_register_static (G_TYPE_OBJECT,
 148                                                   "ModestAccountMgr",
 149                                                   &my_info, 0);
 150         }
 151         return my_type;
 152 }
 153
 154 static void
 155 modest_account_mgr_class_init (ModestAccountMgrClass * klass)
 156 {
 157         GObjectClass *gobject_class;
 158         GType paramtypes[3] = {G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER};
 159
 160         gobject_class = (GObjectClass *) klass;
 161
 162         parent_class = g_type_class_peek_parent (klass);
 163         gobject_class->finalize = modest_account_mgr_finalize;
 164
 165         g_type_class_add_private (gobject_class,
 166                                   sizeof (ModestAccountMgrPrivate));
 167
 168         /* signal definitions */
 169         signals[ACCOUNT_ADD_SIGNAL] =
 170                 g_signal_newv ("account-add",
 171                                G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 172                                NULL, NULL, NULL,
 173                                g_cclosure_marshal_VOID__POINTER,
 174                                G_TYPE_NONE, 1, paramtypes);
 175
 176         signals[ACCOUNT_REMOVE_SIGNAL] =
 177                 g_signal_newv ("account-remove",
 178                                G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 179                                NULL, NULL, NULL,
 180                                g_cclosure_marshal_VOID__POINTER,
 181                                G_TYPE_NONE, 1, paramtypes);
 182         signals[ACCOUNT_CHANGE_SIGNAL] =
 183                 g_signal_newv ("account-change",
 184                                G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 185                                NULL, NULL, NULL,
 186                                modest_marshal_VOID__POINTER_POINTER_POINTER,
 187                                G_TYPE_NONE, 3, paramtypes);
 188 }
 189
 190
 191 static void
 192 modest_account_mgr_init (ModestAccountMgr * obj)
 193 {
 194         ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (obj);
 195
 196         priv->modest_conf = NULL;
 197 }
 198
 199 static void
 200 modest_account_mgr_finalize (GObject * obj)
 201 {
 202         ModestAccountMgr *self = MODEST_ACCOUNT_MGR (obj);
 203         ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 204
 205         if (priv->modest_conf) {
 206                 g_object_unref (G_OBJECT(priv->modest_conf));
 207                 priv->modest_conf = NULL;
 208         }
 209 }
 210
 211 GObject *
 212 modest_account_mgr_new (ModestConf * conf)
 213 {
 214         GObject *obj;
 215         ModestAccountMgrPrivate *priv;
 216
 217         g_return_val_if_fail (conf, NULL);
 218
 219         obj = G_OBJECT (g_object_new (MODEST_TYPE_ACCOUNT_MGR, NULL));
 220         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (obj);
 221
 222         /*
 223          * increase the ref count on the modest_conf. Normally, the
 224          * ModestConf should outlive the ModestAccountMgr though
 225          */
 226         g_object_ref (G_OBJECT (priv->modest_conf = conf));
 227
 228         priv->current_accounts = modest_account_mgr_account_names (MODEST_ACCOUNT_MGR(obj), NULL);
 229
 230         g_signal_connect (G_OBJECT (conf), "key-changed",
 231                           G_CALLBACK (modest_account_mgr_check_change), obj);
 232         return obj;
 233 }
 234
 235
 236 gboolean
 237 modest_account_mgr_add_account (ModestAccountMgr * self, const gchar * name,
 238                                 const gchar * store_account,
 239                                 const gchar * transport_account,
 240                                 GError ** err)
 241 {
 242         ModestAccountMgrPrivate *priv;
 243         gchar *key;
 244
 245         g_return_val_if_fail (self, FALSE);
 246         g_return_val_if_fail (name, FALSE);
 247
 248         if (modest_account_mgr_account_exists (self, name, err)) {
 249                 g_warning ("account already exists");
 250                 //return FALSE;
 251         }
 252         /*
 253          * we create the account by adding an account 'dir', with the name <name>,
 254          * and in that the 'display_name' string key
 255          */
 256         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 257
 258         key = get_account_keyname (name, MODEST_ACCOUNT_DISPLAY_NAME);
 259         modest_conf_set_string (priv->modest_conf, key, name, err);
 260         g_free (key);
 261
 262         if (store_account) {
 263                 key = get_account_keyname (name,
 264                                            MODEST_ACCOUNT_STORE_ACCOUNT);
 265                 modest_conf_set_string (priv->modest_conf, key, store_account,
 266                                         err);
 267                 g_free (key);
 268         }
 269
 270         if (transport_account) {
 271                 key = get_account_keyname (name,
 272                                            MODEST_ACCOUNT_TRANSPORT_ACCOUNT);
 273                 modest_conf_set_string (priv->modest_conf, key,
 274                                         transport_account, err);
 275                 g_free (key);
 276         }
 277
 278         return TRUE;            /* TODO: error handling */
 279 }
 280
 281
 282 gboolean
 283 modest_account_mgr_remove_account (ModestAccountMgr * self,
 284                                    const gchar * name, GError ** err)
 285 {
 286         ModestAccountMgrPrivate *priv;
 287         gchar *key;
 288         gboolean retval;
 289
 290         g_return_val_if_fail (self, FALSE);
 291         g_return_val_if_fail (name, FALSE);
 292
 293         if (!modest_account_mgr_account_exists (self, name, err)) {
 294                 g_warning ("account doest not exist");
 295                 return FALSE;
 296         }
 297
 298         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 299         key = get_account_keyname (name, NULL);
 300
 301         retval = modest_conf_remove_key (priv->modest_conf, key, NULL);
 302
 303         g_free (key);
 304         return retval;
 305 }
 306
 307
 308 static const gchar *
 309 null_means_empty (const gchar * str)
 310 {
 311         return str ? str : "";
 312 }
 313
 314
 315 gboolean
 316 modest_account_mgr_add_server_account (ModestAccountMgr * self,
 317                                        const gchar * name,
 318                                        const gchar * hostname,
 319                                        const gchar * username,
 320                                        const gchar * password,
 321                                        const gchar * proto)
 322 {
 323         ModestAccountMgrPrivate *priv;
 324         gchar *acckey, *key;
 325
 326         g_return_val_if_fail (self, FALSE);
 327         g_return_val_if_fail (name, FALSE);
 328
 329         /* TODO: check already exists */
 330
 331         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 332         acckey = g_strconcat (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
 333                               name, NULL);
 334
 335         if (modest_conf_key_exists (priv->modest_conf, acckey, NULL)) {
 336                 g_warning ("server account %s already exists", name);
 337                 //g_free (acckey);
 338                 //return FALSE;
 339         }
 340
 341         /* hostname */
 342         key = g_strconcat (acckey, "/", MODEST_ACCOUNT_HOSTNAME, NULL);
 343         modest_conf_set_string (priv->modest_conf, key,
 344                                 null_means_empty (hostname), NULL);
 345         g_free (key);
 346
 347         /* username */
 348         key = g_strconcat (acckey, "/", MODEST_ACCOUNT_USERNAME, NULL);
 349         modest_conf_set_string (priv->modest_conf, key,
 350                                 null_means_empty (username), NULL);
 351         g_free (key);
 352
 353         /* password */
 354         if (password) {
 355                 key = g_strconcat (acckey, "/", MODEST_ACCOUNT_PASSWORD,
 356                                    NULL);
 357                 modest_conf_set_string (priv->modest_conf, key,
 358                                         null_means_empty (password), NULL);
 359                 g_free (key);
 360         }
 361
 362         /* proto */
 363         key = g_strconcat (acckey, "/", MODEST_ACCOUNT_PROTO, NULL);
 364         modest_conf_set_string (priv->modest_conf, key,
 365                                 null_means_empty (proto), NULL);
 366         g_free (key);
 367         g_free (acckey);
 368
 369         return TRUE;            /* FIXME: better error checking */
 370 }
 371
 372 gboolean
 373 modest_account_mgr_remove_server_account (ModestAccountMgr * self,
 374                                           const gchar * name, GError ** err)
 375 {
 376         ModestAccountMgrPrivate *priv;
 377         gchar *acckey;
 378         gboolean retval;
 379
 380         g_return_val_if_fail (self, FALSE);
 381         g_return_val_if_fail (name, FALSE);
 382
 383         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 384
 385         acckey = g_strconcat (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
 386                               name, NULL);
 387
 388         if (!modest_conf_key_exists (priv->modest_conf, acckey, NULL)) {
 389                 g_warning ("server account %s does not exist exist", name);
 390                 g_free (acckey);
 391                 return FALSE;
 392         }
 393
 394         retval = modest_conf_remove_key (priv->modest_conf, acckey, NULL);
 395         g_free (acckey);
 396
 397         return retval;
 398 }
 399
 400
 401 /* strip the first /n/ character from each element */
 402 /* caller must make sure all elements are strings with
 403  * length >= n, and also that data can be freed.
 404  */
 405 static GSList *
 406 strip_prefix_from_elements (GSList * lst, guint n)
 407 {
 408         GSList *cursor = lst;
 409
 410         while (cursor) {
 411                 gchar *str = (gchar *) cursor->data;
 412
 413                 cursor->data = g_strdup (str + n);
 414                 g_free (str);
 415                 cursor = cursor->next;
 416         }
 417         return lst;
 418 }
 419
 420
 421 GSList *
 422 modest_account_mgr_server_account_names (ModestAccountMgr * self,
 423                                          const gchar * account_name,
 424                                          ModestProtoType type,
 425                                          const gchar * proto,
 426                                          gboolean only_enabled)
 427 {
 428         GSList *accounts;
 429         GSList *cursor;
 430         ModestAccountMgrPrivate *priv;
 431         const size_t prefix_len =
 432                 strlen (MODEST_SERVER_ACCOUNT_NAMESPACE "/");
 433
 434         g_return_val_if_fail (self, NULL);
 435
 436         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 437         accounts = modest_conf_list_subkeys (priv->modest_conf,
 438                                              MODEST_SERVER_ACCOUNT_NAMESPACE,
 439                                              NULL);
 440
 441         /* no restrictions, return everything */
 442         if (type == MODEST_PROTO_TYPE_ANY && !proto)
 443                 return strip_prefix_from_elements (accounts, prefix_len);
 444
 445         /* otherwise, filter out the none-matching ones */
 446         cursor = accounts;
 447         while (cursor) {
 448                 gchar *keyspace, *proto_key, *acc_proto;
 449
 450                 keyspace = (gchar *) cursor->data;
 451                 proto_key =
 452                         g_strconcat (keyspace, "/", MODEST_ACCOUNT_PROTO,
 453                                      NULL);
 454                 acc_proto =
 455                         modest_conf_get_string (priv->modest_conf, proto_key,
 456                                                 NULL);
 457                 g_free (proto_key);
 458
 459                 if ((!acc_proto) ||     /* proto not defined? */
 460                     (type != MODEST_PROTO_TYPE_ANY &&   /* proto type ...     */
 461                      modest_proto_type (acc_proto) != type) ||  /* ... matches?       */
 462                     (proto && strcmp (proto, acc_proto) != 0)) {        /* proto matches?     */
 463                         /* no match: remove from the list */
 464                         GSList *nxt = cursor->next;
 465
 466                         g_free (acc_proto);
 467                         accounts = g_slist_delete_link (accounts, cursor);
 468                         cursor = nxt;
 469                 } else
 470                         cursor = cursor->next;
 471         }
 472
 473         return strip_prefix_from_elements (accounts, prefix_len);
 474 }
 475
 476
 477 GSList *
 478 modest_account_mgr_account_names (ModestAccountMgr * self, GError ** err)
 479 {
 480         GSList *accounts;
 481         ModestAccountMgrPrivate *priv;
 482         const size_t prefix_len = strlen (MODEST_ACCOUNT_NAMESPACE "/");
 483
 484
 485         g_return_val_if_fail (self, NULL);
 486
 487         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 488
 489         accounts = modest_conf_list_subkeys (priv->modest_conf,
 490                                              MODEST_ACCOUNT_NAMESPACE, err);
 491         return strip_prefix_from_elements (accounts, prefix_len);
 492 }
 493
 494
 495 static gchar *
 496 get_account_string (ModestAccountMgr * self, const gchar * name,
 497                     const gchar * key, gboolean server_account, GError ** err)
 498 {
 499         ModestAccountMgrPrivate *priv;
 500
 501         gchar *keyname;
 502         gchar *retval;
 503
 504         g_return_val_if_fail (self, NULL);
 505         g_return_val_if_fail (name, NULL);
 506         g_return_val_if_fail (key, NULL);
 507
 508         if (server_account)
 509                 keyname = get_server_account_keyname (name, key);
 510         else
 511                 keyname = get_account_keyname (name, key);
 512
 513         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 514         retval = modest_conf_get_string (priv->modest_conf, keyname, err);
 515         g_free (keyname);
 516
 517         return retval;
 518 }
 519
 520
 521 gchar *
 522 modest_account_mgr_get_server_account_string (ModestAccountMgr * self,
 523                                               const gchar * name,
 524                                               const gchar * key,
 525                                               GError ** err)
 526 {
 527         return get_account_string (self, name, key, TRUE, err);
 528 }
 529
 530
 531 gchar *
 532 modest_account_mgr_get_account_string (ModestAccountMgr * self,
 533                                        const gchar * name, const gchar * key,
 534                                        GError ** err)
 535 {
 536         return get_account_string (self, name, key, FALSE, err);
 537 }
 538
 539
 540 static gint
 541 get_account_int (ModestAccountMgr * self, const gchar * name,
 542                  const gchar * key, gboolean server_account, GError ** err)
 543 {
 544         ModestAccountMgrPrivate *priv;
 545
 546         gchar *keyname;
 547         gint retval;
 548
 549         g_return_val_if_fail (self, -1);
 550         g_return_val_if_fail (name, -1);
 551         g_return_val_if_fail (key, -1);
 552
 553         if (server_account)
 554                 keyname = get_server_account_keyname (name, key);
 555         else
 556                 keyname = get_account_keyname (name, key);
 557
 558         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 559         retval = modest_conf_get_int (priv->modest_conf, keyname, err);
 560         g_free (keyname);
 561
 562         return retval;
 563 }
 564
 565
 566 gint
 567 modest_account_mgr_get_server_account_int (ModestAccountMgr * self,
 568                                            const gchar * name,
 569                                            const gchar * key, GError ** err)
 570 {
 571         return get_account_int (self, name, key, TRUE, err);
 572 }
 573
 574
 575 gint
 576 modest_account_mgr_get_account_int (ModestAccountMgr * self,
 577                                     const gchar * name, const gchar * key,
 578                                     GError ** err)
 579 {
 580         return get_account_int (self, name, key, FALSE, err);
 581 }
 582
 583
 584 static gboolean
 585 get_account_bool (ModestAccountMgr * self, const gchar * name,
 586                   const gchar * key, gboolean server_account, GError ** err)
 587 {
 588         ModestAccountMgrPrivate *priv;
 589
 590         gchar *keyname;
 591         gboolean retval;
 592
 593         g_return_val_if_fail (self, FALSE);
 594         g_return_val_if_fail (name, FALSE);
 595         g_return_val_if_fail (key, FALSE);
 596
 597         if (server_account)
 598                 keyname = get_server_account_keyname (name, key);
 599         else
 600                 keyname = get_account_keyname (name, key);
 601
 602         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 603         retval = modest_conf_get_bool (priv->modest_conf, keyname, err);
 604         g_free (keyname);
 605
 606         return retval;
 607 }
 608
 609
 610 gint
 611 modest_account_mgr_get_server_account_bool (ModestAccountMgr * self,
 612                                             const gchar * name,
 613                                             const gchar * key, GError ** err)
 614 {
 615         return get_account_bool (self, name, key, TRUE, err);
 616 }
 617
 618
 619 gint
 620 modest_account_mgr_get_account_bool (ModestAccountMgr * self,
 621                                      const gchar * name, const gchar * key,
 622                                      GError ** err)
 623 {
 624         return get_account_bool (self, name, key, FALSE, err);
 625 }
 626
 627
 628 static gboolean
 629 set_account_string (ModestAccountMgr * self, const gchar * name,
 630                     const gchar * key, const gchar * val,
 631                     gboolean server_account, GError ** err)
 632 {
 633         ModestAccountMgrPrivate *priv;
 634
 635         gchar *keyname;
 636         gboolean retval;
 637
 638         g_return_val_if_fail (self, FALSE);
 639         g_return_val_if_fail (name, FALSE);
 640         g_return_val_if_fail (key, FALSE);
 641
 642         if (server_account)
 643                 keyname = get_server_account_keyname (name, key);
 644         else
 645                 keyname = get_account_keyname (name, key);
 646
 647         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 648
 649         retval = modest_conf_set_string (priv->modest_conf, keyname, val,
 650                                          err);
 651
 652         g_free (keyname);
 653         return retval;
 654 }
 655
 656
 657 gboolean
 658 modest_account_mgr_set_server_account_string (ModestAccountMgr * self,
 659                                               const gchar * name,
 660                                               const gchar * key,
 661                                               const gchar * val,
 662                                               GError ** err)
 663 {
 664         return set_account_string (self, name, key, val, TRUE, err);
 665 }
 666
 667
 668 gboolean
 669 modest_account_mgr_set_account_string (ModestAccountMgr * self,
 670                                        const gchar * name, const gchar * key,
 671                                        const gchar * val, GError ** err)
 672 {
 673         return set_account_string (self, name, key, val, FALSE, err);
 674 }
 675
 676
 677 static gboolean
 678 set_account_int (ModestAccountMgr * self, const gchar * name,
 679                  const gchar * key, gboolean server_account, int val,
 680                  GError ** err)
 681 {
 682         ModestAccountMgrPrivate *priv;
 683
 684         gchar *keyname;
 685         gboolean retval;
 686
 687         g_return_val_if_fail (self, FALSE);
 688         g_return_val_if_fail (name, FALSE);
 689         g_return_val_if_fail (key, FALSE);
 690
 691         if (server_account)
 692                 keyname = get_server_account_keyname (name, key);
 693         else
 694                 keyname = get_account_keyname (name, key);
 695
 696         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 697
 698         retval = modest_conf_set_int (priv->modest_conf, keyname, val, err);
 699
 700         g_free (keyname);
 701         return retval;
 702 }
 703
 704
 705 gboolean
 706 modest_account_mgr_set_server_account_int (ModestAccountMgr * self,
 707                                            const gchar * name,
 708                                            const gchar * key, int val,
 709                                            GError ** err)
 710 {
 711         return set_account_int (self, name, key, val, TRUE, err);
 712 }
 713
 714
 715 gboolean
 716 modest_account_mgr_set_account_int (ModestAccountMgr * self,
 717                                     const gchar * name, const gchar * key,
 718                                     int val, GError ** err)
 719 {
 720         return set_account_int (self, name, key, val, FALSE, err);
 721 }
 722
 723
 724 static gboolean
 725 set_account_bool (ModestAccountMgr * self, const gchar * name,
 726                   const gchar * key, gboolean server_account, gboolean val,
 727                   GError ** err)
 728 {
 729         ModestAccountMgrPrivate *priv;
 730
 731         gchar *keyname;
 732         gboolean retval;
 733
 734         g_return_val_if_fail (self, FALSE);
 735         g_return_val_if_fail (name, FALSE);
 736         g_return_val_if_fail (key, FALSE);
 737
 738         if (server_account)
 739                 keyname = get_server_account_keyname (name, key);
 740         else
 741                 keyname = get_account_keyname (name, key);
 742
 743         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 744
 745         retval = modest_conf_set_bool (priv->modest_conf, keyname, val, err);
 746
 747         g_free (keyname);
 748         return retval;
 749 }
 750
 751
 752 gboolean
 753 modest_account_mgr_set_server_account_bool (ModestAccountMgr * self,
 754                                             const gchar * name,
 755                                             const gchar * key, gboolean val,
 756                                             GError ** err)
 757 {
 758         return set_account_bool (self, name, key, val, TRUE, err);
 759 }
 760
 761
 762 gboolean
 763 modest_account_mgr_set_account_bool (ModestAccountMgr * self,
 764                                      const gchar * name, const gchar * key,
 765                                      gboolean val, GError ** err)
 766 {
 767         return set_account_bool (self, name, key, val, FALSE, err);
 768 }
 769
 770
 771 gboolean
 772 account_exists (ModestAccountMgr * self, const gchar * name,
 773                 gboolean server_account, GError ** err)
 774 {
 775         ModestAccountMgrPrivate *priv;
 776
 777         gchar *keyname;
 778         gboolean retval;
 779
 780         g_return_val_if_fail (self, FALSE);
 781         g_return_val_if_fail (name, FALSE);
 782
 783         if (server_account)
 784                 keyname = get_server_account_keyname (name, NULL);
 785         else
 786                 keyname = get_account_keyname (name, NULL);
 787
 788         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 789         retval = modest_conf_key_exists (priv->modest_conf, keyname, err);
 790
 791         g_free (keyname);
 792         return retval;
 793 }
 794
 795
 796 gboolean
 797 modest_account_mgr_server_account_exists (ModestAccountMgr * self,
 798                                           const gchar * name, GError ** err)
 799 {
 800         return account_exists (self, name, TRUE, err);
 801 }
 802
 803
 804 gboolean
 805 modest_account_mgr_account_exists (ModestAccountMgr * self,
 806                                    const gchar * name, GError ** err)
 807 {
 808         return account_exists (self, name, FALSE, err);
 809 }
 810
 811
 812 /* must be freed by caller */
 813 static gchar *
 814 get_account_keyname (const gchar * accname, const gchar * name)
 815 {
 816         if (name)
 817                 return g_strconcat
 818                         (MODEST_ACCOUNT_NAMESPACE, "/",
 819                          accname, "/", name, NULL);
 820         else
 821                 return g_strconcat
 822                         (MODEST_ACCOUNT_NAMESPACE, "/", accname, NULL);
 823 }
 824
 825
 826 /* must be freed by caller */
 827 static gchar *
 828 get_server_account_keyname (const gchar * accname, const gchar * name)
 829 {
 830         if (name)
 831                 return g_strconcat
 832                         (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
 833                          accname, "/", name, NULL);
 834         else
 835                 return g_strconcat
 836                         (MODEST_SERVER_ACCOUNT_NAMESPACE, "/", accname, NULL);
 837 }