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

A new provider, for spool mailboxes. Mostly a cut and paste of the mbox

Browse Source 
2001-06-12  Not Zed  <NotZed@Ximian.com>

        * providers/local/camel-spool-*.[ch]: A new provider, for spool
        mailboxes.  Mostly a cut and paste of the mbox code, but not a
        subclass CamelLocal*.  Not tested a lot, doesn't lock yet, use
        with extreme caution.

        * tests/lib/folders.c (test_folder_message_ops): Added spool arg,
        spool folders can't be deleted, renamed, etc.
        (test_folder_basic): Same.

        * tests/folder/test2.c (main): Added checks for spool type.

        * tests/[message|stream|folder|misc|smime]/Makefile.am (LDADD):
        Added db3 flags, so make check compiles, doesn't run though.

2001-05-24  Not Zed  <NotZed@Ximian.com>

        * providers/local/camel-local-provider.c
        (camel_provider_module_init): Added spool provider.

svn path=/trunk/; revision=10198
This commit is contained in:
Not Zed
2001-06-12 14:29:28 +00:00
committed by Michael Zucci
parent 8131304fd1
commit f14e85f771
22 changed files with 2468 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
camel/ChangeLog
View File

@ -1,3 +1,24 @@
2001-06-12 Not Zed <NotZed@Ximian.com>
* providers/local/camel-spool-*.[ch]: A new provider, for spool
mailboxes. Mostly a cut and paste of the mbox code, but not a
subclass CamelLocal*. Not tested a lot, doesn't lock yet, use
with extreme caution.
* tests/lib/folders.c (test_folder_message_ops): Added spool arg,
spool folders can't be deleted, renamed, etc.
(test_folder_basic): Same.
* tests/folder/test2.c (main): Added checks for spool type.
* tests/[message|stream|folder|misc|smime]/Makefile.am (LDADD):
Added db3 flags, so make check compiles, doesn't run though.
2001-05-24 Not Zed <NotZed@Ximian.com>
* providers/local/camel-local-provider.c
(camel_provider_module_init): Added spool provider.
2001-06-07 Jon Trowbridge <trow@ximian.com>
* camel-filter-driver.c (camel_filter_driver_filter_folder): Add a

10
camel/providers/local/Makefile.am
View File

@ -32,7 +32,10 @@ libcamellocal_la_SOURCES = \
camel-mbox-summary.c \
camel-maildir-folder.c \
camel-maildir-store.c \
camel-maildir-summary.c
camel-maildir-summary.c \
camel-spool-folder.c \
camel-spool-store.c \
camel-spool-summary.c
libcamellocalinclude_HEADERS = \
camel-local-folder.h \
@ -46,7 +49,10 @@ libcamellocalinclude_HEADERS = \
camel-mbox-summary.h \
camel-maildir-folder.h \
camel-maildir-store.h \
camel-maildir-summary.h
camel-maildir-summary.h \
camel-spool-folder.h \
camel-spool-store.h \
camel-spool-summary.h
noinst_HEADERS = \
camel-local-private.h

14
camel/providers/local/camel-local-private.h
View File

@ -52,6 +52,20 @@ struct _CamelLocalFolderPrivate {
#define CAMEL_LOCAL_FOLDER_UNLOCK(f, l)
#endif
struct _CamelSpoolFolderPrivate {
#ifdef ENABLE_THREADS
GMutex *search_lock; /* for locking the search object */
#endif
};
#ifdef ENABLE_THREADS
#define CAMEL_SPOOL_FOLDER_LOCK(f, l) (g_mutex_lock(((CamelSpoolFolder *)f)->priv->l))
#define CAMEL_SPOOL_FOLDER_UNLOCK(f, l) (g_mutex_unlock(((CamelSpoolFolder *)f)->priv->l))
#else
#define CAMEL_SPOOL_FOLDER_LOCK(f, l)
#define CAMEL_SPOOL_FOLDER_UNLOCK(f, l)
#endif
#ifdef __cplusplus
}
#endif /* __cplusplus */

15
camel/providers/local/camel-local-provider.c
View File

