Implemented.

2004-03-29  Jeffrey Stedfast  <fejj@ximian.com>

	* providers/imap4/camel-imap4-folder.c (camel_imap4_folder_new):
	Implemented.

	* providers/imap4/camel-imap4-engine.c (engine_parse_namespace):
	If the namespace begins with "INBOX", canonicalise the INBOX
	portion (ie, make it all caps).

	* providers/imap4/camel-imap4-store.c (imap4_noop): Implemented.

svn path=/trunk/; revision=25237

25 files changed, 2103 insertions, 1997 deletions

diff --git a/camel/providers/Makefile.am b/camel/providers/Makefile.am
index 55ce850097..22ea481954 100644
--- a/camel/providers/Makefile.am
+++ b/camel/providers/Makefile.am
@@ -8,5 +8,9 @@ if ENABLE_IMAPP
 IMAPP_DIR=imapp
 endif
 
-SUBDIRS = pop3 sendmail smtp imap $(NNTP_DIR) local $(IMAPP_DIR) groupwise
+if ENABLE_IMAP4
+IMAP4_DIR=imap4
+endif
+
+SUBDIRS = pop3 sendmail smtp imap $(NNTP_DIR) local $(IMAPP_DIR) $(IMAP4_DIR) groupwise
 
diff --git a/camel/providers/imap4/Makefile.am b/camel/providers/imap4/Makefile.am
index b94c8f9564..d1bb57e150 100644
--- a/camel/providers/imap4/Makefile.am
+++ b/camel/providers/imap4/Makefile.am
@@ -17,23 +17,23 @@ INCLUDES = 					\
 	-DG_LOG_DOMAIN=\"camel-imap4-provider\"
 
 libcamelimap4_la_SOURCES = 			\
-	camel-imap-command.c			\
-	camel-imap-command.h			\
-	camel-imap-engine.c			\
-	camel-imap-engine.h			\
-	camel-imap-folder.c			\
-	camel-imap-folder.h			\
-	camel-imap-provider.c			\
-	camel-imap-specials.c			\
-	camel-imap-specials.h			\
-	camel-imap-store.c			\
-	camel-imap-store.h			\
-	camel-imap-stream.c			\
-	camel-imap-stream.h			\
-	camel-imap-summary.c			\
-	camel-imap-summary.h			\
-	camel-imap-utils.c			\
-	camel-imap-utils.h
+	camel-imap4-command.c			\
+	camel-imap4-command.h			\
+	camel-imap4-engine.c			\
+	camel-imap4-engine.h			\
+	camel-imap4-folder.c			\
+	camel-imap4-folder.h			\
+	camel-imap4-provider.c			\
+	camel-imap4-specials.c			\
+	camel-imap4-specials.h			\
+	camel-imap4-store.c			\
+	camel-imap4-store.h			\
+	camel-imap4-stream.c			\
+	camel-imap4-stream.h			\
+	camel-imap4-summary.c			\
+	camel-imap4-summary.h			\
+	camel-imap4-utils.c			\
+	camel-imap4-utils.h
 
 libcamelimap4_la_LDFLAGS = -avoid-version -module
 
diff --git a/camel/providers/imap4/camel-imap-command.h b/camel/providers/imap4/camel-imap-command.h
deleted file mode 100644
index af3ad9f927..0000000000
--- a/camel/providers/imap4/camel-imap-command.h
+++ /dev/null
@@ -1,144 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
-/*  Camel
- *  Copyright (C) 1999-2004 Jeffrey Stedfast
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
- */
-
-
-#ifndef __CAMEL_IMAP_COMMAND_H__
-#define __CAMEL_IMAP_COMMAND_H__
-
-#include <stdarg.h>
-
-#include <glib.h>
-
-#include <e-util/e-msgport.h>
-
-#include <camel/camel-stream.h>
-#include <camel/camel-exception.h>
-#include <camel/camel-data-wrapper.h>
-
-#ifdef __cplusplus
-extern "C" {
-#pragma }
-#endif /* __cplusplus */
-
-struct _CamelIMAPEngine;
-struct _CamelIMAPFolder;
-struct _camel_imap_token_t;
-
-typedef struct _CamelIMAPCommand CamelIMAPCommand;
-typedef struct _CamelIMAPLiteral CamelIMAPLiteral;
-
-typedef int (* CamelIMAPPlusCallback) (struct _CamelIMAPEngine *engine,
-				       CamelIMAPCommand *ic,
-				       const unsigned char *linebuf,
-				       size_t linelen, CamelException *ex);
-
-typedef int (* CamelIMAPUntaggedCallback) (struct _CamelIMAPEngine *engine,
-					   CamelIMAPCommand *ic,
-					   guint32 index,
-					   struct _camel_imap_token_t *token,
-					   CamelException *ex);
-
-enum {
-	CAMEL_IMAP_LITERAL_STRING,
-	CAMEL_IMAP_LITERAL_STREAM,
-	CAMEL_IMAP_LITERAL_WRAPPER,
-};
-
-struct _CamelIMAPLiteral {
-	int type;
-	union {
-		char *string;
-		CamelStream *stream;
-		CamelDataWrapper *wrapper;
-	} literal;
-};
-
-typedef struct _CamelIMAPCommandPart {
-	struct _CamelIMAPCommandPart *next;
-	unsigned char *buffer;
-	size_t buflen;
-	
-	CamelIMAPLiteral *literal;
-} CamelIMAPCommandPart;
-
-enum {
-	CAMEL_IMAP_COMMAND_QUEUED,
-	CAMEL_IMAP_COMMAND_ACTIVE,
-	CAMEL_IMAP_COMMAND_COMPLETE,
-	CAMEL_IMAP_COMMAND_ERROR,
-};
-
-enum {
-	CAMEL_IMAP_RESULT_NONE,
-	CAMEL_IMAP_RESULT_OK,
-	CAMEL_IMAP_RESULT_NO,
-	CAMEL_IMAP_RESULT_BAD,
-};
-
-struct _CamelIMAPCommand {
-	EDListNode node;
-	
-	struct _CamelIMAPEngine *engine;
-	
-	unsigned int ref_count:26;
-	unsigned int status:3;
-	unsigned int result:3;
-	int id;
-	
-	char *tag;
-	
-	GPtrArray *resp_codes;
-	
-	struct _CamelIMAPFolder *folder;
-	CamelException ex;
-	
-	/* command parts - logical breaks in the overall command based on literals */
-	CamelIMAPCommandPart *parts;
-	
-	/* current part */
-	CamelIMAPCommandPart *part;
-	
-	/* untagged handlers */
-	GHashTable *untagged;
-	
-	/* '+' callback/data */
-	CamelIMAPPlusCallback plus;
-	void *user_data;
-};
-
-CamelIMAPCommand *camel_imap_command_new (struct _CamelIMAPEngine *engine, struct _CamelIMAPFolder *folder,
-					  const char *format, ...);
-CamelIMAPCommand *camel_imap_command_newv (struct _CamelIMAPEngine *engine, struct _CamelIMAPFolder *folder,
-					   const char *format, va_list args);
-
-void camel_imap_command_register_untagged (CamelIMAPCommand *ic, const char *atom, CamelIMAPUntaggedCallback untagged);
-
-void camel_imap_command_ref (CamelIMAPCommand *ic);
-void camel_imap_command_unref (CamelIMAPCommand *ic);
-
-/* returns 1 when complete, 0 if there is more to do, or -1 on error */
-int camel_imap_command_step (CamelIMAPCommand *ic);
-
-void camel_imap_command_reset (CamelIMAPCommand *ic);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif /* __CAMEL_IMAP_COMMAND_H__ */
diff --git a/camel/providers/imap4/camel-imap-engine.h b/camel/providers/imap4/camel-imap-engine.h
deleted file mode 100644
index 6612693243..0000000000
--- a/camel/providers/imap4/camel-imap-engine.h
+++ /dev/null
@@ -1,222 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
-/*  Camel
- *  Copyright (C) 1999-2004 Jeffrey Stedfast
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
- */
-
-
-#ifndef __CAMEL_IMAP_ENGINE_H__
-#define __CAMEL_IMAP_ENGINE_H__
-
-#include <stdarg.h>
-
-#include <glib.h>
-
-#include <e-util/e-msgport.h>
-
-#include <camel/camel-stream.h>
-#include <camel/camel-folder.h>
-#include <camel/camel-session.h>
-
-#ifdef __cplusplus
-extern "C" {
-#pragma }
-#endif /* __cplusplus */
-
-#define CAMEL_TYPE_IMAP_ENGINE            (camel_imap_engine_get_type ())
-#define CAMEL_IMAP_ENGINE(obj)            (CAMEL_CHECK_CAST ((obj), CAMEL_TYPE_IMAP_ENGINE, CamelIMAPEngine))
-#define CAMEL_IMAP_ENGINE_CLASS(klass)    (CAMEL_CHECK_CLASS_CAST ((klass), CAMEL_TYPE_IMAP_ENGINE, CamelIMAPEngineClass))
-#define CAMEL_IS_IMAP_ENGINE(obj)         (CAMEL_CHECK_TYPE ((obj), CAMEL_TYPE_IMAP_ENGINE))
-#define CAMEL_IS_IMAP_ENGINE_CLASS(klass) (CAMEL_CHECK_CLASS_TYPE ((klass), CAMEL_TYPE_IMAP_ENGINE))
-#define CAMEL_IMAP_ENGINE_GET_CLASS(obj)  (CAMEL_CHECK_GET_CLASS ((obj), CAMEL_TYPE_IMAP_ENGINE, CamelIMAPEngineClass))
-
-typedef struct _CamelIMAPEngine CamelIMAPEngine;
-typedef struct _CamelIMAPEngineClass CamelIMAPEngineClass;
-
-struct _camel_imap_token_t;
-struct _CamelIMAPCommand;
-struct _CamelIMAPFolder;
-struct _CamelIMAPStream;
-
-typedef enum {
-	CAMEL_IMAP_ENGINE_DISCONNECTED,
-	CAMEL_IMAP_ENGINE_CONNECTED,
-	CAMEL_IMAP_ENGINE_PREAUTH,
-	CAMEL_IMAP_ENGINE_AUTHENTICATED,
-	CAMEL_IMAP_ENGINE_SELECTED,
-} camel_imap_engine_t;
-
-typedef enum {
-	CAMEL_IMAP_LEVEL_UNKNOWN,
-	CAMEL_IMAP_LEVEL_IMAP4,
-	CAMEL_IMAP_LEVEL_IMAP4REV1
-} camel_imap_level_t;
-
-enum {
-	CAMEL_IMAP_CAPABILITY_IMAP4           = (1 << 0),
-	CAMEL_IMAP_CAPABILITY_IMAP4REV1       = (1 << 1),
-	CAMEL_IMAP_CAPABILITY_STATUS          = (1 << 2),
-	CAMEL_IMAP_CAPABILITY_NAMESPACE       = (1 << 3),
-	CAMEL_IMAP_CAPABILITY_UIDPLUS         = (1 << 4),
-	CAMEL_IMAP_CAPABILITY_LITERALPLUS     = (1 << 5),
-	CAMEL_IMAP_CAPABILITY_LOGINDISABLED   = (1 << 6),
-	CAMEL_IMAP_CAPABILITY_STARTTLS        = (1 << 7),
-	CAMEL_IMAP_CAPABILITY_useful_lsub     = (1 << 8),
-	CAMEL_IMAP_CAPABILITY_utf8_search     = (1 << 9),
-};
-
-typedef enum {
-	CAMEL_IMAP_RESP_CODE_ALERT,
-	CAMEL_IMAP_RESP_CODE_BADCHARSET,
-	CAMEL_IMAP_RESP_CODE_CAPABILITY,
-	CAMEL_IMAP_RESP_CODE_PARSE,
-	CAMEL_IMAP_RESP_CODE_PERM_FLAGS,
-	CAMEL_IMAP_RESP_CODE_READONLY,
-	CAMEL_IMAP_RESP_CODE_READWRITE,
-	CAMEL_IMAP_RESP_CODE_TRYCREATE,
-	CAMEL_IMAP_RESP_CODE_UIDNEXT,
-	CAMEL_IMAP_RESP_CODE_UIDVALIDITY,
-	CAMEL_IMAP_RESP_CODE_UNSEEN,
-	CAMEL_IMAP_RESP_CODE_NEWNAME,
-	CAMEL_IMAP_RESP_CODE_APPENDUID,
-	CAMEL_IMAP_RESP_CODE_COPYUID,
-	CAMEL_IMAP_RESP_CODE_UNKNOWN,
-} camel_imap_resp_code_t;
-
-typedef struct _CamelIMAPRespCode {
-	camel_imap_resp_code_t code;
-	union {
-		guint32 flags;
-		char *parse;
-		guint32 uidnext;
-		guint32 uidvalidity;
-		guint32 unseen;
-		char *newname[2];
-		struct {
-			guint32 uidvalidity;
-			guint32 uid;
-		} appenduid;
-		struct {
-			guint32 uidvalidity;
-			char *srcset;
-			char *destset;
-		} copyuid;
-	} v;
-} CamelIMAPRespCode;
-
-enum {
-	CAMEL_IMAP_UNTAGGED_ERROR = -1,
-	CAMEL_IMAP_UNTAGGED_OK,
-	CAMEL_IMAP_UNTAGGED_NO,
-	CAMEL_IMAP_UNTAGGED_BAD,
-	CAMEL_IMAP_UNTAGGED_PREAUTH,
-	CAMEL_IMAP_UNTAGGED_HANDLED,
-};
-
-typedef struct _CamelIMAPNamespace {
-	struct _CamelIMAPNamespace *next;
-	char *path;
-	char sep;
-} CamelIMAPNamespace;
-
-typedef struct _CamelIMAPNamespaceList {
-	CamelIMAPNamespace *personal;
-	CamelIMAPNamespace *other;
-	CamelIMAPNamespace *shared;
-} CamelIMAPNamespaceList;
-
-enum {
-	CAMEL_IMAP_ENGINE_MAXLEN_LINE,
-	CAMEL_IMAP_ENGINE_MAXLEN_TOKEN
-};
-
-struct _CamelIMAPEngine {
-	CamelObject parent_object;
-	
-	CamelSession *session;
-	CamelURL *url;
-	
-	camel_imap_engine_t state;
-	camel_imap_level_t level;
-	guint32 capa;
-	
-	guint32 maxlen:31;
-	guint32 maxlentype:1;
-	
-	CamelIMAPNamespaceList namespaces;
-	GHashTable *authtypes;                    /* supported authtypes */
-	
-	struct _CamelIMAPStream *istream;
-	CamelStream *ostream;
-	
-	unsigned char tagprefix;             /* 'A'..'Z' */
-	unsigned int tag;                    /* next command tag */
-	int nextid;
-	
-	struct _CamelIMAPFolder *folder;    /* currently selected folder */
-	
-	EDList queue;                          /* queue of waiting commands */
-	struct _CamelIMAPCommand *current;
-};
-
-struct _CamelIMAPEngineClass {
-	CamelObjectClass parent_class;
-	
-	unsigned char tagprefix;
-};
-
-
-CamelType camel_imap_engine_get_type (void);
-
-CamelIMAPEngine *camel_imap_engine_new (CamelSession *session, CamelURL *url);
-
-/* returns 0 on success or -1 on error */
-int camel_imap_engine_take_stream (CamelIMAPEngine *engine, CamelStream *stream, CamelException *ex);
-
-int camel_imap_engine_capability (CamelIMAPEngine *engine, CamelException *ex);
-int camel_imap_engine_namespace (CamelIMAPEngine *engine, CamelException *ex);
-
-int camel_imap_engine_select_folder (CamelIMAPEngine *engine, CamelFolder *folder, CamelException *ex);
-
-struct _CamelIMAPCommand *camel_imap_engine_queue (CamelIMAPEngine *engine, CamelFolder *folder,
-						   const char *format, ...);
-void camel_imap_engine_prequeue (CamelIMAPEngine *engine, struct _CamelIMAPCommand *ic);
-
-void camel_imap_engine_dequeue (CamelIMAPEngine *engine, struct _CamelIMAPCommand *ic);
-
-int camel_imap_engine_iterate (CamelIMAPEngine *engine);
-
-
-/* untagged response utility functions */
-int camel_imap_engine_handle_untagged_1 (CamelIMAPEngine *engine, struct _camel_imap_token_t *token, CamelException *ex);
-void camel_imap_engine_handle_untagged (CamelIMAPEngine *engine, CamelException *ex);
-
-/* stream wrapper utility functions */
-int camel_imap_engine_next_token (CamelIMAPEngine *engine, struct _camel_imap_token_t *token, CamelException *ex);
-int camel_imap_engine_line (CamelIMAPEngine *engine, unsigned char **line, size_t *len, CamelException *ex);
-int camel_imap_engine_literal (CamelIMAPEngine *engine, unsigned char **literal, size_t *len, CamelException *ex);
-int camel_imap_engine_eat_line (CamelIMAPEngine *engine, CamelException *ex);
-
-
-/* response code stuff */
-int camel_imap_engine_parse_resp_code (CamelIMAPEngine *engine, CamelException *ex);
-void camel_imap_resp_code_free (CamelIMAPRespCode *rcode);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif /* __CAMEL_IMAP_ENGINE_H__ */
diff --git a/camel/providers/imap4/camel-imap-folder.h b/camel/providers/imap4/camel-imap-folder.h
deleted file mode 100644
index a4f4e55528..0000000000
--- a/camel/providers/imap4/camel-imap-folder.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
-/*  Camel
- *  Copyright (C) 1999-2004 Jeffrey Stedfast
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
- */
-
-
-#ifndef __CAMEL_IMAP_FOLDER_H__
-#define __CAMEL_IMAP_FOLDER_H__
-
-#include <camel/camel-store.h>
-#include <camel/camel-folder.h>
-
-#ifdef __cplusplus
-extern "C" {
-#pragma }
-#endif /* __cplusplus */
-
-#define CAMEL_TYPE_IMAP_FOLDER            (camel_imap_folder_get_type ())
-#define CAMEL_IMAP_FOLDER(obj)            (CAMEL_CHECK_CAST ((obj), CAMEL_TYPE_IMAP_FOLDER, CamelIMAPFolder))
-#define CAMEL_IMAP_FOLDER_CLASS(klass)    (CAMEL_CHECK_CLASS_CAST ((klass), CAMEL_TYPE_IMAP_FOLDER, CamelIMAPFolderClass))
-#define CAMEL_IS_IMAP_FOLDER(obj)         (CAMEL_CHECK_TYPE ((obj), CAMEL_TYPE_IMAP_FOLDER))
-#define CAMEL_IS_IMAP_FOLDER_CLASS(klass) (CAMEL_CHECK_CLASS_TYPE ((klass), CAMEL_TYPE_IMAP_FOLDER))
-#define CAMEL_IMAP_FOLDER_GET_CLASS(obj)  (CAMEL_CHECK_GET_CLASS ((obj), CAMEL_TYPE_IMAP_FOLDER, CamelIMAPFolderClass))
-
-typedef struct _CamelIMAPFolder CamelIMAPFolder;
-typedef struct _CamelIMAPFolderClass CamelIMAPFolderClass;
-
-struct _CamelIMAPFolder {
-	CamelFolder parent_object;
-	
-	char *cachedir;
-	char *utf7_name;
-};
-
-struct _CamelIMAPFolderClass {
-	CamelFolderClass parent_class;
-	
-};
-
-
-CamelType camel_imap_folder_get_type (void);
-
-CamelFolder *camel_imap_folder_new (CamelStore *store, const char *full_name, gboolean query, CamelException *ex);
-CamelFolder *camel_imap_folder_new_utf7_name (CamelStore *store, const char *utf7_name, CamelException *ex);
-
-const char *camel_imap_folder_utf7_name (CamelIMAPFolder *folder);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif /* __CAMEL_IMAP_FOLDER_H__ */
diff --git a/camel/providers/imap4/camel-imap-stream.h b/camel/providers/imap4/camel-imap-stream.h
deleted file mode 100644
index 872cbf7141..0000000000
--- a/camel/providers/imap4/camel-imap-stream.h
+++ /dev/null
@@ -1,124 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
-/*  Camel
- *  Copyright (C) 1999-2004 Jeffrey Stedfast
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
- */
-
-
-#ifndef __CAMEL_IMAP_STREAM_H__
-#define __CAMEL_IMAP_STREAM_H__
-
-#include <camel/camel-stream.h>
-
-#ifdef __cplusplus
-extern "C" {
-#pragma }
-#endif /* __cplusplus */
-
-#define CAMEL_TYPE_IMAP_STREAM     (camel_imap_stream_get_type ())
-#define CAMEL_IMAP_STREAM(obj)     (CAMEL_CHECK_CAST ((obj), CAMEL_TYPE_IMAP_STREAM, CamelIMAPStream))
-#define CAMEL_IMAP_STREAM_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_TYPE_IMAP_STREAM, CamelIMAPStreamClass))
-#define CAMEL_IS_IMAP_STREAM(o)    (CAMEL_CHECK_TYPE((o), CAMEL_TYPE_IMAP_STREAM))
-
-typedef struct _CamelIMAPStream CamelIMAPStream;
-typedef struct _CamelIMAPStreamClass CamelIMAPStreamClass;
-
-#define IMAP_READ_PRELEN   128
-#define IMAP_READ_BUFLEN   4096
-
-enum {
-	CAMEL_IMAP_TOKEN_NO_DATA       = -8,
-	CAMEL_IMAP_TOKEN_ERROR         = -7,
-	CAMEL_IMAP_TOKEN_NIL           = -6,
-	CAMEL_IMAP_TOKEN_ATOM          = -5,
-	CAMEL_IMAP_TOKEN_FLAG          = -4,
-	CAMEL_IMAP_TOKEN_NUMBER        = -3,
-	CAMEL_IMAP_TOKEN_QSTRING       = -2,
-	CAMEL_IMAP_TOKEN_LITERAL       = -1,
-	/* CAMEL_IMAP_TOKEN_CHAR would just be the char we got */
-	CAMEL_IMAP_TOKEN_EOLN          = '\n',
-	CAMEL_IMAP_TOKEN_LPAREN        = '(',
-	CAMEL_IMAP_TOKEN_RPAREN        = ')',
-	CAMEL_IMAP_TOKEN_ASTERISK      = '*',
-	CAMEL_IMAP_TOKEN_PLUS          = '+',
-	CAMEL_IMAP_TOKEN_LBRACKET      = '[',
-	CAMEL_IMAP_TOKEN_RBRACKET      = ']',
-};
-
-typedef struct _camel_imap_token_t {
-	int token;
-	union {
-		char *atom;
-		char *flag;
-		char *qstring;
-		size_t literal;
-		guint32 number;
-	} v;
-} camel_imap_token_t;
-
-enum {
-	CAMEL_IMAP_STREAM_MODE_TOKEN   = 0,
-	CAMEL_IMAP_STREAM_MODE_LITERAL = 1,
-};
-
-struct _CamelIMAPStream {
-	CamelStream parent_object;
-	
-	CamelStream *stream;
-	
-	guint disconnected:1;  /* disconnected state */
-	guint mode:1;          /* TOKEN vs LITERAL */
-	guint eol:1;           /* end-of-literal */
-	
-	size_t literal;
-	
-	/* i/o buffers */
-	unsigned char realbuf[IMAP_READ_PRELEN + IMAP_READ_BUFLEN + 1];
-	unsigned char *inbuf;
-	unsigned char *inptr;
-	unsigned char *inend;
-	
-	/* token buffers */
-	unsigned char *tokenbuf;
-	unsigned char *tokenptr;
-	unsigned int tokenleft;
-	
-	camel_imap_token_t *unget;
-};
-
-struct _CamelIMAPStreamClass {
-	CamelStreamClass parent_class;
-	
-	/* Virtual methods */
-};
-
-
-/* Standard Camel function */
-CamelType camel_imap_stream_get_type (void);
-
-CamelStream *camel_imap_stream_new (CamelStream *stream);
-
-int camel_imap_stream_next_token (CamelIMAPStream *stream, camel_imap_token_t *token);
-int camel_imap_stream_unget_token (CamelIMAPStream *stream, camel_imap_token_t *token);
-
-int camel_imap_stream_line (CamelIMAPStream *stream, unsigned char **line, size_t *len);
-int camel_imap_stream_literal (CamelIMAPStream *stream, unsigned char **literal, size_t *len);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif /* __CAMEL_IMAP_STREAM_H__ */
diff --git a/camel/providers/imap4/camel-imap-summary.h b/camel/providers/imap4/camel-imap-summary.h
deleted file mode 100644
index a8faff8522..0000000000
--- a/camel/providers/imap4/camel-imap-summary.h
+++ /dev/null
@@ -1,91 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
-/*  Camel
- *  Copyright (C) 1999-2004 Jeffrey Stedfast
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
- */
-
-
-#ifndef __CAMEL_IMAP_SUMMARY_H__
-#define __CAMEL_IMAP_SUMMARY_H__
-
-#include <sys/types.h>
-
-#include <camel/camel-folder.h>
-#include <camel/camel-folder-summary.h>
-
-#ifdef __cplusplus
-extern "C" {
-#pragma }
-#endif /* __cplusplus */
-
-#define CAMEL_TYPE_IMAP_SUMMARY            (camel_imap_summary_get_type ())
-#define CAMEL_IMAP_SUMMARY(obj)            (CAMEL_CHECK_CAST ((obj), CAMEL_TYPE_IMAP_SUMMARY, CamelIMAPSummary))
-#define CAMEL_IMAP_SUMMARY_CLASS(klass)    (CAMEL_CHECK_CLASS_CAST ((klass), CAMEL_TYPE_IMAP_SUMMARY, CamelIMAPSummaryClass))
-#define CAMEL_IS_IMAP_SUMMARY(obj)         (CAMEL_CHECK_TYPE ((obj), CAMEL_TYPE_IMAP_SUMMARY))
-#define CAMEL_IS_IMAP_SUMMARY_CLASS(klass) (CAMEL_CHECK_CLASS_TYPE ((klass), CAMEL_TYPE_IMAP_SUMMARY))
-#define CAMEL_IMAP_SUMMARY_GET_CLASS(obj)  (CAMEL_CHECK_GET_CLASS ((obj), CAMEL_TYPE_FOLDER_SUMMARY, CamelIMAPSummaryClass))
-
-typedef struct _CamelIMAPMessageInfo CamelIMAPMessageInfo;
-typedef struct _CamelIMAPSummary CamelIMAPSummary;
-typedef struct _CamelIMAPSummaryClass CamelIMAPSummaryClass;
-
-struct _CamelIMAPMessageInfo {
-	CamelMessageInfo parent_info;
-	
-	guint32 server_flags;
-};
-
-struct _CamelIMAPSummary {
-	CamelFolderSummary parent_object;
-	
-	CamelFolder *folder;
-	
-	guint32 exists;
-	guint32 recent;
-	guint32 unseen;
-	
-	guint32 uidvalidity;
-	
-	guint uidvalidity_changed:1;
-	guint exists_changed:1;
-};
-
-struct _CamelIMAPSummaryClass {
-	CamelFolderSummaryClass parent_class;
-	
-};
-
-
-CamelType camel_imap_summary_get_type (void);
-
-CamelFolderSummary *camel_imap_summary_new (CamelFolder *folder);
-
-void camel_imap_summary_set_exists (CamelFolderSummary *summary, guint32 exists);
-void camel_imap_summary_set_recent (CamelFolderSummary *summary, guint32 recent);
-void camel_imap_summary_set_unseen (CamelFolderSummary *summary, guint32 unseen);
-void camel_imap_summary_set_uidnext (CamelFolderSummary *summary, guint32 uidnext);
-
-void camel_imap_summary_set_uidvalidity (CamelFolderSummary *summary, guint32 uidvalidity);
-
-void camel_imap_summary_expunge (CamelFolderSummary *summary, int seqid);
-
-int camel_imap_summary_flush_updates (CamelFolderSummary *summary, CamelException *ex);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif /* __CAMEL_IMAP_SUMMARY_H__ */
diff --git a/camel/providers/imap4/camel-imap-utils.h b/camel/providers/imap4/camel-imap-utils.h
deleted file mode 100644
index c2f87ae4e1..0000000000
--- a/camel/providers/imap4/camel-imap-utils.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
-/*  Camel
- *  Copyright (C) 1999-2004 Jeffrey Stedfast
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
- */
-
-
-#ifndef __CAMEL_IMAP_UTILS_H__
-#define __CAMEL_IMAP_UTILS_H__
-
-#include <glib.h>
-
-#ifdef __cplusplus
-extern "C" {
-#pragma }
-#endif /* __cplusplus */
-
-/* IMAP flag merging */
-typedef struct {
-	guint32 changed;
-	guint32 bits;
-} flags_diff_t;
-
-void camel_imap_flags_diff (flags_diff_t *diff, guint32 old, guint32 new);
-guint32 camel_imap_flags_merge (flags_diff_t *diff, guint32 flags);
-guint32 camel_imap_merge_flags (guint32 original, guint32 local, guint32 server);
-
-
-struct _CamelIMAPEngine;
-struct _CamelIMAPCommand;
-struct _camel_imap_token_t;
-
-void camel_imap_utils_set_unexpected_token_error (CamelException *ex, struct _CamelIMAPEngine *engine, struct _camel_imap_token_t *token);
-
-int camel_imap_parse_flags_list (struct _CamelIMAPEngine *engine, guint32 *flags, CamelException *ex);
-
-enum {
-	CAMEL_IMAP_FOLDER_MARKED          = (1 << 0),
-	CAMEL_IMAP_FOLDER_UNMARKED        = (1 << 1),
-	CAMEL_IMAP_FOLDER_NOSELECT        = (1 << 2),
-	CAMEL_IMAP_FOLDER_NOINFERIORS     = (1 << 3),
-	CAMEL_IMAP_FOLDER_HAS_CHILDREN    = (1 << 4),
-	CAMEL_IMAP_FOLDER_HAS_NO_CHILDREN = (1 << 5),
-};
-
-typedef struct {
-	guint32 flags;
-	char delim;
-	char *name;
-} camel_imap_list_t;
-
-int camel_imap_untagged_list (struct _CamelIMAPEngine *engine, struct _CamelIMAPCommand *ic,
-			       guint32 index, struct _camel_imap_token_t *token, CamelException *ex);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif /* __CAMEL_IMAP_UTILS_H__ */
diff --git a/camel/providers/imap4/camel-imap-command.c b/camel/providers/imap4/camel-imap4-command.c
index e5668ccbc6..c1ff3a289b 100644
--- a/camel/providers/imap4/camel-imap-command.c
+++ b/camel/providers/imap4/camel-imap4-command.c
@@ -30,34 +30,34 @@
 #include <camel/camel-stream-filter.h>
 #include <camel/camel-mime-filter-crlf.h>
 
-#include "camel-imap-stream.h"
-#include "camel-imap-engine.h"
-#include "camel-imap-folder.h"
-#include "camel-imap-specials.h"
+#include "camel-imap4-stream.h"
+#include "camel-imap4-engine.h"
+#include "camel-imap4-folder.h"
+#include "camel-imap4-specials.h"
 
-#include "camel-imap-command.h"
+#include "camel-imap4-command.h"
 
 
 #define d(x) x
 
 
 enum {
-	IMAP_STRING_ATOM,
-	IMAP_STRING_QSTRING,
-	IMAP_STRING_LITERAL,
+	IMAP4_STRING_ATOM,
+	IMAP4_STRING_QSTRING,
+	IMAP4_STRING_LITERAL,
 };
 
 static int
-imap_string_get_type (const char *str)
+imap4_string_get_type (const char *str)
 {
 	int type = 0;
 	
 	while (*str) {
 		if (!is_atom (*str)) {
 			if (is_qsafe (*str))
-				type = IMAP_STRING_QSTRING;
+				type = IMAP4_STRING_QSTRING;
 			else
-				return IMAP_STRING_LITERAL;
+				return IMAP4_STRING_LITERAL;
 		}
 		str++;
 	}
@@ -67,7 +67,7 @@ imap_string_get_type (const char *str)
 
 #if 0
 static gboolean
-imap_string_is_atom_safe (const char *str)
+imap4_string_is_atom_safe (const char *str)
 {
 	while (is_atom (*str))
 		str++;
@@ -76,7 +76,7 @@ imap_string_is_atom_safe (const char *str)
 }
 
 static gboolean
-imap_string_is_quote_safe (const char *str)
+imap4_string_is_quote_safe (const char *str)
 {
 	while (is_qsafe (*str))
 		str++;
@@ -86,13 +86,13 @@ imap_string_is_quote_safe (const char *str)
 #endif
 
 static size_t
-camel_imap_literal_length (CamelIMAPLiteral *literal)
+camel_imap4_literal_length (CamelIMAP4Literal *literal)
 {
 	CamelStream *stream, *null;
 	CamelMimeFilter *crlf;
 	size_t len;
 	
-	if (literal->type == CAMEL_IMAP_LITERAL_STRING)
+	if (literal->type == CAMEL_IMAP4_LITERAL_STRING)
 		return strlen (literal->literal.string);
 	
 	null = camel_stream_null_new ();
@@ -102,11 +102,11 @@ camel_imap_literal_length (CamelIMAPLiteral *literal)
 	camel_object_unref (crlf);
 	
 	switch (literal->type) {
-	case CAMEL_IMAP_LITERAL_STREAM:
+	case CAMEL_IMAP4_LITERAL_STREAM:
 		camel_stream_write_to_stream (literal->literal.stream, stream);
 		camel_stream_reset (literal->literal.stream);
 		break;
-	case CAMEL_IMAP_LITERAL_WRAPPER:
+	case CAMEL_IMAP4_LITERAL_WRAPPER:
 		camel_data_wrapper_write_to_stream (literal->literal.wrapper, stream);
 		break;
 	default:
@@ -122,12 +122,12 @@ camel_imap_literal_length (CamelIMAPLiteral *literal)
 	return len;
 }
 
-static CamelIMAPCommandPart *
+static CamelIMAP4CommandPart *
 command_part_new (void)
 {
-	CamelIMAPCommandPart *part;
+	CamelIMAP4CommandPart *part;
 	
-	part = g_new (CamelIMAPCommandPart, 1);
+	part = g_new (CamelIMAP4CommandPart, 1);
 	part->next = NULL;
 	part->buffer = NULL;
 	part->buflen = 0;
@@ -137,29 +137,29 @@ command_part_new (void)
 }
 
 static void
-imap_command_append_string (CamelIMAPEngine *engine, CamelIMAPCommandPart **tail, GString *str, const char *string)
+imap4_command_append_string (CamelIMAP4Engine *engine, CamelIMAP4CommandPart **tail, GString *str, const char *string)
 {
-	CamelIMAPCommandPart *part;
-	CamelIMAPLiteral *literal;
+	CamelIMAP4CommandPart *part;
+	CamelIMAP4Literal *literal;
 	
-	switch (imap_string_get_type (string)) {
-	case IMAP_STRING_ATOM:
+	switch (imap4_string_get_type (string)) {
+	case IMAP4_STRING_ATOM:
 		/* string is safe as it is... */
 		g_string_append (str, string);
 		break;
-	case IMAP_STRING_QSTRING:
+	case IMAP4_STRING_QSTRING:
 		/* we need to quote the string */
 		/* FIXME: need to escape stuff */
 		g_string_append_printf (str, "\"%s\"", string);
 		break;
-	case IMAP_STRING_LITERAL:
-		if (engine->capa & CAMEL_IMAP_CAPABILITY_LITERALPLUS) {
+	case IMAP4_STRING_LITERAL:
+		if (engine->capa & CAMEL_IMAP4_CAPABILITY_LITERALPLUS) {
 			/* we have to send a literal, but the server supports LITERAL+ so use that */
 			g_string_append_printf (str, "{%u+}\r\n%s", strlen (string), string);
 		} else {
 			/* we have to make it a literal */
-			literal = g_new (CamelIMAPLiteral, 1);
-			literal->type = CAMEL_IMAP_LITERAL_STRING;
+			literal = g_new (CamelIMAP4Literal, 1);
+			literal->type = CAMEL_IMAP4_LITERAL_STRING;
 			literal->literal.string = g_strdup (string);
 			
 			g_string_append_printf (str, "{%u}\r\n", strlen (string));
@@ -178,11 +178,11 @@ imap_command_append_string (CamelIMAPEngine *engine, CamelIMAPCommandPart **tail
 	}
 }
 
-CamelIMAPCommand *
-camel_imap_command_newv (CamelIMAPEngine *engine, CamelIMAPFolder *imap_folder, const char *format, va_list args)
+CamelIMAP4Command *
+camel_imap4_command_newv (CamelIMAP4Engine *engine, CamelIMAP4Folder *imap4_folder, const char *format, va_list args)
 {
-	CamelIMAPCommandPart *parts, *part, *tail;
-	CamelIMAPCommand *ic;
+	CamelIMAP4CommandPart *parts, *part, *tail;
+	CamelIMAP4Command *ic;
 	const char *start;
 	GString *str;
 	
@@ -195,8 +195,8 @@ camel_imap_command_newv (CamelIMAPEngine *engine, CamelIMAPFolder *imap_folder,
 		register char ch = *format++;
 		
 		if (ch == '%') {
-			CamelIMAPLiteral *literal;
-			CamelIMAPFolder *folder;
+			CamelIMAP4Literal *literal;
+			CamelIMAP4Folder *folder;
 			unsigned int u;
 			char *string;
 			size_t len;
@@ -226,21 +226,21 @@ camel_imap_command_newv (CamelIMAPEngine *engine, CamelIMAPFolder *imap_folder,
 				g_string_append_printf (str, "%u", u);
 				break;
 			case 'F':
-				/* CamelIMAPFolder */
-				folder = va_arg (args, CamelIMAPFolder *);
-				string = (char *) camel_imap_folder_utf7_name (folder);
-				imap_command_append_string (engine, &tail, str, string);
+				/* CamelIMAP4Folder */
+				folder = va_arg (args, CamelIMAP4Folder *);
+				string = (char *) camel_imap4_folder_utf7_name (folder);
+				imap4_command_append_string (engine, &tail, str, string);
 				break;
 			case 'L':
 				/* Literal */
 				obj = va_arg (args, void *);
 				
-				literal = g_new (CamelIMAPLiteral, 1);
+				literal = g_new (CamelIMAP4Literal, 1);
 				if (CAMEL_IS_DATA_WRAPPER (obj)) {
-					literal->type = CAMEL_IMAP_LITERAL_WRAPPER;
+					literal->type = CAMEL_IMAP4_LITERAL_WRAPPER;
 					literal->literal.wrapper = obj;
 				} else if (CAMEL_IS_STREAM (obj)) {
-					literal->type = CAMEL_IMAP_LITERAL_STREAM;
+					literal->type = CAMEL_IMAP4_LITERAL_STREAM;
 					literal->literal.stream = obj;
 				} else {
 					g_assert_not_reached ();
@@ -249,7 +249,7 @@ camel_imap_command_newv (CamelIMAPEngine *engine, CamelIMAPFolder *imap_folder,
 				camel_object_ref (obj);
 				
 				/* FIXME: take advantage of LITERAL+? */
-				len = camel_imap_literal_length (literal);
+				len = camel_imap4_literal_length (literal);
 				g_string_append_printf (str, "{%u}\r\n", len);
 				
 				tail->buffer = g_strdup (str->str);
@@ -266,7 +266,7 @@ camel_imap_command_newv (CamelIMAPEngine *engine, CamelIMAPFolder *imap_folder,
 			case 'S':
 				/* string which may need to be quoted or made into a literal */
 				string = va_arg (args, char *);
-				imap_command_append_string (engine, &tail, str, string);
+				imap4_command_append_string (engine, &tail, str, string);
 				break;
 			case 's':
 				/* safe atom string */
@@ -292,11 +292,11 @@ camel_imap_command_newv (CamelIMAPEngine *engine, CamelIMAPFolder *imap_folder,
 	tail->literal = NULL;
 	g_string_free (str, FALSE);
 	
-	ic = g_new0 (CamelIMAPCommand, 1);
+	ic = g_new0 (CamelIMAP4Command, 1);
 	((EDListNode *) ic)->next = NULL;
 	((EDListNode *) ic)->prev = NULL;
 	ic->untagged = g_hash_table_new (g_str_hash, g_str_equal);
-	ic->status = CAMEL_IMAP_COMMAND_QUEUED;
+	ic->status = CAMEL_IMAP4_COMMAND_QUEUED;
 	ic->resp_codes = g_ptr_array_new ();
 	ic->engine = engine;
 	ic->ref_count = 1;
@@ -305,44 +305,44 @@ camel_imap_command_newv (CamelIMAPEngine *engine, CamelIMAPFolder *imap_folder,
 	
 	camel_exception_init (&ic->ex);
 	
-	if (imap_folder) {
-		camel_object_ref (imap_folder);
-		ic->folder = imap_folder;
+	if (imap4_folder) {
+		camel_object_ref (imap4_folder);
+		ic->folder = imap4_folder;
 	} else
 		ic->folder = NULL;
 	
 	return ic;
 }
 
-CamelIMAPCommand *
-camel_imap_command_new (CamelIMAPEngine *engine, CamelIMAPFolder *folder, const char *format, ...)
+CamelIMAP4Command *
+camel_imap4_command_new (CamelIMAP4Engine *engine, CamelIMAP4Folder *folder, const char *format, ...)
 {
-	CamelIMAPCommand *command;
+	CamelIMAP4Command *command;
 	va_list args;
 	
 	va_start (args, format);
-	command = camel_imap_command_newv (engine, folder, format, args);
+	command = camel_imap4_command_newv (engine, folder, format, args);
 	va_end (args);
 	
 	return command;
 }
 
 void
-camel_imap_command_register_untagged (CamelIMAPCommand *ic, const char *atom, CamelIMAPUntaggedCallback untagged)
+camel_imap4_command_register_untagged (CamelIMAP4Command *ic, const char *atom, CamelIMAP4UntaggedCallback untagged)
 {
 	g_hash_table_insert (ic->untagged, g_strdup (atom), untagged);
 }
 
 void
-camel_imap_command_ref (CamelIMAPCommand *ic)
+camel_imap4_command_ref (CamelIMAP4Command *ic)
 {
 	ic->ref_count++;
 }
 
 void
-camel_imap_command_unref (CamelIMAPCommand *ic)
+camel_imap4_command_unref (CamelIMAP4Command *ic)
 {
-	CamelIMAPCommandPart *part, *next;
+	CamelIMAP4CommandPart *part, *next;
 	int i;
 	
 	if (ic == NULL)
@@ -356,10 +356,10 @@ camel_imap_command_unref (CamelIMAPCommand *ic)
 		g_free (ic->tag);
 		
 		for (i = 0; i < ic->resp_codes->len; i++) {
-			CamelIMAPRespCode *resp_code;
+			CamelIMAP4RespCode *resp_code;
 			
 			resp_code = ic->resp_codes->pdata[i];
-			camel_imap_resp_code_free (resp_code);
+			camel_imap4_resp_code_free (resp_code);
 		}
 		g_ptr_array_free (ic->resp_codes, TRUE);
 		
@@ -373,13 +373,13 @@ camel_imap_command_unref (CamelIMAPCommand *ic)
 			g_free (part->buffer);
 			if (part->literal) {
 				switch (part->literal->type) {
-				case CAMEL_IMAP_LITERAL_STRING:
+				case CAMEL_IMAP4_LITERAL_STRING:
 					g_free (part->literal->literal.string);
 					break;
-				case CAMEL_IMAP_LITERAL_STREAM:
+				case CAMEL_IMAP4_LITERAL_STREAM:
 					camel_object_unref (part->literal->literal.stream);
 					break;
-				case CAMEL_IMAP_LITERAL_WRAPPER:
+				case CAMEL_IMAP4_LITERAL_WRAPPER:
 					camel_object_unref (part->literal->literal.wrapper);
 					break;
 				}
@@ -398,14 +398,14 @@ camel_imap_command_unref (CamelIMAPCommand *ic)
 
 
 static int
-imap_literal_write_to_stream (CamelIMAPLiteral *literal, CamelStream *stream)
+imap4_literal_write_to_stream (CamelIMAP4Literal *literal, CamelStream *stream)
 {
 	CamelStream *istream, *ostream = NULL;
 	CamelDataWrapper *wrapper;
 	CamelMimeFilter *crlf;
 	char *string;
 	
-	if (literal->type == CAMEL_IMAP_LITERAL_STRING) {
+	if (literal->type == CAMEL_IMAP4_LITERAL_STRING) {
 		string = literal->literal.string;
 		if (camel_stream_write (stream, string, strlen (string)) == -1)
 			return -1;
@@ -420,12 +420,12 @@ imap_literal_write_to_stream (CamelIMAPLiteral *literal, CamelStream *stream)
 	
 	/* write the literal */
 	switch (literal->type) {
-	case CAMEL_IMAP_LITERAL_STREAM:
+	case CAMEL_IMAP4_LITERAL_STREAM:
 		istream = literal->literal.stream;
 		if (camel_stream_write_to_stream (istream, ostream) == -1)
 			goto exception;
 		break;
-	case CAMEL_IMAP_LITERAL_WRAPPER:
+	case CAMEL_IMAP4_LITERAL_WRAPPER:
 		wrapper = literal->literal.wrapper;
 		if (camel_data_wrapper_write_to_stream (wrapper, ostream) == -1)
 			goto exception;
@@ -451,25 +451,25 @@ imap_literal_write_to_stream (CamelIMAPLiteral *literal, CamelStream *stream)
 
 
 static void
-unexpected_token (camel_imap_token_t *token)
+unexpected_token (camel_imap4_token_t *token)
 {
 	switch (token->token) {
-	case CAMEL_IMAP_TOKEN_NO_DATA:
+	case CAMEL_IMAP4_TOKEN_NO_DATA:
 		fprintf (stderr, "*** NO DATA ***");
 		break;
-	case CAMEL_IMAP_TOKEN_ERROR:
+	case CAMEL_IMAP4_TOKEN_ERROR:
 		fprintf (stderr, "*** ERROR ***");
 		break;
-	case CAMEL_IMAP_TOKEN_NIL:
+	case CAMEL_IMAP4_TOKEN_NIL:
 		fprintf (stderr, "NIL");
 		break;
-	case CAMEL_IMAP_TOKEN_ATOM:
+	case CAMEL_IMAP4_TOKEN_ATOM:
 	        fprintf (stderr, "%s", token->v.atom);
 		break;
-	case CAMEL_IMAP_TOKEN_QSTRING:
+	case CAMEL_IMAP4_TOKEN_QSTRING:
 	        fprintf (stderr, "\"%s\"", token->v.qstring);
 		break;
-	case CAMEL_IMAP_TOKEN_LITERAL:
+	case CAMEL_IMAP4_TOKEN_LITERAL:
 		fprintf (stderr, "{%u}", token->v.literal);
 		break;
 	default:
@@ -479,12 +479,12 @@ unexpected_token (camel_imap_token_t *token)
 }
 
 int
-camel_imap_command_step (CamelIMAPCommand *ic)
+camel_imap4_command_step (CamelIMAP4Command *ic)
 {
-	CamelIMAPEngine *engine = ic->engine;
-	int result = CAMEL_IMAP_RESULT_NONE;
-	CamelIMAPLiteral *literal;
-	camel_imap_token_t token;
+	CamelIMAP4Engine *engine = ic->engine;
+	int result = CAMEL_IMAP4_RESULT_NONE;
+	CamelIMAP4Literal *literal;
+	camel_imap4_token_t token;
 	unsigned char *linebuf;
 	ssize_t nwritten;
 	size_t len;
@@ -532,21 +532,21 @@ camel_imap_command_step (CamelIMAPCommand *ic)
 	if (camel_stream_flush (engine->ostream) == -1)
 		goto exception;
 	
-	/* now we need to read the response(s) from the IMAP server */
+	/* now we need to read the response(s) from the IMAP4 server */
 	
 	do {
-		if (camel_imap_engine_next_token (engine, &token, &ic->ex) == -1)
+		if (camel_imap4_engine_next_token (engine, &token, &ic->ex) == -1)
 			goto exception;
 		
 		if (token.token == '+') {
 			/* we got a continuation response from the server */
 			literal = ic->part->literal;
 			
-			if (camel_imap_engine_line (engine, &linebuf, &len, &ic->ex) == -1)
+			if (camel_imap4_engine_line (engine, &linebuf, &len, &ic->ex) == -1)
 				goto exception;
 			
 			if (literal) {
-				if (imap_literal_write_to_stream (literal, engine->ostream) == -1)
+				if (imap4_literal_write_to_stream (literal, engine->ostream) == -1)
 					goto exception;
 				
 				g_free (linebuf);
@@ -570,39 +570,39 @@ camel_imap_command_step (CamelIMAPCommand *ic)
 			linebuf = NULL;
 		} else if (token.token == '*') {
 			/* we got an untagged response, let the engine handle this */
-			if (camel_imap_engine_handle_untagged_1 (engine, &token, &ic->ex) == -1)
+			if (camel_imap4_engine_handle_untagged_1 (engine, &token, &ic->ex) == -1)
 				goto exception;
-		} else if (token.token == CAMEL_IMAP_TOKEN_ATOM && !strcmp (token.v.atom, ic->tag)) {
+		} else if (token.token == CAMEL_IMAP4_TOKEN_ATOM && !strcmp (token.v.atom, ic->tag)) {
 			/* we got "<tag> OK/NO/BAD" */
 			fprintf (stderr, "got %s response\n", token.v.atom);
 			
-			if (camel_imap_engine_next_token (engine, &token, &ic->ex) == -1)
+			if (camel_imap4_engine_next_token (engine, &token, &ic->ex) == -1)
 				goto exception;
 			
-			if (token.token == CAMEL_IMAP_TOKEN_ATOM) {
+			if (token.token == CAMEL_IMAP4_TOKEN_ATOM) {
 				if (!strcmp (token.v.atom, "OK"))
-					result = CAMEL_IMAP_RESULT_OK;
+					result = CAMEL_IMAP4_RESULT_OK;
 				else if (!strcmp (token.v.atom, "NO"))
-					result = CAMEL_IMAP_RESULT_NO;
+					result = CAMEL_IMAP4_RESULT_NO;
 				else if (!strcmp (token.v.atom, "BAD"))
-					result = CAMEL_IMAP_RESULT_BAD;
+					result = CAMEL_IMAP4_RESULT_BAD;
 				
-				if (result == CAMEL_IMAP_RESULT_NONE) {
+				if (result == CAMEL_IMAP4_RESULT_NONE) {
 					fprintf (stderr, "expected OK/NO/BAD but got %s\n", token.v.atom);
 					goto unexpected;
 				}
 				
-				if (camel_imap_engine_next_token (engine, &token, &ic->ex) == -1)
+				if (camel_imap4_engine_next_token (engine, &token, &ic->ex) == -1)
 					goto exception;
 				
 				if (token.token == '[') {
 					/* we have a response code */
-					camel_imap_stream_unget_token (engine->istream, &token);
-					if (camel_imap_engine_parse_resp_code (engine, &ic->ex) == -1)
+					camel_imap4_stream_unget_token (engine->istream, &token);
+					if (camel_imap4_engine_parse_resp_code (engine, &ic->ex) == -1)
 						goto exception;
 				} else if (token.token != '\n') {
 					/* just gobble up the rest of the line */
-					if (camel_imap_engine_line (engine, NULL, NULL, &ic->ex) == -1)
+					if (camel_imap4_engine_line (engine, NULL, NULL, &ic->ex) == -1)
 						goto exception;
 				}
 			} else {
@@ -622,11 +622,11 @@ camel_imap_command_step (CamelIMAPCommand *ic)
 		unexpected:
 			
 			/* no fucking clue what we got... */
-			if (camel_imap_engine_line (engine, &linebuf, &len, &ic->ex) == -1)
+			if (camel_imap4_engine_line (engine, &linebuf, &len, &ic->ex) == -1)
 				goto exception;
 			
 			camel_exception_setv (&ic->ex, CAMEL_EXCEPTION_SYSTEM,
-					      _("Unexpected response from IMAP server %s: %s"),
+					      _("Unexpected response from IMAP4 server %s: %s"),
 					      engine->url->host, linebuf);
 			
 			g_free (linebuf);
@@ -636,10 +636,10 @@ camel_imap_command_step (CamelIMAPCommand *ic)
 	} while (1);
 	
 	/* status should always be ACTIVE here... */
-	if (ic->status == CAMEL_IMAP_COMMAND_ACTIVE) {
+	if (ic->status == CAMEL_IMAP4_COMMAND_ACTIVE) {
 		ic->part = ic->part->next;
 		if (ic->part == NULL || result) {
-			ic->status = CAMEL_IMAP_COMMAND_COMPLETE;
+			ic->status = CAMEL_IMAP4_COMMAND_COMPLETE;
 			ic->result = result;
 			return 1;
 		}
@@ -649,23 +649,23 @@ camel_imap_command_step (CamelIMAPCommand *ic)
 	
  exception:
 	
-	ic->status = CAMEL_IMAP_COMMAND_ERROR;
+	ic->status = CAMEL_IMAP4_COMMAND_ERROR;
 	
 	return -1;
 }
 
 
 void
-camel_imap_command_reset (CamelIMAPCommand *ic)
+camel_imap4_command_reset (CamelIMAP4Command *ic)
 {
 	int i;
 	
 	for (i = 0; i < ic->resp_codes->len; i++)
-		camel_imap_resp_code_free (ic->resp_codes->pdata[i]);
+		camel_imap4_resp_code_free (ic->resp_codes->pdata[i]);
 	g_ptr_array_set_size (ic->resp_codes, 0);
 	
-	ic->status = CAMEL_IMAP_COMMAND_QUEUED;
-	ic->result = CAMEL_IMAP_RESULT_NONE;
+	ic->status = CAMEL_IMAP4_COMMAND_QUEUED;
+	ic->result = CAMEL_IMAP4_RESULT_NONE;
 	ic->part = ic->parts;
 	g_free (ic->tag);
 	ic->tag = NULL;
diff --git a/camel/providers/imap4/camel-imap4-command.h b/camel/providers/imap4/camel-imap4-command.h
new file mode 100644
index 0000000000..49487b1b2d
--- /dev/null
+++ b/camel/providers/imap4/camel-imap4-command.h
@@ -0,0 +1,144 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*  Camel
+ *  Copyright (C) 1999-2004 Jeffrey Stedfast
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __CAMEL_IMAP4_COMMAND_H__
+#define __CAMEL_IMAP4_COMMAND_H__
+
+#include <stdarg.h>
+
+#include <glib.h>
+
+#include <e-util/e-msgport.h>
+
+#include <camel/camel-stream.h>
+#include <camel/camel-exception.h>
+#include <camel/camel-data-wrapper.h>
+
+#ifdef __cplusplus
+extern "C" {
+#pragma }
+#endif /* __cplusplus */
+
+struct _CamelIMAP4Engine;
+struct _CamelIMAP4Folder;
+struct _camel_imap4_token_t;
+
+typedef struct _CamelIMAP4Command CamelIMAP4Command;
+typedef struct _CamelIMAP4Literal CamelIMAP4Literal;
+
+typedef int (* CamelIMAP4PlusCallback) (struct _CamelIMAP4Engine *engine,
+					CamelIMAP4Command *ic,
+					const unsigned char *linebuf,
+					size_t linelen, CamelException *ex);
+
+typedef int (* CamelIMAP4UntaggedCallback) (struct _CamelIMAP4Engine *engine,
+					    CamelIMAP4Command *ic,
+					    guint32 index,
+					    struct _camel_imap4_token_t *token,
+					    CamelException *ex);
+
+enum {
+	CAMEL_IMAP4_LITERAL_STRING,
+	CAMEL_IMAP4_LITERAL_STREAM,
+	CAMEL_IMAP4_LITERAL_WRAPPER,
+};
+
+struct _CamelIMAP4Literal {
+	int type;
+	union {
+		char *string;
+		CamelStream *stream;
+		CamelDataWrapper *wrapper;
+	} literal;
+};
+
+typedef struct _CamelIMAP4CommandPart {
+	struct _CamelIMAP4CommandPart *next;
+	unsigned char *buffer;
+	size_t buflen;
+	
+	CamelIMAP4Literal *literal;
+} CamelIMAP4CommandPart;
+
+enum {
+	CAMEL_IMAP4_COMMAND_QUEUED,
+	CAMEL_IMAP4_COMMAND_ACTIVE,
+	CAMEL_IMAP4_COMMAND_COMPLETE,
+	CAMEL_IMAP4_COMMAND_ERROR,
+};
+
+enum {
+	CAMEL_IMAP4_RESULT_NONE,
+	CAMEL_IMAP4_RESULT_OK,
+	CAMEL_IMAP4_RESULT_NO,
+	CAMEL_IMAP4_RESULT_BAD,
+};
+
+struct _CamelIMAP4Command {
+	EDListNode node;
+	
+	struct _CamelIMAP4Engine *engine;
+	
+	unsigned int ref_count:26;
+	unsigned int status:3;
+	unsigned int result:3;
+	int id;
+	
+	char *tag;
+	
+	GPtrArray *resp_codes;
+	
+	struct _CamelIMAP4Folder *folder;
+	CamelException ex;
+	
+	/* command parts - logical breaks in the overall command based on literals */
+	CamelIMAP4CommandPart *parts;
+	
+	/* current part */
+	CamelIMAP4CommandPart *part;
+	
+	/* untagged handlers */
+	GHashTable *untagged;
+	
+	/* '+' callback/data */
+	CamelIMAP4PlusCallback plus;
+	void *user_data;
+};
+
+CamelIMAP4Command *camel_imap4_command_new (struct _CamelIMAP4Engine *engine, struct _CamelIMAP4Folder *folder,
+					    const char *format, ...);
+CamelIMAP4Command *camel_imap4_command_newv (struct _CamelIMAP4Engine *engine, struct _CamelIMAP4Folder *folder,
+					     const char *format, va_list args);
+
+void camel_imap4_command_register_untagged (CamelIMAP4Command *ic, const char *atom, CamelIMAP4UntaggedCallback untagged);
+
+void camel_imap4_command_ref (CamelIMAP4Command *ic);
+void camel_imap4_command_unref (CamelIMAP4Command *ic);
+
+/* returns 1 when complete, 0 if there is more to do, or -1 on error */
+int camel_imap4_command_step (CamelIMAP4Command *ic);
+
+void camel_imap4_command_reset (CamelIMAP4Command *ic);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __CAMEL_IMAP4_COMMAND_H__ */
diff --git a/camel/providers/imap4/camel-imap-engine.c b/camel/providers/imap4/camel-imap4-engine.c
index 86afb12fd5..5e3d93ddaf 100644
--- a/camel/providers/imap4/camel-imap-engine.c
+++ b/camel/providers/imap4/camel-imap4-engine.c
@@ -29,46 +29,46 @@
 #include <camel/camel-sasl.h>
 #include <camel/camel-stream-buffer.h>
 
-#include "camel-imap-summary.h"
-#include "camel-imap-command.h"
-#include "camel-imap-stream.h"
-#include "camel-imap-folder.h"
-#include "camel-imap-utils.h"
+#include "camel-imap4-summary.h"
+#include "camel-imap4-command.h"
+#include "camel-imap4-stream.h"
+#include "camel-imap4-folder.h"
+#include "camel-imap4-utils.h"
 
-#include "camel-imap-engine.h"
+#include "camel-imap4-engine.h"
 
 #define d(x) x
 
 
-static void camel_imap_engine_class_init (CamelIMAPEngineClass *klass);
-static void camel_imap_engine_init (CamelIMAPEngine *engine, CamelIMAPEngineClass *klass);
-static void camel_imap_engine_finalize (CamelObject *object);
+static void camel_imap4_engine_class_init (CamelIMAP4EngineClass *klass);
+static void camel_imap4_engine_init (CamelIMAP4Engine *engine, CamelIMAP4EngineClass *klass);
+static void camel_imap4_engine_finalize (CamelObject *object);
 
 
 static CamelObjectClass *parent_class = NULL;
 
 
 CamelType
-camel_imap_engine_get_type (void)
+camel_imap4_engine_get_type (void)
 {
 	static CamelType type = 0;
 	
 	if (!type) {
-		type = camel_type_register (CAMEL_TYPE_IMAP_ENGINE,
-					    "CamelIMAPEngine",
-					    sizeof (CamelIMAPEngine),
-					    sizeof (CamelIMAPEngineClass),
-					    (CamelObjectClassInitFunc) camel_imap_engine_class_init,
+		type = camel_type_register (CAMEL_TYPE_IMAP4_ENGINE,
+					    "CamelIMAP4Engine",
+					    sizeof (CamelIMAP4Engine),
+					    sizeof (CamelIMAP4EngineClass),
+					    (CamelObjectClassInitFunc) camel_imap4_engine_class_init,
 					    NULL,
-					    (CamelObjectInitFunc) camel_imap_engine_init,
-					    (CamelObjectFinalizeFunc) camel_imap_engine_finalize);
+					    (CamelObjectInitFunc) camel_imap4_engine_init,
+					    (CamelObjectFinalizeFunc) camel_imap4_engine_finalize);
 	}
 	
 	return type;
 }
 
 static void
-camel_imap_engine_class_init (CamelIMAPEngineClass *klass)
+camel_imap4_engine_class_init (CamelIMAP4EngineClass *klass)
 {
 	parent_class = camel_type_get_global_classfuncs (CAMEL_OBJECT_TYPE);
 	
@@ -76,10 +76,10 @@ camel_imap_engine_class_init (CamelIMAPEngineClass *klass)
 }
 
 static void
-camel_imap_engine_init (CamelIMAPEngine *engine, CamelIMAPEngineClass *klass)
+camel_imap4_engine_init (CamelIMAP4Engine *engine, CamelIMAP4EngineClass *klass)
 {
-	engine->state = CAMEL_IMAP_ENGINE_DISCONNECTED;
-	engine->level = CAMEL_IMAP_LEVEL_UNKNOWN;
+	engine->state = CAMEL_IMAP4_ENGINE_DISCONNECTED;
+	engine->level = CAMEL_IMAP4_LEVEL_UNKNOWN;
 	
 	engine->session = NULL;
 	engine->url = NULL;
@@ -92,7 +92,7 @@ camel_imap_engine_init (CamelIMAPEngine *engine, CamelIMAPEngineClass *klass)
 	engine->capa = 0;
 	
 	/* this is the suggested default, impacts the max command line length we'll send */
-	engine->maxlentype = CAMEL_IMAP_ENGINE_MAXLEN_LINE;
+	engine->maxlentype = CAMEL_IMAP4_ENGINE_MAXLEN_LINE;
 	engine->maxlen = 1000;
 	
 	engine->namespaces.personal = NULL;
@@ -113,9 +113,9 @@ camel_imap_engine_init (CamelIMAPEngine *engine, CamelIMAPEngineClass *klass)
 }
 
 static void
-imap_namespace_clear (CamelIMAPNamespace **namespace)
+imap4_namespace_clear (CamelIMAP4Namespace **namespace)
 {
-	CamelIMAPNamespace *node, *next;
+	CamelIMAP4Namespace *node, *next;
 	
 	node = *namespace;
 	while (node != NULL) {
@@ -129,9 +129,9 @@ imap_namespace_clear (CamelIMAPNamespace **namespace)
 }
 
 static void
-camel_imap_engine_finalize (CamelObject *object)
+camel_imap4_engine_finalize (CamelObject *object)
 {
-	CamelIMAPEngine *engine = (CamelIMAPEngine *) object;
+	CamelIMAP4Engine *engine = (CamelIMAP4Engine *) object;
 	EDListNode *node;
 	
 	if (engine->session)
@@ -146,9 +146,9 @@ camel_imap_engine_finalize (CamelObject *object)
 	g_hash_table_foreach (engine->authtypes, (GHFunc) g_free, NULL);
 	g_hash_table_destroy (engine->authtypes);
 	
-	imap_namespace_clear (&engine->namespaces.personal);
-	imap_namespace_clear (&engine->namespaces.other);
-	imap_namespace_clear (&engine->namespaces.shared);
+	imap4_namespace_clear (&engine->namespaces.personal);
+	imap4_namespace_clear (&engine->namespaces.other);
+	imap4_namespace_clear (&engine->namespaces.shared);
 	
 	if (engine->folder)
 		camel_object_unref (engine->folder);
@@ -157,26 +157,26 @@ camel_imap_engine_finalize (CamelObject *object)
 		node->next = NULL;
 		node->prev = NULL;
 		
-		camel_imap_command_unref ((CamelIMAPCommand *) node);
+		camel_imap4_command_unref ((CamelIMAP4Command *) node);
 	}
 }
 
 
 /**
- * camel_imap_engine_new:
+ * camel_imap4_engine_new:
  * @session: session
  * @url: service url
  *
- * Returns a new imap engine
+ * Returns a new imap4 engine
  **/
-CamelIMAPEngine *
-camel_imap_engine_new (CamelSession *session, CamelURL *url)
+CamelIMAP4Engine *
+camel_imap4_engine_new (CamelSession *session, CamelURL *url)
 {
-	CamelIMAPEngine *engine;
+	CamelIMAP4Engine *engine;
 	
 	g_return_val_if_fail (CAMEL_IS_SESSION (session), NULL);
 	
-	engine = (CamelIMAPEngine *) camel_object_new (CAMEL_TYPE_IMAP_ENGINE);
+	engine = (CamelIMAP4Engine *) camel_object_new (CAMEL_TYPE_IMAP4_ENGINE);
 	camel_object_ref (session);
 	engine->session = session;
 	engine->url = url;
@@ -186,8 +186,8 @@ camel_imap_engine_new (CamelSession *session, CamelURL *url)
 
 
 /**
- * camel_imap_engine_take_stream:
- * @engine: imap engine
+ * camel_imap4_engine_take_stream:
+ * @engine: imap4 engine
  * @stream: tcp stream
  * @ex: exception
  *
@@ -199,12 +199,12 @@ camel_imap_engine_new (CamelSession *session, CamelURL *url)
  * Note: on error, @stream will be unref'd.
  **/
 int
-camel_imap_engine_take_stream (CamelIMAPEngine *engine, CamelStream *stream, CamelException *ex)
+camel_imap4_engine_take_stream (CamelIMAP4Engine *engine, CamelStream *stream, CamelException *ex)
 {
-	camel_imap_token_t token;
+	camel_imap4_token_t token;
 	int code;
 	
-	g_return_val_if_fail (CAMEL_IS_IMAP_ENGINE (engine), -1);
+	g_return_val_if_fail (CAMEL_IS_IMAP4_ENGINE (engine), -1);
 	g_return_val_if_fail (CAMEL_IS_STREAM (stream), -1);
 	
 	if (engine->istream)
@@ -213,22 +213,22 @@ camel_imap_engine_take_stream (CamelIMAPEngine *engine, CamelStream *stream, Cam
 	if (engine->ostream)
 		camel_object_unref (engine->ostream);
 	
-	engine->istream = (CamelIMAPStream *) camel_imap_stream_new (stream);
+	engine->istream = (CamelIMAP4Stream *) camel_imap4_stream_new (stream);
 	engine->ostream = camel_stream_buffer_new (stream, CAMEL_STREAM_BUFFER_WRITE);
-	engine->state = CAMEL_IMAP_ENGINE_CONNECTED;
+	engine->state = CAMEL_IMAP4_ENGINE_CONNECTED;
 	camel_object_unref (stream);
 	
-	if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 		goto exception;
 	
 	if (token.token != '*') {
-		camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 		goto exception;
 	}
 	
-	if ((code = camel_imap_engine_handle_untagged_1 (engine, &token, ex)) == -1) {
+	if ((code = camel_imap4_engine_handle_untagged_1 (engine, &token, ex)) == -1) {
 		goto exception;
-	} else if (code != CAMEL_IMAP_UNTAGGED_OK && code != CAMEL_IMAP_UNTAGGED_PREAUTH) {
+	} else if (code != CAMEL_IMAP4_UNTAGGED_OK && code != CAMEL_IMAP4_UNTAGGED_PREAUTH) {
 		/* FIXME: set an error? */
 		goto exception;
 	}
@@ -237,7 +237,7 @@ camel_imap_engine_take_stream (CamelIMAPEngine *engine, CamelStream *stream, Cam
 	
  exception:
 	
-	engine->state = CAMEL_IMAP_ENGINE_DISCONNECTED;
+	engine->state = CAMEL_IMAP4_ENGINE_DISCONNECTED;
 	
 	camel_object_unref (engine->istream);
 	engine->istream = NULL;
@@ -249,78 +249,78 @@ camel_imap_engine_take_stream (CamelIMAPEngine *engine, CamelStream *stream, Cam
 
 
 /**
- * camel_imap_engine_capability:
- * @engine: IMAP engine
+ * camel_imap4_engine_capability:
+ * @engine: IMAP4 engine
  * @ex: exception
  *
- * Forces the IMAP engine to query the IMAP server for a list of capabilities.
+ * Forces the IMAP4 engine to query the IMAP4 server for a list of capabilities.
  *
  * Returns 0 on success or -1 on fail.
  **/
 int
-camel_imap_engine_capability (CamelIMAPEngine *engine, CamelException *ex)
+camel_imap4_engine_capability (CamelIMAP4Engine *engine, CamelException *ex)
 {
-	CamelIMAPCommand *ic;
+	CamelIMAP4Command *ic;
 	int id, retval = 0;
 	
-	ic = camel_imap_engine_queue (engine, NULL, "CAPABILITY\r\n");
+	ic = camel_imap4_engine_queue (engine, NULL, "CAPABILITY\r\n");
 	
-	while ((id = camel_imap_engine_iterate (engine)) < ic->id && id != -1)
+	while ((id = camel_imap4_engine_iterate (engine)) < ic->id && id != -1)
 		;
 	
-	if (id == -1 || ic->status != CAMEL_IMAP_COMMAND_COMPLETE) {
+	if (id == -1 || ic->status != CAMEL_IMAP4_COMMAND_COMPLETE) {
 		camel_exception_xfer (ex, &ic->ex);
 		retval = -1;
 	}
 	
-	camel_imap_command_unref (ic);
+	camel_imap4_command_unref (ic);
 	
 	return retval;
 }
 
 
 /**
- * camel_imap_engine_namespace:
- * @engine: IMAP engine
+ * camel_imap4_engine_namespace:
+ * @engine: IMAP4 engine
  * @ex: exception
  *
- * Forces the IMAP engine to query the IMAP server for a list of namespaces.
+ * Forces the IMAP4 engine to query the IMAP4 server for a list of namespaces.
  *
  * Returns 0 on success or -1 on fail.
  **/
 int
-camel_imap_engine_namespace (CamelIMAPEngine *engine, CamelException *ex)
+camel_imap4_engine_namespace (CamelIMAP4Engine *engine, CamelException *ex)
 {
-	camel_imap_list_t *list;
+	camel_imap4_list_t *list;
 	GPtrArray *array = NULL;
-	CamelIMAPCommand *ic;
+	CamelIMAP4Command *ic;
 	int id, i;
 	
-	if (engine->capa & CAMEL_IMAP_CAPABILITY_NAMESPACE) {
-		ic = camel_imap_engine_queue (engine, NULL, "NAMESPACE\r\n");
+	if (engine->capa & CAMEL_IMAP4_CAPABILITY_NAMESPACE) {
+		ic = camel_imap4_engine_queue (engine, NULL, "NAMESPACE\r\n");
 	} else {
-		ic = camel_imap_engine_queue (engine, NULL, "LIST \"\" \"\"\r\n");
-		camel_imap_command_register_untagged (ic, "LIST", camel_imap_untagged_list);
+		ic = camel_imap4_engine_queue (engine, NULL, "LIST \"\" \"\"\r\n");
+		camel_imap4_command_register_untagged (ic, "LIST", camel_imap4_untagged_list);
 		ic->user_data = array = g_ptr_array_new ();
 	}
 	
-	while ((id = camel_imap_engine_iterate (engine)) < ic->id && id != -1)
+	while ((id = camel_imap4_engine_iterate (engine)) < ic->id && id != -1)
 		;
 	
-	if (id == -1 || ic->status != CAMEL_IMAP_COMMAND_COMPLETE) {
+	if (id == -1 || ic->status != CAMEL_IMAP4_COMMAND_COMPLETE) {
 		camel_exception_xfer (ex, &ic->ex);
-		camel_imap_command_unref (ic);
+		camel_imap4_command_unref (ic);
 		return -1;
 	}
 	
 	if (array != NULL) {
-		if (ic->result == CAMEL_IMAP_RESULT_OK) {
-			CamelIMAPNamespace *namespace;
+		if (ic->result == CAMEL_IMAP4_RESULT_OK) {
+			CamelIMAP4Namespace *namespace;
 			
 			g_assert (array->len == 1);
 			list = array->pdata[0];
 			
-			namespace = g_new (CamelIMAPNamespace, 1);
+			namespace = g_new (CamelIMAP4Namespace, 1);
 			namespace->next = NULL;
 			namespace->path = g_strdup ("");
 			namespace->sep = list->delim;
@@ -339,60 +339,60 @@ camel_imap_engine_namespace (CamelIMAPEngine *engine, CamelException *ex)
 		g_ptr_array_free (array, TRUE);
 	}
 	
-	camel_imap_command_unref (ic);
+	camel_imap4_command_unref (ic);
 	
 	return 0;
 }
 
 
 int
-camel_imap_engine_select_folder (CamelIMAPEngine *engine, CamelFolder *folder, CamelException *ex)
+camel_imap4_engine_select_folder (CamelIMAP4Engine *engine, CamelFolder *folder, CamelException *ex)
 {
-	CamelIMAPRespCode *resp;
-	CamelIMAPCommand *ic;
+	CamelIMAP4RespCode *resp;
+	CamelIMAP4Command *ic;
 	int id, retval = 0;
 	int i;
 	
-	g_return_val_if_fail (CAMEL_IS_IMAP_ENGINE (engine), -1);
-	g_return_val_if_fail (CAMEL_IS_IMAP_FOLDER (folder), -1);
+	g_return_val_if_fail (CAMEL_IS_IMAP4_ENGINE (engine), -1);
+	g_return_val_if_fail (CAMEL_IS_IMAP4_FOLDER (folder), -1);
 	
 	/* POSSIBLE FIXME: if the folder to be selected will already
 	 * be selected by the time the queue is emptied, simply
 	 * no-op? */
 	
-	ic = camel_imap_engine_queue (engine, folder, "SELECT %F\r\n", folder);
-	while ((id = camel_imap_engine_iterate (engine)) < ic->id && id != -1)
+	ic = camel_imap4_engine_queue (engine, folder, "SELECT %F\r\n", folder);
+	while ((id = camel_imap4_engine_iterate (engine)) < ic->id && id != -1)
 		;
 	
-	if (id == -1 || ic->status != CAMEL_IMAP_COMMAND_COMPLETE) {
+	if (id == -1 || ic->status != CAMEL_IMAP4_COMMAND_COMPLETE) {
 		camel_exception_xfer (ex, &ic->ex);
-		camel_imap_command_unref (ic);
+		camel_imap4_command_unref (ic);
 		return -1;
 	}
 	
 	switch (ic->result) {
-	case CAMEL_IMAP_RESULT_OK:
+	case CAMEL_IMAP4_RESULT_OK:
 		/*folder->mode = 0;*/
 		for (i = 0; i < ic->resp_codes->len; i++) {
 			resp = ic->resp_codes->pdata[i];
 			switch (resp->code) {
-			case CAMEL_IMAP_RESP_CODE_PERM_FLAGS:
+			case CAMEL_IMAP4_RESP_CODE_PERM_FLAGS:
 				folder->permanent_flags = resp->v.flags;
 				break;
-			case CAMEL_IMAP_RESP_CODE_READONLY:
+			case CAMEL_IMAP4_RESP_CODE_READONLY:
 				/*folder->mode = CAMEL_FOLDER_MODE_READ_ONLY;*/
 				break;
-			case CAMEL_IMAP_RESP_CODE_READWRITE:
+			case CAMEL_IMAP4_RESP_CODE_READWRITE:
 				/*folder->mode = CAMEL_FOLDER_MODE_READ_WRITE;*/
 				break;
-			case CAMEL_IMAP_RESP_CODE_UIDNEXT:
-				camel_imap_summary_set_uidnext (folder->summary, resp->v.uidnext);
+			case CAMEL_IMAP4_RESP_CODE_UIDNEXT:
+				camel_imap4_summary_set_uidnext (folder->summary, resp->v.uidnext);
 				break;
-			case CAMEL_IMAP_RESP_CODE_UIDVALIDITY:
-				camel_imap_summary_set_uidvalidity (folder->summary, resp->v.uidvalidity);
+			case CAMEL_IMAP4_RESP_CODE_UIDVALIDITY:
+				camel_imap4_summary_set_uidvalidity (folder->summary, resp->v.uidvalidity);
 				break;
-			case CAMEL_IMAP_RESP_CODE_UNSEEN:
-				camel_imap_summary_set_unseen (folder->summary, resp->v.unseen);
+			case CAMEL_IMAP4_RESP_CODE_UNSEEN:
+				camel_imap4_summary_set_unseen (folder->summary, resp->v.unseen);
 				break;
 			default:
 				break;
@@ -405,14 +405,14 @@ camel_imap_engine_select_folder (CamelIMAPEngine *engine, CamelFolder *folder, C
 		  }*/
 		
 		break;
-	case CAMEL_IMAP_RESULT_NO:
+	case CAMEL_IMAP4_RESULT_NO:
 		/* FIXME: would be good to save the NO reason into the err message */
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 				      _("Cannot select folder `%s': Invalid mailbox name"),
 				      folder->full_name);
 		retval = -1;
 		break;
-	case CAMEL_IMAP_RESULT_BAD:
+	case CAMEL_IMAP4_RESULT_BAD:
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 				      _("Cannot select folder `%s': Bad command"),
 				      folder->full_name);
@@ -423,7 +423,7 @@ camel_imap_engine_select_folder (CamelIMAPEngine *engine, CamelFolder *folder, C
 		retval = -1;
 	}
 	
-	camel_imap_command_unref (ic);
+	camel_imap4_command_unref (ic);
 	
 	return retval;
 }
@@ -432,15 +432,15 @@ camel_imap_engine_select_folder (CamelIMAPEngine *engine, CamelFolder *folder, C
 static struct {
 	const char *name;
 	guint32 flag;
-} imap_capabilities[] = {
-	{ "IMAP4",         CAMEL_IMAP_CAPABILITY_IMAP4         },
-	{ "IMAP4REV1",     CAMEL_IMAP_CAPABILITY_IMAP4REV1     },
-	{ "STATUS",        CAMEL_IMAP_CAPABILITY_STATUS        },
-	{ "NAMESPACE",     CAMEL_IMAP_CAPABILITY_NAMESPACE     },
-	{ "UIDPLUS",       CAMEL_IMAP_CAPABILITY_UIDPLUS       },
-	{ "LITERAL+",      CAMEL_IMAP_CAPABILITY_LITERALPLUS   },
-	{ "LOGINDISABLED", CAMEL_IMAP_CAPABILITY_LOGINDISABLED },
-	{ "STARTTLS",      CAMEL_IMAP_CAPABILITY_STARTTLS      },
+} imap4_capabilities[] = {
+	{ "IMAP44",         CAMEL_IMAP4_CAPABILITY_IMAP44         },
+	{ "IMAP44REV1",     CAMEL_IMAP4_CAPABILITY_IMAP44REV1     },
+	{ "STATUS",        CAMEL_IMAP4_CAPABILITY_STATUS        },
+	{ "NAMESPACE",     CAMEL_IMAP4_CAPABILITY_NAMESPACE     },
+	{ "UIDPLUS",       CAMEL_IMAP4_CAPABILITY_UIDPLUS       },
+	{ "LITERAL+",      CAMEL_IMAP4_CAPABILITY_LITERALPLUS   },
+	{ "LOGINDISABLED", CAMEL_IMAP4_CAPABILITY_LOGINDISABLED },
+	{ "STARTTLS",      CAMEL_IMAP4_CAPABILITY_STARTTLS      },
 	{ NULL,            0                                    }
 };
 
@@ -452,63 +452,63 @@ auth_free (gpointer key, gpointer value, gpointer user_data)
 }
 
 static int
-engine_parse_capability (CamelIMAPEngine *engine, int sentinel, CamelException *ex)
+engine_parse_capability (CamelIMAP4Engine *engine, int sentinel, CamelException *ex)
 {
-	camel_imap_token_t token;
+	camel_imap4_token_t token;
 	int i;
 	
-	engine->capa = CAMEL_IMAP_CAPABILITY_utf8_search;
+	engine->capa = CAMEL_IMAP4_CAPABILITY_utf8_search;
 	engine->level = 0;
 	
 	g_hash_table_foreach_remove (engine->authtypes, (GHRFunc) auth_free, NULL);
 	
-	if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 		return -1;
 	
-	while (token.token == CAMEL_IMAP_TOKEN_ATOM) {
+	while (token.token == CAMEL_IMAP4_TOKEN_ATOM) {
 		if (!strncasecmp ("AUTH=", token.v.atom, 5)) {
 			CamelServiceAuthType *auth;
 			
 			if ((auth = camel_sasl_authtype (token.v.atom + 5)) != NULL)
 				g_hash_table_insert (engine->authtypes, g_strdup (token.v.atom + 5), auth);
 		} else {
-			for (i = 0; imap_capabilities[i].name; i++) {
-				if (!strcasecmp (imap_capabilities[i].name, token.v.atom))
-					engine->capa |= imap_capabilities[i].flag;
+			for (i = 0; imap4_capabilities[i].name; i++) {
+				if (!strcasecmp (imap4_capabilities[i].name, token.v.atom))
+					engine->capa |= imap4_capabilities[i].flag;
 			}
 		}
 		
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 			return -1;
 	}
 	
 	if (token.token != sentinel) {
-		camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 		return -1;
 	}
 	
 	/* unget our sentinel token */
-	camel_imap_stream_unget_token (engine->istream, &token);
-	
-	/* figure out which version of IMAP we are dealing with */
-	if (engine->capa & CAMEL_IMAP_CAPABILITY_IMAP4REV1) {
-		engine->level = CAMEL_IMAP_LEVEL_IMAP4REV1;
-		engine->capa |= CAMEL_IMAP_CAPABILITY_STATUS;
-	} else if (engine->capa & CAMEL_IMAP_CAPABILITY_IMAP4) {
-		engine->level = CAMEL_IMAP_LEVEL_IMAP4;
+	camel_imap4_stream_unget_token (engine->istream, &token);
+	
+	/* figure out which version of IMAP4 we are dealing with */
+	if (engine->capa & CAMEL_IMAP4_CAPABILITY_IMAP44REV1) {
+		engine->level = CAMEL_IMAP4_LEVEL_IMAP44REV1;
+		engine->capa |= CAMEL_IMAP4_CAPABILITY_STATUS;
+	} else if (engine->capa & CAMEL_IMAP4_CAPABILITY_IMAP44) {
+		engine->level = CAMEL_IMAP4_LEVEL_IMAP44;
 	} else {
-		engine->level = CAMEL_IMAP_LEVEL_UNKNOWN;
+		engine->level = CAMEL_IMAP4_LEVEL_UNKNOWN;
 	}
 	
 	return 0;
 }
 
 static int
-engine_parse_flags_list (CamelIMAPEngine *engine, CamelIMAPRespCode *resp, int perm, CamelException *ex)
+engine_parse_flags_list (CamelIMAP4Engine *engine, CamelIMAP4RespCode *resp, int perm, CamelException *ex)
 {
 	guint32 flags = 0;
 	
-	if (camel_imap_parse_flags_list (engine, &flags, ex) == -1)
+	if (camel_imap4_parse_flags_list (engine, &flags, ex) == -1)
 		return-1;
 	
 	if (resp != NULL)
@@ -534,19 +534,19 @@ engine_parse_flags_list (CamelIMAPEngine *engine, CamelIMAPRespCode *resp, int p
 }
 
 static int
-engine_parse_flags (CamelIMAPEngine *engine, CamelException *ex)
+engine_parse_flags (CamelIMAP4Engine *engine, CamelException *ex)
 {
-	camel_imap_token_t token;
+	camel_imap4_token_t token;
 	
 	if (engine_parse_flags_list (engine, NULL, FALSE, ex) == -1)
 		return -1;
 	
-	if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 		return -1;
 	
 	if (token.token != '\n') {
 		d(fprintf (stderr, "Expected to find a '\\n' token after the FLAGS response\n"));
-		camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 		return -1;
 	}
 	
@@ -555,95 +555,95 @@ engine_parse_flags (CamelIMAPEngine *engine, CamelException *ex)
 
 
 enum {
-	IMAP_STATUS_MESSAGES,
-	IMAP_STATUS_RECENT,
-	IMAP_STATUS_UIDNEXT,
-	IMAP_STATUS_UIDVALIDITY,
-	IMAP_STATUS_UNSEEN,
-	IMAP_STATUS_UNKNOWN
+	IMAP4_STATUS_MESSAGES,
+	IMAP4_STATUS_RECENT,
+	IMAP4_STATUS_UIDNEXT,
+	IMAP4_STATUS_UIDVALIDITY,
+	IMAP4_STATUS_UNSEEN,
+	IMAP4_STATUS_UNKNOWN
 };
 
 static struct {
 	const char *name;
 	int type;
-} imap_status[] = {
-	{ "MESSAGES",    IMAP_STATUS_MESSAGES    },
-	{ "RECENT",      IMAP_STATUS_RECENT      },
-	{ "UIDNEXT",     IMAP_STATUS_UIDNEXT     },
-	{ "UIDVALIDITY", IMAP_STATUS_UIDVALIDITY },
-	{ "UNSEEN",      IMAP_STATUS_UNSEEN      },
-	{ NULL,          IMAP_STATUS_UNKNOWN     },
+} imap4_status[] = {
+	{ "MESSAGES",    IMAP4_STATUS_MESSAGES    },
+	{ "RECENT",      IMAP4_STATUS_RECENT      },
+	{ "UIDNEXT",     IMAP4_STATUS_UIDNEXT     },
+	{ "UIDVALIDITY", IMAP4_STATUS_UIDVALIDITY },
+	{ "UNSEEN",      IMAP4_STATUS_UNSEEN      },
+	{ NULL,          IMAP4_STATUS_UNKNOWN     },
 };
 
 static int
-engine_parse_status (CamelIMAPEngine *engine, CamelException *ex)
+engine_parse_status (CamelIMAP4Engine *engine, CamelException *ex)
 {
-	camel_imap_token_t token;
+	camel_imap4_token_t token;
 	char *mailbox;
 	size_t len;
 	int type;
 	
-	if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 		return -1;
 	
 	switch (token.token) {
-	case CAMEL_IMAP_TOKEN_ATOM:
+	case CAMEL_IMAP4_TOKEN_ATOM:
 		mailbox = g_strdup (token.v.atom);
 		break;
-	case CAMEL_IMAP_TOKEN_QSTRING:
+	case CAMEL_IMAP4_TOKEN_QSTRING:
 		mailbox = g_strdup (token.v.qstring);
 		break;
-	case CAMEL_IMAP_TOKEN_LITERAL:
-		if (camel_imap_engine_literal (engine, (unsigned char **) &mailbox, &len, ex) == -1)
+	case CAMEL_IMAP4_TOKEN_LITERAL:
+		if (camel_imap4_engine_literal (engine, (unsigned char **) &mailbox, &len, ex) == -1)
 			return -1;
 		break;
 	default:
-		fprintf (stderr, "Unexpected token in IMAP untagged STATUS response: %s%c\n",
-			 token.token == CAMEL_IMAP_TOKEN_NIL ? "NIL" : "",
+		fprintf (stderr, "Unexpected token in IMAP4 untagged STATUS response: %s%c\n",
+			 token.token == CAMEL_IMAP4_TOKEN_NIL ? "NIL" : "",
 			 (unsigned char) (token.token & 0xff));
-		camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 		return -1;
 	}
 	
-	if (camel_imap_engine_next_token (engine, &token, ex) == -1) {
+	if (camel_imap4_engine_next_token (engine, &token, ex) == -1) {
 		g_free (mailbox);
 		return -1;
 	}
 	
 	if (token.token != '(') {
 		d(fprintf (stderr, "Expected to find a '(' token after the mailbox token in the STATUS response\n"));
-		camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 		g_free (mailbox);
 		return -1;
 	}
 	
-	if (camel_imap_engine_next_token (engine, &token, ex) == -1) {
+	if (camel_imap4_engine_next_token (engine, &token, ex) == -1) {
 		g_free (mailbox);
 		return -1;
 	}
 	
-	while (token.token == CAMEL_IMAP_TOKEN_ATOM) {
+	while (token.token == CAMEL_IMAP4_TOKEN_ATOM) {
 		const unsigned char *inptr;
 		unsigned int v = 0;
 		
 		/* parse the status messages list */
-		for (type = 0; imap_status[type].name; type++) {
-			if (!strcasecmp (imap_status[type].name, token.v.atom))
+		for (type = 0; imap4_status[type].name; type++) {
+			if (!strcasecmp (imap4_status[type].name, token.v.atom))
 				break;
 		}
 		
-		if (type == IMAP_STATUS_UNKNOWN)
+		if (type == IMAP4_STATUS_UNKNOWN)
 			fprintf (stderr, "unrecognized token in STATUS list: %s\n", token.v.atom);
 		
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1) {
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1) {
 			g_free (mailbox);
 			return -1;
 		}
 		
-		if (token.token != CAMEL_IMAP_TOKEN_ATOM)
+		if (token.token != CAMEL_IMAP4_TOKEN_ATOM)
 			break;
 		
-		if (type == IMAP_STATUS_UIDNEXT || type == IMAP_STATUS_UIDVALIDITY) {
+		if (type == IMAP4_STATUS_UIDNEXT || type == IMAP4_STATUS_UIDVALIDITY) {
 			/* these tokens should be numeric, but we
 			 * treat them as strings internally so we are
 			 * special-casing them here */
@@ -655,25 +655,25 @@ engine_parse_status (CamelIMAPEngine *engine, CamelException *ex)
 				v = (v * 10) + (*inptr++ - '0');
 			
 			if (*inptr != '\0') {
-				if (type == IMAP_STATUS_UNKNOWN) {
+				if (type == IMAP4_STATUS_UNKNOWN) {
 					/* we'll let it slide... unget this token and continue */
-					camel_imap_stream_unget_token (engine->istream, &token);
+					camel_imap4_stream_unget_token (engine->istream, &token);
 					goto loop;
 				}
 				
 				d(fprintf (stderr, "Encountered non-numeric token after %s in untagged STATUS response: %s\n",
-					   imap_status[type].name, token.v.atom));
+					   imap4_status[type].name, token.v.atom));
 				goto loop;
 			}
 			
 			switch (type) {
-			case IMAP_STATUS_MESSAGES:
+			case IMAP4_STATUS_MESSAGES:
 				/* FIXME: save value */
 				break;
-			case IMAP_STATUS_RECENT:
+			case IMAP4_STATUS_RECENT:
 				/* FIXME: save value */
 				break;
-			case IMAP_STATUS_UNSEEN:
+			case IMAP4_STATUS_UNSEEN:
 				/* FIXME: save value */
 				break;
 			default:
@@ -682,7 +682,7 @@ engine_parse_status (CamelIMAPEngine *engine, CamelException *ex)
 		}
 		
 	loop:
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1) {
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1) {
 			g_free (mailbox);
 			return -1;
 		}
@@ -693,16 +693,16 @@ engine_parse_status (CamelIMAPEngine *engine, CamelException *ex)
 	
 	if (token.token != ')') {
 		d(fprintf (stderr, "Expected to find a ')' token terminating the untagged STATUS response\n"));
-		camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 		return -1;
 	}
 	
-	if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 		return -1;
 	
 	if (token.token != '\n') {
 		d(fprintf (stderr, "Expected to find a '\\n' token after the STATUS response\n"));
-		camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 		return -1;
 	}
 	
@@ -710,56 +710,56 @@ engine_parse_status (CamelIMAPEngine *engine, CamelException *ex)
 }
 
 static int
-engine_parse_namespace (CamelIMAPEngine *engine, CamelException *ex)
+engine_parse_namespace (CamelIMAP4Engine *engine, CamelException *ex)
 {
-	CamelIMAPNamespace *namespaces[3], *node, *tail;
-	camel_imap_token_t token;
+	CamelIMAP4Namespace *namespaces[3], *node, *tail;
+	camel_imap4_token_t token;
 	int i, n = 0;
 	
-	imap_namespace_clear (&engine->namespaces.personal);
-	imap_namespace_clear (&engine->namespaces.other);
-	imap_namespace_clear (&engine->namespaces.shared);
+	imap4_namespace_clear (&engine->namespaces.personal);
+	imap4_namespace_clear (&engine->namespaces.other);
+	imap4_namespace_clear (&engine->namespaces.shared);
 	
-	if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 		return -1;
 	
 	do {
 		namespaces[n] = NULL;
-		tail = (CamelIMAPNamespace *) &namespaces[n];
+		tail = (CamelIMAP4Namespace *) &namespaces[n];
 		
 		if (token.token == '(') {
 			/* decode the list of namespace pairs */
-			if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+			if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 				goto exception;
 			
 			while (token.token == '(') {
 				/* decode a namespace pair */
 				
 				/* get the path name token */
-				if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+				if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 					goto exception;
 				
-				if (token.token != CAMEL_IMAP_TOKEN_QSTRING) {
+				if (token.token != CAMEL_IMAP4_TOKEN_QSTRING) {
 					d(fprintf (stderr, "Expected to find a qstring token as first element in NAMESPACE pair\n"));
-					camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+					camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 					goto exception;
 				}
 				
-				node = g_new (CamelIMAPNamespace, 1);
+				node = g_new (CamelIMAP4Namespace, 1);
 				node->next = NULL;
 				node->path = g_strdup (token.v.qstring);
 				
 				/* get the path delimiter token */
-				if (camel_imap_engine_next_token (engine, &token, ex) == -1) {
+				if (camel_imap4_engine_next_token (engine, &token, ex) == -1) {
 					g_free (node->path);
 					g_free (node);
 					
 					goto exception;
 				}
 				
-				if (token.token != CAMEL_IMAP_TOKEN_QSTRING || strlen (token.v.qstring) > 1) {
+				if (token.token != CAMEL_IMAP4_TOKEN_QSTRING || strlen (token.v.qstring) > 1) {
 					d(fprintf (stderr, "Expected to find a qstring token as second element in NAMESPACE pair\n"));
-					camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+					camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 					g_free (node->path);
 					g_free (node);
 					
@@ -774,38 +774,43 @@ engine_parse_namespace (CamelIMAPEngine *engine, CamelException *ex)
 				if (node->path[strlen (node->path) - 1] == node->sep)
 					node->path[strlen (node->path) - 1] = '\0';
 				
+				/* canonicalise if this is an INBOX namespace */
+				if (!g_ascii_strncasecmp (node->path, "INBOX", 5) &&
+				    (node->path[6] == '\0' || node->path[6] == node->sep))
+					memcpy (node->path, "INBOX", 5);
+				
 				/* get the closing ')' for this namespace pair */
-				if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+				if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 					goto exception;
 				
 				if (token.token != ')') {
 					d(fprintf (stderr, "Expected to find a ')' token to close the current namespace pair\n"));
-					camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+					camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 					
 					goto exception;
 				}
 				
 				/* get the next token (should be either '(' or ')') */
-				if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+				if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 					goto exception;
 			}
 			
 			if (token.token != ')') {
 				d(fprintf (stderr, "Expected to find a ')' to close the current namespace list\n"));
-				camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+				camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 				goto exception;
 			}
-		} else if (token.token == CAMEL_IMAP_TOKEN_NIL) {
+		} else if (token.token == CAMEL_IMAP4_TOKEN_NIL) {
 			/* namespace list is NIL */
 			namespaces[n] = NULL;
 		} else {
 			d(fprintf (stderr, "Expected to find either NIL or '(' token in untagged NAMESPACE response\n"));
-			camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+			camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 			goto exception;
 		}
 		
 		/* get the next token (should be either '(', NIL, or '\n') */
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 			goto exception;
 		
 		n++;
@@ -820,7 +825,7 @@ engine_parse_namespace (CamelIMAPEngine *engine, CamelException *ex)
  exception:
 	
 	for (i = 0; i <= n; i++)
-		imap_namespace_clear (&namespaces[i]);
+		imap4_namespace_clear (&namespaces[i]);
 	
 	return -1;
 }
@@ -840,58 +845,58 @@ engine_parse_namespace (CamelIMAPEngine *engine, CamelException *ex)
 
 static struct {
 	const char *name;
-	camel_imap_resp_code_t code;
+	camel_imap4_resp_code_t code;
 	int save;
-} imap_resp_codes[] = {
-	{ "ALERT",          CAMEL_IMAP_RESP_CODE_ALERT,       0 },
-	{ "BADCHARSET",     CAMEL_IMAP_RESP_CODE_BADCHARSET,  0 },
-	{ "CAPABILITY",     CAMEL_IMAP_RESP_CODE_CAPABILITY,  0 },
-	{ "PARSE",          CAMEL_IMAP_RESP_CODE_PARSE,       1 },
-	{ "PERMANENTFLAGS", CAMEL_IMAP_RESP_CODE_PERM_FLAGS,  1 },
-	{ "READ-ONLY",      CAMEL_IMAP_RESP_CODE_READONLY,    1 },
-	{ "READ-WRITE",     CAMEL_IMAP_RESP_CODE_READWRITE,   1 },
-	{ "TRYCREATE",      CAMEL_IMAP_RESP_CODE_TRYCREATE,   1 },
-	{ "UIDNEXT",        CAMEL_IMAP_RESP_CODE_UIDNEXT,     1 },
-	{ "UIDVALIDITY",    CAMEL_IMAP_RESP_CODE_UIDVALIDITY, 1 },
-	{ "UNSEEN",         CAMEL_IMAP_RESP_CODE_UNSEEN,      1 },
-	{ "NEWNAME",        CAMEL_IMAP_RESP_CODE_NEWNAME,     1 },
-	{ "APPENDUID",      CAMEL_IMAP_RESP_CODE_APPENDUID,   1 },
-	{ "COPYUID",        CAMEL_IMAP_RESP_CODE_COPYUID,     1 },
-	{ NULL,             CAMEL_IMAP_RESP_CODE_UNKNOWN,     0 }
+} imap4_resp_codes[] = {
+	{ "ALERT",          CAMEL_IMAP4_RESP_CODE_ALERT,       0 },
+	{ "BADCHARSET",     CAMEL_IMAP4_RESP_CODE_BADCHARSET,  0 },
+	{ "CAPABILITY",     CAMEL_IMAP4_RESP_CODE_CAPABILITY,  0 },
+	{ "PARSE",          CAMEL_IMAP4_RESP_CODE_PARSE,       1 },
+	{ "PERMANENTFLAGS", CAMEL_IMAP4_RESP_CODE_PERM_FLAGS,  1 },
+	{ "READ-ONLY",      CAMEL_IMAP4_RESP_CODE_READONLY,    1 },
+	{ "READ-WRITE",     CAMEL_IMAP4_RESP_CODE_READWRITE,   1 },
+	{ "TRYCREATE",      CAMEL_IMAP4_RESP_CODE_TRYCREATE,   1 },
+	{ "UIDNEXT",        CAMEL_IMAP4_RESP_CODE_UIDNEXT,     1 },
+	{ "UIDVALIDITY",    CAMEL_IMAP4_RESP_CODE_UIDVALIDITY, 1 },
+	{ "UNSEEN",         CAMEL_IMAP4_RESP_CODE_UNSEEN,      1 },
+	{ "NEWNAME",        CAMEL_IMAP4_RESP_CODE_NEWNAME,     1 },
+	{ "APPENDUID",      CAMEL_IMAP4_RESP_CODE_APPENDUID,   1 },
+	{ "COPYUID",        CAMEL_IMAP4_RESP_CODE_COPYUID,     1 },
+	{ NULL,             CAMEL_IMAP4_RESP_CODE_UNKNOWN,     0 }
 };
 
 
 int
-camel_imap_engine_parse_resp_code (CamelIMAPEngine *engine, CamelException *ex)
+camel_imap4_engine_parse_resp_code (CamelIMAP4Engine *engine, CamelException *ex)
 {
-	CamelIMAPRespCode *resp = NULL;
-	camel_imap_resp_code_t code;
-	camel_imap_token_t token;
+	CamelIMAP4RespCode *resp = NULL;
+	camel_imap4_resp_code_t code;
+	camel_imap4_token_t token;
 	unsigned char *linebuf;
 	size_t len;
 	
-	if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 		return -1;
 	
 	if (token.token != '[') {
 		d(fprintf (stderr, "Expected a '[' token (followed by a RESP-CODE)\n"));
-		camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 		return -1;
 	}
 	
-	if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 		return -1;
 	
-	if (token.token != CAMEL_IMAP_TOKEN_ATOM) {
+	if (token.token != CAMEL_IMAP4_TOKEN_ATOM) {
 		d(fprintf (stderr, "Expected an atom token containing a RESP-CODE\n"));
-		camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 		return -1;
 	}
 	
-	for (code = 0; imap_resp_codes[code].name; code++) {
-		if (!strcmp (imap_resp_codes[code].name, token.v.atom)) {
-			if (engine->current && imap_resp_codes[code].save) {
-				resp = g_new0 (CamelIMAPRespCode, 1);
+	for (code = 0; imap4_resp_codes[code].name; code++) {
+		if (!strcmp (imap4_resp_codes[code].name, token.v.atom)) {
+			if (engine->current && imap4_resp_codes[code].save) {
+				resp = g_new0 (CamelIMAP4RespCode, 1);
 				resp->code = code;
 			}
 			break;
@@ -899,33 +904,33 @@ camel_imap_engine_parse_resp_code (CamelIMAPEngine *engine, CamelException *ex)
 	}
 	
 	switch (code) {
-	case CAMEL_IMAP_RESP_CODE_BADCHARSET:
+	case CAMEL_IMAP4_RESP_CODE_BADCHARSET:
 		/* apparently we don't support UTF-8 afterall */
-		engine->capa &= ~CAMEL_IMAP_CAPABILITY_utf8_search;
+		engine->capa &= ~CAMEL_IMAP4_CAPABILITY_utf8_search;
 		break;
-	case CAMEL_IMAP_RESP_CODE_CAPABILITY:
+	case CAMEL_IMAP4_RESP_CODE_CAPABILITY:
 		/* capability list follows */
 		if (engine_parse_capability (engine, ']', ex) == -1)
 			goto exception;
 		break;
-	case CAMEL_IMAP_RESP_CODE_PERM_FLAGS:
+	case CAMEL_IMAP4_RESP_CODE_PERM_FLAGS:
 		/* flag list follows */
 		if (engine_parse_flags_list (engine, resp, TRUE, ex) == -1)
 			goto exception;
 		break;
-	case CAMEL_IMAP_RESP_CODE_READONLY:
+	case CAMEL_IMAP4_RESP_CODE_READONLY:
 		break;
-	case CAMEL_IMAP_RESP_CODE_READWRITE:
+	case CAMEL_IMAP4_RESP_CODE_READWRITE:
 		break;
-	case CAMEL_IMAP_RESP_CODE_TRYCREATE:
+	case CAMEL_IMAP4_RESP_CODE_TRYCREATE:
 		break;
-	case CAMEL_IMAP_RESP_CODE_UIDNEXT:
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	case CAMEL_IMAP4_RESP_CODE_UIDNEXT:
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 			goto exception;
 		
-		if (token.token != CAMEL_IMAP_TOKEN_NUMBER) {
+		if (token.token != CAMEL_IMAP4_TOKEN_NUMBER) {
 			d(fprintf (stderr, "Expected an nz_number token as an argument to the UIDNEXT RESP-CODE\n"));
-			camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+			camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 			goto exception;
 		}
 		
@@ -933,13 +938,13 @@ camel_imap_engine_parse_resp_code (CamelIMAPEngine *engine, CamelException *ex)
 			resp->v.uidnext = token.v.number;
 		
 		break;
-	case CAMEL_IMAP_RESP_CODE_UIDVALIDITY:
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	case CAMEL_IMAP4_RESP_CODE_UIDVALIDITY:
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 			goto exception;
 		
-		if (token.token != CAMEL_IMAP_TOKEN_NUMBER) {
+		if (token.token != CAMEL_IMAP4_TOKEN_NUMBER) {
 			d(fprintf (stderr, "Expected an nz_number token as an argument to the UIDVALIDITY RESP-CODE\n"));
-			camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+			camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 			goto exception;
 		}
 		
@@ -947,13 +952,13 @@ camel_imap_engine_parse_resp_code (CamelIMAPEngine *engine, CamelException *ex)
 			resp->v.uidvalidity = token.v.number;
 		
 		break;
-	case CAMEL_IMAP_RESP_CODE_UNSEEN:
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	case CAMEL_IMAP4_RESP_CODE_UNSEEN:
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 			return -1;
 		
-		if (token.token != CAMEL_IMAP_TOKEN_NUMBER) {
+		if (token.token != CAMEL_IMAP4_TOKEN_NUMBER) {
 			d(fprintf (stderr, "Expected an nz_number token as an argument to the UNSEEN RESP-CODE\n"));
-			camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+			camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 			goto exception;
 		}
 		
@@ -961,25 +966,25 @@ camel_imap_engine_parse_resp_code (CamelIMAPEngine *engine, CamelException *ex)
 			resp->v.unseen = token.v.number;
 		
 		break;
-	case CAMEL_IMAP_RESP_CODE_NEWNAME:
+	case CAMEL_IMAP4_RESP_CODE_NEWNAME:
 		/* this RESP-CODE may actually be removed - see here:
-		 * http://www.washington.edu/imap/listarch/2001/msg00058.html */
+		 * http://www.washington.edu/imap4/listarch/2001/msg00058.html */
 		
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 			return -1;
 		
-		if (token.token != CAMEL_IMAP_TOKEN_ATOM && token.token != CAMEL_IMAP_TOKEN_QSTRING) {
+		if (token.token != CAMEL_IMAP4_TOKEN_ATOM && token.token != CAMEL_IMAP4_TOKEN_QSTRING) {
 			d(fprintf (stderr, "Expected an atom or qstring token as the first argument to the NEWNAME RESP-CODE\n"));
-			camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+			camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 			goto exception;
 		}
 		
 		if (resp != NULL)
 			resp->v.newname[0] = g_strdup (token.v.atom);
 		
-		if (token.token != CAMEL_IMAP_TOKEN_ATOM && token.token != CAMEL_IMAP_TOKEN_QSTRING) {
+		if (token.token != CAMEL_IMAP4_TOKEN_ATOM && token.token != CAMEL_IMAP4_TOKEN_QSTRING) {
 			d(fprintf (stderr, "Expected an atom or qstring token as the second argument to the NEWNAME RESP-CODE\n"));
-			camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+			camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 			goto exception;
 		}
 		
@@ -987,25 +992,25 @@ camel_imap_engine_parse_resp_code (CamelIMAPEngine *engine, CamelException *ex)
 			resp->v.newname[1] = g_strdup (token.v.atom);
 		
 		break;
-	case CAMEL_IMAP_RESP_CODE_APPENDUID:
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	case CAMEL_IMAP4_RESP_CODE_APPENDUID:
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 			return -1;
 		
-		if (token.token != CAMEL_IMAP_TOKEN_NUMBER) {
+		if (token.token != CAMEL_IMAP4_TOKEN_NUMBER) {
 			d(fprintf (stderr, "Expected an nz_number token as the first argument to the APPENDUID RESP-CODE\n"));
-			camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+			camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 			goto exception;
 		}
 		
 		if (resp != NULL)
 			resp->v.appenduid.uidvalidity = token.v.number;
 		
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 			return -1;
 		
-		if (token.token != CAMEL_IMAP_TOKEN_NUMBER) {
+		if (token.token != CAMEL_IMAP4_TOKEN_NUMBER) {
 			d(fprintf (stderr, "Expected an nz_number token as the second argument to the APPENDUID RESP-CODE\n"));
-			camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+			camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 			goto exception;
 		}
 		
@@ -1013,37 +1018,37 @@ camel_imap_engine_parse_resp_code (CamelIMAPEngine *engine, CamelException *ex)
 			resp->v.appenduid.uid = token.v.number;
 		
 		break;
-	case CAMEL_IMAP_RESP_CODE_COPYUID:
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	case CAMEL_IMAP4_RESP_CODE_COPYUID:
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 			return -1;
 		
-		if (token.token != CAMEL_IMAP_TOKEN_NUMBER) {
+		if (token.token != CAMEL_IMAP4_TOKEN_NUMBER) {
 			d(fprintf (stderr, "Expected an nz_number token as the first argument to the COPYUID RESP-CODE\n"));
-			camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+			camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 			goto exception;
 		}
 		
 		if (resp != NULL)
 			resp->v.copyuid.uidvalidity = token.v.number;
 		
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 			return -1;
 		
-		if (token.token != CAMEL_IMAP_TOKEN_ATOM) {
+		if (token.token != CAMEL_IMAP4_TOKEN_ATOM) {
 			d(fprintf (stderr, "Expected an atom token as the second argument to the COPYUID RESP-CODE\n"));
-			camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+			camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 			goto exception;
 		}
 		
 		if (resp != NULL)
 			resp->v.copyuid.srcset = g_strdup (token.v.atom);
 		
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 			return -1;
 		
-		if (token.token != CAMEL_IMAP_TOKEN_ATOM) {
+		if (token.token != CAMEL_IMAP4_TOKEN_ATOM) {
 			d(fprintf (stderr, "Expected an atom token as the third argument to the APPENDUID RESP-CODE\n"));
-			camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+			camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 			goto exception;
 		}
 		
@@ -1058,7 +1063,7 @@ camel_imap_engine_parse_resp_code (CamelIMAPEngine *engine, CamelException *ex)
 		
 		/* eat up the TEXT_CHARs */
 		while (token.token != ']' && token.token != '\n') {
-			if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+			if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 				goto exception;
 		}
 		
@@ -1066,30 +1071,30 @@ camel_imap_engine_parse_resp_code (CamelIMAPEngine *engine, CamelException *ex)
 	}
 	
 	while (token.token != ']' && token.token != '\n') {
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 			goto exception;
 	}
 	
 	if (token.token != ']') {
-		camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 		d(fprintf (stderr, "Expected to find a ']' token after the RESP-CODE\n"));
 		return -1;
 	}
 	
-	if (code == CAMEL_IMAP_RESP_CODE_ALERT) {
-		if (camel_imap_engine_line (engine, &linebuf, &len, ex) == -1)
+	if (code == CAMEL_IMAP4_RESP_CODE_ALERT) {
+		if (camel_imap4_engine_line (engine, &linebuf, &len, ex) == -1)
 			goto exception;
 		
 		camel_session_alert_user (engine->session, CAMEL_SESSION_ALERT_INFO, linebuf, FALSE);
 		g_free (linebuf);
-	} else if (resp != NULL && code == CAMEL_IMAP_RESP_CODE_PARSE) {
-		if (camel_imap_engine_line (engine, &linebuf, &len, ex) == -1)
+	} else if (resp != NULL && code == CAMEL_IMAP4_RESP_CODE_PARSE) {
+		if (camel_imap4_engine_line (engine, &linebuf, &len, ex) == -1)
 			goto exception;
 		
 		resp->v.parse = linebuf;
 	} else {
 		/* eat up the rest of the response */
-		if (camel_imap_engine_line (engine, NULL, NULL, ex) == -1)
+		if (camel_imap4_engine_line (engine, NULL, NULL, ex) == -1)
 			goto exception;
 	}
 	
@@ -1101,38 +1106,38 @@ camel_imap_engine_parse_resp_code (CamelIMAPEngine *engine, CamelException *ex)
  exception:
 	
 	if (resp != NULL)
-		camel_imap_resp_code_free (resp);
+		camel_imap4_resp_code_free (resp);
 	
 	return -1;
 }
 
 
 
-/* returns -1 on error, or one of CAMEL_IMAP_UNTAGGED_[OK,NO,BAD,PREAUTH,HANDLED] on success */
+/* returns -1 on error, or one of CAMEL_IMAP4_UNTAGGED_[OK,NO,BAD,PREAUTH,HANDLED] on success */
 int
-camel_imap_engine_handle_untagged_1 (CamelIMAPEngine *engine, camel_imap_token_t *token, CamelException *ex)
+camel_imap4_engine_handle_untagged_1 (CamelIMAP4Engine *engine, camel_imap4_token_t *token, CamelException *ex)
 {
-	int code = CAMEL_IMAP_UNTAGGED_HANDLED;
-	CamelIMAPCommand *ic = engine->current;
-	CamelIMAPUntaggedCallback untagged;
+	int code = CAMEL_IMAP4_UNTAGGED_HANDLED;
+	CamelIMAP4Command *ic = engine->current;
+	CamelIMAP4UntaggedCallback untagged;
 	CamelFolder *folder;
 	unsigned int v;
 	
-	if (camel_imap_engine_next_token (engine, token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 		return -1;
 	
-	if (token->token == CAMEL_IMAP_TOKEN_ATOM) {
+	if (token->token == CAMEL_IMAP4_TOKEN_ATOM) {
 		if (!strcmp ("BYE", token->v.atom)) {
 			/* we don't care if we fail here, either way we've been disconnected */
-			camel_imap_engine_parse_resp_code (engine, NULL);
-			engine->state = CAMEL_IMAP_ENGINE_DISCONNECTED;
+			camel_imap4_engine_parse_resp_code (engine, NULL);
+			engine->state = CAMEL_IMAP4_ENGINE_DISCONNECTED;
 			
 			/* FIXME: emit a "disconnected" signal for our Store?
 			 * The Store could then initiate a reconnect if
 			 * desirable. */
 			
 			camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
-					      _("IMAP server %s unexpectedly disconnected: %s"),
+					      _("IMAP4 server %s unexpectedly disconnected: %s"),
 					      engine->url->host, _("Got BYE response"));
 			
 			return -1;
@@ -1142,11 +1147,11 @@ camel_imap_engine_handle_untagged_1 (CamelIMAPEngine *engine, camel_imap_token_t
 				return -1;
 			
 			/* find the eoln token */
-			if (camel_imap_engine_next_token (engine, token, ex) == -1)
+			if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 				return -1;
 			
 			if (token->token != '\n') {
-				camel_imap_utils_set_unexpected_token_error (ex, engine, token);
+				camel_imap4_utils_set_unexpected_token_error (ex, engine, token);
 				return -1;
 			}
 		} else if (!strcmp ("FLAGS", token->v.atom)) {
@@ -1157,50 +1162,50 @@ camel_imap_engine_handle_untagged_1 (CamelIMAPEngine *engine, camel_imap_token_t
 			if (engine_parse_namespace (engine, ex) == -1)
 				return -1;
 		} else if (!strcmp ("NO", token->v.atom) || !strcmp ("BAD", token->v.atom)) {
-			code = !strcmp ("NO", token->v.atom) ? CAMEL_IMAP_UNTAGGED_NO : CAMEL_IMAP_UNTAGGED_BAD;
+			code = !strcmp ("NO", token->v.atom) ? CAMEL_IMAP4_UNTAGGED_NO : CAMEL_IMAP4_UNTAGGED_BAD;
 			
 			/* our command has been rejected */
-			if (camel_imap_engine_next_token (engine, token, ex) == -1)
+			if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 				return -1;
 			
 			if (token->token == '[') {
 				/* we have a resp code */
-				camel_imap_stream_unget_token (engine->istream, token);
-				if (camel_imap_engine_parse_resp_code (engine, ex) == -1)
+				camel_imap4_stream_unget_token (engine->istream, token);
+				if (camel_imap4_engine_parse_resp_code (engine, ex) == -1)
 					return -1;
 			} else if (token->token != '\n') {
 				/* we just have resp text */
-				if (camel_imap_engine_line (engine, NULL, NULL, ex) == -1)
+				if (camel_imap4_engine_line (engine, NULL, NULL, ex) == -1)
 					return -1;
 			}
 		} else if (!strcmp ("OK", token->v.atom)) {
-			code = CAMEL_IMAP_UNTAGGED_OK;
+			code = CAMEL_IMAP4_UNTAGGED_OK;
 			
-			if (engine->state == CAMEL_IMAP_ENGINE_CONNECTED) {
+			if (engine->state == CAMEL_IMAP4_ENGINE_CONNECTED) {
 				/* initial server greeting */
-				engine->state = CAMEL_IMAP_ENGINE_PREAUTH;
+				engine->state = CAMEL_IMAP4_ENGINE_PREAUTH;
 			}
 			
-			if (camel_imap_engine_next_token (engine, token, ex) == -1)
+			if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 				return -1;
 			
 			if (token->token == '[') {
 				/* we have a resp code */
-				camel_imap_stream_unget_token (engine->istream, token);
-				if (camel_imap_engine_parse_resp_code (engine, ex) == -1)
+				camel_imap4_stream_unget_token (engine->istream, token);
+				if (camel_imap4_engine_parse_resp_code (engine, ex) == -1)
 					return -1;
 			} else {
 				/* we just have resp text */
-				if (camel_imap_engine_line (engine, NULL, NULL, ex) == -1)
+				if (camel_imap4_engine_line (engine, NULL, NULL, ex) == -1)
 					return -1;
 			}
 		} else if (!strcmp ("PREAUTH", token->v.atom)) {
-			code = CAMEL_IMAP_UNTAGGED_PREAUTH;
+			code = CAMEL_IMAP4_UNTAGGED_PREAUTH;
 			
-			if (engine->state == CAMEL_IMAP_ENGINE_CONNECTED)
-				engine->state = CAMEL_IMAP_ENGINE_AUTHENTICATED;
+			if (engine->state == CAMEL_IMAP4_ENGINE_CONNECTED)
+				engine->state = CAMEL_IMAP4_ENGINE_AUTHENTICATED;
 			
-			if (camel_imap_engine_parse_resp_code (engine, ex) == -1)
+			if (camel_imap4_engine_parse_resp_code (engine, ex) == -1)
 				return -1;
 		} else if (!strcmp ("STATUS", token->v.atom)) {
 			/* FIXME: This should probably be removed... leave it
@@ -1211,24 +1216,24 @@ camel_imap_engine_handle_untagged_1 (CamelIMAPEngine *engine, camel_imap_token_t
 			if (engine_parse_status (engine, ex) == -1)
 				return -1;
 		} else if (ic && (untagged = g_hash_table_lookup (ic->untagged, token->v.atom))) {
-			/* registered untagged handler for imap command */
+			/* registered untagged handler for imap4 command */
 			if (untagged (engine, ic, 0, token, ex) == -1)
 				return -1;
 		} else {
 			d(fprintf (stderr, "Unhandled atom token in untagged response: %s", token->v.atom));
 			
-			if (camel_imap_engine_eat_line (engine, ex) == -1)
+			if (camel_imap4_engine_eat_line (engine, ex) == -1)
 				return -1;
 		}
-	} else if (token->token == CAMEL_IMAP_TOKEN_NUMBER) {
+	} else if (token->token == CAMEL_IMAP4_TOKEN_NUMBER) {
 		/* we probably have something like "* 1 EXISTS" */
 		v = token->v.number;
 		
-		if (camel_imap_engine_next_token (engine, token, ex) == -1)
+		if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 			return -1;
 		
-		if (token->token != CAMEL_IMAP_TOKEN_ATOM) {
-			camel_imap_utils_set_unexpected_token_error (ex, engine, token);
+		if (token->token != CAMEL_IMAP4_TOKEN_ATOM) {
+			camel_imap4_utils_set_unexpected_token_error (ex, engine, token);
 			
 			return -1;
 		}
@@ -1243,13 +1248,13 @@ camel_imap_engine_handle_untagged_1 (CamelIMAPEngine *engine, camel_imap_token_t
 		
 		/* NOTE: these can be over-ridden by a registered untagged response handler */
 		if (!strcmp ("EXISTS", token->v.atom)) {
-			camel_imap_summary_set_exists (folder->summary, v);
+			camel_imap4_summary_set_exists (folder->summary, v);
 		} else if (!strcmp ("EXPUNGE", token->v.atom)) {
-			camel_imap_summary_expunge (folder->summary, (int) v);
+			camel_imap4_summary_expunge (folder->summary, (int) v);
 		} else if (!strcmp ("RECENT", token->v.atom)) {
-			camel_imap_summary_set_recent (folder->summary, v);
+			camel_imap4_summary_set_recent (folder->summary, v);
 		} else if (ic && (untagged = g_hash_table_lookup (ic->untagged, token->v.atom))) {
-			/* registered untagged handler for imap command */
+			/* registered untagged handler for imap4 command */
 			if (untagged (engine, ic, v, token, ex) == -1)
 				return -1;
 		} else {
@@ -1257,10 +1262,10 @@ camel_imap_engine_handle_untagged_1 (CamelIMAPEngine *engine, camel_imap_token_t
 		}
 		
 		/* find the eoln token */
-		if (camel_imap_engine_eat_line (engine, ex) == -1)
+		if (camel_imap4_engine_eat_line (engine, ex) == -1)
 			return -1;
 	} else {
-		camel_imap_utils_set_unexpected_token_error (ex, engine, token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, token);
 		
 		return -1;
 	}
@@ -1270,43 +1275,43 @@ camel_imap_engine_handle_untagged_1 (CamelIMAPEngine *engine, camel_imap_token_t
 
 
 void
-camel_imap_engine_handle_untagged (CamelIMAPEngine *engine, CamelException *ex)
+camel_imap4_engine_handle_untagged (CamelIMAP4Engine *engine, CamelException *ex)
 {
-	camel_imap_token_t token;
+	camel_imap4_token_t token;
 	
-	g_return_if_fail (CAMEL_IS_IMAP_ENGINE (engine));
+	g_return_if_fail (CAMEL_IS_IMAP4_ENGINE (engine));
 	
 	do {
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 			goto exception;
 		
 		if (token.token != '*')
 			break;
 		
-		if (camel_imap_engine_handle_untagged_1 (engine, &token, ex) == -1)
+		if (camel_imap4_engine_handle_untagged_1 (engine, &token, ex) == -1)
 			goto exception;
 	} while (1);
 	
-	camel_imap_stream_unget_token (engine->istream, &token);
+	camel_imap4_stream_unget_token (engine->istream, &token);
 	
 	return;
 	
  exception:
 	
-	engine->state = CAMEL_IMAP_ENGINE_DISCONNECTED;
+	engine->state = CAMEL_IMAP4_ENGINE_DISCONNECTED;
 }
 
 
 static int
-imap_process_command (CamelIMAPEngine *engine, CamelIMAPCommand *ic)
+imap4_process_command (CamelIMAP4Engine *engine, CamelIMAP4Command *ic)
 {
 	int retval;
 	
-	while ((retval = camel_imap_command_step (ic)) == 0)
+	while ((retval = camel_imap4_command_step (ic)) == 0)
 		;
 	
 	if (retval == -1) {
-		engine->state = CAMEL_IMAP_ENGINE_DISCONNECTED;
+		engine->state = CAMEL_IMAP4_ENGINE_DISCONNECTED;
 		return -1;
 	}
 	
@@ -1315,12 +1320,12 @@ imap_process_command (CamelIMAPEngine *engine, CamelIMAPCommand *ic)
 
 
 static void
-engine_prequeue_folder_select (CamelIMAPEngine *engine)
+engine_prequeue_folder_select (CamelIMAP4Engine *engine)
 {
-	CamelIMAPCommand *ic;
+	CamelIMAP4Command *ic;
 	const char *cmd;
 	
-	ic = (CamelIMAPCommand *) engine->queue.head;
+	ic = (CamelIMAP4Command *) engine->queue.head;
 	cmd = (const char *) ic->parts->buffer;
 	
 	if (!ic->folder || ic->folder == engine->folder ||
@@ -1330,47 +1335,47 @@ engine_prequeue_folder_select (CamelIMAPEngine *engine)
 	}
 	
 	/* we need to pre-queue a SELECT */
-	ic = camel_imap_command_new (engine, ic->folder, "SELECT %F\r\n", ic->folder);
-	camel_imap_engine_prequeue (engine, ic);
+	ic = camel_imap4_command_new (engine, ic->folder, "SELECT %F\r\n", ic->folder);
+	camel_imap4_engine_prequeue (engine, ic);
 	ic->user_data = engine;
 	
-	camel_imap_command_unref (ic);
+	camel_imap4_command_unref (ic);
 }
 
 
 static int
-engine_state_change (CamelIMAPEngine *engine, CamelIMAPCommand *ic)
+engine_state_change (CamelIMAP4Engine *engine, CamelIMAP4Command *ic)
 {
 	const char *cmd;
 	int retval = 0;
 	
 	cmd = ic->parts->buffer;
 	if (!strncmp (cmd, "SELECT ", 7) || !strncmp (cmd, "EXAMINE ", 8)) {
-		if (ic->result == CAMEL_IMAP_RESULT_OK) {
+		if (ic->result == CAMEL_IMAP4_RESULT_OK) {
 			/* Update the selected folder */
 			camel_object_ref (ic->folder);
 			if (engine->folder)
 				camel_object_unref (engine->folder);
 			engine->folder = ic->folder;
 			
-			engine->state = CAMEL_IMAP_ENGINE_SELECTED;
+			engine->state = CAMEL_IMAP4_ENGINE_SELECTED;
 		} else if (ic->user_data == engine) {
 			/* the engine pre-queued this SELECT command */
 			retval = -1;
 		}
 	} else if (!strncmp (cmd, "CLOSE", 5)) {
-		if (ic->result == CAMEL_IMAP_RESULT_OK)
-			engine->state = CAMEL_IMAP_ENGINE_AUTHENTICATED;
+		if (ic->result == CAMEL_IMAP4_RESULT_OK)
+			engine->state = CAMEL_IMAP4_ENGINE_AUTHENTICATED;
 	} else if (!strncmp (cmd, "LOGOUT", 6)) {
-		engine->state = CAMEL_IMAP_ENGINE_DISCONNECTED;
+		engine->state = CAMEL_IMAP4_ENGINE_DISCONNECTED;
 	}
 	
 	return retval;
 }
 
 /**
- * camel_imap_engine_iterate:
- * @engine: IMAP engine
+ * camel_imap4_engine_iterate:
+ * @engine: IMAP4 engine
  *
  * Processes the first command in the queue.
  *
@@ -1378,12 +1383,12 @@ engine_state_change (CamelIMAPEngine *engine, CamelIMAPCommand *ic)
  * commands to process, or -1 on error.
  *
  * Note: more details on the error will be held on the
- * CamelIMAPCommand that failed.
+ * CamelIMAP4Command that failed.
  **/
 int
-camel_imap_engine_iterate (CamelIMAPEngine *engine)
+camel_imap4_engine_iterate (CamelIMAP4Engine *engine)
 {
-	CamelIMAPCommand *ic, *nic;
+	CamelIMAP4Command *ic, *nic;
 	GPtrArray *resp_codes;
 	int retval = -1;
 	
@@ -1393,21 +1398,21 @@ camel_imap_engine_iterate (CamelIMAPEngine *engine)
 	/* check to see if we need to pre-queue a SELECT, if so do it */
 	engine_prequeue_folder_select (engine);
 	
-	engine->current = ic = (CamelIMAPCommand *) e_dlist_remhead (&engine->queue);
-	ic->status = CAMEL_IMAP_COMMAND_ACTIVE;
+	engine->current = ic = (CamelIMAP4Command *) e_dlist_remhead (&engine->queue);
+	ic->status = CAMEL_IMAP4_COMMAND_ACTIVE;
 	
-	if (imap_process_command (engine, ic) != -1) {
+	if (imap4_process_command (engine, ic) != -1) {
 		if (engine_state_change (engine, ic) == -1) {
 			/* This can ONLY happen if @ic was the pre-queued SELECT command
 			 * and it got a NO or BAD response.
 			 *
-			 * We have to pop the next imap command or we'll get into an
+			 * We have to pop the next imap4 command or we'll get into an
 			 * infinite loop. In order to provide @nic's owner with as much
 			 * information as possible, we move all @ic status information
 			 * over to @nic and pretend we just processed @nic.
 			 **/
 			
-			nic = (CamelIMAPCommand *) e_dlist_remhead (&engine->queue);
+			nic = (CamelIMAP4Command *) e_dlist_remhead (&engine->queue);
 			
 			nic->status = ic->status;
 			nic->result = ic->result;
@@ -1417,81 +1422,81 @@ camel_imap_engine_iterate (CamelIMAPEngine *engine)
 			
 			camel_exception_xfer (&nic->ex, &ic->ex);
 			
-			camel_imap_command_unref (ic);
+			camel_imap4_command_unref (ic);
 			ic = nic;
 		}
 		
 		retval = ic->id;
 	}
 	
-	camel_imap_command_unref (ic);
+	camel_imap4_command_unref (ic);
 	
 	return retval;
 }
 
 
 /**
- * camel_imap_engine_queue:
- * @engine: IMAP engine
- * @folder: IMAP folder that the command will affect (or %NULL if it doesn't matter)
+ * camel_imap4_engine_queue:
+ * @engine: IMAP4 engine
+ * @folder: IMAP4 folder that the command will affect (or %NULL if it doesn't matter)
  * @format: command format
  * @Varargs: arguments
  *
- * Basically the same as #camel_imap_command_new() except that this
+ * Basically the same as #camel_imap4_command_new() except that this
  * function also places the command in the engine queue.
  *
- * Returns the CamelIMAPCommand.
+ * Returns the CamelIMAP4Command.
  **/
-CamelIMAPCommand *
-camel_imap_engine_queue (CamelIMAPEngine *engine, CamelFolder *folder, const char *format, ...)
+CamelIMAP4Command *
+camel_imap4_engine_queue (CamelIMAP4Engine *engine, CamelFolder *folder, const char *format, ...)
 {
-	CamelIMAPCommand *ic;
+	CamelIMAP4Command *ic;
 	va_list args;
 	
 	va_start (args, format);
-	ic = camel_imap_command_newv (engine, (CamelIMAPFolder *) folder, format, args);
+	ic = camel_imap4_command_newv (engine, (CamelIMAP4Folder *) folder, format, args);
 	va_end (args);
 	
 	ic->id = engine->nextid++;
 	e_dlist_addtail (&engine->queue, (EDListNode *) ic);
-	camel_imap_command_ref (ic);
+	camel_imap4_command_ref (ic);
 	
 	return ic;
 }
 
 
 /**
- * camel_imap_engine_prequeue:
- * @engine: IMAP engine
- * @ic: IMAP command to pre-queue
+ * camel_imap4_engine_prequeue:
+ * @engine: IMAP4 engine
+ * @ic: IMAP4 command to pre-queue
  *
- * Places @ic at the head of the queue of pending IMAP commands.
+ * Places @ic at the head of the queue of pending IMAP4 commands.
  **/
 void
-camel_imap_engine_prequeue (CamelIMAPEngine *engine, CamelIMAPCommand *ic)
+camel_imap4_engine_prequeue (CamelIMAP4Engine *engine, CamelIMAP4Command *ic)
 {
-	g_return_if_fail (CAMEL_IS_IMAP_ENGINE (engine));
+	g_return_if_fail (CAMEL_IS_IMAP4_ENGINE (engine));
 	g_return_if_fail (ic != NULL);
 	
-	camel_imap_command_ref (ic);
+	camel_imap4_command_ref (ic);
 	
 	if (e_dlist_empty (&engine->queue)) {
 		e_dlist_addtail (&engine->queue, (EDListNode *) ic);
 		ic->id = engine->nextid++;
 	} else {
-		CamelIMAPCommand *nic;
+		CamelIMAP4Command *nic;
 		EDListNode *node;
 		
 		node = (EDListNode *) ic;
 		e_dlist_addhead (&engine->queue, node);
-		nic = (CamelIMAPCommand *) node->next;
+		nic = (CamelIMAP4Command *) node->next;
 		ic->id = nic->id - 1;
 		
 		if (ic->id == 0) {
 			/* increment all command ids */
 			node = engine->queue.head;
 			while (node->next) {
-				nic = (CamelIMAPCommand *) node;
+				nic = (CamelIMAP4Command *) node;
 				node = node->next;
 				nic->id++;
 			}
@@ -1501,7 +1506,7 @@ camel_imap_engine_prequeue (CamelIMAPEngine *engine, CamelIMAPCommand *ic)
 
 
 void
-camel_imap_engine_dequeue (CamelIMAPEngine *engine, CamelIMAPCommand *ic)
+camel_imap4_engine_dequeue (CamelIMAP4Engine *engine, CamelIMAP4Command *ic)
 {
 	EDListNode *node = (EDListNode *) ic;
 	
@@ -1512,16 +1517,16 @@ camel_imap_engine_dequeue (CamelIMAPEngine *engine, CamelIMAPCommand *ic)
 	node->next = NULL;
 	node->prev = NULL;
 	
-	camel_imap_command_unref (ic);
+	camel_imap4_command_unref (ic);
 }
 
 
 int
-camel_imap_engine_next_token (CamelIMAPEngine *engine, camel_imap_token_t *token, CamelException *ex)
+camel_imap4_engine_next_token (CamelIMAP4Engine *engine, camel_imap4_token_t *token, CamelException *ex)
 {
-	if (camel_imap_stream_next_token (engine->istream, token) == -1) {
+	if (camel_imap4_stream_next_token (engine->istream, token) == -1) {
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
-				      _("IMAP server %s unexpectedly disconnected: %s"),
+				      _("IMAP4 server %s unexpectedly disconnected: %s"),
 				      engine->url->host, errno ? g_strerror (errno) : _("Unknown"));
 		return -1;
 	}
@@ -1531,24 +1536,24 @@ camel_imap_engine_next_token (CamelIMAPEngine *engine, camel_imap_token_t *token
 
 
 int
-camel_imap_engine_eat_line (CamelIMAPEngine *engine, CamelException *ex)
+camel_imap4_engine_eat_line (CamelIMAP4Engine *engine, CamelException *ex)
 {
-	camel_imap_token_t token;
+	camel_imap4_token_t token;
 	unsigned char *literal;
 	int retval;
 	size_t n;
 	
 	do {
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 			return -1;
 		
-		if (token.token == CAMEL_IMAP_TOKEN_LITERAL) {
-			while ((retval = camel_imap_stream_literal (engine->istream, &literal, &n)) == 1)
+		if (token.token == CAMEL_IMAP4_TOKEN_LITERAL) {
+			while ((retval = camel_imap4_stream_literal (engine->istream, &literal, &n)) == 1)
 				;
 			
 			if (retval == -1) {
 				camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
-						      _("IMAP server %s unexpectedly disconnected: %s"),
+						      _("IMAP4 server %s unexpectedly disconnected: %s"),
 						      engine->url->host, errno ? g_strerror (errno) : _("Unknown"));
 				
 				return -1;
@@ -1561,7 +1566,7 @@ camel_imap_engine_eat_line (CamelIMAPEngine *engine, CamelException *ex)
 
 
 int
-camel_imap_engine_line (CamelIMAPEngine *engine, unsigned char **line, size_t *len, CamelException *ex)
+camel_imap4_engine_line (CamelIMAP4Engine *engine, unsigned char **line, size_t *len, CamelException *ex)
 {
 	GByteArray *linebuf = NULL;
 	unsigned char *buf;
@@ -1571,14 +1576,14 @@ camel_imap_engine_line (CamelIMAPEngine *engine, unsigned char **line, size_t *l
 	if (line != NULL)
 		linebuf = g_byte_array_new ();
 	
-	while ((retval = camel_imap_stream_line (engine->istream, &buf, &buflen)) > 0) {
+	while ((retval = camel_imap4_stream_line (engine->istream, &buf, &buflen)) > 0) {
 		if (linebuf != NULL)
 			g_byte_array_append (linebuf, buf, buflen);
 	}
 	
 	if (retval == -1) {
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
-				      _("IMAP server %s unexpectedly disconnected: %s"),
+				      _("IMAP4 server %s unexpectedly disconnected: %s"),
 				      engine->url->host, errno ? g_strerror (errno) : _("Unknown"));
 		
 		if (linebuf != NULL)
@@ -1601,7 +1606,7 @@ camel_imap_engine_line (CamelIMAPEngine *engine, unsigned char **line, size_t *l
 
 
 int
-camel_imap_engine_literal (CamelIMAPEngine *engine, unsigned char **literal, size_t *len, CamelException *ex)
+camel_imap4_engine_literal (CamelIMAP4Engine *engine, unsigned char **literal, size_t *len, CamelException *ex)
 {
 	GByteArray *literalbuf = NULL;
 	unsigned char *buf;
@@ -1611,14 +1616,14 @@ camel_imap_engine_literal (CamelIMAPEngine *engine, unsigned char **literal, siz
 	if (literal != NULL)
 		literalbuf = g_byte_array_new ();
 	
-	while ((retval = camel_imap_stream_literal (engine->istream, &buf, &buflen)) > 0) {
+	while ((retval = camel_imap4_stream_literal (engine->istream, &buf, &buflen)) > 0) {
 		if (literalbuf != NULL)
 			g_byte_array_append (literalbuf, buf, buflen);
 	}
 	
 	if (retval == -1) {
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
-				      _("IMAP server %s unexpectedly disconnected: %s"),
+				      _("IMAP4 server %s unexpectedly disconnected: %s"),
 				      engine->url->host, errno ? g_strerror (errno) : _("Unknown"));
 		
 		if (literalbuf != NULL)
@@ -1642,17 +1647,17 @@ camel_imap_engine_literal (CamelIMAPEngine *engine, unsigned char **literal, siz
 
 
 void
-camel_imap_resp_code_free (CamelIMAPRespCode *rcode)
+camel_imap4_resp_code_free (CamelIMAP4RespCode *rcode)
 {
 	switch (rcode->code) {
-	case CAMEL_IMAP_RESP_CODE_PARSE:
+	case CAMEL_IMAP4_RESP_CODE_PARSE:
 		g_free (rcode->v.parse);
 		break;
-	case CAMEL_IMAP_RESP_CODE_NEWNAME:
+	case CAMEL_IMAP4_RESP_CODE_NEWNAME:
 		g_free (rcode->v.newname[0]);
 		g_free (rcode->v.newname[1]);
 		break;
-	case CAMEL_IMAP_RESP_CODE_COPYUID:
+	case CAMEL_IMAP4_RESP_CODE_COPYUID:
 		g_free (rcode->v.copyuid.srcset);
 		g_free (rcode->v.copyuid.destset);
 		break;
diff --git a/camel/providers/imap4/camel-imap4-engine.h b/camel/providers/imap4/camel-imap4-engine.h
new file mode 100644
index 0000000000..25ae7ed113
--- /dev/null
+++ b/camel/providers/imap4/camel-imap4-engine.h
@@ -0,0 +1,222 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*  Camel
+ *  Copyright (C) 1999-2004 Jeffrey Stedfast
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __CAMEL_IMAP4_ENGINE_H__
+#define __CAMEL_IMAP4_ENGINE_H__
+
+#include <stdarg.h>
+
+#include <glib.h>
+
+#include <e-util/e-msgport.h>
+
+#include <camel/camel-stream.h>
+#include <camel/camel-folder.h>
+#include <camel/camel-session.h>
+
+#ifdef __cplusplus
+extern "C" {
+#pragma }
+#endif /* __cplusplus */
+
+#define CAMEL_TYPE_IMAP4_ENGINE            (camel_imap4_engine_get_type ())
+#define CAMEL_IMAP4_ENGINE(obj)            (CAMEL_CHECK_CAST ((obj), CAMEL_TYPE_IMAP4_ENGINE, CamelIMAP4Engine))
+#define CAMEL_IMAP4_ENGINE_CLASS(klass)    (CAMEL_CHECK_CLASS_CAST ((klass), CAMEL_TYPE_IMAP4_ENGINE, CamelIMAP4EngineClass))
+#define CAMEL_IS_IMAP4_ENGINE(obj)         (CAMEL_CHECK_TYPE ((obj), CAMEL_TYPE_IMAP4_ENGINE))
+#define CAMEL_IS_IMAP4_ENGINE_CLASS(klass) (CAMEL_CHECK_CLASS_TYPE ((klass), CAMEL_TYPE_IMAP4_ENGINE))
+#define CAMEL_IMAP4_ENGINE_GET_CLASS(obj)  (CAMEL_CHECK_GET_CLASS ((obj), CAMEL_TYPE_IMAP4_ENGINE, CamelIMAP4EngineClass))
+
+typedef struct _CamelIMAP4Engine CamelIMAP4Engine;
+typedef struct _CamelIMAP4EngineClass CamelIMAP4EngineClass;
+
+struct _camel_imap4_token_t;
+struct _CamelIMAP4Command;
+struct _CamelIMAP4Folder;
+struct _CamelIMAP4Stream;
+
+typedef enum {
+	CAMEL_IMAP4_ENGINE_DISCONNECTED,
+	CAMEL_IMAP4_ENGINE_CONNECTED,
+	CAMEL_IMAP4_ENGINE_PREAUTH,
+	CAMEL_IMAP4_ENGINE_AUTHENTICATED,
+	CAMEL_IMAP4_ENGINE_SELECTED,
+} camel_imap4_engine_t;
+
+typedef enum {
+	CAMEL_IMAP4_LEVEL_UNKNOWN,
+	CAMEL_IMAP4_LEVEL_IMAP44,
+	CAMEL_IMAP4_LEVEL_IMAP44REV1
+} camel_imap4_level_t;
+
+enum {
+	CAMEL_IMAP4_CAPABILITY_IMAP44           = (1 << 0),
+	CAMEL_IMAP4_CAPABILITY_IMAP44REV1       = (1 << 1),
+	CAMEL_IMAP4_CAPABILITY_STATUS          = (1 << 2),
+	CAMEL_IMAP4_CAPABILITY_NAMESPACE       = (1 << 3),
+	CAMEL_IMAP4_CAPABILITY_UIDPLUS         = (1 << 4),
+	CAMEL_IMAP4_CAPABILITY_LITERALPLUS     = (1 << 5),
+	CAMEL_IMAP4_CAPABILITY_LOGINDISABLED   = (1 << 6),
+	CAMEL_IMAP4_CAPABILITY_STARTTLS        = (1 << 7),
+	CAMEL_IMAP4_CAPABILITY_useful_lsub     = (1 << 8),
+	CAMEL_IMAP4_CAPABILITY_utf8_search     = (1 << 9),
+};
+
+typedef enum {
+	CAMEL_IMAP4_RESP_CODE_ALERT,
+	CAMEL_IMAP4_RESP_CODE_BADCHARSET,
+	CAMEL_IMAP4_RESP_CODE_CAPABILITY,
+	CAMEL_IMAP4_RESP_CODE_PARSE,
+	CAMEL_IMAP4_RESP_CODE_PERM_FLAGS,
+	CAMEL_IMAP4_RESP_CODE_READONLY,
+	CAMEL_IMAP4_RESP_CODE_READWRITE,
+	CAMEL_IMAP4_RESP_CODE_TRYCREATE,
+	CAMEL_IMAP4_RESP_CODE_UIDNEXT,
+	CAMEL_IMAP4_RESP_CODE_UIDVALIDITY,
+	CAMEL_IMAP4_RESP_CODE_UNSEEN,
+	CAMEL_IMAP4_RESP_CODE_NEWNAME,
+	CAMEL_IMAP4_RESP_CODE_APPENDUID,
+	CAMEL_IMAP4_RESP_CODE_COPYUID,
+	CAMEL_IMAP4_RESP_CODE_UNKNOWN,
+} camel_imap4_resp_code_t;
+
+typedef struct _CamelIMAP4RespCode {
+	camel_imap4_resp_code_t code;
+	union {
+		guint32 flags;
+		char *parse;
+		guint32 uidnext;
+		guint32 uidvalidity;
+		guint32 unseen;
+		char *newname[2];
+		struct {
+			guint32 uidvalidity;
+			guint32 uid;
+		} appenduid;
+		struct {
+			guint32 uidvalidity;
+			char *srcset;
+			char *destset;
+		} copyuid;
+	} v;
+} CamelIMAP4RespCode;
+
+enum {
+	CAMEL_IMAP4_UNTAGGED_ERROR = -1,
+	CAMEL_IMAP4_UNTAGGED_OK,
+	CAMEL_IMAP4_UNTAGGED_NO,
+	CAMEL_IMAP4_UNTAGGED_BAD,
+	CAMEL_IMAP4_UNTAGGED_PREAUTH,
+	CAMEL_IMAP4_UNTAGGED_HANDLED,
+};
+
+typedef struct _CamelIMAP4Namespace {
+	struct _CamelIMAP4Namespace *next;
+	char *path;
+	char sep;
+} CamelIMAP4Namespace;
+
+typedef struct _CamelIMAP4NamespaceList {
+	CamelIMAP4Namespace *personal;
+	CamelIMAP4Namespace *other;
+	CamelIMAP4Namespace *shared;
+} CamelIMAP4NamespaceList;
+
+enum {
+	CAMEL_IMAP4_ENGINE_MAXLEN_LINE,
+	CAMEL_IMAP4_ENGINE_MAXLEN_TOKEN
+};
+
+struct _CamelIMAP4Engine {
+	CamelObject parent_object;
+	
+	CamelSession *session;
+	CamelURL *url;
+	
+	camel_imap4_engine_t state;
+	camel_imap4_level_t level;
+	guint32 capa;
+	
+	guint32 maxlen:31;
+	guint32 maxlentype:1;
+	
+	CamelIMAP4NamespaceList namespaces;
+	GHashTable *authtypes;                    /* supported authtypes */
+	
+	struct _CamelIMAP4Stream *istream;
+	CamelStream *ostream;
+	
+	unsigned char tagprefix;             /* 'A'..'Z' */
+	unsigned int tag;                    /* next command tag */
+	int nextid;
+	
+	struct _CamelIMAP4Folder *folder;    /* currently selected folder */
+	
+	EDList queue;                          /* queue of waiting commands */
+	struct _CamelIMAP4Command *current;
+};
+
+struct _CamelIMAP4EngineClass {
+	CamelObjectClass parent_class;
+	
+	unsigned char tagprefix;
+};
+
+
+CamelType camel_imap4_engine_get_type (void);
+
+CamelIMAP4Engine *camel_imap4_engine_new (CamelSession *session, CamelURL *url);
+
+/* returns 0 on success or -1 on error */
+int camel_imap4_engine_take_stream (CamelIMAP4Engine *engine, CamelStream *stream, CamelException *ex);
+
+int camel_imap4_engine_capability (CamelIMAP4Engine *engine, CamelException *ex);
+int camel_imap4_engine_namespace (CamelIMAP4Engine *engine, CamelException *ex);
+
+int camel_imap4_engine_select_folder (CamelIMAP4Engine *engine, CamelFolder *folder, CamelException *ex);
+
+struct _CamelIMAP4Command *camel_imap4_engine_queue (CamelIMAP4Engine *engine, CamelFolder *folder,
+						     const char *format, ...);
+void camel_imap4_engine_prequeue (CamelIMAP4Engine *engine, struct _CamelIMAP4Command *ic);
+
+void camel_imap4_engine_dequeue (CamelIMAP4Engine *engine, struct _CamelIMAP4Command *ic);
+
+int camel_imap4_engine_iterate (CamelIMAP4Engine *engine);
+
+
+/* untagged response utility functions */
+int camel_imap4_engine_handle_untagged_1 (CamelIMAP4Engine *engine, struct _camel_imap4_token_t *token, CamelException *ex);
+void camel_imap4_engine_handle_untagged (CamelIMAP4Engine *engine, CamelException *ex);
+
+/* stream wrapper utility functions */
+int camel_imap4_engine_next_token (CamelIMAP4Engine *engine, struct _camel_imap4_token_t *token, CamelException *ex);
+int camel_imap4_engine_line (CamelIMAP4Engine *engine, unsigned char **line, size_t *len, CamelException *ex);
+int camel_imap4_engine_literal (CamelIMAP4Engine *engine, unsigned char **literal, size_t *len, CamelException *ex);
+int camel_imap4_engine_eat_line (CamelIMAP4Engine *engine, CamelException *ex);
+
+
+/* response code stuff */
+int camel_imap4_engine_parse_resp_code (CamelIMAP4Engine *engine, CamelException *ex);
+void camel_imap4_resp_code_free (CamelIMAP4RespCode *rcode);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __CAMEL_IMAP4_ENGINE_H__ */
diff --git a/camel/providers/imap4/camel-imap-folder.c b/camel/providers/imap4/camel-imap4-folder.c
index 04af9f3cb8..2169f053ce 100644
--- a/camel/providers/imap4/camel-imap-folder.c
+++ b/camel/providers/imap4/camel-imap4-folder.c
@@ -22,6 +22,8 @@
 #include <config.h>
 #endif
 
+#include <glib.h>
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -33,90 +35,180 @@
 #include <errno.h>
 #include <time.h>
 
+#include <camel/camel-utf8.h>
 #include <camel/camel-file-utils.h>
 #include <camel/camel-mime-message.h>
 #include <camel/camel-stream-mem.h>
 #include <camel/camel-stream-filter.h>
 #include <camel/camel-mime-filter-crlf.h>
 
-#include "camel-imap-utils.h"
-#include "camel-imap-store.h"
-#include "camel-imap-engine.h"
-#include "camel-imap-folder.h"
-#include "camel-imap-stream.h"
-#include "camel-imap-command.h"
-#include "camel-imap-summary.h"
+#include "camel-imap4-utils.h"
+#include "camel-imap4-store.h"
+#include "camel-imap4-engine.h"
+#include "camel-imap4-folder.h"
+#include "camel-imap4-stream.h"
+#include "camel-imap4-command.h"
+#include "camel-imap4-summary.h"
 
 #define d(x) x
 
-static void camel_imap_folder_class_init (CamelIMAPFolderClass *klass);
-static void camel_imap_folder_init (CamelIMAPFolder *folder, CamelIMAPFolderClass *klass);
-static void camel_imap_folder_finalize (CamelObject *object);
+static void camel_imap4_folder_class_init (CamelIMAP4FolderClass *klass);
+static void camel_imap4_folder_init (CamelIMAP4Folder *folder, CamelIMAP4FolderClass *klass);
+static void camel_imap4_folder_finalize (CamelObject *object);
 
-static void imap_sync (CamelFolder *folder, gboolean expunge, CamelException *ex);
-static void imap_expunge (CamelFolder *folder, CamelException *ex);
-static CamelMimeMessage *imap_get_message (CamelFolder *folder, const char *uid, CamelException *ex);
-static void imap_append_message (CamelFolder *folder, CamelMimeMessage *message,
-				 const CamelMessageInfo *info, char **appended_uid, CamelException *ex);
-static void imap_transfer_messages_to (CamelFolder *src, GPtrArray *uids, CamelFolder *dest,
-				       GPtrArray **transferred_uids, gboolean delete_originals, CamelException *ex);
+static void imap4_sync (CamelFolder *folder, gboolean expunge, CamelException *ex);
+static void imap4_expunge (CamelFolder *folder, CamelException *ex);
+static CamelMimeMessage *imap4_get_message (CamelFolder *folder, const char *uid, CamelException *ex);
+static void imap4_append_message (CamelFolder *folder, CamelMimeMessage *message,
+				  const CamelMessageInfo *info, char **appended_uid, CamelException *ex);
+static void imap4_transfer_messages_to (CamelFolder *src, GPtrArray *uids, CamelFolder *dest,
+					GPtrArray **transferred_uids, gboolean delete_originals, CamelException *ex);
 
 
 static CamelFolderClass *parent_class = NULL;
 
 
 CamelType
-camel_imap_folder_get_type (void)
+camel_imap4_folder_get_type (void)
 {
 	static CamelType type = 0;
 	
 	if (!type) {
-		type = camel_type_register (CAMEL_TYPE_IMAP_FOLDER,
-					    "CamelIMAPFolder",
-					    sizeof (CamelIMAPFolder),
-					    sizeof (CamelIMAPFolderClass),
-					    (CamelObjectClassInitFunc) camel_imap_folder_class_init,
+		type = camel_type_register (CAMEL_TYPE_IMAP4_FOLDER,
+					    "CamelIMAP4Folder",
+					    sizeof (CamelIMAP4Folder),
+					    sizeof (CamelIMAP4FolderClass),
+					    (CamelObjectClassInitFunc) camel_imap4_folder_class_init,
 					    NULL,
-					    (CamelObjectInitFunc) camel_imap_folder_init,
-					    (CamelObjectFinalizeFunc) camel_imap_folder_finalize);
+					    (CamelObjectInitFunc) camel_imap4_folder_init,
+					    (CamelObjectFinalizeFunc) camel_imap4_folder_finalize);
 	}
 	
 	return type;
 }
 
 static void
-camel_imap_folder_class_init (CamelIMAPFolderClass *klass)
+camel_imap4_folder_class_init (CamelIMAP4FolderClass *klass)
 {
 	CamelFolderClass *folder_class = (CamelFolderClass *) klass;
 	
 	parent_class = (CamelFolderClass *) camel_type_get_global_classfuncs (CAMEL_FOLDER_TYPE);
 	
-	folder_class->sync = imap_sync;
-	folder_class->expunge = imap_expunge;
-	folder_class->get_message = imap_get_message;
-	folder_class->append_message = imap_append_message;
-	folder_class->transfer_messages_to = imap_transfer_messages_to;
+	folder_class->sync = imap4_sync;
+	folder_class->expunge = imap4_expunge;
+	folder_class->get_message = imap4_get_message;
+	folder_class->append_message = imap4_append_message;
+	folder_class->transfer_messages_to = imap4_transfer_messages_to;
 }
 
 static void
-camel_imap_folder_init (CamelIMAPFolder *folder, CamelIMAPFolderClass *klass)
+camel_imap4_folder_init (CamelIMAP4Folder *folder, CamelIMAP4FolderClass *klass)
 {
 	folder->utf7_name = NULL;
 }
 
 static void
-camel_imap_folder_finalize (CamelObject *object)
+camel_imap4_folder_finalize (CamelObject *object)
 {
-	CamelIMAPFolder *folder = (CamelIMAPFolder *) object;
+	CamelIMAP4Folder *folder = (CamelIMAP4Folder *) object;
 	
 	g_free (folder->utf7_name);
 }
 
+static char
+imap4_get_path_delim (CamelIMAP4Engine *engine, const char *full_name)
+{
+	CamelIMAP4Namespace *namespace;
+	const char *slash;
+	size_t len;
+	char *top;
+	
+	if ((slash = strchr (full_name, '/')))
+		len = (slash - full_name);
+	else
+		len = strlen (full_name);
+	
+	top = g_alloca (len + 1);
+	memcpy (top, full_name, len);
+	top[len] = '\0';
+	
+	if (!g_ascii_strcasecmp (top, "INBOX"))
+		top = "INBOX";
+	
+ retry:
+	namespace = engine->namespaces.personal;
+	while (namespace != NULL) {
+		if (!strcmp (namespace->path, top))
+			return namespace->sep;
+		namespace = namespace->next;
+	}
+	
+	namespace = engine->namespaces.other;
+	while (namespace != NULL) {
+		if (!strcmp (namespace->path, top))
+			return namespace->sep;
+		namespace = namespace->next;
+	}
+	
+	namespace = engine->namespaces.shared;
+	while (namespace != NULL) {
+		if (!strcmp (namespace->path, top))
+			return namespace->sep;
+		namespace = namespace->next;
+	}
+	
+	if (top[0] != '\0') {
+		/* look for a default namespace? */
+		top[0] = '\0';
+		goto retry;
+	}
+	
+	return '/';
+}
+
+CamelFolder *
+camel_imap4_folder_new (CamelStore *store, const char *full_name, CamelException *ex)
+{
+	CamelIMAP4Folder *imap_folder;
+	char *utf7_name, *name, *p;
+	char sep;
+	
+	if (!(p = strrchr (full_name, '/')))
+		p = (char *) full_name;
+	else
+		p++;
+	
+	name = g_alloca (strlen (p) + 1);
+	strcpy (name, p);
+	
+	utf7_name = g_alloca (strlen (full_name) + 1);
+	strcpy (utf7_name, full_name);
+	
+	sep = imap4_get_path_delim (((CamelIMAP4Store *) store)->engine, full_name);
+	if (sep != '/') {
+		p = utf7_name;
+		while (*p != '\0') {
+			if (*p == '/')
+				*p = sep;
+			p++;
+		}
+	}
+	
+	utf7_name = camel_utf8_utf7 (utf7_name);
+	
+	imap_folder = (CamelIMAP4Folder *) camel_object_new (CAMEL_TYPE_IMAP4_FOLDER);
+	camel_folder_construct ((CamelFolder *) imap_folder, store, full_name, name);
+	imap_folder->utf7_name = utf7_name;
+	
+	return (CamelFolder *) imap_folder;
+}
+
+
 
 static struct {
 	const char *name;
 	guint32 flag;
-} imap_flags[] = {
+} imap4_flags[] = {
 	{ "\\Answered", CAMEL_MESSAGE_ANSWERED  },
 	{ "\\Deleted",  CAMEL_MESSAGE_DELETED   },
 	{ "\\Draft",    CAMEL_MESSAGE_DRAFT     },
@@ -126,7 +218,7 @@ static struct {
 };
 
 static int
-imap_get_uid_set (CamelIMAPEngine *engine, CamelFolderSummary *summary, GPtrArray *infos, int cur, size_t linelen, char **set)
+imap4_get_uid_set (CamelIMAP4Engine *engine, CamelFolderSummary *summary, GPtrArray *infos, int cur, size_t linelen, char **set)
 {
 	CamelMessageInfo *info;
 	guint32 this, prev, next;
@@ -135,7 +227,7 @@ imap_get_uid_set (CamelIMAPEngine *engine, CamelFolderSummary *summary, GPtrArra
 	int scount, i;
 	size_t len;
 	
-	if (engine->maxlentype == CAMEL_IMAP_ENGINE_MAXLEN_LINE)
+	if (engine->maxlentype == CAMEL_IMAP4_ENGINE_MAXLEN_LINE)
 		len = engine->maxlen - linelen;
 	else
 		len = engine->maxlen;
@@ -206,38 +298,38 @@ imap_get_uid_set (CamelIMAPEngine *engine, CamelFolderSummary *summary, GPtrArra
 }
 
 static int
-imap_sync_flag (CamelFolder *folder, GPtrArray *infos, char onoff, const char *flag, CamelException *ex)
+imap4_sync_flag (CamelFolder *folder, GPtrArray *infos, char onoff, const char *flag, CamelException *ex)
 {
-	CamelIMAPEngine *engine = ((CamelIMAPStore *) folder->parent_store)->engine;
-	CamelIMAPCommand *ic;
+	CamelIMAP4Engine *engine = ((CamelIMAP4Store *) folder->parent_store)->engine;
+	CamelIMAP4Command *ic;
 	int i, id, retval = 0;
 	char *set = NULL;
 	
 	for (i = 0; i < infos->len; ) {
-		i += imap_get_uid_set (engine, folder->summary, infos, i, 30 + strlen (flag), &set);
+		i += imap4_get_uid_set (engine, folder->summary, infos, i, 30 + strlen (flag), &set);
 		
-		ic = camel_imap_engine_queue (engine, folder, "UID STORE %s %cFLAGS.SILENT (%s)\r\n", set, onoff, flag);
-		while ((id = camel_imap_engine_iterate (engine)) < ic->id && id != -1)
+		ic = camel_imap4_engine_queue (engine, folder, "UID STORE %s %cFLAGS.SILENT (%s)\r\n", set, onoff, flag);
+		while ((id = camel_imap4_engine_iterate (engine)) < ic->id && id != -1)
 			;
 		
 		g_free (set);
 		
-		if (id == -1 || ic->status != CAMEL_IMAP_COMMAND_COMPLETE) {
+		if (id == -1 || ic->status != CAMEL_IMAP4_COMMAND_COMPLETE) {
 			camel_exception_xfer (ex, &ic->ex);
-			camel_imap_command_unref (ic);
+			camel_imap4_command_unref (ic);
 			
 			return -1;
 		}
 		
 		switch (ic->result) {
-		case CAMEL_IMAP_RESULT_NO:
+		case CAMEL_IMAP4_RESULT_NO:
 			/* FIXME: would be good to save the NO reason into the err message */
 			camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 					      _("Cannot sync flags to folder `%s': Unknown"),
 					      folder->full_name);
 			retval = -1;
 			break;
-		case CAMEL_IMAP_RESULT_BAD:
+		case CAMEL_IMAP4_RESULT_BAD:
 			camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 					      _("Cannot sync flags to folder `%s': Bad command"),
 					      folder->full_name);
@@ -245,7 +337,7 @@ imap_sync_flag (CamelFolder *folder, GPtrArray *infos, char onoff, const char *f
 			break;
 		}
 		
-		camel_imap_command_unref (ic);
+		camel_imap4_command_unref (ic);
 		
 		if (retval == -1)
 			return -1;
@@ -255,9 +347,9 @@ imap_sync_flag (CamelFolder *folder, GPtrArray *infos, char onoff, const char *f
 }
 
 static int
-imap_sync_changes (CamelFolder *folder, GPtrArray *sync, CamelException *ex)
+imap4_sync_changes (CamelFolder *folder, GPtrArray *sync, CamelException *ex)
 {
-	CamelIMAPMessageInfo *iinfo;
+	CamelIMAP4MessageInfo *iinfo;
 	GPtrArray *on_set, *off_set;
 	CamelMessageInfo *info;
 	flags_diff_t diff;
@@ -268,15 +360,15 @@ imap_sync_changes (CamelFolder *folder, GPtrArray *sync, CamelException *ex)
 	off_set = g_ptr_array_new ();
 	
 	/* construct commands to sync system and user flags */
-	for (i = 0; i < G_N_ELEMENTS (imap_flags); i++) {
-		if (!(imap_flags[i].flag & folder->permanent_flags))
+	for (i = 0; i < G_N_ELEMENTS (imap4_flags); i++) {
+		if (!(imap4_flags[i].flag & folder->permanent_flags))
 			continue;
 		
 		for (j = 0; j < sync->len; j++) {
-			iinfo = (CamelIMAPMessageInfo *) info = sync->pdata[j];
-			camel_imap_flags_diff (&diff, iinfo->server_flags, info->flags);
-			if (diff.changed & imap_flags[i].flag) {
-				if (diff.bits & imap_flags[i].flag) {
+			iinfo = (CamelIMAP4MessageInfo *) info = sync->pdata[j];
+			camel_imap4_flags_diff (&diff, iinfo->server_flags, info->flags);
+			if (diff.changed & imap4_flags[i].flag) {
+				if (diff.bits & imap4_flags[i].flag) {
 					g_ptr_array_add (on_set, info);
 				} else {
 					g_ptr_array_add (off_set, info);
@@ -285,14 +377,14 @@ imap_sync_changes (CamelFolder *folder, GPtrArray *sync, CamelException *ex)
 		}
 		
 		if (on_set->len > 0) {
-			if ((retval = imap_sync_flag (folder, on_set, '+', imap_flags[i].name, ex)) == -1)
+			if ((retval = imap4_sync_flag (folder, on_set, '+', imap4_flags[i].name, ex)) == -1)
 				break;
 			
 			g_ptr_array_set_size (on_set, 0);
 		}
 		
 		if (off_set->len > 0) {
-			if ((retval = imap_sync_flag (folder, off_set, '-', imap_flags[i].name, ex)) == -1)
+			if ((retval = imap4_sync_flag (folder, off_set, '-', imap4_flags[i].name, ex)) == -1)
 				break;
 			
 			g_ptr_array_set_size (off_set, 0);
@@ -306,7 +398,7 @@ imap_sync_changes (CamelFolder *folder, GPtrArray *sync, CamelException *ex)
 		return-1;
 	
 	for (i = 0; i < sync->len; i++) {
-		iinfo = (CamelIMAPMessageInfo *) info = sync->pdata[i];
+		iinfo = (CamelIMAP4MessageInfo *) info = sync->pdata[i];
 		info->flags &= ~CAMEL_MESSAGE_FOLDER_FLAGGED;
 		iinfo->server_flags = info->flags & folder->permanent_flags;
 	}
@@ -315,12 +407,12 @@ imap_sync_changes (CamelFolder *folder, GPtrArray *sync, CamelException *ex)
 }
 
 static void
-imap_sync (CamelFolder *folder, gboolean expunge, CamelException *ex)
+imap4_sync (CamelFolder *folder, gboolean expunge, CamelException *ex)
 {
-	CamelIMAPEngine *engine = ((CamelIMAPStore *) folder->parent_store)->engine;
-	CamelIMAPMessageInfo *iinfo;
+	CamelIMAP4Engine *engine = ((CamelIMAP4Store *) folder->parent_store)->engine;
+	CamelIMAP4MessageInfo *iinfo;
 	CamelMessageInfo *info;
-	CamelIMAPCommand *ic;
+	CamelIMAP4Command *ic;
 	flags_diff_t diff;
 	GPtrArray *sync;
 	int id, max, i;
@@ -330,10 +422,10 @@ imap_sync (CamelFolder *folder, gboolean expunge, CamelException *ex)
 	sync = g_ptr_array_new ();
 	max = camel_folder_summary_count (folder->summary);
 	for (i = 0; i < max; i++) {
-		iinfo = (CamelIMAPMessageInfo *) info = camel_folder_summary_index (folder->summary, i);
+		iinfo = (CamelIMAP4MessageInfo *) info = camel_folder_summary_index (folder->summary, i);
 		expunge = expunge && (info->flags & CAMEL_MESSAGE_DELETED);
 		if (info->flags & CAMEL_MESSAGE_FOLDER_FLAGGED) {
-			camel_imap_flags_diff (&diff, iinfo->server_flags, info->flags);
+			camel_imap4_flags_diff (&diff, iinfo->server_flags, info->flags);
 			diff.changed &= folder->permanent_flags;
 			
 			/* weed out flag changes that we can't sync to the server */
@@ -347,7 +439,7 @@ imap_sync (CamelFolder *folder, gboolean expunge, CamelException *ex)
 	}
 	
 	if (sync->len > 0) {
-		retval = imap_sync_changes (folder, sync, ex);
+		retval = imap4_sync_changes (folder, sync, ex);
 		
 		for (i = 0; i < sync->len; i++)
 			camel_folder_summary_info_free (folder->summary, sync->pdata[i]);
@@ -361,65 +453,65 @@ imap_sync (CamelFolder *folder, gboolean expunge, CamelException *ex)
 	}
 	
 	if (expunge) {
-		ic = camel_imap_engine_queue (engine, folder, "EXPUNGE\r\n");
-		while ((id = camel_imap_engine_iterate (engine)) < ic->id && id != -1)
+		ic = camel_imap4_engine_queue (engine, folder, "EXPUNGE\r\n");
+		while ((id = camel_imap4_engine_iterate (engine)) < ic->id && id != -1)
 			;
 		
 		switch (ic->result) {
-		case CAMEL_IMAP_RESULT_NO:
+		case CAMEL_IMAP4_RESULT_NO:
 			/* FIXME: would be good to save the NO reason into the err message */
 			camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 					      _("Cannot expunge folder `%s': Unknown"),
 					      folder->full_name);
 			break;
-		case CAMEL_IMAP_RESULT_BAD:
+		case CAMEL_IMAP4_RESULT_BAD:
 			camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 					      _("Cannot expunge folder `%s': Bad command"),
 					      folder->full_name);
 			break;
 		}
 		
-		camel_imap_command_unref (ic);
+		camel_imap4_command_unref (ic);
 	}
 	
 	camel_folder_summary_save (folder->summary);
 }
 
 static void
-imap_expunge (CamelFolder *folder, CamelException *ex)
+imap4_expunge (CamelFolder *folder, CamelException *ex)
 {
-	imap_sync (folder, TRUE, ex);
+	imap4_sync (folder, TRUE, ex);
 }
 
 
 static int
-untagged_fetch (CamelIMAPEngine *engine, CamelIMAPCommand *ic, guint32 index, camel_imap_token_t *token, CamelException *ex)
+untagged_fetch (CamelIMAP4Engine *engine, CamelIMAP4Command *ic, guint32 index, camel_imap4_token_t *token, CamelException *ex)
 {
 	CamelStream *fstream, *stream = ic->user_data;
 	CamelMimeFilter *crlf;
 	int left = 2;
 	
-	if (camel_imap_engine_next_token (engine, token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 		return -1;
 	
 	/* parse the FETCH response list */
 	if (token->token != '(') {
-		camel_imap_utils_set_unexpected_token_error (ex, engine, token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, token);
 		return -1;
 	}
 	
 	do {
-		if (camel_imap_engine_next_token (engine, token, ex) == -1)
+		if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 			goto exception;
 		
-		if (token->token != CAMEL_IMAP_TOKEN_ATOM)
+		if (token->token != CAMEL_IMAP4_TOKEN_ATOM)
 			goto unexpected;
 		
 		if (!strcmp (token->v.atom, "BODY[]")) {
-			if (camel_imap_engine_next_token (engine, token, ex) == -1)
+			if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 				goto exception;
 			
-			if (token->token != CAMEL_IMAP_TOKEN_LITERAL)
+			if (token->token != CAMEL_IMAP4_TOKEN_LITERAL)
 				goto unexpected;
 			
 			fstream = (CamelStream *) camel_stream_filter_new_with_stream (stream);
@@ -433,10 +525,10 @@ untagged_fetch (CamelIMAPEngine *engine, CamelIMAPCommand *ic, guint32 index, ca
 			
 			left--;
 		} else if (!strcmp (token->v.atom, "UID")) {
-			if (camel_imap_engine_next_token (engine, token, ex) == -1)
+			if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 				goto exception;
 			
-			if (token->token != CAMEL_IMAP_TOKEN_NUMBER || token->v.number == 0)
+			if (token->token != CAMEL_IMAP4_TOKEN_NUMBER || token->v.number == 0)
 				goto unexpected;
 			
 			left--;
@@ -446,7 +538,7 @@ untagged_fetch (CamelIMAPEngine *engine, CamelIMAPCommand *ic, guint32 index, ca
 		}
 	} while (left);
 	
-	if (camel_imap_engine_next_token (engine, token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 		goto exception;
 	
 	if (token->token != ')') {
@@ -458,7 +550,7 @@ untagged_fetch (CamelIMAPEngine *engine, CamelIMAPCommand *ic, guint32 index, ca
 	
  unexpected:
 	
-	camel_imap_utils_set_unexpected_token_error (ex, engine, token);
+	camel_imap4_utils_set_unexpected_token_error (ex, engine, token);
 	
  exception:
 	
@@ -466,48 +558,48 @@ untagged_fetch (CamelIMAPEngine *engine, CamelIMAPCommand *ic, guint32 index, ca
 }
 
 static CamelMimeMessage *
-imap_get_message (CamelFolder *folder, const char *uid, CamelException *ex)
+imap4_get_message (CamelFolder *folder, const char *uid, CamelException *ex)
 {
-	CamelIMAPEngine *engine = ((CamelIMAPStore *) folder->parent_store)->engine;
+	CamelIMAP4Engine *engine = ((CamelIMAP4Store *) folder->parent_store)->engine;
 	CamelMimeMessage *message = NULL;
-	CamelIMAPCommand *ic;
+	CamelIMAP4Command *ic;
 	CamelStream *stream;
 	int id;
 	
-	ic = camel_imap_engine_queue (engine, folder, "UID FETCH %s BODY.PEEK[]\r\n", uid);
-	camel_imap_command_register_untagged (ic, "FETCH", untagged_fetch);
+	ic = camel_imap4_engine_queue (engine, folder, "UID FETCH %s BODY.PEEK[]\r\n", uid);
+	camel_imap4_command_register_untagged (ic, "FETCH", untagged_fetch);
 	ic->user_data = stream = camel_stream_mem_new ();
 	
-	while ((id = camel_imap_engine_iterate (engine)) < ic->id && id != -1)
+	while ((id = camel_imap4_engine_iterate (engine)) < ic->id && id != -1)
 		;
 	
-	if (id == -1 || ic->status != CAMEL_IMAP_COMMAND_COMPLETE) {
+	if (id == -1 || ic->status != CAMEL_IMAP4_COMMAND_COMPLETE) {
 		camel_exception_xfer (ex, &ic->ex);
-		camel_imap_command_unref (ic);
+		camel_imap4_command_unref (ic);
 		camel_object_unref (stream);
 		return NULL;
 	}
 	
 	switch (ic->result) {
-	case CAMEL_IMAP_RESULT_OK:
+	case CAMEL_IMAP4_RESULT_OK:
 		camel_stream_reset (stream);
 		message = camel_mime_message_new ();
 		camel_data_wrapper_construct_from_stream ((CamelDataWrapper *) message, stream);
 		break;
-	case CAMEL_IMAP_RESULT_NO:
+	case CAMEL_IMAP4_RESULT_NO:
 		/* FIXME: would be good to save the NO reason into the err message */
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 				      _("Cannot get message %s from folder `%s': No such message"),
 				      uid, folder->full_name);
 		break;
-	case CAMEL_IMAP_RESULT_BAD:
+	case CAMEL_IMAP4_RESULT_BAD:
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 				      _("Cannot get message %s from folder `%s': Bad command"),
 				      uid, folder->full_name);
 		break;
 	}
 	
-	camel_imap_command_unref (ic);
+	camel_imap4_command_unref (ic);
 	
 	camel_object_unref (stream);
 	
@@ -520,13 +612,13 @@ static char *tm_months[] = {
 };
 
 static void
-imap_append_message (CamelFolder *folder, CamelMimeMessage *message,
+imap4_append_message (CamelFolder *folder, CamelMimeMessage *message,
 		     const CamelMessageInfo *info, char **appended_uid, CamelException *ex)
 {
-	CamelIMAPEngine *engine = ((CamelIMAPStore *) folder->parent_store)->engine;
-	CamelIMAPSummary *summary = (CamelIMAPSummary *) folder->summary;
-	CamelIMAPRespCode *resp;
-	CamelIMAPCommand *ic;
+	CamelIMAP4Engine *engine = ((CamelIMAP4Store *) folder->parent_store)->engine;
+	CamelIMAP4Summary *summary = (CamelIMAP4Summary *) folder->summary;
+	CamelIMAP4RespCode *resp;
+	CamelIMAP4Command *ic;
 	CamelFolderInfo *fi;
 	CamelException lex;
 	char flags[100], *p;
@@ -538,9 +630,9 @@ imap_append_message (CamelFolder *folder, CamelMimeMessage *message,
 	if (info->flags & folder->permanent_flags) {
 		p = g_stpcpy (flags, " (");
 		
-		for (i = 0; i < G_N_ELEMENTS (imap_flags); i++) {
-			if ((info->flags & imap_flags[i].flag) & folder->permanent_flags) {
-				p = g_stpcpy (p, imap_flags[i].name);
+		for (i = 0; i < G_N_ELEMENTS (imap4_flags); i++) {
+			if ((info->flags & imap4_flags[i].flag) & folder->permanent_flags) {
+				p = g_stpcpy (p, imap4_flags[i].name);
 				*p++ = ' ';
 			}
 		}
@@ -586,23 +678,23 @@ imap_append_message (CamelFolder *folder, CamelMimeMessage *message,
 	
  retry:
 	
-	if (engine->capa & CAMEL_IMAP_CAPABILITY_UIDPLUS)
-		ic = camel_imap_engine_queue (engine, NULL, "UID APPEND %F%s%s %L\r\n", flags, date, message);
+	if (engine->capa & CAMEL_IMAP4_CAPABILITY_UIDPLUS)
+		ic = camel_imap4_engine_queue (engine, NULL, "UID APPEND %F%s%s %L\r\n", flags, date, message);
 	else
-		ic = camel_imap_engine_queue (engine, NULL, "APPEND %F%s%s %L\r\n", flags, date, message);
+		ic = camel_imap4_engine_queue (engine, NULL, "APPEND %F%s%s %L\r\n", flags, date, message);
 	
-	while ((id = camel_imap_engine_iterate (engine)) < ic->id && id != -1)
+	while ((id = camel_imap4_engine_iterate (engine)) < ic->id && id != -1)
 		;
 	
-	if (id == -1 || ic->status != CAMEL_IMAP_COMMAND_COMPLETE) {
+	if (id == -1 || ic->status != CAMEL_IMAP4_COMMAND_COMPLETE) {
 		camel_exception_xfer (ex, &ic->ex);
-		camel_imap_command_unref (ic);
+		camel_imap4_command_unref (ic);
 		return;
 	}
 	
 	switch (ic->result) {
-	case CAMEL_IMAP_RESULT_OK:
-		if (!(engine->capa & CAMEL_IMAP_CAPABILITY_UIDPLUS))
+	case CAMEL_IMAP4_RESULT_OK:
+		if (!(engine->capa & CAMEL_IMAP4_CAPABILITY_UIDPLUS))
 			break;
 		
 		if (!appended_uid)
@@ -610,14 +702,14 @@ imap_append_message (CamelFolder *folder, CamelMimeMessage *message,
 		
 		for (i = 0; i < ic->resp_codes->len; i++) {
 			resp = ic->resp_codes->pdata[i];
-			if (resp->code == CAMEL_IMAP_RESP_CODE_APPENDUID) {
+			if (resp->code == CAMEL_IMAP4_RESP_CODE_APPENDUID) {
 				if (resp->v.appenduid.uidvalidity == summary->uidvalidity)
 					*appended_uid = g_strdup_printf ("%u", resp->v.appenduid.uid);
 				break;
 			}
 		}
 		break;
-	case CAMEL_IMAP_RESULT_NO:
+	case CAMEL_IMAP4_RESULT_NO:
 		/* FIXME: can we give the user any more information? */
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 				      _("Cannot append message to folder `%s': Unknown error"),
@@ -625,7 +717,7 @@ imap_append_message (CamelFolder *folder, CamelMimeMessage *message,
 		
 		for (i = 0; i < ic->resp_codes->len; i++) {
 			resp = ic->resp_codes->pdata[i];
-			if (resp->code == CAMEL_IMAP_RESP_CODE_TRYCREATE) {
+			if (resp->code == CAMEL_IMAP4_RESP_CODE_TRYCREATE) {
 				char *parent_name, *p;
 				
 				parent_name = g_alloca (strlen (folder->full_name) + 1);
@@ -640,14 +732,14 @@ imap_append_message (CamelFolder *folder, CamelMimeMessage *message,
 				}
 				
 				camel_store_free_folder_info (folder->parent_store, fi);
-				camel_imap_command_unref (ic);
+				camel_imap4_command_unref (ic);
 				camel_exception_clear (ex);
 				goto retry;
 			}
 		}
 		
 		break;
-	case CAMEL_IMAP_RESULT_BAD:
+	case CAMEL_IMAP4_RESULT_BAD:
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 				      _("Cannot append message to folder `%s': Bad command"),
 				      folder->full_name);
@@ -657,7 +749,7 @@ imap_append_message (CamelFolder *folder, CamelMimeMessage *message,
 		g_assert_not_reached ();
 	}
 	
-	camel_imap_command_unref (ic);
+	camel_imap4_command_unref (ic);
 }
 
 
@@ -676,13 +768,13 @@ info_uid_sort (const CamelMessageInfo **info0, const CamelMessageInfo **info1)
 }
 
 static void
-imap_transfer_messages_to (CamelFolder *src, GPtrArray *uids, CamelFolder *dest,
+imap4_transfer_messages_to (CamelFolder *src, GPtrArray *uids, CamelFolder *dest,
 			   GPtrArray **transferred_uids, gboolean delete_originals, CamelException *ex)
 {
-	CamelIMAPEngine *engine = ((CamelIMAPStore *) src->parent_store)->engine;
+	CamelIMAP4Engine *engine = ((CamelIMAP4Store *) src->parent_store)->engine;
 	int i, j, n, id, dest_namelen;
 	CamelMessageInfo *info;
-	CamelIMAPCommand *ic;
+	CamelIMAP4Command *ic;
 	GPtrArray *infos;
 	char *set;
 	
@@ -701,26 +793,26 @@ imap_transfer_messages_to (CamelFolder *src, GPtrArray *uids, CamelFolder *dest,
 	
 	g_ptr_array_sort (infos, (GCompareFunc) info_uid_sort);
 	
-	dest_namelen = strlen (camel_imap_folder_utf7_name ((CamelIMAPFolder *) dest));
+	dest_namelen = strlen (camel_imap4_folder_utf7_name ((CamelIMAP4Folder *) dest));
 	
 	for (i = 0; i < infos->len; i += n) {
-		n = imap_get_uid_set (engine, src->summary, infos, i, 10 + dest_namelen, &set);
+		n = imap4_get_uid_set (engine, src->summary, infos, i, 10 + dest_namelen, &set);
 		
-		ic = camel_imap_engine_queue (engine, src, "UID COPY %s %F\r\n", set, dest);
-		while ((id = camel_imap_engine_iterate (engine)) < ic->id && id != -1)
+		ic = camel_imap4_engine_queue (engine, src, "UID COPY %s %F\r\n", set, dest);
+		while ((id = camel_imap4_engine_iterate (engine)) < ic->id && id != -1)
 			;
 		
 		g_free (set);
 		
-		if (id == -1 || ic->status != CAMEL_IMAP_COMMAND_COMPLETE) {
+		if (id == -1 || ic->status != CAMEL_IMAP4_COMMAND_COMPLETE) {
 			camel_exception_xfer (ex, &ic->ex);
-			camel_imap_command_unref (ic);
+			camel_imap4_command_unref (ic);
 			g_free (set);
 			goto done;
 		}
 		
 		switch (ic->result) {
-		case CAMEL_IMAP_RESULT_NO:
+		case CAMEL_IMAP4_RESULT_NO:
 			/* FIXME: would be good to save the NO reason into the err message */
 			if (delete_originals) {
 				camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
@@ -733,7 +825,7 @@ imap_transfer_messages_to (CamelFolder *src, GPtrArray *uids, CamelFolder *dest,
 			}
 			
 			goto done;
-		case CAMEL_IMAP_RESULT_BAD:
+		case CAMEL_IMAP4_RESULT_BAD:
 			if (delete_originals) {
 				camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 						      _("Cannot move messages from folder `%s' to folder `%s': Bad command"),
@@ -747,7 +839,7 @@ imap_transfer_messages_to (CamelFolder *src, GPtrArray *uids, CamelFolder *dest,
 			goto done;
 		}
 		
-		camel_imap_command_unref (ic);
+		camel_imap4_command_unref (ic);
 		
 		if (delete_originals) {
 			for (j = i; j < n; j++) {
diff --git a/camel/providers/imap4/camel-imap4-folder.h b/camel/providers/imap4/camel-imap4-folder.h
new file mode 100644
index 0000000000..203c80074a
--- /dev/null
+++ b/camel/providers/imap4/camel-imap4-folder.h
@@ -0,0 +1,65 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*  Camel
+ *  Copyright (C) 1999-2004 Jeffrey Stedfast
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __CAMEL_IMAP4_FOLDER_H__
+#define __CAMEL_IMAP4_FOLDER_H__
+
+#include <camel/camel-store.h>
+#include <camel/camel-folder.h>
+
+#ifdef __cplusplus
+extern "C" {
+#pragma }
+#endif /* __cplusplus */
+
+#define CAMEL_TYPE_IMAP4_FOLDER            (camel_imap4_folder_get_type ())
+#define CAMEL_IMAP4_FOLDER(obj)            (CAMEL_CHECK_CAST ((obj), CAMEL_TYPE_IMAP4_FOLDER, CamelIMAP4Folder))
+#define CAMEL_IMAP4_FOLDER_CLASS(klass)    (CAMEL_CHECK_CLASS_CAST ((klass), CAMEL_TYPE_IMAP4_FOLDER, CamelIMAP4FolderClass))
+#define CAMEL_IS_IMAP4_FOLDER(obj)         (CAMEL_CHECK_TYPE ((obj), CAMEL_TYPE_IMAP4_FOLDER))
+#define CAMEL_IS_IMAP4_FOLDER_CLASS(klass) (CAMEL_CHECK_CLASS_TYPE ((klass), CAMEL_TYPE_IMAP4_FOLDER))
+#define CAMEL_IMAP4_FOLDER_GET_CLASS(obj)  (CAMEL_CHECK_GET_CLASS ((obj), CAMEL_TYPE_IMAP4_FOLDER, CamelIMAP4FolderClass))
+
+typedef struct _CamelIMAP4Folder CamelIMAP4Folder;
+typedef struct _CamelIMAP4FolderClass CamelIMAP4FolderClass;
+
+struct _CamelIMAP4Folder {
+	CamelFolder parent_object;
+	
+	char *cachedir;
+	char *utf7_name;
+};
+
+struct _CamelIMAP4FolderClass {
+	CamelFolderClass parent_class;
+	
+};
+
+
+CamelType camel_imap4_folder_get_type (void);
+
+CamelFolder *camel_imap4_folder_new (CamelStore *store, const char *full_name, CamelException *ex);
+
+const char *camel_imap4_folder_utf7_name (CamelIMAP4Folder *folder);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __CAMEL_IMAP4_FOLDER_H__ */
diff --git a/camel/providers/imap4/camel-imap-provider.c b/camel/providers/imap4/camel-imap4-provider.c
index 2cf7f6e1c7..185053f032 100644
--- a/camel/providers/imap4/camel-imap-provider.c
+++ b/camel/providers/imap4/camel-imap4-provider.c
@@ -27,7 +27,7 @@
 #include <camel/camel-sasl.h>
 #include <camel/camel-provider.h>
 
-#include "camel-imap-store.h"
+#include "camel-imap4-store.h"
 
 
 CamelProviderConfEntry imap4_conf_entries[] = {
@@ -52,7 +52,7 @@ static CamelProvider imap4_provider = {
 	"imap4",
 	N_("IMAPv4rev1"),
 	
-	N_("For reading and storing mail on IMAPv4rev1 servers."),
+	N_("For reading and storing mail on IMAPv4rev1 servers. EXPERIMENTAL !!"),
 	
 	"mail",
 	
@@ -69,7 +69,7 @@ static CamelProvider imap4_provider = {
 CamelServiceAuthType camel_imap4_password_authtype = {
 	N_("Password"),
 	
-	N_("This option will connect to the IMAP server using a "
+	N_("This option will connect to the IMAPv4rev1 server using a "
 	   "plaintext password."),
 	
 	"",
@@ -85,7 +85,7 @@ add_hash (guint *hash, char *s)
 }
 
 static guint
-imap_url_hash (gconstpointer key)
+imap4_url_hash (gconstpointer key)
 {
 	const CamelURL *u = (CamelURL *)key;
 	guint hash = 0;
@@ -115,7 +115,7 @@ check_equal (char *s1, char *s2)
 }
 
 static gint
-imap_url_equal (gconstpointer a, gconstpointer b)
+imap4_url_equal (gconstpointer a, gconstpointer b)
 {
 	const CamelURL *u1 = a, *u2 = b;
 	
@@ -129,9 +129,9 @@ imap_url_equal (gconstpointer a, gconstpointer b)
 void
 camel_provider_module_init (void)
 {
-	imap4_provider.object_types[CAMEL_PROVIDER_STORE] = camel_imap_store_get_type ();
-	imap4_provider.url_hash = imap_url_hash;
-	imap4_provider.url_equal = imap_url_equal;
+	imap4_provider.object_types[CAMEL_PROVIDER_STORE] = camel_imap4_store_get_type ();
+	imap4_provider.url_hash = imap4_url_hash;
+	imap4_provider.url_equal = imap4_url_equal;
 	imap4_provider.authtypes = camel_sasl_authtype_list (FALSE);
 	imap4_provider.authtypes = g_list_prepend (imap4_provider.authtypes, &camel_imap4_password_authtype);
 	
diff --git a/camel/providers/imap4/camel-imap-specials.c b/camel/providers/imap4/camel-imap4-specials.c
index 5289394f19..4682a403e4 100644
--- a/camel/providers/imap4/camel-imap-specials.c
+++ b/camel/providers/imap4/camel-imap4-specials.c
@@ -24,14 +24,14 @@
 
 #include <string.h>
 
-#include "camel-imap-specials.h"
+#include "camel-imap4-specials.h"
 
 #define CHARS_ATOM_SPECIALS   "(){]"
 #define CHARS_LWSP            " \t\r\n"
 #define CHARS_QUOTED_SPECIALS "\\\""
 #define CHARS_LIST_WILDCARDS  "*%"
 
-unsigned char camel_imap_specials[256] = {
+unsigned char camel_imap4_specials[256] = {
 	  2,  2,  2,  2,  2,  2,  2,  2,  2,  6,  6,  2,  2,  6,  2,  2,
           2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
          20,  0,  8,  0,  0, 32,  0,  0,  1,  1, 32,  0,  0,  0,  0,  0,
@@ -52,28 +52,28 @@ unsigned char camel_imap_specials[256] = {
 
 
 static void
-imap_init_bits (unsigned short bit, unsigned short bitcopy, int remove, unsigned char *vals)
+imap4_init_bits (unsigned short bit, unsigned short bitcopy, int remove, unsigned char *vals)
 {
 	int i, len = strlen (vals);
 	
 	if (!remove) {
 		for (i = 0; i < len; i++)
-			camel_imap_specials[vals[i]] |= bit;
+			camel_imap4_specials[vals[i]] |= bit;
 		if (bitcopy) {
 			for (i = 0; i < 256; i++) {
-				if (camel_imap_specials[i] & bitcopy)
-					camel_imap_specials[i] |= bit;
+				if (camel_imap4_specials[i] & bitcopy)
+					camel_imap4_specials[i] |= bit;
 			}
 		}
 	} else {
 		for (i = 0; i < 256; i++)
-			camel_imap_specials[i] |= bit;
+			camel_imap4_specials[i] |= bit;
 		for (i = 0; i < len; i++)
-			camel_imap_specials[vals[i]] &= ~bit;
+			camel_imap4_specials[vals[i]] &= ~bit;
 		if (bitcopy) {
 			for (i = 0; i < 256; i++) {
-				if (camel_imap_specials[i] & bitcopy)
-					camel_imap_specials[i] &= ~bit;
+				if (camel_imap4_specials[i] & bitcopy)
+					camel_imap4_specials[i] &= ~bit;
 			}
 		}
 	}
@@ -81,20 +81,20 @@ imap_init_bits (unsigned short bit, unsigned short bitcopy, int remove, unsigned
 
 
 void
-camel_imap_specials_init (void)
+camel_imap4_specials_init (void)
 {
 	int i;
 	
 	for (i = 0; i < 256; i++) {
-		camel_imap_specials[i] = 0;
+		camel_imap4_specials[i] = 0;
 		if (i <= 0x1f || i >= 0x7f)
-			camel_imap_specials[i] |= IS_CTRL;
+			camel_imap4_specials[i] |= IS_CTRL;
 	}
 	
-	camel_imap_specials[' '] |= IS_SPACE;
+	camel_imap4_specials[' '] |= IS_SPACE;
 	
-	imap_init_bits (IS_LWSP, 0, 0, CHARS_LWSP);
-	imap_init_bits (IS_ASPECIAL, 0, 0, CHARS_ATOM_SPECIALS);
-	imap_init_bits (IS_QSPECIAL, 0, 0, CHARS_QUOTED_SPECIALS);
-	imap_init_bits (IS_WILDCARD, 0, 0, CHARS_LIST_WILDCARDS);
+	imap4_init_bits (IS_LWSP, 0, 0, CHARS_LWSP);
+	imap4_init_bits (IS_ASPECIAL, 0, 0, CHARS_ATOM_SPECIALS);
+	imap4_init_bits (IS_QSPECIAL, 0, 0, CHARS_QUOTED_SPECIALS);
+	imap4_init_bits (IS_WILDCARD, 0, 0, CHARS_LIST_WILDCARDS);
 }
diff --git a/camel/providers/imap4/camel-imap-specials.h b/camel/providers/imap4/camel-imap4-specials.h
index 6bae4d3ae3..36765cdc6b 100644
--- a/camel/providers/imap4/camel-imap-specials.h
+++ b/camel/providers/imap4/camel-imap4-specials.h
@@ -18,8 +18,8 @@
  */
 
 
-#ifndef __CAMEL_IMAP_SPECIALS_H__
-#define __CAMEL_IMAP_SPECIALS_H__
+#ifndef __CAMEL_IMAP4_SPECIALS_H__
+#define __CAMEL_IMAP4_SPECIALS_H__
 
 #ifdef __cplusplus
 extern "C" {
@@ -35,19 +35,19 @@ enum {
 	IS_WILDCARD   = (1 << 5),
 };
 
-extern unsigned char camel_imap_specials[256];
+extern unsigned char camel_imap4_specials[256];
 
-#define is_atom(x) ((camel_imap_specials[(unsigned char)(x)] & (IS_ASPECIAL|IS_SPACE|IS_CTRL|IS_WILDCARD|IS_QSPECIAL)) == 0)
-#define is_ctrl(x) ((camel_imap_specials[(unsigned char)(x)] & IS_CTRL) != 0)
-#define is_lwsp(x) ((camel_imap_specials[(unsigned char)(x)] & IS_LWSP) != 0)
-#define is_type(x, t) ((camel_imap_specials[(unsigned char)(x)] & (t)) != 0)
-#define is_qsafe(x) ((camel_imap_specials[(unsigned char)(x)] & (IS_QSPECIAL|IS_CTRL)) == 0)
-#define is_wild(x)  ((camel_imap_specials[(unsigned char)(x)] & IS_WILDCARD) != 0)
+#define is_atom(x) ((camel_imap4_specials[(unsigned char)(x)] & (IS_ASPECIAL|IS_SPACE|IS_CTRL|IS_WILDCARD|IS_QSPECIAL)) == 0)
+#define is_ctrl(x) ((camel_imap4_specials[(unsigned char)(x)] & IS_CTRL) != 0)
+#define is_lwsp(x) ((camel_imap4_specials[(unsigned char)(x)] & IS_LWSP) != 0)
+#define is_type(x, t) ((camel_imap4_specials[(unsigned char)(x)] & (t)) != 0)
+#define is_qsafe(x) ((camel_imap4_specials[(unsigned char)(x)] & (IS_QSPECIAL|IS_CTRL)) == 0)
+#define is_wild(x)  ((camel_imap4_specials[(unsigned char)(x)] & IS_WILDCARD) != 0)
 
-void camel_imap_specials_init (void);
+void camel_imap4_specials_init (void);
 
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
 
-#endif /* __CAMEL_IMAP_SPECIALS_H__ */
+#endif /* __CAMEL_IMAP4_SPECIALS_H__ */
diff --git a/camel/providers/imap4/camel-imap-store.c b/camel/providers/imap4/camel-imap4-store.c
index 7373088f79..ffc8c91408 100644
--- a/camel/providers/imap4/camel-imap-store.c
+++ b/camel/providers/imap4/camel-imap4-store.c
@@ -34,62 +34,62 @@
 
 #include <camel/camel-private.h>
 
-#include "camel-imap-store.h"
-#include "camel-imap-engine.h"
-#include "camel-imap-folder.h"
-#include "camel-imap-stream.h"
-#include "camel-imap-command.h"
+#include "camel-imap4-store.h"
+#include "camel-imap4-engine.h"
+#include "camel-imap4-folder.h"
+#include "camel-imap4-stream.h"
+#include "camel-imap4-command.h"
 
 
-static void camel_imap_store_class_init (CamelIMAPStoreClass *klass);
-static void camel_imap_store_init (CamelIMAPStore *store, CamelIMAPStoreClass *klass);
-static void camel_imap_store_finalize (CamelObject *object);
+static void camel_imap4_store_class_init (CamelIMAP4StoreClass *klass);
+static void camel_imap4_store_init (CamelIMAP4Store *store, CamelIMAP4StoreClass *klass);
+static void camel_imap4_store_finalize (CamelObject *object);
 
 /* service methods */
-static void imap_construct (CamelService *service, CamelSession *session,
-			    CamelProvider *provider, CamelURL *url,
-			    CamelException *ex);
-static char *imap_get_name (CamelService *service, gboolean brief);
-static gboolean imap_connect (CamelService *service, CamelException *ex);
-static gboolean imap_disconnect (CamelService *service, gboolean clean, CamelException *ex);
-static GList *imap_query_auth_types (CamelService *service, CamelException *ex);
+static void imap4_construct (CamelService *service, CamelSession *session,
+			     CamelProvider *provider, CamelURL *url,
+			     CamelException *ex);
+static char *imap4_get_name (CamelService *service, gboolean brief);
+static gboolean imap4_connect (CamelService *service, CamelException *ex);
+static gboolean imap4_disconnect (CamelService *service, gboolean clean, CamelException *ex);
+static GList *imap4_query_auth_types (CamelService *service, CamelException *ex);
 
 /* store methods */
-static CamelFolder *imap_get_folder (CamelStore *store, const char *folder_name, guint32 flags, CamelException *ex);
-static CamelFolderInfo *imap_create_folder (CamelStore *store, const char *parent_name, const char *folder_name, CamelException *ex);
-static void imap_delete_folder (CamelStore *store, const char *folder_name, CamelException *ex);
-static void imap_rename_folder (CamelStore *store, const char *old_name, const char *new_name, CamelException *ex);
-static void imap_sync (CamelStore *store, gboolean expunge, CamelException *ex);
-static CamelFolderInfo *imap_get_folder_info (CamelStore *store, const char *top, guint32 flags, CamelException *ex);
-static void imap_subscribe_folder (CamelStore *store, const char *folder_name, CamelException *ex);
-static void imap_unsubscribe_folder (CamelStore *store, const char *folder_name, CamelException *ex);
-static void imap_noop (CamelStore *store, CamelException *ex);
+static CamelFolder *imap4_get_folder (CamelStore *store, const char *folder_name, guint32 flags, CamelException *ex);
+static CamelFolderInfo *imap4_create_folder (CamelStore *store, const char *parent_name, const char *folder_name, CamelException *ex);
+static void imap4_delete_folder (CamelStore *store, const char *folder_name, CamelException *ex);
+static void imap4_rename_folder (CamelStore *store, const char *old_name, const char *new_name, CamelException *ex);
+static void imap4_sync (CamelStore *store, gboolean expunge, CamelException *ex);
+static CamelFolderInfo *imap4_get_folder_info (CamelStore *store, const char *top, guint32 flags, CamelException *ex);
+static void imap4_subscribe_folder (CamelStore *store, const char *folder_name, CamelException *ex);
+static void imap4_unsubscribe_folder (CamelStore *store, const char *folder_name, CamelException *ex);
+static void imap4_noop (CamelStore *store, CamelException *ex);
 
 
 static CamelStoreClass *parent_class = NULL;
 
 
 CamelType
-camel_imap_store_get_type (void)
+camel_imap4_store_get_type (void)
 {
 	static CamelType type = 0;
 	
 	if (!type) {
-		type = camel_type_register (CAMEL_TYPE_IMAP_STORE,
-					    "CamelIMAPStore",
-					    sizeof (CamelIMAPStore),
-					    sizeof (CamelIMAPStoreClass),
-					    (CamelObjectClassInitFunc) camel_imap_store_class_init,
+		type = camel_type_register (CAMEL_TYPE_IMAP4_STORE,
+					    "CamelIMAP4Store",
+					    sizeof (CamelIMAP4Store),
+					    sizeof (CamelIMAP4StoreClass),
+					    (CamelObjectClassInitFunc) camel_imap4_store_class_init,
 					    NULL,
-					    (CamelObjectInitFunc) camel_imap_store_init,
-					    (CamelObjectFinalizeFunc) camel_imap_store_finalize);
+					    (CamelObjectInitFunc) camel_imap4_store_init,
+					    (CamelObjectFinalizeFunc) camel_imap4_store_finalize);
 	}
 	
 	return type;
 }
 
 static guint
-imap_hash_folder_name (gconstpointer key)
+imap4_hash_folder_name (gconstpointer key)
 {
 	if (g_ascii_strcasecmp (key, "INBOX") == 0)
 		return g_str_hash ("INBOX");
@@ -98,7 +98,7 @@ imap_hash_folder_name (gconstpointer key)
 }
 
 static gint
-imap_compare_folder_name (gconstpointer a, gconstpointer b)
+imap4_compare_folder_name (gconstpointer a, gconstpointer b)
 {
 	gconstpointer aname = a, bname = b;
 
@@ -110,43 +110,43 @@ imap_compare_folder_name (gconstpointer a, gconstpointer b)
 }
 
 static void
-camel_imap_store_class_init (CamelIMAPStoreClass *klass)
+camel_imap4_store_class_init (CamelIMAP4StoreClass *klass)
 {
 	CamelServiceClass *service_class = (CamelServiceClass *) klass;
 	CamelStoreClass *store_class = (CamelStoreClass *) klass;
 	
 	parent_class = (CamelStoreClass *) camel_type_get_global_classfuncs (CAMEL_STORE_TYPE);
 	
-	service_class->construct = imap_construct;
-	service_class->get_name = imap_get_name;
-	service_class->connect = imap_connect;
-	service_class->disconnect = imap_disconnect;
-	service_class->query_auth_types = imap_query_auth_types;
-	
-	store_class->hash_folder_name = imap_hash_folder_name;
-	store_class->compare_folder_name = imap_compare_folder_name;
-	
-	store_class->get_folder = imap_get_folder;
-	store_class->create_folder = imap_create_folder;
-	store_class->delete_folder = imap_delete_folder;
-	store_class->rename_folder = imap_rename_folder;
-	store_class->sync = imap_sync;
-	store_class->get_folder_info = imap_get_folder_info;
-	store_class->subscribe_folder = imap_subscribe_folder;
-	store_class->unsubscribe_folder = imap_unsubscribe_folder;
-	store_class->noop = imap_noop;
+	service_class->construct = imap4_construct;
+	service_class->get_name = imap4_get_name;
+	service_class->connect = imap4_connect;
+	service_class->disconnect = imap4_disconnect;
+	service_class->query_auth_types = imap4_query_auth_types;
+	
+	store_class->hash_folder_name = imap4_hash_folder_name;
+	store_class->compare_folder_name = imap4_compare_folder_name;
+	
+	store_class->get_folder = imap4_get_folder;
+	store_class->create_folder = imap4_create_folder;
+	store_class->delete_folder = imap4_delete_folder;
+	store_class->rename_folder = imap4_rename_folder;
+	store_class->sync = imap4_sync;
+	store_class->get_folder_info = imap4_get_folder_info;
+	store_class->subscribe_folder = imap4_subscribe_folder;
+	store_class->unsubscribe_folder = imap4_unsubscribe_folder;
+	store_class->noop = imap4_noop;
 }
 
 static void
-camel_imap_store_init (CamelIMAPStore *store, CamelIMAPStoreClass *klass)
+camel_imap4_store_init (CamelIMAP4Store *store, CamelIMAP4StoreClass *klass)
 {
 	store->engine = NULL;
 }
 
 static void
-camel_imap_store_finalize (CamelObject *object)
+camel_imap4_store_finalize (CamelObject *object)
 {
-	CamelIMAPStore *store = (CamelIMAPStore *) object;
+	CamelIMAP4Store *store = (CamelIMAP4Store *) object;
 	
 	if (store->engine)
 		camel_object_unref (store->engine);
@@ -154,13 +154,13 @@ camel_imap_store_finalize (CamelObject *object)
 
 
 static void
-imap_construct (CamelService *service, CamelSession *session, CamelProvider *provider, CamelURL *url, CamelException *ex)
+imap4_construct (CamelService *service, CamelSession *session, CamelProvider *provider, CamelURL *url, CamelException *ex)
 {
 	CAMEL_SERVICE_CLASS (parent_class)->construct (service, session, provider, url, ex);
 }
 
 static char *
-imap_get_name (CamelService *service, gboolean brief)
+imap4_get_name (CamelService *service, gboolean brief)
 {
 	if (brief)
 		return g_strdup_printf (_("IMAP server %s"), service->url->host);
@@ -181,8 +181,8 @@ enum {
 static gboolean
 connect_to_server (CamelService *service, struct hostent *host, int ssl_mode, int try_starttls, CamelException *ex)
 {
-	CamelIMAPStore *store = (CamelIMAPStore *) service;
-	CamelIMAPEngine *engine;
+	CamelIMAP4Store *store = (CamelIMAP4Store *) service;
+	CamelIMAP4Engine *engine;
 	CamelStream *tcp_stream;
 	int port, ret;
 	
@@ -232,14 +232,14 @@ connect_to_server (CamelService *service, struct hostent *host, int ssl_mode, in
 		return FALSE;
 	}
 	
-	engine = camel_imap_engine_new (service->session, service->url);
-	if (camel_imap_engine_take_stream (engine, tcp_stream, ex) == -1) {
+	engine = camel_imap4_engine_new (service->session, service->url);
+	if (camel_imap4_engine_take_stream (engine, tcp_stream, ex) == -1) {
 		camel_object_unref (engine);
 		
 		return FALSE;
 	}
 	
-	if (camel_imap_engine_capability (engine, ex) == -1) {
+	if (camel_imap4_engine_capability (engine, ex) == -1) {
 		camel_object_unref (engine);
 		
 		return FALSE;
@@ -250,11 +250,11 @@ connect_to_server (CamelService *service, struct hostent *host, int ssl_mode, in
 #ifdef HAVE_SSL
 	if (ssl_mode == USE_SSL_WHEN_POSSIBLE) {
 		/* try_starttls is always TRUE here */
-		if (engine->capa & CAMEL_IMAP_CAPABILITY_STARTTLS)
+		if (engine->capa & CAMEL_IMAP4_CAPABILITY_STARTTLS)
 			goto starttls;
 	} else if (ssl_mode == USE_SSL_ALWAYS) {
 		if (try_starttls) {
-			if (engine->capa & CAMEL_IMAP_CAPABILITY_STARTTLS) {
+			if (engine->capa & CAMEL_IMAP4_CAPABILITY_STARTTLS) {
 				goto starttls;
 			} else {
 				/* server doesn't support STARTTLS, abort */
@@ -274,15 +274,15 @@ connect_to_server (CamelService *service, struct hostent *host, int ssl_mode, in
  starttls:
 	
 	if (1) {
-		CamelIMAPCommand *ic;
+		CamelIMAP4Command *ic;
 		int id;
 		
-		ic = camel_imap_engine_queue (engine, NULL, "STARTTLS\r\n");
-		while ((id = camel_imap_engine_iterate (engine)) < ic->id && id != -1)
+		ic = camel_imap4_engine_queue (engine, NULL, "STARTTLS\r\n");
+		while ((id = camel_imap4_engine_iterate (engine)) < ic->id && id != -1)
 			;
 		
-		if (id == -1 || ic->result != CAMEL_IMAP_RESULT_OK) {
-			if (ic->result != CAMEL_IMAP_RESULT_OK) {
+		if (id == -1 || ic->result != CAMEL_IMAP4_RESULT_OK) {
+			if (ic->result != CAMEL_IMAP4_RESULT_OK) {
 				camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 						      _("Failed to connect to IMAP server %s in secure mode: %s"),
 						      service->url->host, _("Unknown error"));
@@ -290,12 +290,12 @@ connect_to_server (CamelService *service, struct hostent *host, int ssl_mode, in
 				camel_exception_xfer (ex, &ic->ex);
 			}
 			
-			camel_imap_command_unref (ic);
+			camel_imap4_command_unref (ic);
 			
 			goto exception;
 		}
 		
-		camel_imap_command_unref (ic);
+		camel_imap4_command_unref (ic);
 	}
 	
 	return TRUE;
@@ -363,7 +363,7 @@ connect_to_server_wrapper (CamelService *service, CamelException *ex)
 }
 
 static int
-sasl_auth (CamelIMAPEngine *engine, CamelIMAPCommand *ic, const unsigned char *linebuf, size_t linelen, CamelException *ex)
+sasl_auth (CamelIMAP4Engine *engine, CamelIMAP4Command *ic, const unsigned char *linebuf, size_t linelen, CamelException *ex)
 {
 	/* Perform a single challenge iteration */
 	CamelSasl *sasl = ic->user_data;
@@ -401,12 +401,12 @@ sasl_auth (CamelIMAPEngine *engine, CamelIMAPCommand *ic, const unsigned char *l
 }
 
 static int
-imap_try_authenticate (CamelService *service, gboolean reprompt, const char *errmsg, CamelException *ex)
+imap4_try_authenticate (CamelService *service, gboolean reprompt, const char *errmsg, CamelException *ex)
 {
-	CamelIMAPStore *store = (CamelIMAPStore *) service;
+	CamelIMAP4Store *store = (CamelIMAP4Store *) service;
 	CamelSession *session = service->session;
 	CamelSasl *sasl = NULL;
-	CamelIMAPCommand *ic;
+	CamelIMAP4Command *ic;
 	int id;
 	
 	if (!service->url->passwd) {
@@ -433,47 +433,47 @@ imap_try_authenticate (CamelService *service, gboolean reprompt, const char *err
 		CamelServiceAuthType *mech;
 		
 		mech = g_hash_table_lookup (store->engine->authtypes, service->url->authmech);
-		sasl = camel_sasl_new ("imap", mech->authproto, service);
+		sasl = camel_sasl_new ("imap4", mech->authproto, service);
 		
-		ic = camel_imap_engine_queue (store->engine, NULL, "AUTHENTICATE %s\r\n", service->url->authmech);
+		ic = camel_imap4_engine_queue (store->engine, NULL, "AUTHENTICATE %s\r\n", service->url->authmech);
 		ic->plus = sasl_auth;
 		ic->user_data = sasl;
 	} else {
-		ic = camel_imap_engine_queue (store->engine, NULL, "LOGIN %S %S\r\n",
+		ic = camel_imap4_engine_queue (store->engine, NULL, "LOGIN %S %S\r\n",
 					       service->url->user, service->url->passwd);
 	}
 	
-	while ((id = camel_imap_engine_iterate (store->engine)) < ic->id && id != -1)
+	while ((id = camel_imap4_engine_iterate (store->engine)) < ic->id && id != -1)
 		;
 	
 	if (sasl != NULL)
 		camel_object_unref (sasl);
 	
-	if (id == -1 || ic->status == CAMEL_IMAP_COMMAND_ERROR) {
+	if (id == -1 || ic->status == CAMEL_IMAP4_COMMAND_ERROR) {
 		/* unrecoverable error */
 		camel_exception_xfer (ex, &ic->ex);
-		camel_imap_command_unref (ic);
+		camel_imap4_command_unref (ic);
 		
 		return FALSE;
 	}
 	
-	if (ic->result != CAMEL_IMAP_RESULT_OK) {
-		camel_imap_command_unref (ic);
+	if (ic->result != CAMEL_IMAP4_RESULT_OK) {
+		camel_imap4_command_unref (ic);
 		
 		/* try again */
 		
 		return TRUE;
 	}
 	
-	camel_imap_command_unref (ic);
+	camel_imap4_command_unref (ic);
 	
 	return FALSE;
 }
 
 static gboolean
-imap_connect (CamelService *service, CamelException *ex)
+imap4_connect (CamelService *service, CamelException *ex)
 {
-	CamelIMAPStore *store = (CamelIMAPStore *) service;
+	CamelIMAP4Store *store = (CamelIMAP4Store *) service;
 	CamelServiceAuthType *mech;
 	gboolean reprompt = FALSE;
 	char *errmsg = NULL;
@@ -502,7 +502,7 @@ imap_connect (CamelService *service, CamelException *ex)
 	}
 	
 	camel_exception_init (&lex);
-	while (imap_try_authenticate (service, reprompt, errmsg, &lex)) {
+	while (imap4_try_authenticate (service, reprompt, errmsg, &lex)) {
 		g_free (errmsg);
 		errmsg = g_strdup (lex.desc);
 		camel_exception_clear (&lex);
@@ -520,7 +520,7 @@ imap_connect (CamelService *service, CamelException *ex)
 		return FALSE;
 	}
 	
-	if (camel_imap_engine_namespace (store->engine, ex) == -1) {
+	if (camel_imap4_engine_namespace (store->engine, ex) == -1) {
 		camel_object_unref (store->engine);
 		store->engine = NULL;
 		
@@ -535,18 +535,18 @@ imap_connect (CamelService *service, CamelException *ex)
 }
 
 static gboolean
-imap_disconnect (CamelService *service, gboolean clean, CamelException *ex)
+imap4_disconnect (CamelService *service, gboolean clean, CamelException *ex)
 {
-	CamelIMAPStore *store = (CamelIMAPStore *) service;
-	CamelIMAPCommand *ic;
+	CamelIMAP4Store *store = (CamelIMAP4Store *) service;
+	CamelIMAP4Command *ic;
 	int id;
 	
 	if (clean && !store->engine->istream->disconnected) {
-		ic = camel_imap_engine_queue (store->engine, NULL, "LOGOUT\r\n");
-		while ((id = camel_imap_engine_iterate (store->engine)) < ic->id && id != -1)
+		ic = camel_imap4_engine_queue (store->engine, NULL, "LOGOUT\r\n");
+		while ((id = camel_imap4_engine_iterate (store->engine)) < ic->id && id != -1)
 			;
 		
-		camel_imap_command_unref (ic);
+		camel_imap4_command_unref (ic);
 	}
 	
 	camel_object_unref (store->engine);
@@ -554,12 +554,12 @@ imap_disconnect (CamelService *service, gboolean clean, CamelException *ex)
 	return 0;
 }
 
-extern CamelServiceAuthType camel_imap_password_authtype;
+extern CamelServiceAuthType camel_imap4_password_authtype;
 
 static GList *
-imap_query_auth_types (CamelService *service, CamelException *ex)
+imap4_query_auth_types (CamelService *service, CamelException *ex)
 {
-	CamelIMAPStore *store = (CamelIMAPStore *) service;
+	CamelIMAP4Store *store = (CamelIMAP4Store *) service;
 	CamelServiceAuthType *authtype;
 	GList *sasl_types, *t, *next;
 	gboolean connected;
@@ -581,12 +581,12 @@ imap_query_auth_types (CamelService *service, CamelException *ex)
 		}
 	}
 	
-	return g_list_prepend (sasl_types, &camel_imap_password_authtype);
+	return g_list_prepend (sasl_types, &camel_imap4_password_authtype);
 }
 
 
 static char *
-imap_folder_utf7_name (CamelStore *store, const char *folder_name)
+imap4_folder_utf7_name (CamelStore *store, const char *folder_name)
 {
 	char *real_name, *p;
 	
@@ -606,24 +606,22 @@ imap_folder_utf7_name (CamelStore *store, const char *folder_name)
 }
 
 static CamelFolder *
-imap_get_folder (CamelStore *store, const char *folder_name, guint32 flags, CamelException *ex)
+imap4_get_folder (CamelStore *store, const char *folder_name, guint32 flags, CamelException *ex)
 {
-	CamelIMAPStore *imap_store = (CamelIMAPStore *) store;
-	
 	/* FIXME: implement me */
 	
 	return NULL;
 }
 
 static CamelFolderInfo *
-imap_create_folder (CamelStore *store, const char *parent_name, const char *folder_name, CamelException *ex)
+imap4_create_folder (CamelStore *store, const char *parent_name, const char *folder_name, CamelException *ex)
 {
 	/* FIXME: also need to deal with parent folders that can't
 	 * contain subfolders - delete them and re-create with the
 	 * proper hint */
-	CamelIMAPEngine *engine = ((CamelIMAPStore *) store)->engine;
+	CamelIMAP4Engine *engine = ((CamelIMAP4Store *) store)->engine;
 	CamelFolderInfo *fi = NULL;
-	CamelIMAPCommand *ic;
+	CamelIMAP4Command *ic;
 	char *utf7_name;
 	const char *c;
 	char *name;
@@ -647,32 +645,32 @@ imap_create_folder (CamelStore *store, const char *parent_name, const char *fold
 	else
 		name = g_strdup (folder_name);
 	
-	utf7_name = imap_folder_utf7_name (store, name);
+	utf7_name = imap4_folder_utf7_name (store, name);
 	g_free (name);
 	
-	ic = camel_imap_engine_queue (engine, NULL, "CREATE %S\r\n", utf7_name);
+	ic = camel_imap4_engine_queue (engine, NULL, "CREATE %S\r\n", utf7_name);
 	g_free (utf7_name);
 	
-	while ((id = camel_imap_engine_iterate (engine)) < ic->id && id != -1)
+	while ((id = camel_imap4_engine_iterate (engine)) < ic->id && id != -1)
 		;
 	
-	if (id == -1 || ic->status != CAMEL_IMAP_COMMAND_COMPLETE) {
+	if (id == -1 || ic->status != CAMEL_IMAP4_COMMAND_COMPLETE) {
 		camel_exception_xfer (ex, &ic->ex);
-		camel_imap_command_unref (ic);
+		camel_imap4_command_unref (ic);
 		return NULL;
 	}
 	
 	switch (ic->result) {
-	case CAMEL_IMAP_RESULT_OK:
+	case CAMEL_IMAP4_RESULT_OK:
 		/* FIXME: allocate fi */
 		break;
-	case CAMEL_IMAP_RESULT_NO:
+	case CAMEL_IMAP4_RESULT_NO:
 		/* FIXME: would be good to save the NO reason into the err message */
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 				      _("Cannot create folder `%s': Invalid mailbox name"),
 				      folder_name);
 		break;
-	case CAMEL_IMAP_RESULT_BAD:
+	case CAMEL_IMAP4_RESULT_BAD:
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 				      _("Cannot create folder `%s': Bad command"),
 				      folder_name);
@@ -681,16 +679,16 @@ imap_create_folder (CamelStore *store, const char *parent_name, const char *fold
 		g_assert_not_reached ();
 	}
 	
-	camel_imap_command_unref (ic);
+	camel_imap4_command_unref (ic);
 	
 	return fi;
 }
 
 static void
-imap_delete_folder (CamelStore *store, const char *folder_name, CamelException *ex)
+imap4_delete_folder (CamelStore *store, const char *folder_name, CamelException *ex)
 {
-	CamelIMAPEngine *engine = ((CamelIMAPStore *) store)->engine;
-	CamelIMAPCommand *ic;
+	CamelIMAP4Engine *engine = ((CamelIMAP4Store *) store)->engine;
+	CamelIMAP4Command *ic;
 	char *utf7_name;
 	int id;
 	
@@ -702,151 +700,162 @@ imap_delete_folder (CamelStore *store, const char *folder_name, CamelException *
 		return;
 	}
 	
-	utf7_name = imap_folder_utf7_name (store, folder_name);
-	ic = camel_imap_engine_queue (engine, NULL, "DELETE %S\r\n", utf7_name);
+	utf7_name = imap4_folder_utf7_name (store, folder_name);
+	ic = camel_imap4_engine_queue (engine, NULL, "DELETE %S\r\n", utf7_name);
 	g_free (utf7_name);
 	
-	while ((id = camel_imap_engine_iterate (engine)) < ic->id && id != -1)
+	while ((id = camel_imap4_engine_iterate (engine)) < ic->id && id != -1)
 		;
 	
-	if (id == -1 || ic->status != CAMEL_IMAP_COMMAND_COMPLETE) {
+	if (id == -1 || ic->status != CAMEL_IMAP4_COMMAND_COMPLETE) {
 		camel_exception_xfer (ex, &ic->ex);
-		camel_imap_command_unref (ic);
+		camel_imap4_command_unref (ic);
 		return;
 	}
 	
 	switch (ic->result) {
-	case CAMEL_IMAP_RESULT_OK:
+	case CAMEL_IMAP4_RESULT_OK:
 		/* deleted */
-		/*fi = imap_build_folder_info (store, folder_name);
+		/*fi = imap4_build_folder_info (store, folder_name);
 		camel_object_trigger_event (store, "folder_deleted", fi);
 		camel_folder_info_free (fi);*/
 		break;
-	case CAMEL_IMAP_RESULT_NO:
+	case CAMEL_IMAP4_RESULT_NO:
 		/* FIXME: would be good to save the NO reason into the err message */
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 				      _("Cannot delete folder `%s': Invalid mailbox name"),
 				      folder_name);
 		break;
-	case CAMEL_IMAP_RESULT_BAD:
+	case CAMEL_IMAP4_RESULT_BAD:
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 				      _("Cannot delete folder `%s': Bad command"),
 				      folder_name);
 		break;
 	}
 	
-	camel_imap_command_unref (ic);
+	camel_imap4_command_unref (ic);
 }
 
 static void
-imap_rename_folder (CamelStore *store, const char *old_name, const char *new_name, CamelException *ex)
+imap4_rename_folder (CamelStore *store, const char *old_name, const char *new_name, CamelException *ex)
 {
 
 }
 
 static void
-imap_sync (CamelStore *store, gboolean expunge, CamelException *ex)
+imap4_sync (CamelStore *store, gboolean expunge, CamelException *ex)
 {
 
 }
 
 static CamelFolderInfo *
-imap_get_folder_info (CamelStore *store, const char *top, guint32 flags, CamelException *ex)
+imap4_get_folder_info (CamelStore *store, const char *top, guint32 flags, CamelException *ex)
 {
 	return NULL;
 }
 
 static void
-imap_subscribe_folder (CamelStore *store, const char *folder_name, CamelException *ex)
+imap4_subscribe_folder (CamelStore *store, const char *folder_name, CamelException *ex)
 {
-	CamelIMAPEngine *engine = ((CamelIMAPStore *) store)->engine;
-	CamelIMAPCommand *ic;
+	CamelIMAP4Engine *engine = ((CamelIMAP4Store *) store)->engine;
+	CamelIMAP4Command *ic;
 	char *utf7_name;
 	int id;
 	
-	utf7_name = imap_folder_utf7_name (store, folder_name);
-	ic = camel_imap_engine_queue (engine, NULL, "SUBSCRIBE %S\r\n", utf7_name);
+	utf7_name = imap4_folder_utf7_name (store, folder_name);
+	ic = camel_imap4_engine_queue (engine, NULL, "SUBSCRIBE %S\r\n", utf7_name);
 	g_free (utf7_name);
 	
-	while ((id = camel_imap_engine_iterate (engine)) < ic->id && id != -1)
+	while ((id = camel_imap4_engine_iterate (engine)) < ic->id && id != -1)
 		;
 	
-	if (id == -1 || ic->status != CAMEL_IMAP_COMMAND_COMPLETE) {
+	if (id == -1 || ic->status != CAMEL_IMAP4_COMMAND_COMPLETE) {
 		camel_exception_xfer (ex, &ic->ex);
-		camel_imap_command_unref (ic);
+		camel_imap4_command_unref (ic);
 		return;
 	}
 	
 	switch (ic->result) {
-	case CAMEL_IMAP_RESULT_OK:
+	case CAMEL_IMAP4_RESULT_OK:
 		/* subscribed */
-		/*fi = imap_build_folder_info (store, folder_name);
+		/*fi = imap4_build_folder_info (store, folder_name);
 		  fi->flags |= CAMEL_FOLDER_NOCHILDREN;
 		  camel_object_trigger_event (store, "folder_subscribed", fi);
 		  camel_folder_info_free (fi);*/
 		break;
-	case CAMEL_IMAP_RESULT_NO:
+	case CAMEL_IMAP4_RESULT_NO:
 		/* FIXME: would be good to save the NO reason into the err message */
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 				      _("Cannot subscribe to folder `%s': Invalid mailbox name"),
 				      folder_name);
 		break;
-	case CAMEL_IMAP_RESULT_BAD:
+	case CAMEL_IMAP4_RESULT_BAD:
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 				      _("Cannot subscribe to folder `%s': Bad command"),
 				      folder_name);
 		break;
 	}
 	
-	camel_imap_command_unref (ic);
+	camel_imap4_command_unref (ic);
 }
 
 static void
-imap_unsubscribe_folder (CamelStore *store, const char *folder_name, CamelException *ex)
+imap4_unsubscribe_folder (CamelStore *store, const char *folder_name, CamelException *ex)
 {
-	CamelIMAPEngine *engine = ((CamelIMAPStore *) store)->engine;
-	CamelIMAPCommand *ic;
+	CamelIMAP4Engine *engine = ((CamelIMAP4Store *) store)->engine;
+	CamelIMAP4Command *ic;
 	char *utf7_name;
 	int id;
 	
-	utf7_name = imap_folder_utf7_name (store, folder_name);
-	ic = camel_imap_engine_queue (engine, NULL, "UNSUBSCRIBE %S\r\n", utf7_name);
+	utf7_name = imap4_folder_utf7_name (store, folder_name);
+	ic = camel_imap4_engine_queue (engine, NULL, "UNSUBSCRIBE %S\r\n", utf7_name);
 	g_free (utf7_name);
 	
-	while ((id = camel_imap_engine_iterate (engine)) < ic->id && id != -1)
+	while ((id = camel_imap4_engine_iterate (engine)) < ic->id && id != -1)
 		;
 	
-	if (id == -1 || ic->status != CAMEL_IMAP_COMMAND_COMPLETE) {
+	if (id == -1 || ic->status != CAMEL_IMAP4_COMMAND_COMPLETE) {
 		camel_exception_xfer (ex, &ic->ex);
-		camel_imap_command_unref (ic);
+		camel_imap4_command_unref (ic);
 		return;
 	}
 	
 	switch (ic->result) {
-	case CAMEL_IMAP_RESULT_OK:
+	case CAMEL_IMAP4_RESULT_OK:
 		/* unsubscribed */
-		/*fi = imap_build_folder_info (store, folder_name);
+		/*fi = imap4_build_folder_info (store, folder_name);
 		  camel_object_trigger_event (store, "folder_unsubscribed", fi);
 		  camel_folder_info_free (fi);*/
 		break;
-	case CAMEL_IMAP_RESULT_NO:
+	case CAMEL_IMAP4_RESULT_NO:
 		/* FIXME: would be good to save the NO reason into the err message */
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 				      _("Cannot unsubscribe from folder `%s': Invalid mailbox name"),
 				      folder_name);
 		break;
-	case CAMEL_IMAP_RESULT_BAD:
+	case CAMEL_IMAP4_RESULT_BAD:
 		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
 				      _("Cannot unsubscribe from folder `%s': Bad command"),
 				      folder_name);
 		break;
 	}
 	
-	camel_imap_command_unref (ic);
+	camel_imap4_command_unref (ic);
 }
 
 static void
-imap_noop (CamelStore *store, CamelException *ex)
+imap4_noop (CamelStore *store, CamelException *ex)
 {
-
+	CamelIMAP4Engine *engine = ((CamelIMAP4Store *) store)->engine;
+	CamelIMAP4Command *ic;
+	int id;
+	
+	ic = camel_imap4_engine_queue (engine, NULL, "NOOP\r\n");
+	while ((id = camel_imap4_engine_iterate (engine)) < ic->id && id != -1)
+		;
+	
+	if (id == -1 || ic->status != CAMEL_IMAP4_COMMAND_COMPLETE)
+		camel_exception_xfer (ex, &ic->ex);
+	
+	camel_imap4_command_unref (ic);
 }
diff --git a/camel/providers/imap4/camel-imap-store.h b/camel/providers/imap4/camel-imap4-store.h
index b4643451bf..d8d758ab67 100644
--- a/camel/providers/imap4/camel-imap-store.h
+++ b/camel/providers/imap4/camel-imap4-store.h
@@ -18,8 +18,8 @@
  */
 
 
-#ifndef __CAMEL_IMAP_STORE_H__
-#define __CAMEL_IMAP_STORE_H__
+#ifndef __CAMEL_IMAP4_STORE_H__
+#define __CAMEL_IMAP4_STORE_H__
 
 #include <camel/camel-store.h>
 
@@ -28,34 +28,34 @@ extern "C" {
 #pragma }
 #endif /* __cplusplus */
 
-#define CAMEL_TYPE_IMAP_STORE            (camel_imap_store_get_type ())
-#define CAMEL_IMAP_STORE(obj)            (CAMEL_CHECK_CAST ((obj), CAMEL_TYPE_IMAP_STORE, CamelIMAPStore))
-#define CAMEL_IMAP_STORE_CLASS(klass)    (CAMEL_CHECK_CLASS_CAST ((klass), CAMEL_TYPE_IMAP_STORE, CamelIMAPStoreClass))
-#define CAMEL_IS_IMAP_STORE(obj)         (CAMEL_CHECK_TYPE ((obj), CAMEL_TYPE_IMAP_STORE))
-#define CAMEL_IS_IMAP_STORE_CLASS(klass) (CAMEL_CHECK_CLASS_TYPE ((klass), CAMEL_TYPE_IMAP_STORE))
-#define CAMEL_IMAP_STORE_GET_CLASS(obj)  (CAMEL_CHECK_GET_CLASS ((obj), CAMEL_TYPE_IMAP_STORE, CamelIMAPStoreClass))
+#define CAMEL_TYPE_IMAP4_STORE            (camel_imap4_store_get_type ())
+#define CAMEL_IMAP4_STORE(obj)            (CAMEL_CHECK_CAST ((obj), CAMEL_TYPE_IMAP4_STORE, CamelIMAP4Store))
+#define CAMEL_IMAP4_STORE_CLASS(klass)    (CAMEL_CHECK_CLASS_CAST ((klass), CAMEL_TYPE_IMAP4_STORE, CamelIMAP4StoreClass))
+#define CAMEL_IS_IMAP4_STORE(obj)         (CAMEL_CHECK_TYPE ((obj), CAMEL_TYPE_IMAP4_STORE))
+#define CAMEL_IS_IMAP4_STORE_CLASS(klass) (CAMEL_CHECK_CLASS_TYPE ((klass), CAMEL_TYPE_IMAP4_STORE))
+#define CAMEL_IMAP4_STORE_GET_CLASS(obj)  (CAMEL_CHECK_GET_CLASS ((obj), CAMEL_TYPE_IMAP4_STORE, CamelIMAP4StoreClass))
 
-typedef struct _CamelIMAPStore CamelIMAPStore;
-typedef struct _CamelIMAPStoreClass CamelIMAPStoreClass;
+typedef struct _CamelIMAP4Store CamelIMAP4Store;
+typedef struct _CamelIMAP4StoreClass CamelIMAP4StoreClass;
 
-struct _CamelIMAPEngine;
+struct _CamelIMAP4Engine;
 
-struct _CamelIMAPStore {
+struct _CamelIMAP4Store {
 	CamelStore parent_object;
 	
-	struct _CamelIMAPEngine *engine;
+	struct _CamelIMAP4Engine *engine;
 };
 
-struct _CamelIMAPStoreClass {
+struct _CamelIMAP4StoreClass {
 	CamelStoreClass parent_class;
 	
 };
 
 
-CamelType camel_imap_store_get_type (void);
+CamelType camel_imap4_store_get_type (void);
 
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
 
-#endif /* __CAMEL_IMAP_STORE_H__ */
+#endif /* __CAMEL_IMAP4_STORE_H__ */
diff --git a/camel/providers/imap4/camel-imap-stream.c b/camel/providers/imap4/camel-imap4-stream.c
index be3baa7794..f2b2cbeb4b 100644
--- a/camel/providers/imap4/camel-imap-stream.c
+++ b/camel/providers/imap4/camel-imap4-stream.c
@@ -28,17 +28,17 @@
 #include <errno.h>
 #include <ctype.h>
 
-#include "camel-imap-specials.h"
+#include "camel-imap4-specials.h"
 
-#include "camel-imap-stream.h"
+#include "camel-imap4-stream.h"
 
 #define d(x) x
 
-#define IMAP_TOKEN_LEN  128
+#define IMAP4_TOKEN_LEN  128
 
-static void camel_imap_stream_class_init (CamelIMAPStreamClass *klass);
-static void camel_imap_stream_init (CamelIMAPStream *stream, CamelIMAPStreamClass *klass);
-static void camel_imap_stream_finalize (CamelObject *object);
+static void camel_imap4_stream_class_init (CamelIMAP4StreamClass *klass);
+static void camel_imap4_stream_init (CamelIMAP4Stream *stream, CamelIMAP4StreamClass *klass);
+static void camel_imap4_stream_finalize (CamelObject *object);
 
 static ssize_t stream_read (CamelStream *stream, char *buffer, size_t n);
 static ssize_t stream_write (CamelStream *stream, const char *buffer, size_t n);
@@ -51,26 +51,26 @@ static CamelStreamClass *parent_class = NULL;
 
 
 CamelType
-camel_imap_stream_get_type (void)
+camel_imap4_stream_get_type (void)
 {
 	static CamelType type = 0;
 	
 	if (!type) {
-		type = camel_type_register (CAMEL_TYPE_IMAP_STREAM,
-					    "CamelIMAPStream",
-					    sizeof (CamelIMAPStream),
-					    sizeof (CamelIMAPStreamClass),
-					    (CamelObjectClassInitFunc) camel_imap_stream_class_init,
+		type = camel_type_register (CAMEL_TYPE_IMAP4_STREAM,
+					    "CamelIMAP4Stream",
+					    sizeof (CamelIMAP4Stream),
+					    sizeof (CamelIMAP4StreamClass),
+					    (CamelObjectClassInitFunc) camel_imap4_stream_class_init,
 					    NULL,
-					    (CamelObjectInitFunc) camel_imap_stream_init,
-					    (CamelObjectFinalizeFunc) camel_imap_stream_finalize);
+					    (CamelObjectInitFunc) camel_imap4_stream_init,
+					    (CamelObjectFinalizeFunc) camel_imap4_stream_finalize);
 	}
 	
 	return type;
 }
 
 static void
-camel_imap_stream_class_init (CamelIMAPStreamClass *klass)
+camel_imap4_stream_class_init (CamelIMAP4StreamClass *klass)
 {
 	CamelStreamClass *stream_class = (CamelStreamClass *) klass;
 	
@@ -85,69 +85,69 @@ camel_imap_stream_class_init (CamelIMAPStreamClass *klass)
 }
 
 static void
-camel_imap_stream_init (CamelIMAPStream *imap, CamelIMAPStreamClass *klass)
+camel_imap4_stream_init (CamelIMAP4Stream *imap4, CamelIMAP4StreamClass *klass)
 {
-	imap->stream = NULL;
+	imap4->stream = NULL;
 	
-	imap->mode = CAMEL_IMAP_STREAM_MODE_TOKEN;
-	imap->disconnected = FALSE;
-	imap->eol = FALSE;
+	imap4->mode = CAMEL_IMAP4_STREAM_MODE_TOKEN;
+	imap4->disconnected = FALSE;
+	imap4->eol = FALSE;
 	
-	imap->literal = 0;
+	imap4->literal = 0;
 	
-	imap->inbuf = imap->realbuf + IMAP_READ_PRELEN;
-	imap->inptr = imap->inbuf;
-	imap->inend = imap->inbuf;
+	imap4->inbuf = imap4->realbuf + IMAP4_READ_PRELEN;
+	imap4->inptr = imap4->inbuf;
+	imap4->inend = imap4->inbuf;
 	
-	imap->tokenbuf = g_malloc (IMAP_TOKEN_LEN);
-	imap->tokenptr = imap->tokenbuf;
-	imap->tokenleft = IMAP_TOKEN_LEN;
+	imap4->tokenbuf = g_malloc (IMAP4_TOKEN_LEN);
+	imap4->tokenptr = imap4->tokenbuf;
+	imap4->tokenleft = IMAP4_TOKEN_LEN;
 	
-	imap->unget = NULL;
+	imap4->unget = NULL;
 }
 
 static void
-camel_imap_stream_finalize (CamelObject *object)
+camel_imap4_stream_finalize (CamelObject *object)
 {
-	CamelIMAPStream *imap = (CamelIMAPStream *) object;
+	CamelIMAP4Stream *imap4 = (CamelIMAP4Stream *) object;
 	
-	if (imap->stream)
-		camel_object_unref (imap->stream);
+	if (imap4->stream)
+		camel_object_unref (imap4->stream);
 	
-	g_free (imap->tokenbuf);
-	g_free (imap->unget);
+	g_free (imap4->tokenbuf);
+	g_free (imap4->unget);
 }
 
 
 static ssize_t
-imap_fill (CamelIMAPStream *imap)
+imap4_fill (CamelIMAP4Stream *imap4)
 {
 	unsigned char *inbuf, *inptr, *inend;
 	ssize_t nread;
 	size_t inlen;
 	
-	if (imap->disconnected) {
+	if (imap4->disconnected) {
 		errno = EINVAL;
 		return -1;
 	}
 	
-	inbuf = imap->inbuf;
-	inptr = imap->inptr;
-	inend = imap->inend;
+	inbuf = imap4->inbuf;
+	inptr = imap4->inptr;
+	inend = imap4->inend;
 	inlen = inend - inptr;
 	
 	g_assert (inptr <= inend);
 	
 	/* attempt to align 'inend' with realbuf + SCAN_HEAD */
 	if (inptr >= inbuf) {
-		inbuf -= inlen < IMAP_READ_PRELEN ? inlen : IMAP_READ_PRELEN;
+		inbuf -= inlen < IMAP4_READ_PRELEN ? inlen : IMAP4_READ_PRELEN;
 		memmove (inbuf, inptr, inlen);
 		inptr = inbuf;
 		inbuf += inlen;
-	} else if (inptr > imap->realbuf) {
+	} else if (inptr > imap4->realbuf) {
 		size_t shift;
 		
-		shift = MIN (inptr - imap->realbuf, inend - inbuf);
+		shift = MIN (inptr - imap4->realbuf, inend - inbuf);
 		memmove (inptr - shift, inptr, inlen);
 		inptr -= shift;
 		inbuf = inptr + inlen;
@@ -156,53 +156,53 @@ imap_fill (CamelIMAPStream *imap)
 		inbuf = inend;
 	}
 	
-	imap->inptr = inptr;
-	imap->inend = inbuf;
-	inend = imap->realbuf + IMAP_READ_PRELEN + IMAP_READ_BUFLEN - 1;
+	imap4->inptr = inptr;
+	imap4->inend = inbuf;
+	inend = imap4->realbuf + IMAP4_READ_PRELEN + IMAP4_READ_BUFLEN - 1;
 	
-	if ((nread = camel_stream_read (imap->stream, inbuf, inend - inbuf)) == -1)
+	if ((nread = camel_stream_read (imap4->stream, inbuf, inend - inbuf)) == -1)
 		return -1;
 	else if (nread == 0)
-		imap->disconnected = TRUE;
+		imap4->disconnected = TRUE;
 	
-	imap->inend += nread;
+	imap4->inend += nread;
 	
-	return imap->inend - imap->inptr;
+	return imap4->inend - imap4->inptr;
 }
 
 static ssize_t
 stream_read (CamelStream *stream, char *buffer, size_t n)
 {
-	CamelIMAPStream *imap = (CamelIMAPStream *) stream;
+	CamelIMAP4Stream *imap4 = (CamelIMAP4Stream *) stream;
 	ssize_t len, nread = 0;
 	
-	if (imap->mode == CAMEL_IMAP_STREAM_MODE_LITERAL) {
+	if (imap4->mode == CAMEL_IMAP4_STREAM_MODE_LITERAL) {
 		/* don't let our caller read past the end of the literal */
-		n = MIN (n, imap->literal);
+		n = MIN (n, imap4->literal);
 	}
 	
-	if (imap->inptr < imap->inend) {
-		len = MIN (n, imap->inend - imap->inptr);
-		memcpy (buffer, imap->inptr, len);
-		imap->inptr += len;
+	if (imap4->inptr < imap4->inend) {
+		len = MIN (n, imap4->inend - imap4->inptr);
+		memcpy (buffer, imap4->inptr, len);
+		imap4->inptr += len;
 		nread = len;
 	}
 	
 	if (nread < n) {
-		if ((len = camel_stream_read (imap->stream, buffer + nread, n - nread)) == 0)
-			imap->disconnected = TRUE;
+		if ((len = camel_stream_read (imap4->stream, buffer + nread, n - nread)) == 0)
+			imap4->disconnected = TRUE;
 		else if (len == -1)
 			return -1;
 		
 		nread += len;
 	}
 	
-	if (imap->mode == CAMEL_IMAP_STREAM_MODE_LITERAL) {
-		imap->literal -= nread;
+	if (imap4->mode == CAMEL_IMAP4_STREAM_MODE_LITERAL) {
+		imap4->literal -= nread;
 		
-		if (imap->literal == 0) {
-			imap->mode = CAMEL_IMAP_STREAM_MODE_TOKEN;
-			imap->eol = TRUE;
+		if (imap4->literal == 0) {
+			imap4->mode = CAMEL_IMAP4_STREAM_MODE_TOKEN;
+			imap4->eol = TRUE;
 		}
 	}
 	
@@ -212,16 +212,16 @@ stream_read (CamelStream *stream, char *buffer, size_t n)
 static ssize_t
 stream_write (CamelStream *stream, const char *buffer, size_t n)
 {
-	CamelIMAPStream *imap = (CamelIMAPStream *) stream;
+	CamelIMAP4Stream *imap4 = (CamelIMAP4Stream *) stream;
 	ssize_t nwritten;
 	
-	if (imap->disconnected) {
+	if (imap4->disconnected) {
 		errno = EINVAL;
 		return -1;
 	}
 	
-	if ((nwritten = camel_stream_write (imap->stream, buffer, n)) == 0)
-		imap->disconnected = TRUE;
+	if ((nwritten = camel_stream_write (imap4->stream, buffer, n)) == 0)
+		imap4->disconnected = TRUE;
 	
 	return nwritten;
 }
@@ -229,23 +229,23 @@ stream_write (CamelStream *stream, const char *buffer, size_t n)
 static int
 stream_flush (CamelStream *stream)
 {
-	CamelIMAPStream *imap = (CamelIMAPStream *) stream;
+	CamelIMAP4Stream *imap4 = (CamelIMAP4Stream *) stream;
 	
-	return camel_stream_flush (imap->stream);
+	return camel_stream_flush (imap4->stream);
 }
 
 static int
 stream_close (CamelStream *stream)
 {
-	CamelIMAPStream *imap = (CamelIMAPStream *) stream;
+	CamelIMAP4Stream *imap4 = (CamelIMAP4Stream *) stream;
 	
-	if (camel_stream_close (imap->stream) == -1)
+	if (camel_stream_close (imap4->stream) == -1)
 		return -1;
 	
-	camel_object_unref (imap->stream);
-	imap->stream = NULL;
+	camel_object_unref (imap4->stream);
+	imap4->stream = NULL;
 	
-	imap->disconnected = TRUE;
+	imap4->disconnected = TRUE;
 	
 	return 0;
 }
@@ -253,15 +253,15 @@ stream_close (CamelStream *stream)
 static gboolean
 stream_eos (CamelStream *stream)
 {
-	CamelIMAPStream *imap = (CamelIMAPStream *) stream;
+	CamelIMAP4Stream *imap4 = (CamelIMAP4Stream *) stream;
 	
-	if (imap->eol)
+	if (imap4->eol)
 		return TRUE;
 	
-	if (imap->disconnected && imap->inptr == imap->inend)
+	if (imap4->disconnected && imap4->inptr == imap4->inend)
 		return TRUE;
 	
-	if (camel_stream_eos (imap->stream))
+	if (camel_stream_eos (imap4->stream))
 		return TRUE;
 	
 	return FALSE;
@@ -269,65 +269,65 @@ stream_eos (CamelStream *stream)
 
 
 /**
- * camel_imap_stream_new:
+ * camel_imap4_stream_new:
  * @stream: tcp stream
  *
- * Returns a new imap stream
+ * Returns a new imap4 stream
  **/
 CamelStream *
-camel_imap_stream_new (CamelStream *stream)
+camel_imap4_stream_new (CamelStream *stream)
 {
-	CamelIMAPStream *imap;
+	CamelIMAP4Stream *imap4;
 	
 	g_return_val_if_fail (CAMEL_IS_STREAM (stream), NULL);
 	
-	imap = (CamelIMAPStream *) camel_object_new (CAMEL_TYPE_IMAP_STREAM);
+	imap4 = (CamelIMAP4Stream *) camel_object_new (CAMEL_TYPE_IMAP4_STREAM);
 	camel_object_ref (stream);
-	imap->stream = stream;
+	imap4->stream = stream;
 	
-	return (CamelStream *) imap;
+	return (CamelStream *) imap4;
 }
 
 
 
-#define token_save(imap, start, len) G_STMT_START {                         \
-	if (imap->tokenleft <= len) {                                       \
+#define token_save(imap4, start, len) G_STMT_START {                         \
+	if (imap4->tokenleft <= len) {                                       \
 		unsigned int tlen, toff;                                    \
 		                                                            \
-		tlen = toff = imap->tokenptr - imap->tokenbuf;              \
+		tlen = toff = imap4->tokenptr - imap4->tokenbuf;              \
 		tlen = tlen ? tlen : 1;                                     \
 		                                                            \
 		while (tlen < toff + len)                                   \
 			tlen <<= 1;                                         \
 		                                                            \
-		imap->tokenbuf = g_realloc (imap->tokenbuf, tlen + 1);      \
-		imap->tokenptr = imap->tokenbuf + toff;                     \
-		imap->tokenleft = tlen - toff;                              \
+		imap4->tokenbuf = g_realloc (imap4->tokenbuf, tlen + 1);      \
+		imap4->tokenptr = imap4->tokenbuf + toff;                     \
+		imap4->tokenleft = tlen - toff;                              \
 	}                                                                   \
 	                                                                    \
-	memcpy (imap->tokenptr, start, len);                                \
-	imap->tokenptr += len;                                              \
-	imap->tokenleft -= len;                                             \
+	memcpy (imap4->tokenptr, start, len);                                \
+	imap4->tokenptr += len;                                              \
+	imap4->tokenleft -= len;                                             \
 } G_STMT_END
 
-#define token_clear(imap) G_STMT_START {                                    \
-	imap->tokenleft += imap->tokenptr - imap->tokenbuf;                 \
-	imap->tokenptr = imap->tokenbuf;                                    \
-	imap->literal = 0;                                                  \
+#define token_clear(imap4) G_STMT_START {                                    \
+	imap4->tokenleft += imap4->tokenptr - imap4->tokenbuf;                 \
+	imap4->tokenptr = imap4->tokenbuf;                                    \
+	imap4->literal = 0;                                                  \
 } G_STMT_END
 
 
 /**
- * camel_imap_stream_next_token:
- * @stream: imap stream
- * @token: imap token
+ * camel_imap4_stream_next_token:
+ * @stream: imap4 stream
+ * @token: imap4 token
  *
- * Reads the next token from the imap stream and saves it in @token.
+ * Reads the next token from the imap4 stream and saves it in @token.
  *
  * Returns 0 on success or -1 on fail.
  **/
 int
-camel_imap_stream_next_token (CamelIMAPStream *stream, camel_imap_token_t *token)
+camel_imap4_stream_next_token (CamelIMAP4Stream *stream, camel_imap4_token_t *token)
 {
 	register unsigned char *inptr;
 	unsigned char *inend, *start, *p;
@@ -336,12 +336,12 @@ camel_imap_stream_next_token (CamelIMAPStream *stream, camel_imap_token_t *token
 	guint32 nz_number;
 	int ret;
 	
-	g_return_val_if_fail (CAMEL_IS_IMAP_STREAM (stream), -1);
-	g_return_val_if_fail (stream->mode != CAMEL_IMAP_STREAM_MODE_LITERAL, -1);
+	g_return_val_if_fail (CAMEL_IS_IMAP4_STREAM (stream), -1);
+	g_return_val_if_fail (stream->mode != CAMEL_IMAP4_STREAM_MODE_LITERAL, -1);
 	g_return_val_if_fail (token != NULL, -1);
 	
 	if (stream->unget) {
-		memcpy (token, stream->unget, sizeof (camel_imap_token_t));
+		memcpy (token, stream->unget, sizeof (camel_imap4_token_t));
 		g_free (stream->unget);
 		stream->unget = NULL;
 		return 0;
@@ -355,11 +355,11 @@ camel_imap_stream_next_token (CamelIMAPStream *stream, camel_imap_token_t *token
 	
 	do {
 		if (inptr == inend) {
-			if ((ret = imap_fill (stream)) < 0) {
-				token->token = CAMEL_IMAP_TOKEN_ERROR;
+			if ((ret = imap4_fill (stream)) < 0) {
+				token->token = CAMEL_IMAP4_TOKEN_ERROR;
 				return -1;
 			} else if (ret == 0) {
-				token->token = CAMEL_IMAP_TOKEN_NO_DATA;
+				token->token = CAMEL_IMAP4_TOKEN_NO_DATA;
 				return 0;
 			}
 			
@@ -411,7 +411,7 @@ camel_imap_stream_next_token (CamelIMAPStream *stream, camel_imap_token_t *token
 				/* nul-terminate the atom token */
 				token_save (stream, "", 1);
 				
-				token->token = CAMEL_IMAP_TOKEN_QSTRING;
+				token->token = CAMEL_IMAP4_TOKEN_QSTRING;
 				token->v.qstring = stream->tokenbuf;
 				
 				d(fprintf (stderr, "token: \"%s\"\n", token->v.qstring));
@@ -462,12 +462,12 @@ camel_imap_stream_next_token (CamelIMAPStream *stream, camel_imap_token_t *token
 					/* skip over '\n' */
 					inptr++;
 					
-					token->token = CAMEL_IMAP_TOKEN_LITERAL;
+					token->token = CAMEL_IMAP4_TOKEN_LITERAL;
 					token->v.literal = literal;
 					
 					d(fprintf (stderr, "token: {%u}\n", literal));
 					
-					stream->mode = CAMEL_IMAP_STREAM_MODE_LITERAL;
+					stream->mode = CAMEL_IMAP4_STREAM_MODE_LITERAL;
 					stream->literal = literal;
 					stream->eol = FALSE;
 					
@@ -489,7 +489,7 @@ camel_imap_stream_next_token (CamelIMAPStream *stream, camel_imap_token_t *token
 				}
 				
 				inptr = start;
-				token->token = CAMEL_IMAP_TOKEN_NUMBER;
+				token->token = CAMEL_IMAP4_TOKEN_NUMBER;
 				token->v.number = nz_number;
 				
 				d(fprintf (stderr, "token: %u\n", nz_number));
@@ -515,10 +515,10 @@ camel_imap_stream_next_token (CamelIMAPStream *stream, camel_imap_token_t *token
 				
 				if (!strcmp (stream->tokenbuf, "NIL")) {
 					/* special atom token */
-					token->token = CAMEL_IMAP_TOKEN_NIL;
+					token->token = CAMEL_IMAP4_TOKEN_NIL;
 					d(fprintf (stderr, "token: NIL\n"));
 				} else {
-					token->token = CAMEL_IMAP_TOKEN_ATOM;
+					token->token = CAMEL_IMAP4_TOKEN_ATOM;
 					token->v.atom = stream->tokenbuf;
 					d(fprintf (stderr, "token: %s\n", token->v.atom));
 				}
@@ -542,7 +542,7 @@ camel_imap_stream_next_token (CamelIMAPStream *stream, camel_imap_token_t *token
 					/* nul-terminate the flag token */
 					token_save (stream, "", 1);
 					
-					token->token = CAMEL_IMAP_TOKEN_FLAG;
+					token->token = CAMEL_IMAP4_TOKEN_FLAG;
 					token->v.atom = stream->tokenbuf;
 					d(fprintf (stderr, "token: %s\n", token->v.atom));
 				} else {
@@ -562,8 +562,8 @@ camel_imap_stream_next_token (CamelIMAPStream *stream, camel_imap_token_t *token
 		refill:
 			token_clear (stream);
 			
-			if (imap_fill (stream) <= 0) {
-				token->token = CAMEL_IMAP_TOKEN_ERROR;
+			if (imap4_fill (stream) <= 0) {
+				token->token = CAMEL_IMAP4_TOKEN_ERROR;
 				return -1;
 			}
 			
@@ -580,11 +580,11 @@ camel_imap_stream_next_token (CamelIMAPStream *stream, camel_imap_token_t *token
 
 
 /**
- * camel_imap_stream_unget_token:
- * @stream: imap stream
+ * camel_imap4_stream_unget_token:
+ * @stream: imap4 stream
  * @token: token to 'unget'
  *
- * Ungets an imap token (as in ungetc()).
+ * Ungets an imap4 token (as in ungetc()).
  *
  * Note: you may *ONLY* unget a single token. Trying to unget another
  * token will fail.
@@ -592,16 +592,16 @@ camel_imap_stream_next_token (CamelIMAPStream *stream, camel_imap_token_t *token
  * Returns 0 on success or -1 on fail.
  **/
 int
-camel_imap_stream_unget_token (CamelIMAPStream *stream, camel_imap_token_t *token)
+camel_imap4_stream_unget_token (CamelIMAP4Stream *stream, camel_imap4_token_t *token)
 {
-	camel_imap_token_t *unget;
+	camel_imap4_token_t *unget;
 	
 	if (stream->unget)
 		return -1;
 	
-	if (token->token != CAMEL_IMAP_TOKEN_NO_DATA) {
-		stream->unget = unget = g_new (camel_imap_token_t, 1);
-		memcpy (unget, token, sizeof (camel_imap_token_t));
+	if (token->token != CAMEL_IMAP4_TOKEN_NO_DATA) {
+		stream->unget = unget = g_new (camel_imap4_token_t, 1);
+		memcpy (unget, token, sizeof (camel_imap4_token_t));
 	}
 	
 	return 0;
@@ -609,12 +609,12 @@ camel_imap_stream_unget_token (CamelIMAPStream *stream, camel_imap_token_t *toke
 
 
 /**
- * camel_imap_stream_readline:
- * @stream: imap stream
+ * camel_imap4_stream_readline:
+ * @stream: imap4 stream
  * @line: line pointer
  * @len: line length
  *
- * Reads a single line from the imap stream and points @line at an
+ * Reads a single line from the imap4 stream and points @line at an
  * internal buffer containing the line read and sets @len to the
  * length of the line buffer.
  *
@@ -622,19 +622,19 @@ camel_imap_stream_unget_token (CamelIMAPStream *stream, camel_imap_token_t *toke
  * read is incomplete.
  **/
 int
-camel_imap_stream_line (CamelIMAPStream *stream, unsigned char **line, size_t *len)
+camel_imap4_stream_line (CamelIMAP4Stream *stream, unsigned char **line, size_t *len)
 {
 	register unsigned char *inptr;
 	unsigned char *inend;
 	
-	g_return_val_if_fail (CAMEL_IS_IMAP_STREAM (stream), -1);
-	g_return_val_if_fail (stream->mode != CAMEL_IMAP_STREAM_MODE_LITERAL, -1);
+	g_return_val_if_fail (CAMEL_IS_IMAP4_STREAM (stream), -1);
+	g_return_val_if_fail (stream->mode != CAMEL_IMAP4_STREAM_MODE_LITERAL, -1);
 	g_return_val_if_fail (line != NULL, -1);
 	g_return_val_if_fail (len != NULL, -1);
 	
 	if ((stream->inend - stream->inptr) < 3) {
 		/* keep our buffer full to the optimal size */
-		if (imap_fill (stream) == -1 && stream->inptr == stream->inend)
+		if (imap4_fill (stream) == -1 && stream->inptr == stream->inend)
 			return -1;
 	}
 	
@@ -667,13 +667,13 @@ camel_imap_stream_line (CamelIMAPStream *stream, unsigned char **line, size_t *l
 
 
 int
-camel_imap_stream_literal (CamelIMAPStream *stream, unsigned char **literal, size_t *len)
+camel_imap4_stream_literal (CamelIMAP4Stream *stream, unsigned char **literal, size_t *len)
 {
 	unsigned char *inptr, *inend;
 	size_t nread;
 	
-	g_return_val_if_fail (CAMEL_IS_IMAP_STREAM (stream), -1);
-	g_return_val_if_fail (stream->mode == CAMEL_IMAP_STREAM_MODE_LITERAL, -1);
+	g_return_val_if_fail (CAMEL_IS_IMAP4_STREAM (stream), -1);
+	g_return_val_if_fail (stream->mode == CAMEL_IMAP4_STREAM_MODE_LITERAL, -1);
 	g_return_val_if_fail (literal != NULL, -1);
 	g_return_val_if_fail (len != NULL, -1);
 	
@@ -684,7 +684,7 @@ camel_imap_stream_literal (CamelIMAPStream *stream, unsigned char **literal, siz
 	
 	if ((stream->inend - stream->inptr) < 1) {
 		/* keep our buffer full to the optimal size */
-		if (imap_fill (stream) == -1 && stream->inptr == stream->inend)
+		if (imap4_fill (stream) == -1 && stream->inptr == stream->inend)
 			return -1;
 	}
 	
@@ -699,7 +699,7 @@ camel_imap_stream_literal (CamelIMAPStream *stream, unsigned char **literal, siz
 	
 	stream->literal -= nread;
 	if (stream->literal == 0) {
-		stream->mode = CAMEL_IMAP_STREAM_MODE_TOKEN;
+		stream->mode = CAMEL_IMAP4_STREAM_MODE_TOKEN;
 		stream->eol = TRUE;
 		return 0;
 	}
diff --git a/camel/providers/imap4/camel-imap4-stream.h b/camel/providers/imap4/camel-imap4-stream.h
new file mode 100644
index 0000000000..7ef8422008
--- /dev/null
+++ b/camel/providers/imap4/camel-imap4-stream.h
@@ -0,0 +1,124 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*  Camel
+ *  Copyright (C) 1999-2004 Jeffrey Stedfast
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __CAMEL_IMAP4_STREAM_H__
+#define __CAMEL_IMAP4_STREAM_H__
+
+#include <camel/camel-stream.h>
+
+#ifdef __cplusplus
+extern "C" {
+#pragma }
+#endif /* __cplusplus */
+
+#define CAMEL_TYPE_IMAP4_STREAM     (camel_imap4_stream_get_type ())
+#define CAMEL_IMAP4_STREAM(obj)     (CAMEL_CHECK_CAST ((obj), CAMEL_TYPE_IMAP4_STREAM, CamelIMAP4Stream))
+#define CAMEL_IMAP4_STREAM_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), CAMEL_TYPE_IMAP4_STREAM, CamelIMAP4StreamClass))
+#define CAMEL_IS_IMAP4_STREAM(o)    (CAMEL_CHECK_TYPE((o), CAMEL_TYPE_IMAP4_STREAM))
+
+typedef struct _CamelIMAP4Stream CamelIMAP4Stream;
+typedef struct _CamelIMAP4StreamClass CamelIMAP4StreamClass;
+
+#define IMAP4_READ_PRELEN   128
+#define IMAP4_READ_BUFLEN   4096
+
+enum {
+	CAMEL_IMAP4_TOKEN_NO_DATA       = -8,
+	CAMEL_IMAP4_TOKEN_ERROR         = -7,
+	CAMEL_IMAP4_TOKEN_NIL           = -6,
+	CAMEL_IMAP4_TOKEN_ATOM          = -5,
+	CAMEL_IMAP4_TOKEN_FLAG          = -4,
+	CAMEL_IMAP4_TOKEN_NUMBER        = -3,
+	CAMEL_IMAP4_TOKEN_QSTRING       = -2,
+	CAMEL_IMAP4_TOKEN_LITERAL       = -1,
+	/* CAMEL_IMAP4_TOKEN_CHAR would just be the char we got */
+	CAMEL_IMAP4_TOKEN_EOLN          = '\n',
+	CAMEL_IMAP4_TOKEN_LPAREN        = '(',
+	CAMEL_IMAP4_TOKEN_RPAREN        = ')',
+	CAMEL_IMAP4_TOKEN_ASTERISK      = '*',
+	CAMEL_IMAP4_TOKEN_PLUS          = '+',
+	CAMEL_IMAP4_TOKEN_LBRACKET      = '[',
+	CAMEL_IMAP4_TOKEN_RBRACKET      = ']',
+};
+
+typedef struct _camel_imap4_token_t {
+	int token;
+	union {
+		char *atom;
+		char *flag;
+		char *qstring;
+		size_t literal;
+		guint32 number;
+	} v;
+} camel_imap4_token_t;
+
+enum {
+	CAMEL_IMAP4_STREAM_MODE_TOKEN   = 0,
+	CAMEL_IMAP4_STREAM_MODE_LITERAL = 1,
+};
+
+struct _CamelIMAP4Stream {
+	CamelStream parent_object;
+	
+	CamelStream *stream;
+	
+	guint disconnected:1;  /* disconnected state */
+	guint mode:1;          /* TOKEN vs LITERAL */
+	guint eol:1;           /* end-of-literal */
+	
+	size_t literal;
+	
+	/* i/o buffers */
+	unsigned char realbuf[IMAP4_READ_PRELEN + IMAP4_READ_BUFLEN + 1];
+	unsigned char *inbuf;
+	unsigned char *inptr;
+	unsigned char *inend;
+	
+	/* token buffers */
+	unsigned char *tokenbuf;
+	unsigned char *tokenptr;
+	unsigned int tokenleft;
+	
+	camel_imap4_token_t *unget;
+};
+
+struct _CamelIMAP4StreamClass {
+	CamelStreamClass parent_class;
+	
+	/* Virtual methods */
+};
+
+
+/* Standard Camel function */
+CamelType camel_imap4_stream_get_type (void);
+
+CamelStream *camel_imap4_stream_new (CamelStream *stream);
+
+int camel_imap4_stream_next_token (CamelIMAP4Stream *stream, camel_imap4_token_t *token);
+int camel_imap4_stream_unget_token (CamelIMAP4Stream *stream, camel_imap4_token_t *token);
+
+int camel_imap4_stream_line (CamelIMAP4Stream *stream, unsigned char **line, size_t *len);
+int camel_imap4_stream_literal (CamelIMAP4Stream *stream, unsigned char **literal, size_t *len);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __CAMEL_IMAP4_STREAM_H__ */
diff --git a/camel/providers/imap4/camel-imap-summary.c b/camel/providers/imap4/camel-imap4-summary.c
index d97c93b66c..fdc1e3cd52 100644
--- a/camel/providers/imap4/camel-imap-summary.c
+++ b/camel/providers/imap4/camel-imap4-summary.c
@@ -36,45 +36,45 @@
 
 #include <camel/camel-file-utils.h>
 
-#include "camel-imap-store.h"
-#include "camel-imap-engine.h"
-#include "camel-imap-folder.h"
-#include "camel-imap-stream.h"
-#include "camel-imap-command.h"
-#include "camel-imap-utils.h"
+#include "camel-imap4-store.h"
+#include "camel-imap4-engine.h"
+#include "camel-imap4-folder.h"
+#include "camel-imap4-stream.h"
+#include "camel-imap4-command.h"
+#include "camel-imap4-utils.h"
 
-#include "camel-imap-summary.h"
+#include "camel-imap4-summary.h"
 
-#define IMAP_SUMMARY_VERSION  1
+#define IMAP4_SUMMARY_VERSION  1
 
-static void camel_imap_summary_class_init (CamelIMAPSummaryClass *klass);
-static void camel_imap_summary_init (CamelIMAPSummary *summary, CamelIMAPSummaryClass *klass);
-static void camel_imap_summary_finalize (CamelObject *object);
+static void camel_imap4_summary_class_init (CamelIMAP4SummaryClass *klass);
+static void camel_imap4_summary_init (CamelIMAP4Summary *summary, CamelIMAP4SummaryClass *klass);
+static void camel_imap4_summary_finalize (CamelObject *object);
 
-static int imap_header_load (CamelFolderSummary *summary, FILE *fin);
-static int imap_header_save (CamelFolderSummary *summary, FILE *fout);
-static CamelMessageInfo *imap_message_info_new (CamelFolderSummary *summary, struct _camel_header_raw *header);
-static CamelMessageInfo *imap_message_info_load (CamelFolderSummary *summary, FILE *fin);
-static int imap_message_info_save (CamelFolderSummary *summary, FILE *fout, CamelMessageInfo *info);
+static int imap4_header_load (CamelFolderSummary *summary, FILE *fin);
+static int imap4_header_save (CamelFolderSummary *summary, FILE *fout);
+static CamelMessageInfo *imap4_message_info_new (CamelFolderSummary *summary, struct _camel_header_raw *header);
+static CamelMessageInfo *imap4_message_info_load (CamelFolderSummary *summary, FILE *fin);
+static int imap4_message_info_save (CamelFolderSummary *summary, FILE *fout, CamelMessageInfo *info);
 
 
 static CamelFolderSummaryClass *parent_class = NULL;
 
 
 CamelType
-camel_imap_summary_get_type (void)
+camel_imap4_summary_get_type (void)
 {
 	static CamelType type = 0;
 	
 	if (!type) {
-		type = camel_type_register (CAMEL_TYPE_IMAP_SUMMARY,
-					    "CamelIMAPSummary",
-					    sizeof (CamelIMAPSummary),
-					    sizeof (CamelIMAPSummaryClass),
-					    (CamelObjectClassInitFunc) camel_imap_summary_class_init,
+		type = camel_type_register (CAMEL_TYPE_IMAP4_SUMMARY,
+					    "CamelIMAP4Summary",
+					    sizeof (CamelIMAP4Summary),
+					    sizeof (CamelIMAP4SummaryClass),
+					    (CamelObjectClassInitFunc) camel_imap4_summary_class_init,
 					    NULL,
-					    (CamelObjectInitFunc) camel_imap_summary_init,
-					    (CamelObjectFinalizeFunc) camel_imap_summary_finalize);
+					    (CamelObjectInitFunc) camel_imap4_summary_init,
+					    (CamelObjectFinalizeFunc) camel_imap4_summary_finalize);
 	}
 	
 	return type;
@@ -82,91 +82,91 @@ camel_imap_summary_get_type (void)
 
 
 static void
-camel_imap_summary_class_init (CamelIMAPSummaryClass *klass)
+camel_imap4_summary_class_init (CamelIMAP4SummaryClass *klass)
 {
 	CamelFolderSummaryClass *summary_class = (CamelFolderSummaryClass *) klass;
 	
 	parent_class = (CamelFolderSummaryClass *) camel_type_get_global_classfuncs (camel_folder_summary_get_type ());
 	
-	summary_class->summary_header_load = imap_header_load;
-	summary_class->summary_header_save = imap_header_save;
-	summary_class->message_info_new = imap_message_info_new;
-	summary_class->message_info_load = imap_message_info_load;
-	summary_class->message_info_save = imap_message_info_save;
+	summary_class->summary_header_load = imap4_header_load;
+	summary_class->summary_header_save = imap4_header_save;
+	summary_class->message_info_new = imap4_message_info_new;
+	summary_class->message_info_load = imap4_message_info_load;
+	summary_class->message_info_save = imap4_message_info_save;
 }
 
 static void
-camel_imap_summary_init (CamelIMAPSummary *summary, CamelIMAPSummaryClass *klass)
+camel_imap4_summary_init (CamelIMAP4Summary *summary, CamelIMAP4SummaryClass *klass)
 {
 	CamelFolderSummary *folder_summary = (CamelFolderSummary *) summary;
 	
-	folder_summary->version += IMAP_SUMMARY_VERSION;
+	folder_summary->version += IMAP4_SUMMARY_VERSION;
 	folder_summary->flags = CAMEL_MESSAGE_ANSWERED | CAMEL_MESSAGE_DELETED |
 		CAMEL_MESSAGE_DRAFT | CAMEL_MESSAGE_FLAGGED | CAMEL_MESSAGE_SEEN;
 	
-	folder_summary->message_info_size = sizeof (CamelIMAPMessageInfo);
+	folder_summary->message_info_size = sizeof (CamelIMAP4MessageInfo);
 }
 
 static void
-camel_imap_summary_finalize (CamelObject *object)
+camel_imap4_summary_finalize (CamelObject *object)
 {
 	;
 }
 
 
 CamelFolderSummary *
-camel_imap_summary_new (CamelFolder *folder)
+camel_imap4_summary_new (CamelFolder *folder)
 {
 	CamelFolderSummary *summary;
 	
-	summary = (CamelFolderSummary *) camel_object_new (CAMEL_TYPE_IMAP_SUMMARY);
-	((CamelIMAPSummary *) summary)->folder = folder;
+	summary = (CamelFolderSummary *) camel_object_new (CAMEL_TYPE_IMAP4_SUMMARY);
+	((CamelIMAP4Summary *) summary)->folder = folder;
 	
 	return summary;
 }
 
 static int
-imap_header_load (CamelFolderSummary *summary, FILE *fin)
+imap4_header_load (CamelFolderSummary *summary, FILE *fin)
 {
-	CamelIMAPSummary *imap_summary = (CamelIMAPSummary *) summary;
+	CamelIMAP4Summary *imap4_summary = (CamelIMAP4Summary *) summary;
 	
 	if (CAMEL_FOLDER_SUMMARY_CLASS (parent_class)->summary_header_load (summary, fin) == -1)
 		return -1;
 	
-	if (camel_file_util_decode_uint32 (fin, &imap_summary->uidvalidity) == -1)
+	if (camel_file_util_decode_uint32 (fin, &imap4_summary->uidvalidity) == -1)
 		return -1;
 	
 	return 0;
 }
 
 static int
-imap_header_save (CamelFolderSummary *summary, FILE *fout)
+imap4_header_save (CamelFolderSummary *summary, FILE *fout)
 {
-	CamelIMAPSummary *imap_summary = (CamelIMAPSummary *) summary;
+	CamelIMAP4Summary *imap4_summary = (CamelIMAP4Summary *) summary;
 	
 	if (CAMEL_FOLDER_SUMMARY_CLASS (parent_class)->summary_header_save (summary, fout) == -1)
 		return -1;
 	
-	if (camel_file_util_encode_uint32 (fout, imap_summary->uidvalidity) == -1)
+	if (camel_file_util_encode_uint32 (fout, imap4_summary->uidvalidity) == -1)
 		return -1;
 	
 	return 0;
 }
 
 static int
-envelope_decode_address (CamelIMAPEngine *engine, GString *addrs, CamelException *ex)
+envelope_decode_address (CamelIMAP4Engine *engine, GString *addrs, CamelException *ex)
 {
-	camel_imap_token_t token;
+	camel_imap4_token_t token;
 	gboolean had_name = FALSE;
 	int part = 0;
 	
-	if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 		return -1;
 	
-	if (token.token == CAMEL_IMAP_TOKEN_NIL) {
+	if (token.token == CAMEL_IMAP4_TOKEN_NIL) {
 		return 0;
 	} else if (token.token != '(') {
-		camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 		return -1;
 	}
 	
@@ -174,14 +174,14 @@ envelope_decode_address (CamelIMAPEngine *engine, GString *addrs, CamelException
 		g_string_append (addrs, ", ");
 	
 	do {
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 			return -1;
 		
 		switch (token.token) {
-		case CAMEL_IMAP_TOKEN_NIL:
+		case CAMEL_IMAP4_TOKEN_NIL:
 			break;
-		case CAMEL_IMAP_TOKEN_ATOM:
-		case CAMEL_IMAP_TOKEN_QSTRING:
+		case CAMEL_IMAP4_TOKEN_ATOM:
+		case CAMEL_IMAP4_TOKEN_QSTRING:
 			switch (part) {
 			case 0:
 				g_string_append_printf (addrs, "\"%s\" <", token.v.qstring);
@@ -196,18 +196,18 @@ envelope_decode_address (CamelIMAPEngine *engine, GString *addrs, CamelException
 			}
 			break;
 		default:
-			camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+			camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 			return -1;
 		}
 		
 		part++;
 	} while (part < 4);
 	
-	if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 		return -1;
 	
 	if (token.token != ')') {
-		camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 		return -1;
 	}
 	
@@ -215,32 +215,32 @@ envelope_decode_address (CamelIMAPEngine *engine, GString *addrs, CamelException
 }
 
 static int
-envelope_decode_addresses (CamelIMAPEngine *engine, char **addrlist, CamelException *ex)
+envelope_decode_addresses (CamelIMAP4Engine *engine, char **addrlist, CamelException *ex)
 {
-	camel_imap_token_t token;
+	camel_imap4_token_t token;
 	GString *addrs;
 	
-	if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 		return -1;
 	
-	if (token.token == CAMEL_IMAP_TOKEN_NIL) {
+	if (token.token == CAMEL_IMAP4_TOKEN_NIL) {
 		*addrlist = NULL;
 		return 0;
 	} else if (token.token != '(') {
-		camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 		return -1;
 	}
 	
 	addrs = g_string_new ("");
 	
 	do {
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1) {
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1) {
 			g_string_free (addrs, TRUE);
 			return -1;
 		}
 		
 		if (token.token == '(') {
-			camel_imap_stream_unget_token (engine->istream, &token);
+			camel_imap4_stream_unget_token (engine->istream, &token);
 			
 			if (envelope_decode_address (engine, addrs, ex) == -1) {
 				g_string_free (addrs, TRUE);
@@ -249,7 +249,7 @@ envelope_decode_addresses (CamelIMAPEngine *engine, char **addrlist, CamelExcept
 		} else if (token.token == ')') {
 			break;
 		} else {
-			camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+			camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 			return -1;
 		}
 	} while (1);
@@ -261,26 +261,26 @@ envelope_decode_addresses (CamelIMAPEngine *engine, char **addrlist, CamelExcept
 }
 
 static int
-envelope_decode_date (CamelIMAPEngine *engine, time_t *date, CamelException *ex)
+envelope_decode_date (CamelIMAP4Engine *engine, time_t *date, CamelException *ex)
 {
-	camel_imap_token_t token;
+	camel_imap4_token_t token;
 	const char *nstring;
 	
-	if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 		return -1;
 	
 	switch (token.token) {
-	case CAMEL_IMAP_TOKEN_NIL:
+	case CAMEL_IMAP4_TOKEN_NIL:
 		*date = (time_t) -1;
 		return 0;
-	case CAMEL_IMAP_TOKEN_ATOM:
+	case CAMEL_IMAP4_TOKEN_ATOM:
 		nstring = token.v.atom;
 		break;
-	case CAMEL_IMAP_TOKEN_QSTRING:
+	case CAMEL_IMAP4_TOKEN_QSTRING:
 		nstring = token.v.qstring;
 		break;
 	default:
-		camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 		return -1;
 	}
 	
@@ -290,25 +290,25 @@ envelope_decode_date (CamelIMAPEngine *engine, time_t *date, CamelException *ex)
 }
 
 static int
-envelope_decode_nstring (CamelIMAPEngine *engine, char **nstring, CamelException *ex)
+envelope_decode_nstring (CamelIMAP4Engine *engine, char **nstring, CamelException *ex)
 {
-	camel_imap_token_t token;
+	camel_imap4_token_t token;
 	
-	if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 		return -1;
 	
 	switch (token.token) {
-	case CAMEL_IMAP_TOKEN_NIL:
+	case CAMEL_IMAP4_TOKEN_NIL:
 		*nstring = NULL;
 		break;
-	case CAMEL_IMAP_TOKEN_ATOM:
+	case CAMEL_IMAP4_TOKEN_ATOM:
 		*nstring = g_strdup (token.v.atom);
 		break;
-	case CAMEL_IMAP_TOKEN_QSTRING:
+	case CAMEL_IMAP4_TOKEN_QSTRING:
 		*nstring = g_strdup (token.v.qstring);
 		break;
 	default:
-		camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 		return -1;
 	}
 	
@@ -348,16 +348,16 @@ decode_references (const char *string)
 }
 
 static int
-decode_envelope (CamelIMAPEngine *engine, CamelMessageInfo *info, camel_imap_token_t *token, CamelException *ex)
+decode_envelope (CamelIMAP4Engine *engine, CamelMessageInfo *info, camel_imap4_token_t *token, CamelException *ex)
 {
 	unsigned char md5sum[16];
 	char *nstring;
 	
-	if (camel_imap_engine_next_token (engine, token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 		return -1;
 	
 	if (token->token != '(') {
-		camel_imap_utils_set_unexpected_token_error (ex, engine, token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, token);
 		return -1;
 	}
 	
@@ -418,11 +418,11 @@ decode_envelope (CamelIMAPEngine *engine, CamelMessageInfo *info, camel_imap_tok
 		g_free (nstring);
 	}
 	
-	if (camel_imap_engine_next_token (engine, token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 		return -1;
 	
 	if (token->token != ')') {
-		camel_imap_utils_set_unexpected_token_error (ex, engine, token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, token);
 		goto exception;
 	}
 	
@@ -553,30 +553,30 @@ decode_internaldate (const char *in)
 }
 
 enum {
-	IMAP_FETCH_ENVELOPE     = (1 << 1),
-	IMAP_FETCH_FLAGS        = (1 << 2),
-	IMAP_FETCH_INTERNALDATE = (1 << 3),
-	IMAP_FETCH_RFC822SIZE   = (1 << 4),
-	IMAP_FETCH_UID          = (1 << 5),
+	IMAP4_FETCH_ENVELOPE     = (1 << 1),
+	IMAP4_FETCH_FLAGS        = (1 << 2),
+	IMAP4_FETCH_INTERNALDATE = (1 << 3),
+	IMAP4_FETCH_RFC822SIZE   = (1 << 4),
+	IMAP4_FETCH_UID          = (1 << 5),
 };
 
-#define IMAP_FETCH_ALL (IMAP_FETCH_ENVELOPE | IMAP_FETCH_FLAGS | IMAP_FETCH_INTERNALDATE | IMAP_FETCH_RFC822SIZE | IMAP_FETCH_UID)
+#define IMAP4_FETCH_ALL (IMAP4_FETCH_ENVELOPE | IMAP4_FETCH_FLAGS | IMAP4_FETCH_INTERNALDATE | IMAP4_FETCH_RFC822SIZE | IMAP4_FETCH_UID)
 
-struct imap_envelope_t {
+struct imap4_envelope_t {
 	CamelMessageInfo *info;
 	guint changed;
 };
 
-struct imap_fetch_all_t {
+struct imap4_fetch_all_t {
 	CamelFolderSummary *summary;
 	GHashTable *uid_hash;
 	GPtrArray *added;
 };
 
 static void
-imap_fetch_all_free (struct imap_fetch_all_t *fetch)
+imap4_fetch_all_free (struct imap4_fetch_all_t *fetch)
 {
-	struct imap_envelope_t *envelope;
+	struct imap4_envelope_t *envelope;
 	int i;
 	
 	for (i = 0; i < fetch->added->len; i++) {
@@ -594,9 +594,9 @@ imap_fetch_all_free (struct imap_fetch_all_t *fetch)
 }
 
 static void
-imap_fetch_all_add (struct imap_fetch_all_t *fetch)
+imap4_fetch_all_add (struct imap4_fetch_all_t *fetch)
 {
-	struct imap_envelope_t *envelope;
+	struct imap4_envelope_t *envelope;
 	CamelMessageInfo *info;
 	int i;
 	
@@ -604,8 +604,8 @@ imap_fetch_all_add (struct imap_fetch_all_t *fetch)
 		if (!(envelope = fetch->added->pdata[i]))
 			continue;
 		
-		if (envelope->changed != IMAP_FETCH_ALL) {
-			fprintf (stderr, "Hmmm, IMAP server didn't give us everything for message %d\n", i + 1);
+		if (envelope->changed != IMAP4_FETCH_ALL) {
+			fprintf (stderr, "Hmmm, IMAP4 server didn't give us everything for message %d\n", i + 1);
 			camel_folder_summary_info_free (fetch->summary, envelope->info);
 			g_free (envelope);
 			continue;
@@ -628,10 +628,10 @@ imap_fetch_all_add (struct imap_fetch_all_t *fetch)
 }
 
 static guint32
-imap_fetch_all_update (struct imap_fetch_all_t *fetch)
+imap4_fetch_all_update (struct imap4_fetch_all_t *fetch)
 {
-	CamelIMAPMessageInfo *iinfo, *new_iinfo;
-	struct imap_envelope_t *envelope;
+	CamelIMAP4MessageInfo *iinfo, *new_iinfo;
+	struct imap4_envelope_t *envelope;
 	CamelMessageInfo *info;
 	guint32 first = 0;
 	int scount, i;
@@ -644,12 +644,12 @@ imap_fetch_all_update (struct imap_fetch_all_t *fetch)
 			camel_folder_summary_remove (fetch->summary, info);
 			scount--;
 			i--;
-		} else if (envelope->changed & IMAP_FETCH_FLAGS) {
+		} else if (envelope->changed & IMAP4_FETCH_FLAGS) {
 			/* update it with the new flags */
-			new_iinfo = (CamelIMAPMessageInfo *) envelope->info;
-			iinfo = (CamelIMAPMessageInfo *) info;
+			new_iinfo = (CamelIMAP4MessageInfo *) envelope->info;
+			iinfo = (CamelIMAP4MessageInfo *) info;
 			
-			info->flags = camel_imap_merge_flags (iinfo->server_flags, info->flags, new_iinfo->server_flags);
+			info->flags = camel_imap4_merge_flags (iinfo->server_flags, info->flags, new_iinfo->server_flags);
 			iinfo->server_flags = new_iinfo->server_flags;
 		}
 		
@@ -682,13 +682,13 @@ imap_fetch_all_update (struct imap_fetch_all_t *fetch)
 }
 
 static int
-untagged_fetch_all (CamelIMAPEngine *engine, CamelIMAPCommand *ic, guint32 index, camel_imap_token_t *token, CamelException *ex)
+untagged_fetch_all (CamelIMAP4Engine *engine, CamelIMAP4Command *ic, guint32 index, camel_imap4_token_t *token, CamelException *ex)
 {
-	struct imap_fetch_all_t *fetch = ic->user_data;
+	struct imap4_fetch_all_t *fetch = ic->user_data;
 	CamelFolderSummary *summary = fetch->summary;
-	struct imap_envelope_t *envelope;
+	struct imap4_envelope_t *envelope;
 	GPtrArray *added = fetch->added;
-	CamelIMAPMessageInfo *iinfo;
+	CamelIMAP4MessageInfo *iinfo;
 	CamelMessageInfo *info;
 	char uid[12];
 	
@@ -696,81 +696,81 @@ untagged_fetch_all (CamelIMAPEngine *engine, CamelIMAPCommand *ic, guint32 index
 		g_ptr_array_set_size (added, index);
 	
 	if (!(envelope = added->pdata[index - 1])) {
-		iinfo = (CamelIMAPMessageInfo *) info = camel_folder_summary_info_new (summary);
-		envelope = g_new (struct imap_envelope_t, 1);
+		iinfo = (CamelIMAP4MessageInfo *) info = camel_folder_summary_info_new (summary);
+		envelope = g_new (struct imap4_envelope_t, 1);
 		added->pdata[index - 1] = envelope;
 		envelope->info = info;
 		envelope->changed = 0;
 	} else {
-		iinfo = (CamelIMAPMessageInfo *) info = envelope->info;
+		iinfo = (CamelIMAP4MessageInfo *) info = envelope->info;
 	}
 	
-	if (camel_imap_engine_next_token (engine, token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 		return -1;
 	
 	/* parse the FETCH response list */
 	if (token->token != '(') {
-		camel_imap_utils_set_unexpected_token_error (ex, engine, token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, token);
 		return -1;
 	}
 	
 	do {
-		if (camel_imap_engine_next_token (engine, token, ex) == -1)
+		if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 			goto exception;
 		
 		if (token->token == ')' || token->token == '\n')
 			break;
 		
-		if (token->token != CAMEL_IMAP_TOKEN_ATOM)
+		if (token->token != CAMEL_IMAP4_TOKEN_ATOM)
 			goto unexpected;
 		
 		if (!strcmp (token->v.atom, "ENVELOPE")) {
 			if (decode_envelope (engine, info, token, ex) == -1)
 				goto exception;
 			
-			envelope->changed |= IMAP_FETCH_ENVELOPE;
+			envelope->changed |= IMAP4_FETCH_ENVELOPE;
 		} else if (!strcmp (token->v.atom, "FLAGS")) {
 			guint32 server_flags = 0;
 			
-			if (camel_imap_parse_flags_list (engine, &server_flags, ex) == -1)
+			if (camel_imap4_parse_flags_list (engine, &server_flags, ex) == -1)
 				return -1;
 			
-			info->flags = camel_imap_merge_flags (iinfo->server_flags, info->flags, server_flags);
+			info->flags = camel_imap4_merge_flags (iinfo->server_flags, info->flags, server_flags);
 			iinfo->server_flags = server_flags;
 			
-			envelope->changed |= IMAP_FETCH_FLAGS;
+			envelope->changed |= IMAP4_FETCH_FLAGS;
 		} else if (!strcmp (token->v.atom, "INTERNALDATE")) {
-			if (camel_imap_engine_next_token (engine, token, ex) == -1)
+			if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 				goto exception;
 			
 			switch (token->token) {
-			case CAMEL_IMAP_TOKEN_NIL:
+			case CAMEL_IMAP4_TOKEN_NIL:
 				info->date_received = (time_t) -1;
 				break;
-			case CAMEL_IMAP_TOKEN_ATOM:
-			case CAMEL_IMAP_TOKEN_QSTRING:
+			case CAMEL_IMAP4_TOKEN_ATOM:
+			case CAMEL_IMAP4_TOKEN_QSTRING:
 				info->date_received = decode_internaldate (token->v.qstring);
 				break;
 			default:
 				goto unexpected;
 			}
 			
-			envelope->changed |= IMAP_FETCH_INTERNALDATE;
+			envelope->changed |= IMAP4_FETCH_INTERNALDATE;
 		} else if (!strcmp (token->v.atom, "RFC822.SIZE")) {
-			if (camel_imap_engine_next_token (engine, token, ex) == -1)
+			if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 				goto exception;
 			
-			if (token->token != CAMEL_IMAP_TOKEN_NUMBER)
+			if (token->token != CAMEL_IMAP4_TOKEN_NUMBER)
 				goto unexpected;
 			
 			info->size = token->v.number;
 			
-			envelope->changed |= IMAP_FETCH_RFC822SIZE;
+			envelope->changed |= IMAP4_FETCH_RFC822SIZE;
 		} else if (!strcmp (token->v.atom, "UID")) {
-			if (camel_imap_engine_next_token (engine, token, ex) == -1)
+			if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 				goto exception;
 			
-			if (token->token != CAMEL_IMAP_TOKEN_NUMBER || token->v.number == 0)
+			if (token->token != CAMEL_IMAP4_TOKEN_NUMBER || token->v.number == 0)
 				goto unexpected;
 			
 			sprintf (uid, "%u", token->v.number);
@@ -786,7 +786,7 @@ untagged_fetch_all (CamelIMAPEngine *engine, CamelIMAPCommand *ic, guint32 index
 			camel_message_info_set_uid (info, g_strdup (uid));
 			g_hash_table_insert (fetch->uid_hash, (void *) camel_message_info_uid (info), envelope);
 			
-			envelope->changed |= IMAP_FETCH_UID;
+			envelope->changed |= IMAP4_FETCH_UID;
 		} else {
 			/* wtf? */
 			fprintf (stderr, "huh? %s?...\n", token->v.atom);
@@ -800,25 +800,25 @@ untagged_fetch_all (CamelIMAPEngine *engine, CamelIMAPCommand *ic, guint32 index
 	
  unexpected:
 	
-	camel_imap_utils_set_unexpected_token_error (ex, engine, token);
+	camel_imap4_utils_set_unexpected_token_error (ex, engine, token);
 	
  exception:
 	
 	return -1;
 }
 
-static CamelIMAPCommand *
-imap_summary_fetch_all (CamelFolderSummary *summary, guint32 first, guint32 last)
+static CamelIMAP4Command *
+imap4_summary_fetch_all (CamelFolderSummary *summary, guint32 first, guint32 last)
 {
-	CamelIMAPSummary *imap_summary = (CamelIMAPSummary *) summary;
-	CamelFolder *folder = imap_summary->folder;
-	struct imap_fetch_all_t *fetch;
-	CamelIMAPEngine *engine;
-	CamelIMAPCommand *ic;
+	CamelIMAP4Summary *imap4_summary = (CamelIMAP4Summary *) summary;
+	CamelFolder *folder = imap4_summary->folder;
+	struct imap4_fetch_all_t *fetch;
+	CamelIMAP4Engine *engine;
+	CamelIMAP4Command *ic;
 	
-	engine = ((CamelIMAPStore *) folder->parent_store)->engine;
+	engine = ((CamelIMAP4Store *) folder->parent_store)->engine;
 	
-	fetch = g_new (struct imap_fetch_all_t, 1);
+	fetch = g_new (struct imap4_fetch_all_t, 1);
 	fetch->uid_hash = g_hash_table_new (g_str_hash, g_str_equal);
 	fetch->added = g_ptr_array_new ();
 	fetch->summary = summary;
@@ -832,38 +832,38 @@ imap_summary_fetch_all (CamelFolderSummary *summary, guint32 first, guint32 last
 	 **/
 	
 	if (last != 0)
-		ic = camel_imap_engine_queue (engine, folder, "FETCH %u:%u (UID ALL)\r\n", first, last);
+		ic = camel_imap4_engine_queue (engine, folder, "FETCH %u:%u (UID ALL)\r\n", first, last);
 	else
-		ic = camel_imap_engine_queue (engine, folder, "FETCH %u:* (UID ALL)\r\n", first);
+		ic = camel_imap4_engine_queue (engine, folder, "FETCH %u:* (UID ALL)\r\n", first);
 	
-	camel_imap_command_register_untagged (ic, "FETCH", untagged_fetch_all);
+	camel_imap4_command_register_untagged (ic, "FETCH", untagged_fetch_all);
 	ic->user_data = fetch;
 	
 	return ic;
 }
 
-static CamelIMAPCommand *
-imap_summary_fetch_flags (CamelFolderSummary *summary, guint32 first, guint32 last)
+static CamelIMAP4Command *
+imap4_summary_fetch_flags (CamelFolderSummary *summary, guint32 first, guint32 last)
 {
-	CamelIMAPSummary *imap_summary = (CamelIMAPSummary *) summary;
-	CamelFolder *folder = imap_summary->folder;
-	struct imap_fetch_all_t *fetch;
-	CamelIMAPEngine *engine;
-	CamelIMAPCommand *ic;
+	CamelIMAP4Summary *imap4_summary = (CamelIMAP4Summary *) summary;
+	CamelFolder *folder = imap4_summary->folder;
+	struct imap4_fetch_all_t *fetch;
+	CamelIMAP4Engine *engine;
+	CamelIMAP4Command *ic;
 	
-	engine = ((CamelIMAPStore *) folder->parent_store)->engine;
+	engine = ((CamelIMAP4Store *) folder->parent_store)->engine;
 	
-	fetch = g_new (struct imap_fetch_all_t, 1);
+	fetch = g_new (struct imap4_fetch_all_t, 1);
 	fetch->uid_hash = g_hash_table_new (g_str_hash, g_str_equal);
 	fetch->added = g_ptr_array_new ();
 	fetch->summary = summary;
 	
 	if (last != 0)
-		ic = camel_imap_engine_queue (engine, folder, "FETCH %u:%u (UID FLAGS)\r\n", first, last);
+		ic = camel_imap4_engine_queue (engine, folder, "FETCH %u:%u (UID FLAGS)\r\n", first, last);
 	else
-		ic = camel_imap_engine_queue (engine, folder, "FETCH %u:* (UID FLAGS)\r\n", first);
+		ic = camel_imap4_engine_queue (engine, folder, "FETCH %u:* (UID FLAGS)\r\n", first);
 	
-	camel_imap_command_register_untagged (ic, "FETCH", untagged_fetch_all);
+	camel_imap4_command_register_untagged (ic, "FETCH", untagged_fetch_all);
 	ic->user_data = fetch;
 	
 	return ic;
@@ -871,59 +871,59 @@ imap_summary_fetch_flags (CamelFolderSummary *summary, guint32 first, guint32 la
 
 #if 0
 static int
-imap_build_summary (CamelFolderSummary *summary, guint32 first, guint32 last)
+imap4_build_summary (CamelFolderSummary *summary, guint32 first, guint32 last)
 {
-	CamelIMAPSummary *imap_summary = (CamelIMAPSummary *) summary;
-	CamelFolder *folder = imap_summary->folder;
-	struct imap_fetch_all_t *fetch;
-	CamelIMAPEngine *engine;
-	CamelIMAPCommand *ic;
+	CamelIMAP4Summary *imap4_summary = (CamelIMAP4Summary *) summary;
+	CamelFolder *folder = imap4_summary->folder;
+	struct imap4_fetch_all_t *fetch;
+	CamelIMAP4Engine *engine;
+	CamelIMAP4Command *ic;
 	int id;
 	
-	engine = ((CamelIMAPStore *) folder->store)->engine;
+	engine = ((CamelIMAP4Store *) folder->store)->engine;
 	
-	ic = imap_summary_fetch_all (summary, first, last);
-	while ((id = camel_imap_engine_iterate (engine)) < ic->id && id != -1)
+	ic = imap4_summary_fetch_all (summary, first, last);
+	while ((id = camel_imap4_engine_iterate (engine)) < ic->id && id != -1)
 		;
 	
 	fetch = ic->user_data;
 	
-	if (id == -1 || ic->status != CAMEL_IMAP_COMMAND_COMPLETE) {
-		camel_imap_command_unref (ic);
-		imap_fetch_all_free (fetch);
+	if (id == -1 || ic->status != CAMEL_IMAP4_COMMAND_COMPLETE) {
+		camel_imap4_command_unref (ic);
+		imap4_fetch_all_free (fetch);
 		return -1;
 	}
 	
-	imap_fetch_all_add (fetch);
+	imap4_fetch_all_add (fetch);
 	
-	camel_imap_command_unref (ic);
+	camel_imap4_command_unref (ic);
 	
 	return 0;
 }
 #endif
 
 static CamelMessageInfo *
-imap_message_info_new (CamelFolderSummary *summary, struct _camel_header_raw *header)
+imap4_message_info_new (CamelFolderSummary *summary, struct _camel_header_raw *header)
 {
 	CamelMessageInfo *info;
 	
 	info = CAMEL_FOLDER_SUMMARY_CLASS (parent_class)->message_info_new (summary, header);
 	
-	((CamelIMAPMessageInfo *) info)->server_flags = 0;
+	((CamelIMAP4MessageInfo *) info)->server_flags = 0;
 	
 	return info;
 }
 
 static CamelMessageInfo *
-imap_message_info_load (CamelFolderSummary *summary, FILE *fin)
+imap4_message_info_load (CamelFolderSummary *summary, FILE *fin)
 {
-	CamelIMAPMessageInfo *minfo;
+	CamelIMAP4MessageInfo *minfo;
 	CamelMessageInfo *info;
 	
 	if (!(info = CAMEL_FOLDER_SUMMARY_CLASS (parent_class)->message_info_load (summary, fin)))
 		return NULL;
 	
-	minfo = (CamelIMAPMessageInfo *) info;
+	minfo = (CamelIMAP4MessageInfo *) info;
 	
 	if (camel_file_util_decode_uint32 (fin, &minfo->server_flags) == -1)
 		goto exception;
@@ -938,9 +938,9 @@ imap_message_info_load (CamelFolderSummary *summary, FILE *fin)
 }
 
 static int
-imap_message_info_save (CamelFolderSummary *summary, FILE *fout, CamelMessageInfo *info)
+imap4_message_info_save (CamelFolderSummary *summary, FILE *fout, CamelMessageInfo *info)
 {
-	CamelIMAPMessageInfo *minfo = (CamelIMAPMessageInfo *) info;
+	CamelIMAP4MessageInfo *minfo = (CamelIMAP4MessageInfo *) info;
 	
 	if (CAMEL_FOLDER_SUMMARY_CLASS (parent_class)->message_info_save (summary, fout, info) == -1)
 		return -1;
@@ -953,69 +953,69 @@ imap_message_info_save (CamelFolderSummary *summary, FILE *fout, CamelMessageInf
 
 
 void
-camel_imap_summary_set_exists (CamelFolderSummary *summary, guint32 exists)
+camel_imap4_summary_set_exists (CamelFolderSummary *summary, guint32 exists)
 {
-	CamelIMAPSummary *imap_summary = (CamelIMAPSummary *) summary;
+	CamelIMAP4Summary *imap4_summary = (CamelIMAP4Summary *) summary;
 	
-	g_return_if_fail (CAMEL_IS_IMAP_SUMMARY (summary));
+	g_return_if_fail (CAMEL_IS_IMAP4_SUMMARY (summary));
 	
-	imap_summary->exists = exists;
+	imap4_summary->exists = exists;
 	
-	imap_summary->exists_changed = TRUE;
+	imap4_summary->exists_changed = TRUE;
 }
 
 void
-camel_imap_summary_set_recent (CamelFolderSummary *summary, guint32 recent)
+camel_imap4_summary_set_recent (CamelFolderSummary *summary, guint32 recent)
 {
-	CamelIMAPSummary *imap_summary = (CamelIMAPSummary *) summary;
+	CamelIMAP4Summary *imap4_summary = (CamelIMAP4Summary *) summary;
 	
-	g_return_if_fail (CAMEL_IS_IMAP_SUMMARY (summary));
+	g_return_if_fail (CAMEL_IS_IMAP4_SUMMARY (summary));
 	
-	imap_summary->recent = recent;
+	imap4_summary->recent = recent;
 }
 
 void
-camel_imap_summary_set_unseen (CamelFolderSummary *summary, guint32 unseen)
+camel_imap4_summary_set_unseen (CamelFolderSummary *summary, guint32 unseen)
 {
-	CamelIMAPSummary *imap_summary = (CamelIMAPSummary *) summary;
+	CamelIMAP4Summary *imap4_summary = (CamelIMAP4Summary *) summary;
 	
-	g_return_if_fail (CAMEL_IS_IMAP_SUMMARY (summary));
+	g_return_if_fail (CAMEL_IS_IMAP4_SUMMARY (summary));
 	
-	imap_summary->unseen = unseen;
+	imap4_summary->unseen = unseen;
 }
 
 void
-camel_imap_summary_set_uidnext (CamelFolderSummary *summary, guint32 uidnext)
+camel_imap4_summary_set_uidnext (CamelFolderSummary *summary, guint32 uidnext)
 {
-	g_return_if_fail (CAMEL_IS_IMAP_SUMMARY (summary));
+	g_return_if_fail (CAMEL_IS_IMAP4_SUMMARY (summary));
 	
 	summary->nextuid = uidnext;
 }
 
 void
-camel_imap_summary_set_uidvalidity (CamelFolderSummary *summary, guint32 uidvalidity)
+camel_imap4_summary_set_uidvalidity (CamelFolderSummary *summary, guint32 uidvalidity)
 {
-	CamelIMAPSummary *imap_summary = (CamelIMAPSummary *) summary;
+	CamelIMAP4Summary *imap4_summary = (CamelIMAP4Summary *) summary;
 	
-	g_return_if_fail (CAMEL_IS_IMAP_SUMMARY (summary));
+	g_return_if_fail (CAMEL_IS_IMAP4_SUMMARY (summary));
 	
-	if (imap_summary->uidvalidity == uidvalidity)
+	if (imap4_summary->uidvalidity == uidvalidity)
 		return;
 	
 	/* FIXME: emit a signal or something first? */
 	camel_folder_summary_clear (summary);
 	
-	imap_summary->uidvalidity = uidvalidity;
+	imap4_summary->uidvalidity = uidvalidity;
 	
-	imap_summary->uidvalidity_changed = TRUE;
+	imap4_summary->uidvalidity_changed = TRUE;
 }
 
 void
-camel_imap_summary_expunge (CamelFolderSummary *summary, int seqid)
+camel_imap4_summary_expunge (CamelFolderSummary *summary, int seqid)
 {
 	CamelMessageInfo *info;
 	
-	g_return_if_fail (CAMEL_IS_IMAP_SUMMARY (summary));
+	g_return_if_fail (CAMEL_IS_IMAP4_SUMMARY (summary));
 	
 	if (!(info = camel_folder_summary_index (summary, seqid)))
 		return;
@@ -1046,62 +1046,62 @@ info_uid_sort (const CamelMessageInfo **info0, const CamelMessageInfo **info1)
 }
 
 int
-camel_imap_summary_flush_updates (CamelFolderSummary *summary, CamelException *ex)
+camel_imap4_summary_flush_updates (CamelFolderSummary *summary, CamelException *ex)
 {
-	CamelIMAPSummary *imap_summary = (CamelIMAPSummary *) summary;
-	CamelIMAPEngine *engine;
-	CamelIMAPCommand *ic;
+	CamelIMAP4Summary *imap4_summary = (CamelIMAP4Summary *) summary;
+	CamelIMAP4Engine *engine;
+	CamelIMAP4Command *ic;
 	guint32 first = 0;
 	int scount, id;
 	
-	g_return_val_if_fail (CAMEL_IS_IMAP_SUMMARY (summary), -1);
+	g_return_val_if_fail (CAMEL_IS_IMAP4_SUMMARY (summary), -1);
 	
-	engine = ((CamelIMAPStore *) imap_summary->folder->parent_store)->engine;
+	engine = ((CamelIMAP4Store *) imap4_summary->folder->parent_store)->engine;
 	
-	if (imap_summary->uidvalidity_changed) {
+	if (imap4_summary->uidvalidity_changed) {
 		first = 1;
-	} else if (imap_summary->exists_changed) {
+	} else if (imap4_summary->exists_changed) {
 		scount = camel_folder_summary_count (summary);
-		ic = imap_summary_fetch_flags (summary, 1, scount);
+		ic = imap4_summary_fetch_flags (summary, 1, scount);
 		
-		while ((id = camel_imap_engine_iterate (engine)) < ic->id && id != -1)
+		while ((id = camel_imap4_engine_iterate (engine)) < ic->id && id != -1)
 			;
 		
-		if (id == -1 || ic->status != CAMEL_IMAP_COMMAND_COMPLETE) {
-			imap_fetch_all_free (ic->user_data);
+		if (id == -1 || ic->status != CAMEL_IMAP4_COMMAND_COMPLETE) {
+			imap4_fetch_all_free (ic->user_data);
 			camel_exception_xfer (ex, &ic->ex);
-			camel_imap_command_unref (ic);
+			camel_imap4_command_unref (ic);
 			return -1;
 		}
 		
-		if (!(first = imap_fetch_all_update (ic->user_data)) && imap_summary->exists > scount)
+		if (!(first = imap4_fetch_all_update (ic->user_data)) && imap4_summary->exists > scount)
 			first = scount + 1;
 		
-		camel_imap_command_unref (ic);
+		camel_imap4_command_unref (ic);
 	}
 	
 	if (first != 0) {
-		ic = imap_summary_fetch_all (summary, first, 0);
+		ic = imap4_summary_fetch_all (summary, first, 0);
 		
-		while ((id = camel_imap_engine_iterate (engine)) < ic->id && id != -1)
+		while ((id = camel_imap4_engine_iterate (engine)) < ic->id && id != -1)
 			;
 		
-		if (id == -1 || ic->status != CAMEL_IMAP_COMMAND_COMPLETE) {
-			imap_fetch_all_free (ic->user_data);
+		if (id == -1 || ic->status != CAMEL_IMAP4_COMMAND_COMPLETE) {
+			imap4_fetch_all_free (ic->user_data);
 			camel_exception_xfer (ex, &ic->ex);
-			camel_imap_command_unref (ic);
+			camel_imap4_command_unref (ic);
 			return -1;
 		}
 		
-		imap_fetch_all_add (ic->user_data);
-		camel_imap_command_unref (ic);
+		imap4_fetch_all_add (ic->user_data);
+		camel_imap4_command_unref (ic);
 		
 		/* it's important for these to be sorted sequentially for EXPUNGE events to work */
 		g_ptr_array_sort (summary->messages, (GCompareFunc) info_uid_sort);
 	}
 	
-	imap_summary->exists_changed = FALSE;
-	imap_summary->uidvalidity_changed = FALSE;
+	imap4_summary->exists_changed = FALSE;
+	imap4_summary->uidvalidity_changed = FALSE;
 	
 	return 0;
 }
diff --git a/camel/providers/imap4/camel-imap4-summary.h b/camel/providers/imap4/camel-imap4-summary.h
new file mode 100644
index 0000000000..6b5e906960
--- /dev/null
+++ b/camel/providers/imap4/camel-imap4-summary.h
@@ -0,0 +1,91 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*  Camel
+ *  Copyright (C) 1999-2004 Jeffrey Stedfast
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __CAMEL_IMAP4_SUMMARY_H__
+#define __CAMEL_IMAP4_SUMMARY_H__
+
+#include <sys/types.h>
+
+#include <camel/camel-folder.h>
+#include <camel/camel-folder-summary.h>
+
+#ifdef __cplusplus
+extern "C" {
+#pragma }
+#endif /* __cplusplus */
+
+#define CAMEL_TYPE_IMAP4_SUMMARY            (camel_imap4_summary_get_type ())
+#define CAMEL_IMAP4_SUMMARY(obj)            (CAMEL_CHECK_CAST ((obj), CAMEL_TYPE_IMAP4_SUMMARY, CamelIMAP4Summary))
+#define CAMEL_IMAP4_SUMMARY_CLASS(klass)    (CAMEL_CHECK_CLASS_CAST ((klass), CAMEL_TYPE_IMAP4_SUMMARY, CamelIMAP4SummaryClass))
+#define CAMEL_IS_IMAP4_SUMMARY(obj)         (CAMEL_CHECK_TYPE ((obj), CAMEL_TYPE_IMAP4_SUMMARY))
+#define CAMEL_IS_IMAP4_SUMMARY_CLASS(klass) (CAMEL_CHECK_CLASS_TYPE ((klass), CAMEL_TYPE_IMAP4_SUMMARY))
+#define CAMEL_IMAP4_SUMMARY_GET_CLASS(obj)  (CAMEL_CHECK_GET_CLASS ((obj), CAMEL_TYPE_FOLDER_SUMMARY, CamelIMAP4SummaryClass))
+
+typedef struct _CamelIMAP4MessageInfo CamelIMAP4MessageInfo;
+typedef struct _CamelIMAP4Summary CamelIMAP4Summary;
+typedef struct _CamelIMAP4SummaryClass CamelIMAP4SummaryClass;
+
+struct _CamelIMAP4MessageInfo {
+	CamelMessageInfo parent_info;
+	
+	guint32 server_flags;
+};
+
+struct _CamelIMAP4Summary {
+	CamelFolderSummary parent_object;
+	
+	CamelFolder *folder;
+	
+	guint32 exists;
+	guint32 recent;
+	guint32 unseen;
+	
+	guint32 uidvalidity;
+	
+	guint uidvalidity_changed:1;
+	guint exists_changed:1;
+};
+
+struct _CamelIMAP4SummaryClass {
+	CamelFolderSummaryClass parent_class;
+	
+};
+
+
+CamelType camel_imap4_summary_get_type (void);
+
+CamelFolderSummary *camel_imap4_summary_new (CamelFolder *folder);
+
+void camel_imap4_summary_set_exists (CamelFolderSummary *summary, guint32 exists);
+void camel_imap4_summary_set_recent (CamelFolderSummary *summary, guint32 recent);
+void camel_imap4_summary_set_unseen (CamelFolderSummary *summary, guint32 unseen);
+void camel_imap4_summary_set_uidnext (CamelFolderSummary *summary, guint32 uidnext);
+
+void camel_imap4_summary_set_uidvalidity (CamelFolderSummary *summary, guint32 uidvalidity);
+
+void camel_imap4_summary_expunge (CamelFolderSummary *summary, int seqid);
+
+int camel_imap4_summary_flush_updates (CamelFolderSummary *summary, CamelException *ex);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __CAMEL_IMAP4_SUMMARY_H__ */
diff --git a/camel/providers/imap4/camel-imap-utils.c b/camel/providers/imap4/camel-imap4-utils.c
index 129c7b83af..67dd828134 100644
--- a/camel/providers/imap4/camel-imap-utils.c
+++ b/camel/providers/imap4/camel-imap4-utils.c
@@ -26,17 +26,19 @@
 #include <string.h>
 #include <errno.h>
 
-#include "camel-imap-engine.h"
-#include "camel-imap-stream.h"
-#include "camel-imap-command.h"
+#include <camel/camel-store.h>
 
-#include "camel-imap-utils.h"
+#include "camel-imap4-engine.h"
+#include "camel-imap4-stream.h"
+#include "camel-imap4-command.h"
+
+#include "camel-imap4-utils.h"
 
 #define d(x) x
 
 
 void
-camel_imap_flags_diff (flags_diff_t *diff, guint32 old, guint32 new)
+camel_imap4_flags_diff (flags_diff_t *diff, guint32 old, guint32 new)
 {
 	diff->changed = old ^ new;
 	diff->bits = new & diff->changed;
@@ -44,14 +46,14 @@ camel_imap_flags_diff (flags_diff_t *diff, guint32 old, guint32 new)
 
 
 guint32
-camel_imap_flags_merge (flags_diff_t *diff, guint32 flags)
+camel_imap4_flags_merge (flags_diff_t *diff, guint32 flags)
 {
 	return (flags & ~diff->changed) | diff->bits;
 }
 
 
 /**
- * camel_imap_merge_flags:
+ * camel_imap4_merge_flags:
  * @original: original server flags
  * @local: local flags (after changes)
  * @server: new server flags (another client updated the server flags)
@@ -61,18 +63,18 @@ camel_imap_flags_merge (flags_diff_t *diff, guint32 flags)
  * Returns the merged flags.
  **/
 guint32
-camel_imap_merge_flags (guint32 original, guint32 local, guint32 server)
+camel_imap4_merge_flags (guint32 original, guint32 local, guint32 server)
 {
 	flags_diff_t diff;
 	
-	camel_imap_flags_diff (&diff, original, local);
+	camel_imap4_flags_diff (&diff, original, local);
 	
-	return camel_imap_flags_merge (&diff, server);
+	return camel_imap4_flags_merge (&diff, server);
 }
 
 
 void
-camel_imap_utils_set_unexpected_token_error (CamelException *ex, CamelIMAPEngine *engine, camel_imap_token_t *token)
+camel_imap4_utils_set_unexpected_token_error (CamelException *ex, CamelIMAP4Engine *engine, camel_imap4_token_t *token)
 {
 	GString *errmsg;
 	
@@ -84,25 +86,25 @@ camel_imap_utils_set_unexpected_token_error (CamelException *ex, CamelIMAPEngine
 				engine->url->host);
 	
 	switch (token->token) {
-	case CAMEL_IMAP_TOKEN_NIL:
+	case CAMEL_IMAP4_TOKEN_NIL:
 		g_string_append (errmsg, "NIL");
 		break;
-	case CAMEL_IMAP_TOKEN_ATOM:
+	case CAMEL_IMAP4_TOKEN_ATOM:
 		g_string_append (errmsg, token->v.atom);
 		break;
-	case CAMEL_IMAP_TOKEN_FLAG:
+	case CAMEL_IMAP4_TOKEN_FLAG:
 		g_string_append (errmsg, token->v.flag);
 		break;
-	case CAMEL_IMAP_TOKEN_QSTRING:
+	case CAMEL_IMAP4_TOKEN_QSTRING:
 		g_string_append (errmsg, token->v.qstring);
 		break;
-	case CAMEL_IMAP_TOKEN_LITERAL:
+	case CAMEL_IMAP4_TOKEN_LITERAL:
 		g_string_append_printf (errmsg, "{%u}", token->v.literal);
 		break;
-	case CAMEL_IMAP_TOKEN_NUMBER:
+	case CAMEL_IMAP4_TOKEN_NUMBER:
 		g_string_append_printf (errmsg, "%u", token->v.number);
 		break;
-	case CAMEL_IMAP_TOKEN_NO_DATA:
+	case CAMEL_IMAP4_TOKEN_NO_DATA:
 		g_string_append (errmsg, _("No data"));
 		break;
 	default:
@@ -119,7 +121,7 @@ camel_imap_utils_set_unexpected_token_error (CamelException *ex, CamelIMAPEngine
 static struct {
 	const char *name;
 	guint32 flag;
-} imap_flags[] = {
+} imap4_flags[] = {
 	{ "\\Answered", CAMEL_MESSAGE_ANSWERED    },
 	{ "\\Deleted",  CAMEL_MESSAGE_DELETED     },
 	{ "\\Draft",    CAMEL_MESSAGE_DRAFT       },
@@ -133,64 +135,64 @@ static struct {
 static struct {
 	const char *name;
 	guint32 flag;
-} imap_user_flags[] = {
+} imap4_user_flags[] = {
 	{ "Forwarded",  CAMEL_MESSAGE_FORWARDED   },
 };
 #endif
 
 
 int
-camel_imap_parse_flags_list (CamelIMAPEngine *engine, guint32 *flags, CamelException *ex)
+camel_imap4_parse_flags_list (CamelIMAP4Engine *engine, guint32 *flags, CamelException *ex)
 {
-	camel_imap_token_t token;
+	camel_imap4_token_t token;
 	guint32 new = 0;
 	int i;
 	
-	if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 		return -1;
 	
 	if (token.token != '(') {
 		d(fprintf (stderr, "Expected to find a '(' token starting the flags list\n"));
-		camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 		return -1;
 	}
 	
-	if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 		return -1;
 	
-	while (token.token == CAMEL_IMAP_TOKEN_ATOM || token.token == CAMEL_IMAP_TOKEN_FLAG) {
+	while (token.token == CAMEL_IMAP4_TOKEN_ATOM || token.token == CAMEL_IMAP4_TOKEN_FLAG) {
 		/* parse the flags list */
-		for (i = 0; i < G_N_ELEMENTS (imap_flags); i++) {
-			if (!strcasecmp (imap_flags[i].name, token.v.atom)) {
-				new |= imap_flags[i].flag;
+		for (i = 0; i < G_N_ELEMENTS (imap4_flags); i++) {
+			if (!strcasecmp (imap4_flags[i].name, token.v.atom)) {
+				new |= imap4_flags[i].flag;
 				break;
 			}
 		}
 		
 #if 0
-		if (i == G_N_ELEMENTS (imap_flags)) {
-			for (i = 0; i < G_N_ELEMENTS (imap_user_flags); i++) {
-				if (!strcasecmp (imap_user_flags[i].name, token.v.atom)) {
-					new |= imap_user_flags[i].flag;
+		if (i == G_N_ELEMENTS (imap4_flags)) {
+			for (i = 0; i < G_N_ELEMENTS (imap4_user_flags); i++) {
+				if (!strcasecmp (imap4_user_flags[i].name, token.v.atom)) {
+					new |= imap4_user_flags[i].flag;
 					break;
 				}
 			}
 			
-			if (i == G_N_ELEMENTS (imap_user_flags))
+			if (i == G_N_ELEMENTS (imap4_user_flags))
 				fprintf (stderr, "Encountered unknown flag: %s\n", token.v.atom);
 		}
 #else
-		if (i == G_N_ELEMENTS (imap_flags))
+		if (i == G_N_ELEMENTS (imap4_flags))
 			fprintf (stderr, "Encountered unknown flag: %s\n", token.v.atom);
 #endif
 		
-		if (camel_imap_engine_next_token (engine, &token, ex) == -1)
+		if (camel_imap4_engine_next_token (engine, &token, ex) == -1)
 			return -1;
 	}
 	
 	if (token.token != ')') {
 		d(fprintf (stderr, "Expected to find a ')' token terminating the flags list\n"));
-		camel_imap_utils_set_unexpected_token_error (ex, engine, &token);
+		camel_imap4_utils_set_unexpected_token_error (ex, engine, &token);
 		return -1;
 	}
 	
@@ -204,19 +206,19 @@ struct {
 	const char *name;
 	guint32 flag;
 } list_flags[] = {
-	{ "\\Marked",        CAMEL_IMAP_FOLDER_MARKED          },
-	{ "\\Unmarked",      CAMEL_IMAP_FOLDER_UNMARKED        },
-	{ "\\Noselect",      CAMEL_IMAP_FOLDER_NOSELECT        },
-	{ "\\Noinferiors",   CAMEL_IMAP_FOLDER_NOINFERIORS     },
-	{ "\\HasChildren",   CAMEL_IMAP_FOLDER_HAS_CHILDREN    },
-	{ "\\HasNoChildren", CAMEL_IMAP_FOLDER_HAS_NO_CHILDREN },
+	{ "\\Marked",        CAMEL_IMAP4_FOLDER_MARKED    },
+	{ "\\Unmarked",      CAMEL_IMAP4_FOLDER_UNMARKED  },
+	{ "\\Noselect",      CAMEL_FOLDER_NOSELECT        },
+	{ "\\Noinferiors",   CAMEL_FOLDER_NOINFERIORS     },
+	{ "\\HasChildren",   CAMEL_FOLDER_CHILDREN        },
+	{ "\\HasNoChildren", CAMEL_FOLDER_NOCHILDREN      },
 };
 
 int
-camel_imap_untagged_list (CamelIMAPEngine *engine, CamelIMAPCommand *ic, guint32 index, camel_imap_token_t *token, CamelException *ex)
+camel_imap4_untagged_list (CamelIMAP4Engine *engine, CamelIMAP4Command *ic, guint32 index, camel_imap4_token_t *token, CamelException *ex)
 {
 	GPtrArray *array = ic->user_data;
-	camel_imap_list_t *list;
+	camel_imap4_list_t *list;
 	unsigned char *buf;
 	guint32 flags = 0;
 	GString *literal;
@@ -224,17 +226,17 @@ camel_imap_untagged_list (CamelIMAPEngine *engine, CamelIMAPCommand *ic, guint32
 	size_t n;
 	int i;
 	
-	if (camel_imap_engine_next_token (engine, token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 		return -1;
 	
 	/* parse the flag list */
 	if (token->token != '(')
 		goto unexpected;
 	
-	if (camel_imap_engine_next_token (engine, token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 		return -1;
 	
-	while (token->token == CAMEL_IMAP_TOKEN_FLAG || token->token == CAMEL_IMAP_TOKEN_ATOM) {
+	while (token->token == CAMEL_IMAP4_TOKEN_FLAG || token->token == CAMEL_IMAP4_TOKEN_ATOM) {
 		for (i = 0; i < G_N_ELEMENTS (list_flags); i++) {
 			if (!g_ascii_strcasecmp (list_flags[i].name, token->v.atom)) {
 				flags |= list_flags[i].flag;
@@ -242,7 +244,7 @@ camel_imap_untagged_list (CamelIMAPEngine *engine, CamelIMAPCommand *ic, guint32
 			}
 		}
 		
-		if (camel_imap_engine_next_token (engine, token, ex) == -1)
+		if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 			return -1;
 	}
 	
@@ -250,14 +252,14 @@ camel_imap_untagged_list (CamelIMAPEngine *engine, CamelIMAPCommand *ic, guint32
 		goto unexpected;
 	
 	/* parse the path delimiter */
-	if (camel_imap_engine_next_token (engine, token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 		return -1;
 	
 	switch (token->token) {
-	case CAMEL_IMAP_TOKEN_NIL:
+	case CAMEL_IMAP4_TOKEN_NIL:
 		delim = '\0';
 		break;
-	case CAMEL_IMAP_TOKEN_QSTRING:
+	case CAMEL_IMAP4_TOKEN_QSTRING:
 		delim = *token->v.qstring;
 		break;
 	default:
@@ -265,23 +267,23 @@ camel_imap_untagged_list (CamelIMAPEngine *engine, CamelIMAPCommand *ic, guint32
 	}
 	
 	/* parse the folder name */
-	if (camel_imap_engine_next_token (engine, token, ex) == -1)
+	if (camel_imap4_engine_next_token (engine, token, ex) == -1)
 		return -1;
 	
-	list = g_new (camel_imap_list_t, 1);
+	list = g_new (camel_imap4_list_t, 1);
 	list->flags = flags;
 	list->delim = delim;
 	
 	switch (token->token) {
-	case CAMEL_IMAP_TOKEN_ATOM:
+	case CAMEL_IMAP4_TOKEN_ATOM:
 		list->name = g_strdup (token->v.atom);
 		break;
-	case CAMEL_IMAP_TOKEN_QSTRING:
+	case CAMEL_IMAP4_TOKEN_QSTRING:
 		list->name = g_strdup (token->v.qstring);
 		break;
-	case CAMEL_IMAP_TOKEN_LITERAL:
+	case CAMEL_IMAP4_TOKEN_LITERAL:
 		literal = g_string_new ("");
-		while ((i = camel_imap_stream_literal (engine->istream, &buf, &n)) == 1)
+		while ((i = camel_imap4_stream_literal (engine->istream, &buf, &n)) == 1)
 			g_string_append_len (literal, buf, n);
 		
 		if (i == -1) {
@@ -303,11 +305,11 @@ camel_imap_untagged_list (CamelIMAPEngine *engine, CamelIMAPCommand *ic, guint32
 	
 	g_ptr_array_add (array, list);
 	
-	return camel_imap_engine_eat_line (engine, ex);
+	return camel_imap4_engine_eat_line (engine, ex);
 	
  unexpected:
 	
-	camel_imap_utils_set_unexpected_token_error (ex, engine, token);
+	camel_imap4_utils_set_unexpected_token_error (ex, engine, token);
 	
 	return -1;
 }
diff --git a/camel/providers/imap4/camel-imap4-utils.h b/camel/providers/imap4/camel-imap4-utils.h
new file mode 100644
index 0000000000..ace7b4cad0
--- /dev/null
+++ b/camel/providers/imap4/camel-imap4-utils.h
@@ -0,0 +1,67 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*  Camel
+ *  Copyright (C) 1999-2004 Jeffrey Stedfast
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __CAMEL_IMAP4_UTILS_H__
+#define __CAMEL_IMAP4_UTILS_H__
+
+#include <glib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#pragma }
+#endif /* __cplusplus */
+
+/* IMAP4 flag merging */
+typedef struct {
+	guint32 changed;
+	guint32 bits;
+} flags_diff_t;
+
+void camel_imap4_flags_diff (flags_diff_t *diff, guint32 old, guint32 new);
+guint32 camel_imap4_flags_merge (flags_diff_t *diff, guint32 flags);
+guint32 camel_imap4_merge_flags (guint32 original, guint32 local, guint32 server);
+
+
+struct _CamelIMAP4Engine;
+struct _CamelIMAP4Command;
+struct _camel_imap4_token_t;
+
+void camel_imap4_utils_set_unexpected_token_error (CamelException *ex, struct _CamelIMAP4Engine *engine, struct _camel_imap4_token_t *token);
+
+int camel_imap4_parse_flags_list (struct _CamelIMAP4Engine *engine, guint32 *flags, CamelException *ex);
+
+/* Note: make sure these don't clash with any bit flags in camel-store.h */
+#define CAMEL_IMAP4_FOLDER_MARKED   (1 << 17)
+#define CAMEL_IMAP4_FOLDER_UNMARKED (1 << 18)
+
+typedef struct {
+	guint32 flags;
+	char delim;
+	char *name;
+} camel_imap4_list_t;
+
+int camel_imap4_untagged_list (struct _CamelIMAP4Engine *engine, struct _CamelIMAP4Command *ic,
+			       guint32 index, struct _camel_imap4_token_t *token, CamelException *ex);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __CAMEL_IMAP4_UTILS_H__ */