First batch of disconnected IMAP-related stuff. This adds local

	caching of message parts, but NOT any actual disconnected support.
	(But it should speed up IMAP use.)

	* providers/imap/camel-imap-message-cache.c: New class for caching
	message data to disk, and removing it when it's no longer
	relevant. Will eventually also support merging message parts
	together to save on files. Or maybe using a db instead of files?

	* providers/imap/camel-imap-private.h: Add a cache_lock to
	CamelImapFolderPrivate. This lock must be recursive, so make both
	locks EMutexes rather than GMutex.

	* providers/imap/camel-imap-folder.c (parse_fetch_response): "The
	only FETCH response parser you need!" Replaces the various
	almost-correct bits of code formerly scattered throughout this
	file with a single fully-correct function that can handle any
	FETCH response at any time, so we don't get confused by seeing a
	flags update when we were only expecting a message body, etc.
	(camel_imap_folder_fetch_data): FETCH a message body part either
	from the cache or the server
	(camel_imap_folder_changed): Remove expunged messages from the
	message cache.
	(camel_imap_folder_new): Change to take a directory instead of a
	summary file name. Create a CamelImapMessageCache for the folder.
	(imap_finalize): Unref the message cache.
	(camel_imap_folder_selected, imap_rescan, get_content,
	get_message, imap_get_message, imap_update_summary): Redone a
	bunch to use parse_fetch_data, CamelImapMessageCache, etc.

	* providers/imap/camel-imap-store.c (get_folder): Pass directory
	name to camel_imap_folder_new, not summary filename. Use
	e_path_to_physical to generate a path with /subfolders/ inserted
	between directory components.

	* providers/imap/camel-imap-wrapper.c (camel_imap_wrapper_new):
	Call camel_imap_folder_fetch_data (with cache_only TRUE) and if
	the data is cached, return an online datawrapper rather than an
	offline one.
	(write_to_stream): Use camel_imap_folder_fetch_data (with
	cache_only FALSE) here too

	* providers/imap/camel-imap-utils.c (imap_skip_list): Renamed from
	skip_list and made non-static.

svn path=/trunk/; revision=8743

12 files changed, 739 insertions, 268 deletions

diff --git a/camel/providers/imap/Makefile.am b/camel/providers/imap/Makefile.am
index d38302004c..d29a1677af 100644
--- a/camel/providers/imap/Makefile.am
+++ b/camel/providers/imap/Makefile.am
@@ -22,6 +22,7 @@ INCLUDES = -I.. \
 libcamelimap_la_SOURCES = 			\
 	camel-imap-command.c			\
 	camel-imap-folder.c			\
+	camel-imap-message-cache.c		\
 	camel-imap-provider.c			\
 	camel-imap-search.c			\
 	camel-imap-store.c			\
@@ -32,6 +33,7 @@ libcamelimap_la_SOURCES = 			\
 libcamelimapinclude_HEADERS =			\
 	camel-imap-command.h			\
 	camel-imap-folder.h			\
+	camel-imap-message-cache.h		\
 	camel-imap-search.h			\
 	camel-imap-store.h			\
 	camel-imap-summary.h			\
diff --git a/camel/providers/imap/camel-imap-folder.c b/camel/providers/imap/camel-imap-folder.c
index cf91bceb12..2a99df8149 100644
--- a/camel/providers/imap/camel-imap-folder.c
+++ b/camel/providers/imap/camel-imap-folder.c
@@ -39,6 +39,7 @@
 
 #include "camel-imap-folder.h"
 #include "camel-imap-command.h"
+#include "camel-imap-message-cache.h"
 #include "camel-imap-search.h"
 #include "camel-imap-store.h"
 #include "camel-imap-summary.h"
@@ -46,7 +47,6 @@
 #include "camel-imap-wrapper.h"
 #include "string-utils.h"
 #include "camel-stream.h"
-#include "camel-stream-fs.h"
 #include "camel-stream-mem.h"
 #include "camel-stream-buffer.h"
 #include "camel-data-wrapper.h"
@@ -92,6 +92,8 @@ static void imap_update_summary (CamelFolder *folder, int first, int last,
 static GPtrArray *imap_search_by_expression (CamelFolder *folder, const char *expression, CamelException *ex);
 static void       imap_search_free          (CamelFolder *folder, GPtrArray *uids);
 
+GData *parse_fetch_response (CamelImapFolder *imap_folder, char *msg_att);
+
 static void
 camel_imap_folder_class_init (CamelImapFolderClass *camel_imap_folder_class)
 {
@@ -127,7 +129,8 @@ camel_imap_folder_init (gpointer object, gpointer klass)
 	
 	imap_folder->priv = g_malloc0(sizeof(*imap_folder->priv));
 #ifdef ENABLE_THREADS
-	imap_folder->priv->search_lock = g_mutex_new();
+	imap_folder->priv->search_lock = e_mutex_new(E_MUTEX_SIMPLE);
+	imap_folder->priv->cache_lock = e_mutex_new(E_MUTEX_REC);
 #endif
 }
 
@@ -152,13 +155,14 @@ camel_imap_folder_get_type (void)
 
 CamelFolder *
 camel_imap_folder_new (CamelStore *parent, const char *folder_name,
-		       const char *short_name, const char *summary_file,
+		       const char *short_name, 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;
-	char *resp;
+	char *resp, *summary_file;
 	guint32 validity = 0;
 	int i, exists = 0;
 
@@ -192,7 +196,9 @@ camel_imap_folder_new (CamelStore *parent, const char *folder_name,
 	}
 	camel_imap_response_free (response);
 
+	summary_file = g_strdup_printf ("%s/summary", folder_dir);
 	folder->summary = camel_imap_summary_new (summary_file, validity);
+	g_free (summary_file);
 	if (!folder->summary) {
 		camel_object_unref (CAMEL_OBJECT (folder));
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
@@ -201,6 +207,12 @@ camel_imap_folder_new (CamelStore *parent, const char *folder_name,
 		return NULL;
 	}
 
+	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;
+	}
+
 	CAMEL_IMAP_STORE_LOCK(imap_store, command_lock);
 	imap_rescan (folder, exists, ex);
 	CAMEL_IMAP_STORE_UNLOCK(imap_store, command_lock);
@@ -217,8 +229,10 @@ void
 camel_imap_folder_selected (CamelFolder *folder, CamelImapResponse *response,
 			    CamelException *ex)
 {
+	CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder);
 	unsigned long exists = 0, val, uid;
 	CamelMessageInfo *info;
+	GData *fetch_data;
 	int i, count;
 	char *resp;
 
@@ -259,13 +273,15 @@ camel_imap_folder_selected (CamelFolder *folder, CamelImapResponse *response,
 		for (i = 0; i < response->untagged->len; i++) {
 			resp = response->untagged->pdata[i];
 			val = strtoul (resp + 2, &resp, 10);
-			if (val != count || g_strncasecmp (resp, " FETCH (", 8) != 0)
-				continue;
-			resp = e_strstrcase (resp, "UID ");
-			if (!resp)
-				continue;
-			uid = strtoul (resp + 4, NULL, 10);
-			break;
+			if (val == count && !g_strncasecmp (resp, " FETCH (", 8))
+				break;
+		}
+
+		if (i < response->untagged->len) {
+			fetch_data = parse_fetch_response (imap_folder, resp + 7);
+			uid = strtoul (g_datalist_get_data (&fetch_data, "UID"),
+				       NULL, 10);
+			g_datalist_clear (&fetch_data);
 		}
 		camel_imap_response_free (response);
 
@@ -293,10 +309,13 @@ imap_finalize (CamelObject *object)
 	CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (object);
 
 	if (imap_folder->search)
-		camel_object_unref ((CamelObject *)imap_folder->search);
+		camel_object_unref (CAMEL_OBJECT (imap_folder->search));
+	if (imap_folder->cache)
+		camel_object_unref (CAMEL_OBJECT (imap_folder->cache));
 
 #ifdef ENABLE_THREADS
-	g_mutex_free(imap_folder->priv->search_lock);
+	e_mutex_destroy(imap_folder->priv->search_lock);
+	e_mutex_destroy(imap_folder->priv->cache_lock);
 #endif
 	g_free(imap_folder->priv);
 }
@@ -313,18 +332,19 @@ imap_refresh_info (CamelFolder *folder, CamelException *ex)
 static void
 imap_rescan (CamelFolder *folder, int exists, CamelException *ex)
 {
+	CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder);
 	CamelImapStore *store = CAMEL_IMAP_STORE (folder->parent_store);
 	CamelImapResponse *response;
 	struct {
 		char *uid;
 		guint32 flags;
 	} *new = NULL;
-	char *resp, *p, *flags;
-	const char *uid;
+	char *resp;
 	int i, j, seq, summary_len;
 	CamelMessageInfo *info;
 	CamelImapMessageInfo *iinfo;
 	GArray *removed;
+	GData *fetch_data;
 
 	camel_operation_start(NULL, _("Scanning IMAP folder"));
 
@@ -341,21 +361,14 @@ imap_rescan (CamelFolder *folder, int exists, CamelException *ex)
 			resp = response->untagged->pdata[i];
 
 			seq = strtoul (resp + 2, &resp, 10);
-			if (g_strncasecmp (resp, " FETCH ", 7) != 0)
+			if (g_strncasecmp (resp, " FETCH (", 8) != 0)
 				continue;
 
-			uid = e_strstrcase (resp, "UID ");
-			if (uid) {
-				uid += 4;
-				strtoul (uid, &p, 10);
-				new[seq - 1].uid = g_strndup (uid, p - uid);
-			}
-
-			flags = e_strstrcase (resp, "FLAGS ");
-			if (flags) {
-				flags += 6;
-				new[seq - 1].flags = imap_parse_flag_list (&flags);
-			}
+			fetch_data = parse_fetch_response (imap_folder, resp + 7);
+			new[seq - 1].uid = g_strdup (g_datalist_get_data (&fetch_data, "UID"));
+			new[seq - 1].flags = GPOINTER_TO_UINT (g_datalist_get_data (&fetch_data, "FLAGS"));
+			g_datalist_clear (&fetch_data);
+			g_ptr_array_remove_index_fast (response->untagged, i--);
 		}
 		camel_imap_response_free (response);
 	}
