callisto-debian/evolution
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cache provider, for caching a remote store locally. This is not done yet.

Browse Source 
svn path=/trunk/; revision=5206
This commit is contained in:
Dan Winship
2000-09-05 20:33:05 +00:00
parent 52d74ec874
commit 7a21e4e904
9 changed files with 1471 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
camel/providers/cache/Makefile.am vendored Normal file
View File

@ -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

689
camel/providers/cache/camel-cache-folder.c vendored Normal file
View File

@ -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);
}

87
camel/providers/cache/camel-cache-folder.h vendored Normal file
View File

@ -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 <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
*/
#ifndef CAMEL_CACHE_FOLDER_H
#define CAMEL_CACHE_FOLDER_H 1
#ifdef __cplusplus
extern "C" {
#pragma }
#endif /* __cplusplus }*/
#include <camel/camel-folder.h>
#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 */

255
camel/providers/cache/camel-cache-map.c vendored Normal file
View File

@ -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 <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
*/
#include "camel-cache-map.h"
#include <camel/camel-exception.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
/**
* 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);
}

64
camel/providers/cache/camel-cache-map.h vendored Normal file
View File

@ -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 <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
*/
#ifndef CAMEL_CACHE_MAP_H
#define CAMEL_CACHE_MAP_H 1
#ifdef __cplusplus
extern "C" {
#pragma }
#endif /* __cplusplus }*/
#include <glib.h>
#include <camel/camel-types.h>
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 */

51
camel/providers/cache/camel-cache-provider.c vendored Normal file
View File

@ -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 <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
*/
#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);
}

222
camel/providers/cache/camel-cache-store.c vendored Normal file
View File

@ -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 <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
*/
#include "config.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#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);
}

67
camel/providers/cache/camel-cache-store.h vendored Normal file
View File

@ -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 <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
*/
#ifndef CAMEL_CACHE_STORE_H
#define CAMEL_CACHE_STORE_H 1
#ifdef __cplusplus
extern "C" {
#pragma }
#endif /* __cplusplus }*/
#include <camel/camel-store.h>
#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 */

1
camel/providers/cache/libcamelcache.urls vendored Normal file
View File

@ -0,0 +1 @@
cache