
#include <ctype.h>
#include <errno.h>
#include <string.h>

#include <camel/camel-folder-summary.h>
#include <camel/camel-store.h>
#include <camel/camel-utf8.h>

#include "camel-imapp-folder.h"
#include "camel-imapp-stream.h"
#include "camel-imapp-utils.h"
#include "camel-imapp-exception.h"
#include "camel-imapp-engine.h"
#include "e-util/e-memory.h"

/* high-level parser state */
#define p(x)
/* debug */
#define d(x)

/* ANSI-C code produced by gperf version 2.7 */
/* Command-line: gperf -H imap_hash -N imap_tokenise -L ANSI-C -o -t -k1,$ imap-tokens.txt  */
struct _imap_keyword { char *name; enum _imap_id id; };
/*
 gperf input file
 best hash generated using: gperf -o -s-2 -k1,'$' -t -H imap_hash -N imap_tokenise -L ANSI-C 
*/

#define TOTAL_KEYWORDS 23
#define MIN_WORD_LENGTH 2
#define MAX_WORD_LENGTH 14
#define MIN_HASH_VALUE 2
#define MAX_HASH_VALUE 38
/* maximum key range = 37, duplicates = 0 */

#ifdef __GNUC__
__inline
#endif
static unsigned int
imap_hash (register const char *str, register unsigned int len)
{
  static unsigned char asso_values[] =
    {
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 10, 15, 39, 20,  0,
       0, 39,  0, 10, 39,  0, 39, 39, 10,  0,
       0, 39,  0, 10,  5, 10, 39, 39, 39,  0,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
      39, 39, 39, 39, 39, 39
    };
  return len + asso_values[(unsigned char)str[len - 1]] + asso_values[(unsigned char)str[0]];
}

#ifdef __GNUC__
__inline
#endif
enum _imap_id
imap_tokenise (register const char *str, register unsigned int len)
{
  static struct _imap_keyword wordlist[] =
    {
      {""}, {""},
      {"OK",		IMAP_OK},
      {""}, {""},
      {"PARSE",		IMAP_PARSE},
      {""},
      {"PREAUTH",	IMAP_PREAUTH},
      {"ENVELOPE",	IMAP_ENVELOPE},
      {"READ-ONLY",	IMAP_READ_ONLY},
      {"READ-WRITE",	IMAP_READ_WRITE},
      {"RFC822.SIZE",	IMAP_RFC822_SIZE},
      {"NO",		IMAP_NO},
      {"RFC822.HEADER",	IMAP_RFC822_HEADER},
      {"TRYCREATE",	IMAP_TRYCREATE},
      {"FLAGS",		IMAP_FLAGS},
      {"RFC822.TEXT",	IMAP_RFC822_TEXT},
      {"NEWNAME",	IMAP_NEWNAME},
      {"BYE",		IMAP_BYE},
      {"BODY",		IMAP_BODY},
      {"ALERT",          IMAP_ALERT},
      {"UIDVALIDITY",	IMAP_UIDVALIDITY},
      {"INTERNALDATE",	IMAP_INTERNALDATE},
      {""},
      {"PERMANENTFLAGS",	IMAP_PERMANENTFLAGS},
      {""},
      {"UNSEEN",		IMAP_UNSEEN},
      {""},
      {"BODYSTRUCTURE",	IMAP_BODYSTRUCTURE},
      {""}, {""}, {""}, {""},
      {"UID",		IMAP_UID},
      {""}, {""}, {""}, {""},
      {"BAD",		IMAP_BAD}
    };

  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
    {
      register int key = imap_hash (str, len);

      if (key <= MAX_HASH_VALUE && key >= 0)
        {
          register const char *s = wordlist[key].name;

          if (*str == *s && !strcmp (str + 1, s + 1))
            return wordlist[key].id;
        }
    }
  return 0;
}

/* flag table */
static struct {
	char *name;
	guint32 flag;
} flag_table[] = {
	{ "\\ANSWERED", CAMEL_MESSAGE_ANSWERED },
	{ "\\DELETED", CAMEL_MESSAGE_DELETED },
	{ "\\DRAFT", CAMEL_MESSAGE_DRAFT },
	{ "\\FLAGGED", CAMEL_MESSAGE_FLAGGED },
	{ "\\SEEN", CAMEL_MESSAGE_SEEN },
	{ "\\RECENT", CAMEL_IMAPP_MESSAGE_RECENT },
	{ "\\*", CAMEL_MESSAGE_USER },
};

/* utility functions
   shoudl this be part of imapp-driver? */
/* mabye this should be a stream op? */
void
imap_parse_flags(CamelIMAPPStream *stream, guint32 *flagsp)
/* throws IO,PARSE exception */
{
	int tok, len, i;
	unsigned char *token, *p, c;
	guint32 flags = 0;

	*flagsp = flags;

	tok = camel_imapp_stream_token(stream, &token, &len);
	if (tok == '(') {
		do {
			tok = camel_imapp_stream_token(stream, &token, &len);
			if (tok == IMAP_TOK_TOKEN) {
				p = token;
				while ((c=*p))
					*p++ = toupper(c);
				for (i=0;i<(int)(sizeof(flag_table)/sizeof(flag_table[0]));i++)
					if (!strcmp(token, flag_table[i].name))
						flags |= flag_table[i].flag;
			} else if (tok != ')') {
				camel_exception_throw(1, "expecting flag");
			}
		} while (tok != ')');
	} else {
		camel_exception_throw(1, "expecting flag list");
	}

	*flagsp = flags;
}

