Initial checkin

Imported from subversion report, converted to git. Updated all paths in
scripts and makefiles, reflecting the new directory hierarchy.

1 files changed, 3498 insertions, 0 deletions

diff --git a/libmail/imapfolder.C b/libmail/imapfolder.C
new file mode 100644
index 0000000..7f00f35
--- /dev/null
+++ b/libmail/imapfolder.C
@@ -0,0 +1,3498 @@
+/*
+** Copyright 2003-2004, Double Precision Inc.
+**
+** See COPYING for distribution information.
+*/
+#include "libmail_config.h"
+#include "imap.H"
+#include "misc.H"
+#include "imaphandler.H"
+#include "imapidle.H"
+#include "imapfetchhandler.H"
+#include "imapfolder.H"
+#include "imapparsefmt.H"
+
+#include "smapopen.H"
+#include "smapidle.H"
+#include "smapnoopexpunge.H"
+#include "smapstore.H"
+#include "smapcopy.H"
+#include "smapsearch.H"
+
+#include "generic.H"
+#include "copymessage.H"
+#include "search.H"
+#include "rfcaddr.H"
+#include "envelope.H"
+#include "structure.H"
+#include "rfc822/rfc822.h"
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <sstream>
+#include <limits.h>
+#include <errno.h>
+
+using namespace std;
+
+mail::imapFOLDERinfo::imapFOLDERinfo(string pathArg,
+				     mail::callback::folder &folderCallbackArg)
+	: folderCallback(folderCallbackArg),
+	  exists(0), closeInProgress(false),
+	  path(pathArg)
+{
+}
+
+mail::imapFOLDERinfo::~imapFOLDERinfo()
+{
+}
+
+
+mail::imapFOLDERinfo::indexInfo::indexInfo()
+{
+}
+
+mail::imapFOLDERinfo::indexInfo::~indexInfo()
+{
+}
+
+void mail::imapFOLDERinfo::setUid(size_t count, string uid)
+{
+	if (count < index.size())
+		index[count].uid=uid;
+}
+
+void mail::imapFOLDERinfo::opened()
+{
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+//
+// Helper class for processing the SELECT command.  It's installed when
+// a SELECT command is issued.  It handles the * FLAGS, * OK, and * NO
+// untagged messages, during folder open, as well as the * n EXISTS message
+// ( TODO - ignore any other garbage )
+//
+
+LIBMAIL_START
+
+class imapSELECT : public imapCommandHandler {
+
+	mail::callback &openCallback;
+	mail::callback::folder &folderCallback;
+
+	string path;
+
+public:
+	string uidv;
+	size_t exists;
+
+	imapSELECT(string pathArg,
+			 mail::callback &openCallbackArg,
+			 mail::callback::folder &folderCallbackArg);
+
+	~imapSELECT();
+
+	void installed(imap &imapAccount);
+	static const char name[];
+
+private:
+	const char *getName();
+	void timedOut(const char *errmsg);
+
+	bool untaggedMessage(imap &imapAccount, string name);
+	bool taggedMessage(imap &imapAccount, string name,
+			   string message,
+			   bool okfail, string errmsg);
+};
+
+LIBMAIL_END
+
+const char mail::imapSELECT::name[]="SELECT";
+
+mail::imapSELECT::imapSELECT(string pathArg,
+				   mail::callback &openCallbackArg,
+				   mail::callback::folder &folderCallbackArg)
+	: openCallback(openCallbackArg),
+	  folderCallback(folderCallbackArg), path(pathArg),
+	  uidv(""), exists(0)
+{
+}
+
+mail::imapSELECT::~imapSELECT()
+{
+}
+
+void mail::imapSELECT::installed(mail::imap &imapAccount)
+{
+	imapAccount.imapcmd("SELECT", "SELECT " +
+		     imapAccount.quoteSimple(path) + "\r\n");
+
+	imapAccount.folderFlags.clear();
+	imapAccount.permanentFlags.clear();
+}
+
+const char *mail::imapSELECT::getName()
+{
+	return name;
+}
+
+void mail::imapSELECT::timedOut(const char *errmsg)
+{
+	callbackTimedOut(openCallback, errmsg);
+}
+
+//
+// Helper class for processing the untagged FLAGS response
+//
+
+LIBMAIL_START
+
+class imapSELECT_FLAGS : public imapHandlerStructured {
+
+	void (imapSELECT_FLAGS::*next_func)(imap &, Token t);
+
+public:
+	imapSELECT_FLAGS();
+	~imapSELECT_FLAGS();
+	void installed(imap &imapAccount);
+
+private:
+	const char *getName();
+	void timedOut(const char *errmsg);
+
+	void process(imap &imapAccount, Token t);
+	void start_flags(imap &imapAccount, Token t);
+	void process_flags(imap &imapAccount, Token t);
+};
+
+LIBMAIL_END
+
+mail::imapSELECT_FLAGS::imapSELECT_FLAGS()
+	: next_func(&mail::imapSELECT_FLAGS::start_flags)
+{
+}
+
+mail::imapSELECT_FLAGS::~imapSELECT_FLAGS()
+{
+}
+
+void mail::imapSELECT_FLAGS::installed(mail::imap &imapAccount)
+{
+}
+
+const char *mail::imapSELECT_FLAGS::getName()
+{
+	return ("* FLAGS");
+}
+
+void mail::imapSELECT_FLAGS::timedOut(const char *errmsg)
+{
+}
+
+void mail::imapSELECT_FLAGS::process(mail::imap &imapAccount, Token t)
+{
+	(this->*next_func)(imapAccount, t);
+}
+
+//
+// Helper class for processing an untagged * #nnnn response during a SELECT
+//
+
+LIBMAIL_START
+
+class imapSELECT_COUNT : public imapHandlerStructured {
+
+	imapSELECT &select;
+
+	void (imapSELECT_COUNT::*next_func)(imap &, Token t);
+
+	size_t count;
+
+public:
+	imapSELECT_COUNT(imapSELECT &mySelect,
+			       size_t myCount);
+	~imapSELECT_COUNT();
+	void installed(imap &imapAccount);
+
+private:
+	const char *getName();
+	void timedOut(const char *);
+	void process(imap &imapAccount, Token t);
+	void get_count(imap &imapAccount, Token t);
+};
+
+LIBMAIL_END
+
+mail::imapSELECT_COUNT::imapSELECT_COUNT(mail::imapSELECT &mySelect,
+					       size_t myCount)
+	: select(mySelect),
+	  next_func(&mail::imapSELECT_COUNT::get_count),
+	  count(myCount)
+{
+}
+
+mail::imapSELECT_COUNT::~imapSELECT_COUNT()
+{
+}
+
+void mail::imapSELECT_COUNT::installed(mail::imap &imapAccount)
+{
+}
+
+const char *mail::imapSELECT_COUNT::getName()
+{
+	return ("* #");
+}
+
+void mail::imapSELECT_COUNT::timedOut(const char *errmsg)
+{
+}
+
+void mail::imapSELECT_COUNT::process(mail::imap &imapAccount, Token t)
+{
+	(this->*next_func)(imapAccount, t);
+}
+
+//
+// Helper class for processing an untagged * OK response during a SELECT
+//
+
+LIBMAIL_START
+
+class imapSELECT_OK : public imapHandler {
+
+	imapSELECT &select;
+	string type;
+public:
+	imapSELECT_OK(imapSELECT &mySelect,
+			    string typeArg);
+	~imapSELECT_OK();
+	void installed(imap &imapAccount);
+
+private:
+	const char *getName();
+	void timedOut(const char *errmsg);
+
+	int process(imap &imapAccount, string &buffer);
+	void process(string &buffer);
+};
+
+LIBMAIL_END
+
+mail::imapSELECT_OK::imapSELECT_OK(mail::imapSELECT &mySelect,
+					 string typeArg)
+	: select(mySelect), type(typeArg)
+{
+	upper(type);
+}
+
+mail::imapSELECT_OK::~imapSELECT_OK()
+{
+}
+
+void mail::imapSELECT_OK::installed(mail::imap &imapAccount)
+{
+}
+
+const char *mail::imapSELECT_OK::getName()
+{
+	return("* OK");
+}
+
+void mail::imapSELECT_OK::timedOut(const char *errmsg)
+{
+}
+
+//////////////////////////////////////////////////////////////////////////
+//
+// After a SELECT, and any time * n EXISTS received, a SELECT FLAGS UID
+// is automatically issued (either for the entire folder, or just the new
+// messages).  When this command completes, the application callback methods
+// will be invoked accordingly.
+//
+
+LIBMAIL_START
+
+class imapSYNCHRONIZE : public imapCommandHandler {
+
+	mail::callback &callback;
+ 
+	size_t fetchedCounter;
+
+	size_t newExists;
+
+public:
+	static size_t counter;
+	// Keeps track of the # of objects in existence.
+
+	imapSYNCHRONIZE(mail::callback &callbackArg);
+	~imapSYNCHRONIZE();
+
+	void installed(imap &imapAccount);
+
+	void fetchedUID();
+
+private:
+	const char *getName();
+	void timedOut(const char *errmsg);
+
+	bool untaggedMessage(imap &imapAccount, string name);
+	bool taggedMessage(imap &imapAccount, string name,
+			   string message,
+			   bool okfail, string errmsg);
+};
+
+LIBMAIL_END
+
+const char *mail::imapSYNCHRONIZE::getName()
+{
+	return("SYNC");
+}
+
+void mail::imapSYNCHRONIZE::timedOut(const char *errmsg)
+{
+	callbackTimedOut(callback, errmsg);
+}
+
+///////////////////////////////////////////////////////////////////////
+//
+// Stub call from mail::imapFolder::open()
+//
+
+void mail::imap::openFolder(string path,
+			    mail::snapshot *restoreSnapshot,
+			    mail::callback &openCallback,
+			    mail::callback::folder &folderCallback)
+{
+	if (!ready(openCallback))
+		return;
+
+	// If an existing folder is opened, tell the folder not to poll for
+	// new mail any more.
+	if (currentFolder)
+		currentFolder->closeInProgress=true;
+
+	installForegroundTask(smap ?
+			      (imapHandler *)
+			      new mail::smapOPEN(path,
+						 restoreSnapshot,
+						 openCallback,
+						 folderCallback)
+			      : new mail::imapSELECT(path, openCallback,
+						     folderCallback));
+}
+
+//
+// A manually-requested NOOP.
+//
+
+LIBMAIL_START
+
+class imapCHECKMAIL : public imapCommandHandler {
+
+	mail::callback &callback;
+
+public:
+	imapCHECKMAIL(mail::callback &myCallback);
+	~imapCHECKMAIL();
+	void installed(imap &imapAccount);
+
+	class dummyCallback : public mail::callback {
+	public:
+		dummyCallback();
+		~dummyCallback();
+
+		void success(string);
+		void fail(string);
+
+		void reportProgress(size_t bytesCompleted,
+				    size_t bytesEstimatedTotal,
+
+				    size_t messagesCompleted,
+				    size_t messagesEstimatedTotal);
+	};
+
+private:
+
+	const char *getName();
+
+	void timedOut(const char *errmsg);
+
+	bool untaggedMessage(imap &imapAccount, string name);
+
+	bool taggedMessage(imap &imapAccount, string name,
+			   string message,
+			   bool okfail, string errmsg);
+};
+
+LIBMAIL_END
+
+mail::imapCHECKMAIL::imapCHECKMAIL(mail::callback &myCallback)
+	: callback(myCallback)
+{
+}
+
+mail::imapCHECKMAIL::~imapCHECKMAIL()
+{
+}
+
+void mail::imapCHECKMAIL::installed(mail::imap &imapAccount)
+{
+	imapAccount.imapcmd("NOOP2", "NOOP\r\n");
+}
+
+const char *mail::imapCHECKMAIL::getName()
+{
+	return "NOOP2";
+}
+
+void mail::imapCHECKMAIL::timedOut(const char *errmsg)
+{
+	callbackTimedOut(callback, errmsg);
+}
+
+bool mail::imapCHECKMAIL::untaggedMessage(mail::imap &imapAccount, string name)
+{
+	return false;
+}
+
+bool mail::imapCHECKMAIL::taggedMessage(mail::imap &imapAccount, string name,
+					string message,
+					bool okfail, string errmsg)
+{
+
+	// The check for completion of a manual new mail check must be
+	// done slightly differently.  That's because new mail
+	// processing is handled by the regular new mail processing
+	// objects, which don't really know anything about us.
+	// If new mail processing got kicked off, there should be a
+	// mail::imapSYNCHRONIZE object floating around somewhere.
+	// If there is, what we do is we throw another checkNewMail
+	// object in the queue, which should float to the beginning of
+	// the queue after the current mail::imapSYNCHRONIZE object
+	// goes away.
+
+	if (name == "NOOP2")
+	{
+		if (mail::imapSYNCHRONIZE::counter == 0)
+		{
+			callback.success("DONE");
+			imapAccount.uninstallHandler(this);
+			return true;
+		}
+
+		imapAccount.installForegroundTask(new
+					   mail::imapCHECKMAIL(callback));
+
+		imapAccount.uninstallHandler(this);
+		return true;
+	}
+
+	return false;
+}
+
+mail::imapCHECKMAIL::dummyCallback::dummyCallback()
+{
+}
+
+mail::imapCHECKMAIL::dummyCallback::~dummyCallback()
+{
+}
+
+void mail::imapCHECKMAIL::dummyCallback::success(string dummy)
+{
+	delete this;
+}
+
+void mail::imapCHECKMAIL::dummyCallback::fail(string dummy)
+{
+	delete this;
+}
+
+void mail::imapCHECKMAIL
+::dummyCallback::reportProgress(size_t bytesCompleted,
+				size_t bytesEstimatedTotal,
+
+				size_t messagesCompleted,
+				size_t messagesEstimatedTot)
+{
+}
+
+void mail::imap::checkNewMail(mail::callback &callback)
+{
+	if (!ready(callback))
+		return;
+
+	if (currentFolder)
+		currentFolder->resetMailCheckTimer();
+
+	installForegroundTask(smap ?
+			      (imapHandler *)new smapNoopExpunge("NOOP",
+								 callback,
+								 *this)
+			      : new mail::imapCHECKMAIL(callback));
+}
+
+void mail::imapFOLDER::resetMailCheckTimer()
+{
+	// Reset the regular new mail checking interval
+	setTimeout(mailCheckInterval);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// SELECT processing.
+
+bool mail::imapSELECT::untaggedMessage(mail::imap &imapAccount, string name)
+{
+	if (name == "FLAGS")
+	{
+		imapAccount.installBackgroundTask(new mail::imapSELECT_FLAGS()
+						  );
+		return true;
+	}
+	if (name == "OK" || name == "NO")
+	{
+		imapAccount.installBackgroundTask(new mail::imapSELECT_OK(*this,
+								   name));
+		return true;
+	}
+
+	if (isdigit((int)(unsigned char)*name.begin()))
+	{
+		size_t c=0;
+
+		istringstream(name.c_str()) >> c;
+
+		imapAccount.installBackgroundTask(new mail::imapSELECT_COUNT(*this,
+								      c));
+		return true;
+	}
+
+	return false;
+}
+
+void mail::imapSELECT_FLAGS::start_flags(mail::imap &imapAccount, Token t)
+{
+	imapAccount.folderFlags.clear();
+	if (t == NIL)
+	{
+		done();
+		return;
+	}
+
+	if (t != '(')
+		error(imapAccount);
+	next_func= &mail::imapSELECT_FLAGS::process_flags;
+}
+
+void mail::imapSELECT_FLAGS::process_flags(mail::imap &imapAccount, Token t)
+{
+	if (t == ATOM)
+	{
+		string name=t.text;
+
+		upper(name);
+		imapAccount.folderFlags.insert(name);
+		return;
+	}
+
+	if (t != ')')
+		error(imapAccount);
+	done();
+}
+
+void mail::imapSELECT_COUNT::get_count(mail::imap &imapAccount, Token t)
+{
+	if (t != ATOM)
+		error(imapAccount);
+	else
+	{
+		if (strcasecmp(t.text.c_str(), "EXISTS") == 0)
+		{
+			select.exists=count;
+
+			// Check against hostile servers
+
+			if (select.exists > UINT_MAX
+			    / sizeof(mail::messageInfo))
+				select.exists=UINT_MAX
+					/ sizeof(mail::messageInfo);
+		}
+	}
+	done();
+}
+
+int mail::imapSELECT_OK::process(mail::imap &imapAccount, string &buffer)
+{
+	size_t p=buffer.find('\n');
+
+	if (p == std::string::npos)
+	{
+		if (p + 16000 < buffer.size())
+			return buffer.size() - 16000;
+		// SANITY CHECK - DON'T LET HOSTILE SERVER DOS us
+
+		return 0;
+	}
+
+	string buffer_cpy=buffer;
+
+	buffer_cpy.erase(p);
+	process(buffer_cpy);
+	imapAccount.uninstallHandler(this);
+	return p+1;
+}
+
+void mail::imapSELECT_OK::process(string &buffer)
+{
+	if (type != "OK")
+		return;
+
+	string::iterator b=buffer.begin(), e=buffer.end();
+
+	while (b != e && unicode_isspace((unsigned char)*b))
+		b++;
+
+	if (b == e || *b != '[')
+		return;
+	b++;
+
+	string w=mail::imap::get_word(&b, &e);
+
+	upper(w);
+
+	if (w == "UIDVALIDITY") // Memorize * OK [UIDVALIDITY]
+	{
+		w=mail::imap::get_word(&b, &e);
+		select.uidv=w;
+	}
+	else if (w == "PERMANENTFLAGS")
+	{
+		myimap->setPermanentFlags(b, e);
+	}
+}
+
+//
+// After an initial SELECT succeeds, even if the subsequent resynchronization
+// commands fail, we still want to indicate success.
+//
+
+LIBMAIL_START
+
+class imapSELECTCallback : public mail::callback {
+
+	mail::callback &origCallback;
+
+	void reportProgress(size_t bytesCompleted,
+			    size_t bytesEstimatedTotal,
+
+			    size_t messagesCompleted,
+			    size_t messagesEstimatedTotal);
+
+public:
+	imapSELECTCallback(mail::callback &cb);
+	~imapSELECTCallback();
+	void success(string msg);
+	void fail(string msg);
+};
+LIBMAIL_END
+
+bool mail::imapSELECT::taggedMessage(mail::imap &imapAccount, string name,
+				     string message,
+				     bool okfail, string errmsg)
+{
+	if (name != "SELECT")
+		return false;
+
+	if (okfail && uidv.length() == 0)
+	{
+		okfail=false;
+		errmsg="Server did not return the folder UID-validity token.";
+	}
+
+	if (okfail)
+	{
+		mail::imapFOLDER *f=new mail::imapFOLDER(path, uidv, exists,
+							 folderCallback,
+							 imapAccount);
+		imapAccount.installBackgroundTask(f);
+		imapAccount.currentFolder=f;
+
+		f->exists=0;
+
+		if (exists > 0)
+		{
+			mail::imapSELECTCallback *cb=
+				new mail::imapSELECTCallback(openCallback);
+
+			try {
+				imapAccount.installForegroundTask
+					(new mail::imapSYNCHRONIZE(*cb));
+			} catch (...) {
+				delete cb;
+			}
+		}
+		else
+			openCallback.success("Empty folder.");
+	}
+	else
+	{
+		imapAccount.currentFolder=NULL;
+		openCallback.fail(errmsg);
+	}
+	imapAccount.uninstallHandler(this);
+	return true;
+}
+
+mail::imapSELECTCallback::imapSELECTCallback(mail::callback &cb)
+	: origCallback(cb)
+{
+}
+
+mail::imapSELECTCallback::~imapSELECTCallback()
+{
+}
+
+void mail::imapSELECTCallback::success(string msg)
+{
+	origCallback.success(msg);
+	delete this;
+}
+
+void mail::imapSELECTCallback::fail(string msg)
+{
+	origCallback.success(msg);
+	delete this;
+}
+
+void mail::imapSELECTCallback::reportProgress(size_t bytesCompleted,
+					      size_t bytesEstimatedTotal,
+
+					      size_t messagesCompleted,
+					      size_t messagesEstimatedTotal)
+{
+	origCallback.reportProgress(bytesCompleted, bytesEstimatedTotal,
+				    messagesCompleted,
+				    messagesEstimatedTotal);
+}
+
+////////////////////////////////////////////////////////////////////////
+//
+// Helper class to resynchronize a folder
+
+
+size_t mail::imapSYNCHRONIZE::counter=0;
+
+mail::imapSYNCHRONIZE::imapSYNCHRONIZE(mail::callback &callbackArg)
+	: callback(callbackArg), fetchedCounter(0)
+{
+	++counter;
+}
+
+void mail::imapSYNCHRONIZE::installed(mail::imap &imapAccount)
+{
+	ostringstream o;
+
+	newExists=imapAccount.currentFolder ?
+		imapAccount.currentFolder->index.size():0;
+
+	if (imapAccount.currentFolder == NULL ||
+	    imapAccount.currentFolder->exists >= newExists)
+	{
+		imapAccount.currentFolder->exists=newExists; // Insurance
+
+		o << "NOOP\r\n";
+	}
+	else
+	{
+
+		o << "FETCH " << (imapAccount.currentFolder->exists+1)
+		  << ":" << newExists << " (UID FLAGS)\r\n";
+
+	}
+
+	imapAccount.imapcmd("SYNC", o.str());
+	imapAccount.currentSYNCHRONIZE=this;
+}
+
+mail::imapSYNCHRONIZE::~imapSYNCHRONIZE()
+{
+	if (myimap)
+		myimap->currentSYNCHRONIZE=NULL;
+	--counter;
+}
+
+void mail::imapSYNCHRONIZE::fetchedUID()
+{
+	size_t c=myimap && myimap->currentFolder ?
+		myimap->currentFolder->exists:0;
+
+
+	if (c >= newExists)
+		c=newExists;
+
+	if (fetchedCounter < newExists - c)
+	{
+		++fetchedCounter;
+		callback.reportProgress(0, 0,
+					fetchedCounter, newExists - c);
+	}
+}
+
+bool mail::imapSYNCHRONIZE::untaggedMessage(mail::imap &imapAccount, string name)
+{
+	return false;
+}
+
+bool mail::imapSYNCHRONIZE::taggedMessage(mail::imap &imapAccount, string name,
+					  string message,
+					  bool okfail, string errmsg)
+{
+	if (name != "SYNC")
+		return false;
+
+	if (!okfail)
+	{
+		callback.fail(errmsg);
+		imapAccount.uninstallHandler(this);
+		return true;
+	}
+
+	mail::imapFOLDERinfo *f=imapAccount.currentFolder;
+
+	size_t n;
+
+	for (n=f->exists; n<f->index.size(); n++)
+		if (f->index[n].uid.length() == 0)
+		{
+			callback.fail("Server failed to respond with message identifier.");
+			imapAccount.uninstallHandler(this);
+			return true;
+		}
+
+	if (f->exists < newExists)
+		f->exists=newExists;
+
+
+	callback.success("Folder index updated.");
+	imapAccount.uninstallHandler(this);
+	return true;
+}
+
+
+size_t mail::imap::getFolderIndexSize()
+{
+	if (currentFolder == NULL)
+		return 0;
+
+	return currentFolder->exists;
+}
+
+mail::messageInfo mail::imap::getFolderIndexInfo(size_t n)
+{
+	if (currentFolder  != NULL && n < currentFolder->exists)
+		return currentFolder->index[n];
+
+	return mail::messageInfo();
+}
+
+void mail::imap::getFolderKeywordInfo(size_t n, std::set<std::string> &kwset)
+{
+	if (currentFolder != NULL && n < currentFolder->exists)
+	{
+		currentFolder->index[n].keywords.getFlags(kwset);
+	}
+	else
+		kwset.clear();
+}
+
+//////////////////////////////////////////////////////////////////////////
+//
+// Server replies when a folder is currently open.
+//
+
+const char mail::imapFOLDER::name[]="FolderHandler";
+
+//
+// Helper class for processing an untagged * #nnnn response during a SELECT
+//
+
+LIBMAIL_START
+
+class imapFOLDER_COUNT : public imapHandlerStructured {
+
+	void (imapFOLDER_COUNT::*next_func)(imap &, Token t);
+
+	size_t count;
+	bool body_part_reference; // Fetch References: header
+	string references_buf;
+	vector<string> flags;
+
+	bool accept_largestring;
+
+	bool wantLargeString();
+public:
+	imapFOLDER_COUNT(size_t myCount);
+	~imapFOLDER_COUNT();
+	void installed(imap &imapAccount) {}
+private:
+	const char *getName();
+	void timedOut(const char *errmsg);
+	void process(imap &imapAccount, Token t);
+
+	void get_count(imap &imapAccount, Token t);
+
+	void get_fetch(imap &imapAccount, Token t);
+	void get_fetch_item(imap &imapAccount, Token t);
+	void get_fetch_uid(imap &imapAccount, Token t);
+
+	void get_fetch_flags(imap &imapAccount, Token t);
+	void get_fetch_flag(imap &imapAccount, Token t);
+	void saveflags(imap &imapAccount);
+
+	void get_internaldate(imap &imapAccount, Token t);
+	void get_rfc822size(imap &imapAccount, Token t);
+
+	void get_envelope(imap &imapAccount, Token t);
+	void get_bodystructure(imap &imapAccount, Token t);
+	void get_body(imap &imapAccount, Token t);
+
+	bool fillbodystructure(imap &imapAccount, imapparsefmt &parser,
+			       mimestruct &bodystructure,
+			       string mime_id);
+
+	imapparsefmt parser;
+};
+
+LIBMAIL_END
+
+mail::imapFOLDER::imapFOLDER(string pathArg, string uidvArg, size_t existsArg,
+			     mail::callback::folder &folderCallbackArg,
+			     mail::imap &myserver)
+	: mail::imapCommandHandler(myserver.noopSetting),
+	  imapFOLDERinfo(pathArg, folderCallbackArg),
+	  existsNotify(NULL),
+	  uidv(uidvArg)
+{
+	mailCheckInterval=myserver.noopSetting;
+	setBackgroundTask(true);
+	index.resize(existsArg);
+}
+
+mail::imapFOLDER::~imapFOLDER()
+{
+	if (existsNotify)
+		existsNotify->me=NULL;
+}
+
+mail::imapFOLDER::existsCallback::existsCallback()
+{
+}
+
+mail::imapFOLDER::existsCallback::~existsCallback()
+{
+}
+
+void mail::imapFOLDER::existsCallback::success(string message)
+{
+	if (me)
+	{
+		mail::imapFOLDER *cb=me;
+		me=NULL;
+		cb->existsNotify=NULL;
+		cb->folderCallback.newMessages();
+	}
+	delete this;
+}
+
+void mail::imapFOLDER::existsCallback
+::reportProgress(size_t bytesCompleted,
+		 size_t bytesEstimatedTotal,
+
+		 size_t messagesCompleted,
+		 size_t messagesEstimatedTotal)
+{
+}
+
+void mail::imapFOLDER::existsCallback::fail(string message)
+{
+	if (me)
+	{
+		mail::imapFOLDER *cb=me;
+		me=NULL;
+		cb->existsNotify=NULL;
+		cb->folderCallback.newMessages();
+	}
+	delete this;
+}
+
+const char *mail::imapFOLDER::getName()
+{
+	return name;
+}
+
+void mail::imapFOLDER::installed(mail::imap &imapAccount)
+{
+}
+
+void mail::imapFOLDER::timedOut(const char *errmsg)
+{
+}
+
+int mail::imapFOLDER::getTimeout(mail::imap &imapAccount)
+{
+	int t=mail::imapCommandHandler::getTimeout(imapAccount);
+
+	if (t == 0)
+	{
+		setTimeout(t=imapAccount.noopSetting);
+
+		imapHandler *h;
+
+		if (!closeInProgress // Not closing the folder
+		    && ((h=imapAccount.hasForegroundTask()) == NULL ||
+			strcmp(h->getName(), "IDLE") == 0))
+			// Something else is already in progress
+		{
+			imapCHECKMAIL::dummyCallback *dummy=
+				new imapCHECKMAIL::dummyCallback();
+
+			if (!dummy)
+				LIBMAIL_THROW((strerror(errno)));
+
+			try {
+				imapAccount
+					.installForegroundTask(new
+							       imapCHECKMAIL
+							       (*dummy));
+			} catch (...) {
+				delete dummy;
+				throw;
+			}
+		}
+	}
+	return t;	// This handler never causes a timeout
+}
+
+bool mail::imapFOLDER::untaggedMessage(mail::imap &imapAccount, string name)
+{
+	if (isdigit((int)(unsigned char)*name.begin()))
+	{
+		if (imapAccount.handlers.count(mail::imapSELECT::name) > 0)
+			return false;	// SELECT in progress
+		size_t c=0;
+
+		istringstream(name.c_str()) >> c;
+
+		imapAccount.installBackgroundTask(new mail::imapFOLDER_COUNT(c));
+		return true;
+	}
+
+	if (name == "FLAGS")
+	{
+		imapAccount
+			.installBackgroundTask(new mail::imapSELECT_FLAGS());
+		return true;
+	}
+
+	return false;
+}
+
+bool mail::imapFOLDER::taggedMessage(mail::imap &imapAccount, string name,
+				     string message,
+				     bool okfail, string errmsg)
+{
+	return false;
+}
+
+
+mail::imapFOLDER_COUNT::imapFOLDER_COUNT(size_t myCount)
+	: next_func(&mail::imapFOLDER_COUNT::get_count),
+	  count(myCount), body_part_reference(false),
+	  accept_largestring(false)
+{
+}
+
+mail::imapFOLDER_COUNT::~imapFOLDER_COUNT()
+{
+}
+
+bool mail::imapFOLDER_COUNT::wantLargeString()
+{
+	return accept_largestring;
+}
+
+const char *mail::imapFOLDER_COUNT::getName()
+{
+	return ("* #");
+}
+
+void mail::imapFOLDER_COUNT::timedOut(const char *errmsg)
+{
+}
+
+void mail::imapFOLDER_COUNT::process(mail::imap &imapAccount, Token t)
+{
+	(this->*next_func)(imapAccount, t);
+}
+
+// Seen * nnnnn
+
+void mail::imapFOLDER_COUNT::get_count(mail::imap &imapAccount, Token t)
+{
+	if (t != ATOM)
+	{
+		error(imapAccount);
+		return;
+	}
+
+	string name=t.text;
+
+	upper(name);
+	if (name == "FETCH")
+	{
+		next_func= &mail::imapFOLDER_COUNT::get_fetch;
+		return;
+	}
+
+	if (name == "EXPUNGE")
+	{
+		done();
+
+		if (imapAccount.currentFolder != NULL && count > 0 &&
+		    count <= imapAccount.currentFolder->index.size())
+		{
+			size_t c=count-1;
+
+			vector<imapFOLDERinfo::indexInfo> &indexRef=
+				imapAccount.currentFolder->index;
+
+			indexRef.erase(indexRef.begin() + c,
+				       indexRef.begin() + c + 1);
+
+			if (c < imapAccount.currentFolder->exists)
+			{
+				--imapAccount.currentFolder->exists;
+
+				vector< pair<size_t, size_t> > a;
+
+				a.push_back(make_pair(c, c));
+				imapAccount.currentFolder->folderCallback
+					.messagesRemoved(a);
+			}
+		}
+		return;
+	}
+	if (name == "EXISTS")
+	{
+		done();
+
+		if (imapAccount.currentFolder != NULL &&
+		    !imapAccount.currentFolder->closeInProgress &&
+		    count > imapAccount.currentFolder->index.size())
+		{
+			imapAccount.currentFolder
+				->existsMore(imapAccount, count);
+		}
+	}
+
+	done();
+}
+
+void mail::imapFOLDER::existsMore(mail::imap &imapAccount, size_t count)
+{
+	if (closeInProgress)
+		return;
+
+	if (exists > count)
+		exists=count;
+
+	index.resize(count, imapFOLDERinfo::indexInfo());
+
+	if (existsNotify)
+		existsNotify->me=NULL;
+
+	existsNotify=new mail::imapFOLDER::existsCallback;
+
+	if (!existsNotify)
+		LIBMAIL_THROW("Out of memory.");
+
+	existsNotify->me=this;
+
+	imapAccount
+		.installForegroundTask(new mail::imapSYNCHRONIZE(*existsNotify)
+				       );
+}
+
+void mail::imapFOLDER_COUNT::get_fetch(mail::imap &imapAccount, Token t)
+{
+	if (t != '(')
+		error(imapAccount);
+	next_func= &mail::imapFOLDER_COUNT::get_fetch_item;
+}
+
+void mail::imapFOLDER_COUNT::get_fetch_item(mail::imap &imapAccount, Token t)
+{
+	accept_largestring=false;
+	if (t == ')')
+	{
+		done();
+		return;
+	}
+
+	if (t != ATOM)
+	{
+		error(imapAccount);
+		return;
+	}
+
+	string name=t.text;
+
+	upper(name);
+
+	if (name == "UID")
+	{
+		next_func= &mail::imapFOLDER_COUNT::get_fetch_uid;
+		return;
+	}
+
+	if (name == "FLAGS")
+	{
+		next_func= &mail::imapFOLDER_COUNT::get_fetch_flags;
+		return;
+	}
+
+	if (name == "INTERNALDATE")
+	{
+		next_func= &mail::imapFOLDER_COUNT::get_internaldate;
+		return;
+	}
+
+	if (name == "RFC822.SIZE")
+	{
+		next_func= &mail::imapFOLDER_COUNT::get_rfc822size;
+		return;
+	}
+
+	if (name == "ENVELOPE")
+	{
+		parser.begin();
+		next_func= &mail::imapFOLDER_COUNT::get_envelope;
+		return;
+	}
+
+	if (name == "BODYSTRUCTURE")
+	{
+		parser.begin();
+		next_func= &mail::imapFOLDER_COUNT::get_bodystructure;
+		return;
+	}
+
+	if (strncasecmp(name.c_str(), "BODY[", 5) == 0 ||
+	    strncasecmp(name.c_str(), "BODY.PEEK[", 10) == 0)
+	{
+		accept_largestring=true;
+		next_func= &mail::imapFOLDER_COUNT::get_body;
+
+		size_t i=name.find(']');
+
+		if (i != name.length()-1)
+		{
+			error(imapAccount);
+			return;
+		}
+		name.erase(i);
+		name.erase(0, name.find('[')+1);
+
+		body_part_reference=strncasecmp(name.c_str(),
+						"HEADER.FIELDS", 13) == 0;
+		references_buf="";
+		// Getting the References: header.
+		return;
+	}
+			
+	error(imapAccount);
+}
+
+void mail::imapFOLDER_COUNT::get_fetch_uid(mail::imap &imapAccount, Token t)
+{
+	if (t != ATOM)
+	{
+		error(imapAccount);
+		return;
+	}
+
+	if (imapAccount.currentFolder && count > 0)
+		imapAccount.currentFolder->setUid(count-1, t.text);
+
+	// Report progress
+	if (imapAccount.currentSYNCHRONIZE)
+		imapAccount.currentSYNCHRONIZE->fetchedUID();
+
+	next_func= &mail::imapFOLDER_COUNT::get_fetch_item;
+}
+
+void mail::imapFOLDER::setUid(size_t count, string uid)
+{
+	imapFOLDERinfo::setUid(count, uidv + "/" + uid);
+}
+
+void mail::imapFOLDER_COUNT::get_fetch_flags(mail::imap &imapAccount, Token t)
+{
+	flags.clear();
+
+	if (t == NIL)
+	{
+		saveflags(imapAccount);
+		return;
+	}
+
+	if (t != '(')
+	{
+		error(imapAccount);
+		return;
+	}
+
+	next_func= &mail::imapFOLDER_COUNT::get_fetch_flag;
+}
+
+void mail::imapFOLDER_COUNT::get_fetch_flag(mail::imap &imapAccount, Token t)
+{
+	if (t == ')')
+	{
+		saveflags(imapAccount);
+		return;
+	}
+
+	if (t != ATOM)
+	{
+		error(imapAccount);
+		return;
+	}
+
+	flags.push_back(t.text);
+}
+
+void mail::imapFOLDER_COUNT::saveflags(mail::imap &imapAccount)
+{
+	next_func= &mail::imapFOLDER_COUNT::get_fetch_item;
+
+	if (imapAccount.currentFolder && count > 0 &&
+	    count <= imapAccount.currentFolder->index.size())
+	{
+		imapFOLDERinfo::indexInfo &i=
+			imapAccount.currentFolder->index[count-1];
+
+		if (imapAccount.folderFlags.count("\\DRAFT") > 0)
+			i.draft=0;
+
+		if (imapAccount.folderFlags.count("\\ANSWERED") > 0)
+			i.replied=0;
+
+		if (imapAccount.folderFlags.count("\\FLAGGED") > 0)
+			i.marked=0;
+
+		if (imapAccount.folderFlags.count("\\DELETED") > 0)
+			i.deleted=0;
+
+		if (imapAccount.folderFlags.count("\\SEEN") > 0)
+			i.unread=1;
+
+		if (imapAccount.folderFlags.count("\\RECENT") > 0)
+			i.recent=0;
+
+		size_t n;
+
+		mail::keywords::Message newMessage;
+
+		for (n=0; n<flags.size(); n++)
+		{
+			string f=flags[n];
+
+			upper(f);
+			if (f == "\\DRAFT")
+				i.draft=1;
+			else if (f == "\\ANSWERED")
+				i.replied=1;
+			else if (f == "\\FLAGGED")
+				i.marked=1;
+			else if (f == "\\DELETED")
+				i.deleted=1;
+			else if (f == "\\SEEN")
+				i.unread=0;
+			else if (f == "\\RECENT")
+				i.recent=1;
+			else if (*flags[n].c_str() != '\\')
+			{
+				if (!newMessage.addFlag(imapAccount
+							.keywordHashtable,
+							flags[n]))
+					LIBMAIL_THROW(strerror(errno));
+			}
+		}
+
+		i.keywords=newMessage;
+
+		if (count <= imapAccount.currentFolder->exists)
+			imapAccount.currentFolder->
+				folderCallback.messageChanged(count-1);
+	}
+}
+
+static void parse_addr_list(mail::imapparsefmt *list,
+			    vector<mail::address> &addresses)
+{
+	vector<mail::imapparsefmt *>::iterator b=list->children.begin(),
+		e=list->children.end();
+
+	while (b != e)
+	{
+		mail::imapparsefmt *address= *b;
+
+		if (address->children.size() >= 4)
+		{
+			mail::imapparsefmt *name=address->children[0];
+			mail::imapparsefmt *mailbox=address->children[2];
+			mail::imapparsefmt *host=address->children[3];
+
+			if (host->nil)
+			{
+				if (mailbox->nil)
+					addresses.
+						push_back(mail::address(";",
+									""));
+				else
+					addresses.
+						push_back(mail::address(mailbox
+									->value
+									+ ":",
+									""));
+			}
+			else
+			{
+				addresses.
+					push_back(mail::address(name->value,
+								mailbox->value
+								+ "@" +
+								host->value));
+			}
+		}
+		b++;
+	}
+}
+
+static bool fillenvelope(mail::imapparsefmt &imapenvelope,
+			 mail::envelope &envelope)
+{
+	if (imapenvelope.children.size() < 10)
+		return false;
+
+	vector<mail::imapparsefmt *>::iterator b=imapenvelope.children.begin();
+
+
+	envelope.date=rfc822_parsedt((*b)->value.c_str()); b++;
+
+	envelope.subject= (*b)->value; b++;
+
+	parse_addr_list(*b, envelope.from); b++;
+	parse_addr_list(*b, envelope.sender); b++;
+	parse_addr_list(*b, envelope.replyto); b++;
+	parse_addr_list(*b, envelope.to); b++;
+	parse_addr_list(*b, envelope.cc); b++;
+	parse_addr_list(*b, envelope.bcc); b++;
+
+	envelope.inreplyto= (*b)->value; b++;
+	envelope.messageid= (*b)->value;
+	return true;
+}
+
+void mail::imapFOLDER_COUNT::get_internaldate(mail::imap &imapAccount, Token t)
+{
+	if (t != ATOM && t != STRING)
+	{
+		error(imapAccount);
+		return;
+	}
+
+	if (imapAccount.currentFetch)
+	{
+		// Make IMAP date presentable for rfc822_parsedt() by
+		// replacing dd-mmm-yyyy with dd mmm yyyy
+
+		string d=t.text;
+
+		if (d[0] == ' ')
+			d[0]='0';
+
+		size_t spacepos=d.find(' ');
+		size_t n;
+
+		while ((n=d.find('-')) < spacepos)
+			d[n]=' ';
+
+		time_t tm=rfc822_parsedt(d.c_str());
+
+		if (tm)
+			imapAccount.currentFetch
+				->messageArrivalDateCallback(count-1, tm);
+	}
+
+	next_func= &mail::imapFOLDER_COUNT::get_fetch_item;
+}
+
+void mail::imapFOLDER_COUNT::get_rfc822size(mail::imap &imapAccount, Token t)
+{
+	if (t != ATOM)
+	{
+		error(imapAccount);
+		return;
+	}
+
+	if (imapAccount.currentFetch)
+	{
+		unsigned long msgsize=0;
+
+		istringstream(t.text.c_str()) >> msgsize;
+
+		imapAccount.currentFetch
+			->messageSizeCallback(count-1, msgsize);
+	}
+
+	next_func= &mail::imapFOLDER_COUNT::get_fetch_item;
+}
+
+void mail::imapFOLDER_COUNT::get_envelope(mail::imap &imapAccount, Token t)
+{
+	bool err_flag;
+
+	if (!parser.process(imapAccount, t, err_flag))
+		return;	// Not yet
+
+	next_func= &mail::imapFOLDER_COUNT::get_fetch_item;
+
+	mail::envelope envelope;
+
+	if (err_flag || !fillenvelope(parser, envelope))
+	{
+		error(imapAccount);
+		return;
+	}
+
+	if (imapAccount.currentFetch)
+		imapAccount.currentFetch
+			->messageEnvelopeCallback(count-1, envelope);
+}
+
+
+static void fill_type_parameters(mail::imapparsefmt *ptr,
+				  mail::mimestruct &bodystructure)
+{
+	vector<mail::imapparsefmt *>::iterator
+		bb=ptr->children.begin(),
+		ee=ptr->children.end();
+
+	while (bb != ee)
+	{
+		string name= (*bb)->value; bb++;
+
+		if (bb != ee)
+		{
+			bodystructure.type_parameters.
+				set_simple(name, (*bb)->value);
+			bb++;
+		}
+	}
+}
+
+
+static void fill_disposition(mail::imapparsefmt *ptr,
+			     mail::mimestruct &bodystructure)
+{
+	if (ptr->children.size() > 0)
+		bodystructure.content_disposition=
+			ptr->children[0]->value;
+
+	if (ptr->children.size() < 2)
+		return;
+
+	vector<mail::imapparsefmt *>::iterator
+		bb=ptr->children[1]->children.begin(),
+		ee=ptr->children[1]->children.end();
+
+	while (bb != ee)
+	{
+		string name= (*bb)->value; bb++;
+
+		if (bb != ee)
+		{
+			bodystructure.content_disposition_parameters
+				.set_simple(name, (*bb)->value);
+			bb++;
+		}
+	}
+}
+
+bool mail::imapFOLDER_COUNT::fillbodystructure(mail::imap &imapAccount,
+					       mail::imapparsefmt &parser,
+					       mail::mimestruct &bodystructure,
+					       string mime_id)
+{
+	vector<mail::imapparsefmt *>::iterator b=parser.children.begin(),
+		e=parser.children.end();
+
+	if (b == e)
+	{
+		error(imapAccount);
+		return false;
+	}
+
+	if ( (*b)->children.size() == 0)  // Non-multipart
+	{
+
+		bodystructure.mime_id=mime_id;
+
+		if (mime_id.length() == 0)
+			mime_id="1";
+
+		bodystructure.type= (*b)->value; b++;
+
+		if (b != e)
+		{
+			bodystructure.subtype= (*b)->value;
+			b++;
+		}
+
+		mail::upper(bodystructure.type);
+		mail::upper(bodystructure.subtype);
+
+		if (b != e)
+		{
+			fill_type_parameters( *b, bodystructure ); b++;
+		}
+
+		if (b != e)
+		{
+			bodystructure.content_id= (*b)->value;
+			b++;
+		}
+
+		if (b != e)
+		{
+			bodystructure.content_description= (*b)->value;
+			b++;
+		}
+
+		if (b != e)
+		{
+			bodystructure.content_transfer_encoding= (*b)->value;
+			b++;
+		}
+
+		if (b != e)
+		{
+			istringstream((*b)->value.c_str()) >>
+				bodystructure.content_size;
+			b++;
+
+			if (bodystructure.messagerfc822())
+			{
+				if (b != e)
+				{
+					if (!fillenvelope(**b,
+							  bodystructure
+							  .getEnvelope())
+					    )
+					{
+						error(imapAccount);
+						return false;
+					}
+
+					b++;
+				}
+				if (b != e)
+				{
+					if ( (*b)->children.size() == 0)
+						mime_id=mime_id + ".1";
+
+					mail::mimestruct &child_struct=
+						*bodystructure.addChild();
+
+					if (!fillbodystructure(imapAccount,
+							       **b,
+							       child_struct,
+							       mime_id))
+						return false;
+
+					if (child_struct.getNumChildren() == 0)
+						child_struct.mime_id=
+							mime_id + ".1";
+					// Fixup
+				}
+
+				if (b != e)
+				{
+					istringstream((*b)->value.c_str()) >>
+						bodystructure.content_lines;
+				}
+			}
+			else if (bodystructure.type == "TEXT")
+			{
+				if (b != e)
+				{
+					istringstream((*b)->value.c_str()) >>
+						bodystructure.content_lines;
+					b++;
+				}
+			}
+		}
+
+		if (b != e)
+		{
+			bodystructure.content_md5= (*b)->value;
+			b++;
+		}
+	}
+	else	// MULTIPART
+	{
+		size_t body_num=1;
+
+		bodystructure.mime_id=mime_id;
+
+		if (mime_id.length() > 0)
+			mime_id=mime_id+".";
+#if 0
+		else
+			bodystructure.mime_id="1";
+#endif
+
+		while (b != e)
+		{
+			if ( (*b)->children.size() == 0)
+				break;
+
+			string buffer;
+			{
+				ostringstream o;
+
+				o << body_num;
+				buffer=o.str();
+			}
+			body_num++;
+
+			if (!fillbodystructure(imapAccount, **b,
+					       *bodystructure.addChild(),
+					       mime_id + buffer))
+				return false;
+			b++;
+		}
+
+		bodystructure.type="MULTIPART";
+		bodystructure.subtype="MIXED";
+
+		if (b != e)
+		{
+			bodystructure.subtype= (*b)->value;
+			b++;
+		}
+
+		mail::upper(bodystructure.subtype);
+
+		if (b != e)
+		{
+			fill_type_parameters( *b, bodystructure );
+			b++;
+		}
+	}
+
+
+	if (b != e)
+	{
+		fill_disposition( (*b), bodystructure );
+		b++;
+	}
+
+	if (b != e)
+	{
+		bodystructure.content_language= (*b)->value;
+		b++;
+	}
+
+	return true;
+}
+
+void mail::imapFOLDER_COUNT::get_bodystructure(mail::imap &imapAccount, Token t)
+{
+	bool err_flag;
+
+	if (!parser.process(imapAccount, t, err_flag))
+		return;	// Not yet
+
+	next_func= &mail::imapFOLDER_COUNT::get_fetch_item;
+
+	mail::mimestruct bodystructure;
+	if (err_flag)
+	{
+		error(imapAccount);
+		return;
+	}
+
+	if (!fillbodystructure(imapAccount, parser, bodystructure, ""))
+		return;
+
+	if (imapAccount.currentFetch)
+		imapAccount.currentFetch
+			->messageStructureCallback(count-1, bodystructure);
+
+}
+
+void mail::imapFOLDER_COUNT::get_body(mail::imap &imapAccount, Token t)
+{
+	if (t == STRING)
+		next_func= &mail::imapFOLDER_COUNT::get_fetch_item;
+
+	if (t == STRING || t == LARGESTRING)
+	{
+		string buf=t.text;
+
+		size_t cr;
+
+		while ((cr=buf.find('\r')) != std::string::npos)
+			buf.erase(cr, 1);
+
+		if (imapAccount.currentFetch)
+		{
+			imapAccount.currentFetch->messageTextEstimatedSize =
+				t == LARGESTRING
+				? largestringsize:t.text.size();
+
+			imapAccount.currentFetch
+				->messageTextCompleted += t.text.size();
+
+			if (t == STRING)
+			{
+				imapAccount.currentFetch->messageTextCompleted
+					= imapAccount.currentFetch->
+					messageTextEstimatedSize;
+				++imapAccount.currentFetch->messageCntDone;
+			}
+
+			if (body_part_reference)
+				// Processing References: header
+			{
+				references_buf += buf;
+
+				while (references_buf.size() > 10000)
+					// Prevent the server from DOssing us
+				{
+					size_t n=references_buf.find('>');
+
+					if (n != std::string::npos)
+						++n;
+					else n=references_buf.size()-10000;
+
+					references_buf
+						.erase(references_buf.begin(),
+						       references_buf.begin()
+						       +n);
+				}
+
+				if (t == STRING)
+				{
+					vector<address> address_list;
+					size_t err_index;
+
+					address::fromString(references_buf,
+							    address_list,
+							    err_index);
+
+					vector<string> msgid_list;
+
+					vector<address>::iterator
+						b=address_list.begin(),
+						e=address_list.end();
+
+					while (b != e)
+					{
+						string s=b->getAddr();
+
+						if (s.size() > 0)
+							msgid_list.push_back
+								("<" +
+								 s + ">");
+						++b;
+					}
+
+					if (msgid_list.size() > 0)
+						imapAccount.currentFetch->
+							messageReferencesCallback(count-1, msgid_list);
+				}
+			}
+			else
+				imapAccount.currentFetch
+					->messageTextCallback(count-1, buf);
+		}
+
+	}
+	else
+		error(imapAccount);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//  The STORE command.
+//
+
+LIBMAIL_START
+
+class imapSTORE : public imapCommandHandler {
+
+	mail::callback &callback;
+
+	string storecmd;
+
+public:
+	imapSTORE(mail::callback &callbackArg, string storecmdArg);
+	~imapSTORE();
+
+	void installed(imap &imapAccount);
+
+private:
+	const char *getName();
+	void timedOut(const char *errmsg);
+
+	bool untaggedMessage(imap &imapAccount, string name);
+	bool taggedMessage(imap &imapAccount, string name,
+			   string message,
+			   bool okfail, string errmsg);
+};
+
+LIBMAIL_END
+
+void mail::imapSTORE::timedOut(const char *errmsg)
+{
+	callbackTimedOut(callback, errmsg);
+}
+
+mail::imapSTORE::imapSTORE(mail::callback &callbackArg,
+				 string storecmdArg)
+	: callback(callbackArg), storecmd(storecmdArg)
+{
+}
+
+mail::imapSTORE::~imapSTORE()
+{
+}
+
+void mail::imapSTORE::installed(mail::imap &imapAccount)
+{
+	imapAccount.imapcmd("STORE", storecmd + "\r\n");
+}
+
+const char *mail::imapSTORE::getName()
+{
+	return "STORE";
+}
+
+bool mail::imapSTORE::untaggedMessage(mail::imap &imapAccount, string name)
+{
+	return false;
+}
+
+bool mail::imapSTORE::taggedMessage(mail::imap &imapAccount, string name,
+				    string message,
+				    bool okfail, string errmsg)
+{
+	if (name == "STORE")
+	{
+		if (okfail)
+			callback.success(errmsg);
+		else
+			callback.fail(errmsg);
+		imapAccount.uninstallHandler(this);
+		return true;
+	}
+	return false;
+}
+
+bool mail::imap::keywordAllowed(string kwName)
+{
+	upper(kwName);
+
+	return permanentFlags.count(kwName) > 0 ||
+		permanentFlags.count("\\*") > 0;
+}
+
+void mail::imap::saveFolderIndexInfo(size_t messageNum,
+				     const mail::messageInfo &indexInfo,
+				     mail::callback &callback)
+{
+	if (!ready(callback))
+		return;
+
+	if (messageNum >= getFolderIndexSize())
+	{
+		callback.success("Invalid message number - ignored.");
+		return;
+	}
+
+	if (smap)
+	{
+		string flags;
+
+#define FLAG
+#define NOTFLAG !
+#define DOFLAG(NOT, field, name) \
+		if (NOT indexInfo.field) flags += "," name
+
+		LIBMAIL_SMAPFLAGS;
+#undef DOFLAG
+#undef NOTFLAG
+#undef FLAG
+
+		if (flags.size() > 0)
+			flags=flags.substr(1);
+
+
+		installForegroundTask(new smapSTORE(messageNum,
+						    "FLAGS=" + flags,
+						    *this,
+						    callback));
+		return;
+	}
+
+	bool fakeUpdateFlag;
+
+	string flags=messageFlagStr(indexInfo,
+				    &currentFolder->index[messageNum],
+				    &fakeUpdateFlag);
+
+	{
+		set<string> oflags;
+		currentFolder->index[messageNum].keywords.getFlags(oflags);
+
+		set<string>::iterator b=oflags.begin(), e=oflags.end();
+
+		while (b != e)
+		{
+			if (keywordAllowed(*b))
+			{
+				if (flags.size() > 0)
+					flags += " ";
+				flags += *b;
+			}
+
+			++b;
+		}
+	}
+
+	string messageNumBuffer;
+
+	{
+		ostringstream o;
+
+		o << "STORE " << (messageNum+1) << " FLAGS (";
+		messageNumBuffer=o.str();
+	}
+
+	installForegroundTask(new mail::imapSTORE(callback,
+						  messageNumBuffer
+						  + flags + ")"));
+
+	if (fakeUpdateFlag && messageNum < currentFolder->exists)
+		currentFolder->folderCallback.messageChanged(messageNum);
+}
+
+/////////////////////////////////////////////////////////////////////////
+//
+//  A STORE for a list may be broken up into multiple commands.
+//  Count the number of tagged STORE acknowledgments received, and run the
+//  app callback only after the last STORE ack comes in.
+
+LIBMAIL_START
+
+class imapUpdateFlagsCallback : public mail::callback {
+
+	mail::callback &origCallback;
+
+	void reportProgress(size_t bytesCompleted,
+			    size_t bytesEstimatedTotal,
+
+			    size_t messagesCompleted,
+			    size_t messagesEstimatedTotal);
+
+public:
+	imapUpdateFlagsCallback(mail::callback &callback);
+	~imapUpdateFlagsCallback();
+
+	void success(string message);
+	void fail(string message);
+
+	bool failFlag;
+	string message;
+
+	size_t cnt;
+};
+
+LIBMAIL_END
+
+mail::imapUpdateFlagsCallback::imapUpdateFlagsCallback(mail::callback
+							     &callback)
+	: origCallback(callback),
+	  failFlag(false), message(""), cnt(0)
+{
+}
+
+mail::imapUpdateFlagsCallback::~imapUpdateFlagsCallback()
+{
+}
+
+void mail::imapUpdateFlagsCallback::success(string message)
+{
+	// If any failures were received, the app fail() callback will be
+	// invoked.
+
+	if (!failFlag)
+		this->message=message;
+
+	if (--cnt == 0)
+	{
+		if (failFlag)
+			origCallback.fail(message);
+		else
+			origCallback.success(message);
+		delete this;
+	}
+}
+
+void mail::imapUpdateFlagsCallback::fail(string message)
+{
+	this->message=message;
+	failFlag=true;
+	success(message);
+}
+
+void mail::imapUpdateFlagsCallback
+::reportProgress(size_t bytesCompleted,
+		 size_t bytesEstimatedTotal,
+
+		 size_t messagesCompleted,
+		 size_t messagesEstimatedTotal)
+{
+	origCallback.reportProgress(bytesCompleted,
+				    bytesEstimatedTotal,
+				    messagesCompleted,
+				    messagesEstimatedTotal);
+}
+
+void mail::imap::updateFolderIndexFlags(const vector<size_t> &messages,
+					bool doFlip,
+					bool enableDisable,
+					const mail::messageInfo &flags,
+					mail::callback &callback)
+{
+	if (doFlip)
+	{
+		mail::imapUpdateFlagsCallback *myCallback=
+			new mail::imapUpdateFlagsCallback(callback);
+
+		if (!myCallback)
+		{
+			callback.fail("Out of memory.");
+			return;
+		}
+
+		//
+		// Very ugly, but this is the cleanest ugly solution.
+		// For each flipped flag, segregate messages whose
+		// flag should be turned on, and ones that should be
+		// turned off, and issue a separate STORE for each set.
+		// Lather, rinse, repeat, for all flags.
+		//
+
+		try {
+
+#define DOFLAG(NOT, field, name) { \
+		vector<size_t> enabled, disabled;\
+\
+		vector<size_t>::const_iterator b=messages.begin(),\
+			e=messages.end();\
+\
+		while (b != e)\
+		{\
+			size_t n= *b++;\
+\
+			if (n >= getFolderIndexSize())\
+				continue;\
+\
+			mail::messageInfo &info=currentFolder->index[n];\
+\
+			if ( flags.field ) \
+			{ \
+				if (info.field)\
+					disabled.push_back(n);\
+				else\
+					enabled.push_back(n);\
+			}\
+		}\
+\
+		mail::messageInfo oneFlag;\
+\
+		oneFlag.field=true;\
+		++myCallback->cnt;\
+		updateFolderIndexFlags(enabled, true, oneFlag, *myCallback);\
+		++myCallback->cnt;\
+		updateFolderIndexFlags(disabled, false, oneFlag, *myCallback);\
+		}
+
+			++myCallback->cnt;
+#define NOTFLAG
+#define FLAG
+			LIBMAIL_MSGFLAGS;
+#undef NOTFLAG
+#undef FLAG
+#undef DOFLAG
+			myCallback->success("Success");
+
+		} catch (...) {
+			delete myCallback;
+
+			callback.fail("An exception occured in updateFolderIndexFlags()");
+		}
+		return;
+	}
+
+	updateFolderIndexFlags(messages, enableDisable, flags, callback);
+}
+
+LIBMAIL_START
+
+class imapMessageCallbackStub : public mail::callback::message {
+
+	mail::callback &origCallback;
+
+	void reportProgress(size_t bytesCompleted,
+			    size_t bytesEstimatedTotal,
+
+			    size_t messagesCompleted,
+			    size_t messagesEstimatedTotal);
+
+public:
+	imapMessageCallbackStub(mail::callback &callbackArg);
+	~imapMessageCallbackStub();
+
+	void success(string message);
+	void fail(string message);
+};
+
+LIBMAIL_END
+
+mail::imapMessageCallbackStub
+::imapMessageCallbackStub(mail::callback &callbackArg)
+	: origCallback(callbackArg)
+{
+}
+
+mail::imapMessageCallbackStub::~imapMessageCallbackStub()
+{
+}
+
+void mail::imapMessageCallbackStub::success(string message)
+{
+	origCallback.success(message);
+	delete this;
+}
+
+void mail::imapMessageCallbackStub::fail(string message)
+{
+	origCallback.fail(message);
+	delete this;
+}
+
+void mail::imapMessageCallbackStub
+::reportProgress(size_t bytesCompleted,
+		 size_t bytesEstimatedTotal,
+		 size_t messagesCompleted,
+		 size_t messagesEstimatedTotal)
+{
+	origCallback.reportProgress(bytesCompleted, bytesEstimatedTotal,
+				    messagesCompleted, messagesEstimatedTotal);
+}
+
+void mail::imap::updateFolderIndexFlags(const vector<size_t> &messages,
+					bool enableDisable,
+					const mail::messageInfo &flags,
+					mail::callback &callback)
+{
+	if (smap)
+	{
+		const char *plus="+FLAGS=";
+		const char *minus="-FLAGS=";
+
+
+		string lista;
+		string listb;
+
+#define FLAG lista
+#define NOTFLAG listb
+#define DOFLAG(FLAG, field, name) \
+		if (flags.field) FLAG += "," name
+
+		LIBMAIL_SMAPFLAGS;
+#undef DOFLAG
+#undef NOTFLAG
+#undef FLAG
+
+		if (lista.size() > 0)
+			lista=(enableDisable ? plus:minus)
+				+ lista.substr(1);
+
+		if (listb.size() > 0)
+			listb=(enableDisable ? minus:plus)
+				+ listb.substr(1);
+
+
+		installForegroundTask(new smapSTORE(messages,
+						    lista + " " + listb,
+						    *this,
+						    callback));
+		return;
+	}
+
+	const char *plusminus=NULL;
+
+	string name="";
+	
+#define DOFLAG(MARK, field, n)  if ( flags.field ) { plusminus=MARK; name += " " n; }
+#define FLAG "+-"
+#define NOTFLAG "-+"
+
+	LIBMAIL_MSGFLAGS;
+
+#undef FLAG
+#undef NOTFLAG
+#undef DOFLAG
+
+	if (!plusminus || messages.size() == 0)
+	{
+		callback.success("Ok");
+		return;
+	}
+
+	name=name.substr(1);
+
+	char buf[2];
+
+	buf[0]=plusminus[enableDisable ? 0:1];
+	buf[1]=0;
+
+	mail::imapMessageCallbackStub *c=
+		new mail::imapMessageCallbackStub(callback);
+
+	if (!c)
+	{
+		callback.fail("Out of memory.");
+		return;
+	}
+
+	try {
+		messagecmd(messages, string(" ")
+			   + buf + "FLAGS (" + name + ")",
+			   "UID STORE", "STORE", *c);
+	} catch (...) {
+		delete c;
+		LIBMAIL_THROW(LIBMAIL_THROW_EMPTY);
+	}
+}
+
+class mail::imap::updateImapKeywordHelper : public mail::callback {
+
+	mail::callback *origCallback;
+	mail::ptr<mail::imap> myimap;
+
+public:
+	set<string> newflags;
+	set<string> uids;
+
+	updateImapKeywordHelper(mail::callback *origCallbackArg,
+				mail::imap *myimapArg);
+	~updateImapKeywordHelper();
+
+	void success(std::string message);
+	void fail(std::string message);
+
+	void reportProgress(size_t bytesCompleted,
+			    size_t bytesEstimatedTotal,
+
+			    size_t messagesCompleted,
+			    size_t messagesEstimatedTotal);
+};
+
+
+
+void mail::imap::updateKeywords(const vector<size_t> &messages,
+				const set<string> &keywords,
+				bool setOrChange,
+				// false: set, true: see changeTo
+				bool changeTo,
+				callback &cb)
+{
+	set<string>::const_iterator b=keywords.begin(), e=keywords.end();
+
+	while (b != e)
+	{
+		string::const_iterator sb=b->begin(), se=b->end();
+
+		while (sb != se)
+		{
+			if (strchr(smap ? ",\t\r\n,":"() \t\r\n[]{}\\\"", *sb))
+			{
+				cb.fail("Invalid flag");
+				return;
+			}
+			++sb;
+		}
+		++b;
+	}
+
+	b=keywords.begin();
+	e=keywords.end();
+
+	if (smap)
+	{
+		string setCmd= setOrChange ? changeTo
+			? "+KEYWORDS=":"-KEYWORDS=":"KEYWORDS=";
+
+		const char *comma="";
+
+		while (b != e)
+		{
+			setCmd += comma;
+			setCmd += *b;
+			++b;
+			comma=",";
+		}
+
+		installForegroundTask(new smapSTORE(messages,
+						    quoteSMAP(setCmd),
+						    *this, cb));
+		return;
+	}
+
+	if (!setOrChange)
+	{
+		updateImapKeywordHelper *h=
+			new updateImapKeywordHelper(&cb, this);
+
+		if (!h)
+		{
+			cb.fail(strerror(errno));
+			return;
+		}
+
+		try {
+			h->newflags=keywords;
+
+			map<string, string> allFlags;
+			// Keyed by upper(name), value=name
+			// (be nice, and preserve casing when turning off
+			// flags).
+
+			vector<size_t>::const_iterator mb=messages.begin(),
+				me=messages.end();
+
+			while (mb != me)
+			{
+				size_t n= *mb;
+
+				++mb;
+
+				if (n >= currentFolder->index.size())
+					continue;
+
+				h->uids.insert(currentFolder->index[n].uid);
+				set<string> tempSet;
+
+				currentFolder->index[n].keywords
+					.getFlags(tempSet);
+
+				set<string>::iterator
+					tsb=tempSet.begin(),
+					tse=tempSet.end();
+
+				while (tsb != tse)
+				{
+					string flagName= *tsb;
+
+					// IMAP kws are case insensitive
+
+					mail::upper(flagName);
+					allFlags.insert(make_pair(flagName,
+								  *tsb));
+					++tsb;
+				}
+			}
+
+			b=keywords.begin();
+			e=keywords.end();
+
+			while (b != e)
+			{
+				string flagName= *b;
+				++b;
+
+				mail::upper(flagName);
+				allFlags.erase(flagName);
+				// No need to remove flags that are going to be
+				// set anyway.
+			}
+
+			if (allFlags.empty())
+				h->success("Ok - no keywords changed.");
+			// Nothing to turn off, so punt it.
+			else
+			{
+				set<string> allFlagsV;
+
+				map<string, string>::iterator b=
+					allFlags.begin(), e=allFlags.end();
+
+				while (b != e)
+				{
+					allFlagsV.insert(b->second);
+					++b;
+				}
+
+				allFlags.clear();
+
+				updateImapKeywords(messages, allFlagsV,
+						   false, *h);
+			}
+		} catch (...) {
+			delete h;
+		}
+		return;
+	}
+
+	updateImapKeywords(messages, keywords, changeTo, cb);
+}
+
+mail::imap::updateImapKeywordHelper
+::updateImapKeywordHelper(mail::callback *origCallbackArg,
+			  mail::imap *myimapArg)
+	: origCallback(origCallbackArg), myimap(myimapArg)
+{
+}
+
+mail::imap::updateImapKeywordHelper::~updateImapKeywordHelper()
+{
+	if (origCallback)
+		origCallback->fail("Aborted.");
+}
+
+void mail::imap::updateImapKeywordHelper::success(std::string message)
+{
+	vector<size_t> msgSet;
+
+	mail::imapFOLDERinfo *f=myimap.isDestroyed() ? NULL:
+		myimap->currentFolder;
+
+	size_t n=f ? f->index.size():0;
+	size_t i;
+
+	for (i=0; i<n; i++)
+		if (uids.count(f->index[i].uid) > 0)
+			msgSet.push_back(i);
+
+	try {
+		myimap->updateImapKeywords(msgSet, newflags, true,
+					   *origCallback);
+		origCallback=NULL;
+		delete this;
+	} catch (...) {
+		delete this;
+	}
+}
+
+void mail::imap::updateImapKeywordHelper::fail(std::string message)
+{
+	mail::callback *c=origCallback;
+	origCallback=NULL;
+	delete this;
+
+	c->fail(message);
+}
+
+void mail::imap::updateImapKeywordHelper
+::reportProgress(size_t bytesCompleted,
+		 size_t bytesEstimatedTotal,
+		 size_t messagesCompleted,
+		 size_t messagesEstimatedTotal)
+{
+}
+
+void mail::imap::updateImapKeywords(const vector<size_t> &messages,
+				    const set<string> &keywords,
+				    bool changeTo,
+				    callback &cb)
+{
+	set<string>::const_iterator b=keywords.begin(), e=keywords.end();
+	string setCmd= changeTo	? " +FLAGS (":" -FLAGS (";
+	const char *space="";
+
+	while (b != e)
+	{
+		string flagname= *b;
+
+		if (!keywordAllowed(flagname))
+		{
+			vector<size_t>::const_iterator mb, me;
+
+			mb=messages.begin();
+			me=messages.end();
+
+			while (mb != me)
+			{
+				size_t n= *mb;
+				++mb;
+
+				if (n >= (currentFolder ?
+					  currentFolder->index.size():0))
+					continue;
+
+				if (changeTo)
+				{
+					if (!currentFolder->index[n]
+					    .keywords.addFlag(keywordHashtable,
+							      flagname))
+					{
+						LIBMAIL_THROW(strerror(errno));
+					}
+				}
+				else
+				{
+					if (!currentFolder->index[n].keywords
+					    .remFlag(flagname))
+						LIBMAIL_THROW(strerror(errno));
+				}
+			}
+			++b;
+			continue;
+		}
+
+		setCmd += space;
+		setCmd += *b;
+		++b;
+		space=" ";
+	}
+
+	if (*space == 0)
+	{
+		MONITOR(mail::imap);
+
+		vector<size_t>::const_iterator mb, me;
+
+		mb=messages.begin();
+		me=messages.end();
+
+		while (!DESTROYED() && mb != me)
+		{
+			size_t n= *--me;
+
+			if (n >= (currentFolder ?
+				  currentFolder->index.size():0))
+				continue;
+
+			currentFolder->folderCallback.messageChanged(n);
+		}
+
+		cb.success("Ok.");
+		return;
+	}
+
+
+	mail::imapMessageCallbackStub *c=
+		new mail::imapMessageCallbackStub(cb);
+
+	if (!c)
+	{
+		cb.fail("Out of memory.");
+		return;
+	}
+
+	try {
+		messagecmd(messages, setCmd + ")",
+			   "UID STORE", "STORE", *c);
+	} catch (...) {
+		delete c;
+		LIBMAIL_THROW(LIBMAIL_THROW_EMPTY);
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+
+void mail::imap::copyMessagesTo(const vector<size_t> &messages,
+				mail::folder *copyTo,
+				mail::callback &callback)
+{
+	sameServerFolderPtr=NULL;
+
+	copyTo->sameServerAsHelperFunc();
+
+	if (!sameServerFolderPtr)
+	{
+		// Copy to some other server, use a generic function.
+
+		mail::copyMessages::copy(this, messages, copyTo, callback);
+		return;
+	}
+
+	if (smap)
+	{
+		installForegroundTask(new smapCOPY(messages, copyTo,
+						   *this,
+						   callback, "COPY"));
+		return;
+	}
+
+	mail::imapMessageCallbackStub *c=
+		new mail::imapMessageCallbackStub(callback);
+
+	if (!c)
+	{
+		callback.fail("Out of memory.");
+		return;
+	}
+
+	try {
+		messagecmd(messages, " " + quoteSimple(copyTo->getPath()),
+			   "UID COPY", "COPY", *c);
+	} catch (...) {
+		delete c;
+		LIBMAIL_THROW(LIBMAIL_THROW_EMPTY);
+	}
+
+}
+
+void mail::imap::moveMessagesTo(const vector<size_t> &messages,
+				mail::folder *copyTo,
+				mail::callback &callback)
+{
+	sameServerFolderPtr=NULL;
+
+	copyTo->sameServerAsHelperFunc();
+
+	if (smap && sameServerFolderPtr)
+	{
+		installForegroundTask(new smapCOPY(messages, copyTo,
+						   *this,
+						   callback, "MOVE"));
+		return;
+	}
+	
+	generic::genericMoveMessages(this, messages, copyTo, callback);
+}
+
+///////////////////////////////////////////////////////////////////////////
+//
+//  The search command.
+
+LIBMAIL_START
+
+class imapSEARCH : public imapCommandHandler {
+
+	string searchCmd;
+	bool hasStringArg;
+	string stringArg;
+
+	mail::searchCallback &callback;
+
+	vector<size_t> found;
+
+	class SearchResults : public imapHandlerStructured {
+		vector<size_t> &found;
+	public:
+		SearchResults(vector<size_t> &);
+		~SearchResults();
+
+		void installed(imap &imapAccount);
+	private:
+		const char *getName();
+		void timedOut(const char *errmsg);
+
+		void process(imap &imapAccount, Token t);
+	};
+
+public:
+	imapSEARCH(string searchCmdArg,
+			 bool hasParam2,
+			 string param2Arg,
+			 mail::searchCallback &callbackArg);
+	~imapSEARCH();
+
+	void installed(imap &);
+	const char *getName();
+	void timedOut(const char *errmsg);
+
+	bool untaggedMessage(imap &imapAccount, string name);
+	bool taggedMessage(imap &imapAccount, string name,
+			   string message,
+			   bool okfail, string errmsg);
+	bool continuationRequest(imap &imapAccount, string request);
+};
+
+LIBMAIL_END
+
+mail::imapSEARCH::imapSEARCH(string searchCmdArg,
+				   bool hasParam2,
+				   string param2Arg,
+				   mail::searchCallback &callbackArg)
+	: searchCmd(searchCmdArg),
+	  hasStringArg(hasParam2),
+	  stringArg(param2Arg),
+	  callback(callbackArg)
+{
+}
+
+mail::imapSEARCH::~imapSEARCH()
+{
+}
+
+void mail::imapSEARCH::installed(mail::imap &imapAccount)
+{
+	if (hasStringArg)
+	{
+		string::iterator b=stringArg.begin(), e=stringArg.end();
+
+		while (b != e)
+		{
+			if (*b < ' ' || *b >= 127)
+				break;
+			b++;
+		}
+
+		if (b == e)
+			searchCmd += mail::imap::quoteSimple(stringArg);
+		else
+		{
+			ostringstream o;
+
+			o << "{" << stringArg.size() << "}";
+
+			searchCmd += o.str();
+		}
+	}
+	imapAccount.imapcmd("SEARCH", "SEARCH " + searchCmd + "\r\n");
+}
+
+//
+// High-8 search string must be sent via a literal.
+//
+
+bool mail::imapSEARCH::continuationRequest(mail::imap &imapAccount, string request)
+{
+	imapAccount.socketWrite(stringArg + "\r\n");
+	return true;
+}
+
+const char *mail::imapSEARCH::getName()
+{
+	return "SEARCH";
+}
+
+void mail::imapSEARCH::timedOut(const char *errmsg)
+{
+	callback.fail(errmsg);
+}
+
+bool mail::imapSEARCH::untaggedMessage(mail::imap &imapAccount, string name)
+{
+	if (name == "SEARCH")
+	{
+		imapAccount.installBackgroundTask(new SearchResults(found));
+		return true;
+	}
+	return false;
+}
+
+bool mail::imapSEARCH::taggedMessage(mail::imap &imapAccount, string name,
+				     string message,
+				     bool okfail, string errmsg)
+{
+	if (name != "SEARCH")
+		return false;
+
+	if (okfail)
+		callback.success(found);
+	else
+		callback.fail(errmsg);
+
+	imapAccount.uninstallHandler(this);
+	return true;
+}
+
+mail::imapSEARCH::SearchResults::SearchResults(vector <size_t> &foundArg)
+	: found(foundArg)
+{
+}
+
+mail::imapSEARCH::SearchResults::~SearchResults()
+{
+}
+
+void mail::imapSEARCH::SearchResults::installed(mail::imap &imapAccount)
+{
+}
+
+const char *mail::imapSEARCH::SearchResults::getName()
+{
+	return "* SEARCH";
+}
+
+void mail::imapSEARCH::SearchResults::timedOut(const char *errmsg)
+{
+}
+
+void mail::imapSEARCH::SearchResults::process(mail::imap &imapAccount, Token t)
+{
+	if (t == EOL)
+		return;
+
+	if (t != ATOM)
+	{
+		error(imapAccount);
+		return;
+	}
+
+	size_t n=0;
+
+	istringstream i(t.text.c_str());
+
+	i >> n;
+
+	if (n == 0 || imapAccount.currentFolder == NULL
+	    || n > imapAccount.currentFolder->index.size())
+	{
+		error(imapAccount);
+		return;
+	}
+
+	found.push_back(n-1);
+}
+
+void mail::imap::searchMessages(const class mail::searchParams &searchInfo,
+				class mail::searchCallback &callback)
+{
+	if (smap)
+	{
+		installForegroundTask(new mail::smapSEARCH(searchInfo,
+							   callback,
+							   *this));
+		return;
+	}
+
+	if (folderFlags.count("\\FLAGGED") == 0)
+	{
+		// Server doesn't implement \Flagged, do everything by hand
+
+		mail::searchMessages::search(callback, searchInfo, this);
+		return;
+	}
+
+	string cmd="";
+
+	if (searchInfo.charset.size() > 0)
+		cmd="CHARSET " + quoteSimple(searchInfo.charset) + " ";
+
+	switch (searchInfo.scope) {
+
+	case searchParams::search_all:
+		cmd += "ALL";
+		break;
+
+	case searchParams::search_unmarked:
+		cmd += "ALL NOT FLAGGED";
+		break;
+
+	case searchParams::search_marked:
+		cmd += "ALL FLAGGED";
+		break;
+	case searchParams::search_range:
+
+		{
+			ostringstream o;
+
+			o << searchInfo.rangeLo+1 << ':'
+			  << searchInfo.rangeHi;
+
+			cmd += o.str();
+		}
+		break;
+	}
+
+	bool notFlag=searchInfo.searchNot;
+
+	if (searchInfo.criteria == searchInfo.unread)
+		notFlag= !notFlag;
+
+	if (notFlag)
+		cmd += " NOT";
+
+	string sizeNumStr="";
+
+	switch (searchInfo.criteria) {
+	case searchParams::larger:
+	case searchParams::smaller:
+
+		{
+			unsigned long sizeNum=0;
+
+			istringstream i(searchInfo.param2.c_str());
+
+			i >> sizeNum;
+
+			if (i.fail())
+			{
+				callback.fail("Invalid message size string.");
+				return;
+			}
+
+			string buffer;
+
+			{
+				ostringstream o;
+
+				o << sizeNum;
+				buffer=o.str();
+			}
+
+			sizeNumStr=buffer;
+		}
+		break;
+	default:
+		break;
+	}
+
+	string param2="";
+	bool hasParam2=false;
+
+	string::const_iterator b, e;
+
+	switch (searchInfo.criteria) {
+	case searchParams::replied:
+		cmd += " ANSWERED";
+		break;
+	case searchParams::deleted:
+		cmd += " DELETED";
+		break;
+	case searchParams::draft:
+		cmd += " DRAFT";
+		break;
+	case searchParams::unread:
+		cmd += " SEEN";
+		break;
+
+		// Header match
+		
+	case searchParams::from:
+		cmd += " FROM "; hasParam2=true; param2=searchInfo.param2;
+		break;
+	case searchParams::to:
+		cmd += " TO "; hasParam2=true; param2=searchInfo.param2;
+		break;
+	case searchParams::cc:
+		cmd += " CC "; hasParam2=true; param2=searchInfo.param2;
+		break;
+	case searchParams::bcc:
+		cmd += " BCC "; hasParam2=true; param2=searchInfo.param2;
+		break;
+	case searchParams::subject:
+		cmd += " SUBJECT "; hasParam2=true; param2=searchInfo.param2;
+		break;
+
+	case searchParams::header:
+
+		b=searchInfo.param1.begin();
+		e=searchInfo.param1.end();
+
+		while (b != e)
+		{
+			if (*b < ' '|| *b >= 127)
+			{
+				callback.fail("Invalid header name.");
+				return;
+			}
+		}
+
+		cmd += " HEADER " + quoteSimple(searchInfo.param1)
+			+ " "; hasParam2=true; param2=searchInfo.param2;
+		break;
+	case searchParams::body:
+		cmd += " BODY "; hasParam2=true; param2=searchInfo.param2;
+		break;
+	case searchParams::text:
+		cmd += " TEXT "; hasParam2=true; param2=searchInfo.param2;
+		break;
+
+		// Internal date:
+
+	case searchParams::before:
+		cmd += " BEFORE "; hasParam2=true; param2=searchInfo.param2;
+		break;
+	case searchParams::on:    
+		cmd += " ON "; hasParam2=true; param2=searchInfo.param2;
+		break;
+	case searchParams::since:
+		cmd += " SINCE "; hasParam2=true; param2=searchInfo.param2;
+		break;
+
+		// Sent date:
+
+	case searchParams::sentbefore:
+		cmd += " SENTBEFORE "; hasParam2=true; param2=searchInfo.param2;
+		break;
+	case searchParams::senton:
+		cmd += " SENTON "; hasParam2=true; param2=searchInfo.param2;
+		break;
+	case searchParams::sentsince:
+		cmd += " SENTSINCE "; hasParam2=true; param2=searchInfo.param2;
+		break;
+
+	case searchParams::larger:
+		cmd += " LARGER " + sizeNumStr;
+		break;
+	case searchParams::smaller:
+		cmd += " SMALLER " + sizeNumStr;
+		break;
+	default:
+		callback.fail("Unknown search criteria.");
+		return;
+	}
+
+	installForegroundTask(new mail::imapSEARCH(cmd, hasParam2, param2,
+						   callback));
+}
+
+
+///////////////////////////////////////////////////////////////////////////
+//
+// Convert flags in mail::messageInfo to IMAP flag names.
+// For those flags that are not supported on the server, update the
+// flags in the folder index manually, and set the flagsUpdated flag.
+
+string mail::imap::messageFlagStr(const mail::messageInfo &indexInfo,
+				  mail::messageInfo *oldIndexInfo,
+				  bool *flagsUpdated)
+{
+	string flags="";
+
+	if (flagsUpdated)
+		*flagsUpdated=false;
+
+#define DOFLAG(NOT, field, name) \
+	if (oldIndexInfo == NULL /* APPEND assumes all flags are present */ ||\
+			folderFlags.count( name ) > 0)\
+	{\
+		if (NOT indexInfo.field)\
+			flags += " " name;\
+	}\
+	else if ( oldIndexInfo->field != indexInfo.field)\
+	{\
+		oldIndexInfo->field=indexInfo.field;\
+		*flagsUpdated=true;\
+	}
+
+#define FLAG
+#define NOTFLAG !
+
+	LIBMAIL_MSGFLAGS;
+
+#undef FLAG
+#undef DOFLAG
+#undef NOTFLAG
+
+
+	if (flags.size() > 0)
+		flags=flags.substr(1);
+
+	return flags;
+}
+
+////////////////////////////////////////////////////////////////////////////
+//
+// The IMAP EXPUNGE command.
+
+LIBMAIL_START
+
+class imapEXPUNGE : public imapCommandHandler {
+
+	mail::callback &callback;
+
+public:
+	imapEXPUNGE(mail::callback &callbackArg);
+	~imapEXPUNGE();
+
+	void installed(imap &imapAccount);
+
+private:
+	const char *getName();
+	void timedOut(const char *errmsg);
+
+	bool untaggedMessage(imap &imapAccount, string name);
+	bool taggedMessage(imap &imapAccount, string name,
+			   string message,
+			   bool okfail, string errmsg);
+};
+
+LIBMAIL_END
+
+mail::imapEXPUNGE::imapEXPUNGE(mail::callback &callbackArg)
+	: callback(callbackArg)
+{
+}
+
+void mail::imapEXPUNGE::timedOut(const char *errmsg)
+{
+	callbackTimedOut(callback, errmsg);
+}
+
+mail::imapEXPUNGE::~imapEXPUNGE()
+{
+}
+
+void mail::imapEXPUNGE::installed(mail::imap &imapAccount)
+{
+	imapAccount.imapcmd("EXPUNGE", "EXPUNGE\r\n");
+}
+
+const char *mail::imapEXPUNGE::getName()
+{
+	return "EXPUNGE";
+}
+
+bool mail::imapEXPUNGE::untaggedMessage(mail::imap &imapAccount, string name)
+{
+	return false;
+}
+
+bool mail::imapEXPUNGE::taggedMessage(mail::imap &imapAccount, string name,
+				      string message,
+				      bool okfail, string errmsg)
+{
+	if (name == "EXPUNGE")
+	{
+		if (okfail)
+			callback.success(errmsg);
+		else
+			callback.fail(errmsg);
+		imapAccount.uninstallHandler(this);
+		return true;
+	}
+	return false;
+}
+
+void mail::imap::updateNotify(bool enableDisable, callback &callbackArg)
+{
+	if (!ready(callbackArg))
+		return;
+
+	wantIdleMode=enableDisable;
+	updateNotify(&callbackArg);
+}
+
+void mail::imap::updateNotify(callback *callbackArg)
+{
+	if (!smap && (!hasCapability("IDLE") || noIdle))
+	{
+		if (callbackArg)
+			callbackArg->success("Ok");
+		return;
+	}
+
+	installForegroundTask(smap ?
+			      (imapHandler *)new smapIdleHandler(wantIdleMode,
+								 callbackArg):
+			      new imapIdleHandler(wantIdleMode, callbackArg));
+}
+
+void mail::imap::updateFolderIndexInfo(mail::callback &callback)
+{
+	if (!ready(callback))
+		return;
+
+	installForegroundTask(smap ?
+			      (imapHandler *)new smapNoopExpunge("EXPUNGE",
+								 callback,
+								 *this)
+			      : new mail::imapEXPUNGE(callback));
+}
+
+//////////////////////////////////////////////////////////////////////////
+//
+// UID EXPUNGE
+
+////////////////////////////////////////////////////////////////////////////
+//
+// The IMAP EXPUNGE command.
+
+LIBMAIL_START
+
+class imapUIDEXPUNGE : public mail::callback::message {
+
+	set<string> uids;
+
+	ptr<mail::imap> acct;
+	mail::callback &callback;
+
+	bool uidSent;
+
+public:
+
+	imapUIDEXPUNGE(mail::imap &imapAccount,
+		       mail::callback &callbackArg,
+		       const vector<size_t> &msgs);
+	~imapUIDEXPUNGE();
+
+	void mkVector(mail::imap &, vector<size_t> &);
+
+private:
+	void success(string msg);
+	void fail(string msg);
+
+	void reportProgress(size_t bytesCompleted,
+			    size_t bytesEstimatedTotal,
+
+			    size_t messagesCompleted,
+			    size_t messagesEstimatedTotal);
+
+};
+
+LIBMAIL_END
+
+mail::imapUIDEXPUNGE::imapUIDEXPUNGE(mail::imap &imapAccount,
+				     mail::callback &callbackArg,
+				     const vector<size_t> &msgs)
+	: acct(&imapAccount), callback(callbackArg), uidSent(false)
+{
+	vector<size_t>::const_iterator b, e;
+
+	for (b=msgs.begin(), e=msgs.end(); b != e; b++)
+	{
+		if (imapAccount.currentFolder &&
+		    *b < imapAccount.currentFolder->index.size())
+			uids.insert(imapAccount.currentFolder
+				    ->index[*b].uid);
+	}
+}
+
+mail::imapUIDEXPUNGE::~imapUIDEXPUNGE()
+{
+}
+
+void mail::imapUIDEXPUNGE::mkVector(mail::imap &imapAccount,
+				    vector<size_t> &vec)
+{
+	if (imapAccount.currentFolder)
+	{
+		size_t i;
+
+		for (i=0; i<imapAccount.currentFolder->exists; i++)
+		{
+			if (uids.count(imapAccount.currentFolder
+				       ->index[i].uid) > 0)
+				vec.push_back(i);
+		}
+	}
+}
+
+void mail::imapUIDEXPUNGE::success(string dummy)
+{
+	if (acct.isDestroyed() || uidSent)
+	{
+		callback.success(dummy);
+		delete this;
+		return;
+	}
+
+	vector<size_t> vec;
+
+	mkVector(*acct, vec);
+
+	if (vec.size() == 0)
+	{
+		mail::callback * volatile c= &callback;
+
+		delete this;
+
+		c->fail(dummy);
+		return;
+	}
+
+	uidSent=true;
+	acct->messagecmd(vec, "", "UID EXPUNGE", "EXPUNGE", *this);
+}
+
+void mail::imapUIDEXPUNGE::reportProgress(size_t bytesCompleted,
+					  size_t bytesEstimatedTotal,
+
+					  size_t messagesCompleted,
+					  size_t messagesEstimatedTotal)
+{
+}
+
+void mail::imapUIDEXPUNGE::fail(string dummy)
+{
+	mail::callback * volatile c= &callback;
+
+	delete this;
+
+	c->fail(dummy);
+}
+
+void mail::imap::removeMessages(const std::vector<size_t> &messages,
+				callback &cb)
+{
+	if (!ready(cb))
+		return;
+
+	if (smap)
+	{
+		installForegroundTask(new smapNoopExpunge(messages, cb,
+							  *this));
+		return;
+	}
+
+	if (!hasCapability("UIDPLUS"))
+	{
+		mail::generic::genericRemoveMessages(this, messages, cb);
+		return;
+	}
+
+	imapUIDEXPUNGE *exp=new imapUIDEXPUNGE(*this, cb, messages);
+
+	try {
+		vector<size_t> msgs;
+
+		exp->mkVector(*this, msgs);
+
+		if (msgs.size() == 0)
+		{
+			delete exp;
+			exp=NULL;
+
+			cb.success("OK");
+			return;
+		}
+
+		messagecmd(msgs, " +FLAGS.SILENT (\\Deleted)",
+			   "UID STORE", "STORE", *exp);
+	} catch (...) {
+		if (exp)
+			delete exp;
+
+		cb.fail("An exception occured in removeMessages");
+		return;
+	}
+}