new abstract class for disconnectable remote stores

	* camel-disco-store.c: new abstract class for disconnectable
	remote stores

	* camel-disco-folder.c: new abstract class for folders on
	disconnectable stores.

	* Makefile.am: Add camel-disco-folder.[ch] and
	camel-disco-store.[ch].

	* providers/imap/camel-imap-store.c: Make this a subclass of
	CamelDiscoStore, and fix up the offline interfaces for the changes
	since they were first written (particularly the fact that some
	IMAP stores don't just use subscribed folders).

	* providers/imap/camel-imap-folder.c: Make this a subclass of
	CamelDiscoFolder, although most ops still fail in disconnected
	mode.

	* camel-store.c (camel_store_get_folder_info): Change gboolean,
	gboolean, gboolean to guint32 in the prototype for this function.

	* providers/local/camel-local-store.c (get_folder_info): Update
	for prototype change.

svn path=/trunk/; revision=9659

14 files changed, 1174 insertions, 536 deletions

diff --git a/camel/ChangeLog b/camel/ChangeLog
index 4903f69e6a..ecad1c19d2 100644
--- a/camel/ChangeLog
+++ b/camel/ChangeLog
@@ -1,3 +1,29 @@
+2001-05-03  Dan Winship  <danw@ximian.com>
+
+	* camel-disco-store.c: new abstract class for disconnectable
+	remote stores
+
+	* camel-disco-folder.c: new abstract class for folders on
+	disconnectable stores.
+
+	* Makefile.am: Add camel-disco-folder.[ch] and
+	camel-disco-store.[ch].
+
+	* providers/imap/camel-imap-store.c: Make this a subclass of
+	CamelDiscoStore, and fix up the offline interfaces for the changes
+	since they were first written (particularly the fact that some
+	IMAP stores don't just use subscribed folders).
+
+	* providers/imap/camel-imap-folder.c: Make this a subclass of
+	CamelDiscoFolder, although most ops still fail in disconnected
+	mode.
+
+	* camel-store.c (camel_store_get_folder_info): Change gboolean,
+	gboolean, gboolean to guint32 in the prototype for this function.
+
+	* providers/local/camel-local-store.c (get_folder_info): Update
+	for prototype change.
+
 2001-05-02  Dan Winship  <danw@ximian.com>
 
 	* providers/imap/camel-imap-store.h: Clean this up a bit. Add a
diff --git a/camel/Makefile.am b/camel/Makefile.am
index 53f7befbfe..8145b960ae 100644
--- a/camel/Makefile.am
+++ b/camel/Makefile.am
@@ -24,6 +24,8 @@ libcamel_la_SOURCES = 				\
 	camel-cipher-context.c			\
 	camel-data-wrapper.c			\
 	camel-digest-folder.c			\
+	camel-disco-folder.c			\
+	camel-disco-store.c			\
 	camel-exception.c			\
 	camel-file-utils.c			\
 	camel-filter-driver.c			\
@@ -100,6 +102,9 @@ libcamelinclude_HEADERS =			\
 	camel-cipher-context.h			\
 	camel-data-wrapper.h			\
 	camel-digest-folder.h			\
+	camel-disco-diary.h			\
+	camel-disco-folder.h			\
+	camel-disco-store.h			\
 	camel-exception-list.def		\
 	camel-exception.h			\
 	camel-file-utils.h			\
diff --git a/camel/camel-disco-folder.c b/camel/camel-disco-folder.c
new file mode 100644
index 0000000000..bce6eaef06
--- /dev/null
+++ b/camel/camel-disco-folder.c
@@ -0,0 +1,243 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/* camel-disco-folder.c: abstract class for a disconnectable folder */
+
+/* 
+ * Authors: Dan Winship <danw@ximian.com>
+ *
+ * Copyright (C) 2001 Ximian, Inc.
+ *
+ * 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 "camel-disco-diary.h"
+#include "camel-disco-folder.h"
+#include "camel-disco-store.h"
+#include "camel-exception.h"
+
+#define CF_CLASS(o) (CAMEL_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS (o)))
+#define CDF_CLASS(o) (CAMEL_DISCO_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS (o)))
+
+static CamelFolderClass *parent_class = NULL;
+
+static void disco_refresh_info (CamelFolder *folder, CamelException *ex);
+static void disco_sync (CamelFolder *folder, gboolean expunge, CamelException *ex);
+static void disco_expunge (CamelFolder *folder, CamelException *ex);
+
+static void disco_append_message (CamelFolder *folder, CamelMimeMessage *message,
+				  const CamelMessageInfo *info, CamelException *ex);
+static void disco_copy_messages_to (CamelFolder *source, GPtrArray *uids,
+				    CamelFolder *destination, CamelException *ex);
+static void disco_move_messages_to (CamelFolder *source, GPtrArray *uids,
+				    CamelFolder *destination, CamelException *ex);
+
+
+static void
+camel_disco_folder_class_init (CamelDiscoFolderClass *camel_disco_folder_class)
+{
+	CamelFolderClass *camel_folder_class = CAMEL_FOLDER_CLASS (camel_disco_folder_class);
+
+	parent_class = CAMEL_FOLDER_CLASS (camel_type_get_global_classfuncs (camel_folder_get_type ()));
+
+	/* virtual method overload */
+	camel_folder_class->refresh_info = disco_refresh_info;
+	camel_folder_class->sync = disco_sync;
+	camel_folder_class->expunge = disco_expunge;
+
+	camel_folder_class->append_message = disco_append_message;
+	camel_folder_class->copy_messages_to = disco_copy_messages_to;
+	camel_folder_class->move_messages_to = disco_move_messages_to;
+}
+
+CamelType
+camel_disco_folder_get_type (void)
+{
+	static CamelType camel_disco_folder_type = CAMEL_INVALID_TYPE;
+
+	if (camel_disco_folder_type == CAMEL_INVALID_TYPE) {
+		camel_disco_folder_type = camel_type_register (
+			CAMEL_FOLDER_TYPE, "CamelDiscoFolder",
+			sizeof (CamelDiscoFolder),
+			sizeof (CamelDiscoFolderClass),
+			(CamelObjectClassInitFunc) camel_disco_folder_class_init,
+			NULL, NULL, NULL);
+	}
+
+	return camel_disco_folder_type;
+}
+
+
+static void
+disco_refresh_info (CamelFolder *folder, CamelException *ex)
+{
+	if (camel_disco_store_status (CAMEL_DISCO_STORE (folder->parent_store)) != CAMEL_DISCO_STORE_ONLINE)
+		return;
+	CDF_CLASS (folder)->refresh_info_online (folder, ex);
+}
+
+static void
+disco_sync (CamelFolder *folder, gboolean expunge, CamelException *ex)
+{
+	if (expunge) {
+		disco_expunge (folder, ex);
+		if (camel_exception_is_set (ex))
+			return;
+	}
+
+	switch (camel_disco_store_status (CAMEL_DISCO_STORE (folder->parent_store))) {
+	case CAMEL_DISCO_STORE_ONLINE:
+		CDF_CLASS (folder)->sync_online (folder, ex);
+		break;
+
+	case CAMEL_DISCO_STORE_OFFLINE:
+		CDF_CLASS (folder)->sync_offline (folder, ex);
+		break;
+	}
+}
+
+static void
+disco_expunge_uids (CamelFolder *folder, GPtrArray *uids, CamelException *ex)
+{
+	CamelDiscoStore *disco = CAMEL_DISCO_STORE (folder->parent_store);
+
+	if (uids->len == 0)
+		return;
+
+	switch (camel_disco_store_status (disco)) {
+	case CAMEL_DISCO_STORE_ONLINE:
+		CDF_CLASS (folder)->expunge_uids_online (folder, uids, ex);
+		break;
+
+	case CAMEL_DISCO_STORE_OFFLINE:
+		CDF_CLASS (folder)->expunge_uids_offline (folder, uids, ex);
+#ifdef NOTYET
+		if (!camel_exception_is_set (ex))
+			camel_disco_diary_log (disco->diary, CAMEL_DISCO_DIARY_FOLDER_EXPUNGE, folder, uids);
+#endif
+		break;
+	}
+}
+
+static void
+disco_expunge (CamelFolder *folder, CamelException *ex)
+{
+	GPtrArray *uids;
+	int i, count;
+	CamelMessageInfo *info;
+
+	uids = g_ptr_array_new ();
+	count = camel_folder_summary_count (folder->summary);
+	for (i = 0; i < count; i++) {
+		info = camel_folder_summary_index (folder->summary, i);
+		if (info->flags & CAMEL_MESSAGE_DELETED)
+			g_ptr_array_add (uids, g_strdup (camel_message_info_uid (info)));
+		camel_folder_summary_info_free (folder->summary, info);
+	}
+
+	disco_expunge_uids (folder, uids, ex);
+
+	for (i = 0; i < uids->len; i++)
+		g_free (uids->pdata[i]);
+	g_ptr_array_free (uids, TRUE);
+}
+
+static void
+disco_append_message (CamelFolder *folder, CamelMimeMessage *message,
+		      const CamelMessageInfo *info, CamelException *ex)
+{
+	CamelDiscoStore *disco = CAMEL_DISCO_STORE (folder->parent_store);
+	char *uid;
+
+	switch (camel_disco_store_status (disco)) {
+	case CAMEL_DISCO_STORE_ONLINE:
+		uid = CDF_CLASS (folder)->append_online (folder, message, info, ex);
+		break;
+
+	case CAMEL_DISCO_STORE_OFFLINE:
+		uid = CDF_CLASS (folder)->append_offline (folder, message, info, ex);
+#ifdef NOTYET
+		if (uid)
+			camel_disco_diary_log (disco->diary, CAMEL_DISCO_DIARY_FOLDER_APPEND, folder, uid);
+#endif
+		break;
+	}
+	g_free (uid);
+}
+
+static void
+disco_copy_messages_to (CamelFolder *source, GPtrArray *uids,
+			CamelFolder *destination, CamelException *ex)
+{
+	CamelDiscoStore *disco = CAMEL_DISCO_STORE (source->parent_store);
+
+	switch (camel_disco_store_status (disco)) {
+	case CAMEL_DISCO_STORE_ONLINE:
+		CDF_CLASS (source)->copy_online (source, uids, destination, ex);
+		break;
+
+	case CAMEL_DISCO_STORE_OFFLINE:
+		CDF_CLASS (source)->copy_offline (source, uids, destination, ex);
+#ifdef NOTYET
+		if (!camel_exception_is_set (ex))
+			camel_disco_diary_log (disco->diary, CAMEL_DISCO_DIARY_FOLDER_COPY, source, destination, uids);
+#endif
+		break;
+	}
+}
+
+static void
+disco_move_messages_to (CamelFolder *source, GPtrArray *uids,
+			CamelFolder *destination, CamelException *ex)
+{
+	CamelDiscoStore *disco = CAMEL_DISCO_STORE (source->parent_store);
+
+	switch (camel_disco_store_status (disco)) {
+	case CAMEL_DISCO_STORE_ONLINE:
+		CDF_CLASS (source)->move_online (source, uids, destination, ex);
+		break;
+
+	case CAMEL_DISCO_STORE_OFFLINE:
+		CDF_CLASS (source)->move_offline (source, uids, destination, ex);
+#ifdef NOTYET
+		if (!camel_exception_is_set (ex))
+			camel_disco_diary_log (disco->diary, CAMEL_DISCO_DIARY_FOLDER_MOVE, source, destination, uids);
+#endif
+		break;
+	}
+}
+
+
+/**
+ * camel_disco_folder_expunge_uids:
+ * @folder: a (disconnectable) folder
+ * @uids: array of UIDs to expunge
+ * @ex: a CamelException
+ *
+ * This expunges the messages in @uids from @folder. It should take
+ * whatever steps are needed to avoid expunging any other messages,
+ * although in some cases it may not be possible to avoid expunging
+ * messages that are marked deleted by another client at the same time
+ * as the expunge_uids call is running.
+ **/
+void
+camel_disco_folder_expunge_uids (CamelFolder *folder, GPtrArray *uids,
+				 CamelException *ex)
+{
+	disco_expunge_uids (folder, uids, ex);
+}
diff --git a/camel/camel-disco-folder.h b/camel/camel-disco-folder.h
new file mode 100644
index 0000000000..23e9d24923
--- /dev/null
+++ b/camel/camel-disco-folder.h
@@ -0,0 +1,94 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ *
+ * camel-disco-folder.h: Abstract class for a disconnectable folder
+ *
+ * Authors: Dan Winship <danw@ximian.com>
+ *
+ * Copyright 2001 Ximian, Inc.
+ *
+ * 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_DISCO_FOLDER_H
+#define CAMEL_DISCO_FOLDER_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#pragma }
+#endif /* __cplusplus }*/
+
+#include "camel-folder.h"
+
+#define CAMEL_DISCO_FOLDER_TYPE     (camel_disco_folder_get_type ())
+#define CAMEL_DISCO_FOLDER(obj)     (CAMEL_CHECK_CAST((obj), CAMEL_DISCO_FOLDER_TYPE, CamelDiscoFolder))
+#define CAMEL_DISCO_FOLDER_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_DISCO_FOLDER_TYPE, CamelDiscoFolderClass))
+#define CAMEL_IS_DISCO_FOLDER(o)    (CAMEL_CHECK_TYPE((o), CAMEL_DISCO_FOLDER_TYPE))
+
+struct _CamelDiscoFolder {
+	CamelFolder parent_object;
+
+};
+
+typedef struct {
+	CamelFolderClass parent_class;
+
+	void   (*refresh_info_online) (CamelFolder *folder, CamelException *ex);
+
+	void   (*sync_online)    (CamelFolder *folder, CamelException *ex);
+	void   (*sync_offline)   (CamelFolder *folder, CamelException *ex);
+
+	void   (*expunge_uids_online)    (CamelFolder *folder, GPtrArray *uids,
+					  CamelException *ex);
+	void   (*expunge_uids_offline)   (CamelFolder *folder, GPtrArray *uids,
+					  CamelException *ex);
+
+	char * (*append_online)    (CamelFolder *folder,
+				    CamelMimeMessage *message,
+				    const CamelMessageInfo *info,
+				    CamelException *ex);
+	char * (*append_offline)   (CamelFolder *folder,
+				    CamelMimeMessage *message,
+				    const CamelMessageInfo *info,
+				    CamelException *ex);
+
+	void (*copy_online)    (CamelFolder *source, GPtrArray *uids,
+				CamelFolder *destination, CamelException *ex);
+	void (*copy_offline)   (CamelFolder *source, GPtrArray *uids,
+				CamelFolder *destination, CamelException *ex);
+	
+	void (*move_online)    (CamelFolder *source, GPtrArray *uids,
+				CamelFolder *destination, CamelException *ex);
+	void (*move_offline)   (CamelFolder *source, GPtrArray *uids,
+				CamelFolder *destination, CamelException *ex);
+
+	void (*update_uid) (CamelFolder *folder, const char *old_uid,
+			    const char *new_uid);
+} CamelDiscoFolderClass;
+
+
+/* public methods */
+void camel_disco_folder_expunge_uids (CamelFolder *folder, GPtrArray *uids,
+				      CamelException *ex);
+
+
+/* Standard Camel function */
+CamelType camel_disco_folder_get_type (void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* CAMEL_DISCO_FOLDER_H */
diff --git a/camel/camel-disco-store.c b/camel/camel-disco-store.c
new file mode 100644
index 0000000000..10d3ae78b3
--- /dev/null
+++ b/camel/camel-disco-store.c
@@ -0,0 +1,194 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/* camel-disco-store.c: abstract class for a disconnectable remote store */
+
+/*
+ *  Authors: Dan Winship <danw@ximian.com>
+ *
+ *  Copyright 2001 Ximian, Inc.
+ *
+ *  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 Street #330, Boston, MA 02111-1307, USA.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "camel-disco-store.h"
+#include "camel-exception.h"
+
+#define CDS_CLASS(o) (CAMEL_DISCO_STORE_CLASS (CAMEL_OBJECT_GET_CLASS (o)))
+
+static CamelRemoteStoreClass *remote_store_class = NULL;
+
+static gboolean disco_connect (CamelService *service, CamelException *ex);
+static gboolean disco_disconnect (CamelService *service, gboolean clean, CamelException *ex);
+static CamelFolder *disco_get_folder (CamelStore *store, const char *name,
+				      guint32 flags, CamelException *ex);
+static CamelFolderInfo *disco_get_folder_info (CamelStore *store,
+					       const char *top, guint32 flags,
+					       CamelException *ex);
+
+static void
+camel_disco_store_class_init (CamelDiscoStoreClass *camel_disco_store_class)
+{
+	CamelServiceClass *camel_service_class =
+		CAMEL_SERVICE_CLASS (camel_disco_store_class);
+	CamelStoreClass *camel_store_class =
+		CAMEL_STORE_CLASS (camel_disco_store_class);
+
+	remote_store_class = CAMEL_REMOTE_STORE_CLASS (camel_type_get_global_classfuncs (camel_remote_store_get_type ()));
+
+	/* virtual method overload */
+	camel_service_class->connect = disco_connect;
+	camel_service_class->disconnect = disco_disconnect;
+
+	camel_store_class->get_folder = disco_get_folder;
+	camel_store_class->get_folder_info = disco_get_folder_info;
+}
+
+static void
+camel_disco_store_init (CamelDiscoStore *store)
+{
+	/* Hack */
+	if (getenv ("CAMEL_OFFLINE"))
+		store->status = CAMEL_DISCO_STORE_OFFLINE;
+	else
+		store->status = CAMEL_DISCO_STORE_ONLINE;
+}
+
+CamelType
+camel_disco_store_get_type (void)
+{
+	static CamelType camel_disco_store_type = CAMEL_INVALID_TYPE;
+
+	if (camel_disco_store_type == CAMEL_INVALID_TYPE) {
+		camel_disco_store_type = camel_type_register (
+			CAMEL_REMOTE_STORE_TYPE, "CamelDiscoStore",
+			sizeof (CamelDiscoStore),
+			sizeof (CamelDiscoStoreClass),
+			(CamelObjectClassInitFunc) camel_disco_store_class_init,
+			NULL,
+			(CamelObjectInitFunc) camel_disco_store_init,
+			NULL);
+	}
+
+	return camel_disco_store_type;
+}
+
+static gboolean
+disco_connect (CamelService *service, CamelException *ex)
+{
+	CamelDiscoStore *store = CAMEL_DISCO_STORE (service);
+
+	if (!CAMEL_SERVICE_CLASS (remote_store_class)->connect (service, ex))
+		return FALSE;
+
+	switch (camel_disco_store_status (store)) {
+	case CAMEL_DISCO_STORE_ONLINE:
+		return CDS_CLASS (service)->connect_online (service, ex);
+
+	case CAMEL_DISCO_STORE_OFFLINE:
+		return CDS_CLASS (service)->connect_offline (service, ex);
+	}
+
+	/* Not reached */
+	return TRUE;
+}
+
+static gboolean
+disco_disconnect (CamelService *service, gboolean clean, CamelException *ex)
+{
+	CamelDiscoStore *store = CAMEL_DISCO_STORE (service);
+
+	switch (camel_disco_store_status (store)) {
+	case CAMEL_DISCO_STORE_ONLINE:
+		if (!CDS_CLASS (service)->disconnect_online (service, clean, ex))
+			return FALSE;
+		break;
+
+	case CAMEL_DISCO_STORE_OFFLINE:
+		if (!CDS_CLASS (service)->disconnect_offline (service, clean, ex))
+			return FALSE;
+		break;
+	}
+
+	return CAMEL_SERVICE_CLASS (remote_store_class)->disconnect (service, clean, ex);
+}
+
+static CamelFolder *
+disco_get_folder (CamelStore *store, const char *name,
+		  guint32 flags, CamelException *ex)
+{
+	CamelDiscoStore *disco_store = CAMEL_DISCO_STORE (store);
+
+	switch (camel_disco_store_status (disco_store)) {
+	case CAMEL_DISCO_STORE_ONLINE:
+		return CDS_CLASS (store)->get_folder_online (store, name, flags, ex);
+
+	case CAMEL_DISCO_STORE_OFFLINE:
+		return CDS_CLASS (store)->get_folder_offline (store, name, flags, ex);
+	}
+
+	/* Not reached */
+	return NULL;
+}
+
+static CamelFolderInfo *
+disco_get_folder_info (CamelStore *store, const char *top,
+		       guint32 flags, CamelException *ex)
+{
+	CamelDiscoStore *disco_store = CAMEL_DISCO_STORE (store);
+
+	switch (camel_disco_store_status (disco_store)) {
+	case CAMEL_DISCO_STORE_ONLINE:
+		return CDS_CLASS (store)->get_folder_info_online (store, top, flags, ex);
+
+	case CAMEL_DISCO_STORE_OFFLINE:
+		/* Can't edit subscriptions while offline */
+		if ((store->flags & CAMEL_STORE_SUBSCRIPTIONS) &&
+		    !(flags & CAMEL_STORE_FOLDER_INFO_SUBSCRIBED)) {
+			camel_disco_store_check_online (disco_store, ex);
+			return NULL;
+		}
+
+		return CDS_CLASS (store)->get_folder_info_offline (store, top, flags, ex);
+	}
+
+	/* Not reached */
+	return NULL;
+}
+
+
+CamelDiscoStoreStatus
+camel_disco_store_status (CamelDiscoStore *store)
+{
+	g_return_val_if_fail (CAMEL_IS_DISCO_STORE (store), CAMEL_DISCO_STORE_ONLINE);
+
+	return store->status;
+}
+
+gboolean
+camel_disco_store_check_online (CamelDiscoStore *store, CamelException *ex)
+{
+	if (camel_disco_store_status (store) != CAMEL_DISCO_STORE_ONLINE) {
+		camel_exception_set (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
+				     _("You must be working online to "
+				       "complete this operation"));
+		return FALSE;
+	}
+
+	return TRUE;
+}
diff --git a/camel/camel-disco-store.h b/camel/camel-disco-store.h
new file mode 100644
index 0000000000..3bba4e8a2b
--- /dev/null
+++ b/camel/camel-disco-store.h
@@ -0,0 +1,105 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/* camel-disco-store.h: abstruct class for a disconnectable store */
+
+/* 
+ * Authors: Dan Winship <danw@ximian.com>
+ *
+ * Copyright (C) 2001 Ximian, Inc.
+ *
+ * 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_DISCO_STORE_H
+#define CAMEL_DISCO_STORE_H 1
+
+
+#ifdef __cplusplus
+extern "C" {
+#pragma }
+#endif /* __cplusplus }*/
+
+#include "camel-remote-store.h"
+
+#define CAMEL_DISCO_STORE_TYPE     (camel_disco_store_get_type ())
+#define CAMEL_DISCO_STORE(obj)     (CAMEL_CHECK_CAST((obj), CAMEL_DISCO_STORE_TYPE, CamelDiscoStore))
+#define CAMEL_DISCO_STORE_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_DISCO_STORE_TYPE, CamelDiscoStoreClass))
+#define CAMEL_IS_DISCO_STORE(o)    (CAMEL_CHECK_TYPE((o), CAMEL_DISCO_STORE_TYPE))
+
+typedef enum {
+	CAMEL_DISCO_STORE_ONLINE,
+	CAMEL_DISCO_STORE_OFFLINE,
+#ifdef NOTYET
+	CAMEL_DISCO_STORE_RESYNCING
+#endif
+} CamelDiscoStoreStatus;
+
+struct _CamelDiscoStore {
+	CamelRemoteStore parent_object;	
+
+	CamelDiscoStoreStatus status;
+	CamelDiscoDiary *diary;
+};
+
+
+typedef struct {
+	CamelRemoteStoreClass parent_class;
+
+	gboolean          (*connect_online)          (CamelService *,
+						      CamelException *);
+	gboolean          (*connect_offline)         (CamelService *,
+						      CamelException *);
+
+	gboolean          (*disconnect_online)       (CamelService *, gboolean,
+						      CamelException *);
+	gboolean          (*disconnect_offline)      (CamelService *, gboolean,
+						      CamelException *);
+
+	CamelFolder *     (*get_folder_online)       (CamelStore *store,
+						      const char *name,
+						      guint32 flags,
+						      CamelException *ex);
+	CamelFolder *     (*get_folder_offline)      (CamelStore *store,
+						      const char *name,
+						      guint32 flags,
+						      CamelException *ex);
+
+	CamelFolderInfo * (*get_folder_info_online)  (CamelStore *store,
+						      const char *top,
+						      guint32 flags,
+						      CamelException *ex);
+	CamelFolderInfo * (*get_folder_info_offline) (CamelStore *store,
+						      const char *top,
+						      guint32 flags,
+						      CamelException *ex);
+
+} CamelDiscoStoreClass;
+
+
+/* Standard Camel function */
+CamelType camel_disco_store_get_type (void);
+
+/* Public methods */
+CamelDiscoStoreStatus camel_disco_store_status       (CamelDiscoStore *store);
+
+/* Convenience functions */
+gboolean camel_disco_store_check_online (CamelDiscoStore *store, CamelException *ex);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* CAMEL_DISCO_STORE_H */
diff --git a/camel/camel-store.c b/camel/camel-store.c
index 3314b710d8..3418bd9a56 100644
--- a/camel/camel-store.c
+++ b/camel/camel-store.c
@@ -60,9 +60,7 @@ static void rename_folder (CamelStore *store, const char *old_name,
 
 static void store_sync (CamelStore *store, CamelException *ex);
 static CamelFolderInfo *get_folder_info (CamelStore *store, const char *top,
-					 gboolean fast, gboolean recursive,
-					 gboolean subscribed_only,
-					 CamelException *ex);
+					 guint32 flags, CamelException *ex);
 static void free_folder_info (CamelStore *store, CamelFolderInfo *tree);
 
 static gboolean folder_subscribed (CamelStore *store, const char *folder_name);
@@ -471,9 +469,7 @@ camel_store_sync (CamelStore *store, CamelException *ex)
 
 static CamelFolderInfo *
 get_folder_info (CamelStore *store, const char *top,
-		 gboolean fast, gboolean recursive,
-		 gboolean subscribed_only,
-		 CamelException *ex)
+		 guint32 flags, CamelException *ex)
 {
 	g_warning ("CamelStore::get_folder_info not implemented for `%s'",
 		   camel_type_to_name (CAMEL_OBJECT_GET_TYPE (store)));
@@ -484,36 +480,37 @@ get_folder_info (CamelStore *store, const char *top,
  * camel_store_get_folder_info:
  * @store: a CamelStore
  * @top: the name of the folder to start from
- * @fast: whether or not to do a "fast" scan.
- * @recursive: whether to include information for subfolders
+ * @flags: various CAMEL_STORE_FOLDER_INFO_* flags to control behavior
  * @ex: a CamelException
  *
  * This fetches information about the folder structure of @store,
  * starting with @top, and returns a tree of CamelFolderInfo
- * structures. If @fast is %TRUE, the message_count or
- * unread_message_count fields of some or all of the structures may be
- * set to -1, if the store cannot determine that information quickly.
- * If @recursive is %TRUE, the returned tree will include all levels of
- * hierarchy below @top. If it is %FALSE, it will only include the
- * immediate subfolders of @top.
- *
+ * structures. If @flags includes %CAMEL_STORE_FOLDER_INFO_SUBSCRIBED,
+ * only subscribed folders will be listed. (This flag can only be used
+ * for stores that support subscriptions.) If @flags includes
+ * %CAMEL_STORE_FOLDER_INFO_RECURSIVE, the returned tree will include
+ * all levels of hierarchy below @top. If not, it will only include
+ * the immediate subfolders of @top. If @flags includes
+ * %CAMEL_STORE_FOLDER_INFO_FAST, the unread_message_count fields of
+ * some or all of the structures may be set to -1, if the store cannot
+ * determine that information quickly.
+ * 
  * Return value: a CamelFolderInfo tree, which must be freed with
  * camel_store_free_folder_info.
  **/
 CamelFolderInfo *
 camel_store_get_folder_info (CamelStore *store, const char *top,
-			     gboolean fast, gboolean recursive,
-			     gboolean subscribed_only,
-			     CamelException *ex)
+			     guint32 flags, CamelException *ex)
 {
 	CamelFolderInfo *ret;
 
 	g_return_val_if_fail (CAMEL_IS_STORE (store), NULL);
+	g_return_val_if_fail ((store->flags & CAMEL_STORE_SUBSCRIPTIONS) ||
+			      !(flags & CAMEL_STORE_FOLDER_INFO_SUBSCRIBED),
+			      NULL);
 
 	CAMEL_STORE_LOCK(store, folder_lock);
-
-	ret = CS_CLASS (store)->get_folder_info (store, top, fast, recursive, subscribed_only, ex);
-
+	ret = CS_CLASS (store)->get_folder_info (store, top, flags, ex);
 	CAMEL_STORE_UNLOCK(store, folder_lock);
 
 	return ret;
diff --git a/camel/camel-store.h b/camel/camel-store.h
index 51d6570348..d81f08e914 100644
--- a/camel/camel-store.h
+++ b/camel/camel-store.h
@@ -72,6 +72,10 @@ struct _CamelStore
 #define CAMEL_STORE_FOLDER_BODY_INDEX (1<<1)
 #define CAMEL_STORE_FOLDER_PRIVATE (1<<2) /* a private folder, that shouldn't show up in unmatched/folder info's, etc */
 
+#define CAMEL_STORE_FOLDER_INFO_FAST       (1 << 0)
+#define CAMEL_STORE_FOLDER_INFO_RECURSIVE  (1 << 1)
+#define CAMEL_STORE_FOLDER_INFO_SUBSCRIBED (1 << 2)
+
 typedef struct {
 	CamelServiceClass parent_class;
 
@@ -104,12 +108,9 @@ typedef struct {
 	void            (*sync)                     (CamelStore *store,
 						     CamelException *ex);
 
-	/* this should take flags instead, so its more futureproof */
 	CamelFolderInfo *(*get_folder_info)         (CamelStore *store,
 						     const char *top,
-						     gboolean fast,
-						     gboolean recursive,
-						     gboolean subscribed_only,
+						     guint32 flags,
 						     CamelException *ex);
 	void            (*free_folder_info)         (CamelStore *store,
 						     CamelFolderInfo *fi);
@@ -155,9 +156,7 @@ void             camel_store_sync               (CamelStore *store,
 
 CamelFolderInfo *camel_store_get_folder_info    (CamelStore *store,
 						 const char *top,
-						 gboolean fast,
-						 gboolean recursive,
-						 gboolean subscribed_only,
+						 guint32 flags,
 						 CamelException *ex);
 void             camel_store_free_folder_info   (CamelStore *store,
 						 CamelFolderInfo *fi);
diff --git a/camel/camel-types.h b/camel/camel-types.h
index 727c0a266c..dbcce56550 100644
--- a/camel/camel-types.h
+++ b/camel/camel-types.h
@@ -29,6 +29,8 @@ extern "C" {
 
 typedef struct _CamelAddress CamelAddress;
 typedef struct _header_content_type CamelContentType;
+typedef struct _CamelDiscoFolder CamelDiscoFolder;
+typedef struct _CamelDiscoStore CamelDiscoStore;
 typedef struct _CamelDataWrapper CamelDataWrapper;
 typedef struct _CamelException CamelException;
 typedef struct _CamelFolder CamelFolder;
diff --git a/camel/providers/imap/camel-imap-folder.c b/camel/providers/imap/camel-imap-folder.c
index 4ee65371fd..d0828ccac9 100644
--- a/camel/providers/imap/camel-imap-folder.c
+++ b/camel/providers/imap/camel-imap-folder.c
@@ -2,9 +2,11 @@
 /* camel-imap-folder.c: class for an imap folder */
 
 /* 
- * Authors: Jeffrey Stedfast <fejj@helixcode.com> 
+ * Authors:
+ *   Dan Winship <danw@ximian.com>
+ *   Jeffrey Stedfast <fejj@ximian.com> 
  *
- * Copyright (C) 2000 Helix Code, Inc.
+ * Copyright (C) 2000, 2001 Ximian, Inc.
  *
  * This program is free software; you can redistribute it and/or 
  * modify it under the terms of the GNU General Public License as 
@@ -60,26 +62,29 @@
 #include "camel-multipart.h"
 #include "camel-operation.h"
 
-#define d(x) x
-
 #define CF_CLASS(o) (CAMEL_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(o)))
-
-static CamelFolderClass *parent_class = NULL;
+static CamelDiscoFolderClass *disco_folder_class = NULL;
 
 static void imap_finalize (CamelObject *object);
 static void imap_rescan (CamelFolder *folder, int exists, CamelException *ex);
 static void imap_refresh_info (CamelFolder *folder, CamelException *ex);
-static void imap_sync (CamelFolder *folder, gboolean expunge, CamelException *ex);
+static void imap_sync_online (CamelFolder *folder, CamelException *ex);
+static void imap_sync_offline (CamelFolder *folder, CamelException *ex);
 static const char *imap_get_full_name (CamelFolder *folder);
-static void imap_expunge (CamelFolder *folder, CamelException *ex);
+static void imap_expunge_uids_online (CamelFolder *folder, GPtrArray *uids, CamelException *ex);
+static void imap_expunge_uids_offline (CamelFolder *folder, GPtrArray *uids, CamelException *ex);
 
 /* message manipulation */
 static CamelMimeMessage *imap_get_message (CamelFolder *folder, const gchar *uid,
 					   CamelException *ex);
-static void imap_append_message (CamelFolder *folder, CamelMimeMessage *message,
+static char *imap_append_online (CamelFolder *folder, CamelMimeMessage *message,
 				 const CamelMessageInfo *info, CamelException *ex);
-static void imap_copy_messages_to (CamelFolder *source, GPtrArray *uids,
-				   CamelFolder *destination, CamelException *ex);
+static char *imap_append_offline (CamelFolder *folder, CamelMimeMessage *message,
+				  const CamelMessageInfo *info, CamelException *ex);
+static void imap_copy_online (CamelFolder *source, GPtrArray *uids,
+			      CamelFolder *destination, CamelException *ex);
+static void imap_copy_offline (CamelFolder *source, GPtrArray *uids,
+			       CamelFolder *destination, CamelException *ex);
 static void imap_move_messages_to (CamelFolder *source, GPtrArray *uids,
 				   CamelFolder *destination, CamelException *ex);
 
@@ -93,24 +98,26 @@ static void
 camel_imap_folder_class_init (CamelImapFolderClass *camel_imap_folder_class)
 {
 	CamelFolderClass *camel_folder_class = CAMEL_FOLDER_CLASS (camel_imap_folder_class);
+	CamelDiscoFolderClass *camel_disco_folder_class = CAMEL_DISCO_FOLDER_CLASS (camel_imap_folder_class);
+
+	disco_folder_class = CAMEL_DISCO_FOLDER_CLASS (camel_type_get_global_classfuncs (camel_disco_folder_get_type ()));
 
-	parent_class = CAMEL_FOLDER_CLASS(camel_type_get_global_classfuncs (camel_folder_get_type ()));
-	
-	/* virtual method definition */
-	
 	/* virtual method overload */
-	camel_folder_class->refresh_info = imap_refresh_info;
-	camel_folder_class->sync = imap_sync;
-	camel_folder_class->expunge = imap_expunge;
 	camel_folder_class->get_full_name = imap_get_full_name;
-	
 	camel_folder_class->get_message = imap_get_message;
-	camel_folder_class->append_message = imap_append_message;
-	camel_folder_class->copy_messages_to = imap_copy_messages_to;
 	camel_folder_class->move_messages_to = imap_move_messages_to;
-	
 	camel_folder_class->search_by_expression = imap_search_by_expression;
 	camel_folder_class->search_free = imap_search_free;
+
+	camel_disco_folder_class->refresh_info_online = imap_refresh_info;
+	camel_disco_folder_class->sync_online = imap_sync_online;
+	camel_disco_folder_class->sync_offline = imap_sync_offline;
+	camel_disco_folder_class->expunge_uids_online = imap_expunge_uids_online;
+	camel_disco_folder_class->expunge_uids_offline = imap_expunge_uids_offline;
+	camel_disco_folder_class->append_online = imap_append_online;
+	camel_disco_folder_class->append_offline = imap_append_offline;
+	camel_disco_folder_class->copy_online = imap_copy_online;
+	camel_disco_folder_class->copy_offline = imap_copy_offline;
 }
 
 static void
@@ -136,7 +143,7 @@ camel_imap_folder_get_type (void)
 	
 	if (camel_imap_folder_type == CAMEL_INVALID_TYPE) {
 		camel_imap_folder_type =
-			camel_type_register (CAMEL_FOLDER_TYPE, "CamelImapFolder",
+			camel_type_register (CAMEL_DISCO_FOLDER_TYPE, "CamelImapFolder",
 					     sizeof (CamelImapFolder),
 					     sizeof (CamelImapFolderClass),
 					     (CamelObjectClassInitFunc) camel_imap_folder_class_init,
@@ -150,15 +157,27 @@ camel_imap_folder_get_type (void)
 
 CamelFolder *
 camel_imap_folder_new (CamelStore *parent, const char *folder_name,
-		       const char *short_name, const char *folder_dir,
-		       CamelException *ex)
+		       const char *folder_dir, CamelException *ex)
 {
 	CamelImapStore *imap_store = CAMEL_IMAP_STORE (parent);
-	CamelFolder *folder = CAMEL_FOLDER (camel_object_new (camel_imap_folder_get_type ()));
-	CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder);
-	CamelImapResponse *response;
+	CamelFolder *folder;
+	CamelImapFolder *imap_folder;
+	const char *short_name;
 	char *summary_file;
 
+	if (camel_mkdir_hier (folder_dir, S_IRWXU) != 0) {
+		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
+				      _("Could not create directory %s: %s"),
+				      folder_dir, g_strerror (errno));
+		return NULL;
+	}
+
+	folder = CAMEL_FOLDER (camel_object_new (camel_imap_folder_get_type ()));
+	short_name = strrchr (folder_name, imap_store->dir_sep);
+	if (short_name)
+		short_name++;
+	else
+		short_name = folder_name;
 	camel_folder_construct (folder, parent, folder_name, short_name);
 
 	summary_file = g_strdup_printf ("%s/summary", folder_dir);
@@ -172,22 +191,13 @@ camel_imap_folder_new (CamelStore *parent, const char *folder_name,
 		return NULL;
 	}
 
+	imap_folder = CAMEL_IMAP_FOLDER (folder);
 	imap_folder->cache = camel_imap_message_cache_new (folder_dir, folder->summary, ex);
 	if (!imap_folder->cache) {
 		camel_object_unref (CAMEL_OBJECT (folder));
 		return NULL;
 	}
 
-	if (camel_imap_store_check_online (imap_store, NULL)) {
-		response = camel_imap_command (imap_store, folder, ex, NULL);
-		if (response)
-			camel_imap_response_free (imap_store, response);
-		else {
-			camel_object_unref (CAMEL_OBJECT (folder));
-			return NULL;
-		}
-	}
-
 	return folder;
 }
 
@@ -321,7 +331,7 @@ imap_finalize (CamelObject *object)
 static void
 imap_refresh_info (CamelFolder *folder, CamelException *ex)
 {
-	if (!camel_imap_store_check_online (CAMEL_IMAP_STORE (folder->parent_store), NULL))
+	if (camel_disco_store_status (CAMEL_DISCO_STORE (folder->parent_store)) == CAMEL_DISCO_STORE_OFFLINE)
 		return;
 
 	CAMEL_IMAP_STORE_LOCK (folder->parent_store, command_lock);
@@ -499,7 +509,13 @@ get_matching (CamelFolder *folder, guint32 flags, guint32 mask, char **set)
 }
 
 static void
-imap_sync (CamelFolder *folder, gboolean expunge, CamelException *ex)
+imap_sync_offline (CamelFolder *folder, CamelException *ex)
+{
+	camel_folder_summary_save (folder->summary);
+}
+
+static void
+imap_sync_online (CamelFolder *folder, CamelException *ex)
 {
 	CamelImapStore *store = CAMEL_IMAP_STORE (folder->parent_store);
 	CamelImapResponse *response = NULL;
@@ -508,43 +524,13 @@ imap_sync (CamelFolder *folder, gboolean expunge, CamelException *ex)
 	char *set, *flaglist;
 	int i, j, max;
 
-	if (!camel_imap_store_check_online (store, NULL))
-		return;
-
-	max = camel_folder_summary_count (folder->summary);
-
 	CAMEL_IMAP_STORE_LOCK (store, command_lock);
 
-	/* If we're expunging then we don't need to be precise about the
-	 * flags of deleted messages. Just add \Deleted to anything that
-	 * should have it.
-	 */
-	if (expunge && (matches = get_matching (folder, CAMEL_MESSAGE_DELETED,
-						CAMEL_MESSAGE_DELETED, &set))) {
-		for (i = 0; i < matches->len; i++) {
-			info = matches->pdata[i];
-			info->flags &= ~CAMEL_MESSAGE_FOLDER_FLAGGED;
-			camel_folder_summary_info_free (folder->summary, info);
-		}
-		g_ptr_array_free (matches, TRUE);
-		camel_folder_summary_touch (folder->summary);
-
-		response = camel_imap_command (store, folder, ex,
-					       "UID STORE %s +FLAGS.SILENT \\Deleted",
-					       set);
-		g_free (set);
-		if (response)
-			camel_imap_response_free (store, response);
-		if (camel_exception_is_set (ex)) {
-			CAMEL_IMAP_STORE_UNLOCK (store, command_lock);
-			return;
-		}
-	}
-
-	/* OK, now, find a message with changed flags, find all of the
-	 * other messages like it, sync them as a group, mark them as
+	/* Find a message with changed flags, find all of the other
+	 * messages like it, sync them as a group, mark them as
 	 * updated, and continue.
 	 */
+	max = camel_folder_summary_count (folder->summary);
 	for (i = 0; i < max; i++) {
 		info = camel_folder_summary_index (folder->summary, i);
 		if (!info)
@@ -587,32 +573,55 @@ imap_sync (CamelFolder *folder, gboolean expunge, CamelException *ex)
 		}
 	}
 
-	if (expunge) {
-		response = camel_imap_command (store, folder, ex, "EXPUNGE");
-		camel_imap_response_free (store, response);
-	}
-
 	if (!response) {
-		/* We didn't sync or expunge anything... Do a noop so
-		 * the server gets a chance to tell us any news it has.
+		/* We didn't sync anything... Do a noop so the server
+		 * gets a chance to tell us any news it has.
 		 */
 		response = camel_imap_command (store, folder, ex, "NOOP");
 		camel_imap_response_free (store, response);
 	}		
 
-	camel_folder_summary_save (folder->summary);
+	/* Save the summary */
+	imap_sync_offline (folder, ex);
+
 	CAMEL_IMAP_STORE_UNLOCK (store, command_lock);
+}
 
-	camel_operation_end(NULL);
+static void
+imap_expunge_uids_offline (CamelFolder *folder, GPtrArray *uids, CamelException *ex)
+{
+	/* Fail */
+	camel_disco_store_check_online (CAMEL_DISCO_STORE (folder->parent_store), ex);
 }
 
 static void
-imap_expunge (CamelFolder *folder, CamelException *ex)
+imap_expunge_uids_online (CamelFolder *folder, GPtrArray *uids, CamelException *ex)
 {
-	if (!camel_imap_store_check_online (CAMEL_IMAP_STORE (folder->parent_store), ex))
+	CamelImapStore *store = CAMEL_IMAP_STORE (folder->parent_store);
+	CamelImapResponse *response;
+	char *set;
+
+	set = imap_uid_array_to_set (folder->summary, uids);
+	CAMEL_IMAP_STORE_LOCK (store, command_lock);
+	response = camel_imap_command (store, folder, ex,
+				       "UID STORE %s +FLAGS.SILENT \\Deleted",
+				       set);
+	if (response)
+		camel_imap_response_free (store, response);
+	if (camel_exception_is_set (ex)) {
+		CAMEL_IMAP_STORE_UNLOCK (store, command_lock);
+		g_free (set);
 		return;
+	}
 
-	imap_sync (folder, TRUE, ex);
+	if (store->capabilities & IMAP_CAPABILITY_UIDPLUS) {
+		response = camel_imap_command (store, folder, ex,
+					       "UID EXPUNGE %s", set);
+	} else
+		response = camel_imap_command (store, folder, ex, "EXPUNGE");
+	if (response)
+		camel_imap_response_free (store, response);
+	CAMEL_IMAP_STORE_UNLOCK (store, command_lock);
 }
 
 static const char *
@@ -634,20 +643,26 @@ imap_get_full_name (CamelFolder *folder)
 	return name;
 }	
 
-static void
-imap_append_message (CamelFolder *folder, CamelMimeMessage *message,
+static char *
+imap_append_offline (CamelFolder *folder, CamelMimeMessage *message,
 		     const CamelMessageInfo *info, CamelException *ex)
 {
+	/* Fail */
+	camel_disco_store_check_online (CAMEL_DISCO_STORE (folder->parent_store), ex);
+	return NULL;
+}
+
+static char *
+imap_append_online (CamelFolder *folder, CamelMimeMessage *message,
+		    const CamelMessageInfo *info, CamelException *ex)
+{
 	CamelImapStore *store = CAMEL_IMAP_STORE (folder->parent_store);
 	CamelImapResponse *response;
 	CamelStream *memstream;
 	CamelMimeFilter *crlf_filter;
 	CamelStreamFilter *streamfilter;
 	GByteArray *ba;
-	char *flagstr, *result, *uid;
-
-	if (!camel_imap_store_check_online (store, ex))
-		return;
+	char *flagstr, *result, *uid = NULL;
 
 	/* create flag string param */
 	if (info && info->flags)
@@ -678,12 +693,12 @@ imap_append_message (CamelFolder *folder, CamelMimeMessage *message,
 	
 	if (!response) {
 		g_byte_array_free (ba, TRUE);
-		return;
+		return NULL;
 	}
 	result = camel_imap_response_extract_continuation (store, response, ex);
 	if (!result) {
 		g_byte_array_free (ba, TRUE);
-		return;
+		return NULL;
 	}
 	g_free (result);
 
@@ -692,7 +707,7 @@ imap_append_message (CamelFolder *folder, CamelMimeMessage *message,
 	response = camel_imap_command_continuation (store, ex, ba->data);
 	g_byte_array_free (ba, TRUE);
 	if (!response)
-		return;
+		return NULL;
 
 	if (store->capabilities & IMAP_CAPABILITY_UIDPLUS) {
 		uid = strstrcase (response->status, "[APPENDUID ");
@@ -707,15 +722,26 @@ imap_append_message (CamelFolder *folder, CamelMimeMessage *message,
 				camel_imap_message_cache_insert_wrapper (
 					CAMEL_IMAP_FOLDER (folder)->cache,
 					uid, "", CAMEL_DATA_WRAPPER (message));
+			} else {
+				g_free (uid);
+				uid = NULL;
 			}
-			g_free (uid);
 		}
 	}
 
 	camel_imap_response_free (store, response);
+	return uid;
 }
 
 static void
+imap_copy_offline (CamelFolder *source, GPtrArray *uids,
+		   CamelFolder *destination, CamelException *ex)
+{
+	/* Fail */
+	camel_disco_store_check_online (CAMEL_DISCO_STORE (source->parent_store), ex);
+}
+	
+static void
 handle_copyuid (CamelImapResponse *response, CamelFolder *source,
 		CamelFolder *destination)
 {
@@ -769,18 +795,15 @@ handle_copyuid (CamelImapResponse *response, CamelFolder *source,
 }
 
 static void
-imap_copy_messages_to (CamelFolder *source, GPtrArray *uids,
-		       CamelFolder *destination, CamelException *ex)
+imap_copy_online (CamelFolder *source, GPtrArray *uids,
+		  CamelFolder *destination, CamelException *ex)
 {
 	CamelImapStore *store = CAMEL_IMAP_STORE (source->parent_store);
 	CamelImapResponse *response;
 	char *set;
 	
-	if (!camel_imap_store_check_online (store, ex))
-		return;
-	
 	/* Sync message flags if needed. */
-	imap_sync (source, FALSE, ex);
+	imap_sync_online (source, ex);
 	if (camel_exception_is_set (ex))
 		return;
 	
@@ -807,11 +830,11 @@ imap_move_messages_to (CamelFolder *source, GPtrArray *uids,
 		       CamelFolder *destination, CamelException *ex)
 {
 	int i;
-	
-	imap_copy_messages_to (source, uids, destination, ex);
+
+	CF_CLASS (disco_folder_class)->copy_messages_to (source, uids, destination, ex);
 	if (camel_exception_is_set (ex))
 		return;
-	
+
 	for (i = 0; i < uids->len; i++)
 		camel_folder_delete_message (source, uids->pdata[i]);
 }
@@ -822,7 +845,7 @@ imap_search_by_expression (CamelFolder *folder, const char *expression, CamelExc
 	CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder);
 	GPtrArray *matches, *summary;
 
-	if (!camel_imap_store_check_online (CAMEL_IMAP_STORE (folder->parent_store), ex))
+	if (!camel_disco_store_check_online (CAMEL_DISCO_STORE (folder->parent_store), ex))
 		return NULL;
 
 	/* we could get around this by creating a new search object each time,
@@ -1015,7 +1038,7 @@ imap_get_message (CamelFolder *folder, const char *uid, CamelException *ex)
 		char *body, *found_uid;
 		int i;
 
-		if (!camel_imap_store_check_online (store, NULL)) {
+		if (camel_disco_store_status (CAMEL_DISCO_STORE (store)) == CAMEL_DISCO_STORE_OFFLINE) {
 			camel_exception_set (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
 					     _("This message is not currently available"));
 			return NULL;
@@ -1212,6 +1235,8 @@ camel_imap_folder_changed (CamelFolder *folder, int exists,
 					    "folder_changed", changes);
 	}
 	camel_folder_change_info_free (changes);
+
+	camel_folder_summary_save (folder->summary);
 }
 
 
@@ -1235,9 +1260,10 @@ camel_imap_folder_fetch_data (CamelImapFolder *imap_folder, const char *uid,
 		return stream;
 	}
 
-	if (!camel_imap_store_check_online (store, NULL)) {
+	if (camel_disco_store_status (CAMEL_DISCO_STORE (store)) == CAMEL_DISCO_STORE_OFFLINE) {
 		camel_exception_set (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
 				     _("This message is not currently available"));
+		CAMEL_IMAP_FOLDER_UNLOCK (imap_folder, cache_lock);
 		return NULL;
 	}
 
diff --git a/camel/providers/imap/camel-imap-folder.h b/camel/providers/imap/camel-imap-folder.h
index 6d969bf752..96b33c0400 100644
--- a/camel/providers/imap/camel-imap-folder.h
+++ b/camel/providers/imap/camel-imap-folder.h
@@ -1,11 +1,12 @@
 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
-/* camel-imap-folder.h : Abstract class for an imap folder */
+/* camel-imap-folder.h: class for an imap folder */
 
 /* 
- * Author: 
- *   Jeffrey Stedfast <fejj@helixcode.com> 
+ * Authors:
+ *   Dan Winship <danw@ximian.com>
+ *   Jeffrey Stedfast <fejj@ximian.com> 
  *
- * Copyright (C) 2000 Helix Code, Inc. (www.helixcode.com)
+ * Copyright (C) 2000, 2001 Ximian, Inc.
  *
  * This program is free software; you can redistribute it and/or 
  * modify it under the terms of the GNU General Public License as 
@@ -34,7 +35,7 @@ extern "C" {
 #endif /* __cplusplus }*/
 
 #include "camel-imap-types.h"
-#include "camel-folder.h"
+#include "camel-disco-folder.h"
 #include <camel/camel-folder-search.h>
 
 #define CAMEL_IMAP_FOLDER_TYPE     (camel_imap_folder_get_type ())
@@ -43,7 +44,7 @@ extern "C" {
 #define CAMEL_IS_IMAP_FOLDER(o)    (CAMEL_CHECK_TYPE((o), CAMEL_IMAP_FOLDER_TYPE))
 
 struct _CamelImapFolder {
-	CamelFolder parent_object;
+	CamelDiscoFolder parent_object;
 
 	struct _CamelImapFolderPrivate *priv;
 
@@ -53,7 +54,7 @@ struct _CamelImapFolder {
 
 
 typedef struct {
-	CamelFolderClass parent_class;
+	CamelDiscoFolderClass parent_class;
 
 	/* Virtual methods */	
 	
@@ -63,7 +64,6 @@ typedef struct {
 /* public methods */
 CamelFolder *camel_imap_folder_new (CamelStore *parent,
 				    const char *folder_name,
-				    const char *short_name,
 				    const char *folder_dir,
 				    CamelException *ex);
 
diff --git a/camel/providers/imap/camel-imap-store.c b/camel/providers/imap/camel-imap-store.c
index 42c2f12cde..0a5c4425ac 100644
--- a/camel/providers/imap/camel-imap-store.c
+++ b/camel/providers/imap/camel-imap-store.c
@@ -57,23 +57,30 @@
 /* Specified in RFC 2060 */
 #define IMAP_PORT 143
 
-static CamelRemoteStoreClass *remote_store_class = NULL;
+static CamelDiscoStoreClass *disco_store_class = NULL;
 static char imap_tag_prefix = 'A';
 
 static void construct (CamelService *service, CamelSession *session,
 		       CamelProvider *provider, CamelURL *url,
 		       CamelException *ex);
-static gboolean imap_connect (CamelService *service, CamelException *ex);
-static gboolean imap_disconnect (CamelService *service, gboolean clean, CamelException *ex);
+static gboolean imap_connect_online (CamelService *service, CamelException *ex);
+static gboolean imap_connect_offline (CamelService *service, CamelException *ex);
+static gboolean imap_disconnect_online (CamelService *service, gboolean clean, CamelException *ex);
+static gboolean imap_disconnect_offline (CamelService *service, gboolean clean, CamelException *ex);
 static GList *query_auth_types (CamelService *service, CamelException *ex);
 static guint hash_folder_name (gconstpointer key);
 static gint compare_folder_name (gconstpointer a, gconstpointer b);
-static CamelFolder *get_folder (CamelStore *store, const char *folder_name, guint32 flags, CamelException *ex);
+static CamelFolder *get_folder_online (CamelStore *store, const char *folder_name, guint32 flags, CamelException *ex);
+static CamelFolder *get_folder_offline (CamelStore *store, const char *folder_name, guint32 flags, CamelException *ex);
 static CamelFolderInfo *create_folder (CamelStore *store, const char *parent_name, const char *folder_name, CamelException *ex);
-static CamelFolderInfo *get_folder_info (CamelStore *store, const char *top,
-					 gboolean fast, gboolean recursive,
-					 gboolean subscribed_only,
-					 CamelException *ex);
+static CamelFolderInfo *get_folder_info_online (CamelStore *store,
+						const char *top,
+						guint32 flags,
+						CamelException *ex);
+static CamelFolderInfo *get_folder_info_offline (CamelStore *store,
+						 const char *top,
+						 guint32 flags,
+						 CamelException *ex);
 static gboolean folder_subscribed (CamelStore *store, const char *folder_name);
 static void subscribe_folder (CamelStore *store, const char *folder_name,
 			      CamelException *ex);
@@ -81,44 +88,43 @@ static void unsubscribe_folder (CamelStore *store, const char *folder_name,
 				CamelException *ex);
 static void imap_keepalive (CamelRemoteStore *store);
 
-static gboolean imap_store_setup_online  (CamelImapStore *store,
-					  CamelException *ex);
-static gboolean imap_store_setup_offline (CamelImapStore *store,
-					  CamelException *ex);
-
 
 static void
 camel_imap_store_class_init (CamelImapStoreClass *camel_imap_store_class)
 {
-	/* virtual method overload */
 	CamelServiceClass *camel_service_class =
 		CAMEL_SERVICE_CLASS (camel_imap_store_class);
 	CamelStoreClass *camel_store_class =
 		CAMEL_STORE_CLASS (camel_imap_store_class);
 	CamelRemoteStoreClass *camel_remote_store_class =
 		CAMEL_REMOTE_STORE_CLASS (camel_imap_store_class);
-	
-	remote_store_class = CAMEL_REMOTE_STORE_CLASS(camel_type_get_global_classfuncs 
-						      (camel_remote_store_get_type ()));
-	
+	CamelDiscoStoreClass *camel_disco_store_class =
+		CAMEL_DISCO_STORE_CLASS (camel_imap_store_class);
+
+	disco_store_class = CAMEL_DISCO_STORE_CLASS (camel_type_get_global_classfuncs (camel_disco_store_get_type ()));
+
 	/* virtual method overload */
 	camel_service_class->construct = construct;
 	camel_service_class->query_auth_types = query_auth_types;
-	camel_service_class->connect = imap_connect;
-	camel_service_class->disconnect = imap_disconnect;
-	
+
 	camel_store_class->hash_folder_name = hash_folder_name;
 	camel_store_class->compare_folder_name = compare_folder_name;
-	camel_store_class->get_folder = get_folder;
 	camel_store_class->create_folder = create_folder;
-	camel_store_class->get_folder_info = get_folder_info;
 	camel_store_class->free_folder_info = camel_store_free_folder_info_full;
-
 	camel_store_class->folder_subscribed = folder_subscribed;
 	camel_store_class->subscribe_folder = subscribe_folder;
 	camel_store_class->unsubscribe_folder = unsubscribe_folder;
 
 	camel_remote_store_class->keepalive = imap_keepalive;
+
+	camel_disco_store_class->connect_online = imap_connect_online;
+	camel_disco_store_class->connect_offline = imap_connect_offline;
+	camel_disco_store_class->disconnect_online = imap_disconnect_online;
+	camel_disco_store_class->disconnect_offline = imap_disconnect_offline;
+	camel_disco_store_class->get_folder_online = get_folder_online;
+	camel_disco_store_class->get_folder_offline = get_folder_offline;
+	camel_disco_store_class->get_folder_info_online = get_folder_info_online;
+	camel_disco_store_class->get_folder_info_offline = get_folder_info_offline;
 }
 
 static gboolean
@@ -133,24 +139,14 @@ camel_imap_store_finalize (CamelObject *object)
 {
 	CamelImapStore *imap_store = CAMEL_IMAP_STORE (object);
 
-	if (imap_store->subscribed_folders) {
-		g_hash_table_foreach_remove (imap_store->subscribed_folders,
-					     free_key, NULL);
-		g_hash_table_destroy (imap_store->subscribed_folders);
-	}
-	if (imap_store->authtypes) {
-		g_hash_table_foreach_remove (imap_store->authtypes,
-					     free_key, NULL);
-		g_hash_table_destroy (imap_store->authtypes);
-	}
-	if (imap_store->namespace)
-		g_free (imap_store->namespace);
+	/* This frees current_folder, folders, authtypes, and namespace. */
+	imap_disconnect_offline (CAMEL_SERVICE (object), FALSE, NULL);
+
 	if (imap_store->base_url)
 		g_free (imap_store->base_url);
 	if (imap_store->storage_path)
 		g_free (imap_store->storage_path);
-	if (imap_store->current_folder)
-		camel_object_unref (CAMEL_OBJECT (imap_store->current_folder));
+
 #ifdef ENABLE_THREADS
 	e_mutex_destroy(imap_store->priv->command_lock);
 #endif
@@ -188,7 +184,7 @@ camel_imap_store_get_type (void)
 	
 	if (camel_imap_store_type == CAMEL_INVALID_TYPE)	{
 		camel_imap_store_type =
-			camel_type_register (CAMEL_REMOTE_STORE_TYPE, "CamelImapStore",
+			camel_type_register (CAMEL_DISCO_STORE_TYPE, "CamelImapStore",
 					     sizeof (CamelImapStore),
 					     sizeof (CamelImapStoreClass),
 					     (CamelObjectClassInitFunc) camel_imap_store_class_init,
@@ -208,7 +204,7 @@ construct (CamelService *service, CamelSession *session,
 	CamelImapStore *imap_store = CAMEL_IMAP_STORE (service);
 	CamelStore *store = CAMEL_STORE (service);
 
-	CAMEL_SERVICE_CLASS (remote_store_class)->construct (service, session, provider, url, ex);
+	CAMEL_SERVICE_CLASS (disco_store_class)->construct (service, session, provider, url, ex);
 	if (camel_exception_is_set (ex))
 		return;
 
@@ -216,6 +212,7 @@ construct (CamelService *service, CamelSession *session,
 	if (camel_exception_is_set (ex)) 
 		return;
 
+	/* FIXME */
 	imap_store->base_url = camel_url_to_string (service->url, (CAMEL_URL_HIDE_PASSWORD |
 								   CAMEL_URL_HIDE_PARAMS |
 								   CAMEL_URL_HIDE_AUTH));
@@ -233,6 +230,18 @@ construct (CamelService *service, CamelSession *session,
 		imap_store->parameters |= IMAP_PARAM_FILTER_INBOX;
 }
 
+static void
+imap_set_server_level (CamelImapStore *store)
+{
+	if (store->capabilities & IMAP_CAPABILITY_IMAP4REV1) {
+		store->server_level = IMAP_LEVEL_IMAP4REV1;
+		store->capabilities |= IMAP_CAPABILITY_STATUS;
+	} else if (store->capabilities & IMAP_CAPABILITY_IMAP4)
+		store->server_level = IMAP_LEVEL_IMAP4;
+	else
+		store->server_level = IMAP_LEVEL_UNKNOWN;
+}
+
 static struct {
 	const char *name;
 	guint32 flag;
@@ -257,9 +266,6 @@ connect_to_server (CamelService *service, CamelException *ex)
 
 	CAMEL_IMAP_STORE_ASSERT_LOCKED (store, command_lock);
 
-	if (!CAMEL_SERVICE_CLASS (remote_store_class)->connect (service, ex))
-		return FALSE;
-
 	store->command = 0;
 
 	/* Read the greeting, if any. FIXME: deal with PREAUTH */
@@ -299,13 +305,7 @@ connect_to_server (CamelService *service, CamelException *ex)
 	}
 	g_free (result);
 
-	if (store->capabilities & IMAP_CAPABILITY_IMAP4REV1) {
-		store->server_level = IMAP_LEVEL_IMAP4REV1;
-		store->capabilities |= IMAP_CAPABILITY_STATUS;
-	} else if (store->capabilities & IMAP_CAPABILITY_IMAP4)
-		store->server_level = IMAP_LEVEL_IMAP4;
-	else
-		store->server_level = IMAP_LEVEL_UNKNOWN;
+	imap_set_server_level (store);
 
 	return TRUE;
 }
@@ -326,7 +326,7 @@ query_auth_types (CamelService *service, CamelException *ex)
 	if (!connected)
 		return NULL;
 
-	types = CAMEL_SERVICE_CLASS (remote_store_class)->query_auth_types (service, ex);
+	types = CAMEL_SERVICE_CLASS (disco_store_class)->query_auth_types (service, ex);
 	if (camel_exception_is_set (ex))
 		return types;
 
@@ -536,39 +536,25 @@ imap_auth_loop (CamelService *service, CamelException *ex)
 	return TRUE;
 }
 
-static gboolean
-imap_connect (CamelService *service, CamelException *ex)
-{
-	CamelImapStore *store = CAMEL_IMAP_STORE (service);
-
-	if (camel_imap_store_check_online (store, NULL)) {
-		CAMEL_IMAP_STORE_LOCK (store, command_lock);
-		if (!connect_to_server (service, ex) ||
-		    !imap_auth_loop (service, ex) ||
-		    !imap_store_setup_online (store, ex)) {
-			CAMEL_IMAP_STORE_UNLOCK (store, command_lock);
-			camel_service_disconnect (service, TRUE, NULL);
-			return FALSE;
-		}
-		CAMEL_IMAP_STORE_UNLOCK (store, command_lock);
-	} else
-		imap_store_setup_offline (store, ex);
-
-	imap_store_refresh_folders (CAMEL_REMOTE_STORE (store), ex);
-	return !camel_exception_is_set (ex);
-}
-
 #define IMAP_STOREINFO_VERSION 1
 
 static gboolean
-imap_store_setup_online (CamelImapStore *store, CamelException *ex)
+imap_connect_online (CamelService *service, CamelException *ex)
 {
+	CamelImapStore *store = CAMEL_IMAP_STORE (service);
 	CamelImapResponse *response;
 	int i, flags, len;
 	char *result, *name, *path;
 	FILE *storeinfo;
 
-	CAMEL_IMAP_STORE_ASSERT_LOCKED (store, command_lock);
+
+	CAMEL_IMAP_STORE_LOCK (store, command_lock);
+	if (!connect_to_server (service, ex) ||
+	    !imap_auth_loop (service, ex)) {
+		CAMEL_IMAP_STORE_UNLOCK (store, command_lock);
+		camel_service_disconnect (service, TRUE, NULL);
+		return FALSE;
+	}
 
 	path = g_strdup_printf ("%s/storeinfo", store->storage_path);
 	storeinfo = fopen (path, "w");
@@ -585,16 +571,16 @@ imap_store_setup_online (CamelImapStore *store, CamelException *ex)
 	    !(store->parameters & IMAP_PARAM_OVERRIDE_NAMESPACE)) {
 		response = camel_imap_command (store, NULL, ex, "NAMESPACE");
 		if (!response)
-			return FALSE;
+			goto done;
 
 		result = camel_imap_response_extract (store, response, "NAMESPACE", ex);
 		if (!result)
-			return FALSE;
-		
+			goto done;
+
 		name = strstrcase (result, "NAMESPACE ((");
 		if (name) {
 			char *sep;
-			
+
 			name += 12;
 			store->namespace = imap_parse_string (&name, &len);
 			if (name && *name++ == ' ') {
@@ -627,9 +613,8 @@ imap_store_setup_online (CamelImapStore *store, CamelException *ex)
 						       "LIST \"\" %S",
 						       store->namespace);
 		}
-
 		if (!response)
-			return FALSE;
+			goto done;
 
 		result = camel_imap_response_extract (store, response, "LIST", NULL);
 		if (result) {
@@ -648,7 +633,7 @@ imap_store_setup_online (CamelImapStore *store, CamelException *ex)
 		/* Get subscribed folders */
 		response = camel_imap_command (store, NULL, ex, "LSUB \"\" \"*\"");
 		if (!response)
-			return FALSE;
+			goto done;
 		store->subscribed_folders = g_hash_table_new (g_str_hash, g_str_equal);
 		for (i = 0; i < response->untagged->len; i++) {
 			result = response->untagged->pdata[i];
@@ -667,13 +652,21 @@ imap_store_setup_online (CamelImapStore *store, CamelException *ex)
 		camel_imap_response_free (store, response);
 	}
 
+ done:
 	fclose (storeinfo);
-	return TRUE;
+	CAMEL_IMAP_STORE_UNLOCK (store, command_lock);
+
+	if (camel_exception_is_set (ex))
+		camel_service_disconnect (service, TRUE, NULL);
+	else
+		imap_store_refresh_folders (CAMEL_REMOTE_STORE (store), ex);
+	return !camel_exception_is_set (ex);
 }
 
 static gboolean
-imap_store_setup_offline (CamelImapStore *store, CamelException *ex)
+imap_connect_offline (CamelService *service, CamelException *ex)
 {
+	CamelImapStore *store = CAMEL_IMAP_STORE (service);
 	char *buf, *name, *path;
 	FILE *storeinfo;
 	guint32 tmp;
@@ -685,11 +678,17 @@ imap_store_setup_offline (CamelImapStore *store, CamelException *ex)
 	if (storeinfo)
 		camel_file_util_decode_uint32 (storeinfo, &tmp);
 	if (tmp != IMAP_STOREINFO_VERSION) {
-		/* This must set ex and return FALSE if we're here... */
-		return camel_imap_store_check_online (store, ex);
+		if (storeinfo)
+			fclose (storeinfo);
+
+		/* We know we're offline, so this will have to set ex
+		 * and return FALSE.
+		 */
+		return camel_disco_store_check_online (CAMEL_DISCO_STORE (store), ex);
 	}
 
 	camel_file_util_decode_uint32 (storeinfo, &store->capabilities);
+	imap_set_server_level (store);
 	camel_file_util_decode_string (storeinfo, &store->namespace);
 	camel_file_util_decode_uint32 (storeinfo, &tmp);
 	store->dir_sep = tmp;
@@ -707,21 +706,17 @@ imap_store_setup_offline (CamelImapStore *store, CamelException *ex)
 	}
 
 	fclose (storeinfo);
-	return TRUE;
-}
-
+	imap_store_refresh_folders (CAMEL_REMOTE_STORE (store), ex);
 
+	store->connected = !camel_exception_is_set (ex);
+	return store->connected;
+}
 
 static gboolean
-imap_disconnect (CamelService *service, gboolean clean, CamelException *ex)
+imap_disconnect_offline (CamelService *service, gboolean clean, CamelException *ex)
 {
 	CamelImapStore *store = CAMEL_IMAP_STORE (service);
-	CamelImapResponse *response;
-	
-	if (store->connected && clean) {
-		response = camel_imap_command (store, NULL, ex, "LOGOUT");
-		camel_imap_response_free (store, response);
-	}
+
 	store->connected = FALSE;
 	if (store->current_folder) {
 		camel_object_unref (CAMEL_OBJECT (store->current_folder));
@@ -747,63 +742,24 @@ imap_disconnect (CamelService *service, gboolean clean, CamelException *ex)
 		store->namespace = NULL;
 	}
 
-	return CAMEL_SERVICE_CLASS (remote_store_class)->disconnect (service, clean, ex);
+	return TRUE;
 }
 
 static gboolean
-imap_folder_exists (CamelImapStore *store, const char *folder_name,
-		    gboolean *selectable, char **short_name,
-		    CamelException *ex)
+imap_disconnect_online (CamelService *service, gboolean clean, CamelException *ex)
 {
+	CamelImapStore *store = CAMEL_IMAP_STORE (service);
 	CamelImapResponse *response;
-	char *result, sep;
-	int flags;
-
-	if (!g_strcasecmp (folder_name, "INBOX")) {
-		if (selectable)
-			*selectable = TRUE;
-		if (short_name)
-			*short_name = g_strdup ("INBOX");
-		return TRUE;
-	}
-
-	response = camel_imap_command (store, NULL, ex, "LIST \"\" %S",
-				       folder_name);
-	if (!response)
-		return FALSE;
-	result = camel_imap_response_extract (store, response, "LIST", ex);
-	if (!result)
-		return FALSE;
-
-	if (!imap_parse_list_response (result, &flags, &sep, NULL))
-		return FALSE;
-
-	if (selectable)
-		*selectable = !(flags & IMAP_LIST_FLAG_NOSELECT);
-	if (short_name) {
-		*short_name = strrchr (folder_name, sep);
-		if (*short_name)
-			*short_name = g_strdup (*short_name + 1);
-		else
-			*short_name = g_strdup (folder_name);
+	
+	imap_disconnect_offline (service, clean, ex);
+	if (store->connected && clean) {
+		response = camel_imap_command (store, NULL, ex, "LOGOUT");
+		camel_imap_response_free (store, response);
 	}
 
 	return TRUE;
 }
 
-static gboolean
-imap_create (CamelImapStore *store, const char *folder_name,
-	     CamelException *ex)
-{
-	CamelImapResponse *response;
-
-	response = camel_imap_command (store, NULL, ex, "CREATE %S",
-				       folder_name);
-	camel_imap_response_free (store, response);
-
-	return !camel_exception_is_set (ex);
-}
-
 static guint
 hash_folder_name (gconstpointer key)
 {
@@ -826,68 +782,85 @@ compare_folder_name (gconstpointer a, gconstpointer b)
 }
 
 static CamelFolder *
-get_folder (CamelStore *store, const char *folder_name, guint32 flags,
-	    CamelException *ex)
+no_such_folder (const char *name, CamelException *ex)
+{
+	camel_exception_setv (ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
+			      _("No such folder %s"), name);
+	return NULL;
+}
+
+static CamelFolder *
+get_folder_online (CamelStore *store, const char *folder_name,
+		   guint32 flags, CamelException *ex)
 {
 	CamelImapStore *imap_store = CAMEL_IMAP_STORE (store);
-	CamelFolder *new_folder = NULL;
-	char *short_name, *folder_dir;
-	gboolean selectable;
+	CamelImapResponse *response;
+	CamelFolder *new_folder;
+	char *folder_dir;
 
-	if (camel_imap_store_check_online (imap_store, NULL)) {
-		if (!camel_remote_store_connected (CAMEL_REMOTE_STORE (store), ex))
-			return NULL;
+	if (!camel_remote_store_connected (CAMEL_REMOTE_STORE (store), ex))
+		return NULL;
 
-		/* lock around the whole lot to check/create atomically */
-		CAMEL_IMAP_STORE_LOCK(imap_store, command_lock);
-		if (!imap_folder_exists (imap_store, folder_name,
-					 &selectable, &short_name, ex) &&
-		    ((flags & CAMEL_STORE_FOLDER_CREATE) == 0
-		     || (!imap_create (imap_store, folder_name, ex))
-		     || (!imap_folder_exists (imap_store, folder_name,
-					      &selectable, &short_name, ex)))) {
-			CAMEL_IMAP_STORE_UNLOCK(imap_store, command_lock);
+	/* Lock around the whole lot to check/create atomically */
+	CAMEL_IMAP_STORE_LOCK (imap_store, command_lock);
+	imap_store->current_folder = NULL;
+	response = camel_imap_command (imap_store, NULL, NULL,
+				       "SELECT %S", folder_name);
+	if (!response) {
+		if (!flags & CAMEL_STORE_FOLDER_CREATE)
+			return no_such_folder (folder_name, ex);
+
+		response = camel_imap_command (imap_store, NULL, ex,
+					       "CREATE %S", folder_name);
+		if (response) {
+			camel_imap_response_free (imap_store, response);
+
+			response = camel_imap_command (imap_store, NULL, NULL,
+						       "SELECT %S", folder_name);
+		}
+		if (!response) {
+			CAMEL_IMAP_STORE_UNLOCK (imap_store, command_lock);
 			return NULL;
 		}
-	} else {
-		selectable = g_hash_table_lookup (imap_store->subscribed_folders, folder_name) != NULL;
-		short_name = strrchr (folder_name, imap_store->dir_sep);
-		if (short_name)
-			short_name = g_strdup (short_name + 1);
-		else
-			short_name = g_strdup (folder_name);
-
-		/* Need to lock here for parallelism with the online case */
-		CAMEL_IMAP_STORE_LOCK(imap_store, command_lock);
 	}
 
-	if (!selectable) {
-		camel_exception_setv (ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
-				      _("%s is not a selectable folder"),
-				      folder_name);
-		g_free (short_name);
-		CAMEL_IMAP_STORE_UNLOCK(imap_store, command_lock);
-		return NULL;
+	folder_dir = e_path_to_physical (imap_store->storage_path, folder_name);
+	new_folder = camel_imap_folder_new (store, folder_name, folder_dir, ex);
+	g_free (folder_dir);
+	if (new_folder) {
+		imap_store->current_folder = new_folder;
+		camel_imap_folder_selected (new_folder, response, ex);
+		if (camel_exception_is_set (ex)) {
+			camel_object_unref (CAMEL_OBJECT (new_folder));
+			new_folder = imap_store->current_folder = NULL;
+		}
 	}
+	camel_imap_response_free_without_processing (imap_store, response);
 
-	folder_dir = e_path_to_physical (imap_store->storage_path,
-					 folder_name);
-	if (camel_mkdir_hier (folder_dir, S_IRWXU) == 0) {
-		new_folder = camel_imap_folder_new (store, folder_name,
-						    short_name, folder_dir,
-						    ex);
-	} else {
-		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
-				      _("Could not create directory %s: %s"),
-				      folder_dir, g_strerror (errno));
-	}
-	CAMEL_IMAP_STORE_UNLOCK(imap_store, command_lock);
-	g_free (folder_dir);
-	g_free (short_name);
+	CAMEL_IMAP_STORE_UNLOCK (imap_store, command_lock);
 
-	if (camel_exception_is_set (ex))
+	return new_folder;
+}
+
+static CamelFolder *
+get_folder_offline (CamelStore *store, const char *folder_name,
+		    guint32 flags, CamelException *ex)
+{
+	CamelImapStore *imap_store = CAMEL_IMAP_STORE (store);
+	CamelFolder *new_folder;
+	char *folder_dir;
+
+	if (!imap_store->connected &&
+	    !camel_service_connect (CAMEL_SERVICE (store), ex))
 		return NULL;
 
+	folder_dir = e_path_to_physical (imap_store->storage_path, folder_name);
+	if (access (folder_dir, F_OK) != 0)
+		return no_such_folder (folder_name, ex);
+
+	new_folder = camel_imap_folder_new (store, folder_name, folder_dir, ex);
+	g_free (folder_dir);
+
 	return new_folder;
 }
 
@@ -908,24 +881,25 @@ create_folder (CamelStore *store, const char *parent_name,
 	       const char *folder_name, CamelException *ex)
 {
 	CamelImapStore *imap_store = CAMEL_IMAP_STORE (store);
+	CamelImapResponse *response;
 	CamelFolderInfo *fi;
 	char *full_name;
 
-	if (!camel_imap_store_check_online (imap_store, ex))
+	if (!camel_disco_store_check_online (CAMEL_DISCO_STORE (store), ex))
 		return NULL;
 	if (!parent_name)
 		parent_name = imap_store->namespace;
 	full_name = imap_concat (imap_store, parent_name, folder_name);
 
-	imap_create (imap_store, full_name, ex);
-	if (camel_exception_is_set (ex)) {
-		g_free (full_name);
-		return NULL;
-	}
+	response = camel_imap_command (imap_store, NULL, ex, "CREATE %S",
+				       full_name);
+	if (response) {
+		camel_imap_response_free (imap_store, response);
+		fi = get_folder_info_online (store, full_name, 0, ex);
+	} else
+		fi = NULL;
 
-	fi = get_folder_info (store, full_name, FALSE, FALSE, FALSE, ex);
 	g_free (full_name);
-	
 	return fi;
 }
 
@@ -1029,9 +1003,6 @@ get_folders_online (CamelImapStore *imap_store, const char *pattern,
 	char *list;
 	int i;
 
-	if (!camel_remote_store_connected (CAMEL_REMOTE_STORE (imap_store), ex))
-		return;
-
 	response = camel_imap_command (imap_store, NULL, ex,
 				       "%s \"\" %S", lsub ? "LSUB" : "LIST",
 				       pattern);
@@ -1047,92 +1018,19 @@ get_folders_online (CamelImapStore *imap_store, const char *pattern,
 	camel_imap_response_free (imap_store, response);
 }
 
-static void
-get_unread_online (CamelImapStore *imap_store, CamelFolderInfo *fi)
-{
-	CamelImapResponse *response;
-	char *status, *p;
-
-	response = camel_imap_command (imap_store, NULL, NULL,
-				       "STATUS %S (UNSEEN)", fi->full_name);
-	if (!response)
-		return;
-	status = camel_imap_response_extract (imap_store, response, "STATUS", NULL);
-	if (!status)
-		return;
-	
-	p = strstrcase (status, "UNSEEN");
-	if (p)
-		fi->unread_message_count = strtoul (p + 6, NULL, 10);
-	g_free (status);
-}
-
-static void
-add_folder (gpointer key, gpointer value, gpointer data)
-{
-	g_ptr_array_add (data, key);
-}
-
-static void
-get_folders_offline (CamelImapStore *imap_store, GPtrArray *folders,
-		     CamelException *ex)
-{
-	CamelFolderInfo *fi;
-	CamelURL *url;
-	int i;
-
-	i = folders->len;
-	g_hash_table_foreach (imap_store->subscribed_folders,
-			      add_folder, folders);
-	
-	url = camel_url_new (imap_store->base_url, NULL);
-	
-	while (i < folders->len) {
-		fi = g_new0 (CamelFolderInfo, 1);
-		fi->full_name = g_strdup (folders->pdata[i]);
-		fi->name = strchr (fi->full_name, imap_store->dir_sep);
-		if (fi->name)
-			fi->name = g_strdup (fi->name + 1);
-		else
-			fi->name = g_strdup (fi->full_name);
-		
-		g_free (url->path);
-		url->path = g_strdup_printf ("/%s", fi->full_name);
-		fi->url = camel_url_to_string (url, 0);
-		
-		fi->unread_message_count = -1;
-		folders->pdata[i++] = fi;
-	}
-	
-	camel_url_free (url);
-}
-
-static void
-get_unread_offline (CamelImapStore *imap_store, CamelFolderInfo *fi)
-{
-	/* FIXME */
-}
-
 static CamelFolderInfo *
-get_folder_info (CamelStore *store, const char *top, gboolean fast,
-		 gboolean recursive, gboolean subscribed_only,
-		 CamelException *ex)
+get_folder_info_online (CamelStore *store, const char *top,
+			guint32 flags, CamelException *ex)
 {
 	CamelImapStore *imap_store = CAMEL_IMAP_STORE (store);
-	gboolean need_inbox = FALSE, online;
+	CamelImapResponse *response;
+	gboolean need_inbox = FALSE;
 	GPtrArray *folders;
 	const char *name;
-	char *pattern;
+	char *pattern, *status, *p;
 	CamelFolderInfo *fi;
 	int i;
 
-	if (!subscribed_only || !recursive || top) {
-		if (!camel_imap_store_check_online (imap_store, ex))
-			return NULL;
-		online = TRUE;
-	} else
-		online = camel_imap_store_check_online (imap_store, NULL);
-
 	if (!camel_remote_store_connected (CAMEL_REMOTE_STORE (store), ex))
 		return NULL;
 
@@ -1144,41 +1042,35 @@ get_folder_info (CamelStore *store, const char *top, gboolean fast,
 
 	folders = g_ptr_array_new ();
 
-	if (online) {
-		/* Get top-level */
-		get_folders_online (imap_store, name, folders, FALSE, ex);
-		if (camel_exception_is_set (ex))
-			return NULL;
-		if (folders->len) {
-			fi = folders->pdata[0];
-			if (!fi->url) {
-				camel_folder_info_free (fi);
-				g_ptr_array_remove_index (folders, 0);
-			}
-		}
-
-		/* If we want to look at only subscribed folders AND
-		 * check if any of them have new mail, AND the server
-		 * doesn't return Marked/UnMarked with LSUB, then
-		 * use get_subscribed_folders_by_hand. In all other
-		 * cases, use a single LIST or LSUB command.
-		 */
-		if (subscribed_only &&
-		    !(imap_store->capabilities & IMAP_CAPABILITY_useful_lsub) &&
-		     (imap_store->parameters & IMAP_PARAM_CHECK_ALL)) {
-			get_subscribed_folders_by_hand (imap_store, name,
-							folders, ex);
-		} else {
-			pattern = imap_concat (imap_store, name,
-					       recursive ? "*" : "%");
-			get_folders_online (imap_store, pattern, folders,
-					    subscribed_only, ex);
-			g_free (pattern);
+	/* Get top-level */
+	get_folders_online (imap_store, name, folders, FALSE, ex);
+	if (camel_exception_is_set (ex))
+		goto lose;
+	if (folders->len) {
+		fi = folders->pdata[0];
+		if (!fi->url) {
+			camel_folder_info_free (fi);
+			g_ptr_array_remove_index (folders, 0);
 		}
-	} else
-		get_folders_offline (imap_store, folders, ex);
+	}
 
+	/* If we want to look at only subscribed folders AND check if
+	 * any of them have new mail, AND the server doesn't return
+	 * Marked/UnMarked with LSUB, then use
+	 * get_subscribed_folders_by_hand. In all other cases, use a
+	 * single LIST or LSUB command.
+	 */
+	if ((flags & CAMEL_STORE_FOLDER_INFO_SUBSCRIBED) &&
+	    !(imap_store->capabilities & IMAP_CAPABILITY_useful_lsub) &&
+	    (imap_store->parameters & IMAP_PARAM_CHECK_ALL)) {
+		get_subscribed_folders_by_hand (imap_store, name, folders, ex);
+	} else {
+		pattern = imap_concat (imap_store, name, (flags & CAMEL_STORE_FOLDER_INFO_RECURSIVE) ? "*" : "%");
+		get_folders_online (imap_store, pattern, folders, (flags & CAMEL_STORE_FOLDER_INFO_SUBSCRIBED), ex);
+		g_free (pattern);
+	}
 	if (camel_exception_is_set (ex)) {
+	lose:
 		for (i = 0; i < folders->len; i++)
 			camel_folder_info_free (folders->pdata[i]);
 		g_ptr_array_free (folders, TRUE);
@@ -1194,68 +1086,143 @@ get_folder_info (CamelStore *store, const char *top, gboolean fast,
 				break;
 			}
 		}
+
+		if (need_inbox) {
+			CamelURL *url;
+			char *uri;
+
+			url = camel_url_new (imap_store->base_url, NULL);
+			g_free (url->path);
+			url->path = g_strdup ("/INBOX");
+			uri = camel_url_to_string (url, 0);
+			camel_url_free (url);
+
+			fi = g_new0 (CamelFolderInfo, 1);
+			fi->full_name = g_strdup ("INBOX");
+			fi->name = g_strdup ("INBOX");
+			fi->url = uri;
+			fi->unread_message_count = -1;
+
+			g_ptr_array_add (folders, fi);
+		}
 	}
-	
-	if (need_inbox) {
-		CamelURL *url;
-		char *uri;
-		
-		url = camel_url_new (imap_store->base_url, NULL);
-		g_free (url->path);
-		url->path = g_strdup ("/INBOX");
-		uri = camel_url_to_string (url, 0);
-		camel_url_free (url);
-		
-		fi = g_new0 (CamelFolderInfo, 1);
-		fi->full_name = g_strdup ("INBOX");
-		fi->name = g_strdup ("INBOX");
-		fi->url = uri;
-		fi->unread_message_count = -1;
-		
-		g_ptr_array_add (folders, fi);
+
+	/* Assemble. */
+	fi = camel_folder_info_build (folders, name, imap_store->dir_sep, TRUE);
+	if (flags & CAMEL_STORE_FOLDER_INFO_FAST) {
+		g_ptr_array_free (folders, TRUE);
+		return fi;
 	}
 
-	if (!fast) {
-		/* Get unread counts. Sync flag changes to the server
-		 * first so it has the same ideas about read/unread as
-		 * we do.
+	/* Get unread counts. Sync flag changes to the server first so
+	 * it has the same ideas about read/unread as we do.
+	 */
+	camel_store_sync (store, NULL);
+	for (i = 0; i < folders->len; i++) {
+		fi = folders->pdata[i];
+
+		/* Don't check if it doesn't contain messages or if it
+		 * was \UnMarked.
 		 */
-		camel_store_sync (store, NULL);
-		for (i = 0; i < folders->len; i++) {
-			fi = folders->pdata[i];
+		if (!fi->url || fi->unread_message_count != -1)
+			continue;
+		/* Don't check if it's not INBOX and we're only
+		 * checking INBOX.
+		 */
+		if ((!(imap_store->parameters & IMAP_PARAM_CHECK_ALL))
+		    && (g_strcasecmp (fi->name, "INBOX") != 0))
+			continue;
 
-			/* Don't check if it doesn't contain messages
-			 * or if it was \UnMarked.
-			 */
-			if (!fi->url || fi->unread_message_count != -1)
-				continue;
-			/* Don't check if it's not INBOX and we're only
-			 * checking INBOX.
-			 */
-			if ((!(imap_store->parameters & IMAP_PARAM_CHECK_ALL))
-			    && (g_strcasecmp (fi->name, "INBOX") != 0))
-				continue;
+		/* UW will give cached data for the currently selected
+		 * folder. Grr. Well, I guess this also potentially
+		 * saves us one IMAP command.
+		 */
+		if (imap_store->current_folder &&
+		    !strcmp (imap_store->current_folder->full_name, fi->full_name)) {
+			fi->unread_message_count = camel_folder_get_unread_message_count (imap_store->current_folder);
+			continue;
+		}
 
-			/* UW will give cached data for the currently
-			 * selected folder. Grr. Well, I guess this
-			 * also potentially saves us one IMAP command.
-			 */
-			if (imap_store->current_folder &&
-			    !strcmp (imap_store->current_folder->full_name,
-				     fi->full_name)) {
-				fi->unread_message_count = camel_folder_get_unread_message_count (imap_store->current_folder);
-				continue;
-			}
+		response = camel_imap_command (imap_store, NULL, NULL,
+					       "STATUS %S (UNSEEN)",
+					       fi->full_name);
+		if (!response)
+			continue;
+		status = camel_imap_response_extract (imap_store, response,
+						      "STATUS", NULL);
+		if (!status)
+			continue;
 
-			if (online)
-				get_unread_online (imap_store, fi);
-			else
-				get_unread_offline (imap_store, fi);
-		}
+		p = strstrcase (status, "UNSEEN");
+		if (p)
+			fi->unread_message_count = strtoul (p + 6, NULL, 10);
+		g_free (status);
+	}
+
+	g_ptr_array_free (folders, TRUE);
+	return fi;
+}
+
+static gboolean
+get_one_folder_offline (const char *physical_path, const char *path, gpointer data)
+{
+	GPtrArray *folders = data;
+	CamelImapStore *imap_store = folders->pdata[0];
+	CamelFolderInfo *fi;
+
+	if (*path++ != '/')
+		return TRUE;
+
+	fi = g_new0 (CamelFolderInfo, 1);
+	fi->full_name = g_strdup (path);
+	fi->name = strrchr (fi->full_name, imap_store->dir_sep);
+	if (fi->name)
+		fi->name = g_strdup (fi->name + 1);
+	else
+		fi->name = g_strdup (fi->full_name);
+
+	fi->url = g_strdup_printf ("%s/%s", imap_store->base_url, path);
+
+	/* FIXME: check summary */
+	fi->unread_message_count = -1;
+
+	g_ptr_array_add (folders, fi);
+	return TRUE;
+}
+
+static CamelFolderInfo *
+get_folder_info_offline (CamelStore *store, const char *top,
+			 guint32 flags, CamelException *ex)
+{
+	CamelImapStore *imap_store = CAMEL_IMAP_STORE (store);
+	CamelFolderInfo *fi;
+	GPtrArray *folders;
+
+	if (!imap_store->connected &&
+	    !camel_service_connect (CAMEL_SERVICE (store), ex))
+		return NULL;
+
+	if ((store->flags & CAMEL_STORE_SUBSCRIPTIONS) &&
+	    !(flags & CAMEL_STORE_FOLDER_INFO_SUBSCRIBED)) {
+		camel_disco_store_check_online (CAMEL_DISCO_STORE (store), ex);
+		return NULL;
+	}
+
+	/* FIXME: obey other flags */
+
+	folders = g_ptr_array_new ();
+
+	/* A kludge to avoid having to pass a struct to the callback */
+	g_ptr_array_add (folders, imap_store);
+	if (!e_path_find_folders (imap_store->storage_path, get_one_folder_offline, folders)) {
+		camel_disco_store_check_online (CAMEL_DISCO_STORE (imap_store), ex);
+		fi = NULL;
+	} else {
+		g_ptr_array_remove_index_fast (folders, 0);
+		fi = camel_folder_info_build (folders, imap_store->namespace,
+					      imap_store->dir_sep, TRUE);
 	}
 
-	/* And assemble. */
-	fi = camel_folder_info_build (folders, name, imap_store->dir_sep, TRUE);
 	g_ptr_array_free (folders, TRUE);
 	return fi;
 }
@@ -1280,7 +1247,7 @@ subscribe_folder (CamelStore *store, const char *folder_name,
 	CamelFolderInfo *fi;
 	char *name;
 
-	if (!camel_imap_store_check_online (imap_store, ex))
+	if (!camel_disco_store_check_online (CAMEL_DISCO_STORE (store), ex))
 		return;
 	if (!camel_remote_store_connected (CAMEL_REMOTE_STORE (store), ex))
 		return;
@@ -1318,7 +1285,7 @@ unsubscribe_folder (CamelStore *store, const char *folder_name,
 	CamelFolderInfo *fi;
 	char *name;
 
-	if (!camel_imap_store_check_online (imap_store, ex))
+	if (!camel_disco_store_check_online (CAMEL_DISCO_STORE (store), ex))
 		return;
 	if (!camel_remote_store_connected (CAMEL_REMOTE_STORE (store), ex))
 		return;
@@ -1357,17 +1324,3 @@ imap_keepalive (CamelRemoteStore *store)
 	response = camel_imap_command (imap_store, NULL, NULL, "NOOP");
 	camel_imap_response_free (imap_store, response);
 }
-
-gboolean
-camel_imap_store_check_online (CamelImapStore *store, CamelException *ex)
-{
-	/* Hack */
-	if (getenv ("CAMEL_OFFLINE")) {
-		camel_exception_set (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
-				     _("You must be working online to "
-				       "complete this operation"));
-		return FALSE;
-	}
-
-	return TRUE;
-}
diff --git a/camel/providers/imap/camel-imap-store.h b/camel/providers/imap/camel-imap-store.h
index b05e525845..8c0453cb53 100644
--- a/camel/providers/imap/camel-imap-store.h
+++ b/camel/providers/imap/camel-imap-store.h
@@ -33,7 +33,7 @@ extern "C" {
 #endif /* __cplusplus }*/
 
 #include "camel-imap-types.h"
-#include "camel-remote-store.h"
+#include "camel-disco-store.h"
 
 #define CAMEL_IMAP_STORE_TYPE     (camel_imap_store_get_type ())
 #define CAMEL_IMAP_STORE(obj)     (CAMEL_CHECK_CAST((obj), CAMEL_IMAP_STORE_TYPE, CamelImapStore))
@@ -59,7 +59,7 @@ typedef enum {
 #define IMAP_PARAM_FILTER_INBOX			(1 << 2)
 
 struct _CamelImapStore {
-	CamelRemoteStore parent_object;	
+	CamelDiscoStore parent_object;	
 	struct _CamelImapStorePrivate *priv;
 
 	/* Information about the command channel / connection status */
@@ -77,7 +77,7 @@ struct _CamelImapStore {
 
 
 typedef struct {
-	CamelRemoteStoreClass parent_class;
+	CamelDiscoStoreClass parent_class;
 
 } CamelImapStoreClass;
 
@@ -85,8 +85,6 @@ typedef struct {
 /* Standard Camel function */
 CamelType camel_imap_store_get_type (void);
 
-gboolean camel_imap_store_check_online (CamelImapStore *store, CamelException *ex);
-
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/camel/providers/local/camel-local-store.c b/camel/providers/local/camel-local-store.c
index d0ce48ce98..4b948ab96a 100644
--- a/camel/providers/local/camel-local-store.c
+++ b/camel/providers/local/camel-local-store.c
@@ -46,9 +46,7 @@ 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,
-					 gboolean fast, gboolean recursive,
-					 gboolean subscribed_only,
-					 CamelException *ex);
+					 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);
 
@@ -187,9 +185,7 @@ get_name (CamelService *service, gboolean brief)
 
 static CamelFolderInfo *
 get_folder_info (CamelStore *store, const char *top,
-		 gboolean fast, gboolean recursive,
-		 gboolean subscribed_only,
-		 CamelException *ex)
+		 guint32 flags, CamelException *ex)
 {
 	/* FIXME: This is broken, but it corresponds to what was
 	 * there before.