diff options
Diffstat (limited to 'camel/providers/cache/camel-cache-folder.c')
-rw-r--r-- | camel/providers/cache/camel-cache-folder.c | 689 |
1 files changed, 689 insertions, 0 deletions
diff --git a/camel/providers/cache/camel-cache-folder.c b/camel/providers/cache/camel-cache-folder.c new file mode 100644 index 0000000000..0d24fb58bb --- /dev/null +++ b/camel/providers/cache/camel-cache-folder.c @@ -0,0 +1,689 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* camel-cache-folder.c : class for a cache folder */ + +/* + * Authors: + * Dan Winship <danw@helixcode.com> + * + * Copyright (C) 2000 Helix Code, Inc. (www.helixcode.com) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA + */ + + +/* + * Notes on the cache provider: + * + * We require that the remote folder have persistent UIDs, and nothing + * else. We require that the local store folder have persistent UIDs + * and summary capability. + * + * If the remote folder does not have summary capability, we will need + * to sync any new messages over to the local folder when the folder + * is opened or when it changes. If the remote folder does have + * summary capability, we can be more relaxed about doing this. + * + * If the remote folder has search capability, we will use it, at + * least when the folder isn't synced. Otherwise if the local folder + * has search capability, we will use that (but it will require + * syncing the remote folder locally to use). Otherwise the cache + * folder won't have search capability. + * + * CamelCacheFolder UIDs are remote UIDs, because we need to be able + * to return a complete list of them at get_uids time, and the + * messages might not all be present in the local folder, and we can't + * predict what UIDs will be assigned to them when they are cached + * there. We keep hash tables mapping remote to local UIDs and vice + * versa, and a map file to cache this information between sessions. + * The maps must always be 100% accurate. + * + * The messages in the local folder may not be in the same order as + * the messages in the remote folder. + * + * + * Many operations on the local folder are done with a NULL + * CamelException, because having them fail only results in efficiency + * problems, not actual permanent failures. (Eg, get_message will + * try to append the message to the local folder, but doesn't check + * for failure, because it already has the message to pass back to the + * user.) + */ + +#include "camel-cache-folder.h" +#include "camel-cache-store.h" +#include <camel/camel-exception.h> +#include <camel/camel-medium.h> + +static CamelFolderClass *parent_class; +#define CF_CLASS(so) CAMEL_FOLDER_CLASS (GTK_OBJECT(so)->klass) + +static void init (CamelFolder *folder, CamelStore *parent_store, + CamelFolder *parent_folder, const gchar *name, + gchar *separator, gboolean path_begins_with_sep, + CamelException *ex); + +static void cache_sync (CamelFolder *folder, gboolean expunge, + CamelException *ex); + +static void expunge (CamelFolder *folder, CamelException *ex); + +static gint get_message_count (CamelFolder *folder); + +static void append_message (CamelFolder *folder, CamelMimeMessage *message, + guint32 flags, CamelException *ex); + +static guint32 get_message_flags (CamelFolder *folder, const char *uid); +static void set_message_flags (CamelFolder *folder, const char *uid, + guint32 flags, guint32 set); +static gboolean get_message_user_flag (CamelFolder *folder, const char *uid, + const char *name); +static void set_message_user_flag (CamelFolder *folder, const char *uid, + const char *name, gboolean value); + +static CamelMimeMessage *get_message (CamelFolder *folder, + const gchar *uid, + CamelException *ex); + +static GPtrArray *get_uids (CamelFolder *folder); +static GPtrArray *get_summary (CamelFolder *folder); +static GPtrArray *get_subfolder_names (CamelFolder *folder); +static void free_subfolder_names (CamelFolder *folder, GPtrArray *subfolders); + +static GPtrArray *search_by_expression (CamelFolder *folder, + const char *expression, + CamelException *ex); + +static const CamelMessageInfo *get_message_info (CamelFolder *folder, + const char *uid); + +static void finalize (GtkObject *object); + +static void +camel_cache_folder_class_init (CamelCacheFolderClass *camel_cache_folder_class) +{ + CamelFolderClass *camel_folder_class = + CAMEL_FOLDER_CLASS (camel_cache_folder_class); + GtkObjectClass *gtk_object_class = + GTK_OBJECT_CLASS (camel_cache_folder_class); + + parent_class = gtk_type_class (camel_folder_get_type ()); + + /* virtual method overload */ + camel_folder_class->init = init; + camel_folder_class->sync = cache_sync; + camel_folder_class->expunge = expunge; + camel_folder_class->get_message_count = get_message_count; + camel_folder_class->append_message = append_message; + camel_folder_class->get_message_flags = get_message_flags; + camel_folder_class->set_message_flags = set_message_flags; + camel_folder_class->get_message_user_flag = get_message_user_flag; + camel_folder_class->set_message_user_flag = set_message_user_flag; + camel_folder_class->get_message = get_message; + camel_folder_class->get_uids = get_uids; + camel_folder_class->free_uids = camel_folder_free_nop; + camel_folder_class->get_summary = get_summary; + camel_folder_class->free_summary = camel_folder_free_nop; + camel_folder_class->get_subfolder_names = get_subfolder_names; + camel_folder_class->free_subfolder_names = free_subfolder_names; + camel_folder_class->search_by_expression = search_by_expression; + camel_folder_class->get_message_info = get_message_info; + + gtk_object_class->finalize = finalize; +} + +GtkType +camel_cache_folder_get_type (void) +{ + static GtkType camel_cache_folder_type = 0; + + if (!camel_cache_folder_type) { + GtkTypeInfo camel_cache_folder_info = + { + "CamelCacheFolder", + sizeof (CamelCacheFolder), + sizeof (CamelCacheFolderClass), + (GtkClassInitFunc) camel_cache_folder_class_init, + (GtkObjectInitFunc) NULL, + /* reserved_1 */ NULL, + /* reserved_2 */ NULL, + (GtkClassInitFunc) NULL, + }; + + camel_cache_folder_type = gtk_type_unique (CAMEL_FOLDER_TYPE, &camel_cache_folder_info); + } + + return camel_cache_folder_type; +} + + +static void +cache_free_summary (CamelCacheFolder *cache_folder) +{ + if (cache_folder->remote_summary) { + camel_folder_free_summary (cache_folder->remote, + cache_folder->summary); + } else { + int i; + + for (i = 0; i < cache_folder->summary->len; i++) { + camel_message_info_free ( + cache_folder->summary->pdata[i]); + } + g_ptr_array_free (cache_folder->summary, TRUE); + g_hash_table_destroy (cache_folder->summary_uids); + } +} + +static void +finalize (GtkObject *object) +{ + CamelCacheFolder *cache_folder = CAMEL_CACHE_FOLDER (object); + + if (cache_folder->uids) { + camel_folder_free_uids (cache_folder->remote, + cache_folder->uids); + } + if (cache_folder->summary) + cache_free_summary (cache_folder); + + if (cache_folder->uidmap) + camel_cache_map_destroy (cache_folder->uidmap); + + gtk_object_unref (GTK_OBJECT (cache_folder->local)); + gtk_object_unref (GTK_OBJECT (cache_folder->remote)); + + g_free (cache_folder->mapfile); + + GTK_OBJECT_CLASS (parent_class)->finalize (object); +} + + +static void +update (CamelCacheFolder *cache_folder, CamelException *ex) +{ + if (cache_folder->uids) { + camel_folder_free_uids (cache_folder->remote, + cache_folder->uids); + } + cache_folder->uids = camel_folder_get_uids (cache_folder->remote); + + if (cache_folder->summary) + cache_free_summary (cache_folder); + + if (cache_folder->remote_summary) { + cache_folder->summary = + camel_folder_get_summary (cache_folder->remote); + } else { + CamelMessageInfo *mi; + GPtrArray *lsummary; + const char *ruid; + int i; + + if (!cache_folder->is_synced) { + camel_cache_folder_sync (cache_folder, ex); + if (camel_exception_is_set (ex)) + return; + } + + cache_folder->summary = g_ptr_array_new (); + cache_folder->summary_uids = g_hash_table_new (g_str_hash, + g_str_equal); + + lsummary = camel_folder_get_summary (cache_folder->local); + + /* For each local message, duplicate its info, replace + * the uid with the remote one, and add it to the + * uid->info cache. + */ + for (i = 0; i < lsummary->len; i++) { + mi = lsummary->pdata[i]; + ruid = camel_cache_map_get_remote (cache_folder->uidmap, mi->uid); + if (!ruid) { + /* Stale message. Delete it from cache. */ + camel_folder_delete_message ( + cache_folder->local, mi->uid); + continue; + } + + mi = g_new (CamelMessageInfo, 1); + camel_message_info_dup_to (lsummary->pdata[i], mi); + g_free (mi->uid); + mi->uid = g_strdup (ruid); + g_hash_table_insert (cache_folder->summary_uids, + mi->uid, mi); + } + camel_folder_free_summary (cache_folder->local, lsummary); + + /* Now build the summary array in remote UID order. */ + for (i = 0; i < cache_folder->uids->len; i++) { + mi = g_hash_table_lookup (cache_folder->summary_uids, + cache_folder->uids->pdata[i]); + g_ptr_array_add (cache_folder->summary, mi); + } + } + +} + +static void +init (CamelFolder *folder, CamelStore *parent_store, + CamelFolder *parent_folder, const gchar *name, gchar *separator, + gboolean path_begins_with_sep, CamelException *ex) +{ + CamelCacheFolder *cache_folder = (CamelCacheFolder *)folder; + char *path; + + CF_CLASS (folder)->init (folder, parent_store, parent_folder, + name, separator, path_begins_with_sep, ex); + if (camel_exception_is_set (ex)) + return; + + folder->permanent_flags = + camel_folder_get_permanent_flags (cache_folder->local); + folder->can_hold_folders = cache_folder->remote->can_hold_folders; + folder->can_hold_messages = cache_folder->remote->can_hold_messages; + folder->has_summary_capability = TRUE; + folder->has_search_capability = + camel_folder_has_search_capability (cache_folder->local) || + camel_folder_has_search_capability (cache_folder->remote); + + cache_folder->remote_summary = + camel_folder_has_summary_capability (cache_folder->remote); + + /* Load UIDs, summary, etc. */ + path = CAMEL_SERVICE (cache_folder->local->parent_store)->url->path; + cache_folder->mapfile = g_strdup_printf ("%s/%s.map", path, name); + cache_folder->uidmap = camel_cache_map_new (); + camel_cache_map_read (cache_folder->uidmap, cache_folder->mapfile, ex); + if (camel_exception_is_set (ex)) + return; + update (cache_folder, ex); + + return; +} + +/* If the remote folder changes, cache the new messages if necessary, + * update the summary, and propagate the signal. + */ +static void +remote_folder_changed (CamelFolder *remote_folder, int type, gpointer data) +{ + CamelCacheFolder *cache_folder = data; + + update (cache_folder, NULL); + gtk_signal_emit_by_name (GTK_OBJECT (cache_folder), "folder_changed", + type); +} + +/* If the local folder changes, it's because we just cached a message + * or expunged messages. Look for new messages and update the UID maps. + */ +static void +local_folder_changed (CamelFolder *local_folder, int type, gpointer data) +{ + CamelCacheFolder *cache_folder = data; + CamelMimeMessage *msg; + GPtrArray *new_luids; + char *luid; + const char *ruid; + int i; + + /* Get the updated list of local UIDs. For any that we didn't + * already know about, figure out the corresponding remote + * UID. + */ + new_luids = camel_folder_get_uids (local_folder); + for (i = 0; i < new_luids->len; i++) { + luid = new_luids->pdata[i]; + if (!camel_cache_map_get_remote (cache_folder->uidmap, luid)) { + msg = camel_folder_get_message (local_folder, + luid, NULL); + if (!msg) + continue; /* Hrmph. */ + ruid = camel_medium_get_header (CAMEL_MEDIUM (msg), + "X-Evolution-Remote-UID"); + if (!ruid) { + /* How'd that get here? */ + camel_folder_delete_message (local_folder, + luid); + continue; + } + + camel_cache_map_update (cache_folder->uidmap, + luid, ruid); + } + } + camel_folder_free_uids (local_folder, new_luids); + + /* FIXME: the uidmaps contain bad data now. */ +} + +/* DONE */ +static void +cache_sync (CamelFolder *folder, gboolean expunge, CamelException *ex) +{ + CamelCacheFolder *cache_folder = (CamelCacheFolder *)folder; + + camel_folder_sync (cache_folder->remote, expunge, ex); + if (!camel_exception_is_set (ex)) { + camel_folder_sync (cache_folder->local, expunge, NULL); + camel_cache_map_write (cache_folder->uidmap, + cache_folder->mapfile, ex); + } +} + +/* DONE */ +static void +expunge (CamelFolder *folder, CamelException *ex) +{ + CamelCacheFolder *cache_folder = (CamelCacheFolder *)folder; + + camel_folder_expunge (cache_folder->remote, ex); + if (!camel_exception_is_set (ex)) + camel_folder_expunge (cache_folder->local, NULL); +} + +/* DONE */ +static gint +get_message_count (CamelFolder *folder) +{ + CamelCacheFolder *cache_folder = (CamelCacheFolder *)folder; + + return cache_folder->summary->len; +} + +/* DONE */ +static void +append_message (CamelFolder *folder, CamelMimeMessage *message, + guint32 flags, CamelException *ex) +{ + CamelCacheFolder *cache_folder = (CamelCacheFolder *)folder; + + /* We'd like to cache this locally as well, but we have no + * 100% reliable way to determine the UID assigned to the + * remote message, so we can't. + */ + camel_folder_append_message (cache_folder->remote, message, flags, ex); +} + +/* DONE */ +static guint32 +get_message_flags (CamelFolder *folder, const char *uid) +{ + const CamelMessageInfo *mi; + + mi = get_message_info (folder, uid); + g_return_val_if_fail (mi != NULL, 0); + return mi->flags; +} + +/* DONE */ +static void +set_message_flags (CamelFolder *folder, const char *uid, + guint32 flags, guint32 set) +{ + CamelCacheFolder *cache_folder = (CamelCacheFolder *)folder; + const char *luid; + + luid = camel_cache_map_get_local (cache_folder->uidmap, uid); + if (luid) { + camel_folder_set_message_flags (cache_folder->local, luid, + flags, set); + } + camel_folder_set_message_flags (cache_folder->remote, uid, flags, set); +} + +/* DONE */ +static gboolean +get_message_user_flag (CamelFolder *folder, const char *uid, const char *name) +{ + const CamelMessageInfo *mi; + + mi = get_message_info (folder, uid); + g_return_val_if_fail (mi != NULL, 0); + return camel_flag_get ((CamelFlag **)&mi->user_flags, name); +} + +/* DONE */ +static void +set_message_user_flag (CamelFolder *folder, const char *uid, + const char *name, gboolean value) +{ + CamelCacheFolder *cache_folder = (CamelCacheFolder *)folder; + const char *luid; + + luid = camel_cache_map_get_local (cache_folder->uidmap, uid); + if (luid) { + camel_folder_set_message_user_flag (cache_folder->local, luid, + name, value); + } + camel_folder_set_message_user_flag (cache_folder->remote, uid, + name, value); +} + + +/* DONE */ +static CamelMimeMessage * +get_message (CamelFolder *folder, const gchar *uid, CamelException *ex) +{ + CamelCacheFolder *cache_folder = (CamelCacheFolder *)folder; + CamelMimeMessage *msg; + guint32 flags; + const char *luid; + + /* Check if we have it cached first. */ + luid = camel_cache_map_get_local (cache_folder->uidmap, uid); + if (luid) { + msg = camel_folder_get_message (cache_folder->local, + luid, NULL); + if (msg) + return msg; + + /* Hm... Oh well. Update the map and try for real. */ + camel_cache_map_remove (cache_folder->uidmap, NULL, uid); + } + + /* OK. It's not cached. Get the remote message. */ + msg = camel_folder_get_message (cache_folder->remote, uid, ex); + if (!msg) + return NULL; + flags = camel_folder_get_message_flags (cache_folder->remote, uid); + + /* Add a header giving the remote UID and append it to the + * local folder. (This should eventually invoke + * local_folder_changed(), which will take care of updating + * the uidmaps.) + */ + camel_medium_add_header (CAMEL_MEDIUM (msg), "X-Evolution-Remote-UID", + uid); + camel_folder_append_message (cache_folder->local, msg, flags, NULL); + + return msg; +} + +/* DONE */ +static GPtrArray * +get_uids (CamelFolder *folder) +{ + CamelCacheFolder *cache_folder = (CamelCacheFolder *)folder; + + return cache_folder->uids; +} + +/* DONE */ +static GPtrArray * +get_summary (CamelFolder *folder) +{ + CamelCacheFolder *cache_folder = (CamelCacheFolder *)folder; + + return cache_folder->summary; +} + +/* DONE */ +static GPtrArray * +get_subfolder_names (CamelFolder *folder) +{ + CamelCacheFolder *cache_folder = (CamelCacheFolder *)folder; + + return camel_folder_get_subfolder_names (cache_folder->remote); +} + +/* DONE */ +static void +free_subfolder_names (CamelFolder *folder, GPtrArray *subfolders) +{ + CamelCacheFolder *cache_folder = (CamelCacheFolder *)folder; + + camel_folder_free_subfolder_names (cache_folder->remote, subfolders); +} + +/* DONE */ +static GPtrArray * +search_by_expression (CamelFolder *folder, const char *expression, + CamelException *ex) +{ + CamelCacheFolder *cache_folder = (CamelCacheFolder *)folder; + + /* Search on the remote folder if we're not synced. */ + if (!cache_folder->is_synced && + camel_folder_has_search_capability (cache_folder->remote)) { + return camel_folder_search_by_expression (cache_folder->remote, + expression, ex); + } else { + GPtrArray *matches; + const char *ruid; + int i; + + if (!cache_folder->is_synced) + camel_cache_folder_sync (cache_folder, ex); + if (camel_exception_is_set (ex)) + return NULL; + matches = search_by_expression (cache_folder->local, + expression, ex); + if (camel_exception_is_set (ex)) + return NULL; + + /* Convert local uids to remote. */ + for (i = 0; i < matches->len; i++) { + ruid = camel_cache_map_get_remote (cache_folder->uidmap, + matches->pdata[i]); + g_free (matches->pdata[i]); + matches->pdata[i] = g_strdup (ruid); + } + + return matches; + } +} + +/* DONE */ +static const CamelMessageInfo * +get_message_info (CamelFolder *folder, const char *uid) +{ + CamelCacheFolder *cache_folder = (CamelCacheFolder *)folder; + + if (cache_folder->remote_summary) { + return camel_folder_get_message_info (cache_folder->remote, + uid); + } else + return g_hash_table_lookup (cache_folder->summary_uids, uid); +} + + +CamelFolder * +camel_cache_folder_new (CamelStore *store, CamelFolder *parent, + CamelFolder *remote, CamelFolder *local) +{ + CamelCacheFolder *cache_folder; + CamelFolder *folder; + + cache_folder = gtk_type_new (CAMEL_CACHE_FOLDER_TYPE); + folder = (CamelFolder *)cache_folder; + + cache_folder->local = local; + gtk_object_ref (GTK_OBJECT (local)); + gtk_signal_connect (GTK_OBJECT (local), "folder_changed", + GTK_SIGNAL_FUNC (local_folder_changed), + cache_folder); + + cache_folder->remote = remote; + gtk_object_ref (GTK_OBJECT (remote)); + gtk_signal_connect (GTK_OBJECT (remote), "folder_changed", + GTK_SIGNAL_FUNC (remote_folder_changed), + cache_folder); + + /* XXX */ + + return folder; +} + +void +camel_cache_folder_sync (CamelCacheFolder *cache_folder, CamelException *ex) +{ + CamelMimeMessage *msg; + const char *ruid, *luid; + int lsize, i; + guint32 flags; + + lsize = camel_folder_get_message_count (cache_folder->local); + + camel_folder_freeze (cache_folder->local); + for (i = 0; i < cache_folder->uids->len; i++) { + ruid = cache_folder->uids->pdata[i]; + luid = camel_cache_map_get_local (cache_folder->uidmap, ruid); + + /* Don't re-copy messages we already have. */ + if (luid && + camel_folder_get_message_info (cache_folder->local, luid)) + continue; + + msg = camel_folder_get_message (cache_folder->remote, + ruid, ex); + if (camel_exception_is_set (ex)) + return; + flags = camel_folder_get_message_flags (cache_folder->remote, + ruid); + + camel_medium_add_header (CAMEL_MEDIUM (msg), + "X-Evolution-Remote-UID", ruid); + camel_folder_append_message (cache_folder->local, msg, + flags, ex); + if (camel_exception_is_set (ex)) + return; + } + camel_folder_thaw (cache_folder->local); +} + +static void +get_mappings (CamelCacheFolder *cache_folder, int first, CamelException *ex) +{ + GPtrArray *uids; + CamelMimeMessage *msg; + const char *ruid; + int i; + + uids = camel_folder_get_uids (cache_folder->local); + for (i = first; i < uids->len; i++) { + msg = camel_folder_get_message (cache_folder->local, + uids->pdata[i], ex); + if (!msg) + break; + ruid = camel_medium_get_header (CAMEL_MEDIUM (msg), + "X-Evolution-Remote-UID"); + + camel_cache_map_add (cache_folder->uidmap, + uids->pdata[i], ruid); + } + camel_folder_free_uids (cache_folder->local, uids); +} |