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