camel/camel-vee-store.c

   1 /*
   2  *  Copyright (C) 2000 Ximian Inc.
   3  *
   4  *  Authors: Michael Zucchi <notzed@ximian.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of version 2 of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this program; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 #include <string.h>
  26
  27 #include <glib.h>
  28 #include <glib/gi18n-lib.h>
  29 #include <glib/gstdio.h>
  30
  31 #include "camel-exception.h"
  32 #include "camel-private.h"
  33 #include "camel-vee-folder.h"
  34 #include "camel-vee-store.h"
  35
  36 #define d(x)
  37
  38 static CamelFolder *vee_get_folder (CamelStore *store, const char *folder_name, guint32 flags, CamelException *ex);
  39 static void vee_delete_folder(CamelStore *store, const char *folder_name, CamelException *ex);
  40 static void vee_rename_folder(CamelStore *store, const char *old, const char *new, CamelException *ex);
  41
  42 static void vee_sync (CamelStore *store, int expunge, CamelException *ex);
  43 static CamelFolder *vee_get_trash  (CamelStore *store, CamelException *ex);
  44 static CamelFolder *vee_get_junk  (CamelStore *store, CamelException *ex);
  45
  46 static CamelFolderInfo *vee_get_folder_info(CamelStore *store, const char *top, guint32 flags, CamelException *ex);
  47
  48 static void camel_vee_store_class_init (CamelVeeStoreClass *klass);
  49 static void camel_vee_store_init       (CamelVeeStore *obj);
  50 static void camel_vee_store_finalise   (CamelObject *obj);
  51
  52 static CamelStoreClass *camel_vee_store_parent;
  53
  54 CamelType
  55 camel_vee_store_get_type (void)
  56 {
  57         static CamelType type = CAMEL_INVALID_TYPE;
  58
  59         if (type == CAMEL_INVALID_TYPE) {
  60                 type = camel_type_register (camel_store_get_type (), "CamelVeeStore",
  61                                             sizeof (CamelVeeStore),
  62                                             sizeof (CamelVeeStoreClass),
  63                                             (CamelObjectClassInitFunc) camel_vee_store_class_init,
  64                                             NULL,
  65                                             (CamelObjectInitFunc) camel_vee_store_init,
  66                                             (CamelObjectFinalizeFunc) camel_vee_store_finalise);
  67         }
  68
  69         return type;
  70 }
  71
  72 static void
  73 camel_vee_store_class_init (CamelVeeStoreClass *klass)
  74 {
  75         CamelStoreClass *store_class = (CamelStoreClass *) klass;
  76
  77         camel_vee_store_parent = (CamelStoreClass *)camel_store_get_type();
  78
  79         /* virtual method overload */
  80         store_class->get_folder = vee_get_folder;
  81         store_class->rename_folder = vee_rename_folder;
  82         store_class->delete_folder = vee_delete_folder;
  83         store_class->get_folder_info = vee_get_folder_info;
  84         store_class->free_folder_info = camel_store_free_folder_info_full;
  85
  86         store_class->sync = vee_sync;
  87         store_class->get_trash = vee_get_trash;
  88         store_class->get_junk = vee_get_junk;
  89 }
  90
  91 static void
  92 camel_vee_store_init (CamelVeeStore *obj)
  93 {
  94         CamelStore *store = (CamelStore *)obj;
  95
  96         /* we dont want a vtrash/vjunk on this one */
  97         store->flags &= ~(CAMEL_STORE_VTRASH | CAMEL_STORE_VJUNK);
  98
  99         /* Set up unmatched folder */
 100         obj->unmatched_uids = g_hash_table_new (g_str_hash, g_str_equal);
 101         obj->folder_unmatched = (CamelVeeFolder *)camel_object_new (camel_vee_folder_get_type ());
 102         camel_vee_folder_construct (obj->folder_unmatched, store, CAMEL_UNMATCHED_NAME, _("Unmatched"), CAMEL_STORE_FOLDER_PRIVATE);
 103 }
 104
 105 static void
 106 cvs_free_unmatched(void *key, void *value, void *data)
 107 {
 108         g_free(key);
 109 }
 110
 111 static void
 112 camel_vee_store_finalise (CamelObject *obj)
 113 {
 114         CamelVeeStore *vstore = (CamelVeeStore *)obj;
 115
 116         g_hash_table_foreach(vstore->unmatched_uids, cvs_free_unmatched, NULL);
 117         g_hash_table_destroy(vstore->unmatched_uids);
 118         camel_object_unref(vstore->folder_unmatched);
 119 }
 120
 121 /**
 122  * camel_vee_store_new:
 123  *
 124  * Create a new #CamelVeeStore object.
 125  *
 126  * Returns new #CamelVeeStore object
 127  **/
 128 CamelVeeStore *
 129 camel_vee_store_new (void)
 130 {
 131         CamelVeeStore *new = CAMEL_VEE_STORE(camel_object_new(camel_vee_store_get_type ()));
 132         return new;
 133 }
 134
 135 /* flags
 136    1 = delete (0 = add)
 137    2 = noselect
 138 */
 139 #define CHANGE_ADD (0)
 140 #define CHANGE_DELETE (1)
 141 #define CHANGE_NOSELECT (2)
 142
 143 static void
 144 change_folder(CamelStore *store, const char *name, guint32 flags, int count)
 145 {
 146         CamelFolderInfo *fi;
 147         const char *tmp;
 148         CamelURL *url;
 149
 150         fi = g_malloc0(sizeof(*fi));
 151         fi->full_name = g_strdup(name);
 152         tmp = strrchr(name, '/');
 153         if (tmp == NULL)
 154                 tmp = name;
 155         else
 156                 tmp++;
 157         fi->name = g_strdup(tmp);
 158         url = camel_url_new("vfolder:", 0);
 159         camel_url_set_path(url, ((CamelService *)store)->url->path);
 160         if (flags & CHANGE_NOSELECT)
 161                 camel_url_set_param(url, "noselect", "yes");
 162         camel_url_set_fragment(url, name);
 163         fi->uri = camel_url_to_string(url, 0);
 164         camel_url_free(url);
 165         /*fi->url = g_strdup_printf("vfolder:%s%s#%s", ((CamelService *)store)->url->path, (flags&CHANGE_NOSELECT)?";noselect=yes":"", name);*/
 166         fi->unread = count;
 167         fi->flags = CAMEL_FOLDER_VIRTUAL;
 168         if (!(flags & CHANGE_DELETE))
 169                 fi->flags |= CAMEL_FOLDER_NOCHILDREN;
 170         camel_object_trigger_event(store, (flags&CHANGE_DELETE)?"folder_deleted":"folder_created", fi);
 171         camel_folder_info_free(fi);
 172 }
 173
 174 static CamelFolder *
 175 vee_get_folder (CamelStore *store, const char *folder_name, guint32 flags, CamelException *ex)
 176 {
 177         CamelVeeFolder *vf;
 178         CamelFolder *folder;
 179         char *name, *p;
 180
 181         vf = (CamelVeeFolder *)camel_vee_folder_new(store, folder_name, flags);
 182         if ((vf->flags & CAMEL_STORE_FOLDER_PRIVATE) == 0) {
 183                 /* Check that parents exist, if not, create dummy ones */
 184                 name = alloca(strlen(((CamelFolder *)vf)->full_name)+1);
 185                 strcpy(name, ((CamelFolder *)vf)->full_name);
 186                 p = name;
 187                 while ( (p = strchr(p, '/'))) {
 188                         *p = 0;
 189
 190                         folder = camel_object_bag_reserve(store->folders, name);
 191                         if (folder == NULL) {
 192                                 /* create a dummy vFolder for this, makes get_folder_info simpler */
 193                                 folder = camel_vee_folder_new(store, name, flags);
 194                                 camel_object_bag_add(store->folders, name, folder);
 195                                 change_folder(store, name, CHANGE_ADD|CHANGE_NOSELECT, 0);
 196                                 /* FIXME: this sort of leaks folder, nobody owns a ref to it but us */
 197                         } else {
 198                                 camel_object_unref(folder);
 199                         }
 200                         *p++='/';
 201                 }
 202
 203                 change_folder(store, ((CamelFolder *)vf)->full_name, CHANGE_ADD, camel_folder_get_message_count((CamelFolder *)vf));
 204         }
 205
 206         return (CamelFolder *)vf;
 207 }
 208
 209 static void
 210 vee_sync(CamelStore *store, int expunge, CamelException *ex)
 211 {
 212         /* noop */;
 213 }
 214
 215 static CamelFolder *
 216 vee_get_trash (CamelStore *store, CamelException *ex)
 217 {
 218         return NULL;
 219 }
 220
 221 static CamelFolder *
 222 vee_get_junk (CamelStore *store, CamelException *ex)
 223 {
 224         return NULL;
 225 }
 226
 227 static int
 228 vee_folder_cmp(const void *ap, const void *bp)
 229 {
 230         return strcmp(((CamelFolder **)ap)[0]->full_name, ((CamelFolder **)bp)[0]->full_name);
 231 }
 232
 233 static CamelFolderInfo *
 234 vee_get_folder_info(CamelStore *store, const char *top, guint32 flags, CamelException *ex)
 235 {
 236         CamelFolderInfo *info, *res = NULL, *tail;
 237         GPtrArray *folders;
 238         GHashTable *infos_hash;
 239         CamelURL *url;
 240         int i;
 241
 242         d(printf("Get folder info '%s'\n", top?top:"<null>"));
 243
 244         infos_hash = g_hash_table_new(g_str_hash, g_str_equal);
 245         folders = camel_object_bag_list(store->folders);
 246         qsort(folders->pdata, folders->len, sizeof(folders->pdata[0]), vee_folder_cmp);
 247         for (i=0;i<folders->len;i++) {
 248                 CamelVeeFolder *folder = folders->pdata[i];
 249                 int add = FALSE;
 250                 char *name = ((CamelFolder *)folder)->full_name, *pname, *tmp;
 251                 CamelFolderInfo *pinfo;
 252
 253                 d(printf("folder '%s'\n", name));
 254
 255                 /* check we have to include this one */
 256                 if (top) {
 257                         int namelen = strlen(name);
 258                         int toplen = strlen(top);
 259
 260                         add = ((namelen == toplen
 261                                 && strcmp(name, top) == 0)
 262                                || ((namelen > toplen)
 263                                    && strncmp(name, top, toplen) == 0
 264                                    && name[toplen] == '/'
 265                                    && ((flags & CAMEL_STORE_FOLDER_INFO_RECURSIVE)
 266                                        || strchr(name+toplen+1, '/') == NULL)));
 267                 } else {
 268                         add = (flags & CAMEL_STORE_FOLDER_INFO_RECURSIVE)
 269                                 || strchr(name, '/') == NULL;
 270                 }
 271
 272                 d(printf("%sadding '%s'\n", add?"":"not ", name));
 273
 274                 if (add) {
 275                         /* ensures unread is correct */
 276                         if ((flags & CAMEL_STORE_FOLDER_INFO_FAST) == 0)
 277                                 camel_folder_refresh_info((CamelFolder *)folder, NULL);
 278
 279                         info = g_malloc0(sizeof(*info));
 280                         url = camel_url_new("vfolder:", NULL);
 281                         camel_url_set_path(url, ((CamelService *)((CamelFolder *)folder)->parent_store)->url->path);
 282                         camel_url_set_fragment(url, ((CamelFolder *)folder)->full_name);
 283                         info->uri = camel_url_to_string(url, 0);
 284                         camel_url_free(url);
 285 /*
 286                         info->url = g_strdup_printf("vfolder:%s#%s", ((CamelService *)((CamelFolder *)folder)->parent_store)->url->path,
 287                         ((CamelFolder *)folder)->full_name);*/
 288                         info->full_name = g_strdup(((CamelFolder *)folder)->full_name);
 289                         info->name = g_strdup(((CamelFolder *)folder)->name);
 290                         info->unread = camel_folder_get_unread_message_count((CamelFolder *)folder);
 291                         info->flags = CAMEL_FOLDER_NOCHILDREN|CAMEL_FOLDER_VIRTUAL;
 292                         g_hash_table_insert(infos_hash, info->full_name, info);
 293
 294                         if (res == NULL)
 295                                 res = info;
 296                 } else {
 297                         info = NULL;
 298                 }
 299
 300                 /* check for parent, if present, update flags and if adding, update parent linkage */
 301                 pname = g_strdup(((CamelFolder *)folder)->full_name);
 302                 d(printf("looking up parent of '%s'\n", pname));
 303                 tmp = strrchr(pname, '/');
 304                 if (tmp) {
 305                         *tmp = 0;
 306                         pinfo = g_hash_table_lookup(infos_hash, pname);
 307                 } else
 308                         pinfo = NULL;
 309
 310                 if (pinfo) {
 311                         pinfo->flags = (pinfo->flags & ~(CAMEL_FOLDER_CHILDREN|CAMEL_FOLDER_NOCHILDREN))|CAMEL_FOLDER_CHILDREN;
 312                         d(printf("updating parent flags for children '%s' %08x\n", pinfo->full_name, pinfo->flags));
 313                         tail = pinfo->child;
 314                         if (tail == NULL)
 315                                 pinfo->child = info;
 316                 } else if (info != res) {
 317                         tail = res;
 318                 } else {
 319                         tail = NULL;
 320                 }
 321
 322                 if (info && tail) {
 323                         while (tail->next)
 324                                 tail = tail->next;
 325                         tail->next = info;
 326                         info->parent = pinfo;
 327                 }
 328
 329                 g_free(pname);
 330                 camel_object_unref(folder);
 331         }
 332         g_ptr_array_free(folders, TRUE);
 333         g_hash_table_destroy(infos_hash);
 334
 335         /* and always add UNMATCHED, if scanning from top/etc */
 336         if (top == NULL || top[0] == 0 || strncmp(top, CAMEL_UNMATCHED_NAME, strlen(CAMEL_UNMATCHED_NAME)) == 0) {
 337                 info = g_malloc0(sizeof(*info));
 338                 url = camel_url_new("vfolder:", NULL);
 339                 camel_url_set_path(url, ((CamelService *)store)->url->path);
 340                 camel_url_set_fragment(url, CAMEL_UNMATCHED_NAME);
 341                 info->uri = camel_url_to_string(url, 0);
 342                 camel_url_free(url);
 343                 /*info->url = g_strdup_printf("vfolder:%s#%s", ((CamelService *)store)->url->path, CAMEL_UNMATCHED_NAME);*/
 344                 info->full_name = g_strdup(CAMEL_UNMATCHED_NAME);
 345                 info->name = g_strdup(_("Unmatched"));
 346                 info->unread = -1;
 347                 info->flags = CAMEL_FOLDER_NOCHILDREN|CAMEL_FOLDER_NOINFERIORS|CAMEL_FOLDER_SYSTEM|CAMEL_FOLDER_VIRTUAL;
 348
 349                 if (res == NULL)
 350                         res = info;
 351                 else {
 352                         tail = res;
 353                         while (tail->next)
 354                                 tail = tail->next;
 355                         tail->next = info;
 356                 }
 357         }
 358
 359         return res;
 360 }
 361
 362 static void
 363 vee_delete_folder(CamelStore *store, const char *folder_name, CamelException *ex)
 364 {
 365         CamelFolder *folder;
 366
 367         if (strcmp(folder_name, CAMEL_UNMATCHED_NAME) == 0) {
 368                 camel_exception_setv(ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
 369                                      _("Cannot delete folder: %s: Invalid operation"), folder_name);
 370                 return;
 371         }
 372
 373         folder = camel_object_bag_get(store->folders, folder_name);
 374         if (folder) {
 375                 char *statefile;
 376
 377                 camel_object_get(folder, NULL, CAMEL_OBJECT_STATE_FILE, &statefile, NULL);
 378                 if (statefile) {
 379                         g_unlink(statefile);
 380                         camel_object_free(folder, CAMEL_OBJECT_STATE_FILE, statefile);
 381                         camel_object_set(folder, NULL, CAMEL_OBJECT_STATE_FILE, NULL, NULL);
 382                 }
 383
 384                 if ((((CamelVeeFolder *)folder)->flags & CAMEL_STORE_FOLDER_PRIVATE) == 0) {
 385                         /* what about now-empty parents?  ignore? */
 386                         change_folder(store, folder_name, CHANGE_DELETE, -1);
 387                 }
 388
 389                 camel_object_unref(folder);
 390         } else {
 391                 camel_exception_setv(ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
 392                                      _("Cannot delete folder: %s: No such folder"), folder_name);
 393         }
 394 }
 395
 396 static void
 397 vee_rename_folder(CamelStore *store, const char *old, const char *new, CamelException *ex)
 398 {
 399         CamelFolder *folder, *oldfolder;
 400         char *p, *name;
 401
 402         d(printf("vee rename folder '%s' '%s'\n", old, new));
 403
 404         if (strcmp(old, CAMEL_UNMATCHED_NAME) == 0) {
 405                 camel_exception_setv(ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
 406                                      _("Cannot rename folder: %s: Invalid operation"), old);
 407                 return;
 408         }
 409
 410         /* See if it exists, for vfolders, all folders are in the folders hash */
 411         oldfolder = camel_object_bag_get(store->folders, old);
 412         if (oldfolder == NULL) {
 413                 camel_exception_setv(ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
 414                                      _("Cannot rename folder: %s: No such folder"), old);
 415                 return;
 416         }
 417
 418         /* Check that new parents exist, if not, create dummy ones */
 419         name = alloca(strlen(new)+1);
 420         strcpy(name, new);
 421         p = name;
 422         while ( (p = strchr(p, '/'))) {
 423                 *p = 0;
 424
 425                 folder = camel_object_bag_reserve(store->folders, name);
 426                 if (folder == NULL) {
 427                         /* create a dummy vFolder for this, makes get_folder_info simpler */
 428                         folder = camel_vee_folder_new(store, name, ((CamelVeeFolder *)oldfolder)->flags);
 429                         camel_object_bag_add(store->folders, name, folder);
 430                         change_folder(store, name, CHANGE_ADD|CHANGE_NOSELECT, 0);
 431                         /* FIXME: this sort of leaks folder, nobody owns a ref to it but us */
 432                 } else {
 433                         camel_object_unref(folder);
 434                 }
 435                 *p++='/';
 436         }
 437
 438         camel_object_unref(oldfolder);
 439 }