void
imap_write_flags(CamelStream *stream, guint32 flags)
/* throws IO exception */
{
	int i;

	/* all this ugly exception throwing goes away once camel streams throw their own? */
	if (camel_stream_write(stream, "(", 1) == -1)
		camel_exception_throw(1, "io error: %s", strerror(errno));

	for (i=0;flags!=0 && i<(int)(sizeof(flag_table)/sizeof(flag_table[0]));i++) {
		if (flag_table[i].flag & flags) {
			if (camel_stream_write(stream, flag_table[i].name, strlen(flag_table[i].name)) == -1)
				camel_exception_throw(1, "io error: %s", strerror(errno));
			flags &= ~flag_table[i].flag;
			if (flags != 0)
				if (camel_stream_write(stream, " ", 1) == -1)
					camel_exception_throw(1, "io error: %s", strerror(errno));
		}
	}

	if (camel_stream_write(stream, ")", 1) == -1)
		camel_exception_throw(1, "io error: %s", strerror(errno));
}

/*
body            ::= "(" body_type_1part / body_type_mpart ")"

body_extension  ::= nstring / number / "(" 1#body_extension ")"
                    ;; Future expansion.  Client implementations
                    ;; MUST accept body_extension fields.  Server
                    ;; implementations MUST NOT generate
                    ;; body_extension fields except as defined by
                    ;; future standard or standards-track
                    ;; revisions of this specification.

body_ext_1part  ::= body_fld_md5 [SPACE body_fld_dsp
                    [SPACE body_fld_lang
                    [SPACE 1#body_extension]]]
                    ;; MUST NOT be returned on non-extensible
                    ;; "BODY" fetch

body_ext_mpart  ::= body_fld_param
                    [SPACE body_fld_dsp SPACE body_fld_lang
                    [SPACE 1#body_extension]]
                    ;; MUST NOT be returned on non-extensible
                    ;; "BODY" fetch

body_fields     ::= body_fld_param SPACE body_fld_id SPACE
                    body_fld_desc SPACE body_fld_enc SPACE
                    body_fld_octets

body_fld_desc   ::= nstring

body_fld_dsp    ::= "(" string SPACE body_fld_param ")" / nil

body_fld_enc    ::= (<"> ("7BIT" / "8BIT" / "BINARY" / "BASE64"/
                    "QUOTED-PRINTABLE") <">) / string

body_fld_id     ::= nstring

body_fld_lang   ::= nstring / "(" 1#string ")"

body_fld_lines  ::= number

body_fld_md5    ::= nstring

body_fld_octets ::= number

body_fld_param  ::= "(" 1#(string SPACE string) ")" / nil

body_type_1part ::= (body_type_basic / body_type_msg / body_type_text)
                    [SPACE body_ext_1part]

body_type_basic ::= media_basic SPACE body_fields
                    ;; MESSAGE subtype MUST NOT be "RFC822"

body_type_mpart ::= 1*body SPACE media_subtype
                    [SPACE body_ext_mpart]

body_type_msg   ::= media_message SPACE body_fields SPACE envelope
                    SPACE body SPACE body_fld_lines

body_type_text  ::= media_text SPACE body_fields SPACE body_fld_lines

envelope        ::= "(" env_date SPACE env_subject SPACE env_from
                    SPACE env_sender SPACE env_reply_to SPACE env_to
                    SPACE env_cc SPACE env_bcc SPACE env_in_reply_to
                    SPACE env_message_id ")"

env_bcc         ::= "(" 1*address ")" / nil

env_cc          ::= "(" 1*address ")" / nil

env_date        ::= nstring

env_from        ::= "(" 1*address ")" / nil

env_in_reply_to ::= nstring

env_message_id  ::= nstring

env_reply_to    ::= "(" 1*address ")" / nil

env_sender      ::= "(" 1*address ")" / nil

env_subject     ::= nstring

env_to          ::= "(" 1*address ")" / nil

media_basic     ::= (<"> ("APPLICATION" / "AUDIO" / "IMAGE" /
                    "MESSAGE" / "VIDEO") <">) / string)
                    SPACE media_subtype
                    ;; Defined in [MIME-IMT]

media_message   ::= <"> "MESSAGE" <"> SPACE <"> "RFC822" <">
                    ;; Defined in [MIME-IMT]

media_subtype   ::= string
                    ;; Defined in [MIME-IMT]

media_text      ::= <"> "TEXT" <"> SPACE media_subtype
                    ;; Defined in [MIME-IMT]



 ( "type" "subtype"  body_fields [envelope body body_fld_lines]
                                 [body_fld_lines]



 (("TEXT" "PLAIN" ("CHARSET"
                     "US-ASCII") NIL NIL "7BIT" 1152 23)("TEXT" "PLAIN"
                     ("CHARSET" "US-ASCII" "NAME" "cc.diff")
                     "<960723163407.20117h@cac.washington.edu>"
                     "Compiler diff" "BASE64" 4554 73) "MIXED"))

*/

/*
struct _body_fields {
	CamelContentType *ct;
	char *msgid, *desc;
	CamelTransferEncoding encoding;
	guint32 size;
	};*/

void
imap_free_body(struct _CamelMessageContentInfo *cinfo)
{
	struct _CamelMessageContentInfo *list, *next;

	list = cinfo->childs;
	while (list) {
		next = list->next;
		imap_free_body(list);
		list = next;
	}
	
	if (cinfo->type)
		camel_content_type_unref(cinfo->type);
	g_free(cinfo->id);
	g_free(cinfo->description);
	g_free(cinfo->encoding);
	g_free(cinfo);
}

