experimental, non-working imap implementation

svn path=/trunk/; revision=22061

1 files changed, 1156 insertions, 0 deletions

diff --git a/camel/providers/imapp/camel-imapp-engine.c b/camel/providers/imapp/camel-imapp-engine.c
new file mode 100644
index 0000000000..f6cfcbf86c
--- /dev/null
+++ b/camel/providers/imapp/camel-imapp-engine.c
@@ -0,0 +1,1156 @@
+
+#include "config.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include "camel-imapp-engine.h"
+#include "camel-imapp-stream.h"
+#include "camel-imapp-utils.h"
+#include "camel-imapp-exception.h"
+
+#include <camel/camel-folder-summary.h>
+#include <camel/camel-stream-mem.h>
+#include <camel/camel-stream-null.h>
+#include <camel/camel-data-wrapper.h>
+#include <camel/camel-sasl.h>
+
+#include <ctype.h>
+
+#define e(x) 
+#define c(x)			/* command build debug */
+
+static void imap_engine_command_addv(CamelIMAPPEngine *imap, CamelIMAPPCommand *ic, const char *fmt, va_list ap);
+static void imap_engine_command_complete(CamelIMAPPEngine *imap, CamelIMAPPCommand *ic);
+
+struct _handler {
+	CamelIMAPPEngineFunc func;
+	void *data;
+	char name[1];
+};
+
+static void
+class_init(CamelIMAPPEngineClass *ieclass)
+{
+	ieclass->tagprefix = 'A';
+
+	camel_object_class_add_event((CamelObjectClass *)ieclass, "status", NULL);
+}
+
+static void
+object_init(CamelIMAPPEngine *ie, CamelIMAPPEngineClass *ieclass)
+{
+	ie->handlers = g_hash_table_new(g_str_hash, g_str_equal);
+	e_dlist_init(&ie->active);
+	e_dlist_init(&ie->queue);
+
+	ie->tagprefix = ieclass->tagprefix;
+	ieclass->tagprefix++;
+	if (ieclass->tagprefix > 'Z')
+		ieclass->tagprefix = 'A';
+	ie->tagprefix = 'A';
+
+	ie->state = IMAP_ENGINE_DISCONNECT;
+}
+
+static void
+handler_free(void *key, void *mem, void *data)
+{
+	g_free(mem);
+}
+
+static void
+object_finalise(CamelIMAPPEngine *ie, CamelIMAPPEngineClass *ieclass)
+{
+	/* FIXME: need to free the commands ... */
+	while (camel_imapp_engine_iterate(ie, NULL) > 0)
+		;
+
+	g_hash_table_foreach(ie->handlers, (GHFunc)handler_free, NULL);
+	g_hash_table_destroy(ie->handlers);
+}
+
+CamelType
+camel_imapp_engine_get_type (void)
+{
+	static CamelType type = CAMEL_INVALID_TYPE;
+
+	if (type == CAMEL_INVALID_TYPE) {
+		type = camel_type_register (
+			camel_object_get_type (),
+			"CamelIMAPPEngine",
+			sizeof (CamelIMAPPEngine),
+			sizeof (CamelIMAPPEngineClass),
+			(CamelObjectClassInitFunc) class_init,
+			NULL,
+			(CamelObjectInitFunc) object_init,
+			(CamelObjectFinalizeFunc) object_finalise);
+	}
+	
+	return type;
+}
+
+/* FIXME: check this, just taken from old code, not rfc */
+struct {
+	char *name;
+	guint32 flag;
+} capa_table[] = {
+	{ "IMAP4", IMAP_CAPABILITY_IMAP4 },
+	{ "IMAP4REV1", IMAP_CAPABILITY_IMAP4REV1 },
+	{ "STATUS",  IMAP_CAPABILITY_STATUS } ,
+	{ "NAMESPACE", IMAP_CAPABILITY_NAMESPACE },
+	{ "UIDPLUS",  IMAP_CAPABILITY_UIDPLUS },
+	{ "LITERAL+", IMAP_CAPABILITY_LITERALPLUS },
+	{ "STARTTLS", IMAP_CAPABILITY_STARTTLS },
+};
+
+
+/*
+capability_data ::= "CAPABILITY" SPACE [1#capability SPACE] "IMAP4rev1"
+                    [SPACE 1#capability]
+                    ;; IMAP4rev1 servers which offer RFC 1730
+                    ;; compatibility MUST list "IMAP4" as the first
+                    ;; capability.
+*/
+static int resp_capability(CamelIMAPPEngine *ie, guint32 id, void *data)
+{
+	int tok, len, i;
+	unsigned char *token, *p, c;
+
+	/* FIXME: handle auth types */
+
+	printf("got capability response:\n");
+	while (1) {
+		tok = camel_imapp_stream_token(ie->stream, &token, &len);
+		switch(tok) {
+		case IMAP_TOK_TOKEN:
+			p = token;
+			while ((c = *p))
+				*p++ = toupper(c);
+		case IMAP_TOK_INT:
+			printf(" cap: '%s'\n", token);
+			for (i=0;i<(int)(sizeof(capa_table)/sizeof(capa_table[0]));i++)
+				if (strcmp(token, capa_table[i].name))
+					ie->capa |= capa_table[i].flag;
+			break;
+		case '\n':
+			return 0;
+		case IMAP_TOK_ERROR:
+		case IMAP_TOK_PROTOCOL:
+			camel_imapp_engine_skip(ie);
+			return -1;
+		default:
+			printf("Unknown Response token %02x '%c'\n", tok, isprint(tok)?tok:'.');
+		}
+	} while (tok != '\n');
+
+	return 0;
+}
+
+/* expunge command, id is expunged seq number */
+/* message_data    ::= nz_number SPACE ("EXPUNGE" /
+   ("FETCH" SPACE msg_att)) */
+static int resp_expunge(CamelIMAPPEngine *ie, guint32 id, void *data)
+{
+	printf("message expunged: %d\n", id);
+
+	return camel_imapp_engine_skip(ie);
+}
+
+static int resp_flags(CamelIMAPPEngine *ie, guint32 id, void *data)
+{
+	guint32 flags;
+
+	imap_parse_flags(ie->stream, &flags);
+
+	printf("flags: %08x\n", flags);
+
+	return camel_imapp_engine_skip(ie);
+}
+
+/* exists count */
+static int resp_exists(CamelIMAPPEngine *ie, guint32 id, void *data)
+{
+	printf("messages exist: %d\n", id);
+
+	if (ie->select_response)
+		ie->select_response->exists = id;
+
+	return camel_imapp_engine_skip(ie);
+}
+
+static int resp_recent(CamelIMAPPEngine *ie, guint32 id, void *data)
+{
+	printf("messages recent: %d\n", id);
+
+	if (ie->select_response)
+		ie->select_response->recent = id;
+
+	return camel_imapp_engine_skip(ie);
+}
+
+static int resp_fetch(CamelIMAPPEngine *ie, guint32 id, void *data)
+{
+	struct _fetch_info *finfo;
+
+	finfo = imap_parse_fetch(ie->stream);
+	imap_dump_fetch(finfo);
+	imap_free_fetch(finfo);
+
+	return camel_imapp_engine_skip(ie);
+}
+
+#if 0
+static int resp_list(CamelIMAPPEngine *ie, guint32 id, void *data)
+{
+	struct _list_info *linfo;
+
+	linfo = imap_parse_list(ie->stream);
+	printf("list:  '%s' (%c)\n", linfo->name, linfo->separator);
+	imap_free_list(linfo);
+
+	return camel_imapp_engine_skip(ie);
+}
+#endif
+
+CamelIMAPPEngine *
+camel_imapp_engine_new(CamelIMAPPStream *stream)
+{
+	CamelIMAPPEngine * volatile engine;
+
+	engine = CAMEL_IMAPP_ENGINE (camel_object_new (CAMEL_IMAPP_ENGINE_TYPE));
+	engine->stream = stream;
+	camel_object_ref((CamelObject *)stream);
+
+	camel_imapp_engine_add_handler(engine, "CAPABILITY", resp_capability, engine);
+
+	/* mailbox_data */
+	camel_imapp_engine_add_handler(engine, "FLAGS", (CamelIMAPPEngineFunc)resp_flags, engine);
+	camel_imapp_engine_add_handler(engine, "EXISTS", (CamelIMAPPEngineFunc)resp_exists, engine);
+	camel_imapp_engine_add_handler(engine, "RECENT", (CamelIMAPPEngineFunc)resp_recent, engine);
+
+#if 0
+	camel_imapp_engine_add_handler(engine, "LIST", (CamelIMAPPEngineFunc)resp_list, engine);
+	camel_imapp_engine_add_handler(engine, "LSUB", (CamelIMAPPEngineFunc)resp_list, engine);
+#endif
+	/* message_data */
+	camel_imapp_engine_add_handler(engine, "EXPUNGE", (CamelIMAPPEngineFunc)resp_expunge, engine);
+	camel_imapp_engine_add_handler(engine, "FETCH", (CamelIMAPPEngineFunc)resp_fetch, engine);
+
+	/* TODO: move this to a driver:connect call? */
+	CAMEL_TRY {
+		unsigned char *token;
+		unsigned int len;
+		int tok;
+
+		tok = camel_imapp_stream_token(stream, &token, &len);
+		if (tok == '*') {
+			struct _status_info *sinfo = imap_parse_status(stream);
+
+			switch (sinfo->result) {
+			case IMAP_OK:
+				engine->state = IMAP_ENGINE_CONNECT;
+				printf("Server connected ok: %s\n", sinfo->text);
+				break;
+			case IMAP_PREAUTH:
+				printf("pre-authenticated ...\n");
+				engine->state = IMAP_ENGINE_AUTH;
+				break;
+			default:
+				imap_free_status(sinfo);
+				camel_exception_throw(1, "Server refused connection: %s", sinfo->text);
+				break;
+			}
+			imap_free_status(sinfo);
+		} else {
+			engine->state = IMAP_ENGINE_CONNECT;
+			printf("unknwon server greeting, ignored\n");
+			camel_imapp_engine_skip(engine);
+		}
+		camel_imapp_engine_capabilities(engine);
+	} CAMEL_CATCH(ex) {
+		printf("connection failed: %s\n", ex->desc);
+		camel_object_unref((CamelObject *)engine);
+		engine = NULL;
+	} CAMEL_DONE;
+
+	return engine;
+}
+
+void
+camel_imapp_engine_add_handler(CamelIMAPPEngine *imap, const char *response, CamelIMAPPEngineFunc func, void *data)
+{
+	struct _handler *h;
+	const unsigned char *p;
+	unsigned char *o, c;
+	
+	h = g_malloc0(sizeof(*h) + strlen(response));
+	h->func = func;
+	h->data = data;
+
+	p = response;
+	o = h->name;
+	while ((c = *p++))
+		*o++ = toupper(c);
+	*o = 0;
+
+	g_hash_table_insert(imap->handlers, h->name, h);
+}
+
+int
+camel_imapp_engine_capabilities(CamelIMAPPEngine *ie)
+{
+	CamelIMAPPCommand *ic;
+
+	/* reset capabilities */
+	ie->capa = 0;
+
+	ic = camel_imapp_engine_command_new(ie, "CAPABILITY", NULL, "CAPABILITY");
+	camel_imapp_engine_command_queue(ie, ic);
+	while (camel_imapp_engine_iterate(ie, ic)>0)
+		;
+	camel_imapp_engine_command_free(ie, ic);
+
+	return 0;
+}
+
+/* skip the rest of the line of tokens */
+int
+camel_imapp_engine_skip(CamelIMAPPEngine *imap)
+{
+	int tok;
+	unsigned char *token;
+	unsigned int len;
+
+	do {
+		tok = camel_imapp_stream_token(imap->stream, &token, &len);
+		if (tok == IMAP_TOK_LITERAL) {
+			camel_imapp_stream_set_literal(imap->stream, len);
+			while ((tok = camel_imapp_stream_getl(imap->stream, &token, &len)) > 0) {
+				printf("Skip literal data '%.*s'\n", (int)len, token);
+			}
+		}
+	} while (tok != '\n' && tok >= 0);
+
+	if (tok < 0)
+		return -1;
+
+	return 0;
+}
+
+/* handle any untagged responses */
+int
+iterate_untagged(CamelIMAPPEngine *imap)
+{
+	unsigned int id, len;
+	unsigned char *token, *p, c;
+	int tok;
+	struct _handler *h;
+	struct _status_info *sinfo;
+	
+	e(printf("got untagged response\n"));
+	id = 0;
+	tok = camel_imapp_stream_token(imap->stream, &token, &len);
+	if (tok == IMAP_TOK_INT) {
+		id = strtoul(token, NULL, 10);
+		tok = camel_imapp_stream_token(imap->stream, &token, &len);
+	}
+
+	if (tok == '\n')
+		camel_exception_throw(1, "truncated server response");
+
+	e(printf("Have token '%s' id %d\n", token, id));
+	p = token;
+	while ((c = *p))
+		*p++ = toupper(c);
+
+	/* first, check for generic unsolicited response */
+	h = g_hash_table_lookup(imap->handlers, token);
+	if (h) {
+		tok = h->func(imap, id, h->data);
+		if (tok < 0)
+			return tok;
+		return 1;
+	}
+
+	/* TODO: apart from bye/preauth, these could be callbacks/events? */
+
+	/* now, check for status responses */
+	switch (imap_tokenise(token, len)) {
+	case IMAP_BYE:
+	case IMAP_OK:
+	case IMAP_NO:
+	case IMAP_BAD:
+	case IMAP_PREAUTH:
+		/* TODO: validate which ones of these can happen as unsolicited responses */
+		/* TODO: handle bye/preauth differently */
+		/* FIXME: free sinfo */
+		camel_imapp_stream_ungettoken(imap->stream, tok, token, len);
+		sinfo = imap_parse_status(imap->stream);
+		camel_object_trigger_event(imap, "status", sinfo);
+		imap_free_status(sinfo);
+#if 0
+		switch(sinfo->condition) {
+		case IMAP_READ_WRITE:
+			printf("folder is read-write\n");
+			break;
+		case IMAP_READ_ONLY:
+			printf("folder is read-only\n");
+			break;
+		case IMAP_UIDVALIDITY:
+			if (imap->select_response)
+				imap->select_response->uidvalidity = sinfo->u.uidvalidity;
+			break;
+#if 0	
+			/* not defined yet ... */
+		case IMAP_UIDNEXT:
+			printf("got uidnext for folder: %d\n", sinfo->u.uidnext);
+			break;
+#endif	
+		case IMAP_UNSEEN:
+			if (imap->select_response)
+				imap->select_response->unseen = sinfo->u.unseen;
+			break;
+		case IMAP_PERMANENTFLAGS:
+			if (imap->select_response)
+				imap->select_response->permanentflags = sinfo->u.permanentflags;
+			break;
+		case IMAP_ALERT:
+			printf("ALERT!: %s\n", sinfo->text);
+			break;
+		case IMAP_PARSE:
+			printf("PARSE: %s\n", sinfo->text);
+			break;
+		default:
+			break;
+		}
+#endif
+		break;
+	default:
+		printf("unknown token: %s\n", token);
+		camel_imapp_engine_skip(imap);
+		/* unknown response, just ignore it */
+	}
+
+	return 1;
+}
+
+/* handle any continuation requests
+   either data continuations, or auth continuation */
+int
+iterate_continuation(CamelIMAPPEngine *imap)
+{
+	CamelIMAPPCommand *ic;
+	CamelIMAPPCommandPart *cp;
+	
+	printf("got continuation response\n");
+
+	ic = imap->literal;
+	imap->literal = NULL;
+	if (ic == NULL) {
+		camel_imapp_engine_skip(imap);
+		printf("got continuation response with no outstanding continuation requests?\n");
+		return 1;
+	}
+
+	printf("got continuation response for data\n");
+	cp = ic->current;
+	switch(cp->type & CAMEL_IMAPP_COMMAND_MASK) {
+	case CAMEL_IMAPP_COMMAND_DATAWRAPPER:
+		printf("writing data wrapper to literal\n");
+		camel_data_wrapper_write_to_stream((CamelDataWrapper *)cp->ob, (CamelStream *)imap->stream);
+		break;
+	case CAMEL_IMAPP_COMMAND_STREAM:
+		printf("writing stream to literal\n");
+		camel_stream_write_to_stream((CamelStream *)cp->ob, (CamelStream *)imap->stream);
+		break;
+	case CAMEL_IMAPP_COMMAND_AUTH: {
+		CamelException *ex = camel_exception_new();
+		char *resp;
+		unsigned char *token;
+		int tok, len;
+		
+		tok = camel_imapp_stream_token(imap->stream, &token, &len);
+		resp = camel_sasl_challenge_base64((CamelSasl *)cp->ob, token, ex);
+		if (camel_exception_is_set(ex))
+			camel_exception_throw_ex(ex);
+		camel_exception_free(ex);
+		
+		printf("got auth continuation, feeding token '%s' back to auth mech\n", resp);
+		
+		camel_stream_write((CamelStream *)imap->stream, resp, strlen(resp));
+		
+		/* we want to keep getting called until we get a status reponse from the server
+		   ignore what sasl tells us */
+		imap->literal = ic;
+		
+		break; }
+	default:
+		/* should we just ignore? */
+		camel_exception_throw(1, "continuation response for non-continuation request");
+	}
+	
+	camel_imapp_engine_skip(imap);
+	
+	cp = cp->next;
+	if (cp->next) {
+		ic->current = cp;
+		printf("next part of command \"A%05u: %s\"\n", ic->tag, cp->data);
+		camel_stream_printf((CamelStream *)imap->stream, "%s\r\n", cp->data);
+		if (cp->type & CAMEL_IMAPP_COMMAND_CONTINUATION) {
+			imap->literal = ic;
+		} else {
+			g_assert(cp->next->next == NULL);
+		}
+	} else {
+		printf("%p: queueing continuation\n", ic);
+		camel_stream_printf((CamelStream *)imap->stream, "\r\n");
+	}
+	
+	if (imap->literal == NULL) {
+		ic = (CamelIMAPPCommand *)e_dlist_remhead(&imap->queue);
+		if (ic) {
+			printf("found outstanding op, queueing\n");
+			camel_imapp_engine_command_queue(imap, ic);
+		}
+	}
+
+	return 1;
+}
+
+/* handle a completion line */
+int
+iterate_completion(CamelIMAPPEngine *imap, unsigned char *token)
+{
+	CamelIMAPPCommand *ic;
+	unsigned int tag;
+
+	if (token[0] != imap->tagprefix)
+		camel_exception_throw(1, "Server sent unexpected response: %s", token);
+
+	tag = strtoul(token+1, NULL, 10);
+	ic = camel_imapp_engine_command_find_tag(imap, tag);
+	if (ic) {
+		printf("Got completion response for command %05u '%s'\n", ic->tag, ic->name);
+		printf("%p: removing command from qwueue, we were at '%s'\n", ic, ic->current->data);
+		printf("%p: removing command\n", ic);
+		e_dlist_remove((EDListNode *)ic);
+		if (imap->literal == ic)
+			imap->literal = NULL;
+		ic->status = imap_parse_status(imap->stream);
+		printf("got response code: %s\n", ic->status->text);
+
+		/* TODO: remove this stuff and use a completion handler? */
+		/* TODO: handle 'SELECT' command cleanup here */
+		/* FIXME: have this use tokeniser, have this handle close/logout/select etc as well */
+		/* ok response from login/authenticate, then we're in happy land */
+		if ((!strcmp(ic->name, "LOGIN") || !strcmp(ic->name, "AUTHENTICATE"))
+		    && ic->status->result == IMAP_OK)
+			imap->state = IMAP_ENGINE_AUTH;
+
+		if (ic->complete)
+			ic->complete(imap, ic, ic->complete_data);
+	} else {
+		camel_exception_throw(1, "got response tag unexpectedly: %s", token);
+	}
+	
+	if (imap->literal != NULL) {
+		printf("Warning: continuation command '%s' finished with outstanding continuation\n", imap->literal->name);
+		ic = imap->literal;
+				/* set the command complete with a failure code? */
+		e_dlist_remove((EDListNode *)ic);
+		imap->literal = NULL;
+	}
+	
+	ic = (CamelIMAPPCommand *)e_dlist_remhead(&imap->queue);
+	if (ic) {
+		printf("found outstanding op, queueing\n");
+		camel_imapp_engine_command_queue(imap, ic);
+	}
+	
+	return 1;
+}
+
+
+/* Do work if there's any to do */
+int
+camel_imapp_engine_iterate(CamelIMAPPEngine *imap, CamelIMAPPCommand *icwait)
+/* throws IO,PARSE exception */
+{
+	unsigned int len;
+	unsigned char *token;
+	int tok;
+
+	if ((icwait && icwait->status != NULL) || e_dlist_empty(&imap->active))
+		return 0;
+
+	/* handle exceptions here? */
+
+	/* lock here? */
+
+	tok = camel_imapp_stream_token(imap->stream, &token, &len);
+	if (tok == '*')
+		iterate_untagged(imap);
+	else if (tok == IMAP_TOK_TOKEN)
+		iterate_completion(imap, token);
+	else if (tok == '+')
+		iterate_continuation(imap);
+	else
+		camel_exception_throw(1, "unexpected server response: %s", token);
+
+	if (e_dlist_empty(&imap->active))
+		return 0;
+
+	return 1;
+}
+
+CamelIMAPPCommand *
+camel_imapp_engine_command_new(CamelIMAPPEngine *imap, const char *name, const char *select, const char *fmt, ...)
+{
+	CamelIMAPPCommand *ic;
+	va_list ap;
+
+	ic = g_malloc0(sizeof(*ic));
+	ic->tag = imap->tag++;
+	ic->name = name;
+	ic->mem = (CamelStreamMem *)camel_stream_mem_new();
+	ic->select = g_strdup(select);
+	e_dlist_init(&ic->parts);
+
+	if (fmt && fmt[0]) {
+		va_start(ap, fmt);
+		imap_engine_command_addv(imap, ic, fmt, ap);
+		va_end(ap);
+	}
+
+	return ic;
+}
+
+void
+camel_imapp_engine_command_add(CamelIMAPPEngine *imap, CamelIMAPPCommand *ic, const char *fmt, ...)
+{
+	va_list ap;
+
+	g_assert(ic->mem);	/* gets reset on queue */
+
+	if (fmt && fmt[0]) {
+		va_start(ap, fmt);
+		imap_engine_command_addv(imap, ic, fmt, ap);
+		va_end(ap);
+	}
+}
+
+void
+camel_imapp_engine_command_complete(CamelIMAPPEngine *imap, struct _CamelIMAPPCommand *ic, CamelIMAPPCommandFunc func, void *data)
+{
+	ic->complete = func;
+	ic->complete_data = data;
+}
+
+/* FIXME: make imap command's refcounted */
+void
+camel_imapp_engine_command_free (CamelIMAPPEngine *imap, CamelIMAPPCommand *ic)
+{
+	CamelIMAPPCommandPart *cp, *cn;
+
+	if (ic == NULL)
+		return;
+
+	/* validity check - we cant' free items still in any queue ... */
+	/* maybe we should just have another queue to keep them? */
+	{
+		CamelIMAPPCommand *iw;
+
+		iw = (CamelIMAPPCommand *)imap->active.head;
+		while (iw->next) {
+			if (iw == ic)
+				abort();
+			iw = iw->next;
+		}
+		iw = (CamelIMAPPCommand *)imap->queue.head;
+		while (iw->next) {
+			if (iw == ic)
+				abort();
+			iw = iw->next;
+		}
+	}
+
+	if (ic->mem)
+		camel_object_unref((CamelObject *)ic->mem);
+	imap_free_status(ic->status);
+	g_free(ic->select);
+
+	cp = (CamelIMAPPCommandPart *)ic->parts.head;
+	cn = cp->next;
+	while (cn) {
+		g_free(cp->data);
+		if (cp->ob)
+			camel_object_unref(cp->ob);
+		g_free(cp);
+		cp = cn;
+		cn = cn->next;
+	}
+
+	g_free(ic);
+}
+
+/* FIXME: error handling */
+void
+camel_imapp_engine_command_queue(CamelIMAPPEngine *imap, CamelIMAPPCommand *ic)
+{
+	CamelIMAPPCommandPart *cp;
+
+	if (ic->mem)
+		imap_engine_command_complete(imap, ic);
+
+	/* FIXME: remove select stuff */
+
+	/* see if we need to pre-queue a select command to select the right folder first */
+	if (ic->select && (imap->last_select == NULL || strcmp(ic->select, imap->last_select) != 0)) {
+		CamelIMAPPCommand *select;
+		
+		/* of course ... we can't do anything like store/search if we have to select
+		   first, because it'll mess up all the sequence numbers ... hrm ... bugger */
+
+		select = camel_imapp_engine_command_new(imap, "SELECT", NULL, "SELECT %s", ic->select);
+		g_free(imap->last_select);
+		imap->last_select = g_strdup(ic->select);
+		camel_imapp_engine_command_queue(imap, select);
+		/* how does it get freed? handle inside engine? */
+	}
+	
+	/* first, check if command can be sent yet ... queue if not */
+	if (imap->literal != NULL) {
+		printf("%p: queueing while literal active\n", ic);
+		e_dlist_addtail(&imap->queue, (EDListNode *)ic);
+		return;
+	}
+
+	cp = (CamelIMAPPCommandPart *)ic->parts.head;
+	g_assert(cp);
+	ic->current = cp;
+
+	/* how to handle exceptions here? */
+
+	printf("queueing command \"%c%05u %s\"\n", imap->tagprefix, ic->tag, cp->data);
+	camel_stream_printf((CamelStream *)imap->stream, "%c%05u %s\r\n", imap->tagprefix, ic->tag, cp->data);
+
+	if (cp->type & CAMEL_IMAPP_COMMAND_CONTINUATION) {
+		printf("%p: active literal\n", ic);
+		g_assert(cp->next);
+		imap->literal = ic;
+		e_dlist_addtail(&imap->active, (EDListNode *)ic);
+	} else {
+		printf("%p: active non-literal\n", ic);
+		g_assert(cp->next && cp->next->next == NULL);
+		e_dlist_addtail(&imap->active, (EDListNode *)ic);
+	}
+}
+
+CamelIMAPPCommand *
+camel_imapp_engine_command_find (CamelIMAPPEngine *imap, const char *name)
+{
+	CamelIMAPPCommand *ic, *in;
+
+	ic = imap->literal;
+	if (ic && strcmp(ic->name, name) == 0)
+		return ic;
+
+	/* first, try active */
+	ic = (CamelIMAPPCommand *)imap->active.head;
+	in = ic->next;
+	while (in) {
+		if (strcmp(ic->name, name) == 0)
+			return ic;
+		ic = in;
+		in = in->next;
+	}
+
+	return NULL;
+}
+
+CamelIMAPPCommand *
+camel_imapp_engine_command_find_tag(CamelIMAPPEngine *imap, unsigned int tag)
+{
+	CamelIMAPPCommand *ic, *in;
+
+	ic = imap->literal;
+	if (ic && ic->tag == tag)
+		return ic;
+
+	ic = (CamelIMAPPCommand *)imap->active.head;
+	in = ic->next;
+	while (in) {
+		if (ic->tag == tag)
+			return ic;
+		ic = in;
+		in = in->next;
+	}
+
+	return NULL;
+}
+
+/* ********************************************************************** */
+
+CamelIMAPPSelectResponse *
+camel_imapp_engine_select(CamelIMAPPEngine *imap, const char *name)
+{
+	CamelIMAPPSelectResponse * volatile resp;
+	CamelIMAPPCommand * volatile ic = NULL;
+
+	resp = g_malloc0(sizeof(*resp));
+	imap->select_response = resp;
+
+	CAMEL_TRY {
+		ic = camel_imapp_engine_command_new(imap, "SELECT", NULL, "SELECT %s", name);
+		camel_imapp_engine_command_queue(imap, ic);
+		while (camel_imapp_engine_iterate(imap, ic) > 0)
+			;
+
+		if (ic->status->result != IMAP_OK)
+			camel_exception_throw(1, "select failed: %s", ic->status->text);
+		resp->status = ic->status;
+		ic->status = NULL;
+	} CAMEL_CATCH (e) {
+		camel_imapp_engine_command_free(imap, ic);
+		camel_imapp_engine_select_free(imap, resp);
+		imap->select_response = NULL;
+		camel_exception_throw_ex(e);
+	} CAMEL_DONE;
+
+	camel_imapp_engine_command_free(imap, ic);
+	imap->select_response = NULL;
+
+	return resp;
+}
+
+void
+camel_imapp_engine_select_free(CamelIMAPPEngine *imap, CamelIMAPPSelectResponse *select)
+{
+	if (select) {
+		imap_free_status(select->status);
+		g_free(select);
+	}
+}
+
+/* ********************************************************************** */
+
+static void
+imap_engine_command_add_part(CamelIMAPPEngine *imap, CamelIMAPPCommand *ic, camel_imapp_command_part_t type, CamelObject *ob)
+{
+	CamelIMAPPCommandPart *cp;
+	CamelStreamNull *null;
+	unsigned int ob_size = 0;
+	
+	switch(type & CAMEL_IMAPP_COMMAND_MASK) {
+	case CAMEL_IMAPP_COMMAND_DATAWRAPPER:
+	case CAMEL_IMAPP_COMMAND_STREAM:
+		null = (CamelStreamNull *)camel_stream_null_new();
+		if ( (type & CAMEL_IMAPP_COMMAND_MASK) == CAMEL_IMAPP_COMMAND_DATAWRAPPER) {
+			camel_data_wrapper_write_to_stream((CamelDataWrapper *)ob, (CamelStream *)null);
+		} else {
+			camel_stream_reset((CamelStream *)ob);
+			camel_stream_write_to_stream((CamelStream *)ob, (CamelStream *)null);
+			camel_stream_reset((CamelStream *)ob);
+		}
+		type |= CAMEL_IMAPP_COMMAND_CONTINUATION;
+		camel_object_ref(ob);
+		ob_size = null->written;
+		camel_object_unref((CamelObject *)null);
+		camel_stream_printf((CamelStream *)ic->mem, "{%u}", ob_size);
+		break;
+	case CAMEL_IMAPP_COMMAND_AUTH:
+		/* we presume we'll need to get additional data only if we're not authenticated yet */
+		camel_object_ref(ob);
+		camel_stream_printf((CamelStream *)ic->mem, "%s", ((CamelSasl *)ob)->mech);
+		if (!camel_sasl_authenticated((CamelSasl *)ob))
+			type |= CAMEL_IMAPP_COMMAND_CONTINUATION;
+		break;
+	default:
+		ob_size = 0;
+	}
+
+	cp = g_malloc0(sizeof(*cp));
+	cp->type = type;
+	cp->ob_size = ob_size;
+	cp->ob = ob;
+	cp->data_size = ic->mem->buffer->len;
+	cp->data = g_malloc(cp->data_size+1);
+	memcpy(cp->data, ic->mem->buffer->data, cp->data_size);
+	cp->data[cp->data_size] = 0;
+
+	camel_stream_reset((CamelStream *)ic->mem);
+	/* FIXME: hackish? */
+	g_byte_array_set_size(ic->mem->buffer, 0);
+
+	e_dlist_addtail(&ic->parts, (EDListNode *)cp);
+}
+
+static int len(EDList *list)
+{
+	int count = 0;
+	EDListNode *n = list->head;
+
+	while (n->next) {
+		n = n->next;
+		count++;
+	}
+	return count;
+}
+
+static void
+imap_engine_command_complete(CamelIMAPPEngine *imap, CamelIMAPPCommand *ic)
+{
+	c(printf("completing command buffer is [%d] '%.*s'\n", ic->mem->buffer->len, (int)ic->mem->buffer->len, ic->mem->buffer->data));
+	c(printf("command has %d parts\n", len(&ic->parts)));
+	if (ic->mem->buffer->len > 0)
+		imap_engine_command_add_part(imap, ic, CAMEL_IMAPP_COMMAND_SIMPLE, NULL);
+	
+	c(printf("command has %d parts\n", len(&ic->parts)));
+
+	camel_object_unref((CamelObject *)ic->mem);
+	ic->mem = NULL;
+}
+
+static void
+imap_engine_command_addv(CamelIMAPPEngine *imap, CamelIMAPPCommand *ic, const char *fmt, va_list ap)
+{
+	const unsigned char *p, *ps, *start;
+	unsigned char c;
+	unsigned int width;
+	char ch;
+	int llong;
+	int left;
+	int fill;
+	int zero;
+	char *s;
+	int d;
+	long int l;
+	guint32 f;
+	CamelStream *S;
+	CamelDataWrapper *D;
+	CamelSasl *A;
+	char buffer[16];
+
+	c(printf("adding command, fmt = '%s'\n", fmt));
+
+	p = fmt;
+	ps = fmt;
+	while ( ( c = *p++ ) ) {
+		switch(c) {
+		case '%':
+			if (*p == '%') {
+				camel_stream_write((CamelStream *)ic->mem, ps, p-ps);
+				p++;
+				ps = p;
+			} else {
+				camel_stream_write((CamelStream *)ic->mem, ps, p-ps-1);
+				start = p-1;
+				width = 0;
+				left = FALSE;
+				fill = FALSE;
+				zero = FALSE;
+				llong = FALSE;
+
+				do {
+					c = *p++;
+					if (c == '0')
+						zero = TRUE;
+					else if ( c== '-')
+						left = TRUE;
+					else
+						break;
+				} while (c);
+
+				do {
+					if (isdigit(c))
+						width = width * 10 + (c-'0');
+					else
+						break;
+				} while ((c = *p++));
+
+				if (c == 'l') {
+					llong = TRUE;
+					c = *p++;
+				}
+
+				switch(c) {
+				case 'A': /* auth object - sasl auth, treat as special kind of continuation */
+					A = va_arg(ap, CamelSasl *);
+					imap_engine_command_add_part(imap, ic, CAMEL_IMAPP_COMMAND_AUTH, (CamelObject *)A);
+					break;
+				case 'S': /* stream */
+					S = va_arg(ap, CamelStream *);
+					c(printf("got stream '%p'\n", S));
+					imap_engine_command_add_part(imap, ic, CAMEL_IMAPP_COMMAND_STREAM, (CamelObject *)S);
+					break;
+				case 'D': /* datawrapper */
+					D = va_arg(ap, CamelDataWrapper *);
+					c(printf("got data wrapper '%p'\n", D));
+					imap_engine_command_add_part(imap, ic, CAMEL_IMAPP_COMMAND_DATAWRAPPER, (CamelObject *)D);
+					break;
+				case 't': /* token */
+					s = va_arg(ap, char *);
+					camel_stream_write((CamelStream *)ic->mem, s, strlen(s));
+					break;
+				case 's': /* simple string */
+					s = va_arg(ap, char *);
+					c(printf("got string '%s'\n", s));
+					/* FIXME: escpae chars, convert to literal or literal+, etc */
+					camel_stream_printf((CamelStream *)ic->mem, "\"%s\"", s);
+					break;
+				case 'f': /* imap folder name */
+					s = va_arg(ap, char *);
+					c(printf("got folder '%s'\n", s));
+					/* FIXME: encode folder name */
+					/* FIXME: namespace? */
+					camel_stream_printf((CamelStream *)ic->mem, "\"%s\"", s?s:"");
+					break;
+				case 'F': /* IMAP flags set */
+					f = va_arg(ap, guint32);
+					imap_write_flags((CamelStream *)ic->mem, f);
+					break;
+				case 'c':
+					d = va_arg(ap, int);
+					ch = d;
+					camel_stream_write((CamelStream *)ic->mem, &ch, 1);
+					break;
+				case 'd': /* int/unsigned */
+				case 'u':
+					if (llong) {
+						l = va_arg(ap, long int);
+						c(printf("got long int '%d'\n", (int)l));
+						memcpy(buffer, start, p-start);
+						buffer[p-start] = 0;
+						camel_stream_printf((CamelStream *)ic->mem, buffer, l);
+					} else {
+						d = va_arg(ap, int);
+						c(printf("got int '%d'\n", d));
+						memcpy(buffer, start, p-start);
+						buffer[p-start] = 0;
+						camel_stream_printf((CamelStream *)ic->mem, buffer, d);
+					}
+					break;
+				}
+
+				ps = p;
+			}
+			break;
+		case '\\':	/* only for \\ really, we dont support \n\r etc at all */
+			c = *p;
+			if (c) {
+				g_assert(c == '\\');
+				camel_stream_write((CamelStream *)ic->mem, ps, p-ps);
+				p++;
+				ps = p;
+			}
+		}
+	}
+
+	camel_stream_write((CamelStream *)ic->mem, ps, p-ps-1);
+}
+
+
+/* here temporarily while its experimental */
+
+
+#ifdef ENABLE_THREADS
+#include <pthread.h>
+
+static pthread_key_t handler_key = 0;
+
+void camel_exception_setup(void)
+{
+	pthread_key_create(&handler_key, NULL);
+}
+
+#else
+/* this is per-thread in threaded mode */
+static struct _CamelExceptionEnv *handler = NULL;
+
+void camel_exception_setup(void)
+{
+}
+#endif
+
+void
+camel_exception_try(struct _CamelExceptionEnv *env)
+{
+#ifdef ENABLE_THREADS
+	struct _CamelExceptionEnv *handler;
+
+	handler = pthread_getspecific(handler_key);
+#endif
+	env->parent = handler;
+	handler = env;
+	env->ex = NULL;
+
+#ifdef ENABLE_THREADS
+	pthread_setspecific(handler_key, handler);
+#endif
+}
+
+void
+camel_exception_throw_ex(CamelException *ex)
+{
+	struct _CamelExceptionEnv *env;
+#ifdef ENABLE_THREADS
+	struct _CamelExceptionEnv *handler;
+
+	handler = pthread_getspecific(handler_key);
+#endif
+	printf("throwing exception '%s'\n", ex->desc);
+
+	env = handler;
+	if (env != NULL) {
+		env->ex = ex;
+		handler = env->parent;
+#ifdef ENABLE_THREADS
+		pthread_setspecific(handler_key, handler);
+#endif
+		longjmp(env->env, ex->id);
+	} else {
+		g_warning("Uncaught exception: %s\n", ex->desc);
+		/* we just crash and burn, this is a code problem */
+		/* we dont use g_assert_not_reached() since its not a noreturn function */
+		abort();
+	}
+}
+
+void
+camel_exception_throw(int id, char *fmt, ...)
+{
+	CamelException *ex;
+	va_list ap;
+
+	ex = camel_exception_new();
+	ex->id = id;
+	va_start(ap, fmt);
+	ex->desc = g_strdup_vprintf(fmt, ap);
+	va_end(ap);
+
+	camel_exception_throw_ex(ex);
+}
+
+void
+camel_exception_drop(struct _CamelExceptionEnv *env)
+{
+#ifdef ENABLE_THREADS
+	pthread_setspecific(handler_key, env->parent);
+#else
+	handler = env->parent;
+#endif
+}
+
+void
+camel_exception_done(struct _CamelExceptionEnv *env)
+{
+#ifdef ENABLE_THREADS
+	pthread_setspecific(handler_key, env->parent);
+#else
+	handler = env->parent;
+#endif
+	if (env->ex != NULL) {
+		camel_exception_free(env->ex);
+	}
+}