@ -33,6 +33,7 @@
#include "camel-mh-store.h"
#include "camel-mbox-store.h"
#include "camel-maildir-store.h"
#include "camel-spool-store.h"
static CamelProvider mh_provider = {
"mh",
@ -64,6 +65,16 @@ static CamelProvider maildir_provider = {
/* ... */
};
static CamelProvider spool_provider = {
"spool",
N_("Unix mbox spool-format mail files"),
N_("For storing local mail in standard Unix spool directories"),
"mail",
CAMEL_PROVIDER_IS_SOURCE | CAMEL_PROVIDER_IS_STORAGE,
CAMEL_URL_NEED_PATH | CAMEL_URL_PATH_IS_ABSOLUTE,
/* ... */
};
void camel_provider_module_init(CamelSession * session)
{
mh_provider.object_types[CAMEL_PROVIDER_STORE] = camel_mh_store_get_type();
@ -77,4 +88,8 @@ void camel_provider_module_init(CamelSession * session)
maildir_provider.object_types[CAMEL_PROVIDER_STORE] = camel_maildir_store_get_type();
maildir_provider.service_cache = g_hash_table_new(camel_url_hash, camel_url_equal);
camel_session_register_provider(session, &maildir_provider);
spool_provider.object_types[CAMEL_PROVIDER_STORE] = camel_spool_store_get_type();
spool_provider.service_cache = g_hash_table_new(camel_url_hash, camel_url_equal);
camel_session_register_provider(session, &spool_provider);
}

609
camel/providers/local/camel-spool-folder.c Normal file
View File

@ -0,0 +1,609 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; fill-column: 160 -*-
*
* Authors: Michael Zucchi <notzed@ximian.com>
*
* Copyright (C) 2001 Ximian Inc (http://www.ximian.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
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdlib.h>
#include <sys/types.h>
#include <dirent.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include "camel-spool-folder.h"
#include "camel-spool-store.h"
#include "string-utils.h"
#include "camel-stream-fs.h"
#include "camel-spool-summary.h"
#include "camel-data-wrapper.h"
#include "camel-mime-message.h"
#include "camel-stream-filter.h"
#include "camel-mime-filter-from.h"
#include "camel-exception.h"
#include "camel-local-private.h"
#define d(x) /*(printf("%s(%d): ", __FILE__, __LINE__),(x))*/
static CamelFolderClass *parent_class = NULL;
/* Returns the class for a CamelSpoolFolder */
#define CSPOOLF_CLASS(so) CAMEL_SPOOL_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(so))
#define CF_CLASS(so) CAMEL_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(so))
#define CSPOOLS_CLASS(so) CAMEL_STORE_CLASS (CAMEL_OBJECT_GET_CLASS(so))
static int spool_lock(CamelSpoolFolder *lf, CamelLockType type, CamelException *ex);
static void spool_unlock(CamelSpoolFolder *lf);
static void spool_sync(CamelFolder *folder, gboolean expunge, CamelException *ex);
static void spool_expunge(CamelFolder *folder, CamelException *ex);
static GPtrArray *spool_search_by_expression(CamelFolder *folder, const char *expression, CamelException *ex);
static void spool_search_free(CamelFolder *folder, GPtrArray * result);
static void spool_append_message(CamelFolder *folder, CamelMimeMessage * message, const CamelMessageInfo * info, CamelException *ex);
static CamelMimeMessage *spool_get_message(CamelFolder *folder, const gchar * uid, CamelException *ex);
static void spool_set_message_user_flag(CamelFolder *folder, const char *uid, const char *name, gboolean value);
static void spool_set_message_user_tag(CamelFolder *folder, const char *uid, const char *name, const char *value);
static void spool_finalize(CamelObject * object);
static void
camel_spool_folder_class_init(CamelSpoolFolderClass * camel_spool_folder_class)
{
CamelFolderClass *camel_folder_class = CAMEL_FOLDER_CLASS(camel_spool_folder_class);
parent_class = CAMEL_FOLDER_CLASS(camel_type_get_global_classfuncs(camel_folder_get_type()));
/* virtual method definition */
/* virtual method overload */
camel_folder_class->sync = spool_sync;
camel_folder_class->expunge = spool_expunge;
camel_folder_class->search_by_expression = spool_search_by_expression;
camel_folder_class->search_free = spool_search_free;
/* virtual method overload */
camel_folder_class->append_message = spool_append_message;
camel_folder_class->get_message = spool_get_message;
camel_folder_class->set_message_user_flag = spool_set_message_user_flag;
camel_folder_class->set_message_user_tag = spool_set_message_user_tag;
camel_spool_folder_class->lock = spool_lock;
camel_spool_folder_class->unlock = spool_unlock;
}
static void
spool_init(gpointer object, gpointer klass)
{
CamelFolder *folder = object;
CamelSpoolFolder *spool_folder = object;
folder->has_summary_capability = TRUE;
folder->has_search_capability = TRUE;
folder->permanent_flags = CAMEL_MESSAGE_ANSWERED |
CAMEL_MESSAGE_DELETED | CAMEL_MESSAGE_DRAFT |
CAMEL_MESSAGE_FLAGGED | CAMEL_MESSAGE_SEEN | CAMEL_MESSAGE_USER;
folder->summary = NULL;
spool_folder->search = NULL;
spool_folder->priv = g_malloc0(sizeof(*spool_folder->priv));
#ifdef ENABLE_THREADS
spool_folder->priv->search_lock = g_mutex_new();
#endif
}
static void
spool_finalize(CamelObject * object)
{
CamelSpoolFolder *spool_folder = CAMEL_SPOOL_FOLDER(object);
CamelFolder *folder = (CamelFolder *)object;
if (folder->summary) {
camel_spool_summary_sync((CamelSpoolSummary *)folder->summary, FALSE, spool_folder->changes, NULL);
camel_object_unref((CamelObject *)folder->summary);
folder->summary = NULL;
}
if (spool_folder->search) {
camel_object_unref((CamelObject *)spool_folder->search);
}
while (spool_folder->locked> 0)
camel_spool_folder_unlock(spool_folder);
g_free(spool_folder->base_path);
g_free(spool_folder->folder_path);
camel_folder_change_info_free(spool_folder->changes);
#ifdef ENABLE_THREADS
g_mutex_free(spool_folder->priv->search_lock);
#endif
g_free(spool_folder->priv);
}
CamelType camel_spool_folder_get_type(void)
{
static CamelType camel_spool_folder_type = CAMEL_INVALID_TYPE;
if (camel_spool_folder_type == CAMEL_INVALID_TYPE) {
camel_spool_folder_type = camel_type_register(CAMEL_FOLDER_TYPE, "CamelSpoolFolder",
sizeof(CamelSpoolFolder),
sizeof(CamelSpoolFolderClass),
(CamelObjectClassInitFunc) camel_spool_folder_class_init,
NULL,
(CamelObjectInitFunc) spool_init,
(CamelObjectFinalizeFunc) spool_finalize);
}
return camel_spool_folder_type;
}
CamelSpoolFolder *
camel_spool_folder_construct(CamelSpoolFolder *lf, CamelStore *parent_store, const char *full_name, guint32 flags, CamelException *ex)
{
CamelFolderInfo *fi;
CamelFolder *folder;
const char *root_dir_path, *name;
folder = (CamelFolder *)lf;
name = strrchr(full_name, '/');
if (name)
name++;
else
name = full_name;
camel_folder_construct(folder, parent_store, full_name, name);
root_dir_path = camel_spool_store_get_toplevel_dir(CAMEL_SPOOL_STORE(folder->parent_store));
lf->base_path = g_strdup(root_dir_path);
lf->folder_path = g_strdup_printf("%s/%s", root_dir_path, full_name);
lf->changes = camel_folder_change_info_new();
lf->flags = flags;
folder->summary = (CamelFolderSummary *)camel_spool_summary_new(lf->folder_path);
if (camel_spool_folder_lock(lf, CAMEL_LOCK_WRITE, ex) != -1) {
camel_spool_summary_check((CamelSpoolSummary *)folder->summary, NULL, ex);
camel_spool_folder_unlock(lf);
}
fi = g_malloc0(sizeof(*fi));
fi->full_name = g_strdup(full_name);
fi->name = g_strdup(name);
fi->url = g_strdup(lf->folder_path);
fi->unread_message_count = -1;
camel_object_trigger_event(CAMEL_OBJECT(parent_store), "folder_created", fi);
camel_folder_info_free (fi);
return lf;
}
CamelFolder *
camel_spool_folder_new(CamelStore *parent_store, const char *full_name, guint32 flags, CamelException *ex)
{
CamelFolder *folder;
d(printf("Creating spool folder: %s in %s\n", full_name, camel_local_store_get_toplevel_dir((CamelLocalStore *)parent_store)));
folder = (CamelFolder *)camel_object_new(CAMEL_SPOOL_FOLDER_TYPE);
folder = (CamelFolder *)camel_spool_folder_construct((CamelSpoolFolder *)folder,
parent_store, full_name, flags, ex);
return folder;
}
/* lock the folder, may be called repeatedly (with matching unlock calls),
with type the same or less than the first call */
int camel_spool_folder_lock(CamelSpoolFolder *lf, CamelLockType type, CamelException *ex)
{
if (lf->locked > 0) {
/* lets be anal here - its important the code knows what its doing */
g_assert(lf->locktype == type || lf->locktype == CAMEL_LOCK_WRITE);
} else {
if (CSPOOLF_CLASS(lf)->lock(lf, type, ex) == -1)
return -1;
lf->locktype = type;
}
lf->locked++;
return 0;
}
/* unlock folder */
int camel_spool_folder_unlock(CamelSpoolFolder *lf)
{
g_assert(lf->locked>0);
lf->locked--;
if (lf->locked == 0)
CSPOOLF_CLASS(lf)->unlock(lf);
return 0;
}
static int
spool_lock(CamelSpoolFolder *lf, CamelLockType type, CamelException *ex)
{
return 0;
}
static void
spool_unlock(CamelSpoolFolder *lf)
{
/* nothing */
}
static void
spool_sync(CamelFolder *folder, gboolean expunge, CamelException *ex)
{
CamelSpoolFolder *lf = CAMEL_SPOOL_FOLDER(folder);
d(printf("spool sync, expunge=%s\n", expunge?"true":"false"));
if (camel_spool_folder_lock(lf, CAMEL_LOCK_WRITE, ex) == -1)
return;
/* if sync fails, we'll pass it up on exit through ex */
camel_spool_summary_sync((CamelSpoolSummary *)folder->summary, expunge, lf->changes, ex);
camel_spool_folder_unlock(lf);
if (camel_folder_change_info_changed(lf->changes)) {
camel_object_trigger_event(CAMEL_OBJECT(folder), "folder_changed", lf->changes);
camel_folder_change_info_clear(lf->changes);
}
}
static void
spool_expunge(CamelFolder *folder, CamelException *ex)
{
d(printf("expunge\n"));
/* Just do a sync with expunge, serves the same purpose */
/* call the callback directly, to avoid locking problems */
CAMEL_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(folder))->sync(folder, TRUE, ex);
}
static GPtrArray *
spool_search_by_expression(CamelFolder *folder, const char *expression, CamelException *ex)
{
CamelSpoolFolder *spool_folder = CAMEL_SPOOL_FOLDER(folder);
GPtrArray *summary, *matches;
/* NOTE: could get away without the search lock by creating a new
search object each time */
CAMEL_SPOOL_FOLDER_LOCK(folder, search_lock);
if (spool_folder->search == NULL)
spool_folder->search = camel_folder_search_new();
camel_folder_search_set_folder(spool_folder->search, folder);
summary = camel_folder_get_summary(folder);
camel_folder_search_set_summary(spool_folder->search, summary);
matches = camel_folder_search_execute_expression(spool_folder->search, expression, ex);
CAMEL_SPOOL_FOLDER_UNLOCK(folder, search_lock);
camel_folder_free_summary(folder, summary);
return matches;
}
static void
spool_search_free(CamelFolder *folder, GPtrArray * result)
{
CamelSpoolFolder *spool_folder = CAMEL_SPOOL_FOLDER(folder);
/* we need to lock this free because of the way search_free_result works */
/* FIXME: put the lock inside search_free_result */
CAMEL_SPOOL_FOLDER_LOCK(folder, search_lock);
camel_folder_search_free_result(spool_folder->search, result);
CAMEL_SPOOL_FOLDER_UNLOCK(folder, search_lock);
}
static void
spool_append_message(CamelFolder *folder, CamelMimeMessage * message, const CamelMessageInfo * info, CamelException *ex)
{
CamelSpoolFolder *lf = (CamelSpoolFolder *)folder;
CamelStream *output_stream = NULL, *filter_stream = NULL;
CamelMimeFilter *filter_from = NULL;
CamelSpoolSummary *mbs = (CamelSpoolSummary *)folder->summary;
CamelMessageInfo *mi;
char *fromline = NULL;
int fd;
struct stat st;
#if 0
char *xev;
#endif
/* If we can't lock, dont do anything */
if (camel_spool_folder_lock(lf, CAMEL_LOCK_WRITE, ex) == -1)
return;
d(printf("Appending message\n"));
/* first, check the summary is correct (updates folder_size too) */
camel_spool_summary_check((CamelSpoolSummary *)folder->summary, lf->changes, ex);
if (camel_exception_is_set(ex))
goto fail;
/* add it to the summary/assign the uid, etc */
mi = camel_spool_summary_add((CamelSpoolSummary *)folder->summary, message, info, lf->changes, ex);
if (camel_exception_is_set(ex))
goto fail;
d(printf("Appending message: uid is %s\n", camel_message_info_uid(mi)));
output_stream = camel_stream_fs_new_with_name(lf->folder_path, O_WRONLY|O_APPEND, 0600);
if (output_stream == NULL) {
camel_exception_setv(ex, 1, _("Cannot open mailbox: %s: %s\n"), lf->folder_path, strerror(errno));
goto fail;
}
/* and we need to set the frompos/XEV explicitly */
((CamelSpoolMessageInfo *)mi)->frompos = mbs->folder_size?mbs->folder_size+1:0;
#if 0
xev = camel_spool_summary_encode_x_evolution((CamelLocalSummary *)folder->summary, mi);
if (xev) {
/* the x-ev header should match the 'current' flags, no problem, so store as much */
camel_medium_set_header((CamelMedium *)message, "X-Evolution", xev);
mi->flags &= ~ CAMEL_MESSAGE_FOLDER_NOXEV|CAMEL_MESSAGE_FOLDER_FLAGGED;
g_free(xev);
}
#endif
/* we must write this to the non-filtered stream ... prepend a \n if not at the start of the file */
fromline = camel_spool_summary_build_from(((CamelMimePart *)message)->headers);
if (camel_stream_printf(output_stream, mbs->folder_size==0?"%s":"\n%s", fromline) == -1)
goto fail_write;
/* and write the content to the filtering stream, that translated '\nFrom' into '\n>From' */
filter_stream = (CamelStream *) camel_stream_filter_new_with_stream(output_stream);
filter_from = (CamelMimeFilter *) camel_mime_filter_from_new();
camel_stream_filter_add((CamelStreamFilter *) filter_stream, filter_from);
if (camel_data_wrapper_write_to_stream((CamelDataWrapper *)message, filter_stream) == -1)
goto fail_write;
if (camel_stream_close(filter_stream) == -1)
goto fail_write;
/* unlock as soon as we can */
camel_spool_folder_unlock(lf);
/* filter stream ref's the output stream itself, so we need to unref it too */
camel_object_unref((CamelObject *)filter_from);
camel_object_unref((CamelObject *)filter_stream);
camel_object_unref((CamelObject *)output_stream);
g_free(fromline);
/* now we 'fudge' the summary to tell it its uptodate, because its idea of uptodate has just changed */
/* the stat really shouldn't fail, we just wrote to it */
if (stat(lf->folder_path, &st) == 0) {
mbs->folder_size = st.st_size;
((CamelFolderSummary *)mbs)->time = st.st_mtime;
}
if (camel_folder_change_info_changed(lf->changes)) {
camel_object_trigger_event((CamelObject *)folder, "folder_changed", lf->changes);
camel_folder_change_info_clear(lf->changes);
}
return;
fail_write:
camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
_("Cannot append message to spool file: %s: %s"),
lf->folder_path, g_strerror (errno));
if (filter_stream)
camel_object_unref(CAMEL_OBJECT(filter_stream));
if (output_stream)
camel_object_unref(CAMEL_OBJECT(output_stream));
if (filter_from)
camel_object_unref(CAMEL_OBJECT(filter_from));
g_free(fromline);
/* reset the file to original size */
fd = open(lf->folder_path, O_WRONLY, 0600);
if (fd != -1) {
ftruncate(fd, mbs->folder_size);
close(fd);
}
/* remove the summary info so we are not out-of-sync with the spool */
camel_folder_summary_remove_uid (CAMEL_FOLDER_SUMMARY (mbs), camel_message_info_uid (mi));
/* and tell the summary its uptodate */
if (stat(lf->folder_path, &st) == 0) {
mbs->folder_size = st.st_size;
((CamelFolderSummary *)mbs)->time = st.st_mtime;
}
fail:
/* make sure we unlock the folder - before we start triggering events into appland */
camel_spool_folder_unlock(lf);
/* cascade the changes through, anyway, if there are any outstanding */
if (camel_folder_change_info_changed(lf->changes)) {
camel_object_trigger_event((CamelObject *)folder, "folder_changed", lf->changes);
camel_folder_change_info_clear(lf->changes);
}
}
static CamelMimeMessage *
spool_get_message(CamelFolder *folder, const gchar * uid, CamelException *ex)
{
CamelSpoolFolder *lf = (CamelSpoolFolder *)folder;
CamelMimeMessage *message;
CamelSpoolMessageInfo *info;
CamelMimeParser *parser;
int fd;
int retried = FALSE;
d(printf("Getting message %s\n", uid));
/* lock the folder first, burn if we can't */
if (camel_spool_folder_lock(lf, CAMEL_LOCK_READ, ex) == -1)
return NULL;
retry:
/* get the message summary info */
info = (CamelSpoolMessageInfo *) camel_folder_summary_uid(folder->summary, uid);
if (info == NULL) {
camel_exception_setv(ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID,
_("Cannot get message: %s\n %s"), uid, _("No such message"));
camel_spool_folder_unlock(lf);
return NULL;
}
/* no frompos, its an error in the library (and we can't do anything with it */
g_assert(info->frompos != -1);
/* we use an fd instead of a normal stream here - the reason is subtle, camel_mime_part will cache
the whole message in memory if the stream is non-seekable (which it is when built from a parser
with no stream). This means we dont have to lock the spool for the life of the message, but only
while it is being created. */
fd = open(lf->folder_path, O_RDONLY);
if (fd == -1) {
camel_exception_setv(ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID,
_("Cannot get message: %s from folder %s\n %s"), uid, lf->folder_path,
strerror(errno));
camel_spool_folder_unlock(lf);
camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)info);
return NULL;
}
/* we use a parser to verify the message is correct, and in the correct position */
parser = camel_mime_parser_new();
camel_mime_parser_init_with_fd(parser, fd);
camel_mime_parser_scan_from(parser, TRUE);
camel_mime_parser_seek(parser, info->frompos, SEEK_SET);
if (camel_mime_parser_step(parser, NULL, NULL) != HSCAN_FROM
|| camel_mime_parser_tell_start_from(parser) != info->frompos) {
g_warning("Summary doesn't match the folder contents! eek!\n"
" expecting offset %ld got %ld, state = %d", (long int)info->frompos,
(long int)camel_mime_parser_tell_start_from(parser),
camel_mime_parser_state(parser));
camel_object_unref((CamelObject *)parser);
camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)info);
if (!retried) {
retried = TRUE;
camel_spool_summary_check((CamelSpoolSummary *)folder->summary, lf->changes, ex);
if (!camel_exception_is_set(ex))
goto retry;
}
camel_exception_setv(ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID,
_("Cannot get message: %s from folder %s\n %s"), uid, lf->folder_path,
_("The folder appears to be irrecoverably corrupted."));
camel_spool_folder_unlock(lf);
return NULL;
}
camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)info);
message = camel_mime_message_new();
if (camel_mime_part_construct_from_parser((CamelMimePart *)message, parser) == -1) {
g_warning("Construction failed");
camel_exception_setv(ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID,
_("Cannot get message: %s from folder %s\n %s"), uid, lf->folder_path,
_("Message construction failed: Corrupt mailbox?"));
camel_object_unref((CamelObject *)parser);
camel_object_unref((CamelObject *)message);
camel_spool_folder_unlock(lf);
return NULL;
}
/* and unlock now we're finished with it */
camel_spool_folder_unlock(lf);
camel_object_unref((CamelObject *)parser);
/* use the opportunity to notify of changes (particularly if we had a rebuild) */
if (camel_folder_change_info_changed(lf->changes)) {
camel_object_trigger_event((CamelObject *)folder, "folder_changed", lf->changes);
camel_folder_change_info_clear(lf->changes);
}
return message;
}
static void
spool_set_message_user_flag(CamelFolder *folder, const char *uid, const char *name, gboolean value)
{
CamelMessageInfo *info;
g_return_if_fail(folder->summary != NULL);
info = camel_folder_summary_uid(folder->summary, uid);
g_return_if_fail(info != NULL);
if (camel_flag_set(&info->user_flags, name, value)) {
info->flags |= CAMEL_MESSAGE_FOLDER_FLAGGED|CAMEL_MESSAGE_FOLDER_XEVCHANGE;
camel_folder_summary_touch(folder->summary);
camel_object_trigger_event(CAMEL_OBJECT(folder), "message_changed", (char *) uid);
}
camel_folder_summary_info_free(folder->summary, info);
}
static void
spool_set_message_user_tag(CamelFolder *folder, const char *uid, const char *name, const char *value)
{
CamelMessageInfo *info;
g_return_if_fail(folder->summary != NULL);
info = camel_folder_summary_uid(folder->summary, uid);
g_return_if_fail(info != NULL);
if (camel_tag_set(&info->user_tags, name, value)) {
info->flags |= CAMEL_MESSAGE_FOLDER_FLAGGED|CAMEL_MESSAGE_FOLDER_XEVCHANGE;
camel_folder_summary_touch(folder->summary);
camel_object_trigger_event(CAMEL_OBJECT(folder), "message_changed", (char *) uid);
}
camel_folder_summary_info_free(folder->summary, info);
}