void
imap_parse_param_list(CamelIMAPPStream *is, struct _camel_header_param **plist)
{
	int tok, len;
	unsigned char *token, *param;

	p(printf("body_fld_param\n"));

	/* body_fld_param  ::= "(" 1#(string SPACE string) ")" / nil */
	tok = camel_imapp_stream_token(is, &token, &len);
	if (tok == '(') {
		while (1) {
			tok = camel_imapp_stream_token(is, &token, &len);
			if (tok == ')')
				break;
			camel_imapp_stream_ungettoken(is, tok, token, len);
			
			camel_imapp_stream_astring(is, &token);
			param = alloca(strlen(token)+1);
			strcpy(param, token);
			camel_imapp_stream_astring(is, &token);
			camel_header_set_param(plist, param, token);
		}
	} /* else check nil?  no need */
}

struct _CamelContentDisposition *
imap_parse_ext_optional(CamelIMAPPStream *is)
{
	int tok, len;
	unsigned char *token;
	struct _CamelContentDisposition * volatile dinfo = NULL;

	/* this parses both extension types, from the body_fld_dsp onwards */
	/* although the grammars are different, they can be parsed the same way */

	/* body_ext_1part  ::= body_fld_md5 [SPACE body_fld_dsp
	   [SPACE body_fld_lang
	   [SPACE 1#body_extension]]]
	   ;; MUST NOT be returned on non-extensible
	   ;; "BODY" fetch */

	/* body_ext_mpart  ::= body_fld_param
	   [SPACE body_fld_dsp SPACE body_fld_lang
	   [SPACE 1#body_extension]]
	   ;; MUST NOT be returned on non-extensible
	   ;; "BODY" fetch */

	CAMEL_TRY {
		/* body_fld_dsp    ::= "(" string SPACE body_fld_param ")" / nil */

		tok = camel_imapp_stream_token(is, &token, &len);
		switch (tok) {
		case '(':
			dinfo = g_malloc0(sizeof(*dinfo));
			dinfo->refcount = 1;
			/* should be string */
			camel_imapp_stream_astring(is, &token);
		
			dinfo->disposition = g_strdup(token);
			imap_parse_param_list(is, &dinfo->params);
		case IMAP_TOK_TOKEN:
			d(printf("body_fld_dsp: NIL\n"));
			break;
		default:
			camel_exception_throw(1, "body_fld_disp: expecting nil or list");
		}
	
		p(printf("body_fld_lang\n"));

		/* body_fld_lang   ::= nstring / "(" 1#string ")" */
	
		/* we just drop the lang string/list, save it somewhere? */
	
		tok = camel_imapp_stream_token(is, &token, &len);
		switch (tok) {
		case '(':
			while (1) {
				tok = camel_imapp_stream_token(is, &token, &len);
				if (tok == ')') {
					break;
				} else if (tok != IMAP_TOK_STRING) {
					camel_exception_throw(1, "expecting string");
				}
			}
			break;
		case IMAP_TOK_TOKEN:
			d(printf("body_fld_lang = nil\n"));
			/* treat as 'nil' */
			break;
		case IMAP_TOK_STRING:
			/* we have a string */
			break;
		case IMAP_TOK_LITERAL:
			/* we have a literal string */
			camel_imapp_stream_set_literal(is, len);
			while ((tok = camel_imapp_stream_getl(is, &token, &len)) > 0) {
				d(printf("Skip literal data '%.*s'\n", (int)len, token));
			}
			break;

		}
	} CAMEL_CATCH(ex) {
		if (dinfo)
			camel_content_disposition_unref(dinfo);
		camel_exception_throw_ex(ex);
	} CAMEL_DONE;

	return dinfo;
}

struct _CamelMessageContentInfo *
imap_parse_body_fields(CamelIMAPPStream *is)
{
	unsigned char *token, *type;
	struct _CamelMessageContentInfo *cinfo;
		
	/* body_fields     ::= body_fld_param SPACE body_fld_id SPACE
	   body_fld_desc SPACE body_fld_enc SPACE
	   body_fld_octets */

	p(printf("body_fields\n"));

	cinfo = g_malloc0(sizeof(*cinfo));

	CAMEL_TRY {
		/* this should be string not astring */
		camel_imapp_stream_astring(is, &token);
		type = alloca(strlen(token)+1);
		strcpy(type, token);
		camel_imapp_stream_astring(is, &token);
		cinfo->type = camel_content_type_new(type, token);
		imap_parse_param_list(is, &cinfo->type->params);
	
		/* body_fld_id     ::= nstring */
		camel_imapp_stream_nstring(is, &token);
		cinfo->id = g_strdup(token);
	
		/* body_fld_desc   ::= nstring */
		camel_imapp_stream_nstring(is, &token);
		cinfo->description = g_strdup(token);
	
		/* body_fld_enc    ::= (<"> ("7BIT" / "8BIT" / "BINARY" / "BASE64"/
		   "QUOTED-PRINTABLE") <">) / string */
		camel_imapp_stream_astring(is, &token);
		cinfo->encoding = g_strdup(token);
	
		/* body_fld_octets ::= number */
		cinfo->size = camel_imapp_stream_number(is);
	} CAMEL_CATCH(ex) {
		imap_free_body(cinfo);
		camel_exception_throw_ex(ex);
	} CAMEL_DONE;

	return cinfo;
}