@@ -767,83 +780,8 @@ imap_search_free (CamelFolder *folder, GPtrArray *uids)
 	CAMEL_IMAP_FOLDER_UNLOCK(folder, search_lock);
 }
 
-/* parse a header response (starting after the first ' ' after
- * *@headers_p) and construct a content-free CamelMedium from it.
- */
-static CamelMedium *
-parse_headers (char **headers_p, CamelType medium_type)
-{
-	CamelMedium *medium; 
-	CamelStream *stream;
-	char *headers;
-	int len;
-
-	*headers_p = strchr (*headers_p, ' ');
-	if (!*headers_p)
-		return FALSE;
-	(*headers_p)++;
-
-	headers = imap_parse_nstring (headers_p, &len);
-	if (!headers)
-		return FALSE;
-	stream = camel_stream_mem_new_with_buffer (headers, len);
-	g_free (headers);
-
-	medium = CAMEL_MEDIUM (camel_object_new (medium_type));
-	camel_data_wrapper_construct_from_stream (CAMEL_DATA_WRAPPER (medium), stream);
-	camel_object_unref (CAMEL_OBJECT (stream));
-
-	return medium;
-}
-
-static CamelMedium *
-fetch_medium (CamelFolder *folder, const char *uid, const char *section_text,
-	      CamelType type, CamelException *ex)
-{
-	CamelImapStore *store = CAMEL_IMAP_STORE (folder->parent_store);
-	CamelImapResponse *response;
-	CamelMedium *medium;
-	char *result, *p;
-
-	CAMEL_IMAP_STORE_LOCK (store, command_lock);
-	if (store->server_level < IMAP_LEVEL_IMAP4REV1 && !*section_text) {
-		response = camel_imap_command (store, folder, ex,
-					       "UID FETCH %s RFC822.PEEK",
-					       uid);
-	} else {
-		response = camel_imap_command (store, folder, ex,
-					       "UID FETCH %s BODY.PEEK[%s]",
-					       uid, section_text);
-	}
-	CAMEL_IMAP_STORE_UNLOCK (store, command_lock);
-	if (!response)
-		return NULL;
-
-	/* FIXME: there could be multiple lines of FETCH response. */
-	result = camel_imap_response_extract (response, "FETCH", ex);
-	if (!result)
-		return NULL;
-
-	
-	if (store->server_level < IMAP_LEVEL_IMAP4REV1 && !*section_text)
-		p = e_strstrcase (result, "RFC822");
-	else
-		p = e_strstrcase (result, "BODY");
-
-	if (p)
-		medium = parse_headers (&p, type);
-	else {
-		camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
-				      _("Could not find message body in FETCH "
-					"response."));
-		medium = NULL;
-	}
-	g_free (result);
-
-	return medium;
-}
-
-static CamelMimeMessage *get_message (CamelFolder *folder, const char *uid,
+static CamelMimeMessage *get_message (CamelImapFolder *imap_folder,
+				      const char *uid,
 				      const char *part_specifier,
 				      CamelMessageContentInfo *ci,
 				      CamelException *ex);
@@ -852,17 +790,18 @@ static CamelMimeMessage *get_message (CamelFolder *folder, const char *uid,
  * of message @uid in @folder.
  */
 static CamelDataWrapper *
-get_content (CamelFolder *folder, const char *uid, const char *part_spec,
-	     CamelMimePart *part, CamelMessageContentInfo *ci,
-	     CamelException *ex)
+get_content (CamelImapFolder *imap_folder, const char *uid,
+	     const char *part_spec, CamelMimePart *part,
+	     CamelMessageContentInfo *ci, CamelException *ex)
 {
+	CamelDataWrapper *content;
+	CamelStream *stream;
 	char *child_spec;
 
 	/* There are three cases: multipart, message/rfc822, and "other" */
 
 	if (header_content_type_is (ci->type, "multipart", "*")) {
 		CamelMultipart *body_mp;
-		CamelDataWrapper *content;
 		int speclen, num;
 
 		body_mp = camel_multipart_new ();
@@ -880,18 +819,21 @@ get_content (CamelFolder *folder, const char *uid, const char *part_spec,
 		num = 1;
 		while (ci) {
 			sprintf (child_spec + speclen, "%d.MIME", num++);
-			part = (CamelMimePart *)fetch_medium (folder, uid, child_spec, CAMEL_MIME_PART_TYPE, ex);
-			*(strchr (child_spec + speclen, '.')) = '\0';
-			if (part)
-				content = get_content (folder, uid, child_spec, part, ci, ex);
-			if (!part || !content) {
+			stream = camel_imap_folder_fetch_data (imap_folder, uid, child_spec, FALSE, ex);
+			if (stream) {
+				part = camel_mime_part_new ();
+				camel_data_wrapper_construct_from_stream (CAMEL_DATA_WRAPPER (part), stream);
+				camel_object_unref (CAMEL_OBJECT (stream));
+				*(strchr (child_spec + speclen, '.')) = '\0';
+				content = get_content (imap_folder, uid, child_spec, part, ci, ex);
+			}
+			if (!stream || !content) {
 				g_free (child_spec);
-				camel_object_unref (CAMEL_OBJECT (part));
 				camel_object_unref (CAMEL_OBJECT (body_mp));
 				return NULL;
 			}
-			camel_medium_set_content_object (CAMEL_MEDIUM (part),
-							 content);
+
+			camel_medium_set_content_object (CAMEL_MEDIUM (part), content);
 			camel_object_unref (CAMEL_OBJECT (content));
 			camel_multipart_add_part (body_mp, part);
 			camel_object_unref (CAMEL_OBJECT (part));
@@ -903,37 +845,42 @@ get_content (CamelFolder *folder, const char *uid, const char *part_spec,
 		return (CamelDataWrapper *)body_mp;
 	} else if (header_content_type_is (ci->type, "message", "rfc822")) {
 		return (CamelDataWrapper *)
-			get_message (folder, uid, part_spec, ci->childs, ex);
+			get_message (imap_folder, uid, part_spec, ci->childs, ex);
 	} else {
-		CamelDataWrapper *content;
-
 		if (!ci->parent || header_content_type_is (ci->parent->type, "message", "rfc822"))
 			child_spec = g_strdup_printf ("%s%s1", part_spec, *part_spec ? "." : "");
 		else
 			child_spec = g_strdup (part_spec);
-		content = camel_imap_wrapper_new (folder, ci->type, uid, child_spec, part);
+
+		content = camel_imap_wrapper_new (imap_folder, ci->type, uid, child_spec, part);
 		g_free (child_spec);
 		return content;
 	}
 }
 
 static CamelMimeMessage *
-get_message (CamelFolder *folder, const char *uid, const char *part_spec,
-	     CamelMessageContentInfo *ci, CamelException *ex)
+get_message (CamelImapFolder *imap_folder, const char *uid,
+	     const char *part_spec, CamelMessageContentInfo *ci,
+	     CamelException *ex)
 {
-	CamelImapStore *store = CAMEL_IMAP_STORE (folder->parent_store);
+	CamelImapStore *store = CAMEL_IMAP_STORE (CAMEL_FOLDER (imap_folder)->parent_store);
 	CamelDataWrapper *content;
 	CamelMimeMessage *msg;
+	CamelStream *stream;
 	char *section_text;
 
 	section_text = g_strdup_printf ("%s%s%s", part_spec, *part_spec ? "." : "",
 					store->server_level >= IMAP_LEVEL_IMAP4REV1 ? "HEADER" : "0");
-	msg = (CamelMimeMessage *)fetch_medium (folder, uid, section_text, CAMEL_MIME_MESSAGE_TYPE, ex);
+	stream = camel_imap_folder_fetch_data (imap_folder, uid, section_text, FALSE, ex);
 	g_free (section_text);
-	if (!msg)
+	if (!stream)
 		return NULL;
 
-	content = get_content (folder, uid, part_spec, CAMEL_MIME_PART (msg), ci, ex);
+	msg = camel_mime_message_new ();
+	camel_data_wrapper_construct_from_stream (CAMEL_DATA_WRAPPER (msg), stream);
+	camel_object_unref (CAMEL_OBJECT (stream));
+
+	content = get_content (imap_folder, uid, part_spec, CAMEL_MIME_PART (msg), ci, ex);
 	if (!content) {
 		camel_object_unref (CAMEL_OBJECT (msg));
 		return NULL;
@@ -951,8 +898,10 @@ get_message (CamelFolder *folder, const char *uid, const char *part_spec,
 static CamelMimeMessage *
 imap_get_message (CamelFolder *folder, const char *uid, CamelException *ex)
 {
+	CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder);
 	CamelMessageInfo *mi;
 	CamelMimeMessage *msg;
+	CamelStream *stream;
 
 	mi = camel_folder_summary_uid (folder->summary, uid);
 	g_return_val_if_fail (mi != NULL, NULL);
@@ -960,7 +909,13 @@ imap_get_message (CamelFolder *folder, const char *uid, CamelException *ex)
 	/* Fetch small messages directly. */
 	if (mi->size < IMAP_SMALL_BODY_SIZE) {
 		camel_folder_summary_info_free (folder->summary, mi);
-		return (CamelMimeMessage *)fetch_medium (folder, uid, "", CAMEL_MIME_MESSAGE_TYPE, ex);
+		stream = camel_imap_folder_fetch_data (imap_folder, uid, "", FALSE, ex);
+		if (!stream)
+			return NULL;
+		msg = camel_mime_message_new ();
+		camel_data_wrapper_construct_from_stream (CAMEL_DATA_WRAPPER (msg), stream);
+		camel_object_unref (CAMEL_OBJECT (stream));
+		return msg;
 	}
 
 	/* For larger messages, fetch the structure and build a message
@@ -971,7 +926,9 @@ imap_get_message (CamelFolder *folder, const char *uid, CamelException *ex)
 	if (!mi->content->type) {
 		CamelImapStore *store = CAMEL_IMAP_STORE (folder->parent_store);
 		CamelImapResponse *response;
-		char *result, *p;
+		GData *fetch_data;
+		char *body, *found_uid;
+		int i;
 
 		CAMEL_IMAP_STORE_LOCK (store, command_lock);
 		response = camel_imap_command (store, folder, ex,
@@ -981,19 +938,22 @@ imap_get_message (CamelFolder *folder, const char *uid, CamelException *ex)
 			camel_folder_summary_info_free (folder->summary, mi);
 			return NULL;
 		}
-		/* FIXME, wrong */
-		result = camel_imap_response_extract (response, "FETCH", ex);
-		if (!result) {
-			camel_folder_summary_info_free (folder->summary, mi);
-			return NULL;
-		}
 
-		p = e_strstrcase (result, "BODY ");
-		if (p) {
-			p += 5;
-			imap_parse_body (&p, folder, mi->content);
+		for (i = 0, body = NULL; i < response->untagged->len; i++) {
+			fetch_data = parse_fetch_response (imap_folder, response->untagged->pdata[i]);
+			found_uid = g_datalist_get_data (&fetch_data, "UID");
+			body = g_datalist_get_data (&fetch_data, "BODY");
+			if (found_uid && body && !strcmp (found_uid, uid))
+				break;
+			g_datalist_clear (&fetch_data);
+			body = NULL;
 		}
-		g_free (result);
+
+		if (body)
+			imap_parse_body (&body, folder, mi->content);
+		g_datalist_clear (&fetch_data);
+		camel_imap_response_free (response);
+
 		if (!mi->content->type) {
 			camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
 					      _("Could not find message body in FETCH response."));
@@ -1002,7 +962,7 @@ imap_get_message (CamelFolder *folder, const char *uid, CamelException *ex)
 		}
 	}
 
-	msg = get_message (folder, uid, "", mi->content, ex);
+	msg = get_message (imap_folder, uid, "", mi->content, ex);
 	camel_folder_summary_info_free (folder->summary, mi);
 
 	return msg;
@@ -1021,15 +981,16 @@ static void
 imap_update_summary (CamelFolder *folder, int first, int last,
 		     CamelFolderChangeInfo *changes, CamelException *ex)
 {
+	CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder);
 	CamelImapStore *store = CAMEL_IMAP_STORE (folder->parent_store);
 	CamelImapResponse *response;
 	GPtrArray *headers, *messages;
 	const char *summary_specifier;
-	char *p, *uid;
+	char *p;
 	int i, seq, count;
 	CamelMimeMessage *msg;
 	CamelMessageInfo *mi;
-	guint32 flags, size;
+	GData *fetch_data;
 
 	summary_specifier = imap_protocol_get_summary_specifier (store);
 	/* We already have the command lock */
@@ -1055,58 +1016,43 @@ imap_update_summary (CamelFolder *folder, int first, int last,
 		if (*p++ != '*' || *p++ != ' ')
 			continue;
 		seq = strtoul (p, &p, 10);
-		if (!seq || seq < count)
+		if (!seq || seq < first || seq > last)
 			continue;
 		if (g_strncasecmp (p, " FETCH (", 8) != 0)
 			continue;
-		p += 8;
+		p += 7;
 
 		mi = messages->pdata[seq - first];
-		flags = size = 0;
-		uid = NULL;
-		while (p && *p != ')') {
-			if (*p == ' ')
-				p++;
-			if (!g_strncasecmp (p, "FLAGS ", 6)) {
-				p += 6;
-				/* FIXME user flags */
-				flags = imap_parse_flag_list (&p);
-			} else if (!g_strncasecmp (p, "RFC822.SIZE ", 12)) {
-				size = strtoul (p + 12, &p, 10);
-			} else if (!g_strncasecmp (p, "UID ", 4)) {
-				uid = p + 4;
-				strtoul (uid, &p, 10);
-				uid = g_strndup (uid, p - uid);
-			} else if (!g_strncasecmp (p, "BODY[HEADER", 11) ||
-				   !g_strncasecmp (p, "RFC822.HEADER", 13)) {
-				msg = (CamelMimeMessage *) parse_headers (&p, CAMEL_MIME_MESSAGE_TYPE);
-				mi = camel_folder_summary_info_new_from_message (folder->summary, msg);
-				camel_object_unref (CAMEL_OBJECT (msg));
-			} else {
-				g_warning ("Waiter, I did not order this %.*s",
-					   (int)strcspn (p, " \n"), p);
-				p = NULL;
+		fetch_data = parse_fetch_response (imap_folder, p);
+
+		if (!mi) {
+			CamelStream *stream;
+
+			if (!g_datalist_get_data (&fetch_data, "BODY_PART_DATA")) {
+				g_datalist_clear (&fetch_data);
+				p = headers->pdata[i];
+				g_ptr_array_remove_index (headers, i--);
+				g_ptr_array_add (headers, p);
+				continue;
 			}
-		}
 
-		/* Ideally we got everything on one line, but if we
-		 * we didn't, and we didn't get the body yet, then we
-		 * have to postpone this line for later.
-		 */
-		if (mi == NULL) {
-			p = headers->pdata[i];
-			g_ptr_array_remove_index (headers, i);
-			g_ptr_array_add (headers, p);
-			continue;
+			msg = camel_mime_message_new ();
+			stream = g_datalist_get_data (&fetch_data, "BODY_PART_STREAM");
+			camel_data_wrapper_construct_from_stream (CAMEL_DATA_WRAPPER (msg), stream);
+			mi = camel_folder_summary_info_new_from_message (folder->summary, msg);
+			camel_object_unref (CAMEL_OBJECT (msg));
+
+			messages->pdata[seq - first] = mi;
 		}
 
-		messages->pdata[seq - first] = mi;
-		if (uid)
-			camel_message_info_set_uid (mi, uid);
-		if (flags)
-			mi->flags = flags;
-		if (size)
-			mi->size = size;
+		if (g_datalist_get_data (&fetch_data, "UID"))
+			camel_message_info_set_uid (mi, g_strdup (g_datalist_get_data (&fetch_data, "UID")));
+		if (g_datalist_get_data (&fetch_data, "FLAGS"))
+			mi->flags = GPOINTER_TO_INT (g_datalist_get_data (&fetch_data, "FLAGS"));
+		if (g_datalist_get_data (&fetch_data, "RFC822.SIZE"))
+			mi->size = GPOINTER_TO_INT (g_datalist_get_data (&fetch_data, "RFC822.SIZE"));
+
+		g_datalist_clear (&fetch_data);
 	}
 	camel_imap_response_free (response);
 
@@ -1123,6 +1069,7 @@ void
 camel_imap_folder_changed (CamelFolder *folder, int exists,
 			   GArray *expunged, CamelException *ex)
 {
+	CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder);
 	CamelFolderChangeInfo *changes;
 	CamelMessageInfo *info;
 	int len;
@@ -1135,6 +1082,8 @@ camel_imap_folder_changed (CamelFolder *folder, int exists,
 			id = g_array_index (expunged, int, i);
 			info = camel_folder_summary_index (folder->summary, id - 1);
 			camel_folder_change_info_remove_uid (changes, camel_message_info_uid (info));
+			/* It's safe to not lock around this. */
+			camel_imap_message_cache_remove (imap_folder->cache, camel_message_info_uid (info));
 			camel_folder_summary_remove (folder->summary, info);
 			camel_folder_summary_info_free(folder->summary, info);
 		}
@@ -1150,3 +1099,168 @@ camel_imap_folder_changed (CamelFolder *folder, int exists,
 	}
 	camel_folder_change_info_free (changes);
 }
+
+
+CamelStream *
+camel_imap_folder_fetch_data (CamelImapFolder *imap_folder, const char *uid,
+			      const char *section_text, gboolean cache_only,
+			      CamelException *ex)
+{
+	CamelFolder *folder = CAMEL_FOLDER (imap_folder);
+	CamelImapStore *store = CAMEL_IMAP_STORE (folder->parent_store);
+	CamelImapResponse *response;
+	CamelStream *stream;
+	GData *fetch_data;
+	char *found_uid;
+	int i;
+
+	CAMEL_IMAP_FOLDER_LOCK (imap_folder, cache_lock);
+	stream = camel_imap_message_cache_get (imap_folder->cache, uid, section_text);
+	if (stream || cache_only) {
+		CAMEL_IMAP_FOLDER_UNLOCK (imap_folder, cache_lock);
+		return stream;
+	}
+
+	CAMEL_IMAP_STORE_LOCK (store, command_lock);
+	if (store->server_level < IMAP_LEVEL_IMAP4REV1 && !*section_text) {
+		response = camel_imap_command (store, folder, ex,
+					       "UID FETCH %s RFC822.PEEK",
+					       uid);
+	} else {
+		response = camel_imap_command (store, folder, ex,
+					       "UID FETCH %s BODY.PEEK[%s]",
+					       uid, section_text);
+	}
+	CAMEL_IMAP_STORE_UNLOCK (store, command_lock);
+	if (!response) {
+		CAMEL_IMAP_FOLDER_UNLOCK (imap_folder, cache_lock);
+		return NULL;
+	}
+
+	for (i = 0; i < response->untagged->len; i++) {
+		fetch_data = parse_fetch_response (imap_folder, response->untagged->pdata[i]);
+		found_uid = g_datalist_get_data (&fetch_data, "UID");
+		stream = g_datalist_get_data (&fetch_data, "BODY_PART_STREAM");
+		if (found_uid && stream && !strcmp (uid, found_uid))
+			break;
+
+		g_datalist_clear (&fetch_data);
+		stream = NULL;
+	}
+	camel_imap_response_free (response);
+	CAMEL_IMAP_FOLDER_UNLOCK (imap_folder, cache_lock);
+	if (!stream) {
+		camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
+				      _("Could not find message body in FETCH "
+					"response."));
+	} else
+		camel_object_ref (CAMEL_OBJECT (stream));
+
+	g_datalist_clear (&fetch_data);
+
+	return stream;
+}
+
+GData *
+parse_fetch_response (CamelImapFolder *imap_folder, char *response)
+{
+	GData *data = NULL;
+	char *start, *part_spec = NULL, *body = NULL, *uid = NULL;
+	int body_len = 0;
+
+	if (*response != '(') {
+		long seq;
+
+		if (*response != '*' || *(response + 1) != ' ')
+			return NULL;
+		seq = strtol (response + 2, &response, 10);
+		if (seq == 0)
+			return NULL;
+		if (g_strncasecmp (response, " FETCH (", 8) != 0)
+			return NULL;
+		response += 7;
+	}
+
+	do {
+		/* Skip the initial '(' or the ' ' between elements */
+		response++;
+
+		if (!g_strncasecmp (response, "FLAGS ", 6)) {
+			guint32 flags;
+
+			response += 6;
+			/* FIXME user flags */
+			flags = imap_parse_flag_list (&response);
+
+			g_datalist_set_data (&data, "FLAGS", GUINT_TO_POINTER (flags));
+		} else if (!g_strncasecmp (response, "RFC822.SIZE ", 12)) {
+			unsigned long size;
+
+			response += 12;
+			size = strtoul (response, &response, 10);
+			g_datalist_set_data (&data, "RFC822.SIZE", GUINT_TO_POINTER (size));
+		} else if (!g_strncasecmp (response, "BODY[", 5) ||
+			   !g_strncasecmp (response, "RFC822 ", 7)) {
+			char *p;
+
+			if (*response == 'B') {
+				response += 5;
+				p = strchr (response, ']');
+				if (!p || *(p + 1) != ' ')
+					break;
+				part_spec = g_strndup (response, p - response);
+				response = p + 2;
+			} else {
+				part_spec = g_strdup ("");
+				response += 7;
+			}
+
+			body = imap_parse_nstring (&response, &body_len);
+			if (!body) {
+				g_free (part_spec);
+				break;
+			}
+
+			g_datalist_set_data_full (&data, "BODY_PART_SPEC", part_spec, g_free);
+			g_datalist_set_data_full (&data, "BODY_PART_DATA", body, g_free);
+			g_datalist_set_data (&data, "BODY_PART_LEN", GINT_TO_POINTER (body_len));
+		} else if (!g_strncasecmp (response, "BODY ", 5) ||
+			   !g_strncasecmp (response, "BODYSTRUCTURE ", 14)) {
+			response = strchr (response, ' ') + 1;
+			start = response;
+			imap_skip_list (&response);
+			g_datalist_set_data_full (&data, "BODY", g_strndup (start, response - start), g_free);
+		} else if (!g_strncasecmp (response, "UID ", 4)) {
+			int len;
+
+			len = strcspn (response + 4, " )");
+			uid = g_strndup (response + 4, len);
+			g_datalist_set_data_full (&data, "UID", uid, g_free);
+			response += 4 + len;
+		} else {
+			g_warning ("Unexpected FETCH response from server: "
+				   "(%s", response);
+			break;
+		}
+	} while (response && *response != ')');
+
+	if (!response || *response != ')') {
+		g_datalist_clear (&data);
+		return NULL;
+	}
+
+	if (uid && body) {
+		CamelStream *stream;
+
+		CAMEL_IMAP_FOLDER_LOCK (imap_folder, cache_lock);
+		stream = camel_imap_message_cache_insert (imap_folder->cache,
+							  uid, part_spec,
+							  body, body_len);
+		CAMEL_IMAP_FOLDER_UNLOCK (imap_folder, cache_lock);
+		g_datalist_set_data_full (&data, "BODY_PART_STREAM", stream,
+					  (GDestroyNotify)camel_object_unref);
+	}
+
+	return data;
+}
+
diff --git a/camel/providers/imap/camel-imap-folder.h b/camel/providers/imap/camel-imap-folder.h
index a943189f5a..6d969bf752 100644
--- a/camel/providers/imap/camel-imap-folder.h
+++ b/camel/providers/imap/camel-imap-folder.h
@@ -48,6 +48,7 @@ struct _CamelImapFolder {
 	struct _CamelImapFolderPrivate *priv;
 
 	CamelFolderSearch *search;
+	CamelImapMessageCache *cache;
 };
 
 
@@ -63,7 +64,7 @@ typedef struct {
 CamelFolder *camel_imap_folder_new (CamelStore *parent,
 				    const char *folder_name,
 				    const char *short_name,
-				    const char *summary_file,
+				    const char *folder_dir,
 				    CamelException *ex);
 
 void camel_imap_folder_selected (CamelFolder *folder,
@@ -73,6 +74,12 @@ void camel_imap_folder_selected (CamelFolder *folder,
 void camel_imap_folder_changed (CamelFolder *folder, int exists,
 				GArray *expunged, CamelException *ex);
 
+CamelStream *camel_imap_folder_fetch_data (CamelImapFolder *imap_folder,
+					   const char *uid,
+					   const char *section_text,
+					   gboolean cache_only,
+					   CamelException *ex);
+
 /* Standard Camel function */
 CamelType camel_imap_folder_get_type (void);
 
diff --git a/camel/providers/imap/camel-imap-message-cache.c b/camel/providers/imap/camel-imap-message-cache.c
new file mode 100644
index 0000000000..0ac90f7062
--- /dev/null
+++ b/camel/providers/imap/camel-imap-message-cache.c
@@ -0,0 +1,277 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/* camel-imap-message-cache.c: Class for an IMAP message cache */
+
+/* 
+ * Author: 
+ *   Dan Winship <danw@ximian.com>
+ *
+ * Copyright (C) 2001 Ximian, Inc. (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
+ */
+
+#include <config.h>
+
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <string.h>
+
+#include "camel-imap-message-cache.h"
+#include "camel-exception.h"
+#include "camel-stream-fs.h"
+
+static void finalize (CamelImapMessageCache *cache);
+static void stream_finalize (CamelObject *stream, gpointer event_data, gpointer user_data);
+
+
+CamelType
+camel_imap_message_cache_get_type (void)
+{
+	static CamelType camel_imap_message_cache_type = CAMEL_INVALID_TYPE;
+	
+	if (camel_imap_message_cache_type == CAMEL_INVALID_TYPE) {
+		camel_imap_message_cache_type = camel_type_register (
+			CAMEL_OBJECT_TYPE, "CamelImapMessageCache",
+			sizeof (CamelImapMessageCache),
+			sizeof (CamelImapMessageCacheClass),
+			NULL,
+			NULL,
+			NULL,
+			(CamelObjectFinalizeFunc) finalize);
+	}
+
+	return camel_imap_message_cache_type;
+}
+
+static void
+free_part (gpointer key, gpointer value, gpointer data)
+{
+	if (value) {
+		if (strchr (key, '.')) {
+			camel_object_unhook_event (value, "finalize",
+						   stream_finalize, data);
+			camel_object_unref (value);
+		} else
+			g_ptr_array_free (value, TRUE);
+	}
+	g_free (key);
+}
+
+static void
+finalize (CamelImapMessageCache *cache)
+{
+	if (cache->path)
+		g_free (cache->path);
+	if (cache->parts) {
+		g_hash_table_foreach (cache->parts, free_part, cache);
+		g_hash_table_destroy (cache->parts);
+	}
+	if (cache->cached)
+		g_hash_table_destroy (cache->cached);
+}
+
+static void
+cache_put (CamelImapMessageCache *cache, const char *uid, const char *key,
+	   CamelStream *stream)
+{
+	char *hash_key;
+	GPtrArray *subparts;
+	gpointer old_key, old_value;
+
+	hash_key = g_strdup (key);
+	subparts = g_hash_table_lookup (cache->parts, uid);
+	if (!subparts) {
+		subparts = g_ptr_array_new ();
+		g_hash_table_insert (cache->parts, g_strdup (uid), subparts);
+	} else if (g_hash_table_lookup_extended (cache->parts, hash_key,
+						 &old_key, &old_value))
+		g_ptr_array_remove (subparts, old_key);
+
+	g_ptr_array_add (subparts, hash_key);
+	g_hash_table_insert (cache->parts, hash_key, stream);
+	g_hash_table_insert (cache->cached, stream, hash_key);
+
+	if (stream) {
+		camel_object_hook_event (CAMEL_OBJECT (stream), "finalize",
+					 stream_finalize, cache);
+	}
+}
+
+CamelImapMessageCache *
+camel_imap_message_cache_new (const char *path, CamelFolderSummary *summary,
+			      CamelException *ex)
+{
+	CamelImapMessageCache *cache;
+	DIR *dir;
+	struct dirent *d;
+	char *uid, *p;
+	GPtrArray *deletes;
+	CamelMessageInfo *info;
+
+	dir = opendir (path);
+	if (!dir) {
+		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
+				      _("Could not open cache directory: %s"),
+				      g_strerror (errno));
+		return NULL;
+	}
+
+	cache = (CamelImapMessageCache *)camel_object_new (CAMEL_IMAP_MESSAGE_CACHE_TYPE);
+	cache->path = g_strdup (path);
+
+	cache->parts = g_hash_table_new (g_str_hash, g_str_equal);
+	cache->cached = g_hash_table_new (NULL, NULL);
+	deletes = g_ptr_array_new ();
+	while ((d = readdir (dir))) {
+		if (!isdigit (d->d_name[0]))
+			continue;
+
+		p = strchr (d->d_name, '.');
+		if (p)
+			uid = g_strndup (d->d_name, p - d->d_name);
+		else
+			uid = g_strdup (d->d_name);
+
+		info = camel_folder_summary_uid (summary, uid);
+		if (info) {
+			camel_folder_summary_info_free (summary, info);
+			cache_put (cache, uid, d->d_name, NULL);
+		} else
+			g_ptr_array_add (deletes, g_strdup_printf ("%s/%s", cache->path, d->d_name));
+		g_free (uid);
+	}
+	closedir (dir);
+
+	while (deletes->len) {
+		unlink (deletes->pdata[0]);
+		g_free (deletes->pdata[0]);
+		g_ptr_array_remove_index_fast (deletes, 0);
+	}
+	g_ptr_array_free (deletes, TRUE);
+
+	if (camel_exception_is_set (ex)) {
+		camel_object_unref (CAMEL_OBJECT (cache));
+		return NULL;
+	}
+
+	return cache;
+}
+
+
+static void
+stream_finalize (CamelObject *stream, gpointer event_data, gpointer user_data)
+{
+	CamelImapMessageCache *cache = user_data;
+	char *key;
+
+	key = g_hash_table_lookup (cache->cached, stream);
+	if (!key)
+		return;
+	g_hash_table_remove (cache->cached, stream);
+	g_hash_table_insert (cache->parts, key, NULL);
+}
+
+CamelStream *
+camel_imap_message_cache_insert (CamelImapMessageCache *cache, const char *uid,
+				 const char *part_spec, const char *data,
+				 int len)
+{
+	char *path, *key;
+	int fd, status;
+	CamelStream *stream;
+
+	path = g_strdup_printf ("%s/%s.%s", cache->path, uid, part_spec);
+	key = strrchr (path, '/') + 1;
+	stream = g_hash_table_lookup (cache->parts, key);
+	if (stream)
+		camel_object_unref (CAMEL_OBJECT (stream));
+
+	fd = open (path, O_RDWR | O_CREAT | O_TRUNC, 0600);
+	if (fd == -1) {
+		g_free (path);
+		return NULL;
+	}
+
+	stream = camel_stream_fs_new_with_fd (fd);
+	status = camel_stream_write (stream, data, len);
+	camel_stream_reset (stream);
+
+	if (status == -1) {
+		unlink (path);
+		g_free (path);
+		camel_object_unref (CAMEL_OBJECT (stream));
+		return NULL;
+	}
+
+	cache_put (cache, uid, key, stream);
+	g_free (path);
+
+	return stream;
+}
+
+CamelStream *
+camel_imap_message_cache_get (CamelImapMessageCache *cache, const char *uid,
+			      const char *part_spec)
+{
+	CamelStream *stream;
+	char *path, *key;
+
+	path = g_strdup_printf ("%s/%s.%s", cache->path, uid, part_spec);
+	key = strrchr (path, '/');
+	stream = g_hash_table_lookup (cache->parts, key);
+	if (stream) {
+		camel_object_ref (CAMEL_OBJECT (stream));
+		return stream;
+	}
+
+	stream = camel_stream_fs_new_with_name (path, O_RDONLY, 0);
+	if (stream)
+		cache_put (cache, uid, key, stream);
+	g_free (path);
+
+	return stream;
+}
+
+void
+camel_imap_message_cache_remove (CamelImapMessageCache *cache, const char *uid)
+{
+	GPtrArray *subparts;
+	char *key, *path;
+	CamelObject *stream;
+	int i;
+
+	subparts = g_hash_table_lookup (cache->parts, uid);
+	if (!subparts)
+		return;
+	for (i = 0; i < subparts->len; i++) {
+		key = subparts->pdata[i];
+		path = g_strdup_printf ("%s/%s", cache->path, key);
+		unlink (path);
+		stream = g_hash_table_lookup (cache->parts, key);
+		if (stream) {
+			camel_object_unhook_event (stream, "finalize",
+						   stream_finalize, cache);
+			camel_object_unref (stream);
+			g_hash_table_remove (cache->cached, stream);
+		}
+		g_hash_table_remove (cache->parts, key);
+		g_free (key);
+	}
+	g_hash_table_remove (cache->parts, uid);
+	g_ptr_array_free (subparts, TRUE);
+}
+
diff --git a/camel/providers/imap/camel-imap-message-cache.h b/camel/providers/imap/camel-imap-message-cache.h
new file mode 100644
index 0000000000..1ac48086ae
--- /dev/null
+++ b/camel/providers/imap/camel-imap-message-cache.h
@@ -0,0 +1,85 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/* camel-imap-message-cache.h: Class for an IMAP message cache */
+
+/* 
+ * Author: 
+ *   Dan Winship <danw@ximian.com>
+ *
+ * Copyright (C) 2001 Ximian, Inc. (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_IMAP_MESSAGE_CACHE_H
+#define CAMEL_IMAP_MESSAGE_CACHE_H 1
+
+
+#ifdef __cplusplus
+extern "C" {
+#pragma }
+#endif /* __cplusplus }*/
+
+#include "camel-imap-types.h"
+#include "camel-folder.h"
+#include <camel/camel-folder-search.h>
+
+#define CAMEL_IMAP_MESSAGE_CACHE_TYPE     (camel_imap_message_cache_get_type ())
+#define CAMEL_IMAP_MESSAGE_CACHE(obj)     (CAMEL_CHECK_CAST((obj), CAMEL_IMAP_MESSAGE_CACHE_TYPE, CamelImapFolder))
+#define CAMEL_IMAP_MESSAGE_CACHE_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_IMAP_MESSAGE_CACHE_TYPE, CamelImapFolderClass))
+#define CAMEL_IS_IMAP_MESSAGE_CACHE(o)    (CAMEL_CHECK_TYPE((o), CAMEL_IMAP_MESSAGE_CACHE_TYPE))
+
+struct _CamelImapMessageCache {
+	CamelObject parent_object;
+
+	char *path;
+	GHashTable *parts, *cached;
+};
+
+
+typedef struct {
+	CamelFolderClass parent_class;
+
+	/* Virtual methods */	
+	
+} CamelImapMessageCacheClass;
+
+
+/* public methods */
+CamelImapMessageCache *camel_imap_message_cache_new (const char *path,
+						     CamelFolderSummary *summ,
+						     CamelException *ex);
+
+CamelStream *camel_imap_message_cache_insert (CamelImapMessageCache *cache,
+					      const char *uid,
+					      const char *part_spec,
+					      const char *data,
+					      int len);
+CamelStream *camel_imap_message_cache_get    (CamelImapMessageCache *cache,
+					      const char *uid,
+					      const char *part_spec);
+void         camel_imap_message_cache_remove (CamelImapMessageCache *cache,
+					      const char *uid);
+
+
+/* Standard Camel function */
+CamelType camel_imap_message_cache_get_type (void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* CAMEL_IMAP_MESSAGE_CACHE_H */
diff --git a/camel/providers/imap/camel-imap-private.h b/camel/providers/imap/camel-imap-private.h
index c7af3ee5e6..811efc5576 100644
--- a/camel/providers/imap/camel-imap-private.h
+++ b/camel/providers/imap/camel-imap-private.h
@@ -54,13 +54,14 @@ struct _CamelImapStorePrivate {
 
 struct _CamelImapFolderPrivate {
 #ifdef ENABLE_THREADS
-	GMutex *search_lock;	/* for locking the search object */
+	EMutex *search_lock;	/* for locking the search object */
+	EMutex *cache_lock;     /* for locking the cache object */
 #endif
 };
 
 #ifdef ENABLE_THREADS
-#define CAMEL_IMAP_FOLDER_LOCK(f, l) (g_mutex_lock(((CamelImapFolder *)f)->priv->l))
-#define CAMEL_IMAP_FOLDER_UNLOCK(f, l) (g_mutex_unlock(((CamelImapFolder *)f)->priv->l))
+#define CAMEL_IMAP_FOLDER_LOCK(f, l) (e_mutex_lock(((CamelImapFolder *)f)->priv->l))
+#define CAMEL_IMAP_FOLDER_UNLOCK(f, l) (e_mutex_unlock(((CamelImapFolder *)f)->priv->l))
 #else
 #define CAMEL_IMAP_FOLDER_LOCK(f, l)
 #define CAMEL_IMAP_FOLDER_UNLOCK(f, l)
diff --git a/camel/providers/imap/camel-imap-store.c b/camel/providers/imap/camel-imap-store.c
index 83f9548bde..44ebea5ebe 100644
--- a/camel/providers/imap/camel-imap-store.c
+++ b/camel/providers/imap/camel-imap-store.c
@@ -32,6 +32,7 @@
 #include <errno.h>
 
 #include <gal/util/e-util.h>
+#include "e-util/e-path.h"
 
 #include "camel-imap-store.h"
 #include "camel-imap-folder.h"
@@ -729,7 +730,7 @@ get_folder (CamelStore *store, const char *folder_name, guint32 flags,
 {
 	CamelImapStore *imap_store = CAMEL_IMAP_STORE (store);
 	CamelFolder *new_folder = NULL;
-	char *short_name, *summary_file, *p;
+	char *short_name, *folder_dir;
 	gboolean selectable;
 
 	if (!camel_remote_store_connected (CAMEL_REMOTE_STORE (store), ex))
@@ -757,22 +758,18 @@ get_folder (CamelStore *store, const char *folder_name, guint32 flags,
 		return NULL;
 	}
 
-	summary_file = g_strdup_printf ("%s/%s/#summary",
-					imap_store->storage_path,
-					folder_name);
-	p = strrchr (summary_file, '/');
-	*p = '\0';
-	if (e_mkdir_hier (summary_file, S_IRWXU) == 0) {
-		*p = '/';
+	folder_dir = e_path_to_physical (imap_store->storage_path,
+					 folder_name);
+	if (e_mkdir_hier (folder_dir, S_IRWXU) == 0) {
 		new_folder = camel_imap_folder_new (store, folder_name,
-						    short_name, summary_file,
+						    short_name, folder_dir,
 						    ex);
 	} else {
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 				      _("Could not create directory %s: %s"),
-				      summary_file, g_strerror (errno));
+				      folder_dir, g_strerror (errno));
 	}
-	g_free (summary_file);
+	g_free (folder_dir);
 	g_free (short_name);
 
 	if (camel_exception_is_set (ex))
diff --git a/camel/providers/imap/camel-imap-types.h b/camel/providers/imap/camel-imap-types.h
index af5d8b8c77..e5d2d18dc1 100644
--- a/camel/providers/imap/camel-imap-types.h
+++ b/camel/providers/imap/camel-imap-types.h
@@ -30,10 +30,11 @@ extern "C" {
 
 #include "camel-types.h"
 
-typedef struct _CamelImapResponse CamelImapResponse;
-typedef struct _CamelImapFolder   CamelImapFolder;
-typedef struct _CamelImapSearch   CamelImapSearch;
-typedef struct _CamelImapStore    CamelImapStore;
-typedef struct _CamelImapSummary  CamelImapSummary;
+typedef struct _CamelImapFolder       CamelImapFolder;
+typedef struct _CamelImapMessageCache CamelImapMessageCache;
+typedef struct _CamelImapResponse     CamelImapResponse;
+typedef struct _CamelImapSearch       CamelImapSearch;
+typedef struct _CamelImapStore        CamelImapStore;
+typedef struct _CamelImapSummary      CamelImapSummary;
 
 #endif /* CAMEL_IMAP_TYPES_H */
diff --git a/camel/providers/imap/camel-imap-utils.c b/camel/providers/imap/camel-imap-utils.c
index 8116f12386..1ec8e79eaf 100644
--- a/camel/providers/imap/camel-imap-utils.c
+++ b/camel/providers/imap/camel-imap-utils.c
@@ -337,13 +337,13 @@ skip_asn (char **str_p)
 	}
 }
 
-static void
-skip_list (char **str_p)
+void
+imap_skip_list (char **str_p)
 {
 	skip_char (str_p, '(');
 	while (*str_p && **str_p != ')') {
 		if (**str_p == '(')
-			skip_list (str_p);
+			imap_skip_list (str_p);
 		else
 			skip_asn (str_p);
 		if (*str_p && **str_p == ' ')
@@ -495,7 +495,7 @@ imap_parse_body (char **body_p, CamelFolder *folder,
 		child = NULL;
 		if (header_content_type_is (type, "message", "rfc822")) {
 			skip_char (&body, ' ');
-			skip_list (&body); /* envelope */
+			imap_skip_list (&body); /* envelope */
 			skip_char (&body, ' ');
 			child = camel_folder_summary_content_info_new (folder->summary);
 			imap_parse_body (&body, folder, child);
diff --git a/camel/providers/imap/camel-imap-utils.h b/camel/providers/imap/camel-imap-utils.h
index 985f177b3a..77bc51f9bc 100644
--- a/camel/providers/imap/camel-imap-utils.h
+++ b/camel/providers/imap/camel-imap-utils.h
@@ -55,6 +55,8 @@ void imap_parse_body (char **body_p, CamelFolder *folder,
 
 char *imap_quote_string (const char *str);
 
+void imap_skip_list (char **str_p);
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/camel/providers/imap/camel-imap-wrapper.c b/camel/providers/imap/camel-imap-wrapper.c
index e4d06a009b..a0e8b963fc 100644
--- a/camel/providers/imap/camel-imap-wrapper.c
+++ b/camel/providers/imap/camel-imap-wrapper.c
@@ -24,14 +24,10 @@
 
 #include <config.h>
 
+#include "camel-imap-folder.h"
 #include "camel-imap-wrapper.h"
-#include "camel-imap-command.h"
-#include "camel-imap-store.h"
-#include "camel-imap-utils.h"
 #include "camel-imap-private.h"
 #include "camel-exception.h"
-#include "camel-folder.h"
-#include "camel-stream-mem.h"
 #include "camel-stream-filter.h"
 #include "camel-mime-filter-basic.h"
 #include "camel-mime-filter-crlf.h"
@@ -109,54 +105,15 @@ camel_imap_wrapper_get_type (void)
 }
 
 
-static int
-write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream)
+static void
+imap_wrapper_hydrate (CamelImapWrapper *imap_wrapper, CamelStream *stream)
 {
-	CamelImapWrapper *imap_wrapper = CAMEL_IMAP_WRAPPER (data_wrapper);
-	CamelImapStore *store;
-	CamelImapResponse *response;
-	CamelStream *memstream;
+	CamelDataWrapper *data_wrapper = CAMEL_DATA_WRAPPER (imap_wrapper);
 	CamelStreamFilter *filterstream;
 	CamelMimeFilter *filter;
 	CamelContentType *ct;
-	char *result, *p, *body;
-	int len;
 
-	CAMEL_IMAP_WRAPPER_LOCK (imap_wrapper, lock);
-	if (!data_wrapper->offline) {
-		CAMEL_IMAP_WRAPPER_UNLOCK (imap_wrapper, lock);
-		return parent_class->write_to_stream (data_wrapper, stream);
-	}
-
-	store = CAMEL_IMAP_STORE (imap_wrapper->folder->parent_store);
-	CAMEL_IMAP_STORE_LOCK (store, command_lock);
-	response = camel_imap_command (store, imap_wrapper->folder, NULL,
-				       "UID FETCH %s BODY.PEEK[%s]",
-				       imap_wrapper->uid,
-				       imap_wrapper->part_spec);
-	CAMEL_IMAP_STORE_UNLOCK (store, command_lock);
-	if (!response)
-		goto lose;
-
-	result = camel_imap_response_extract (response, "FETCH", NULL);
-	if (!result)
-		goto lose;
-
-	p = strchr (result, ']');
-	if (!p) {
-		g_free (result);
-		goto lose;
-	}
-	p += 2;
-
-	body = imap_parse_nstring (&p, &len);
-	g_free (result);
-	if (!body)
-		goto lose;
-
-	memstream = camel_stream_mem_new_with_buffer (body, len);
-	g_free (body);
-	filterstream = camel_stream_filter_new_with_stream (memstream);
+	filterstream = camel_stream_filter_new_with_stream (stream);
 
 	if (camel_mime_part_get_encoding (imap_wrapper->part) ==
 	    CAMEL_MIME_PART_ENCODING_BASE64) {
@@ -198,37 +155,64 @@ write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream)
 	imap_wrapper->uid = NULL;
 	g_free (imap_wrapper->part_spec);
 	imap_wrapper->part = NULL;
+}
 
-	CAMEL_IMAP_WRAPPER_UNLOCK (imap_wrapper, lock);
 
-	return parent_class->write_to_stream (data_wrapper, stream);
+static int
+write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream)
+{
+	CamelImapWrapper *imap_wrapper = CAMEL_IMAP_WRAPPER (data_wrapper);
+
+	CAMEL_IMAP_WRAPPER_LOCK (imap_wrapper, lock);
+	if (data_wrapper->offline) {
+		CamelStream *datastream;
+
+		datastream = camel_imap_folder_fetch_data (
+			imap_wrapper->folder, imap_wrapper->uid,
+			imap_wrapper->part_spec, FALSE, NULL);
+		if (!datastream) {
+			CAMEL_IMAP_WRAPPER_UNLOCK (imap_wrapper, lock);
+			errno = ENETUNREACH;
+			return -1;
+		}
 
- lose:
+		imap_wrapper_hydrate (imap_wrapper, datastream);
+		camel_object_unref (CAMEL_OBJECT (datastream));
+	}
 	CAMEL_IMAP_WRAPPER_UNLOCK (imap_wrapper, lock);
-	errno = ENETUNREACH;
-	return -1;
+
+	return parent_class->write_to_stream (data_wrapper, stream);
 }
 
 
 CamelDataWrapper *
-camel_imap_wrapper_new (CamelFolder *folder, CamelContentType *type,
+camel_imap_wrapper_new (CamelImapFolder *imap_folder, CamelContentType *type,
 			const char *uid, const char *part_spec,
 			CamelMimePart *part)
 {
 	CamelImapWrapper *imap_wrapper;
+	CamelStream *stream;
 
 	imap_wrapper = (CamelImapWrapper *)camel_object_new(camel_imap_wrapper_get_type());
 
 	camel_data_wrapper_set_mime_type_field (CAMEL_DATA_WRAPPER (imap_wrapper), type);
 	((CamelDataWrapper *)imap_wrapper)->offline = TRUE;
 
-	imap_wrapper->folder = folder;
-	camel_object_ref (CAMEL_OBJECT (folder));
+	imap_wrapper->folder = imap_folder;
+	camel_object_ref (CAMEL_OBJECT (imap_folder));
 	imap_wrapper->uid = g_strdup (uid);
 	imap_wrapper->part_spec = g_strdup (part_spec);
 
 	/* Don't ref this, it's our parent. */
 	imap_wrapper->part = part;
 
+	/* Try the cache. */
+	stream = camel_imap_folder_fetch_data (imap_folder, uid, part_spec,
+					       TRUE, NULL);
+	if (stream) {
+		imap_wrapper_hydrate (imap_wrapper, stream);
+		camel_object_unref (CAMEL_OBJECT (stream));
+	}
+
 	return (CamelDataWrapper *)imap_wrapper;
 }
diff --git a/camel/providers/imap/camel-imap-wrapper.h b/camel/providers/imap/camel-imap-wrapper.h
index 8eb9d0969a..38bfd62fe2 100644
--- a/camel/providers/imap/camel-imap-wrapper.h
+++ b/camel/providers/imap/camel-imap-wrapper.h
@@ -31,6 +31,7 @@ extern "C" {
 #endif /* __cplusplus }*/
 
 #include <camel/camel-data-wrapper.h>
+#include "camel-imap-types.h"
 
 #define CAMEL_IMAP_WRAPPER_TYPE     (camel_imap_wrapper_get_type ())
 #define CAMEL_IMAP_WRAPPER(obj)     (CAMEL_CHECK_CAST((obj), CAMEL_IMAP_WRAPPER_TYPE, CamelImapWrapper))
@@ -43,7 +44,7 @@ typedef struct
 
 	struct _CamelImapWrapperPrivate *priv;
 
-	CamelFolder *folder;
+	CamelImapFolder *folder;
 	char *uid, *part_spec;
 	CamelMimePart *part;
 } CamelImapWrapper;
@@ -57,7 +58,7 @@ typedef struct {
 CamelType camel_imap_wrapper_get_type (void);
 
 /* Constructor */
-CamelDataWrapper *camel_imap_wrapper_new (CamelFolder *folder,
+CamelDataWrapper *camel_imap_wrapper_new (CamelImapFolder *imap_folder,
 					  CamelContentType *type,
 					  const char *uid,
 					  const char *part_spec,