No, we're not going to have g_strcasecmp for no good reason,

not even if its slipped in with no changelog.

2000-05-04  NotZed  <NotZed@HelixCode.com>

	* providers/mbox/camel-mbox-summary.c: Yes, and anotherone.

	* camel-mime-utils.c: And another one.

	* camel-mime-part.c: And another one.

	* camel-mime-part-utils.c: And another one.

	* camel-folder-search.c: And another one.

	* camel-mime-parser.c: Reverted a change wihtout a ChangeLog entry.

2000-05-04  NotZed  <NotZed@HelixCode.com>

	* camel-folder-summary.[hc]: Yes, CamelFolderSummary is back ...
	... re-usable class to summarise and index any stream or message
	and to manage/load/save the created summaries.

	* camel-folder.c: Include string.h to kill a warning.

2000-05-03  NotZed  <NotZed@HelixCode.com>

	* camel-folder.h: Added pos/bodypos/endpos to the basic message
	content info object.  Size to be removed?  Moved the
	messageconentinfo and messageinfo back to camel-folder-summary.h.

	* camel-mime-filter-index.c (camel_mime_filter_index_set_ibex):
	New function to (re)set the index to use on a filter.

	* camel-mime-parser.c (camel_mime_parser_scan_from): Whole bunch
	of inline docs.
	(camel_mime_parser_drop_step): New function to drop a state from
	the parser.  Needs more testing.

svn path=/trunk/; revision=2789

15 files changed, 1597 insertions, 47 deletions

diff --git a/camel/ChangeLog b/camel/ChangeLog
index 39846f46ca..5a655a3aa7 100644
--- a/camel/ChangeLog
+++ b/camel/ChangeLog
@@ -1,3 +1,25 @@
+2000-05-04  NotZed  <NotZed@HelixCode.com>
+
+	* providers/mbox/camel-mbox-summary.c: Yes, and anotherone.
+
+	* camel-mime-utils.c: And another one.
+
+	* camel-mime-part.c: And another one.
+
+	* camel-mime-part-utils.c: And another one.
+
+	* camel-folder-search.c: And another one.
+
+	* camel-mime-parser.c: Reverted a change wihtout a ChangeLog entry.
+
+2000-05-04  NotZed  <NotZed@HelixCode.com>
+
+	* camel-folder-summary.[hc]: Yes, CamelFolderSummary is back ...
+	... re-usable class to summarise and index any stream or message
+	and to manage/load/save the created summaries.
+	
+	* camel-folder.c: Include string.h to kill a warning.
+
 2000-05-03  Jason Leach  <leach@wam.umd.edu>
 
 	* Makefile.am (INCLUDES): add $(UNICODE_CFLAGS) to the INCLUDES,
@@ -6,6 +28,18 @@
 
 2000-05-03  NotZed  <NotZed@HelixCode.com>
 
+	* camel-folder.h: Added pos/bodypos/endpos to the basic message
+	content info object.  Size to be removed?  Moved the
+	messageconentinfo and messageinfo back to camel-folder-summary.h.
+
+	* camel-mime-filter-index.c (camel_mime_filter_index_set_ibex):
+	New function to (re)set the index to use on a filter.
+
+	* camel-mime-parser.c (camel_mime_parser_scan_from): Whole bunch
+	of inline docs.
+	(camel_mime_parser_drop_step): New function to drop a state from
+	the parser.  Needs more testing.
+
 	* camel-mime-utils.c (rfc2047_decode_word): If the iconv handle is
 	-1, then dont try and convert (crashes unicode_iconv?).
 	(rfc2047_decode_word): Use alloca for variables instead of
diff --git a/camel/Makefile.am b/camel/Makefile.am
index 81914c5950..513cd25648 100644
--- a/camel/Makefile.am
+++ b/camel/Makefile.am
@@ -38,6 +38,7 @@ libcamel_la_SOURCES = 				\
 	camel-exception.c			\
 	camel-folder.c				\
 	camel-folder-search.c			\
+	camel-folder-summary.c			\
 	camel-medium.c				\
 	camel-marshal-utils.c			\
 	camel-mime-message.c			\
@@ -81,6 +82,7 @@ libcamelinclude_HEADERS =			\
 	camel-exception.h			\
 	camel-folder.h				\
 	camel-folder-search.h			\
+	camel-folder-summary.h			\
 	camel-marshal-utils.h			\
 	camel-medium.h				\
 	camel-mime-message.h			\