struct _camel_header_address *
imap_parse_address_list(CamelIMAPPStream *is)
/* throws PARSE,IO exception */
{
	int tok, len;
	unsigned char *token, *host, *mbox;
	struct _camel_header_address *list = NULL;

	/* "(" 1*address ")" / nil */

	CAMEL_TRY {
		tok = camel_imapp_stream_token(is, &token, &len);
		if (tok == '(') {
			while (1) {
				struct _camel_header_address *addr, *group = NULL;

				/* address         ::= "(" addr_name SPACE addr_adl SPACE addr_mailbox
				   SPACE addr_host ")" */
				tok = camel_imapp_stream_token(is, &token, &len);
				if (tok == ')')
					break;
				if (tok != '(')
					camel_exception_throw(1, "missing '(' for address");

				addr = camel_header_address_new();
				addr->type = CAMEL_HEADER_ADDRESS_NAME;
				tok = camel_imapp_stream_nstring(is, &token);
				addr->name = g_strdup(token);
				/* we ignore the route, nobody uses it in the real world */
				tok = camel_imapp_stream_nstring(is, &token);

				/* [RFC-822] group syntax is indicated by a special
				   form of address structure in which the host name
				   field is NIL.  If the mailbox name field is also
				   NIL, this is an end of group marker (semi-colon in
				   RFC 822 syntax).  If the mailbox name field is
				   non-NIL, this is a start of group marker, and the
				   mailbox name field holds the group name phrase. */

				tok = camel_imapp_stream_nstring(is, &mbox);
				mbox = g_strdup(mbox);
				tok = camel_imapp_stream_nstring(is, &host);
				if (host == NULL) {
					if (mbox == NULL) {
						group = NULL;
					} else {
						d(printf("adding group '%s'\n", mbox));
						g_free(addr->name);
						addr->name = mbox;
						addr->type = CAMEL_HEADER_ADDRESS_GROUP;
						camel_header_address_list_append(&list, addr);
						group = addr;
					}
				} else {
					addr->v.addr = g_strdup_printf("%s%s%s", mbox?(char *)mbox:"", host?"@":"", host?(char *)host:"");
					g_free(mbox);
					d(printf("adding address '%s'\n", addr->v.addr));
					if (group != NULL)
						camel_header_address_add_member(group, addr);
					else
						camel_header_address_list_append(&list, addr);
				}
				do {
					tok = camel_imapp_stream_token(is, &token, &len);
				} while (tok != ')');
			}
		} else {
			d(printf("empty, nil '%s'\n", token));
		}
	} CAMEL_CATCH(ex) {
		camel_header_address_list_clear(&list);
		camel_exception_throw_ex(ex);
	} CAMEL_DONE;

	return list;
}

struct _CamelMessageInfo *
imap_parse_envelope(CamelIMAPPStream *is)
{
	int tok, len;
	unsigned char *token;
	struct _camel_header_address *addr, *addr_from;
	char *addrstr;
	struct _CamelMessageInfo *minfo;

	/* envelope        ::= "(" env_date SPACE env_subject SPACE env_from
	   SPACE env_sender SPACE env_reply_to SPACE env_to
	   SPACE env_cc SPACE env_bcc SPACE env_in_reply_to
	   SPACE env_message_id ")" */

	p(printf("envelope\n"));

	minfo = camel_message_info_new();

	CAMEL_TRY {
		tok = camel_imapp_stream_token(is, &token, &len);
		if (tok != '(')
			camel_exception_throw(1, "envelope: expecting '('");

		/* env_date        ::= nstring */
		camel_imapp_stream_nstring(is, &token);
		minfo->date_sent = camel_header_decode_date(token, NULL);

		/* env_subject     ::= nstring */
		tok = camel_imapp_stream_nstring(is, &token);
		/* DUH: this free's it!: camel_message_info_set_subject(minfo, token); */
		e_poolv_set(minfo->strings, CAMEL_MESSAGE_INFO_SUBJECT, token, FALSE);

		/* we merge from/sender into from, append should probably merge more smartly? */

		/* env_from        ::= "(" 1*address ")" / nil */
		addr_from = imap_parse_address_list(is);

		/* env_sender      ::= "(" 1*address ")" / nil */
		addr = imap_parse_address_list(is);
		if (addr_from) {
			camel_header_address_list_clear(&addr);
#if 0
			if (addr)
				camel_header_address_list_append_list(&addr_from, &addr);
#endif
		} else {
			if (addr)
				addr_from = addr;
		}

		if (addr_from) {
			addrstr = camel_header_address_list_format(addr_from);
			camel_message_info_set_from(minfo, addrstr);
			camel_header_address_list_clear(&addr_from);
		}

		/* we dont keep reply_to */

		/* env_reply_to    ::= "(" 1*address ")" / nil */
		addr = imap_parse_address_list(is);
		camel_header_address_list_clear(&addr);

		/* env_to          ::= "(" 1*address ")" / nil */
		addr = imap_parse_address_list(is);
		if (addr) {
			addrstr = camel_header_address_list_format(addr);
			camel_message_info_set_to(minfo, addrstr);
			camel_header_address_list_clear(&addr);
		}

		/* env_cc          ::= "(" 1*address ")" / nil */
		addr = imap_parse_address_list(is);
		if (addr) {
			addrstr = camel_header_address_list_format(addr);
			camel_message_info_set_cc(minfo, addrstr);
			camel_header_address_list_clear(&addr);
		}

		/* we dont keep bcc either */

		/* env_bcc         ::= "(" 1*address ")" / nil */
		addr = imap_parse_address_list(is);
		camel_header_address_list_clear(&addr);

		/* FIXME: need to put in-reply-to into references hash list */

		/* env_in_reply_to ::= nstring */
		tok = camel_imapp_stream_nstring(is, &token);

		/* FIXME: need to put message-id into message-id hash */

		/* env_message_id  ::= nstring */
		tok = camel_imapp_stream_nstring(is, &token);

		tok = camel_imapp_stream_token(is, &token, &len);
		if (tok != ')')
			camel_exception_throw(1, "expecting ')'");
	} CAMEL_CATCH(ex) {
		camel_message_info_free(minfo);
		camel_exception_throw_ex(ex);
	} CAMEL_DONE;

	return minfo;
}
	