101
camel/providers/local/camel-spool-folder.h Normal file
View File

@ -0,0 +1,101 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
*
* Author: Michael Zucchi <notzed@ximian.com>
*
* Copyright (C) 2001 Ximian Inc (http://www.ximian.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_SPOOL_FOLDER_H
#define CAMEL_SPOOL_FOLDER_H 1
#ifdef __cplusplus
extern "C" {
#pragma }
#endif /* __cplusplus }*/
#include <camel/camel-folder.h>
#include <camel/camel-folder-search.h>
#include <libibex/ibex.h>
#include "camel-spool-summary.h"
#include "camel-lock.h"
/* #include "camel-store.h" */
#define CAMEL_SPOOL_FOLDER_TYPE (camel_spool_folder_get_type ())
#define CAMEL_SPOOL_FOLDER(obj) (CAMEL_CHECK_CAST((obj), CAMEL_SPOOL_FOLDER_TYPE, CamelSpoolFolder))
#define CAMEL_SPOOL_FOLDER_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_SPOOL_FOLDER_TYPE, CamelSpoolFolderClass))
#define CAMEL_IS_SPOOL_FOLDER(o) (CAMEL_CHECK_TYPE((o), CAMEL_SPOOL_FOLDER_TYPE))
typedef struct {
CamelFolder parent_object;
struct _CamelSpoolFolderPrivate *priv;
guint32 flags; /* open mode flags */
int locked; /* lock counter */
CamelLockType locktype; /* what type of lock we have */
char *base_path; /* base path of the spool folder */
char *folder_path; /* the path to the folder itself */
#if 0
char *summary_path; /* where the summary lives */
char *index_path; /* where the index file lives */
ibex *index; /* index for this folder */
#endif
CamelFolderSearch *search; /* used to run searches, we just use the real thing (tm) */
CamelFolderChangeInfo *changes; /* used to store changes to the folder during processing */
} CamelSpoolFolder;
typedef struct {
CamelFolderClass parent_class;
/* Virtual methods */
/* summary factory, only used at init */
CamelSpoolSummary *(*create_summary)(const char *path, const char *folder, ibex *index);
/* Lock the folder for my operations */
int (*lock)(CamelSpoolFolder *, CamelLockType type, CamelException *ex);
/* Unlock the folder for my operations */
void (*unlock)(CamelSpoolFolder *);
} CamelSpoolFolderClass;
/* public methods */
/* flags are taken from CAMEL_STORE_FOLDER_* flags */
CamelSpoolFolder *camel_spool_folder_construct(CamelSpoolFolder *lf, CamelStore *parent_store,
const char *full_name, guint32 flags, CamelException *ex);
/* Standard Camel function */
CamelType camel_spool_folder_get_type(void);
CamelFolder *camel_spool_folder_new(CamelStore *parent_store, const char *full_name,
guint32 flags, CamelException *ex);
/* Lock the folder for internal use. May be called repeatedly */
/* UNIMPLEMENTED */
int camel_spool_folder_lock(CamelSpoolFolder *lf, CamelLockType type, CamelException *ex);
int camel_spool_folder_unlock(CamelSpoolFolder *lf);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* CAMEL_SPOOL_FOLDER_H */

194
camel/providers/local/camel-spool-store.c Normal file
View File

@ -0,0 +1,194 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
*
* Authors: Michael Zucchi <notzed@ximian.com>
*
* Copyright (C) 2001 Ximian Inc (http://www.ximian.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
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <sys/stat.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#include "camel-spool-store.h"
#include "camel-spool-folder.h"
#include "camel-exception.h"
#include "camel-url.h"
#define d(x)
/* Returns the class for a CamelSpoolStore */
#define CSPOOLS_CLASS(so) CAMEL_SPOOL_STORE_CLASS (CAMEL_OBJECT_GET_CLASS(so))
#define CF_CLASS(so) CAMEL_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(so))
static void construct (CamelService *service, CamelSession *session, CamelProvider *provider, CamelURL *url, CamelException *ex);
static CamelFolder *get_folder(CamelStore * store, const char *folder_name, guint32 flags, CamelException * ex);
static char *get_name(CamelService *service, gboolean brief);
static CamelFolder *get_inbox (CamelStore *store, CamelException *ex);
static void rename_folder(CamelStore *store, const char *old_name, const char *new_name, CamelException *ex);
static CamelFolderInfo *get_folder_info (CamelStore *store, const char *top,
guint32 flags, CamelException *ex);
static void delete_folder(CamelStore *store, const char *folder_name, CamelException *ex);
static void rename_folder(CamelStore *store, const char *old, const char *new, CamelException *ex);
static CamelStoreClass *parent_class = NULL;
static void
camel_spool_store_class_init (CamelSpoolStoreClass *camel_spool_store_class)
{
CamelStoreClass *camel_store_class = CAMEL_STORE_CLASS (camel_spool_store_class);
CamelServiceClass *camel_service_class = CAMEL_SERVICE_CLASS (camel_spool_store_class);
parent_class = CAMEL_STORE_CLASS (camel_type_get_global_classfuncs (camel_store_get_type ()));
/* virtual method overload */
camel_service_class->construct = construct;
camel_service_class->get_name = get_name;
camel_store_class->get_folder = get_folder;
camel_store_class->get_inbox = get_inbox;
camel_store_class->get_folder_info = get_folder_info;
camel_store_class->free_folder_info = camel_store_free_folder_info_full;
camel_store_class->delete_folder = delete_folder;
camel_store_class->rename_folder = rename_folder;
}
CamelType
camel_spool_store_get_type (void)
{
static CamelType camel_spool_store_type = CAMEL_INVALID_TYPE;
if (camel_spool_store_type == CAMEL_INVALID_TYPE) {
camel_spool_store_type = camel_type_register (CAMEL_STORE_TYPE, "CamelSpoolStore",
sizeof (CamelSpoolStore),
sizeof (CamelSpoolStoreClass),
(CamelObjectClassInitFunc) camel_spool_store_class_init,
NULL,
NULL,
NULL);
}
return camel_spool_store_type;
}
static void
construct (CamelService *service, CamelSession *session, CamelProvider *provider, CamelURL *url, CamelException *ex)
{
int len;
CAMEL_SERVICE_CLASS (parent_class)->construct (service, session, provider, url, ex);
if (camel_exception_is_set (ex))
return;
len = strlen (service->url->path);
if (service->url->path[len - 1] != '/') {
service->url->path = g_realloc (service->url->path, len + 2);
strcpy (service->url->path + len, "/");
}
}
const char *
camel_spool_store_get_toplevel_dir (CamelSpoolStore *store)
{
CamelURL *url = CAMEL_SERVICE (store)->url;
g_assert (url != NULL);
return url->path;
}
static CamelFolder *
get_folder(CamelStore * store, const char *folder_name, guint32 flags, CamelException * ex)
{
struct stat st;
char *path = ((CamelService *)store)->url->path;
char *name;
if (path[0] != '/') {
camel_exception_setv(ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
_("Store root %s is not an absolute path"), path);
return NULL;
}
name = g_strdup_printf("%s%s", CAMEL_SERVICE(store)->url->path, folder_name);
if (stat(name, &st) == -1) {
camel_exception_setv(ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
_("Folder `%s/%s' does not exist."),
path, folder_name);
g_free(name);
return NULL;
} else if (!S_ISREG(st.st_mode)) {
camel_exception_setv(ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
_("`%s' is not a regular file."),
name);
g_free(name);
return NULL;
}
g_free(name);
return camel_spool_folder_new(store, folder_name, flags, ex);
}
static CamelFolder *
get_inbox(CamelStore *store, CamelException *ex)
{
camel_exception_set(ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
_("Spool stores do not have an inbox"));
return NULL;
}
static char *
get_name (CamelService *service, gboolean brief)
{
if (brief)
return g_strdup (service->url->path);
else
return g_strdup_printf (_("Spool mail file %s"), service->url->path);
}
static CamelFolderInfo *
get_folder_info (CamelStore *store, const char *top,
guint32 flags, CamelException *ex)
{
/* FIXME: This is broken, but it corresponds to what was
* there before.
*/
return NULL;
}
/* default implementation, rename all */
static void
rename_folder(CamelStore *store, const char *old, const char *new, CamelException *ex)
{
camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM,
_("Spool folders cannot be renamed"));
}
/* default implementation, only delete metadata */
static void
delete_folder(CamelStore *store, const char *folder_name, CamelException *ex)
{
camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM,
_("Spool folders cannot be deleted"));
}

67
camel/providers/local/camel-spool-store.h Normal file
View File

@ -0,0 +1,67 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
*
* Authors: Michael Zucchi <notzed@ximian.com>
*
* Copyright (C) 2001 Ximian Inc (http://www.ximian.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_SPOOL_STORE_H
#define CAMEL_SPOOL_STORE_H 1
#ifdef __cplusplus
extern "C" {
#pragma }
#endif /* __cplusplus }*/
#include "camel-store.h"
#define CAMEL_SPOOL_STORE_TYPE (camel_spool_store_get_type ())
#define CAMEL_SPOOL_STORE(obj) (CAMEL_CHECK_CAST((obj), CAMEL_SPOOL_STORE_TYPE, CamelSpoolStore))
#define CAMEL_SPOOL_STORE_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_SPOOL_STORE_TYPE, CamelSpoolStoreClass))
#define CAMEL_IS_SPOOL_STORE(o) (CAMEL_CHECK_TYPE((o), CAMEL_SPOOL_STORE_TYPE))
typedef struct {
CamelStore parent_object;
} CamelSpoolStore;
typedef struct {
CamelStoreClass parent_class;
} CamelSpoolStoreClass;
/* public methods */
/* Standard Camel function */
CamelType camel_spool_store_get_type (void);
const gchar *camel_spool_store_get_toplevel_dir (CamelSpoolStore *store);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* CAMEL_SPOOL_STORE_H */

1273
camel/providers/local/camel-spool-summary.c Normal file
View File

File diff suppressed because it is too large Load Diff

96
camel/providers/local/camel-spool-summary.h Normal file
View File

@ -0,0 +1,96 @@
/*
* Copyright (C) 2001 Ximian Inc. (http://www.ximian.com)
*
* Authors: Michael Zucchi <notzed@ximian.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_SPOOL_SUMMARY_H
#define _CAMEL_SPOOL_SUMMARY_H
#include <camel/camel-folder-summary.h>
#include <camel/camel-folder.h>
#include <camel/camel-exception.h>
#include <libibex/ibex.h>
#define CAMEL_SPOOL_SUMMARY(obj) CAMEL_CHECK_CAST (obj, camel_spool_summary_get_type (), CamelSpoolSummary)
#define CAMEL_SPOOL_SUMMARY_CLASS(klass) CAMEL_CHECK_CLASS_CAST (klass, camel_spool_summary_get_type (), CamelSpoolSummaryClass)
#define CAMEL_IS_SPOOL_SUMMARY(obj) CAMEL_CHECK_TYPE (obj, camel_spool_summary_get_type ())
typedef struct _CamelSpoolSummary CamelSpoolSummary;
typedef struct _CamelSpoolSummaryClass CamelSpoolSummaryClass;
/* extra summary flags */
enum {
CAMEL_MESSAGE_FOLDER_NOXEV = 1<<17,
CAMEL_MESSAGE_FOLDER_XEVCHANGE = 1<<18,
};
typedef struct _CamelSpoolMessageInfo {
CamelMessageInfo info;
off_t frompos;
} CamelSpoolMessageInfo;
struct _CamelSpoolSummary {
CamelFolderSummary parent;
struct _CamelSpoolSummaryPrivate *priv;
char *folder_path; /* name of matching folder */
size_t folder_size;
};
struct _CamelSpoolSummaryClass {
CamelFolderSummaryClass parent_class;
int (*load)(CamelSpoolSummary *cls, int forceindex, CamelException *ex);
int (*check)(CamelSpoolSummary *cls, CamelFolderChangeInfo *changeinfo, CamelException *ex);
int (*sync)(CamelSpoolSummary *cls, gboolean expunge, CamelFolderChangeInfo *changeinfo, CamelException *ex);
CamelMessageInfo *(*add)(CamelSpoolSummary *cls, CamelMimeMessage *msg, const CamelMessageInfo *info, CamelFolderChangeInfo *, CamelException *ex);
char *(*encode_x_evolution)(CamelSpoolSummary *cls, const CamelMessageInfo *info);
int (*decode_x_evolution)(CamelSpoolSummary *cls, const char *xev, CamelMessageInfo *info);
};
guint camel_spool_summary_get_type (void);
void camel_spool_summary_construct (CamelSpoolSummary *new, const char *filename, const char *spool_name, ibex *index);
/* create the summary, in-memory only */
CamelSpoolSummary *camel_spool_summary_new(const char *filename);
/* load/check the summary */
int camel_spool_summary_load(CamelSpoolSummary *cls, int forceindex, CamelException *ex);
/* check for new/removed messages */
int camel_spool_summary_check(CamelSpoolSummary *cls, CamelFolderChangeInfo *, CamelException *ex);
/* perform a folder sync or expunge, if needed */
int camel_spool_summary_sync(CamelSpoolSummary *cls, gboolean expunge, CamelFolderChangeInfo *, CamelException *ex);
/* add a new message to the summary */
CamelMessageInfo *camel_spool_summary_add(CamelSpoolSummary *cls, CamelMimeMessage *msg, const CamelMessageInfo *info, CamelFolderChangeInfo *, CamelException *ex);
/* generate an X-Evolution header line */
char *camel_spool_summary_encode_x_evolution(CamelSpoolSummary *cls, const CamelMessageInfo *info);
int camel_spool_summary_decode_x_evolution(CamelSpoolSummary *cls, const char *xev, CamelMessageInfo *info);
/* utility functions - write headers to a file with optional X-Evolution header */
int camel_spool_summary_write_headers(int fd, struct _header_raw *header, char *xevline);
/* build a from line: FIXME: remove, or move to common code */
char *camel_spool_summary_build_from(struct _header_raw *header);
#endif /* ! _CAMEL_SPOOL_SUMMARY_H */

1
camel/providers/local/libcamellocal.urls
View File

@ -1,3 +1,4 @@
mh
mbox
maildir
spool

1
camel/tests/folder/Makefile.am
View File

@ -8,6 +8,7 @@ LDADD = \
$(top_builddir)/camel/libcamel.la \
$(top_builddir)/e-util/libeutil.la \
$(top_builddir)/libibex/libibex.la \
$(DB3_LDADD) \
$(GNOME_LIBDIR) \
$(top_builddir)/camel/tests/lib/libcameltest.a \
$(GNOMEUI_LIBS) $(INTLLIBS) $(EXTRA_GNOME_LIBS)

2
camel/tests/folder/test1.c
View File

@ -38,7 +38,7 @@ int main(int argc, char **argv)
for (i=0;i<ARRAY_LEN(local_providers);i++) {
path = g_strdup_printf("%s:///tmp/camel-test/%s", local_providers[i], local_providers[i]);
test_folder_basic(session, path, TRUE);
test_folder_basic(session, path, TRUE, FALSE);
g_free(path);
}

10
camel/tests/folder/test2.c
View File

@ -1,5 +1,9 @@
/* folder testing */
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "camel-test.h"
#include "messages.h"
#include "folders.h"
@ -40,9 +44,13 @@ int main(int argc, char **argv)
for (i=0;i<ARRAY_LEN(stores);i++) {
char *name = stores[i];
test_folder_message_ops(session, name, TRUE);
test_folder_message_ops(session, name, TRUE, FALSE);
}
/* create a pseudo-spool file, and check that */
creat("/tmp/camel-test/testbox", 0600);
test_folder_message_ops(session, "spool:///tmp/camel-test", FALSE, TRUE);
check_unref(session, 1);
camel_exception_free(ex);

2
camel/tests/folder/test4.c
View File

@ -42,7 +42,7 @@ int main(int argc, char **argv)
_exit(77);
}
camel_test_nonfatal("The IMAP code is just rooted");
test_folder_basic(session, path, FALSE);
test_folder_basic(session, path, FALSE, FALSE);
camel_test_fatal();
}

2
camel/tests/folder/test5.c
View File

@ -42,7 +42,7 @@ int main(int argc, char **argv)
_exit(77);
}
camel_test_nonfatal("Not sure how many tests apply to NNTP");
test_folder_basic(session, path, FALSE);
test_folder_basic(session, path, FALSE, FALSE);
camel_test_fatal();
}