diff --git a/camel/camel-folder-search.c b/camel/camel-folder-search.c
index 9d6f80d256..8a58d9a6ef 100644
--- a/camel/camel-folder-search.c
+++ b/camel/camel-folder-search.c
@@ -358,15 +358,15 @@ search_header_contains(struct _ESExp *f, int argc, struct _ESExpResult **argv, C
 
 		/* only a subset of headers are supported .. */
 		headername = argv[0]->value.string;
-		if (!g_strcasecmp(headername, "subject")) {
+		if (!strcasecmp(headername, "subject")) {
 			header = search->current->subject;
-		} else if (!g_strcasecmp(headername, "date")) {
+		} else if (!strcasecmp(headername, "date")) {
 			/* FIXME: not a very useful form of the date */
 			sprintf(strbuf, "%d", (int)search->current->date_sent);
 			header = strbuf;
-		} else if (!g_strcasecmp(headername, "from")) {
+		} else if (!strcasecmp(headername, "from")) {
 			header = search->current->from;
-		} else if (!g_strcasecmp(headername, "to")) {
+		} else if (!strcasecmp(headername, "to")) {
 			header = search->current->from;
 		} else {
 			g_warning("Performing query on unknown header: %s", headername);
diff --git a/camel/camel-folder-summary.c b/camel/camel-folder-summary.c
new file mode 100644
index 0000000000..c54100375f
--- /dev/null
+++ b/camel/camel-folder-summary.c
@@ -0,0 +1,1041 @@
+/*
+ *  Copyright (C) 2000 Helix Code Inc.
+ *
+ *  Authors: Michael Zucchi <notzed@helixcode.com>
+ *
+ *  This program is free software; you can redistribute it and/or 
+ *  modify it under the terms of the GNU General Public License as 
+ *  published by the Free Software Foundation; either version 2 of the
+ *  License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ *  USA
+ */
+
+#include <unistd.h>
+#include <netinet/in.h>
+#include <ctype.h>
+#include <string.h>
+
+#include "camel-folder-summary.h"
+
+#include <camel/camel-mime-filter.h>
+#include <camel/camel-mime-filter-index.h>
+#include <camel/camel-mime-filter-charset.h>
+#include <camel/camel-mime-filter-save.h>
+#include <camel/camel-mime-filter-basic.h>
+#include "hash-table-utils.h"
+
+#define d(x)
+
+#define CAMEL_FOLDER_SUMMARY_VERSION (3)
+
+struct _CamelFolderSummaryPrivate {
+	GHashTable *filter_charset;	/* CamelMimeFilterCharset's indexed by source charset */
+
+	CamelMimeFilterIndex *filter_index;
+	CamelMimeFilterBasic *filter_64;
+	CamelMimeFilterBasic *filter_qp;
+	CamelMimeFilterSave *filter_save;
+
+	ibex *index;
+};
+
+#define _PRIVATE(o) (((CamelFolderSummary *)(o))->priv)
+
+/* trivial lists, just because ... */
+struct _node {
+	struct _node *next;
+};
+
+static struct _node *my_list_append(struct _node **list, struct _node *n);
+static int my_list_size(struct _node **list);
+
+static int summary_header_load(CamelFolderSummary *, FILE *);
+static int summary_header_save(CamelFolderSummary *, FILE *);
+
+static CamelMessageInfo * message_info_new(CamelFolderSummary *, struct _header_raw *);
+static CamelMessageInfo * message_info_new_from_parser(CamelFolderSummary *, CamelMimeParser *);
+static CamelMessageInfo * message_info_load(CamelFolderSummary *, FILE *);
+static int		  message_info_save(CamelFolderSummary *, FILE *, CamelMessageInfo *);
+static void		  message_info_free(CamelFolderSummary *, CamelMessageInfo *);
+
+static CamelMessageContentInfo * content_info_new(CamelFolderSummary *, struct _header_raw *);
+static CamelMessageContentInfo * content_info_new_from_parser(CamelFolderSummary *, CamelMimeParser *);
+static CamelMessageContentInfo * content_info_load(CamelFolderSummary *, FILE *);
+static int		         content_info_save(CamelFolderSummary *, FILE *, CamelMessageContentInfo *);
+static void		         content_info_free(CamelFolderSummary *, CamelMessageContentInfo *);
+
+static CamelMessageContentInfo * summary_build_content_info(CamelFolderSummary *s, CamelMimeParser *mp);
+
+static void camel_folder_summary_class_init (CamelFolderSummaryClass *klass);
+static void camel_folder_summary_init       (CamelFolderSummary *obj);
+static void camel_folder_summary_finalise   (GtkObject *obj);
+
+static GtkObjectClass *camel_folder_summary_parent;
+
+enum SIGNALS {
+	LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+guint
+camel_folder_summary_get_type (void)
+{
+	static guint type = 0;
+	
+	if (!type) {
+		GtkTypeInfo type_info = {
+			"CamelFolderSummary",
+			sizeof (CamelFolderSummary),
+			sizeof (CamelFolderSummaryClass),
+			(GtkClassInitFunc) camel_folder_summary_class_init,
+			(GtkObjectInitFunc) camel_folder_summary_init,
+			(GtkArgSetFunc) NULL,
+			(GtkArgGetFunc) NULL
+		};
+		
+		type = gtk_type_unique (gtk_object_get_type (), &type_info);
+	}
+	
+	return type;
+}
+
+static void
+camel_folder_summary_class_init (CamelFolderSummaryClass *klass)
+{
+	GtkObjectClass *object_class = (GtkObjectClass *) klass;
+	
+	camel_folder_summary_parent = gtk_type_class (gtk_object_get_type ());
+
+	object_class->finalize = camel_folder_summary_finalise;
+
+	klass->summary_header_load = summary_header_load;
+	klass->summary_header_save = summary_header_save;
+
+	klass->message_info_new  = message_info_new;
+	klass->message_info_new_from_parser = message_info_new_from_parser;
+	klass->message_info_load = message_info_load;
+	klass->message_info_save = message_info_save;
+	klass->message_info_free = message_info_free;
+
+	klass->content_info_new  = content_info_new;
+	klass->content_info_new_from_parser = content_info_new_from_parser;
+	klass->content_info_load = content_info_load;
+	klass->content_info_save = content_info_save;
+	klass->content_info_free = content_info_free;
+
+	gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL);
+}
+
+static void
+camel_folder_summary_init (CamelFolderSummary *s)
+{
+	struct _CamelFolderSummaryPrivate *p;
+
+	p = _PRIVATE(s) = g_malloc0(sizeof(*p));
+
+	p->filter_charset = g_hash_table_new(g_strcase_hash, g_strcase_equal);
+
+	s->message_info_size = sizeof(CamelMessageInfo);
+	s->content_info_size = sizeof(CamelMessageContentInfo);
+
+	s->version = CAMEL_FOLDER_SUMMARY_VERSION;
+	s->flags = 0;
+	s->time = 0;
+	s->nextuid = 1;
+
+	s->messages = g_ptr_array_new();
+	s->messages_uid = g_hash_table_new(g_str_hash, g_str_equal);
+}
+
+static void
+camel_folder_summary_finalise (GtkObject *obj)
+{
+	struct _CamelFolderSummaryPrivate *p;
+	CamelFolderSummary *s = (CamelFolderSummary *)obj;
+
+	p = _PRIVATE(obj);
+
+	/* FIXME: free contents */
+	g_ptr_array_free(s->messages, TRUE);
+
+	g_hash_table_destroy(s->messages_uid);
+
+	/* FIXME: free contents */
+	g_hash_table_destroy(p->filter_charset);
+	g_free(p);
+
+	((GtkObjectClass *)(camel_folder_summary_parent))->finalize((GtkObject *)obj);
+}
+
+/**
+ * camel_folder_summary_new:
+ *
+ * Create a new CamelFolderSummary object.
+ * 
+ * Return value: A new CamelFolderSummary widget.
+ **/
+CamelFolderSummary *
+camel_folder_summary_new (void)
+{
+	CamelFolderSummary *new = CAMEL_FOLDER_SUMMARY ( gtk_type_new (camel_folder_summary_get_type ()));
+	return new;
+}
+
+
+void camel_folder_summary_set_filename(CamelFolderSummary *s, const char *name)
+{
+	g_free(s->summary_path);
+	s->summary_path = g_strdup(name);
+}
+
+void camel_folder_summary_set_index(CamelFolderSummary *s, ibex *index)
+{
+	struct _CamelFolderSummaryPrivate *p = _PRIVATE(s);
+
+	if (p->index)
+		ibex_write(p->index);
+	p->index = index;
+}
+
+void camel_folder_summary_set_build_content(CamelFolderSummary *s, gboolean state)
+{
+	s->build_content = state;
+}
+
+int
+camel_folder_summary_count(CamelFolderSummary *s)
+{
+	return s->messages->len;
+}
+
+CamelMessageInfo *
+camel_folder_summary_index(CamelFolderSummary *s, int i)
+{
+	if (i<s->messages->len)
+		return g_ptr_array_index(s->messages, i);
+	return NULL;
+}
+
+CamelMessageInfo *
+camel_folder_summary_uid(CamelFolderSummary *s, const char *uid)
+{
+	return g_hash_table_lookup(s->messages_uid, uid);
+}
+
+void
+camel_folder_summary_set_uid(CamelFolderSummary *s, guint32 base)
+{
+	if (s->nextuid <= base)
+		s->nextuid = base+1;
+}
+
+guint32 camel_folder_summary_next_uid(CamelFolderSummary *s)
+{
+	guint32 uid = s->nextuid++;
+
+	/* FIXME: sync this to disk */
+/*	summary_header_save(s);*/
+	return uid;
+}
+
+/* loads the content descriptions, recursively */
+static CamelMessageContentInfo *
+perform_content_info_load(CamelFolderSummary *s, FILE *in)
+{
+	int i;
+	guint32 count;
+	CamelMessageContentInfo *ci, *part;
+
+	ci = ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->content_info_load(s, in);
+	camel_folder_summary_decode_uint32(in, &count);
+	for (i=0;i<count;i++) {
+		part = perform_content_info_load(s, in);
+		if (part) {
+			my_list_append((struct _node **)&ci->childs, (struct _node *)ci);
+			ci->parent = ci;
+		} else {
+			g_warning("Summary file format messed up?");
+		}
+	}
+	return ci;
+}
+
+int
+camel_folder_summary_load(CamelFolderSummary *s)
+{
+	FILE *in;
+	int i;
+	CamelMessageInfo *mi;
+
+	g_assert(s->summary_path);
+
+	in = fopen(s->summary_path, "r");
+	if ( in == NULL ) {
+		return -1;
+	}
+
+	if ( ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->summary_header_load(s, in) == -1) {
+		fclose(in);
+		return -1;
+	}
+
+	/* now read in each message ... */
+	/* FIXME: check returns */
+	for (i=0;i<s->saved_count;i++) {
+		mi = ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->message_info_load(s, in);
+
+		if (s->build_content) {
+			mi->content = content_info_load(s, in);
+		}
+	}
+
+	/* FIXME: check error return */
+	return 0;
+}
+
+/* saves the content descriptions, recursively */
+static int
+perform_content_info_save(CamelFolderSummary *s, FILE *out, CamelMessageContentInfo *ci)
+{
+	CamelMessageContentInfo *part;
+
+	((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->content_info_save(s, out, ci);
+	camel_folder_summary_encode_uint32(out, my_list_size((struct _node **)&ci->childs));
+	part = ci->childs;
+	while (part) {
+		perform_content_info_save(s, out, part);
+		part = part->next;
+	}
+	return 0;
+}
+
+int
+camel_folder_summary_save(CamelFolderSummary *s)
+{
+	FILE *out;
+	int fd;
+	int i;
+	guint32 count;
+	CamelMessageInfo *mi;
+
+	g_assert(s->summary_path);
+
+	fd = open(s->summary_path, O_RDWR|O_CREAT, 0600);
+	if (fd == -1)
+		return -1;
+	out = fdopen(fd, "w");
+	if ( out == NULL ) {
+		close(fd);
+		return -1;
+	}
+
+	if ( ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->summary_header_save(s, out) == -1) {
+		fclose(out);
+		return -1;
+	}
+
+	/* now write out each message ... */
+	/* FIXME: check returns */
+	count = camel_folder_summary_count(s);
+	for (i=0;i<count;i++) {
+		mi = camel_folder_summary_index(s, i);
+		((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->message_info_save(s, out, mi);
+
+		if (s->build_content) {
+			perform_content_info_save(s, out, mi->content);
+		}
+	}
+	return fclose(out);
+}
+
+void camel_folder_summary_add(CamelFolderSummary *s, CamelMessageInfo *info)
+{
+	if (info == NULL)
+		return;
+retry:
+	if (info->uid == NULL) {
+		info->uid = g_strdup_printf("%u", s->nextuid++);
+	}
+	if (g_hash_table_lookup(s->messages_uid, info->uid)) {
+		g_warning("Trying to insert message with clashing uid.  new uid re-assigned");
+		g_free(info->uid);
+		info->uid = NULL;
+		goto retry;
+	}
+
+	g_ptr_array_add(s->messages, info);
+	g_hash_table_insert(s->messages_uid, info->uid, info);
+	s->flags |= CAMEL_SUMMARY_DIRTY;
+}
+
+void camel_folder_summary_add_from_header(CamelFolderSummary *s, struct _header_raw *h)
+{
+	CamelMessageInfo *info;
+
+	info = ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->message_info_new(s, h);
+	camel_folder_summary_add(s, info);
+}
+
+void camel_folder_summary_add_from_parser(CamelFolderSummary *s, CamelMimeParser *mp)
+{
+	CamelMessageInfo *info;
+	char *buffer;
+	int len;
+	struct _CamelFolderSummaryPrivate *p = _PRIVATE(s);
+
+	/* should this check the parser is in the right state, or assume it is?? */
+
+	if (camel_mime_parser_step(mp, &buffer, &len) != HSCAN_EOF) {
+		info = ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->message_info_new_from_parser(s, mp);
+
+		camel_mime_parser_unstep(mp);
+
+		/* FIXME: better uid assignment method? */
+		if (info->uid == NULL) {
+			info->uid = g_strdup_printf("%u", s->nextuid++);
+		}
+
+		if (p->index) {
+			if (p->filter_index == NULL)
+				p->filter_index = camel_mime_filter_index_new_ibex(p->index);
+			camel_mime_filter_index_set_name(p->filter_index, info->uid);
+			ibex_unindex(p->index, info->uid);
+		}
+
+		/* build the content info, if we're supposed to */
+		if (s->build_content) {
+			info->content = summary_build_content_info(s, mp);
+			if (info->content->pos != -1)
+				info->size = info->content->endpos - info->content->pos;
+		} else {
+			camel_mime_parser_drop_step(mp);
+		}
+
+		camel_folder_summary_add(s, info);
+	}
+}
+
+int
+camel_folder_summary_encode_uint32(FILE *out, guint32 value)
+{
+	int i;
+
+	for (i=28;i>0;i-=7) {
+		if (value >= (1<<i)) {
+			unsigned int c = (value>>i) & 0x7f;
+			if (fputc(c, out) == -1)
+				return -1;
+		}
+	}
+	return fputc(value | 0x80, out);
+}
+
+int
+camel_folder_summary_decode_uint32(FILE *in, guint32 *dest)
+{
+        gint32 value=0, v;
+
+        /* until we get the last byte, keep decoding 7 bits at a time */
+        while ( ((v = fgetc(in)) & 0x80) == 0 && v!=EOF) {
+                value |= v;
+                value <<= 7;
+        }
+	if (v == EOF) {
+		*dest = value>>7;
+		return 01;
+	}
+	*dest = value | (v&0x7f);
+        return 0;
+}
+
+int
+camel_folder_summary_encode_fixed_int32(FILE *out, gint32 value)
+{
+	guint32 save;
+
+	save = htonl(value);
+	return fwrite(&save, sizeof(save), 1, out);
+}
+
+int
+camel_folder_summary_decode_fixed_int32(FILE *in, gint32 *dest)
+{
+	guint32 save;
+
+	if (fread(&save, sizeof(save), 1, in) != -1) {
+		*dest = ntohl(save);
+		return 0;
+	} else {
+		return -1;
+	}
+}
+
+/* should be sorted, for binary search */
+/* This is a tokenisation mechanism for strings written to the
+   summary - to save space.
+   This list can have at most 31 words. */
+static char * tokens[] = {
+	"7bit",
+	"8bit",
+	"alternative",
+	"application",
+	"base64",
+	"boundary",
+	"charset",
+	"filename",
+	"html",
+	"image",
+	"iso-8859-1",
+	"iso-8859-8",
+	"message",
+	"mixed",
+	"multipart",
+	"name",
+	"octet-stream",
+	"parallel",
+	"plain",
+	"quoted-printable",
+	"rfc822",
+	"text",
+	"us-ascii",		/* 23 words */
+};
+
+#define tokens_len (sizeof(tokens)/sizeof(tokens[0]))
+
+/* baiscally ...
+    0 = null
+    1-tokens_len == tokens[id-1]
+    >=32 string, length = n-32
+*/
+
+int
+camel_folder_summary_encode_token(FILE *out, char *str)
+{
+	if (str == NULL) {
+		return camel_folder_summary_encode_uint32(out, 0);
+	} else {
+		int len = strlen(str);
+		int i, token=-1;
+
+		if (len <= 16) {
+			char lower[32];
+
+			for (i=0;i<len;i++)
+				lower[i] = tolower(str[i]);
+			lower[i] = 0;
+			for (i=0;i<tokens_len;i++) {
+				if (!strcmp(tokens[i], lower)) {
+					token = i;
+					break;
+				}
+			}
+		}
+		if (token != -1) {
+			return camel_folder_summary_encode_uint32(out, token+1);
+		} else {
+			if (camel_folder_summary_encode_uint32(out, len+32) == -1)
+				return -1;
+			return fwrite(str, len, 1, out);
+		}
+	}
+	return 0;
+}
+
+int
+camel_folder_summary_decode_token(FILE *in, char **str)
+{
+	char *ret;
+	int len;
+	
+	if (camel_folder_summary_decode_uint32(in, &len) == -1) {
+		*str = NULL;
+		return -1;
+	}
+
+	if (len<32) {
+		if (len <= 0) {
+			ret = NULL;
+		} else if (len<= tokens_len) {
+			ret = g_strdup(tokens[len-1]);
+		} else {
+			g_warning("Invalid token encountered: %d", len);
+			*str = NULL;
+			return -1;
+		}
+	} else if (len > 10240) {
+		g_warning("Got broken string header length: %d bytes", len);
+		*str = NULL;
+		return -1;
+	} else {
+		len -= 32;
+		ret = g_malloc(len+1);
+		if (fread(ret, len, 1, in) == -1) {
+			g_free(ret);
+			*str = NULL;
+			return -1;
+		}
+		ret[len]=0;
+	}
+
+	*str = ret;
+	return 0;
+}
+
+int
+camel_folder_summary_encode_string(FILE *out, char *str)
+{
+	register int len;
+
+	if (str == NULL)
+		return camel_folder_summary_encode_uint32(out, 0);
+
+	len = strlen(str);
+	if (camel_folder_summary_encode_uint32(out, len+1) == -1)
+		return -1;
+	return fwrite(str, len, 1, out);	
+}
+
+
+int
+camel_folder_summary_decode_string(FILE *in, char **str)
+{
+	int len;
+	register char *ret;
+
+	if (camel_folder_summary_decode_uint32(in, &len) == -1) {
+		*str = NULL;
+		return -1;
+	}
+
+	len--;
+	if (len < 0) {
+		*str = NULL;
+		return -1;
+	}
+
+	ret = g_malloc(len+1);
+	if (fread(ret, len, 1, in) == -1) {
+		g_free(ret);
+		*str = NULL;
+		return -1;
+	}
+
+	ret[len] = 0;
+	*str = ret;
+	return 0;
+}
+
+void
+camel_folder_summary_offset_content(CamelMessageContentInfo *content, off_t offset)
+{
+	content->pos += offset;
+	content->bodypos += offset;
+	content->endpos += offset;
+	content = content->childs;
+	while (content) {
+		camel_folder_summary_offset_content(content, offset);
+		content = content->next;
+	}
+}
+
+static struct _node *
+my_list_append(struct _node **list, struct _node *n)
+{
+	struct _node *ln = (struct _node *)list;
+	while (ln->next)
+		ln = ln->next;
+	n->next = 0;
+	ln->next = n;
+	return n;
+}
+
+static int
+my_list_size(struct _node **list)
+{
+	int len = 0;
+	struct _node *ln = (struct _node *)list;
+	while (ln->next) {
+		ln = ln->next;
+		len++;
+	}
+	return len;
+}
+
+static int
+summary_header_load(CamelFolderSummary *s, FILE *in)
+{
+	guint32 version, flags, nextuid, count;
+	time_t time;
+
+	fseek(in, 0, SEEK_SET);
+
+	if (camel_folder_summary_decode_fixed_int32(in, &version) == -1
+	    || camel_folder_summary_decode_fixed_int32(in, &flags) == -1
+	    || camel_folder_summary_decode_fixed_int32(in, &nextuid) == -1
+	    || camel_folder_summary_decode_fixed_int32(in, &time) == -1	/* TODO: yes i know this warns, to be fixed later */
+	    || camel_folder_summary_decode_fixed_int32(in, &count) == -1) {
+		return -1;
+	}
+
+	s->nextuid = nextuid;
+	s->flags = flags;
+	s->time = time;
+	s->saved_count = count;
+	if (s->version != version) {
+		g_warning("Summary header version mismatch");
+		return -1;
+	}
+	return 0;
+}
+
+static int
+summary_header_save(CamelFolderSummary *s, FILE *out)
+{
+	fseek(out, 0, SEEK_SET);
+
+	camel_folder_summary_encode_fixed_int32(out, s->version);
+	camel_folder_summary_encode_fixed_int32(out, s->flags);
+	camel_folder_summary_encode_fixed_int32(out, s->nextuid);
+	camel_folder_summary_encode_fixed_int32(out, s->time);
+	return camel_folder_summary_encode_fixed_int32(out, camel_folder_summary_count(s));
+}
+
+/* are these even useful for anything??? */
+static CamelMessageInfo * message_info_new_from_parser(CamelFolderSummary *s, CamelMimeParser *mp)
+{
+	CamelMessageInfo *mi = NULL;
+	int state;
+
+	state = camel_mime_parser_state(mp);
+	switch (state) {
+	case HSCAN_HEADER:
+	case HSCAN_MESSAGE:
+	case HSCAN_MULTIPART:
+		mi = ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->message_info_new(s, camel_mime_parser_headers_raw(mp));
+		break;
+	default:
+		g_error("Invalid parser state");
+	}
+
+	return mi;
+}
+
+static CamelMessageContentInfo * content_info_new_from_parser(CamelFolderSummary *s, CamelMimeParser *mp)
+{
+	CamelMessageContentInfo *ci = NULL;
+
+	switch (camel_mime_parser_state(mp)) {
+	case HSCAN_HEADER:
+	case HSCAN_MESSAGE:
+	case HSCAN_MULTIPART:
+		ci = ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->content_info_new(s, camel_mime_parser_headers_raw(mp));
+		if (ci) {
+			ci->type = camel_mime_parser_content_type(mp);
+			header_content_type_ref(ci->type);
+		}
+		break;
+	default:
+		g_error("Invalid parser state");
+	}
+
+	return ci;
+}
+
+static char *
+summary_format_address(struct _header_raw *h, const char *name)
+{
+	struct _header_address *addr;
+	const char *text;
+	char *ret;
+
+	text = header_raw_find(&h, name, NULL);
+	addr = header_address_decode(text);
+	if (addr) {
+		ret = header_address_list_format(addr);
+		header_address_list_clear(&addr);
+	} else {
+		ret = g_strdup(text);
+	}
+	return ret;
+}
+
+static CamelMessageInfo *
+message_info_new(CamelFolderSummary *s, struct _header_raw *h)
+{
+	CamelMessageInfo *mi;
+
+	mi = g_malloc0(s->message_info_size);
+
+	mi->subject = header_decode_string(header_raw_find(&h, "subject", NULL));
+	mi->from = summary_format_address(h, "from");
+	mi->to = summary_format_address(h, "to");
+	mi->date_sent = header_decode_date(header_raw_find(&h, "date", NULL), NULL);
+	mi->date_received = 0;
+
+	return mi;
+}
+
+
+static CamelMessageInfo *
+message_info_load(CamelFolderSummary *s, FILE *in)
+{
+	guint32 tmp;
+	CamelMessageInfo *mi;
+
+	mi = g_malloc0(s->message_info_size);
+
+	camel_folder_summary_decode_uint32(in, &tmp);
+	mi->uid = g_strdup_printf("%u", tmp);
+	camel_folder_summary_decode_uint32(in, &mi->flags);
+	camel_folder_summary_decode_uint32(in, &mi->date_sent);	/* warnings, leave them here */
+	camel_folder_summary_decode_uint32(in, &mi->date_received);
+/*	ms->xev_offset = camel_folder_summary_decode_uint32(in);*/
+	camel_folder_summary_decode_string(in, &mi->subject);
+	camel_folder_summary_decode_string(in, &mi->from);
+	camel_folder_summary_decode_string(in, &mi->to);
+	mi->content = NULL;
+
+	return mi;
+}
+
+static int
+message_info_save(CamelFolderSummary *s, FILE *out, CamelMessageInfo *mi)
+{
+	camel_folder_summary_encode_uint32(out, strtoul(mi->uid, NULL, 10));
+	camel_folder_summary_encode_uint32(out, mi->flags);
+	camel_folder_summary_encode_uint32(out, mi->date_sent);
+	camel_folder_summary_encode_uint32(out, mi->date_received);
+/*	camel_folder_summary_encode_uint32(out, ms->xev_offset);*/
+	camel_folder_summary_encode_string(out, mi->subject);
+	camel_folder_summary_encode_string(out, mi->from);
+	return camel_folder_summary_encode_string(out, mi->to);
+}
+
+static void
+message_info_free(CamelFolderSummary *s, CamelMessageInfo *mi)
+{
+	g_free(mi->uid);
+	g_free(mi->subject);
+	g_free(mi->from);
+	g_free(mi->to);
+	g_free(mi);
+}
+
+static CamelMessageContentInfo *
+content_info_new(CamelFolderSummary *s, struct _header_raw *h)
+{
+	CamelMessageContentInfo *ci;
+
+	ci = g_malloc0(s->content_info_size);
+
+	ci->id = header_msgid_decode(header_raw_find(&h, "content-id", NULL));
+	ci->description = header_decode_string(header_raw_find(&h, "content-description", NULL));
+	ci->encoding = header_content_encoding_decode(header_raw_find(&h, "content-transfer-encoding", NULL));
+
+	ci->pos = -1;
+	ci->bodypos = -1;
+	ci->endpos = -1;
+	return ci;
+}
+
+static CamelMessageContentInfo *
+content_info_load(CamelFolderSummary *s, FILE *in)
+{
+	CamelMessageContentInfo *ci;
+	char *type, *subtype;
+	guint32 count, i;
+	struct _header_content_type *ct;
+
+	ci = g_malloc0(s->content_info_size);
+
+/*	bs->pos = decode_int(in);
+	bs->bodypos = bs->pos + decode_int(in);
+	bs->endpos = bs->pos + decode_int(in);*/
+
+	camel_folder_summary_decode_token(in, &type);
+	camel_folder_summary_decode_token(in, &subtype);
+	ct = header_content_type_new(type, subtype);
+	g_free(type);		/* can this be removed? */
+	g_free(subtype);
+	camel_folder_summary_decode_uint32(in, &count);
+	for (i=0;i<count;i++) {
+		char *name, *value;
+		camel_folder_summary_decode_token(in, &name);
+		camel_folder_summary_decode_token(in, &value);
+		header_content_type_set_param(ct, name, value);
+		/* TODO: do this so we dont have to double alloc/free */
+		g_free(name);
+		g_free(value);
+	}
+	ci->type = ct;
+
+	camel_folder_summary_decode_token(in, &ci->id);
+	camel_folder_summary_decode_token(in, &ci->description);
+	camel_folder_summary_decode_token(in, &ci->encoding);
+
+	ci->childs = NULL;
+	return ci;
+}
+
+static int
+content_info_save(CamelFolderSummary *s, FILE *out, CamelMessageContentInfo *ci)
+{
+	struct _header_content_type *ct;
+	struct _header_param *hp;
+
+/*	camel_folder_summary_encode_uint32(out, bs->pos);
+	camel_folder_summary_encode_uint32(out, bs->bodypos - bs->pos);
+	camel_folder_summary_encode_uint32(out, bs->endpos - bs->pos);*/
+
+	ct = ci->type;
+	if (ct) {
+		camel_folder_summary_encode_token(out, ct->type);
+		camel_folder_summary_encode_token(out, ct->subtype);
+		camel_folder_summary_encode_uint32(out, my_list_size((struct _node **)&ct->params));
+		hp = ct->params;
+		while (hp) {
+			camel_folder_summary_encode_token(out, hp->name);
+			camel_folder_summary_encode_token(out, hp->value);
+			hp = hp->next;
+		}
+	} else {
+		camel_folder_summary_encode_token(out, NULL);
+		camel_folder_summary_encode_token(out, NULL);
+		camel_folder_summary_encode_uint32(out, 0);
+	}
+	camel_folder_summary_encode_token(out, ci->id);
+	camel_folder_summary_encode_token(out, ci->description);
+	return camel_folder_summary_encode_token(out, ci->encoding);
+}
+
+static void
+content_info_free(CamelFolderSummary *s, CamelMessageContentInfo *ci)
+{
+	header_content_type_unref(ci->type);
+	g_free(ci->id);
+	g_free(ci->description);
+	g_free(ci->encoding);
+	g_free(ci);
+}
+
+/*
+  OK
+  Now this is where all the "smarts" happen, where the content info is built,
+  and any indexing and what not is performed
+*/
+
+static CamelMessageContentInfo *
+summary_build_content_info(CamelFolderSummary *s, CamelMimeParser *mp)
+{
+	int state, len;
+	char *buffer;
+	CamelMessageContentInfo *info = NULL;
+	struct _header_content_type *ct;
+	int start, body;
+	int enc_id = -1, chr_id = -1, idx_id = -1;
+	struct _CamelFolderSummaryPrivate *p = _PRIVATE(s);
+	CamelMimeFilterCharset *mfc;
+	CamelMessageContentInfo *part;
+
+	/* start of this part */
+	start = camel_mime_parser_tell(mp);
+	state = camel_mime_parser_step(mp, &buffer, &len);
+	body = camel_mime_parser_tell(mp);
+
+	info = ((CamelFolderSummaryClass *)((GtkObject *)s)->klass)->content_info_new_from_parser(s, mp);
+
+	info->pos = start;
+	info->bodypos = body;
+
+	switch(state) {
+	case HSCAN_HEADER:
+		/* check content type for indexing, then read body */
+		ct = camel_mime_parser_content_type(mp);
+		if (p->index && header_content_type_is(ct, "text", "*")) {
+			char *encoding;
+			const char *charset;
+				
+			encoding = header_content_encoding_decode(camel_mime_parser_header(mp, "content-transfer-encoding", NULL));
+			if (encoding) {
+				if (!strcasecmp(encoding, "base64")) {
+					if (p->filter_64 == NULL)
+						p->filter_64 = camel_mime_filter_basic_new_type(CAMEL_MIME_FILTER_BASIC_BASE64_DEC);
+					enc_id = camel_mime_parser_filter_add(mp, (CamelMimeFilter *)p->filter_64);
+				} else if (!strcasecmp(encoding, "quoted-printable")) {
+					if (p->filter_qp == NULL)
+						p->filter_qp = camel_mime_filter_basic_new_type(CAMEL_MIME_FILTER_BASIC_QP_DEC);
+					enc_id = camel_mime_parser_filter_add(mp, (CamelMimeFilter *)p->filter_qp);
+				}
+				g_free(encoding);
+			}
+				
+			charset = header_content_type_param(ct, "charset");
+			if (charset!=NULL
+			    && !(strcasecmp(charset, "us-ascii")==0
+				 || strcasecmp(charset, "utf-8")==0)) {
+				d(printf("Adding conversion filter from %s to utf-8\n", charset));
+				mfc = g_hash_table_lookup(p->filter_charset, charset);
+				if (mfc == NULL) {
+					mfc = camel_mime_filter_charset_new_convert(charset, "utf-8");
+					if (mfc)
+						g_hash_table_insert(p->filter_charset, g_strdup(charset), mfc);
+				}
+				if (mfc) {
+					chr_id = camel_mime_parser_filter_add(mp, (CamelMimeFilter *)mfc);
+				} else {
+					g_warning("Cannot convert '%s' to 'utf-8', message index may be corrupt", charset);
+				}
+			}
+
+			/* and this filter actually does the indexing */
+			idx_id = camel_mime_parser_filter_add(mp, (CamelMimeFilter *)p->filter_index);
+		}
+		/* and scan/index everything */
+		while (camel_mime_parser_step(mp, &buffer, &len) != HSCAN_BODY_END)
+			;
+		/* and remove the filters */
+		camel_mime_parser_filter_remove(mp, enc_id);
+		camel_mime_parser_filter_remove(mp, chr_id);
+		camel_mime_parser_filter_remove(mp, idx_id);
+		break;
+	case HSCAN_MULTIPART:
+		while (camel_mime_parser_step(mp, &buffer, &len) != HSCAN_MULTIPART_END) {
+			camel_mime_parser_unstep(mp);
+			part = summary_build_content_info(s, mp);
+			if (part) {
+				part->parent = info;
+				my_list_append((struct _node **)&info->childs, (struct _node *)part);
+			} else {
+				g_error("Parsing failed: could not build part of a multipart");
+			}
+		}
+		break;
+	case HSCAN_MESSAGE:
+		part = summary_build_content_info(s, mp);
+		if (part) {
+			part->parent = info;
+			my_list_append((struct _node **)&info->childs, (struct _node *)part);
+		} else {
+			g_error("Parsing failed: no content of a message?");
+		}
+		if (!(state == HSCAN_MESSAGE_END)) {
+			g_error("Bad parser state: Expecing MESSAGE_END or MESSAGE_EOF, got: %d", state);
+			camel_mime_parser_unstep(mp);
+		}
+		break;
+	}
+
+	info->endpos = camel_mime_parser_tell(mp);
+
+	return info;
+}
diff --git a/camel/camel-folder-summary.h b/camel/camel-folder-summary.h
new file mode 100644
index 0000000000..69045d6931
--- /dev/null
+++ b/camel/camel-folder-summary.h
@@ -0,0 +1,181 @@
+/*
+ *  Copyright (C) 2000 Helix Code Inc.
+ *
+ *  Authors: Michael Zucchi <notzed@helixcode.com>
+ *
+ *  This program is free software; you can redistribute it and/or 
+ *  modify it under the terms of the GNU General Public License as 
+ *  published by the Free Software Foundation; either version 2 of the
+ *  License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ *  USA
+ */
+
+#ifndef _CAMEL_FOLDER_SUMMARY_H
+#define _CAMEL_FOLDER_SUMMARY_H
+
+#include <gtk/gtk.h>
+#include <stdio.h>
+#include <time.h>
+#include <camel/camel-mime-parser.h>
+#include <libibex/ibex.h>
+
+#define CAMEL_FOLDER_SUMMARY(obj)         GTK_CHECK_CAST (obj, camel_folder_summary_get_type (), CamelFolderSummary)
+#define CAMEL_FOLDER_SUMMARY_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, camel_folder_summary_get_type (), CamelFolderSummaryClass)
+#define IS_CAMEL_FOLDER_SUMMARY(obj)      GTK_CHECK_TYPE (obj, camel_folder_summary_get_type ())
+
+/*typedef struct _CamelFolderSummary      CamelFolderSummary;*/
+typedef struct _CamelFolderSummaryClass CamelFolderSummaryClass;
+
+/* these structs from camel-folder-summary.h ... (remove comment after cleanup soon) */
+/* TODO: perhaps they should be full-block objects? */
+/* FIXME: rename this to something more suitable */
+typedef struct {
+	gchar *name;
+	gint nb_message;	/* ick, these should be renamed to something better */
+	gint nb_unread_message;
+	gint nb_deleted_message;
+} CamelFolderInfo;
+
+/* A tree of message content info structures
+   describe the content structure of the message (if it has any) */
+typedef struct _CamelMessageContentInfo {
+	struct _CamelMessageContentInfo *next;
+
+	struct _CamelMessageContentInfo *childs;
+	struct _CamelMessageContentInfo *parent;
+
+	struct _header_content_type *type;
+	char *id;
+	char *description;
+	char *encoding;
+
+	/* information about where this object lives in the stream.
+	   if pos is -1 these are all invalid */
+	off_t pos;
+	off_t bodypos;
+	off_t endpos;
+} CamelMessageContentInfo;
+
+/* information about a given object */
+typedef struct {
+	/* public fields */
+	gchar *subject;
+	gchar *to;
+	gchar *from;
+
+	gchar *uid;
+	guint32 flags;
+	guint32 size;
+
+	time_t date_sent;
+	time_t date_received;
+
+	/* tree of content description - NULL if it is not available */
+	CamelMessageContentInfo *content;
+} CamelMessageInfo;
+
+enum _CamelFolderSummaryFlags {
+	CAMEL_SUMMARY_DIRTY = 1<<0,
+};
+
+struct _CamelFolderSummary {
+	GtkObject parent;
+
+	struct _CamelFolderSummaryPrivate *priv;
+
+	/* header info */
+	guint32 version;	/* version of file required, should be set by implementors */
+	guint32 flags;		/* flags */
+	guint32 nextuid;	/* next uid? */
+	guint32 saved_count;	/* how many were saved/loaded */
+	time_t time;		/* timestamp for this summary */
+
+	/* sizes of memory objects */
+	guint32 message_info_size;
+	guint32 content_info_size;
+
+	char *summary_path;
+	gboolean build_content;	/* do we try and parse/index the content, or not? */
+
+	GPtrArray *messages;	/* CamelMessageInfo's */
+	GHashTable *messages_uid; /* CamelMessageInfo's by uid */
+};
+
+struct _CamelFolderSummaryClass {
+	GtkObjectClass parent_class;
+
+	/* load/save the global info */
+	int (*summary_header_load)(CamelFolderSummary *, FILE *);
+	int (*summary_header_save)(CamelFolderSummary *, FILE *);
+
+	/* create/save/load an individual message info */
+	CamelMessageInfo * (*message_info_new)(CamelFolderSummary *, struct _header_raw *);
+	CamelMessageInfo * (*message_info_new_from_parser)(CamelFolderSummary *, CamelMimeParser *);
+	CamelMessageInfo * (*message_info_load)(CamelFolderSummary *, FILE *);
+	int		   (*message_info_save)(CamelFolderSummary *, FILE *, CamelMessageInfo *);
+	void		   (*message_info_free)(CamelFolderSummary *, CamelMessageInfo *);
+
+	/* save/load individual content info's */
+	CamelMessageContentInfo * (*content_info_new)(CamelFolderSummary *, struct _header_raw *);
+	CamelMessageContentInfo * (*content_info_new_from_parser)(CamelFolderSummary *, CamelMimeParser *);
+	CamelMessageContentInfo * (*content_info_load)(CamelFolderSummary *, FILE *);
+	int		          (*content_info_save)(CamelFolderSummary *, FILE *, CamelMessageContentInfo *);
+	void		          (*content_info_free)(CamelFolderSummary *, CamelMessageContentInfo *);
+};
+
+guint			 camel_folder_summary_get_type	(void);
+CamelFolderSummary      *camel_folder_summary_new	(void);
+
+void camel_folder_summary_set_filename(CamelFolderSummary *, const char *);
+void camel_folder_summary_set_index(CamelFolderSummary *, ibex *);
+void camel_folder_summary_set_uid(CamelFolderSummary *, guint32);
+void camel_folder_summary_set_build_content(CamelFolderSummary *, gboolean state);
+
+guint32 camel_folder_summary_next_uid(CamelFolderSummary *s);
+
+/* load/save the summary in its entirety */
+int camel_folder_summary_load(CamelFolderSummary *);
+int camel_folder_summary_save(CamelFolderSummary *);
+
+/* add a new raw summary item */
+void camel_folder_summary_add(CamelFolderSummary *, CamelMessageInfo *info);
+void camel_folder_summary_add_from_header(CamelFolderSummary *, struct _header_raw *);
+void camel_folder_summary_add_from_parser(CamelFolderSummary *, CamelMimeParser *);
+
+/* removes a summary item, fixes offsets? */
+void camel_mbox_summary_remove_uid(CamelFolderSummary *s, const char *uid);
+
+/* lookup functions */
+int camel_folder_summary_count(CamelFolderSummary *);
+CamelMessageInfo *camel_folder_summary_index(CamelFolderSummary *, int);
+CamelMessageInfo *camel_folder_summary_uid(CamelFolderSummary *, const char *uid);
+
+/* utility functions */
+void camel_folder_summary_set_flags_by_uid(CamelFolderSummary *s, const char *uid, guint32 flags);
+/* shift content ... */
+void camel_folder_summary_offset_content(CamelMessageContentInfo *content, off_t offset);
+
+/* summary file loading/saving helper functions */
+int camel_folder_summary_encode_fixed_int32(FILE *, gint32);
+int camel_folder_summary_decode_fixed_int32(FILE *, gint32 *);
+
+int camel_folder_summary_encode_uint32(FILE *, guint32);
+int camel_folder_summary_decode_uint32(FILE *, guint32 *);
+
+int camel_folder_summary_encode_string(FILE *, char *);
+int camel_folder_summary_decode_string(FILE *, char **);
+
+/* basically like strings, but certain keywords can be compressed and de-cased */
+int camel_folder_summary_encode_token(FILE *, char *);
+int camel_folder_summary_decode_token(FILE *, char **);
+
+#endif /* ! _CAMEL_FOLDER_SUMMARY_H */
diff --git a/camel/camel-folder.c b/camel/camel-folder.c
index 6455fbf77b..6188c35866 100644
--- a/camel/camel-folder.c
+++ b/camel/camel-folder.c
@@ -24,6 +24,7 @@
  * USA
  */
 #include <config.h>
+#include <string.h>
 #include "camel-folder.h"
 #include "camel-exception.h"
 #include "camel-store.h"
diff --git a/camel/camel-folder.h b/camel/camel-folder.h
index 713b3ced5c..5cc379be3b 100644
--- a/camel/camel-folder.h
+++ b/camel/camel-folder.h
@@ -56,11 +56,8 @@ typedef enum {
 } CamelFolderOpenMode;
 
 
-typedef void (*CamelFolderAsyncCallback) ();
+#warning old summary stuff to be removed!
 
-/* these structs from camel-folder-summary.h ... (remove comment after cleanup soon) */
-/* TODO: perhaps they should be full-block objects? */
-/* FIXME: rename this to something more suitable */
 typedef struct {
 	gchar *name;
 	gint nb_message;	/* ick, these should be renamed to something better */
@@ -82,10 +79,10 @@ typedef struct _CamelMessageContentInfo {
 	char *encoding;
 
 	guint32 size;
+
 } CamelMessageContentInfo;
 
-/* TODO: rename this?? */
-/* TODO: Make this an object, maybe? */
+/* information about a given object */
 typedef struct {
 	/* public fields */
 	gchar *subject;
@@ -98,11 +95,13 @@ typedef struct {
 	time_t date_sent;
 	time_t date_received;
 
-	/* tree of content description */
+	/* tree of content description - NULL if it is not available */
 	CamelMessageContentInfo *content;
 } CamelMessageInfo;
 
 
+typedef void (*CamelFolderAsyncCallback) ();
+
 struct _CamelFolder
 {
 	GtkObject parent_object;
diff --git a/camel/camel-mime-filter-index.c b/camel/camel-mime-filter-index.c
index 24c223d4e5..53a9f72920 100644
--- a/camel/camel-mime-filter-index.c
+++ b/camel/camel-mime-filter-index.c
@@ -163,4 +163,16 @@ void camel_mime_filter_index_set_name (CamelMimeFilterIndex *mf, char *name)
 	mf->name = g_strdup(name);
 }
 
+void camel_mime_filter_index_set_ibex (CamelMimeFilterIndex *mf, ibex *index)
+{
+	if (mf->index) {
+		char *out;
+		size_t outlen, outspace;
+
+		camel_mime_filter_complete((CamelMimeFilter *)mf, "", 0, 0, &out, &outlen, &outspace);
+	}
+	mf->index = index;
+}
+
+
 
diff --git a/camel/camel-mime-filter-index.h b/camel/camel-mime-filter-index.h
index b4ea1966f0..f480fc55c7 100644
--- a/camel/camel-mime-filter-index.h
+++ b/camel/camel-mime-filter-index.h
@@ -53,5 +53,6 @@ CamelMimeFilterIndex      *camel_mime_filter_index_new_ibex (ibex *);
 
 /* Set the match name for any indexed words */
 void camel_mime_filter_index_set_name (CamelMimeFilterIndex *, char *);
+void camel_mime_filter_index_set_ibex (CamelMimeFilterIndex *mf, ibex *index);
 
 #endif /* ! _CAMEL_MIME_FILTER_INDEX_H */
diff --git a/camel/camel-mime-parser.c b/camel/camel-mime-parser.c
index 5417fffa3a..cf81eed25b 100644
--- a/camel/camel-mime-parser.c
+++ b/camel/camel-mime-parser.c
@@ -118,6 +118,7 @@ struct _header_scan_filter {
 };
 
 static void folder_scan_step(struct _header_scan_state *s, char **databuffer, int *datalength);
+static void folder_scan_drop_step(struct _header_scan_state *s);
 static int folder_scan_init_with_fd(struct _header_scan_state *s, int fd);
 static int folder_scan_init_with_stream(struct _header_scan_state *s, CamelStream *stream);
 static struct _header_scan_state *folder_scan_init(void);
@@ -226,6 +227,22 @@ camel_mime_parser_new (void)
 }
 
 
+/**
+ * camel_mime_parser_filter_add:
+ * @m: 
+ * @mf: 
+ * 
+ * Add a filter that will be applied to any body content before it is passed
+ * to the caller.  Filters may be pipelined to perform multi-pass operations
+ * on the content, and are applied in the order they were added.
+ *
+ * Note that filters are only applied to the body content of messages, and once
+ * a filter has been set, all content returned by a filter_step() with a state
+ * of HSCAN_BODY will have passed through the filter.
+ * 
+ * Return value: An id that may be passed to filter_remove() to remove
+ * the filter, or -1 if the operation failed.
+ **/
 int
 camel_mime_parser_filter_add(CamelMimeParser *m, CamelMimeFilter *mf)
 {
@@ -248,6 +265,14 @@ camel_mime_parser_filter_add(CamelMimeParser *m, CamelMimeFilter *mf)
 	return new->id;
 }
 
+/**
+ * camel_mime_parser_filter_remove:
+ * @m: 
+ * @id: 
+ * 
+ * Remove a processing filter from the pipeline.  There is no
+ * restriction on the order the filters can be removed.
+ **/
 void
 camel_mime_parser_filter_remove(CamelMimeParser *m, int id)
 {
@@ -268,6 +293,18 @@ camel_mime_parser_filter_remove(CamelMimeParser *m, int id)
 	}
 }
 
+/**
+ * camel_mime_parser_header:
+ * @m: 
+ * @name: Name of header.
+ * @offset: Pointer that can receive the offset of the header in
+ * the stream from the start of parsing.
+ * 
+ * Lookup a header by name.
+ * 
+ * Return value: The header value, or NULL if the header is not
+ * defined.
+ **/
 const char *
 camel_mime_parser_header(CamelMimeParser *m, const char *name, int *offset)
 {
@@ -280,6 +317,17 @@ camel_mime_parser_header(CamelMimeParser *m, const char *name, int *offset)
 	return NULL;
 }
 
+/**
+ * camel_mime_parser_headers_raw:
+ * @m: 
+ * 
+ * Get the list of the raw headers which are defined for the
+ * current state of the parser.  These headers are valid
+ * until the next call to parser_step(), or parser_drop_step().
+ * 
+ * Return value: The raw headers, or NULL if there are no headers
+ * defined for the current part or state.
+ **/
 struct _header_raw *
 camel_mime_parser_headers_raw(CamelMimeParser *m)
 {
@@ -290,6 +338,21 @@ camel_mime_parser_headers_raw(CamelMimeParser *m)
 	return NULL;
 }
 
+/**
+ * camel_mime_parser_init_with_fd:
+ * @m: 
+ * @fd: A valid file descriptor.
+ * 
+ * Initialise the scanner with an fd.  The scanner's offsets
+ * will be relative to the current file position of the file
+ * descriptor.  As a result, seekable descritors should
+ * be seeked using the parser seek functions.
+ * 
+ * An initial buffer will be read from the file descriptor
+ * immediately, although no parsing will occur.
+ *
+ * Return value: Returns -1 on error.
+ **/
 int
 camel_mime_parser_init_with_fd(CamelMimeParser *m, int fd)
 {
@@ -298,6 +361,21 @@ camel_mime_parser_init_with_fd(CamelMimeParser *m, int fd)
 	return folder_scan_init_with_fd(s, fd);
 }
 
+/**
+ * camel_mime_parser_init_with_stream:
+ * @m: 
+ * @stream: 
+ * 
+ * Initialise the scanner with a source stream.  The scanner's
+ * offsets will be relative to the current file position of
+ * the stream.  As a result, seekable streams should only
+ * be seeked using the parser seek function.
+ *
+ * An initial buffer will be read from the stream
+ * immediately, although no parsing will occur.
+ * 
+ * Return value: -1 on error.
+ **/
 int
 camel_mime_parser_init_with_stream(CamelMimeParser *m, CamelStream *stream)
 {
@@ -306,6 +384,17 @@ camel_mime_parser_init_with_stream(CamelMimeParser *m, CamelStream *stream)
 	return folder_scan_init_with_stream(s, stream);
 }
 
+/**
+ * camel_mime_parser_scan_from:
+ * @m: 
+ * @scan_from: #TRUE if the scanner should scan From lines.
+ * 
+ * Tell the scanner if it should scan "^From " lines or not.
+ *
+ * If the scanner is scanning from lines, two additional
+ * states HSCAN_FROM and HSCAN_FROM_END will be returned
+ * to the caller during parsing.
+ **/
 void
 camel_mime_parser_scan_from(CamelMimeParser *m, int scan_from)
 {
@@ -313,6 +402,16 @@ camel_mime_parser_scan_from(CamelMimeParser *m, int scan_from)
 	s->scan_from = scan_from;
 }
 
+/**
+ * camel_mime_parser_content_type:
+ * @m: 
+ * 
+ * Get the content type defined in the current part.
+ * 
+ * Return value: A content_type structure, or NULL if there
+ * is no content-type defined for this part of state of the
+ * parser.
+ **/
 struct _header_content_type *
 camel_mime_parser_content_type(CamelMimeParser *m)
 {
@@ -325,6 +424,17 @@ camel_mime_parser_content_type(CamelMimeParser *m)
 	return NULL;
 }
 
+/**
+ * camel_mime_parser_unstep:
+ * @m: 
+ * 
+ * Cause the last step operation to repeat itself.  If this is 
+ * called repeated times, then the same step will be repeated
+ * that many times.
+ *
+ * Note that it is not possible to scan back using this function,
+ * only to have a way of peeking the next state.
+ **/
 void camel_mime_parser_unstep(CamelMimeParser *m)
 {
 	struct _header_scan_state *s = _PRIVATE(m);
@@ -332,6 +442,49 @@ void camel_mime_parser_unstep(CamelMimeParser *m)
 	s->unstep++;
 }
 
+/**
+ * camel_mime_parser_drop_step:
+ * @m: 
+ * 
+ * Drop the last step call.  This should only be used
+ * in conjunction with seeking of the stream as the
+ * stream may be in an undefined state relative to the
+ * state of the parser.
+ *
+ * Use this call with care.
+ **/
+void camel_mime_parser_drop_step(CamelMimeParser *m)
+{
+	struct _header_scan_state *s = _PRIVATE(m);
+
+	s->unstep = 0;
+	folder_scan_drop_step(s);
+}
+
+/**
+ * camel_mime_parser_step:
+ * @m: 
+ * @databuffer: Pointer to accept a pointer to the data
+ * associated with this step (if any).
+ * @datalength: Pointer to accept a pointer to the data
+ * length associated with this step (if any).
+ * 
+ * Parse the next part of the MIME message.  If _unstep()
+ * has been called, then continue to return the same state
+ * for that many calls.
+ *
+ * If the step is HSCAN_BODY then the databuffer and datalength
+ * pointers will be setup to point to the internal data buffer
+ * of the scanner and may be processed as required.  Any
+ * filters will have already been applied to this data.
+ *
+ * Refer to the state diagram elsewhere for a full listing of
+ * the states an application is gauranteed to get from the
+ * scanner.
+ *
+ * Return value: The current new state of the parser
+ * is returned.
+ **/
 enum _header_state
 camel_mime_parser_step(CamelMimeParser *m, char **databuffer, int *datalength)
 {
@@ -349,6 +502,26 @@ camel_mime_parser_step(CamelMimeParser *m, char **databuffer, int *datalength)
 	return s->state;
 }
 
+/**
+ * camel_mime_parser_tell:
+ * @m: 
+ * 
+ * Return the current scanning offset.  The meaning of this
+ * value will depend on the current state of the parser.
+ *
+ * An incomplete listing of the states:
+ *
+ * HSCAN_INITIAL, The start of the current message.
+ * HSCAN_HEADER, HSCAN_MESSAGE, HSCAN_MULTIPART, the character
+ * position immediately after the end of the header.
+ * HSCAN_BODY, Position within the message of the start
+ * of the current data block.
+ * HSCAN_*_END, The position of the character starting
+ * the next section of the scan (the last position + 1 of
+ * the respective current state).
+ * 
+ * Return value: See above.
+ **/
 off_t camel_mime_parser_tell(CamelMimeParser *m)
 {
 	struct _header_scan_state *s = _PRIVATE(m);
@@ -356,6 +529,17 @@ off_t camel_mime_parser_tell(CamelMimeParser *m)
 	return folder_tell(s);
 }
 
+/**
+ * camel_mime_parser_tell_start_headers:
+ * @m: 
+ * 
+ * Find out the position within the file of where the
+ * headers started, this is cached by the parser
+ * at the time.
+ * 
+ * Return value: The header start position, or -1 if
+ * no headers were scanned in the current state.
+ **/
 off_t camel_mime_parser_tell_start_headers(CamelMimeParser *m)
 {
 	struct _header_scan_state *s = _PRIVATE(m);
@@ -363,6 +547,16 @@ off_t camel_mime_parser_tell_start_headers(CamelMimeParser *m)
 	return s->start_of_headers;
 }
 
+/**
+ * camel_mime_parser_tell_start_from:
+ * @m: 
+ * 
+ * If the parser is scanning From lines, then this returns
+ * the position of the start of the From line.
+ * 
+ * Return value: The start of the from line, or -1 if there
+ * was no From line, or From lines are not being scanned.
+ **/
 off_t camel_mime_parser_tell_start_from(CamelMimeParser *m)
 {
 	struct _header_scan_state *s = _PRIVATE(m);
@@ -370,24 +564,76 @@ off_t camel_mime_parser_tell_start_from(CamelMimeParser *m)
 	return s->start_of_from;
 }
 
+/**
+ * camel_mime_parser_seek:
+ * @m: 
+ * @off: Number of bytes to offset the seek by.
+ * @whence: SEEK_SET, SEEK_CUR, SEEK_END
+ * 
+ * Reset the source position to a known value.
+ *
+ * Note that if the source stream/descriptor was not
+ * positioned at 0 to begin with, and an absolute seek
+ * is specified (whence != SEEK_CUR), then the seek
+ * position may not match the desired seek position.
+ * 
+ * Return value: The new seek offset, or -1 on
+ * an error (for example, trying to seek on a non-seekable
+ * stream or file descriptor).
+ **/
 off_t camel_mime_parser_seek(CamelMimeParser *m, off_t off, int whence)
 {
 	struct _header_scan_state *s = _PRIVATE(m);
 	return folder_seek(s, off, whence);
 }
 
+/**
+ * camel_mime_parser_state:
+ * @m: 
+ * 
+ * Get the current parser state.
+ * 
+ * Return value: The current parser state.
+ **/
 enum _header_state camel_mime_parser_state(CamelMimeParser *m)
 {
 	struct _header_scan_state *s = _PRIVATE(m);
 	return s->state;
 }
 
+/**
+ * camel_mime_parser_stream:
+ * @m: 
+ * 
+ * Get the stream, if any, the parser has been initialised
+ * with.  May be used to setup sub-streams, but should not
+ * be read from directly (without saving and restoring
+ * the seek position in between).
+ * 
+ * Return value: The stream from _init_with_stream(), or NULL
+ * if the parser is reading from a file descriptor or is
+ * uninitialised.
+ **/
 CamelStream *camel_mime_parser_stream(CamelMimeParser *m)
 {
 	struct _header_scan_state *s = _PRIVATE(m);
 	return s->stream;
 }
 
+/**
+ * camel_mime_parser_fd:
+ * @m: 
+ * 
+ * Return the file descriptor, if any, the parser has been
+ * initialised with.
+ *
+ * Should not be read from unless the parser it to terminate,
+ * or the seek offset can be reset before the next parse
+ * step.
+ * 
+ * Return value: The file descriptor or -1 if the parser
+ * is reading from a stream or has not been initialised.
+ **/
 int camel_mime_parser_fd(CamelMimeParser *m)
 {
 	struct _header_scan_state *s = _PRIVATE(m);
@@ -1022,7 +1268,7 @@ tail_recurse:
 		type = HSCAN_HEADER;
 		if ( (content = header_raw_find(&h->headers, "Content-Type", NULL))
 		     && (ct = header_content_type_decode(content))) {
-			if (!g_strcasecmp(ct->type, "multipart")) {
+			if (!strcasecmp(ct->type, "multipart")) {
 				bound = header_content_type_param(ct, "boundary");
 				if (bound) {
 					d(printf("multipart, boundary = %s\n", bound));
@@ -1037,9 +1283,9 @@ tail_recurse:
 /*					header_raw_replace(&h->headers, "Content-Type", "text/plain", offset);*/
 					g_warning("Multipart with no boundary, treating as text/plain");
 				}
-			} else if (!g_strcasecmp(ct->type, "message")) {
-				if (!g_strcasecmp(ct->subtype, "rfc822")
-				    /*|| !g_strcasecmp(ct->subtype, "partial")*/) {
+			} else if (!strcasecmp(ct->type, "message")) {
+				if (!strcasecmp(ct->subtype, "rfc822")
+				    /*|| !strcasecmp(ct->subtype, "partial")*/) {
 					type = HSCAN_MESSAGE;
 				}
 			}
@@ -1138,6 +1384,38 @@ tail_recurse:
 	return;
 }
 
+/* drops the current state back one */
+static void
+folder_scan_drop_step(struct _header_scan_state *s)
+{
+	switch (s->state) {
+	case HSCAN_INITIAL:
+	case HSCAN_EOF:
+		return;
+
+	case HSCAN_FROM:
+		s->state = HSCAN_INITIAL;
+		folder_pull_part(s);
+		return;
+
+	case HSCAN_MESSAGE:
+	case HSCAN_HEADER:
+	case HSCAN_MULTIPART:
+
+	case HSCAN_FROM_END:
+	case HSCAN_BODY_END:
+	case HSCAN_MULTIPART_END:
+	case HSCAN_MESSAGE_END:
+
+		s->state = s->parts->savestate;
+		folder_pull_part(s);
+		if (s->state & HSCAN_END) {
+			s->state &= ~HSCAN_END;
+		}
+		return;
+	}
+}
+
 #ifdef STANDALONE
 int main(int argc, char **argv)
 {
@@ -1182,7 +1460,7 @@ int main(int argc, char **argv)
 			case HSCAN_HEADER:
 				if (s->parts->content_type
 				    && (charset = header_content_type_param(s->parts->content_type, "charset"))) {
-					if (g_strcasecmp(charset, "us-ascii")) {
+					if (strcasecmp(charset, "us-ascii")) {
 						folder_push_filter_charset(s, "UTF-8", charset);
 					} else {
 						charset = NULL;
diff --git a/camel/camel-mime-parser.h b/camel/camel-mime-parser.h
index f8964ed86c..cbc7b6095e 100644
--- a/camel/camel-mime-parser.h
+++ b/camel/camel-mime-parser.h
@@ -89,6 +89,7 @@ void camel_mime_parser_scan_from(CamelMimeParser *, int);
 /* normal interface */
 enum _header_state camel_mime_parser_step(CamelMimeParser *, char **, int *);
 void camel_mime_parser_unstep(CamelMimeParser *);
+void camel_mime_parser_drop_step(CamelMimeParser *m);
 enum _header_state camel_mime_parser_state(CamelMimeParser *);
 
 /* get content type for the current part/header */
diff --git a/camel/camel-mime-part-utils.c b/camel/camel-mime-part-utils.c
index ac2c81ad0a..fa914be960 100644
--- a/camel/camel-mime-part-utils.c
+++ b/camel/camel-mime-part-utils.c
@@ -71,11 +71,11 @@ simple_data_wrapper_construct_from_parser(CamelDataWrapper *dw, CamelMimeParser
 	/* first, work out conversion, if any, required, we dont care about what we dont know about */
 	encoding = header_content_encoding_decode(camel_mime_parser_header(mp, "content-transfer-encoding", NULL));
 	if (encoding) {
-		if (!g_strcasecmp(encoding, "base64")) {
+		if (!strcasecmp(encoding, "base64")) {
 			d(printf("Adding base64 decoder ...\n"));
 			fdec = (CamelMimeFilter *)camel_mime_filter_basic_new_type(CAMEL_MIME_FILTER_BASIC_BASE64_DEC);
 			decid = camel_mime_parser_filter_add(mp, fdec);
-		} else if (!g_strcasecmp(encoding, "quoted-printable")) {
+		} else if (!strcasecmp(encoding, "quoted-printable")) {
 			d(printf("Adding quoted-printable decoder ...\n"));
 			fdec = (CamelMimeFilter *)camel_mime_filter_basic_new_type(CAMEL_MIME_FILTER_BASIC_QP_DEC);
 			decid = camel_mime_parser_filter_add(mp, fdec);
@@ -88,8 +88,8 @@ simple_data_wrapper_construct_from_parser(CamelDataWrapper *dw, CamelMimeParser
 	if (header_content_type_is(ct, "text", "*")) {
 		const char *charset = header_content_type_param(ct, "charset");
 		if (charset!=NULL
-		    && !(g_strcasecmp(charset, "us-ascii")==0
-			 || g_strcasecmp(charset, "utf-8")==0)) {
+		    && !(strcasecmp(charset, "us-ascii")==0
+			 || strcasecmp(charset, "utf-8")==0)) {
 			d(printf("Adding conversion filter from %s to utf-8\n", charset));
 			fch = (CamelMimeFilter *)camel_mime_filter_charset_new_convert(charset, "utf-8");
 			if (fch) {
diff --git a/camel/camel-mime-part.c b/camel/camel-mime-part.c
index 744f2a7247..bb3abe7062 100644
--- a/camel/camel-mime-part.c
+++ b/camel/camel-mime-part.c
@@ -606,13 +606,13 @@ camel_mime_part_encoding_from_string (const gchar *string)
 {
 	if (string == NULL)
 		return CAMEL_MIME_PART_ENCODING_DEFAULT;
-	else if (g_strcasecmp (string, "7bit") == 0)
+	else if (strcasecmp (string, "7bit") == 0)
 		return CAMEL_MIME_PART_ENCODING_7BIT;
-	else if (g_strcasecmp (string, "8bit") == 0)
+	else if (strcasecmp (string, "8bit") == 0)
 		return CAMEL_MIME_PART_ENCODING_8BIT;
-	else if (g_strcasecmp (string, "base64") == 0)
+	else if (strcasecmp (string, "base64") == 0)
 		return CAMEL_MIME_PART_ENCODING_BASE64;
-	else if (g_strcasecmp (string, "quoted-printable") == 0)
+	else if (strcasecmp (string, "quoted-printable") == 0)
 		return CAMEL_MIME_PART_ENCODING_QUOTEDPRINTABLE;
 	else
 		/* FIXME?  Spit a warning?  */
diff --git a/camel/camel-mime-utils.c b/camel/camel-mime-utils.c
index f53531feb7..3f4c4d99d3 100644
--- a/camel/camel-mime-utils.c
+++ b/camel/camel-mime-utils.c
@@ -808,7 +808,7 @@ char *rfc2047_encode_word(const char *in, int len, char *type)
 	out = buffer;
 
 	/* if we can't convert from utf-8, just encode as utf-8 */
-	if (!g_strcasecmp(type, "UTF-8")
+	if (!strcasecmp(type, "UTF-8")
 	    || (ic = unicode_iconv_open(type, "UTF-8")) == (unicode_iconv_t)-1) {
 		memcpy(buffer, in, len);
 		out = buffer+len;
@@ -1065,7 +1065,7 @@ header_decode_param(const char **in, char **paramp, char **valuep)
 char *
 header_param(struct _header_param *p, const char *name)
 {
-	while (p && g_strcasecmp(p->name, name) != 0)
+	while (p && strcasecmp(p->name, name) != 0)
 		p = p->next;
 	if (p)
 		return p->value;
@@ -1079,7 +1079,7 @@ header_set_param(struct _header_param **l, const char *name, const char *value)
 
 	while (p->next) {
 		pn = p->next;
-		if (!g_strcasecmp(pn->name, name)) {
+		if (!strcasecmp(pn->name, name)) {
 			g_free(pn->value);
 			if (value) {
 				pn->value = g_strdup(value);
@@ -1135,16 +1135,16 @@ header_content_type_is(struct _header_content_type *ct, const char *type, const
 {
 	/* no type == text/plain or text/"*" */
 	if (ct==NULL) {
-		return (!g_strcasecmp(type, "text")
-			&& (!g_strcasecmp(subtype, "plain")
-			    || !g_strcasecmp(subtype, "*")));
+		return (!strcasecmp(type, "text")
+			&& (!strcasecmp(subtype, "plain")
+			    || !strcasecmp(subtype, "*")));
 	}
 
 	return (ct->type != NULL
-		&& (!g_strcasecmp(ct->type, type)
+		&& (!strcasecmp(ct->type, type)
 		    && ((ct->subtype != NULL
-			 && !g_strcasecmp(ct->subtype, subtype))
-			|| !g_strcasecmp("*", subtype))));
+			 && !strcasecmp(ct->subtype, subtype))
+			|| !strcasecmp("*", subtype))));
 }
 
 void
@@ -1660,7 +1660,7 @@ header_content_type_decode(const char *in)
 			inptr++;
 			subtype = decode_token(&inptr);
 		}
-		if (subtype == NULL && (!g_strcasecmp(type, "text"))) {
+		if (subtype == NULL && (!strcasecmp(type, "text"))) {
 			g_warning("text type with no subtype, resorting to text/plain: %s", in);
 			subtype = g_strdup("plain");
 		}
@@ -1713,7 +1713,7 @@ header_content_type_format(struct _header_content_type *ct)
 		g_warning("Content-Type with no main type");
 	} else if (ct->subtype == NULL) {
 		g_warning("Content-Type with no sub type: %s", ct->type);
-		if (!g_strcasecmp(ct->type, "multipart"))
+		if (!strcasecmp(ct->type, "multipart"))
 			g_string_sprintfa(out, "%s/mixed", ct->type);
 		else
 			g_string_sprintfa(out, "%s", ct->type);
@@ -1879,7 +1879,7 @@ header_decode_date(const char *in, int *saveoffset)
 	monthname = decode_token(&inptr);
 	if (monthname) {
 		for (i=0;i<sizeof(tz_months)/sizeof(tz_months[0]);i++) {
-			if (!g_strcasecmp(tz_months[i], monthname)) {
+			if (!strcasecmp(tz_months[i], monthname)) {
 				tm.tm_mon = i;
 				break;
 			}
@@ -1916,7 +1916,7 @@ header_decode_date(const char *in, int *saveoffset)
 
 		if (tz) {
 			for (i=0;i<sizeof(tz_offsets)/sizeof(tz_offsets[0]);i++) {
-				if (!g_strcasecmp(tz_offsets[i].name, tz)) {
+				if (!strcasecmp(tz_offsets[i].name, tz)) {
 					offset = tz_offsets[i].offset;
 					break;
 				}
@@ -2031,13 +2031,13 @@ header_raw_append(struct _header_raw **list, const char *name, const char *value
 
 	/* debug */
 #if 0
-	if (!g_strcasecmp(name, "To")) {
+	if (!strcasecmp(name, "To")) {
 		printf("- Decoding To\n");
 		header_to_decode(value);
-	} else if (!g_strcasecmp(name, "Content-type")) {
+	} else if (!strcasecmp(name, "Content-type")) {
 		printf("- Decoding content-type\n");
 		header_content_type_dump(header_content_type_decode(value));		
-	} else if (!g_strcasecmp(name, "MIME-Version")) {
+	} else if (!strcasecmp(name, "MIME-Version")) {
 		printf("- Decoding mime version\n");
 		header_mime_decode(value);
 	}
@@ -2051,7 +2051,7 @@ header_raw_find_node(struct _header_raw **list, const char *name)
 
 	l = *list;
 	while (l) {
-		if (!g_strcasecmp(l->name, name))
+		if (!strcasecmp(l->name, name))
 			break;
 		l = l->next;
 	}
@@ -2103,7 +2103,7 @@ header_raw_remove(struct _header_raw **list, const char *name)
 	p = (struct _header_raw *)list;
 	l = *list;
 	while (l) {
-		if (!g_strcasecmp(l->name, name)) {
+		if (!strcasecmp(l->name, name)) {
 			p->next = l->next;
 			header_raw_free(l);
 			l = p->next;
diff --git a/camel/providers/mbox/camel-mbox-summary.c b/camel/providers/mbox/camel-mbox-summary.c
index 01deaef19a..35b7945e49 100644
--- a/camel/providers/mbox/camel-mbox-summary.c
+++ b/camel/providers/mbox/camel-mbox-summary.c
@@ -595,7 +595,7 @@ header_write(int fd, struct _header_raw *header, unsigned int uid, unsigned int
 	iv[3].iov_len = 1;
 
 	while (header) {
-		if (g_strcasecmp(header->name, "x-evolution")) {
+		if (strcasecmp(header->name, "x-evolution")) {
 			int len;
 
 			iv[0].iov_base = header->name;
@@ -876,12 +876,12 @@ static int index_folder(CamelMboxSummary *s, int startoffset)
 				   messages/message parts */
 				encoding = header_content_encoding_decode(camel_mime_parser_header(mp, "content-transfer-encoding", NULL));
 				if (encoding) {
-					if (!g_strcasecmp(encoding, "base64")) {
+					if (!strcasecmp(encoding, "base64")) {
 						d(printf("Adding decoding filter for base64\n"));
 						if (mf64 == NULL)
 							mf64 = camel_mime_filter_basic_new_type(CAMEL_MIME_FILTER_BASIC_BASE64_DEC);
 						enc_id = camel_mime_parser_filter_add(mp, (CamelMimeFilter *)mf64);
-					} else if (!g_strcasecmp(encoding, "quoted-printable")) {
+					} else if (!strcasecmp(encoding, "quoted-printable")) {
 						d(printf("Adding decoding filter for quoted-printable\n"));
 						if (mfqp == NULL)
 							mfqp = camel_mime_filter_basic_new_type(CAMEL_MIME_FILTER_BASIC_QP_DEC);
@@ -892,8 +892,8 @@ static int index_folder(CamelMboxSummary *s, int startoffset)
 				
 				charset = header_content_type_param(ct, "charset");
 				if (charset!=NULL
-				    && !(g_strcasecmp(charset, "us-ascii")==0
-					|| g_strcasecmp(charset, "utf-8")==0)) {
+				    && !(strcasecmp(charset, "us-ascii")==0
+					|| strcasecmp(charset, "utf-8")==0)) {
 					d(printf("Adding conversion filter from %s to utf-8\n", charset));
 					if (mfc == NULL)
 						mfc = camel_mime_filter_charset_new_convert(charset, "utf-8");