struct _CamelMessageContentInfo *
imap_parse_body(CamelIMAPPStream *is)
{
	int tok, len;
	unsigned char *token;
	struct _CamelMessageContentInfo * volatile cinfo = NULL;
	struct _CamelMessageContentInfo *subinfo, *last;
	struct _CamelContentDisposition * volatile dinfo = NULL;
	struct _CamelMessageInfo * volatile minfo = NULL;

	/* body            ::= "(" body_type_1part / body_type_mpart ")" */

	p(printf("body\n"));

	CAMEL_TRY {
		tok = camel_imapp_stream_token(is, &token, &len);
		if (tok != '(')
			camel_exception_throw(1, "body: expecting '('");

		/* 1*body (optional for multiparts) */
		tok = camel_imapp_stream_token(is, &token, &len);
		camel_imapp_stream_ungettoken(is, tok, token, len);
		if (tok == '(') {
			/* body_type_mpart ::= 1*body SPACE media_subtype
			   [SPACE body_ext_mpart] */

			cinfo = g_malloc0(sizeof(*cinfo));
			last = (struct _CamelMessageContentInfo *)&cinfo->childs;
			do {
				subinfo = imap_parse_body(is);
				last->next = subinfo;
				last = subinfo;
				subinfo->parent = cinfo;
				tok = camel_imapp_stream_token(is, &token, &len);
				camel_imapp_stream_ungettoken(is, tok, token, len);
			} while (tok == '(');

			d(printf("media_subtype\n"));

			camel_imapp_stream_astring(is, &token);
			cinfo->type = camel_content_type_new("multipart", token);

			/* body_ext_mpart  ::= body_fld_param
			   [SPACE body_fld_dsp SPACE body_fld_lang
			   [SPACE 1#body_extension]]
			   ;; MUST NOT be returned on non-extensible
			   ;; "BODY" fetch */

			d(printf("body_ext_mpart\n"));

			tok = camel_imapp_stream_token(is, &token, &len);
			camel_imapp_stream_ungettoken(is, tok, token, len);
			if (tok == '(') {
				imap_parse_param_list(is, &cinfo->type->params);

				/* body_fld_dsp    ::= "(" string SPACE body_fld_param ")" / nil */

				tok = camel_imapp_stream_token(is, &token, &len);
				camel_imapp_stream_ungettoken(is, tok, token, len);
				if (tok == '(' || tok == IMAP_TOK_TOKEN) {
					dinfo = imap_parse_ext_optional(is);
					/* other extension fields?, soaked up below */
				} else {
					camel_imapp_stream_ungettoken(is, tok, token, len);
				}
			}
		} else {
			/* body_type_1part ::= (body_type_basic / body_type_msg / body_type_text)
			   [SPACE body_ext_1part]
			   
			   body_type_basic ::= media_basic SPACE body_fields
			   body_type_text  ::= media_text SPACE body_fields SPACE body_fld_lines
			   body_type_msg   ::= media_message SPACE body_fields SPACE envelope
			   SPACE body SPACE body_fld_lines */

			d(printf("Single part body\n"));

			cinfo = imap_parse_body_fields(is);

			d(printf("envelope?\n"));

			/* do we have an envelope following */
			tok = camel_imapp_stream_token(is, &token, &len);
			camel_imapp_stream_ungettoken(is, tok, token, len);
			if (tok == '(') {
				/* what do we do with the envelope?? */
				minfo = imap_parse_envelope(is);
				/* what do we do with the message content info?? */
				minfo->content = imap_parse_body(is);
				camel_message_info_free(minfo);
				minfo = NULL;
				d(printf("Scanned envelope - what do i do with it?\n"));
			}

			d(printf("fld_lines?\n"));

			/* do we have fld_lines following? */
			tok = camel_imapp_stream_token(is, &token, &len);
			if (tok == IMAP_TOK_INT) {
				d(printf("field lines: %s\n", token));
				tok = camel_imapp_stream_token(is, &token, &len);
			}
			camel_imapp_stream_ungettoken(is, tok, token, len);

			/* body_ext_1part  ::= body_fld_md5 [SPACE body_fld_dsp
			   [SPACE body_fld_lang
			   [SPACE 1#body_extension]]]
			   ;; MUST NOT be returned on non-extensible
			   ;; "BODY" fetch */

			d(printf("extension data?\n"));

			if (tok != ')') {
				camel_imapp_stream_nstring(is, &token);

				d(printf("md5: %s\n", token?(char *)token:"NIL"));

				/* body_fld_dsp    ::= "(" string SPACE body_fld_param ")" / nil */

				tok = camel_imapp_stream_token(is, &token, &len);
				camel_imapp_stream_ungettoken(is, tok, token, len);
				if (tok == '(' || tok == IMAP_TOK_TOKEN) {
					dinfo = imap_parse_ext_optional(is);
					/* then other extension fields, soaked up below */
				}
			}
		}

		/* soak up any other extension fields that may be present */
		/* there should only be simple tokens, no lists */
		do {
			tok = camel_imapp_stream_token(is, &token, &len);
			if (tok != ')')
				d(printf("Dropping extension data '%s'\n", token));
		} while (tok != ')');
	} CAMEL_CATCH(ex) {
		if (cinfo)
			imap_free_body(cinfo);
		if (dinfo)
			camel_content_disposition_unref(dinfo);
		if (minfo)
			camel_message_info_free(minfo);
		camel_exception_throw_ex(ex);
	} CAMEL_DONE;

	/* FIXME: do something with the disposition, currently we have no way to pass it out? */
	if (dinfo)
		camel_content_disposition_unref(dinfo);

	return cinfo;
}

