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