92
camel/tests/lib/folders.c
View File

@ -189,7 +189,7 @@ test_folder_not_message(CamelFolder *folder, const char *uid)
/* test basic store operations on folders */
/* TODO: Add subscription stuff */
void
test_folder_basic(CamelSession *session, const char *storename, int local)
test_folder_basic(CamelSession *session, const char *storename, int local, int spool)
{
CamelStore *store;
CamelException *ex = camel_exception_new();
@ -226,44 +226,46 @@ test_folder_basic(CamelSession *session, const char *storename, int local)
camel_exception_clear(ex);
pull();
push("getting a non-existant folder, with create");
folder = camel_store_get_folder(store, "testbox", CAMEL_STORE_FOLDER_CREATE, ex);
check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
check(folder != NULL);
check_unref(folder, 1);
pull();
if (!spool) {
push("getting a non-existant folder, with create");
folder = camel_store_get_folder(store, "testbox", CAMEL_STORE_FOLDER_CREATE, ex);
check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
check(folder != NULL);
check_unref(folder, 1);
pull();
push("getting an existing folder");
folder = camel_store_get_folder(store, "testbox", 0, ex);
check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
check(folder != NULL);
check_unref(folder, 1);
pull();
push("getting an existing folder");
folder = camel_store_get_folder(store, "testbox", 0, ex);
check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
check(folder != NULL);
check_unref(folder, 1);
pull();
push("renaming a non-existant folder");
camel_store_rename_folder(store, "unknown1", "unknown2", ex);
check(camel_exception_is_set(ex));
camel_exception_clear(ex);
pull();
push("renaming a non-existant folder");
camel_store_rename_folder(store, "unknown1", "unknown2", ex);
check(camel_exception_is_set(ex));
camel_exception_clear(ex);
pull();
push("renaming an existing folder");
camel_store_rename_folder(store, "testbox", "testbox2", ex);
check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
pull();
push("renaming an existing folder");
camel_store_rename_folder(store, "testbox", "testbox2", ex);
check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
pull();
push("opening the old name of a renamed folder");
folder = camel_store_get_folder(store, "testbox", 0, ex);
check(camel_exception_is_set(ex));
check(folder == NULL);
camel_exception_clear(ex);
pull();
push("opening the old name of a renamed folder");
folder = camel_store_get_folder(store, "testbox", 0, ex);
check(camel_exception_is_set(ex));
check(folder == NULL);
camel_exception_clear(ex);
pull();
push("opening the new name of a renamed folder");
folder = camel_store_get_folder(store, "testbox2", 0, ex);
check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
check(folder != NULL);
check_unref(folder, 1);
pull();
push("opening the new name of a renamed folder");
folder = camel_store_get_folder(store, "testbox2", 0, ex);
check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
check(folder != NULL);
check_unref(folder, 1);
pull();
}
push("deleting a non-existant folder");
camel_store_delete_folder(store, "unknown", ex);
@ -271,10 +273,12 @@ test_folder_basic(CamelSession *session, const char *storename, int local)
camel_exception_clear(ex);
pull();
push("deleting an existing folder");
camel_store_delete_folder(store, "testbox2", ex);
check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
pull();
if (!spool) {
push("deleting an existing folder");
camel_store_delete_folder(store, "testbox2", ex);
check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
pull();
}
push("opening a folder that has been deleted");
folder = camel_store_get_folder(store, "testbox2", 0, ex);
@ -294,7 +298,7 @@ test_folder_basic(CamelSession *session, const char *storename, int local)
/* todo: cross-check everything with folder_info checks as well */
/* this should probably take a folder instead of a session ... */
void
test_folder_message_ops(CamelSession *session, const char *name, int local)
test_folder_message_ops(CamelSession *session, const char *name, int local, int spool)
{
CamelStore *store;
CamelException *ex = camel_exception_new();
@ -499,10 +503,12 @@ test_folder_message_ops(CamelSession *session, const char *name, int local)
check_unref(folder, 1);
pull(); /* re-opening folder */
push("deleting test folder, with no messages in it");
camel_store_delete_folder(store, "testbox", ex);
check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
pull();
if (!spool) {
push("deleting test folder, with no messages in it");
camel_store_delete_folder(store, "testbox", ex);
check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
pull();
}
check_unref(store, 1);
camel_test_end();

4
camel/tests/lib/folders.h
View File

@ -15,6 +15,6 @@ void test_folder_message(CamelFolder *folder, const char *uid);
/* check message not present everywhere it shouldn't be */
void test_folder_not_message(CamelFolder *folder, const char *uid);
/* test basic folder ops on a store */
void test_folder_basic(CamelSession *session, const char *storename, int local);
void test_folder_basic(CamelSession *session, const char *storename, int local, int spool);
/* test basic message operations on a folder */
void test_folder_message_ops(CamelSession *session, const char *storename, int local);
void test_folder_message_ops(CamelSession *session, const char *storename, int local, int spool);

2
camel/tests/message/Makefile.am
View File

@ -4,10 +4,12 @@ INCLUDES = -I$(top_srcdir)/intl -I$(top_srcdir) -I$(top_srcdir)/camel \
-I$(top_srcdir)/camel/tests/lib \
-DG_LOG_DOMAIN=\"evolution-tests\"
# We want to remove the DB3 crap asap.
LDADD = \
$(top_builddir)/camel/libcamel.la \
$(top_builddir)/e-util/libeutil.la \
$(top_builddir)/libibex/libibex.la \
$(DB3_LDADD) \
$(GNOME_LIBDIR) \
$(top_builddir)/camel/tests/lib/libcameltest.a \
$(GNOMEUI_LIBS) $(INTLLIBS) $(EXTRA_GNOME_LIBS)

1
camel/tests/misc/Makefile.am
View File

@ -8,6 +8,7 @@ LDADD = \
$(top_builddir)/camel/libcamel.la \
$(top_builddir)/e-util/libeutil.la \
$(top_builddir)/libibex/libibex.la \
$(DB3_LDADD) \
$(GNOME_LIBDIR) \
$(top_builddir)/camel/tests/lib/libcameltest.a \
$(GNOMEUI_LIBS) $(INTLLIBS) $(EXTRA_GNOME_LIBS)

1
camel/tests/smime/Makefile.am
View File

@ -8,6 +8,7 @@ LDADD = \
$(top_builddir)/camel/libcamel.la \
$(top_builddir)/e-util/libeutil.la \
$(top_builddir)/libibex/libibex.la \
$(DB3_LDADD) \
$(GNOME_LIBDIR) \
$(top_builddir)/camel/tests/lib/libcameltest.a \
$(GNOMEUI_LIBS) $(INTLLIBS) $(EXTRA_GNOME_LIBS) \

1
camel/tests/stream/Makefile.am
View File

@ -8,6 +8,7 @@ LDADD = \
$(top_builddir)/camel/libcamel.la \
$(top_builddir)/e-util/libeutil.la \
$(top_builddir)/libibex/libibex.la \
$(DB3_LDADD) \
$(GNOME_LIBDIR) \
$(top_builddir)/camel/tests/lib/libcameltest.a \
$(GNOMEUI_LIBS) $(INTLLIBS) $(EXTRA_GNOME_LIBS)