char *
imap_parse_section(CamelIMAPPStream *is)
{
	int tok, len;
	unsigned char *token;
	char * volatile section = NULL;

	/* currently we only return the part within the [section] specifier
	   any header fields are parsed, but dropped */

	/*
	  section         ::= "[" [section_text /
	  (nz_number *["." nz_number] ["." (section_text / "MIME")])] "]"

	  section_text    ::= "HEADER" / "HEADER.FIELDS" [".NOT"]
	  SPACE header_list / "TEXT"
	*/

	CAMEL_TRY {
		tok = camel_imapp_stream_token(is, &token, &len);
		if (tok != '[')
			camel_exception_throw(1, "section: expecting '['");

		tok = camel_imapp_stream_token(is, &token, &len);
		if (tok == IMAP_TOK_INT || tok == IMAP_TOK_TOKEN)
			section = g_strdup(token);
		else if (tok == ']') {
			section = g_strdup("");
			camel_imapp_stream_ungettoken(is, tok, token, len);
		} else
			camel_exception_throw(1, "section: expecting token");

		/* header_list     ::= "(" 1#header_fld_name ")"
		   header_fld_name ::= astring */

		/* we dont need the header specifiers */
		tok = camel_imapp_stream_token(is, &token, &len);
		if (tok == '(') {
			do {
				tok = camel_imapp_stream_token(is, &token, &len);
				if (tok == IMAP_TOK_STRING || tok == IMAP_TOK_TOKEN || tok == IMAP_TOK_INT) {
					/* ?do something? */
				} else if (tok != ')')
					camel_exception_throw(1, "section: header fields: expecting string");
			} while (tok != ')');
			tok = camel_imapp_stream_token(is, &token, &len);
		}

		if (tok != ']')
			camel_exception_throw(1, "section: expecting ']'");
	} CAMEL_CATCH(ex) {
		g_free(section);
		camel_exception_throw_ex(ex);
	} CAMEL_DONE;

	return section;
}

void
imap_free_fetch(struct _fetch_info *finfo)
{
	if (finfo == NULL)
		return;

	if (finfo->body)
		camel_object_unref((CamelObject *)finfo->body);
	if (finfo->text)
		camel_object_unref((CamelObject *)finfo->text);
	if (finfo->header)
		camel_object_unref((CamelObject *)finfo->header);
	if (finfo->minfo)
		camel_message_info_free(finfo->minfo);
	if (finfo->cinfo)
		imap_free_body(finfo->cinfo);
	g_free(finfo->date);
	g_free(finfo->section);
	g_free(finfo->uid);
	g_free(finfo);
}

extern void camel_content_info_dump(CamelMessageContentInfo *ci, int depth);
extern void camel_message_info_dump(CamelMessageInfo *mi);

#include <camel/camel-stream-fs.h>

/* debug, dump one out */
void
imap_dump_fetch(struct _fetch_info *finfo)
{
	CamelStream *sout;
	int fd;

	printf("Fetch info:\n");
	if (finfo == NULL) {
		printf("Empty\n");
		return;
	}

	fd = dup(1);
	sout = camel_stream_fs_new_with_fd(fd);
	if (finfo->body) {
		camel_stream_printf(sout, "Body content:\n");
		camel_stream_write_to_stream(finfo->body, sout);
	}
	if (finfo->text) {
		camel_stream_printf(sout, "Text content:\n");
		camel_stream_write_to_stream(finfo->text, sout);
	}
	if (finfo->header) {
		camel_stream_printf(sout, "Header content:\n");
		camel_stream_write_to_stream(finfo->header, sout);
	}
	if (finfo->minfo) {
		camel_stream_printf(sout, "Message Info:\n");
		camel_message_info_dump(finfo->minfo);
	}
	if (finfo->cinfo) {
		camel_stream_printf(sout, "Content Info:\n");
		camel_content_info_dump(finfo->cinfo, 0);
	}
	if (finfo->got & FETCH_SIZE)
		camel_stream_printf(sout, "Size: %d\n", (int)finfo->size);
	if (finfo->got & FETCH_BODY)
		camel_stream_printf(sout, "Offset: %d\n", (int)finfo->offset);
	if (finfo->got & FETCH_FLAGS)
		camel_stream_printf(sout, "Flags: %08x\n", (int)finfo->flags);
	if (finfo->date)
		camel_stream_printf(sout, "Date: '%s'\n", finfo->date);
	if (finfo->section)
		camel_stream_printf(sout, "Section: '%s'\n", finfo->section);
	if (finfo->date)
		camel_stream_printf(sout, "UID: '%s'\n", finfo->uid);
	camel_object_unref((CamelObject *)sout);
}

