From 7a21e4e9044d17d340e6e3ba2fbc4b110123d9f3 Mon Sep 17 00:00:00 2001 From: Dan Winship Date: Tue, 5 Sep 2000 20:33:05 +0000 Subject: Cache provider, for caching a remote store locally. This is not done yet. svn path=/trunk/; revision=5206 --- camel/providers/cache/Makefile.am | 35 ++ camel/providers/cache/camel-cache-folder.c | 689 +++++++++++++++++++++++++++ camel/providers/cache/camel-cache-folder.h | 87 ++++ camel/providers/cache/camel-cache-map.c | 255 ++++++++++ camel/providers/cache/camel-cache-map.h | 64 +++ camel/providers/cache/camel-cache-provider.c | 51 ++ camel/providers/cache/camel-cache-store.c | 222 +++++++++ camel/providers/cache/camel-cache-store.h | 67 +++ camel/providers/cache/libcamelcache.urls | 1 + 9 files changed, 1471 insertions(+) create mode 100644 camel/providers/cache/Makefile.am create mode 100644 camel/providers/cache/camel-cache-folder.c create mode 100644 camel/providers/cache/camel-cache-folder.h create mode 100644 camel/providers/cache/camel-cache-map.c create mode 100644 camel/providers/cache/camel-cache-map.h create mode 100644 camel/providers/cache/camel-cache-provider.c create mode 100644 camel/providers/cache/camel-cache-store.c create mode 100644 camel/providers/cache/camel-cache-store.h create mode 100644 camel/providers/cache/libcamelcache.urls diff --git a/camel/providers/cache/Makefile.am b/camel/providers/cache/Makefile.am new file mode 100644 index 0000000000..7f9f6a9df5 --- /dev/null +++ b/camel/providers/cache/Makefile.am @@ -0,0 +1,35 @@ +## Process this file with automake to produce Makefile.in + +SUBDIRS = + +libcamelcacheincludedir = $(includedir)/camel + +providerdir = $(pkglibdir)/camel-providers/$(VERSION) + +provider_LTLIBRARIES = libcamelcache.la +provider_DATA = libcamelcache.urls + +INCLUDES = \ + -I.. \ + -I$(srcdir)/.. \ + -I$(srcdir)/../../.. \ + -I$(includedir) \ + -I$(top_srcdir)/intl \ + $(GTK_INCLUDEDIR) \ + -I$(top_srcdir)/camel \ + -DG_LOG_DOMAIN=\"camel-cache-provider\" + +libcamelcache_la_SOURCES = \ + camel-cache-folder.c \ + camel-cache-provider.c \ + camel-cache-store.c \ + camel-cache-map.c + +libcamelcacheinclude_HEADERS = \ + camel-cache-folder.h \ + camel-cache-store.h + + +libcamelcache_la_LDFLAGS = -version-info 0:0:0 + +EXTRA_DIST = libcamelcache.urls 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 + * + * 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 +#include + +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); +} diff --git a/camel/providers/cache/camel-cache-folder.h b/camel/providers/cache/camel-cache-folder.h new file mode 100644 index 0000000000..4f30c701b2 --- /dev/null +++ b/camel/providers/cache/camel-cache-folder.h @@ -0,0 +1,87 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* camel-cache-folder.h: Class for a cache folder */ + +/* + * Author: + * Dan Winship + * + * 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 + */ + +#ifndef CAMEL_CACHE_FOLDER_H +#define CAMEL_CACHE_FOLDER_H 1 + +#ifdef __cplusplus +extern "C" { +#pragma } +#endif /* __cplusplus }*/ + +#include +#include "camel-cache-map.h" + +#define CAMEL_CACHE_FOLDER_TYPE (camel_cache_folder_get_type ()) +#define CAMEL_CACHE_FOLDER(obj) (GTK_CHECK_CAST((obj), CAMEL_CACHE_FOLDER_TYPE, CamelCacheFolder)) +#define CAMEL_CACHE_FOLDER_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_CACHE_FOLDER_TYPE, CamelCacheFolderClass)) +#define IS_CAMEL_CACHE_FOLDER(o) (GTK_CHECK_TYPE((o), CAMEL_CACHE_FOLDER_TYPE)) + + +typedef struct { + CamelFolder parent_object; + + /* Remote and local folders */ + CamelFolder *remote, *local; + + /* Remote UIDs, in order, summary, and uid->info map if + * summary is from local info. + */ + GPtrArray *uids, *summary; + GHashTable *summary_uids; + + /* UID map */ + CamelCacheMap *uidmap; + char *mapfile; + + /* Is the summary remote? Is the folder known to be synced? */ + gboolean remote_summary, is_synced; + +} CamelCacheFolder; + + + +typedef struct { + CamelFolderClass parent_class; + + /* Virtual methods */ + +} CamelCacheFolderClass; + + +CamelFolder *camel_cache_folder_new (CamelStore *store, CamelFolder *parent, + CamelFolder *remote, CamelFolder *local); + +void camel_cache_folder_sync (CamelCacheFolder *cache_folder, + CamelException *ex); + +/* Standard Gtk function */ +GtkType camel_cache_folder_get_type (void); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* CAMEL_CACHE_FOLDER_H */ diff --git a/camel/providers/cache/camel-cache-map.c b/camel/providers/cache/camel-cache-map.c new file mode 100644 index 0000000000..d3cece6f60 --- /dev/null +++ b/camel/providers/cache/camel-cache-map.c @@ -0,0 +1,255 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* camel-cache-map.c : functions for a local<->remote uid map */ + +/* + * Authors: + * Dan Winship + * + * 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 + */ + +#include "camel-cache-map.h" +#include + +#include +#include +#include +#include +#include +#include + +/** + * camel_cache_map_new: + * + * Return value: a new CamelCacheMap + **/ +CamelCacheMap * +camel_cache_map_new (void) +{ + CamelCacheMap *map = g_new (CamelCacheMap, 1); + + map->l2r = g_hash_table_new (g_str_hash, g_str_equal); + map->r2l = g_hash_table_new (g_str_hash, g_str_equal); + + return map; +} + +static void +free_mapping (gpointer key, gpointer value, gpointer data) +{ + g_free (key); + g_free (data); +} + +/** + * camel_cache_map_destroy: + * @map: a CamelCacheMap + * + * Frees @map and all of the data stored in it. + **/ +void +camel_cache_map_destroy (CamelCacheMap *map) +{ + g_hash_table_foreach (map->l2r, free_mapping, NULL); + g_hash_table_destroy (map->l2r); + g_hash_table_destroy (map->r2l); + g_free (map); +} + +/** + * camel_cache_map_add: + * @map: a CamelCacheMap + * @luid: the local uid + * @ruid: the remote uid + * + * Adds a mapping between @luid and @ruid. If either already exists + * in the map, this may leak memory and result in incorrect map entries. + * Use camel_cache_map_update() in that case instead. + **/ +void +camel_cache_map_add (CamelCacheMap *map, const char *luid, const char *ruid) +{ + char *map_luid = g_strdup (luid); + char *map_ruid = g_strdup (ruid); + + g_hash_table_insert (map->l2r, map_luid, map_ruid); + g_hash_table_insert (map->r2l, map_ruid, map_luid); +} + +/** + * camel_cache_map_remove: + * @map: a CamelCacheMap + * @luid: the local uid + * @ruid: the remote uid + * + * Removes the mapping between @luid and @ruid. Either (but not both) + * of the uids can be %NULL if they are not both known. + **/ +void +camel_cache_map_remove (CamelCacheMap *map, const char *luid, const char *ruid) +{ + gpointer map_luid, map_ruid; + + if ((luid && g_hash_table_lookup_extended (map->l2r, luid, + &map_luid, &map_ruid)) || + (ruid && g_hash_table_lookup_extended (map->r2l, ruid, + &map_luid, &map_ruid))) { + g_hash_table_remove (map->l2r, map_luid); + g_hash_table_remove (map->r2l, map_ruid); + g_free (map_luid); + g_free (map_ruid); + } +} + +/** + * camel_cache_map_update: + * @map: a CamelCacheMap + * @luid: the local uid + * @ruid: the remote uid + * + * Updates the mappings to associate @luid with @ruid, clearing any + * previous mappings for both of them. + **/ +void +camel_cache_map_update (CamelCacheMap *map, const char *luid, const char *ruid) +{ + camel_cache_map_remove (map, luid, ruid); + camel_cache_map_add (map, luid, ruid); +} + +/** + * camel_cache_map_get_local + * @map: a CamelCacheMap + * @ruid: the remote uid + * + * Return value: the corresponding local uid, or %NULL + **/ +const char * +camel_cache_map_get_local (CamelCacheMap *map, const char *ruid) +{ + return g_hash_table_lookup (map->r2l, ruid); +} + +/** + * camel_cache_map_get_remote + * @map: a CamelCacheMap + * @luid: the local uid + * + * Return value: the corresponding remote uid, or %NULL + **/ +const char * +camel_cache_map_get_remote (CamelCacheMap *map, const char *luid) +{ + return g_hash_table_lookup (map->l2r, luid); +} + + + +static void +write_mapping (gpointer key, gpointer value, gpointer user_data) +{ + int fd = *(int *)user_data; + + /* FIXME: We assume the local UID has no ':'s in it. */ + write (fd, key, strlen (key)); + write (fd, ":", 1); + write (fd, value, strlen (value)); + write (fd, "\n", 1); +} + +/** + * camel_cache_map_write: + * @map: a CamelCacheMap + * @file: the filename to write the map to + * @ex: a CamelException + * + * Writes @map out to @file, setting @ex if something goes wrong. + **/ +void +camel_cache_map_write (CamelCacheMap *map, const char *file, + CamelException *ex) +{ + int fd; + char *tmpfile; + + tmpfile = g_strdup_printf ("%s~", file); + fd = open (tmpfile, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR); + if (fd == -1) { + g_free (tmpfile); + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + "Could not create cache map file: %s", + g_strerror (errno)); + return; + } + + g_hash_table_foreach (map->l2r, write_mapping, &fd); + + if (close (fd) == -1 || + rename (tmpfile, file) == -1) { + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + "Could not save cache map file: %s", + g_strerror (errno)); + unlink (tmpfile); + } + g_free (tmpfile); +} + +/** + * camel_cache_map_read: + * @map: a CamelCacheMap + * @file: the filename to read the map from + * @ex: a CamelException + * + * Reads @map from @file, setting @ex if something goes wrong. @map + * should be a freshly-created CamelCacheMap. + **/ +void +camel_cache_map_read (CamelCacheMap *map, const char *file, CamelException *ex) +{ + FILE *f; + char buf[1024], *p, *q; + + /* FIXME: lazy implementation. We could make this work with + * lines longer than 1024 chars. :) + */ + + f = fopen (file, "r"); + if (!f) { + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + "Could not open cache map file: %s", + g_strerror (errno)); + return; + } + + while (fgets (buf, sizeof (buf), f)) { + p = strchr (buf, ':'); + if (p) + q = strchr (buf, '\n'); + if (!p || !q) { + camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, + "Bad cache file."); + return; + } + *p++ = *q = '\0'; + + /* Local uid at buf, remote at p. */ + camel_cache_map_add (map, buf, p); + } + + fclose (f); +} diff --git a/camel/providers/cache/camel-cache-map.h b/camel/providers/cache/camel-cache-map.h new file mode 100644 index 0000000000..a15c9afe1a --- /dev/null +++ b/camel/providers/cache/camel-cache-map.h @@ -0,0 +1,64 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* camel-cache-map.h: functions for dealing with UID maps */ + +/* + * Author: + * Dan Winship + * + * 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 + */ + +#ifndef CAMEL_CACHE_MAP_H +#define CAMEL_CACHE_MAP_H 1 + +#ifdef __cplusplus +extern "C" { +#pragma } +#endif /* __cplusplus }*/ + +#include +#include + +typedef struct { + GHashTable *l2r, *r2l; +} CamelCacheMap; + +CamelCacheMap *camel_cache_map_new (void); +void camel_cache_map_destroy (CamelCacheMap *map); + +void camel_cache_map_add (CamelCacheMap *map, const char *luid, + const char *ruid); +void camel_cache_map_remove (CamelCacheMap *map, const char *luid, + const char *ruid); +void camel_cache_map_update (CamelCacheMap *map, const char *luid, + const char *ruid); + +const char *camel_cache_map_get_local (CamelCacheMap *map, const char *ruid); +const char *camel_cache_map_get_remote (CamelCacheMap *map, const char *luid); + +void camel_cache_map_write (CamelCacheMap *map, const char *file, + CamelException *ex); +void camel_cache_map_read (CamelCacheMap *map, const char *file, + CamelException *ex); + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* CAMEL_CACHE_MAP_H */ diff --git a/camel/providers/cache/camel-cache-provider.c b/camel/providers/cache/camel-cache-provider.c new file mode 100644 index 0000000000..2d17a62df4 --- /dev/null +++ b/camel/providers/cache/camel-cache-provider.c @@ -0,0 +1,51 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* camel-cache-provider.c: cache provider registration code */ + +/* + * Authors : + * Dan Winship + * + * 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 + */ + +#include "config.h" +#include "camel-cache-store.h" +#include "camel-provider.h" +#include "camel-session.h" + +static CamelProvider cache_provider = { + "cache", + "Cache", + + "For caching remote mail into a local store." + + "cache", + + 0, + + { 0, 0 } +}; + +void +camel_provider_module_init (CamelSession *session) +{ + cache_provider.object_types[CAMEL_PROVIDER_STORE] = + camel_cache_store_get_type(); + + camel_session_register_provider (session, &cache_provider); +} diff --git a/camel/providers/cache/camel-cache-store.c b/camel/providers/cache/camel-cache-store.c new file mode 100644 index 0000000000..ce34a0e716 --- /dev/null +++ b/camel/providers/cache/camel-cache-store.c @@ -0,0 +1,222 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* camel-cache-store.c : class for a cache store */ + +/* + * Authors: + * Dan Winship + * + * 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 + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "camel-cache-store.h" +#include "camel-cache-folder.h" +#include "camel-stream-buffer.h" +#include "camel-stream-fs.h" +#include "camel-session.h" +#include "camel-exception.h" +#include "camel-url.h" +#include "md5-utils.h" + +static CamelServiceClass *service_class = NULL; + +static void finalize (GtkObject *object); + +static gboolean cache_connect (CamelService *service, CamelException *ex); +static gboolean cache_disconnect (CamelService *service, CamelException *ex); + +static CamelFolder *get_folder (CamelStore *store, const char *folder_name, + gboolean create, CamelException *ex); +static CamelFolder *delete_folder (CamelStore *store, const char *folder_name, + CamelException *ex); +static char *get_folder_name (CamelStore *store, const char *folder_name, + CamelException *ex); +static char *get_root_folder_name (CamelStore *store, CamelException *ex); +static char *get_default_folder_name (CamelStore *store, CamelException *ex); + + +static void +camel_cache_store_class_init (CamelCacheStoreClass *camel_cache_store_class) +{ + GtkObjectClass *object_class = + GTK_OBJECT_CLASS (camel_cache_store_class); + CamelServiceClass *camel_service_class = + CAMEL_SERVICE_CLASS (camel_cache_store_class); + CamelStoreClass *camel_store_class = + CAMEL_STORE_CLASS (camel_cache_store_class); + + service_class = gtk_type_class (camel_service_get_type ()); + + /* virtual method overload */ + object_class->finalize = finalize; + + camel_service_class->connect = cache_connect; + camel_service_class->disconnect = cache_disconnect; + + camel_store_class->get_folder = get_folder; + camel_store_class->delete_folder = delete_folder; + camel_store_class->get_folder_name = get_folder_name; + camel_store_class->get_root_folder_name = get_root_folder_name; + camel_store_class->get_default_folder_name = get_default_folder_name; +} + + +static void +camel_cache_store_init (gpointer object, gpointer klass) +{ + CamelCacheStore *cache_store = CAMEL_CACHE_STORE (object); + CamelService *service = CAMEL_SERVICE (object); + + service->url_flags = CAMEL_SERVICE_URL_NEED_PATH; +} + + +GtkType +camel_cache_store_get_type (void) +{ + static GtkType camel_cache_store_type = 0; + + if (!camel_cache_store_type) { + GtkTypeInfo camel_cache_store_info = + { + "CamelCacheStore", + sizeof (CamelCacheStore), + sizeof (CamelCacheStoreClass), + (GtkClassInitFunc) camel_cache_store_class_init, + (GtkObjectInitFunc) camel_cache_store_init, + /* reserved_1 */ NULL, + /* reserved_2 */ NULL, + (GtkClassInitFunc) NULL, + }; + + camel_cache_store_type = gtk_type_unique (CAMEL_STORE_TYPE, &camel_cache_store_info); + } + + return camel_cache_store_type; +} + +static void +finalize (GtkObject *object) +{ + CamelCacheStore *cache_store = CAMEL_CACHE_STORE (object); + + gtk_object_unref (GTK_OBJECT (cache_store->local)); + gtk_object_unref (GTK_OBJECT (cache_store->remote)); +} + + +static gboolean +cache_connect (CamelService *service, CamelException *ex) +{ + CamelCacheStore *cache_store = CAMEL_CACHE_STORE (service); + + if (!cache_store->remote) { + cache_store->remote = + camel_session_get_store (service->session, + service->url->path, + ex); + if (camel_exception_is_set (ex)) + return FALSE; + + cache_store->local = XXX; + if (camel_exception_is_set (ex)) + return FALSE; + } + + if (!camel_service_connect (CAMEL_SERVICE (cache_store->remote), ex)) + return FALSE; + if (!camel_service_connect (CAMEL_SERVICE (cache_store->local), ex)) { + camel_service_disconnect (CAMEL_SERVICE (store->remote), NULL); + return FALSE; + } + + return service_class->connect (service, ex); +} + +static gboolean +cache_disconnect (CamelService *service, CamelException *ex) +{ + CamelCacheStore *store = CAMEL_CACHE_STORE (service); + + if (!service_class->disconnect (service, ex)) + return FALSE; + + return camel_service_disconnect (CAMEL_SERVICE (store->local), ex) && + camel_service_disconnect (CAMEL_SERVICE (store->remote), ex); +} + +static CamelFolder * +get_folder (CamelStore *store, const char *folder_name, + gboolean create, CamelException *ex) +{ + CamelCacheStore *cache_store = CAMEL_CACHE_STORE (store); + CamelFolder *rf, *lf; + + rf = camel_store_get_folder (cache_store->remote, folder_name, + create, ex); + if (!rf) + return NULL; + + lf = camel_store_get_folder (cache_store->local, folder_name, + TRUE, ex); + if (!lf) { + camel_exception_setv (ex, camel_exception_get_id (ex), + "Could not create cache folder:\n%s", + camel_exception_get_description (ex)); + return NULL; + } + + return camel_cache_folder_new (cache_store, rf, lf, ex); +} + +static char * +get_folder_name (CamelStore *store, const char *folder_name, + CamelException *ex) +{ + CamelCacheStore *cache_store = CAMEL_CACHE_STORE (store); + + return camel_store_get_folder_name (cache_store->remote, + folder_name, ex); +} + +static char * +get_root_folder_name (CamelStore *store, CamelException *ex) +{ + CamelCacheStore *cache_store = CAMEL_CACHE_STORE (store); + + return camel_store_get_root_folder_name (cache_store->remote, ex); +} + +static char * +get_default_folder_name (CamelStore *store, CamelException *ex) +{ + CamelCacheStore *cache_store = CAMEL_CACHE_STORE (store); + + return camel_store_get_default_folder_name (cache_store->remote, ex); +} diff --git a/camel/providers/cache/camel-cache-store.h b/camel/providers/cache/camel-cache-store.h new file mode 100644 index 0000000000..d85f759640 --- /dev/null +++ b/camel/providers/cache/camel-cache-store.h @@ -0,0 +1,67 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* camel-cache-store.h: class for a cache store */ + +/* + * Authors: + * Dan Winship + * + * 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 + */ + +#ifndef CAMEL_CACHE_STORE_H +#define CAMEL_CACHE_STORE_H 1 + +#ifdef __cplusplus +extern "C" { +#pragma } +#endif /* __cplusplus }*/ + +#include + +#define CAMEL_CACHE_STORE_TYPE (camel_cache_store_get_type ()) +#define CAMEL_CACHE_STORE(obj) (GTK_CHECK_CAST((obj), CAMEL_CACHE_STORE_TYPE, CamelCacheStore)) +#define CAMEL_CACHE_STORE_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_CACHE_STORE_TYPE, CamelCacheStoreClass)) +#define IS_CAMEL_CACHE_STORE(o) (GTK_CHECK_TYPE((o), CAMEL_CACHE_STORE_TYPE)) + +typedef struct { + CamelStore parent_object; + + CamelStore *remote, *local; + +} CamelCacheStore; + + +typedef struct { + CamelStoreClass parent_class; + +} CamelCacheStoreClass; + + +/* support functions */ +void camel_cache_store_sync (CamelCacheStore *store); + +/* Standard Gtk function */ +GtkType camel_cache_store_get_type (void); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* CAMEL_CACHE_STORE_H */ + + diff --git a/camel/providers/cache/libcamelcache.urls b/camel/providers/cache/libcamelcache.urls new file mode 100644 index 0000000000..06cf65390f --- /dev/null +++ b/camel/providers/cache/libcamelcache.urls @@ -0,0 +1 @@ +cache -- cgit v1.2.3