struct _fetch_info *
imap_parse_fetch(CamelIMAPPStream *is)
{
	int tok, len;
	unsigned char *token, *p, c;
	struct _fetch_info *finfo;

	finfo = g_malloc0(sizeof(*finfo));

	CAMEL_TRY {
		tok = camel_imapp_stream_token(is, &token, &len);
		if (tok != '(')
			camel_exception_throw(1, "fetch: expecting '('");

		while ( (tok = camel_imapp_stream_token(is, &token, &len)) == IMAP_TOK_TOKEN ) {

			p = token;
			while ((c=*p))
				*p++ = toupper(c);

			switch(imap_tokenise(token, len)) {
			case IMAP_ENVELOPE:
				finfo->minfo = imap_parse_envelope(is);
				finfo->got |= FETCH_MINFO;
				break;
			case IMAP_FLAGS:
				imap_parse_flags(is, &finfo->flags);
				finfo->got |= FETCH_FLAGS;
				break;
			case IMAP_INTERNALDATE:
				camel_imapp_stream_nstring(is, &token);
				/* TODO: convert to camel format? */
				finfo->date = g_strdup(token);
				finfo->got |= FETCH_DATE;
				break;
			case IMAP_RFC822_HEADER:
				camel_imapp_stream_nstring_stream(is, &finfo->header);
				finfo->got |= FETCH_HEADER;
				break;
			case IMAP_RFC822_TEXT:
				camel_imapp_stream_nstring_stream(is, &finfo->text);
				finfo->got |= FETCH_TEXT;
				break;
			case IMAP_RFC822_SIZE:
				finfo->size = camel_imapp_stream_number(is);
				finfo->got |= FETCH_SIZE;
				break;
			case IMAP_BODYSTRUCTURE:
				finfo->cinfo = imap_parse_body(is);
				finfo->got |= FETCH_CINFO;
				break;
			case IMAP_BODY:
				tok = camel_imapp_stream_token(is, &token, &len);
				camel_imapp_stream_ungettoken(is, tok, token, len);
				if (tok == '(') {
					finfo->cinfo = imap_parse_body(is);
					finfo->got |= FETCH_CINFO;
				} else if (tok == '[') {
					finfo->section = imap_parse_section(is);
					finfo->got |= FETCH_SECTION;
					tok = camel_imapp_stream_token(is, &token, &len);
					if (token[0] == '<') {
						finfo->offset = strtoul(token+1, NULL, 10);
					} else {
						camel_imapp_stream_ungettoken(is, tok, token, len);
					}
					camel_imapp_stream_nstring_stream(is, &finfo->body);
					finfo->got |= FETCH_BODY;					
				} else {
					camel_exception_throw(1, "unknown body response");
				}
				break;
			case IMAP_UID:
				tok = camel_imapp_stream_token(is, &token, &len);
				if (tok != IMAP_TOK_INT)
					camel_exception_throw(1, "uid not integer");
				finfo->uid = g_strdup(token);
				finfo->got |= FETCH_UID;
				break;
			default:
				camel_exception_throw(1, "unknown body response");
			}
		}

		if (tok != ')')
			camel_exception_throw(1, "missing closing ')' on fetch response");
	} CAMEL_CATCH(ex) {
		imap_free_fetch(finfo);
		camel_exception_throw_ex(ex);
	} CAMEL_DONE;

	return finfo;
}

/* rfc 2060 section 7.1 Status Responses */
/* shoudl this start after [ or before the [? token_unget anyone? */
struct _status_info *
imap_parse_status(CamelIMAPPStream *is)
{
	int tok, len;
	unsigned char *token;
	struct _status_info *sinfo;

	sinfo = g_malloc0(sizeof(*sinfo));

	CAMEL_TRY {
		camel_imapp_stream_atom(is, &token, &len);

		/*
		  resp_cond_auth  ::= ("OK" / "PREAUTH") SPACE resp_text
		  ;; Authentication condition

		  resp_cond_bye   ::= "BYE" SPACE resp_text

		  resp_cond_state ::= ("OK" / "NO" / "BAD") SPACE resp_text
		  ;; Status condition
		*/

		sinfo->result = imap_tokenise(token, len);
		switch (sinfo->result) {
		case IMAP_OK:
		case IMAP_NO:
		case IMAP_BAD:
		case IMAP_PREAUTH:
		case IMAP_BYE:
			break;
		default:
			camel_exception_throw(1, "expecting OK/NO/BAD");
		}

		tok = camel_imapp_stream_token(is, &token, &len);
		if (tok == '[') {
			camel_imapp_stream_atom(is, &token, &len);
			sinfo->condition = imap_tokenise(token, len);

			/* parse any details */
			switch (sinfo->condition) {
			case IMAP_READ_ONLY:
			case IMAP_READ_WRITE:
			case IMAP_ALERT:
			case IMAP_PARSE:
			case IMAP_TRYCREATE:
				break;
			case IMAP_NEWNAME:
				/* the rfc doesn't specify the bnf for this */
				camel_imapp_stream_astring(is, &token);
				sinfo->u.newname.oldname = g_strdup(token);
				camel_imapp_stream_astring(is, &token);
				sinfo->u.newname.newname = g_strdup(token);
				break;
			case IMAP_PERMANENTFLAGS:
				imap_parse_flags(is, &sinfo->u.permanentflags);
				break;
			case IMAP_UIDVALIDITY:
				sinfo->u.uidvalidity = camel_imapp_stream_number(is);
				break;
			case IMAP_UNSEEN:
				sinfo->u.unseen = camel_imapp_stream_number(is);
				break;
			default:
				sinfo->condition = IMAP_UNKNOWN;
				printf("Got unknown response code: %s: ignored\n", token);
			}
			
			/* ignore anything we dont know about */
			do {
				tok = camel_imapp_stream_token(is, &token, &len);
				if (tok == '\n')
					camel_exception_throw(1, "server response truncated");
			} while (tok != ']');
		} else {
			camel_imapp_stream_ungettoken(is, tok, token, len);
		}

		/* and take the human readable response */
		camel_imapp_stream_text(is, (unsigned char **)&sinfo->text);
	} CAMEL_CATCH(ex) {
		imap_free_status(sinfo);
		camel_exception_throw_ex(ex);
	} CAMEL_DONE;

	return sinfo;
}

void
imap_free_status(struct _status_info *sinfo)
{
	if (sinfo == NULL)
		return;

	switch (sinfo->condition) {
	case IMAP_NEWNAME:
		g_free(sinfo->u.newname.oldname);
		g_free(sinfo->u.newname.newname);
	default:
		break;
	}

	g_free(sinfo->text);
	g_free(sinfo);
}

/* FIXME: use tokeniser? */
/* FIXME: real flags */
static struct {
	char *name;
	guint32 flag;
} list_flag_table[] = {
	{ "\\NOINFERIORS", CAMEL_FOLDER_NOINFERIORS },
	{ "\\NOSELECT", CAMEL_FOLDER_NOSELECT },
	{ "\\MARKED", 1<<8 },
	{ "\\UNMARKED", 1<<9 },
};

struct _list_info *
imap_parse_list(CamelIMAPPStream *is)
/* throws io, parse */
{
	int tok, len, i;
	unsigned char *token, *p, c;
	struct _list_info * volatile linfo;

	linfo = g_malloc0(sizeof(*linfo));
	
	CAMEL_TRY {
		/* mailbox_list    ::= "(" #("\Marked" / "\Noinferiors" /
		   "\Noselect" / "\Unmarked" / flag_extension) ")"
		   SPACE (<"> QUOTED_CHAR <"> / nil) SPACE mailbox */

		tok = camel_imapp_stream_token(is, &token, &len);
		if (tok != '(')
			camel_exception_throw(1, "list: expecting '('");

		while ( (tok = camel_imapp_stream_token(is, &token, &len)) != ')' ) {
			if (tok == IMAP_TOK_STRING || tok == IMAP_TOK_TOKEN) {
				p = token;
				while ((c=*p))
					*p++ = toupper(c);
				for (i=0;i<(int)(sizeof(list_flag_table)/sizeof(list_flag_table[0]));i++)
					if (!strcmp(token, list_flag_table[i].name))
						linfo->flags |= list_flag_table[i].flag;
			} else {
				camel_exception_throw(1, "list: expecting flag or ')'");
			}
		}

		camel_imapp_stream_nstring(is, &token);
		linfo->separator = token?*token:0;
		camel_imapp_stream_astring(is, &token);
		linfo->name = g_strdup(token);
	} CAMEL_CATCH(ex) {
		imap_free_list(linfo);
		camel_exception_throw_ex(ex);
	} CAMEL_DONE;

	return linfo;
}

char *
imapp_list_get_path(struct _list_info *li)
{
	char *path, *p;
	int c;
	const char *f;

	if (li->separator != 0 && li->separator != '/') {
		p = path = alloca(strlen(li->name)*3+1);
		f = li->name;
		while ( (c = *f++ & 0xff) ) {
			if (c == li->separator)
				*p++ = '/';
			else if (c == '/' || c == '%')
				p += sprintf(p, "%%%02X", c);
			else
				*p++ = c;
		}
		*p = 0;
	} else
		path = li->name;

	return camel_utf7_utf8(path);
}

void
imap_free_list(struct _list_info *linfo)
{
	if (linfo) {
		g_free(linfo->name);
		g_free(linfo);
	}
}


/* ********************************************************************** */
/* utility functions */

/* should the rest of imapp-utils go into imapp-parse? */

/* this creates a uid (or sequence number) set directly into the command,
  optionally breaking it into smaller chunks */

void
imapp_uidset_init(struct _uidset_state *ss, CamelIMAPPEngine *ie)
{
	ss->ie = ie;
	ss->len = 0;
	ss->start = 0;
	ss->last = 0;
}

int
imapp_uidset_done(struct _uidset_state *ss, CamelIMAPPCommand *ic)
{
	int ret = 0;

	if (ss->last != 0 && ss->last != ss->start) {
		camel_imapp_engine_command_add(ss->ie, ic, ":%d", ss->last);
		printf(":%d", ss->last);
	}

	ret = ss->last != 0;

	ss->start = 0;
	ss->last = 0;
	ss->len = 0;

	return ret;
}

int
imapp_uidset_add(struct _uidset_state *ss, CamelIMAPPCommand *ic, const char *uid)
{
	guint32 uidn;

	uidn = strtoul(uid, NULL, 10);
	if (uidn == 0)
		return -1;

	if (ss->last == 0) {
		camel_imapp_engine_command_add(ss->ie, ic, "%d", uidn);
		printf("%d", uidn);
		ss->len ++;
		ss->start = uidn;
	} else {
		if (ss->last != uidn-1) {
			if (ss->last == ss->start) {
				camel_imapp_engine_command_add(ss->ie, ic, ",%d", uidn);
				printf(",%d", uidn);
				ss->len ++;
			} else {
				camel_imapp_engine_command_add(ss->ie, ic, ":%d,%d", ss->last, uidn);
				printf(":%d,%d", ss->last, uidn);
				ss->len+=2;
			}
			ss->start = uidn;
		}
	}

	ss->last = uidn;

	if (ss->len > 10) {
		imapp_uidset_done(ss, ic);
		return 1;
	}

	return 0;
}
