initial/final commitHEADmaster

28 files changed, 12709 insertions, 0 deletions

diff --git a/vmime-master/src/vmime/net/imap/IMAPCommand.cpp b/vmime-master/src/vmime/net/imap/IMAPCommand.cpp
new file mode 100644
index 0000000..8911ed0
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPCommand.cpp
@@ -0,0 +1,437 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/imap/IMAPCommand.hpp"
+#include "vmime/net/imap/IMAPConnection.hpp"
+#include "vmime/net/imap/IMAPUtils.hpp"
+
+#include <sstream>
+
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+IMAPCommand::IMAPCommand(const string& text, const string& traceText)
+	: m_text(text),
+	  m_traceText(traceText) {
+
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::LOGIN(const string& username, const string& password) {
+
+	std::ostringstream cmd;
+	cmd.imbue(std::locale::classic());
+	cmd << "LOGIN " << IMAPUtils::quoteString(username)
+	    << " " << IMAPUtils::quoteString(password);
+
+	std::ostringstream trace;
+	trace.imbue(std::locale::classic());
+	trace << "LOGIN {username} {password}";
+
+	return createCommand(cmd.str(), trace.str());
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::AUTHENTICATE(const string& mechName) {
+
+	std::ostringstream cmd;
+	cmd.imbue(std::locale::classic());
+	cmd << "AUTHENTICATE " << mechName;
+
+	return createCommand(cmd.str());
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::AUTHENTICATE(const string& mechName, const string& initialResponse) {
+
+	std::ostringstream cmd;
+	cmd.imbue(std::locale::classic());
+	cmd << "AUTHENTICATE " << mechName << " " << initialResponse;
+
+	return createCommand(cmd.str());
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::LIST(const string& refName, const string& mailboxName) {
+
+	std::ostringstream cmd;
+	cmd.imbue(std::locale::classic());
+	cmd << "LIST " << IMAPUtils::quoteString(refName)
+	    << " " << IMAPUtils::quoteString(mailboxName);
+
+	return createCommand(cmd.str());
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::SELECT(
+	const bool readOnly,
+	const string& mailboxName,
+	const std::vector <string>& params
+) {
+
+	std::ostringstream cmd;
+	cmd.imbue(std::locale::classic());
+
+	if (readOnly) {
+		cmd << "EXAMINE ";
+	} else {
+		cmd << "SELECT ";
+	}
+
+	cmd << IMAPUtils::quoteString(mailboxName);
+
+	if (!params.empty()) {
+
+		cmd << " (";
+
+		for (size_t i = 0, n = params.size() ; i < n ; ++i) {
+			if (i != 0) cmd << " ";
+			cmd << params[i];
+		}
+
+		cmd << ")";
+	}
+
+	return createCommand(cmd.str());
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::STATUS(
+	const string& mailboxName,
+	const std::vector <string>& attribs
+) {
+
+	std::ostringstream cmd;
+	cmd.imbue(std::locale::classic());
+	cmd << "STATUS " << IMAPUtils::quoteString(mailboxName);
+
+	cmd << " (";
+
+	for (size_t i = 0, n = attribs.size() ; i < n ; ++i) {
+		if (i != 0) cmd << " ";
+		cmd << attribs[i];
+	}
+
+	cmd << ")";
+
+	return createCommand(cmd.str());
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::CREATE(
+	const string& mailboxName,
+	const std::vector <string>& params
+) {
+
+	std::ostringstream cmd;
+	cmd.imbue(std::locale::classic());
+	cmd << "CREATE " << IMAPUtils::quoteString(mailboxName);
+
+	if (!params.empty()) {
+
+		cmd << " (";
+
+		for (size_t i = 0, n = params.size() ; i < n ; ++i) {
+			if (i != 0) cmd << " ";
+			cmd << params[i];
+		}
+
+		cmd << ")";
+	}
+
+	return createCommand(cmd.str());
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::DELETE(const string& mailboxName) {
+
+	std::ostringstream cmd;
+	cmd.imbue(std::locale::classic());
+	cmd << "DELETE " << IMAPUtils::quoteString(mailboxName);
+
+	return createCommand(cmd.str());
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::RENAME(
+	const string& mailboxName,
+	const string& newMailboxName
+) {
+
+	std::ostringstream cmd;
+	cmd.imbue(std::locale::classic());
+	cmd << "RENAME " << IMAPUtils::quoteString(mailboxName)
+	    << " " << IMAPUtils::quoteString(newMailboxName);
+
+	return createCommand(cmd.str());
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::FETCH(
+	const messageSet& msgs,
+	const std::vector <string>& params
+) {
+
+	std::ostringstream cmd;
+	cmd.imbue(std::locale::classic());
+
+	if (msgs.isUIDSet()) {
+		cmd << "UID FETCH " << IMAPUtils::messageSetToSequenceSet(msgs);
+	} else {
+		cmd << "FETCH " << IMAPUtils::messageSetToSequenceSet(msgs);
+	}
+
+	if (params.size() == 1) {
+
+		cmd << " " << params[0];
+
+	} else {
+
+		cmd << " (";
+
+		for (size_t i = 0, n = params.size() ; i < n ; ++i) {
+			if (i != 0) cmd << " ";
+			cmd << params[i];
+		}
+
+		cmd << ")";
+	}
+
+	return createCommand(cmd.str());
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::STORE(
+	const messageSet& msgs,
+	const int mode,
+	const std::vector <string>& flags
+) {
+
+	std::ostringstream cmd;
+	cmd.imbue(std::locale::classic());
+
+	if (msgs.isUIDSet()) {
+		cmd << "UID STORE " << IMAPUtils::messageSetToSequenceSet(msgs);
+	} else {
+		cmd << "STORE " << IMAPUtils::messageSetToSequenceSet(msgs);
+	}
+
+	if (mode == message::FLAG_MODE_ADD) {
+		cmd << " +FLAGS ";
+	} else if (mode == message::FLAG_MODE_REMOVE) {
+		cmd << " -FLAGS ";
+	} else { // if (mode == message::FLAG_MODE_SET)
+		cmd << " FLAGS ";
+	}
+
+	cmd << "(";
+
+	for (size_t i = 0, n = flags.size() ; i < n ; ++i) {
+		if (i != 0) cmd << " ";
+		cmd << flags[i];
+	}
+
+	cmd << ")";
+
+	return createCommand(cmd.str());
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::APPEND(
+	const string& mailboxName,
+	const std::vector <string>& flags,
+	vmime::datetime* date,
+	const size_t size
+) {
+
+	std::ostringstream cmd;
+	cmd.imbue(std::locale::classic());
+	cmd << "APPEND " << IMAPUtils::quoteString(mailboxName);
+
+	if (!flags.empty()) {
+
+		cmd << " (";
+
+		for (size_t i = 0, n = flags.size() ; i < n ; ++i) {
+			if (i != 0) cmd << " ";
+			cmd << flags[i];
+		}
+
+		cmd << ")";
+	}
+
+	if (date != NULL) {
+		cmd << " " << IMAPUtils::dateTime(*date);
+	}
+
+	cmd << " {" << size << "}";
+
+	return createCommand(cmd.str());
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::COPY(
+	const messageSet& msgs,
+	const string& mailboxName
+) {
+
+	std::ostringstream cmd;
+	cmd.imbue(std::locale::classic());
+
+	if (msgs.isUIDSet()) {
+		cmd << "UID COPY " << IMAPUtils::messageSetToSequenceSet(msgs);
+	} else {
+		cmd << "COPY " << IMAPUtils::messageSetToSequenceSet(msgs);
+	}
+
+	cmd << " " << IMAPUtils::quoteString(mailboxName);
+
+	return createCommand(cmd.str());
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::SEARCH(
+	const std::vector <string>& keys,
+	const vmime::charset* charset
+) {
+
+	std::ostringstream cmd;
+	cmd.imbue(std::locale::classic());
+	cmd << "SEARCH";
+
+	if (charset) {
+		cmd << " CHARSET " << charset->getName();
+	}
+
+	for (size_t i = 0, n = keys.size() ; i < n ; ++i) {
+		cmd << " " << keys[i];
+	}
+
+	return createCommand(cmd.str());
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::STARTTLS() {
+
+	return createCommand("STARTTLS");
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::CAPABILITY() {
+
+	return createCommand("CAPABILITY");
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::NOOP() {
+
+	return createCommand("NOOP");
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::EXPUNGE() {
+
+	return createCommand("EXPUNGE");
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::CLOSE() {
+
+	return createCommand("CLOSE");
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::LOGOUT() {
+
+	return createCommand("LOGOUT");
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPCommand::createCommand(
+	const string& text,
+	const string& traceText
+) {
+
+	if (traceText.empty()) {
+		return shared_ptr <IMAPCommand>(new IMAPCommand(text, text));
+	} else {
+		return shared_ptr <IMAPCommand>(new IMAPCommand(text, traceText));
+	}
+}
+
+
+const string IMAPCommand::getText() const {
+
+	return m_text;
+}
+
+
+const string IMAPCommand::getTraceText() const {
+
+	return m_traceText;
+}
+
+
+void IMAPCommand::send(const shared_ptr <IMAPConnection>& conn) {
+
+	conn->sendCommand(dynamicCast <IMAPCommand>(shared_from_this()));
+}
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
diff --git a/vmime-master/src/vmime/net/imap/IMAPCommand.hpp b/vmime-master/src/vmime/net/imap/IMAPCommand.hpp
new file mode 100644
index 0000000..4915a57
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPCommand.hpp
@@ -0,0 +1,124 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_NET_IMAP_IMAPCOMMAND_HPP_INCLUDED
+#define VMIME_NET_IMAP_IMAPCOMMAND_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/object.hpp"
+#include "vmime/base.hpp"
+#include "vmime/dateTime.hpp"
+
+#include "vmime/net/messageSet.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+class IMAPConnection;
+
+
+/** An IMAP command that will be sent to the server.
+  */
+class VMIME_EXPORT IMAPCommand : public object, public enable_shared_from_this <IMAPCommand> {
+
+public:
+
+	static shared_ptr <IMAPCommand> LOGIN(const string& username, const string& password);
+	static shared_ptr <IMAPCommand> AUTHENTICATE(const string& mechName);
+	static shared_ptr <IMAPCommand> AUTHENTICATE(const string& mechName, const string& initialResponse);
+	static shared_ptr <IMAPCommand> LIST(const string& refName, const string& mailboxName);
+	static shared_ptr <IMAPCommand> SELECT(const bool readOnly, const string& mailboxName, const std::vector <string>& params);
+	static shared_ptr <IMAPCommand> STATUS(const string& mailboxName, const std::vector <string>& attribs);
+	static shared_ptr <IMAPCommand> CREATE(const string& mailboxName, const std::vector <string>& params);
+	static shared_ptr <IMAPCommand> DELETE(const string& mailboxName);
+	static shared_ptr <IMAPCommand> RENAME(const string& mailboxName, const string& newMailboxName);
+	static shared_ptr <IMAPCommand> FETCH(const messageSet& msgs, const std::vector <string>& params);
+	static shared_ptr <IMAPCommand> STORE(const messageSet& msgs, const int mode, const std::vector <string>& flags);
+	static shared_ptr <IMAPCommand> APPEND(const string& mailboxName, const std::vector <string>& flags, vmime::datetime* date, const size_t size);
+	static shared_ptr <IMAPCommand> COPY(const messageSet& msgs, const string& mailboxName);
+	static shared_ptr <IMAPCommand> SEARCH(const std::vector <string>& keys, const vmime::charset* charset);
+	static shared_ptr <IMAPCommand> STARTTLS();
+	static shared_ptr <IMAPCommand> CAPABILITY();
+	static shared_ptr <IMAPCommand> NOOP();
+	static shared_ptr <IMAPCommand> EXPUNGE();
+	static shared_ptr <IMAPCommand> CLOSE();
+	static shared_ptr <IMAPCommand> LOGOUT();
+
+	/** Creates a new IMAP command with the specified text.
+	  *
+	  * @param text command text
+	  * @param traceText trace text (if empty, command text is used)
+	  * @return a new IMAPCommand object
+	  */
+	static shared_ptr <IMAPCommand> createCommand(const string& text, const string& traceText = "");
+
+	/** Sends this command over the specified connection.
+	  *
+	  * @param conn connection onto which the command will be sent
+	  */
+	virtual void send(const shared_ptr <IMAPConnection>& conn);
+
+	/** Returns the full text of the command, including command name
+	  * and parameters (if any). This is the text that will be sent
+	  * to the server.
+	  *
+	  * @return command text (eg. "LOGIN myusername mypassword")
+	  */
+	virtual const string getText() const;
+
+	/** Returns the full text of the command, suitable for outputing
+	  * to the tracer.
+	  *
+	  * @return trace text (eg. "LOGIN {username} {password}")
+	  */
+	virtual const string getTraceText() const;
+
+protected:
+
+	IMAPCommand(const string& text, const string& traceText);
+	IMAPCommand(const IMAPCommand&);
+
+private:
+
+	string m_text;
+	string m_traceText;
+};
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+#endif // VMIME_NET_IMAP_IMAPCOMMAND_HPP_INCLUDED
diff --git a/vmime-master/src/vmime/net/imap/IMAPConnection.cpp b/vmime-master/src/vmime/net/imap/IMAPConnection.cpp
new file mode 100644
index 0000000..df3da1c
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPConnection.cpp
@@ -0,0 +1,886 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/imap/IMAPTag.hpp"
+#include "vmime/net/imap/IMAPConnection.hpp"
+#include "vmime/net/imap/IMAPUtils.hpp"
+#include "vmime/net/imap/IMAPStore.hpp"
+#include "vmime/net/imap/IMAPCommand.hpp"
+
+#include "vmime/exception.hpp"
+#include "vmime/platform.hpp"
+
+#include "vmime/utility/stringUtils.hpp"
+
+#include "vmime/net/defaultConnectionInfos.hpp"
+
+#if VMIME_HAVE_SASL_SUPPORT
+	#include "vmime/security/sasl/SASLContext.hpp"
+#endif // VMIME_HAVE_SASL_SUPPORT
+
+#if VMIME_HAVE_TLS_SUPPORT
+	#include "vmime/net/tls/TLSSession.hpp"
+	#include "vmime/net/tls/TLSSecuredConnectionInfos.hpp"
+#endif // VMIME_HAVE_TLS_SUPPORT
+
+#include <sstream>
+
+
+// Helpers for service properties
+#define GET_PROPERTY(type, prop) \
+	(m_store.lock()->getInfos().getPropertyValue <type>(getSession(), \
+		dynamic_cast <const IMAPServiceInfos&>(m_store.lock()->getInfos()).getProperties().prop))
+#define HAS_PROPERTY(prop) \
+	(m_store.lock()->getInfos().hasProperty(getSession(), \
+		dynamic_cast <const IMAPServiceInfos&>(m_store.lock()->getInfos()).getProperties().prop))
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+IMAPConnection::IMAPConnection(
+	const shared_ptr <IMAPStore>& store,
+	const shared_ptr <security::authenticator>& auth
+)
+	: m_store(store),
+	  m_auth(auth),
+	  m_socket(null),
+	  m_parser(null),
+	  m_tag(null),
+	  m_hierarchySeparator('\0'),
+	  m_state(STATE_NONE),
+	  m_timeoutHandler(null),
+	  m_secured(false),
+	  m_firstTag(true),
+	  m_capabilitiesFetched(false),
+	  m_noModSeq(false) {
+
+	static int connectionId = 0;
+
+	m_tag = make_shared <IMAPTag>();
+
+	if (store->getTracerFactory()) {
+		m_tracer = store->getTracerFactory()->create(store, ++connectionId);
+	}
+
+	m_parser = make_shared <IMAPParser>();
+	m_parser->setTracer(m_tracer);
+}
+
+
+IMAPConnection::~IMAPConnection() {
+
+	try {
+
+		if (isConnected()) {
+			disconnect();
+		} else if (m_socket) {
+			internalDisconnect();
+		}
+
+	} catch (...) {
+
+		// Don't throw in destructor
+	}
+}
+
+
+void IMAPConnection::connect() {
+
+	if (isConnected()) {
+		throw exceptions::already_connected();
+	}
+
+	m_state = STATE_NONE;
+	m_hierarchySeparator = '\0';
+
+	const string address = GET_PROPERTY(string, PROPERTY_SERVER_ADDRESS);
+	const port_t port = GET_PROPERTY(port_t, PROPERTY_SERVER_PORT);
+
+	shared_ptr <IMAPStore> store = m_store.lock();
+
+	// Create the time-out handler
+	if (store->getTimeoutHandlerFactory()) {
+		m_timeoutHandler = store->getTimeoutHandlerFactory()->create();
+	}
+
+	// Create and connect the socket
+	m_socket = store->getSocketFactory()->create(m_timeoutHandler);
+	m_socket->setTracer(m_tracer);
+
+#if VMIME_HAVE_TLS_SUPPORT
+	if (store->isIMAPS()) {  // dedicated port/IMAPS
+
+		shared_ptr <tls::TLSSession> tlsSession = tls::TLSSession::create
+			(store->getCertificateVerifier(),
+			 store->getSession()->getTLSProperties());
+
+		shared_ptr <tls::TLSSocket> tlsSocket =
+			tlsSession->getSocket(m_socket);
+
+		m_socket = tlsSocket;
+
+		m_secured = true;
+		m_cntInfos = make_shared <tls::TLSSecuredConnectionInfos>(address, port, tlsSession, tlsSocket);
+
+	} else
+#endif // VMIME_HAVE_TLS_SUPPORT
+	{
+		m_cntInfos = make_shared <defaultConnectionInfos>(address, port);
+	}
+
+	m_socket->connect(address, port);
+
+
+	m_parser->setSocket(m_socket);
+	m_parser->setTimeoutHandler(m_timeoutHandler);
+
+
+	setState(STATE_NON_AUTHENTICATED);
+
+
+	// Connection greeting
+	//
+	// eg:  C: <connection to server>
+	// ---  S: * OK mydomain.org IMAP4rev1 v12.256 server ready
+
+	scoped_ptr <IMAPParser::greeting> greet(m_parser->readGreeting());
+	bool needAuth = false;
+
+	if (greet->resp_cond_bye) {
+
+		internalDisconnect();
+		throw exceptions::connection_greeting_error(greet->getErrorLog());
+
+	} else if (greet->resp_cond_auth->condition != IMAPParser::resp_cond_auth::PREAUTH) {
+
+		needAuth = true;
+	}
+
+	if (greet->resp_cond_auth->resp_text->resp_text_code &&
+	    greet->resp_cond_auth->resp_text->resp_text_code->capability_data) {
+
+		processCapabilityResponseData(greet->resp_cond_auth->resp_text->resp_text_code->capability_data.get());
+	}
+
+#if VMIME_HAVE_TLS_SUPPORT
+	// Setup secured connection, if requested
+	const bool tls = HAS_PROPERTY(PROPERTY_CONNECTION_TLS)
+		&& GET_PROPERTY(bool, PROPERTY_CONNECTION_TLS);
+	const bool tlsRequired = HAS_PROPERTY(PROPERTY_CONNECTION_TLS_REQUIRED)
+		&& GET_PROPERTY(bool, PROPERTY_CONNECTION_TLS_REQUIRED);
+
+	if (!store->isIMAPS() && tls) {  // only if not IMAPS
+
+		try {
+
+			startTLS();
+
+		// Non-fatal error
+		} catch (exceptions::command_error&) {
+
+			if (tlsRequired) {
+				m_state = STATE_NONE;
+				throw;
+			} else {
+				// TLS is not required, so don't bother
+			}
+
+		// Fatal error
+		} catch (...) {
+
+			m_state = STATE_NONE;
+			throw;
+		}
+	}
+#endif // VMIME_HAVE_TLS_SUPPORT
+
+	// Authentication
+	if (needAuth) {
+
+		try {
+
+			authenticate();
+
+		} catch (...) {
+
+			m_state = STATE_NONE;
+			throw;
+		}
+	}
+
+	// Get the hierarchy separator character
+	initHierarchySeparator();
+
+	// Switch to state "Authenticated"
+	setState(STATE_AUTHENTICATED);
+}
+
+
+void IMAPConnection::authenticate() {
+
+	getAuthenticator()->setService(m_store.lock());
+
+#if VMIME_HAVE_SASL_SUPPORT
+	// First, try SASL authentication
+	if (GET_PROPERTY(bool, PROPERTY_OPTIONS_SASL)) {
+
+		try {
+
+			authenticateSASL();
+			return;
+
+		} catch (exceptions::authentication_error&) {
+
+			if (!GET_PROPERTY(bool, PROPERTY_OPTIONS_SASL_FALLBACK)) {
+
+				// Can't fallback on normal authentication
+				internalDisconnect();
+				throw;
+
+			} else {
+
+				// Ignore, will try normal authentication
+			}
+
+		} catch (exception&) {
+
+			internalDisconnect();
+			throw;
+		}
+	}
+#endif // VMIME_HAVE_SASL_SUPPORT
+
+	// Normal authentication
+	const string username = getAuthenticator()->getUsername();
+	const string password = getAuthenticator()->getPassword();
+
+	shared_ptr <IMAPConnection> conn = dynamicCast <IMAPConnection>(shared_from_this());
+	IMAPCommand::LOGIN(username, password)->send(conn);
+
+	scoped_ptr <IMAPParser::response> resp(m_parser->readResponse(*m_tag));
+
+	if (resp->isBad()) {
+
+		internalDisconnect();
+		throw exceptions::command_error("LOGIN", resp->getErrorLog());
+
+	} else if (resp->response_done->response_tagged->
+					resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		internalDisconnect();
+		throw exceptions::authentication_error(resp->getErrorLog());
+	}
+
+	// Server capabilities may change when logged in
+	if (!processCapabilityResponseData(resp.get())) {
+		invalidateCapabilities();
+	}
+}
+
+
+#if VMIME_HAVE_SASL_SUPPORT
+
+void IMAPConnection::authenticateSASL() {
+
+	if (!dynamicCast <security::sasl::SASLAuthenticator>(getAuthenticator())) {
+		throw exceptions::authentication_error("No SASL authenticator available.");
+	}
+
+	const std::vector <string> capa = getCapabilities();
+	std::vector <string> saslMechs;
+
+	for (unsigned int i = 0 ; i < capa.size() ; ++i) {
+
+		const string& x = capa[i];
+
+		if (x.length() > 5 &&
+		    (x[0] == 'A' || x[0] == 'a') &&
+		    (x[1] == 'U' || x[1] == 'u') &&
+		    (x[2] == 'T' || x[2] == 't') &&
+		    (x[3] == 'H' || x[3] == 'h') &&
+		    x[4] == '=') {
+
+			saslMechs.push_back(string(x.begin() + 5, x.end()));
+		}
+	}
+
+	if (saslMechs.empty()) {
+		throw exceptions::authentication_error("No SASL mechanism available.");
+	}
+
+	std::vector <shared_ptr <security::sasl::SASLMechanism> > mechList;
+
+	shared_ptr <security::sasl::SASLContext> saslContext =
+		security::sasl::SASLContext::create();
+
+	for (unsigned int i = 0 ; i < saslMechs.size() ; ++i) {
+
+		try {
+			mechList.push_back(saslContext->createMechanism(saslMechs[i]));
+		} catch (exceptions::no_such_mechanism&) {
+			// Ignore mechanism
+		}
+	}
+
+	if (mechList.empty()) {
+		throw exceptions::authentication_error("No SASL mechanism available.");
+	}
+
+	// Try to suggest a mechanism among all those supported
+	shared_ptr <security::sasl::SASLMechanism> suggestedMech =
+		saslContext->suggestMechanism(mechList);
+
+	if (!suggestedMech) {
+		throw exceptions::authentication_error("Unable to suggest SASL mechanism.");
+	}
+
+	// Allow application to choose which mechanisms to use
+	mechList = dynamicCast <security::sasl::SASLAuthenticator>(getAuthenticator())->
+		getAcceptableMechanisms(mechList, suggestedMech);
+
+	if (mechList.empty()) {
+		throw exceptions::authentication_error("No SASL mechanism available.");
+	}
+
+	// Try each mechanism in the list in turn
+	for (unsigned int i = 0 ; i < mechList.size() ; ++i) {
+
+		shared_ptr <security::sasl::SASLMechanism> mech = mechList[i];
+
+		shared_ptr <security::sasl::SASLSession> saslSession =
+			saslContext->createSession("imap", getAuthenticator(), mech);
+
+		saslSession->init();
+
+		shared_ptr <IMAPCommand> authCmd;
+
+		if (saslSession->getMechanism()->hasInitialResponse()) {
+
+			byte_t* initialResp = 0;
+			size_t initialRespLen = 0;
+
+			saslSession->evaluateChallenge(NULL, 0, &initialResp, &initialRespLen);
+
+			string encodedInitialResp(saslContext->encodeB64(initialResp, initialRespLen));
+			delete [] initialResp;
+
+			if (encodedInitialResp.empty()) {
+				authCmd = IMAPCommand::AUTHENTICATE(mech->getName(), "=");
+			} else {
+				authCmd = IMAPCommand::AUTHENTICATE(mech->getName(), encodedInitialResp);
+			}
+
+		} else {
+
+			authCmd = IMAPCommand::AUTHENTICATE(mech->getName());
+		}
+
+		authCmd->send(dynamicCast <IMAPConnection>(shared_from_this()));
+
+		for (bool cont = true ; cont ; ) {
+
+			scoped_ptr <IMAPParser::response> resp(m_parser->readResponse(*m_tag));
+
+			if (resp->response_done &&
+			    resp->response_done->response_tagged &&
+			    resp->response_done->response_tagged->resp_cond_state->
+			    	status == IMAPParser::resp_cond_state::OK) {
+
+				m_socket = saslSession->getSecuredSocket(m_socket);
+				return;
+
+			} else {
+
+				string response;
+				bool hasResponse = false;
+
+				for (auto &respData : resp->continue_req_or_response_data) {
+
+					if (respData->continue_req) {
+
+						response = respData->continue_req->resp_text->text;
+						hasResponse = true;
+						break;
+					}
+				}
+
+				if (!hasResponse) {
+					cont = false;
+					continue;
+				}
+
+				byte_t* challenge = 0;
+				size_t challengeLen = 0;
+
+				byte_t* resp = 0;
+				size_t respLen = 0;
+
+				try {
+
+					// Extract challenge
+					saslContext->decodeB64(response, &challenge, &challengeLen);
+
+					// Prepare response
+					saslSession->evaluateChallenge
+						(challenge, challengeLen, &resp, &respLen);
+
+					// Send response
+					const string respB64 = saslContext->encodeB64(resp, respLen) + "\r\n";
+					sendRaw(utility::stringUtils::bytesFromString(respB64), respB64.length());
+
+					if (m_tracer) {
+						m_tracer->traceSendBytes(respB64.length() - 2, "SASL exchange");
+					}
+
+					// Server capabilities may change when logged in
+					invalidateCapabilities();
+
+				} catch (exceptions::sasl_exception& e) {
+
+					if (challenge) {
+						delete [] challenge;
+						challenge = NULL;
+					}
+
+					if (resp) {
+						delete [] resp;
+						resp = NULL;
+					}
+
+					// Cancel SASL exchange
+					sendRaw(utility::stringUtils::bytesFromString("*\r\n"), 3);
+
+					if (m_tracer) {
+						m_tracer->traceSend("*");
+					}
+
+				} catch (...) {
+
+					if (challenge) {
+						delete [] challenge;
+					}
+
+					if (resp) {
+						delete [] resp;
+					}
+
+					throw;
+				}
+
+				if (challenge) {
+					delete [] challenge;
+				}
+
+				if (resp) {
+					delete [] resp;
+				}
+			}
+		}
+	}
+
+	throw exceptions::authentication_error("Could not authenticate using SASL: all mechanisms failed.");
+}
+
+#endif // VMIME_HAVE_SASL_SUPPORT
+
+
+#if VMIME_HAVE_TLS_SUPPORT
+
+void IMAPConnection::startTLS() {
+
+	try {
+
+		IMAPCommand::STARTTLS()->send(dynamicCast <IMAPConnection>(shared_from_this()));
+
+		scoped_ptr <IMAPParser::response> resp(m_parser->readResponse(*m_tag));
+
+		if (resp->isBad() || resp->response_done->response_tagged->
+			resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+			throw exceptions::command_error("STARTTLS", resp->getErrorLog(), "bad response");
+		}
+
+		shared_ptr <tls::TLSSession> tlsSession = tls::TLSSession::create(
+			m_store.lock()->getCertificateVerifier(),
+			m_store.lock()->getSession()->getTLSProperties()
+		);
+
+		shared_ptr <tls::TLSSocket> tlsSocket = tlsSession->getSocket(m_socket);
+
+		tlsSocket->handshake();
+
+		m_socket = tlsSocket;
+		m_parser->setSocket(m_socket);
+
+		m_secured = true;
+		m_cntInfos = make_shared <tls::TLSSecuredConnectionInfos>(
+			m_cntInfos->getHost(), m_cntInfos->getPort(), tlsSession, tlsSocket
+		);
+
+		// " Once TLS has been started, the client MUST discard cached
+		//   information about server capabilities and SHOULD re-issue the
+		//   CAPABILITY command.  This is necessary to protect against
+		//   man-in-the-middle attacks which alter the capabilities list prior
+		//   to STARTTLS. " (RFC-2595)
+		invalidateCapabilities();
+
+	} catch (exceptions::command_error&) {
+
+		// Non-fatal error
+		throw;
+
+	} catch (exception&) {
+
+		// Fatal error
+		internalDisconnect();
+		throw;
+	}
+}
+
+#endif // VMIME_HAVE_TLS_SUPPORT
+
+
+const std::vector <string> IMAPConnection::getCapabilities() {
+
+	if (!m_capabilitiesFetched) {
+		fetchCapabilities();
+	}
+
+	return m_capabilities;
+}
+
+
+bool IMAPConnection::hasCapability(const string& capa) {
+
+	if (!m_capabilitiesFetched) {
+		fetchCapabilities();
+	}
+
+	const string normCapa = utility::stringUtils::toUpper(capa);
+
+	for (size_t i = 0, n = m_capabilities.size() ; i < n ; ++i) {
+
+		if (m_capabilities[i] == normCapa) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+bool IMAPConnection::hasCapability(const string& capa) const {
+
+	const string normCapa = utility::stringUtils::toUpper(capa);
+
+	for (size_t i = 0, n = m_capabilities.size() ; i < n ; ++i) {
+
+		if (m_capabilities[i] == normCapa)
+			return true;
+	}
+
+	return false;
+}
+
+
+void IMAPConnection::invalidateCapabilities() {
+
+	m_capabilities.clear();
+	m_capabilitiesFetched = false;
+}
+
+
+void IMAPConnection::fetchCapabilities() {
+
+	IMAPCommand::CAPABILITY()->send(dynamicCast <IMAPConnection>(shared_from_this()));
+
+	scoped_ptr <IMAPParser::response> resp(m_parser->readResponse(*m_tag));
+
+	if (resp->response_done->response_tagged->
+			resp_cond_state->status == IMAPParser::resp_cond_state::OK) {
+
+		processCapabilityResponseData(resp.get());
+	}
+}
+
+
+bool IMAPConnection::processCapabilityResponseData(const IMAPParser::response* resp) {
+
+	for (auto &respData : resp->continue_req_or_response_data) {
+
+		if (respData->response_data == NULL) {
+			continue;
+		}
+
+		auto &capaData = respData->response_data->capability_data;
+
+		if (!capaData) {
+			continue;
+		}
+
+		processCapabilityResponseData(capaData.get());
+		return true;
+	}
+
+	return false;
+}
+
+
+void IMAPConnection::processCapabilityResponseData(const IMAPParser::capability_data* capaData) {
+
+	std::vector <string> res;
+
+	for (auto &cap : capaData->capabilities) {
+
+		if (cap->auth_type) {
+			res.push_back("AUTH=" + cap->auth_type->name);
+		} else {
+			res.push_back(utility::stringUtils::toUpper(cap->atom->value));
+		}
+	}
+
+	m_capabilities = res;
+	m_capabilitiesFetched = true;
+}
+
+
+shared_ptr <security::authenticator> IMAPConnection::getAuthenticator() {
+
+	return m_auth;
+}
+
+
+bool IMAPConnection::isConnected() const {
+
+	return m_socket
+	    && m_socket->isConnected()
+	    && (m_state == STATE_AUTHENTICATED || m_state == STATE_SELECTED);
+}
+
+
+bool IMAPConnection::isSecuredConnection() const {
+
+	return m_secured;
+}
+
+
+shared_ptr <connectionInfos> IMAPConnection::getConnectionInfos() const {
+
+	return m_cntInfos;
+}
+
+
+void IMAPConnection::disconnect() {
+
+	if (!isConnected()) {
+		throw exceptions::not_connected();
+	}
+
+	internalDisconnect();
+}
+
+
+void IMAPConnection::internalDisconnect() {
+
+	if (isConnected()) {
+
+		IMAPCommand::LOGOUT()->send(dynamicCast <IMAPConnection>(shared_from_this()));
+
+		m_socket->disconnect();
+		m_socket = null;
+	}
+
+	m_timeoutHandler = null;
+
+	m_state = STATE_LOGOUT;
+
+	m_secured = false;
+	m_cntInfos = null;
+}
+
+
+void IMAPConnection::initHierarchySeparator() {
+
+	IMAPCommand::LIST("", "")->send(dynamicCast <IMAPConnection>(shared_from_this()));
+
+	scoped_ptr <IMAPParser::response> resp(m_parser->readResponse(*m_tag));
+
+	if (resp->isBad() || resp->response_done->response_tagged->
+			resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		internalDisconnect();
+		throw exceptions::command_error("LIST", resp->getErrorLog(), "bad response");
+	}
+
+	const auto& respDataList = resp->continue_req_or_response_data;
+
+	bool found = false;
+
+	for (unsigned int i = 0 ; !found && i < respDataList.size() ; ++i) {
+
+		if (!respDataList[i]->response_data) {
+			continue;
+		}
+
+		auto &mailboxData = respDataList[i]->response_data->mailbox_data;
+
+		if (!mailboxData || mailboxData->type != IMAPParser::mailbox_data::LIST) {
+			continue;
+		}
+
+		if (mailboxData->mailbox_list->quoted_char != '\0') {
+			m_hierarchySeparator = mailboxData->mailbox_list->quoted_char;
+			found = true;
+		}
+	}
+
+	if (!found) {  // default
+		m_hierarchySeparator = '/';
+	}
+}
+
+
+void IMAPConnection::sendCommand(const shared_ptr <IMAPCommand>& cmd) {
+
+	if (!m_firstTag) {
+		++(*m_tag);
+	}
+
+	m_socket->send(*m_tag);
+	m_socket->send(" ");
+	m_socket->send(cmd->getText());
+	m_socket->send("\r\n");
+
+	m_firstTag = false;
+
+	if (m_tracer) {
+
+		std::ostringstream oss;
+		oss << string(*m_tag) << " " << cmd->getText();
+
+		m_tracer->traceSend(oss.str());
+	}
+}
+
+
+void IMAPConnection::sendRaw(const byte_t* buffer, const size_t count) {
+
+	m_socket->sendRaw(buffer, count);
+}
+
+
+IMAPParser::response* IMAPConnection::readResponse(IMAPParser::literalHandler* lh) {
+
+	return m_parser->readResponse(*m_tag, lh);
+}
+
+
+IMAPConnection::ProtocolStates IMAPConnection::state() const {
+
+	return m_state;
+}
+
+
+void IMAPConnection::setState(const ProtocolStates state) {
+
+	m_state = state;
+}
+
+
+char IMAPConnection::hierarchySeparator() const {
+
+	return m_hierarchySeparator;
+}
+
+
+shared_ptr <const IMAPStore> IMAPConnection::getStore() const {
+
+	return m_store.lock();
+}
+
+
+shared_ptr <IMAPStore> IMAPConnection::getStore() {
+
+	return m_store.lock();
+}
+
+
+shared_ptr <session> IMAPConnection::getSession() {
+
+	return m_store.lock()->getSession();
+}
+
+
+shared_ptr <const socket> IMAPConnection::getSocket() const {
+
+	return m_socket;
+}
+
+
+void IMAPConnection::setSocket(const shared_ptr <socket>& sok) {
+
+	m_socket = sok;
+	m_parser->setSocket(sok);
+}
+
+
+shared_ptr <tracer> IMAPConnection::getTracer() {
+
+	return m_tracer;
+}
+
+
+shared_ptr <IMAPTag> IMAPConnection::getTag() {
+
+	return m_tag;
+}
+
+
+bool IMAPConnection::isMODSEQDisabled() const {
+
+	return m_noModSeq;
+}
+
+
+void IMAPConnection::disableMODSEQ() {
+
+	m_noModSeq = true;
+}
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
diff --git a/vmime-master/src/vmime/net/imap/IMAPConnection.hpp b/vmime-master/src/vmime/net/imap/IMAPConnection.hpp
new file mode 100644
index 0000000..99750d4
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPConnection.hpp
@@ -0,0 +1,172 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_NET_IMAP_IMAPCONNECTION_HPP_INCLUDED
+#define VMIME_NET_IMAP_IMAPCONNECTION_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/socket.hpp"
+#include "vmime/net/timeoutHandler.hpp"
+#include "vmime/net/tracer.hpp"
+#include "vmime/net/session.hpp"
+#include "vmime/net/connectionInfos.hpp"
+
+#include "vmime/net/imap/IMAPParser.hpp"
+
+#include "vmime/security/authenticator.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+class IMAPTag;
+class IMAPStore;
+class IMAPCommand;
+
+
+class VMIME_EXPORT IMAPConnection : public object, public enable_shared_from_this <IMAPConnection> {
+
+public:
+
+	IMAPConnection(const shared_ptr <IMAPStore>& store, const shared_ptr <security::authenticator>& auth);
+	~IMAPConnection();
+
+
+	void connect();
+	bool isConnected() const;
+	void disconnect();
+
+
+	enum ProtocolStates {
+		STATE_NONE,
+		STATE_NON_AUTHENTICATED,
+		STATE_AUTHENTICATED,
+		STATE_SELECTED,
+		STATE_LOGOUT
+	};
+
+	ProtocolStates state() const;
+	void setState(const ProtocolStates state);
+
+
+	char hierarchySeparator() const;
+
+
+	void sendCommand(const shared_ptr <IMAPCommand>& cmd);
+	void sendRaw(const byte_t* buffer, const size_t count);
+
+	IMAPParser::response* readResponse(IMAPParser::literalHandler* lh = NULL);
+
+
+	shared_ptr <const IMAPStore> getStore() const;
+	shared_ptr <IMAPStore> getStore();
+
+	shared_ptr <session> getSession();
+
+	void fetchCapabilities();
+	void invalidateCapabilities();
+	const std::vector <string> getCapabilities();
+	bool hasCapability(const string& capa);
+	bool hasCapability(const string& capa) const;
+
+	shared_ptr <security::authenticator> getAuthenticator();
+
+	bool isSecuredConnection() const;
+	shared_ptr <connectionInfos> getConnectionInfos() const;
+
+	shared_ptr <const socket> getSocket() const;
+	void setSocket(const shared_ptr <socket>& sok);
+
+	shared_ptr <tracer> getTracer();
+
+	shared_ptr <IMAPTag> getTag();
+
+	bool isMODSEQDisabled() const;
+	void disableMODSEQ();
+
+private:
+
+	void authenticate();
+#if VMIME_HAVE_SASL_SUPPORT
+	void authenticateSASL();
+#endif // VMIME_HAVE_SASL_SUPPORT
+
+#if VMIME_HAVE_TLS_SUPPORT
+	void startTLS();
+#endif // VMIME_HAVE_TLS_SUPPORT
+
+	bool processCapabilityResponseData(const IMAPParser::response* resp);
+	void processCapabilityResponseData(const IMAPParser::capability_data* capaData);
+
+
+	weak_ptr <IMAPStore> m_store;
+
+	shared_ptr <security::authenticator> m_auth;
+
+	shared_ptr <socket> m_socket;
+
+	shared_ptr <IMAPParser> m_parser;
+
+	shared_ptr <IMAPTag> m_tag;
+
+	char m_hierarchySeparator;
+
+	ProtocolStates m_state;
+
+	shared_ptr <timeoutHandler> m_timeoutHandler;
+
+	bool m_secured;
+	shared_ptr <connectionInfos> m_cntInfos;
+
+	bool m_firstTag;
+
+	std::vector <string> m_capabilities;
+	bool m_capabilitiesFetched;
+
+	bool m_noModSeq;
+
+	shared_ptr <tracer> m_tracer;
+
+
+	void internalDisconnect();
+
+	void initHierarchySeparator();
+};
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+#endif // VMIME_NET_IMAP_IMAPCONNECTION_HPP_INCLUDED
diff --git a/vmime-master/src/vmime/net/imap/IMAPFolder.cpp b/vmime-master/src/vmime/net/imap/IMAPFolder.cpp
new file mode 100644
index 0000000..98bc05d
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPFolder.cpp
@@ -0,0 +1,1622 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/imap/IMAPFolder.hpp"
+
+#include "vmime/net/imap/IMAPStore.hpp"
+#include "vmime/net/imap/IMAPParser.hpp"
+#include "vmime/net/imap/IMAPMessage.hpp"
+#include "vmime/net/imap/IMAPUtils.hpp"
+#include "vmime/net/imap/IMAPConnection.hpp"
+#include "vmime/net/imap/IMAPFolderStatus.hpp"
+#include "vmime/net/imap/IMAPCommand.hpp"
+
+#include "vmime/message.hpp"
+
+#include "vmime/exception.hpp"
+
+#include "vmime/utility/outputStreamAdapter.hpp"
+
+#include <algorithm>
+#include <sstream>
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+IMAPFolder::IMAPFolder(
+	const folder::path& path,
+	const shared_ptr <IMAPStore>& store,
+	const shared_ptr <folderAttributes>& attribs
+)
+	: m_store(store),
+	  m_connection(store->connection()),
+	  m_path(path),
+	  m_name(path.isEmpty() ? folder::path::component("") : path.getLastComponent()),
+	  m_mode(-1),
+	  m_open(false),
+	  m_attribs(attribs) {
+
+	store->registerFolder(this);
+
+	m_status = make_shared <IMAPFolderStatus>();
+}
+
+
+IMAPFolder::~IMAPFolder() {
+
+	try {
+
+		shared_ptr <IMAPStore> store = m_store.lock();
+
+		if (store) {
+
+			if (m_open) {
+				close(false);
+			}
+
+			store->unregisterFolder(this);
+
+		} else if (m_open) {
+
+			m_connection = null;
+			onClose();
+		}
+
+	} catch (...) {
+
+		// Don't throw in destructor
+	}
+}
+
+
+int IMAPFolder::getMode() const {
+
+	if (!isOpen()) {
+		throw exceptions::illegal_state("Folder not open");
+	}
+
+	return m_mode;
+}
+
+
+const folderAttributes IMAPFolder::getAttributes() {
+
+	// Root folder
+	if (m_path.isEmpty()) {
+
+		folderAttributes attribs;
+		attribs.setType(folderAttributes::TYPE_CONTAINS_FOLDERS);
+		attribs.setFlags(folderAttributes::FLAG_HAS_CHILDREN | folderAttributes::FLAG_NO_OPEN);
+
+		return attribs;
+
+	} else {
+
+		if (!m_attribs) {
+			testExistAndGetType();
+		}
+
+		return *m_attribs;
+	}
+}
+
+
+const folder::path::component IMAPFolder::getName() const {
+
+	return m_name;
+}
+
+
+const folder::path IMAPFolder::getFullPath() const {
+
+	return m_path;
+}
+
+
+void IMAPFolder::open(const int mode, bool failIfModeIsNotAvailable) {
+
+	shared_ptr <IMAPStore> store = m_store.lock();
+
+	if (!store) {
+		throw exceptions::illegal_state("Store disconnected");
+	}
+
+	// Ensure this folder is not already open in the same session
+	for (std::list <IMAPFolder*>::iterator it = store->m_folders.begin() ;
+	     it != store->m_folders.end() ; ++it) {
+
+		if ((*it) != this && (*it)->getFullPath() == m_path) {
+			throw exceptions::folder_already_open();
+		}
+	}
+
+	// Open a connection for this folder
+	shared_ptr <IMAPConnection> connection =
+		make_shared <IMAPConnection>(store, store->getAuthenticator());
+
+	try {
+
+		connection->connect();
+
+		// Emit the "SELECT" command
+		//
+		// Example:  C: A142 SELECT INBOX
+		//           S: * 172 EXISTS
+		//           S: * 1 RECENT
+		//           S: * OK [UNSEEN 12] Message 12 is first unseen
+		//           S: * OK [UIDVALIDITY 3857529045] UIDs valid
+		//           S: * FLAGS (\Answered \Flagged \Deleted \Seen \Draft)
+		//           S: * OK [PERMANENTFLAGS (\Deleted \Seen \*)] Limited
+		//           S: A142 OK [READ-WRITE] SELECT completed
+
+		std::vector <string> selectParams;
+
+		if (m_connection->hasCapability("CONDSTORE")) {
+			selectParams.push_back("CONDSTORE");
+		}
+
+		IMAPCommand::SELECT(
+			mode == MODE_READ_ONLY,
+			IMAPUtils::pathToString(connection->hierarchySeparator(), getFullPath()),
+			selectParams
+		)->send(connection);
+
+		// Read the response
+		scoped_ptr <IMAPParser::response> resp(connection->readResponse());
+
+		if (resp->isBad() || resp->response_done->response_tagged->
+				resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+			throw exceptions::command_error("SELECT", resp->getErrorLog(), "bad response");
+		}
+
+		auto &respDataList = resp->continue_req_or_response_data;
+
+		for (auto it = respDataList.begin() ; it != respDataList.end() ; ++it) {
+
+			auto *responseData = (*it)->response_data.get();
+
+			if (!responseData) {
+				throw exceptions::command_error("SELECT", resp->getErrorLog(), "invalid response");
+			}
+
+			// OK Untagged responses: UNSEEN, PERMANENTFLAGS, UIDVALIDITY (optional)
+			if (responseData->resp_cond_state) {
+
+				auto *code = responseData->resp_cond_state->resp_text->resp_text_code.get();
+
+				if (code) {
+
+					switch (code->type) {
+
+						case IMAPParser::resp_text_code::NOMODSEQ:
+
+							connection->disableMODSEQ();
+							break;
+
+						default:
+
+							break;
+					}
+				}
+
+			// Untagged responses: FLAGS, EXISTS, RECENT (required)
+			} else if (responseData->mailbox_data) {
+
+				switch (responseData->mailbox_data->type) {
+
+					default: break;
+
+					case IMAPParser::mailbox_data::FLAGS: {
+
+						if (!m_attribs) {
+							m_attribs = make_shared <folderAttributes>();
+						}
+
+						IMAPUtils::mailboxFlagsToFolderAttributes(
+							connection,
+							m_path,
+							*responseData->mailbox_data->mailbox_flag_list,
+							*m_attribs
+						);
+
+						break;
+					}
+				}
+			}
+		}
+
+		processStatusUpdate(resp.get());
+
+		// Check for access mode (read-only or read-write)
+		auto *respTextCode = resp->response_done->response_tagged->resp_cond_state->resp_text->resp_text_code.get();
+
+		if (respTextCode) {
+
+			const int openMode =
+				(respTextCode->type == IMAPParser::resp_text_code::READ_WRITE)
+					? MODE_READ_WRITE
+					: MODE_READ_ONLY;
+
+			if (failIfModeIsNotAvailable &&
+			    mode == MODE_READ_WRITE && openMode == MODE_READ_ONLY) {
+
+				throw exceptions::operation_not_supported();
+			}
+		}
+
+		m_connection = connection;
+		m_open = true;
+		m_mode = mode;
+
+	} catch (std::exception&) {
+
+		throw;
+	}
+}
+
+
+void IMAPFolder::close(const bool expunge) {
+
+	shared_ptr <IMAPStore> store = m_store.lock();
+
+	if (!store) {
+		throw exceptions::illegal_state("Store disconnected");
+	}
+
+	if (!isOpen()) {
+		throw exceptions::illegal_state("Folder not open");
+	}
+
+	shared_ptr <IMAPConnection> oldConnection = m_connection;
+
+	// Emit the "CLOSE" command to expunge messages marked
+	// as deleted (this is fastest than "EXPUNGE")
+	if (expunge) {
+
+		if (m_mode == MODE_READ_ONLY) {
+			throw exceptions::operation_not_supported();
+		}
+
+		IMAPCommand::CLOSE()->send(oldConnection);
+	}
+
+	// Close this folder connection
+	oldConnection->disconnect();
+
+	// Now use default store connection
+	m_connection = m_store.lock()->connection();
+
+	m_open = false;
+	m_mode = -1;
+
+	m_status = make_shared <IMAPFolderStatus>();
+
+	onClose();
+}
+
+
+void IMAPFolder::onClose() {
+
+	for (std::vector <IMAPMessage*>::iterator it = m_messages.begin() ;
+	     it != m_messages.end() ; ++it) {
+
+		(*it)->onFolderClosed();
+	}
+
+	m_messages.clear();
+}
+
+
+void IMAPFolder::create(const folderAttributes& attribs) {
+
+	shared_ptr <IMAPStore> store = m_store.lock();
+
+	if (!store) {
+		throw exceptions::illegal_state("Store disconnected");
+	} else if (isOpen()) {
+		throw exceptions::illegal_state("Folder is open");
+	} else if (exists()) {
+		throw exceptions::illegal_state("Folder already exists");
+	} else if (!store->isValidFolderName(m_name)) {
+		throw exceptions::invalid_folder_name();
+	}
+
+	// Emit the "CREATE" command
+	//
+	// Example:   C: A003 CREATE owatagusiam/
+	//            S: A003 OK CREATE completed
+	//            C: A004 CREATE owatagusiam/blurdybloop
+	//            S: A004 OK CREATE completed
+
+	string mailbox = IMAPUtils::pathToString
+		(m_connection->hierarchySeparator(), getFullPath());
+
+	if (attribs.getType() & folderAttributes::TYPE_CONTAINS_FOLDERS) {
+		mailbox += m_connection->hierarchySeparator();
+	}
+
+	std::vector <string> createParams;
+
+	if (attribs.getSpecialUse() != folderAttributes::SPECIALUSE_NONE) {
+
+		if (!m_connection->hasCapability("CREATE-SPECIAL-USE")) {
+			throw exceptions::operation_not_supported();
+		}
+
+		// C: t2 CREATE MySpecial (USE (\Drafts \Sent))
+		std::ostringstream oss;
+		oss << "USE (";
+
+		switch (attribs.getSpecialUse()) {
+
+			case folderAttributes::SPECIALUSE_NONE:      // should not happen
+			case folderAttributes::SPECIALUSE_ALL:       oss << "\\All"; break;
+			case folderAttributes::SPECIALUSE_ARCHIVE:   oss << "\\Archive"; break;
+			case folderAttributes::SPECIALUSE_DRAFTS:    oss << "\\Drafts"; break;
+			case folderAttributes::SPECIALUSE_FLAGGED:   oss << "\\Flagged"; break;
+			case folderAttributes::SPECIALUSE_JUNK:      oss << "\\Junk"; break;
+			case folderAttributes::SPECIALUSE_SENT:      oss << "\\Sent"; break;
+			case folderAttributes::SPECIALUSE_TRASH:     oss << "\\Trash"; break;
+			case folderAttributes::SPECIALUSE_IMPORTANT: oss << "\\Important"; break;
+		}
+
+		oss << ")";
+
+		createParams.push_back(oss.str());
+	}
+
+	IMAPCommand::CREATE(mailbox, createParams)->send(m_connection);
+
+
+	scoped_ptr <IMAPParser::response> resp(m_connection->readResponse());
+
+	if (resp->isBad() || resp->response_done->response_tagged->
+			resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		throw exceptions::command_error("CREATE", resp->getErrorLog(), "bad response");
+	}
+
+	// Notify folder created
+	shared_ptr <events::folderEvent> event =
+		make_shared <events::folderEvent>(
+			dynamicCast <folder>(shared_from_this()),
+			events::folderEvent::TYPE_CREATED,
+			m_path, m_path
+		);
+
+	notifyFolder(event);
+}
+
+
+void IMAPFolder::destroy() {
+
+	shared_ptr <IMAPStore> store = m_store.lock();
+
+	if (!store) {
+		throw exceptions::illegal_state("Store disconnected");
+	}
+
+	if (isOpen()) {
+		throw exceptions::illegal_state("Folder is open");
+	}
+
+	const string mailbox = IMAPUtils::pathToString(
+		m_connection->hierarchySeparator(), getFullPath()
+	);
+
+	IMAPCommand::DELETE(mailbox)->send(m_connection);
+
+
+	scoped_ptr <IMAPParser::response> resp(m_connection->readResponse());
+
+	if (resp->isBad() || resp->response_done->response_tagged->
+			resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		throw exceptions::command_error("DELETE", resp->getErrorLog(), "bad response");
+	}
+
+	// Notify folder deleted
+	shared_ptr <events::folderEvent> event =
+		make_shared <events::folderEvent>(
+			dynamicCast <folder>(shared_from_this()),
+			events::folderEvent::TYPE_DELETED,
+			m_path, m_path
+		);
+
+	notifyFolder(event);
+}
+
+
+bool IMAPFolder::exists() {
+
+	shared_ptr <IMAPStore> store = m_store.lock();
+
+	if (!isOpen() && !store) {
+		throw exceptions::illegal_state("Store disconnected");
+	}
+
+	return testExistAndGetType() != -1;
+}
+
+
+int IMAPFolder::testExistAndGetType() {
+
+	// To test whether a folder exists, we simple list it using
+	// the "LIST" command, and there should be one unique mailbox
+	// with this name...
+	//
+	// Eg. Test whether '/foo/bar' exists
+	//
+	//     C: a005 list "" foo/bar
+	//     S: * LIST (\NoSelect) "/" foo/bar
+	//     S: a005 OK LIST completed
+	//
+	// ==> OK, exists
+	//
+	// Test whether '/foo/bar/zap' exists
+	//
+	//     C: a005 list "" foo/bar/zap
+	//     S: a005 OK LIST completed
+	//
+	// ==> NO, does not exist
+
+	IMAPCommand::LIST(
+		"",
+		IMAPUtils::pathToString(
+			m_connection->hierarchySeparator(),
+			getFullPath()
+		)
+	)->send(m_connection);
+
+
+	scoped_ptr <IMAPParser::response> resp(m_connection->readResponse());
+
+	if (resp->isBad() || resp->response_done->response_tagged->
+			resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		throw exceptions::command_error("LIST", resp->getErrorLog(), "bad response");
+	}
+
+	// Check whether the result mailbox list contains this folder
+	auto& respDataList = resp->continue_req_or_response_data;
+
+	folderAttributes attribs;
+	attribs.setType(-1);
+
+	for (auto it = respDataList.begin() ; it != respDataList.end() ; ++it) {
+
+		if (!(*it)->response_data) {
+			throw exceptions::command_error("LIST", resp->getErrorLog(), "invalid response");
+		}
+
+		auto *mailboxData = (*it)->response_data->mailbox_data.get();
+
+		// We are only interested in responses of type "LIST"
+		if (mailboxData &&
+		    mailboxData->type == IMAPParser::mailbox_data::LIST) {
+
+			// Get the folder type/flags at the same time
+			IMAPUtils::mailboxFlagsToFolderAttributes(
+				m_connection,
+				m_path,
+				*mailboxData->mailbox_list->mailbox_flag_list,
+				attribs
+			);
+		}
+	}
+
+	m_attribs = make_shared <folderAttributes>(attribs);
+
+	return m_attribs->getType();
+}
+
+
+bool IMAPFolder::isOpen() const {
+
+	return m_open;
+}
+
+
+shared_ptr <message> IMAPFolder::getMessage(const size_t num) {
+
+	if (!isOpen()) {
+		throw exceptions::illegal_state("Folder not open");
+	}
+
+	if (num < 1 || num > m_status->getMessageCount()) {
+		throw exceptions::message_not_found();
+	}
+
+	return make_shared <IMAPMessage>(dynamicCast <IMAPFolder>(shared_from_this()), num);
+}
+
+
+std::vector <shared_ptr <message> > IMAPFolder::getMessages(const messageSet& msgs) {
+
+	if (!isOpen()) {
+		throw exceptions::illegal_state("Folder not open");
+	}
+
+	if (msgs.isEmpty()) {
+		return std::vector <shared_ptr <message> >();
+	}
+
+	std::vector <shared_ptr <message> > messages;
+
+	// Sequence number message set:
+	//     C: . FETCH uuuu1,uuuu2,uuuu3 UID
+	//     S: * nnnn1 FETCH (UID uuuu1)
+	//     S: * nnnn2 FETCH (UID uuuu2)
+	//     S: * nnnn3 FETCH (UID uuuu3)
+	//     S: . OK FETCH completed
+
+	// UID message set:
+	//     C: . UID FETCH uuuu1,uuuu2,uuuu3 UID
+	//     S: * nnnn1 FETCH (UID uuuu1)
+	//     S: * nnnn2 FETCH (UID uuuu2)
+	//     S: * nnnn3 FETCH (UID uuuu3)
+	//     S: . OK UID FETCH completed
+
+	std::vector <string> params;
+	params.push_back("UID");
+
+	IMAPCommand::FETCH(msgs, params)->send(m_connection);
+
+	// Get the response
+	scoped_ptr <IMAPParser::response> resp(m_connection->readResponse());
+
+	if (resp->isBad() || resp->response_done->response_tagged->
+			resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		throw exceptions::command_error("UID FETCH ... UID", resp->getErrorLog(), "bad response");
+	}
+
+	// Process the response
+	auto &respDataList = resp->continue_req_or_response_data;
+
+	for (auto it = respDataList.begin() ; it != respDataList.end() ; ++it) {
+
+		if (!(*it)->response_data) {
+			throw exceptions::command_error("UID FETCH ... UID", resp->getErrorLog(), "invalid response");
+		}
+
+		auto *messageData = (*it)->response_data->message_data.get();
+
+		// We are only interested in responses of type "FETCH"
+		if (!messageData || messageData->type != IMAPParser::message_data::FETCH) {
+			continue;
+		}
+
+		// Find UID in message attributes
+		const size_t msgNum = messageData->number;
+		message::uid msgUID;
+
+		for (auto &att : messageData->msg_att->items) {
+
+			if (att->type == IMAPParser::msg_att_item::UID) {
+				msgUID = att->uniqueid->value;
+				break;
+			}
+		}
+
+		if (!msgUID.empty()) {
+			shared_ptr <IMAPFolder> thisFolder = dynamicCast <IMAPFolder>(shared_from_this());
+			messages.push_back(make_shared <IMAPMessage>(thisFolder, msgNum, msgUID));
+		}
+	}
+
+	return messages;
+}
+
+
+size_t IMAPFolder::getMessageCount() {
+
+	if (!isOpen()) {
+		throw exceptions::illegal_state("Folder not open");
+	}
+
+	return m_status->getMessageCount();
+}
+
+
+vmime_uint32 IMAPFolder::getUIDValidity() const {
+
+	if (!isOpen()) {
+		throw exceptions::illegal_state("Folder not open");
+	}
+
+	return m_status->getUIDValidity();
+}
+
+
+vmime_uint64 IMAPFolder::getHighestModSequence() const {
+
+	if (!isOpen()) {
+		throw exceptions::illegal_state("Folder not open");
+	}
+
+	return m_status->getHighestModSeq();
+}
+
+
+shared_ptr <folder> IMAPFolder::getFolder(const folder::path::component& name) {
+
+	shared_ptr <IMAPStore> store = m_store.lock();
+
+	if (!store) {
+		throw exceptions::illegal_state("Store disconnected");
+	}
+
+	return make_shared <IMAPFolder>(m_path / name, store, shared_ptr <folderAttributes>());
+}
+
+
+std::vector <shared_ptr <folder> > IMAPFolder::getFolders(const bool recursive) {
+
+	shared_ptr <IMAPStore> store = m_store.lock();
+
+	if (!isOpen() && !store) {
+		throw exceptions::illegal_state("Store disconnected");
+	}
+
+	// Eg. List folders in '/foo/bar'
+	//
+	//     C: a005 list "foo/bar" *
+	//     S: * LIST (\NoSelect) "/" foo/bar
+	//     S: * LIST (\NoInferiors) "/" foo/bar/zap
+	//     S: a005 OK LIST completed
+
+	shared_ptr <IMAPCommand> cmd;
+
+	const string pathString = IMAPUtils::pathToString(
+		m_connection->hierarchySeparator(), getFullPath()
+	);
+
+	if (recursive) {
+
+		cmd = IMAPCommand::LIST(pathString, "*");
+
+	} else {
+
+		cmd = IMAPCommand::LIST(
+			pathString.empty()
+				? ""
+				: (pathString + m_connection->hierarchySeparator()),
+			"%"
+		);
+	}
+
+	cmd->send(m_connection);
+
+
+	scoped_ptr <IMAPParser::response> resp(m_connection->readResponse());
+
+	if (resp->isBad() || resp->response_done->response_tagged->
+			resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		throw exceptions::command_error("LIST", resp->getErrorLog(), "bad response");
+	}
+
+	auto &respDataList = resp->continue_req_or_response_data;
+
+	std::vector <shared_ptr <folder> > v;
+
+	for (auto it = respDataList.begin() ; it != respDataList.end() ; ++it) {
+
+		if (!(*it)->response_data) {
+			throw exceptions::command_error("LIST", resp->getErrorLog(), "invalid response");
+		}
+
+		auto *mailboxData = (*it)->response_data->mailbox_data.get();
+
+		if (!mailboxData || mailboxData->type != IMAPParser::mailbox_data::LIST) {
+			continue;
+		}
+
+		// Get folder path
+		auto &mailbox = mailboxData->mailbox_list->mailbox;
+
+		folder::path path = IMAPUtils::stringToPath(
+			mailboxData->mailbox_list->quoted_char, mailbox->name
+		);
+
+		if (recursive || m_path.isDirectParentOf(path)) {
+
+			// Append folder to list
+			shared_ptr <folderAttributes> attribs = make_shared <folderAttributes>();
+
+			IMAPUtils::mailboxFlagsToFolderAttributes(
+				m_connection,
+				path,
+				*mailboxData->mailbox_list->mailbox_flag_list,
+				*attribs
+			);
+
+			v.push_back(make_shared <IMAPFolder>(path, store, attribs));
+		}
+	}
+
+	return v;
+}
+
+
+void IMAPFolder::fetchMessages(
+	std::vector <shared_ptr <message> >& msg,
+	const fetchAttributes& options,
+	utility::progressListener* progress
+) {
+
+	shared_ptr <IMAPStore> store = m_store.lock();
+
+	if (!store) {
+		throw exceptions::illegal_state("Store disconnected");
+	} else if (!isOpen()) {
+		throw exceptions::illegal_state("Folder not open");
+	}
+
+	if (msg.empty()) {
+		return;
+	}
+
+	// Build message numbers list
+	std::vector <size_t> list;
+	list.reserve(msg.size());
+
+	std::map <size_t, shared_ptr <IMAPMessage> > numberToMsg;
+
+	for (std::vector <shared_ptr <message> >::iterator it = msg.begin() ; it != msg.end() ; ++it) {
+
+		list.push_back((*it)->getNumber());
+		numberToMsg[(*it)->getNumber()] = dynamicCast <IMAPMessage>(*it);
+	}
+
+	// Send the request
+	IMAPUtils::buildFetchCommand(
+		m_connection, messageSet::byNumber(list), options
+	)->send(m_connection);
+
+	// Get the response
+	scoped_ptr <IMAPParser::response> resp(m_connection->readResponse());
+
+	if (resp->isBad() || resp->response_done->response_tagged->
+		resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		throw exceptions::command_error("FETCH", resp->getErrorLog(), "bad response");
+	}
+
+	auto &respDataList = resp->continue_req_or_response_data;
+
+	const size_t total = msg.size();
+	size_t current = 0;
+
+	if (progress) {
+		progress->start(total);
+	}
+
+	try {
+
+		for (auto it = respDataList.begin() ; it != respDataList.end() ; ++it) {
+
+			if (!(*it)->response_data) {
+				throw exceptions::command_error("FETCH", resp->getErrorLog(), "invalid response");
+			}
+
+			auto *messageData = (*it)->response_data->message_data.get();
+
+			// We are only interested in responses of type "FETCH"
+			if (!messageData || messageData->type != IMAPParser::message_data::FETCH) {
+				continue;
+			}
+
+			// Process fetch response for this message
+			const size_t num = messageData->number;
+
+			std::map <size_t, shared_ptr <IMAPMessage> >::iterator msg = numberToMsg.find(num);
+
+			if (msg != numberToMsg.end()) {
+
+				(*msg).second->processFetchResponse(options, *messageData);
+
+				if (progress) {
+					progress->progress(++current, total);
+				}
+			}
+		}
+
+	} catch (...) {
+
+		if (progress) {
+			progress->stop(total);
+		}
+
+		throw;
+	}
+
+	if (progress) {
+		progress->stop(total);
+	}
+
+	processStatusUpdate(resp.get());
+}
+
+
+void IMAPFolder::fetchMessage(const shared_ptr <message>& msg, const fetchAttributes& options) {
+
+	std::vector <shared_ptr <message> > msgs;
+	msgs.push_back(msg);
+
+	fetchMessages(msgs, options, /* progress */ NULL);
+}
+
+
+std::vector <shared_ptr <message> > IMAPFolder::getAndFetchMessages(
+	const messageSet& msgs,
+	const fetchAttributes& attribs
+) {
+
+	shared_ptr <IMAPStore> store = m_store.lock();
+
+	if (!store) {
+		throw exceptions::illegal_state("Store disconnected");
+	} else if (!isOpen()) {
+		throw exceptions::illegal_state("Folder not open");
+	}
+
+	if (msgs.isEmpty()) {
+		return std::vector <shared_ptr <message> >();
+	}
+
+	// Ensure we also get the UID for each message
+	fetchAttributes attribsWithUID(attribs);
+	attribsWithUID.add(fetchAttributes::UID);
+
+	// Send the request
+	IMAPUtils::buildFetchCommand(m_connection, msgs, attribsWithUID)->send(m_connection);
+
+	// Get the response
+	scoped_ptr <IMAPParser::response> resp(m_connection->readResponse());
+
+	if (resp->isBad() || resp->response_done->response_tagged->
+		resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		throw exceptions::command_error("FETCH", resp->getErrorLog(), "bad response");
+	}
+
+	auto &respDataList = resp->continue_req_or_response_data;
+
+	std::vector <shared_ptr <message> > messages;
+
+	for (auto it = respDataList.begin() ; it != respDataList.end() ; ++it) {
+
+		if (!(*it)->response_data) {
+			throw exceptions::command_error("FETCH", resp->getErrorLog(), "invalid response");
+		}
+
+		auto *messageData = (*it)->response_data->message_data.get();
+
+		// We are only interested in responses of type "FETCH"
+		if (!messageData || messageData->type != IMAPParser::message_data::FETCH) {
+			continue;
+		}
+
+		// Get message number
+		const size_t msgNum = messageData->number;
+
+		// Get message UID
+		message::uid msgUID;
+
+		for (auto &att : messageData->msg_att->items) {
+
+			if (att->type == IMAPParser::msg_att_item::UID) {
+				msgUID = att->uniqueid->value;
+				break;
+			}
+		}
+
+		// Create a new message reference
+		shared_ptr <IMAPFolder> thisFolder = dynamicCast <IMAPFolder>(shared_from_this());
+		shared_ptr <IMAPMessage> msg = make_shared <IMAPMessage>(thisFolder, msgNum, msgUID);
+
+		messages.push_back(msg);
+
+		// Process fetch response for this message
+		msg->processFetchResponse(attribsWithUID, *messageData);
+	}
+
+	processStatusUpdate(resp.get());
+
+	return messages;
+}
+
+
+int IMAPFolder::getFetchCapabilities() const {
+
+	return fetchAttributes::ENVELOPE | fetchAttributes::CONTENT_INFO |
+	       fetchAttributes::STRUCTURE | fetchAttributes::FLAGS |
+	       fetchAttributes::SIZE | fetchAttributes::FULL_HEADER |
+	       fetchAttributes::UID | fetchAttributes::IMPORTANCE;
+}
+
+
+shared_ptr <folder> IMAPFolder::getParent() {
+
+	if (m_path.isEmpty()) {
+
+		return null;
+
+	} else {
+
+		return make_shared <IMAPFolder>(
+			m_path.getParent(), m_store.lock(), shared_ptr <folderAttributes>()
+		);
+	}
+}
+
+
+shared_ptr <const store> IMAPFolder::getStore() const {
+
+	return m_store.lock();
+}
+
+
+shared_ptr <store> IMAPFolder::getStore() {
+
+	return m_store.lock();
+}
+
+
+void IMAPFolder::registerMessage(IMAPMessage* msg) {
+
+	m_messages.push_back(msg);
+}
+
+
+void IMAPFolder::unregisterMessage(IMAPMessage* msg) {
+
+	std::vector <IMAPMessage*>::iterator it =
+		std::find(m_messages.begin(), m_messages.end(), msg);
+
+	if (it != m_messages.end()) {
+		m_messages.erase(it);
+	}
+}
+
+
+void IMAPFolder::onStoreDisconnected() {
+
+	m_store.reset();
+}
+
+
+void IMAPFolder::deleteMessages(const messageSet& msgs) {
+
+	shared_ptr <IMAPStore> store = m_store.lock();
+
+	if (msgs.isEmpty()) {
+		throw exceptions::invalid_argument();
+	}
+
+	if (!store) {
+		throw exceptions::illegal_state("Store disconnected");
+	} else if (!isOpen()) {
+		throw exceptions::illegal_state("Folder not open");
+	} else if (m_mode == MODE_READ_ONLY) {
+		throw exceptions::illegal_state("Folder is read-only");
+	}
+
+	// Send the request
+	IMAPCommand::STORE(
+		msgs, message::FLAG_MODE_ADD,
+		IMAPUtils::messageFlagList(message::FLAG_DELETED)
+	)->send(m_connection);
+
+	// Get the response
+	scoped_ptr <IMAPParser::response> resp(m_connection->readResponse());
+
+	if (resp->isBad() || resp->response_done->response_tagged->
+		resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		throw exceptions::command_error("STORE", resp->getErrorLog(), "bad response");
+	}
+
+	processStatusUpdate(resp.get());
+}
+
+
+void IMAPFolder::setMessageFlags(
+	const messageSet& msgs,
+	const int flags,
+	const int mode
+) {
+
+	const std::vector <string> flagList = IMAPUtils::messageFlagList(flags);
+
+	if ((mode == message::FLAG_MODE_SET) || !flagList.empty()) {
+
+		// Send the request
+		IMAPCommand::STORE(msgs, mode, flagList)->send(m_connection);
+
+		// Get the response
+		scoped_ptr <IMAPParser::response> resp(m_connection->readResponse());
+
+		if (resp->isBad() || resp->response_done->response_tagged->
+			resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+			throw exceptions::command_error("STORE", resp->getErrorLog(), "bad response");
+		}
+
+		processStatusUpdate(resp.get());
+	}
+}
+
+
+messageSet IMAPFolder::addMessage(
+	const shared_ptr <vmime::message>& msg,
+	const int flags,
+	vmime::datetime* date,
+	utility::progressListener* progress
+) {
+
+	std::ostringstream oss;
+	utility::outputStreamAdapter ossAdapter(oss);
+
+	msg->generate(ossAdapter);
+
+	const string& str = oss.str();
+	utility::inputStreamStringAdapter strAdapter(str);
+
+	return addMessage(strAdapter, str.length(), flags, date, progress);
+}
+
+
+messageSet IMAPFolder::addMessage(
+	utility::inputStream& is,
+	const size_t size,
+	const int flags,
+	vmime::datetime* date,
+	utility::progressListener* progress
+) {
+
+	shared_ptr <IMAPStore> store = m_store.lock();
+
+	if (!store) {
+		throw exceptions::illegal_state("Store disconnected");
+	} else if (!isOpen()) {
+		throw exceptions::illegal_state("Folder not open");
+	} else if (m_mode == MODE_READ_ONLY) {
+		throw exceptions::illegal_state("Folder is read-only");
+	}
+
+	// Send the request
+	IMAPCommand::APPEND(
+		IMAPUtils::pathToString(m_connection->hierarchySeparator(), getFullPath()),
+		IMAPUtils::messageFlagList(flags), date, size
+	)->send(m_connection);
+
+	// Get the response
+	scoped_ptr <IMAPParser::response> resp(m_connection->readResponse());
+
+	bool ok = false;
+	auto &respList = resp->continue_req_or_response_data;
+
+	for (auto it = respList.begin() ; !ok && (it != respList.end()) ; ++it) {
+
+		if ((*it)->continue_req) {
+			ok = true;
+		}
+	}
+
+	if (!ok) {
+		throw exceptions::command_error("APPEND", resp->getErrorLog(), "bad response");
+	}
+
+	processStatusUpdate(resp.get());
+
+	// Send message data
+	const size_t total = size;
+	size_t current = 0;
+
+	if (progress) {
+		progress->start(total);
+	}
+
+	const size_t blockSize = std::min(
+		is.getBlockSize(),
+		static_cast <size_t>(m_connection->getSocket()->getBlockSize())
+	);
+
+	std::vector <byte_t> vbuffer(blockSize);
+	byte_t* buffer = &vbuffer.front();
+
+	while (!is.eof()) {
+
+		// Read some data from the input stream
+		const size_t read = is.read(buffer, blockSize);
+		current += read;
+
+		// Put read data into socket output stream
+		m_connection->sendRaw(buffer, read);
+
+		// Notify progress
+		if (progress) {
+			progress->progress(current, total);
+		}
+	}
+
+	m_connection->sendRaw(utility::stringUtils::bytesFromString("\r\n"), 2);
+
+	if (m_connection->getTracer()) {
+		m_connection->getTracer()->traceSendBytes(current);
+	}
+
+	if (progress) {
+		progress->stop(total);
+	}
+
+	// Get the response
+	scoped_ptr <IMAPParser::response> finalResp(m_connection->readResponse());
+
+	if (finalResp->isBad() || finalResp->response_done->response_tagged->
+			resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		throw exceptions::command_error("APPEND", resp->getErrorLog(), "bad response");
+	}
+
+	processStatusUpdate(finalResp.get());
+
+	auto *respTextCode =
+		finalResp->response_done->response_tagged->resp_cond_state->resp_text->resp_text_code.get();
+
+	if (respTextCode && respTextCode->type == IMAPParser::resp_text_code::APPENDUID) {
+		return IMAPUtils::buildMessageSet(*respTextCode->uid_set);
+	}
+
+	return messageSet::empty();
+}
+
+
+void IMAPFolder::expunge() {
+
+	shared_ptr <IMAPStore> store = m_store.lock();
+
+	if (!store) {
+		throw exceptions::illegal_state("Store disconnected");
+	} else if (!isOpen()) {
+		throw exceptions::illegal_state("Folder not open");
+	} else if (m_mode == MODE_READ_ONLY) {
+		throw exceptions::illegal_state("Folder is read-only");
+	}
+
+	// Send the request
+	IMAPCommand::EXPUNGE()->send(m_connection);
+
+	// Get the response
+	scoped_ptr <IMAPParser::response> resp(m_connection->readResponse());
+
+	if (resp->isBad() || resp->response_done->response_tagged->
+		resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		throw exceptions::command_error("EXPUNGE", resp->getErrorLog(), "bad response");
+	}
+
+	processStatusUpdate(resp.get());
+}
+
+
+void IMAPFolder::rename(const folder::path& newPath) {
+
+	shared_ptr <IMAPStore> store = m_store.lock();
+
+	if (!store) {
+		throw exceptions::illegal_state("Store disconnected");
+	} else if (m_path.isEmpty() || newPath.isEmpty()) {
+		throw exceptions::illegal_operation("Cannot rename root folder");
+	} else if (m_path.getSize() == 1 && m_name.getBuffer() == "INBOX") {
+		throw exceptions::illegal_operation("Cannot rename 'INBOX' folder");
+	} else if (!store->isValidFolderName(newPath.getLastComponent())) {
+		throw exceptions::invalid_folder_name();
+	}
+
+	// Send the request
+	IMAPCommand::RENAME(
+		IMAPUtils::pathToString(m_connection->hierarchySeparator(), getFullPath()),
+		IMAPUtils::pathToString(m_connection->hierarchySeparator(), newPath)
+	)->send(m_connection);
+
+	// Get the response
+	scoped_ptr <IMAPParser::response> resp(m_connection->readResponse());
+
+	if (resp->isBad() || resp->response_done->response_tagged->
+		resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		throw exceptions::command_error("RENAME", resp->getErrorLog(), "bad response");
+	}
+
+	// Notify folder renamed
+	folder::path oldPath(m_path);
+
+	m_path = newPath;
+	m_name = newPath.getLastComponent();
+
+	shared_ptr <events::folderEvent> event =
+		make_shared <events::folderEvent>(
+			dynamicCast <folder>(shared_from_this()),
+			events::folderEvent::TYPE_RENAMED,
+			oldPath,
+			newPath
+		);
+
+	notifyFolder(event);
+
+	// Notify sub-folders
+	for (std::list <IMAPFolder*>::iterator it = store->m_folders.begin() ;
+	     it != store->m_folders.end() ; ++it) {
+
+		if ((*it) != this && oldPath.isParentOf((*it)->getFullPath())) {
+
+			folder::path oldPath((*it)->m_path);
+
+			(*it)->m_path.renameParent(oldPath, newPath);
+
+			shared_ptr <events::folderEvent> event =
+				make_shared <events::folderEvent>(
+					dynamicCast <folder>((*it)->shared_from_this()),
+					events::folderEvent::TYPE_RENAMED,
+					oldPath, (*it)->m_path
+				);
+
+			(*it)->notifyFolder(event);
+		}
+	}
+
+	processStatusUpdate(resp.get());
+}
+
+
+messageSet IMAPFolder::copyMessages(const folder::path& dest, const messageSet& set) {
+
+	shared_ptr <IMAPStore> store = m_store.lock();
+
+	if (!store) {
+		throw exceptions::illegal_state("Store disconnected");
+	} else if (!isOpen()) {
+		throw exceptions::illegal_state("Folder not open");
+	}
+
+	// Send the request
+	IMAPCommand::COPY(
+		set,
+		IMAPUtils::pathToString(m_connection->hierarchySeparator(), dest)
+	)->send(m_connection);
+
+	// Get the response
+	scoped_ptr <IMAPParser::response> resp(m_connection->readResponse());
+
+	if (resp->isBad() || resp->response_done->response_tagged->
+		resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		throw exceptions::command_error("COPY", resp->getErrorLog(), "bad response");
+	}
+
+	processStatusUpdate(resp.get());
+
+	auto *respTextCode =
+		resp->response_done->response_tagged->resp_cond_state->resp_text->resp_text_code.get();
+
+	if (respTextCode && respTextCode->type == IMAPParser::resp_text_code::COPYUID) {
+		return IMAPUtils::buildMessageSet(*respTextCode->uid_set2);
+	}
+
+	return messageSet::empty();
+}
+
+
+void IMAPFolder::status(size_t& count, size_t& unseen) {
+
+	count = 0;
+	unseen = 0;
+
+	shared_ptr <folderStatus> status = getStatus();
+
+	count = status->getMessageCount();
+	unseen = status->getUnseenCount();
+}
+
+
+shared_ptr <folderStatus> IMAPFolder::getStatus() {
+
+	shared_ptr <IMAPStore> store = m_store.lock();
+
+	if (!store) {
+		throw exceptions::illegal_state("Store disconnected");
+	}
+
+	// Build the attributes list
+	std::vector <string> attribs;
+
+	attribs.push_back("MESSAGES");
+	attribs.push_back("UNSEEN");
+	attribs.push_back("UIDNEXT");
+	attribs.push_back("UIDVALIDITY");
+
+	if (m_connection->hasCapability("CONDSTORE")) {
+		attribs.push_back("HIGHESTMODSEQ");
+	}
+
+	// Send the request
+	IMAPCommand::STATUS(
+		IMAPUtils::pathToString(m_connection->hierarchySeparator(), getFullPath()),
+		attribs
+	)->send(m_connection);
+
+	// Get the response
+	scoped_ptr <IMAPParser::response> resp(m_connection->readResponse());
+
+	if (resp->isBad() || resp->response_done->response_tagged->
+			resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		throw exceptions::command_error("STATUS", resp->getErrorLog(), "bad response");
+	}
+
+	auto &respDataList = resp->continue_req_or_response_data;
+
+	for (auto it = respDataList.begin() ; it != respDataList.end() ; ++it) {
+
+		if ((*it)->response_data) {
+
+			auto &responseData = (*it)->response_data;
+
+			if (responseData->mailbox_data &&
+				responseData->mailbox_data->type == IMAPParser::mailbox_data::STATUS) {
+
+				shared_ptr <IMAPFolderStatus> status = make_shared <IMAPFolderStatus>();
+				status->updateFromResponse(*responseData->mailbox_data);
+
+				m_status->updateFromResponse(*responseData->mailbox_data);
+
+				return status;
+			}
+		}
+	}
+
+	throw exceptions::command_error("STATUS", resp->getErrorLog(), "invalid response");
+}
+
+
+void IMAPFolder::noop() {
+
+	shared_ptr <IMAPStore> store = m_store.lock();
+
+	if (!store) {
+		throw exceptions::illegal_state("Store disconnected");
+	}
+
+	IMAPCommand::NOOP()->send(m_connection);
+
+	scoped_ptr <IMAPParser::response> resp(m_connection->readResponse());
+
+	if (resp->isBad() || resp->response_done->response_tagged->
+			resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		throw exceptions::command_error("NOOP", resp->getErrorLog());
+	}
+
+	processStatusUpdate(resp.get());
+}
+
+
+std::vector <size_t> IMAPFolder::getMessageNumbersStartingOnUID(const message::uid& uid) {
+
+	// Send the request
+	std::ostringstream uidSearchKey;
+	uidSearchKey.imbue(std::locale::classic());
+	uidSearchKey << "UID " << uid << ":*";
+
+	std::vector <string> searchKeys;
+	searchKeys.push_back(uidSearchKey.str());
+
+	IMAPCommand::SEARCH(searchKeys, /* charset */ NULL)->send(m_connection);
+
+	// Get the response
+	scoped_ptr <IMAPParser::response> resp(m_connection->readResponse());
+
+	if (resp->isBad() ||
+	    resp->response_done->response_tagged->resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		throw exceptions::command_error("SEARCH", resp->getErrorLog(), "bad response");
+	}
+
+	auto& respDataList = resp->continue_req_or_response_data;
+
+	std::vector <size_t> seqNumbers;
+
+	for (auto it = respDataList.begin() ; it != respDataList.end() ; ++it) {
+
+		if (!(*it)->response_data) {
+			throw exceptions::command_error("SEARCH", resp->getErrorLog(), "invalid response");
+		}
+
+		auto *mailboxData = (*it)->response_data->mailbox_data.get();
+
+		// We are only interested in responses of type "SEARCH"
+		if (!mailboxData ||
+		    mailboxData->type != IMAPParser::mailbox_data::SEARCH) {
+
+			continue;
+		}
+
+		for (auto &nzn : mailboxData->search_nz_number_list) {
+			seqNumbers.push_back(nzn->value);
+		}
+	}
+
+	processStatusUpdate(resp.get());
+
+	return seqNumbers;
+}
+
+
+void IMAPFolder::processStatusUpdate(const IMAPParser::response* resp) {
+
+	std::vector <shared_ptr <events::event> > events;
+
+	shared_ptr <IMAPFolderStatus> oldStatus = vmime::clone(m_status);
+	int expungedMessageCount = 0;
+
+	// Process tagged response
+	if (resp->response_done &&
+	    resp->response_done->response_tagged &&
+	    resp->response_done->response_tagged->resp_cond_state->resp_text->resp_text_code) {
+
+		m_status->updateFromResponse(
+			*resp->response_done->response_tagged->resp_cond_state->resp_text->resp_text_code
+		);
+	}
+
+	// Process untagged responses
+	for (auto it = resp->continue_req_or_response_data.begin() ;
+	     it != resp->continue_req_or_response_data.end() ; ++it) {
+
+		if ((*it)->response_data &&
+		    (*it)->response_data->resp_cond_state &&
+		    (*it)->response_data->resp_cond_state->resp_text->resp_text_code) {
+
+			m_status->updateFromResponse(
+				*(*it)->response_data->resp_cond_state->resp_text->resp_text_code
+			);
+
+		} else if ((*it)->response_data &&
+		           (*it)->response_data->mailbox_data) {
+
+			m_status->updateFromResponse(*(*it)->response_data->mailbox_data);
+
+			// Update folder attributes, if available
+			if ((*it)->response_data->mailbox_data->type == IMAPParser::mailbox_data::LIST) {
+
+				folderAttributes attribs;
+				IMAPUtils::mailboxFlagsToFolderAttributes(
+					m_connection,
+					m_path,
+					*(*it)->response_data->mailbox_data->mailbox_list->mailbox_flag_list,
+					attribs
+				);
+
+				m_attribs = make_shared <folderAttributes>(attribs);
+			}
+
+		} else if ((*it)->response_data && (*it)->response_data->message_data) {
+
+			auto* msgData = (*it)->response_data->message_data.get();
+			const size_t msgNumber = msgData->number;
+
+			if (msgData->type == IMAPParser::message_data::FETCH) {
+
+				// Message changed
+				for (std::vector <IMAPMessage*>::iterator mit =
+				     m_messages.begin() ; mit != m_messages.end() ; ++mit) {
+
+					if ((*mit)->getNumber() == msgNumber) {
+						(*mit)->processFetchResponse(/* options */ 0, *msgData);
+					}
+				}
+
+				events.push_back(
+					make_shared <events::messageChangedEvent>(
+						dynamicCast <folder>(shared_from_this()),
+						events::messageChangedEvent::TYPE_FLAGS,
+						std::vector <size_t>(1, msgNumber)
+					)
+				);
+
+			} else if (msgData->type == IMAPParser::message_data::EXPUNGE) {
+
+				// A message has been expunged, renumber messages
+				for (std::vector <IMAPMessage*>::iterator jt =
+				     m_messages.begin() ; jt != m_messages.end() ; ++jt) {
+
+					if ((*jt)->getNumber() == msgNumber) {
+						(*jt)->setExpunged();
+					} else if ((*jt)->getNumber() > msgNumber) {
+						(*jt)->renumber((*jt)->getNumber() - 1);
+					}
+				}
+
+				events.push_back(
+					make_shared <events::messageCountEvent>(
+						dynamicCast <folder>(shared_from_this()),
+						events::messageCountEvent::TYPE_REMOVED,
+						std::vector <size_t>(1, msgNumber)
+					)
+				);
+
+				expungedMessageCount++;
+			}
+		}
+	}
+
+	// New messages arrived
+	if (m_status->getMessageCount() > oldStatus->getMessageCount() - expungedMessageCount) {
+
+		std::vector <size_t> newMessageNumbers;
+
+		for (size_t msgNumber = oldStatus->getMessageCount() - expungedMessageCount ;
+		     msgNumber <= m_status->getMessageCount() ; ++msgNumber) {
+
+			newMessageNumbers.push_back(msgNumber);
+		}
+
+		events.push_back(
+			make_shared <events::messageCountEvent>(
+				dynamicCast <folder>(shared_from_this()),
+				events::messageCountEvent::TYPE_ADDED,
+				newMessageNumbers
+			)
+		);
+	}
+
+	// Dispatch notifications
+	for (std::vector <shared_ptr <events::event> >::iterator evit =
+	     events.begin() ; evit != events.end() ; ++evit) {
+
+		notifyEvent(*evit);
+	}
+}
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
diff --git a/vmime-master/src/vmime/net/imap/IMAPFolder.hpp b/vmime-master/src/vmime/net/imap/IMAPFolder.hpp
new file mode 100644
index 0000000..3e6b04b
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPFolder.hpp
@@ -0,0 +1,230 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_NET_IMAP_IMAPFOLDER_HPP_INCLUDED
+#define VMIME_NET_IMAP_IMAPFOLDER_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include <vector>
+#include <map>
+
+#include "vmime/types.hpp"
+
+#include "vmime/net/folder.hpp"
+
+#include "vmime/net/imap/IMAPParser.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+class IMAPStore;
+class IMAPMessage;
+class IMAPConnection;
+class IMAPFolderStatus;
+
+
+/** IMAP folder implementation.
+  */
+class VMIME_EXPORT IMAPFolder : public folder {
+
+private:
+
+	friend class IMAPStore;
+	friend class IMAPMessage;
+
+	IMAPFolder(const IMAPFolder&);
+
+public:
+
+	IMAPFolder(
+		const folder::path& path,
+		const shared_ptr <IMAPStore>& store,
+		const shared_ptr <folderAttributes>& attribs
+	);
+
+	~IMAPFolder();
+
+	int getMode() const;
+
+	const folderAttributes getAttributes();
+
+	const folder::path::component getName() const;
+	const folder::path getFullPath() const;
+
+	void open(const int mode, bool failIfModeIsNotAvailable = false);
+	void close(const bool expunge);
+	void create(const folderAttributes& attribs);
+
+	bool exists();
+
+	void destroy();
+
+	bool isOpen() const;
+
+	shared_ptr <message> getMessage(const size_t num);
+	std::vector <shared_ptr <message> > getMessages(const messageSet& msgs);
+
+	std::vector <size_t> getMessageNumbersStartingOnUID(const message::uid& uid);
+
+	size_t getMessageCount();
+
+	shared_ptr <folder> getFolder(const folder::path::component& name);
+	std::vector <shared_ptr <folder> > getFolders(const bool recursive = false);
+
+	void rename(const folder::path& newPath);
+
+	void deleteMessages(const messageSet& msgs);
+
+	void setMessageFlags(
+		const messageSet& msgs,
+		const int flags,
+		const int mode = message::FLAG_MODE_SET
+	);
+
+	messageSet addMessage(
+		const shared_ptr <vmime::message>& msg,
+		const int flags = -1,
+		vmime::datetime* date = NULL,
+		utility::progressListener* progress = NULL
+	);
+
+	messageSet addMessage(
+		utility::inputStream& is,
+		const size_t size,
+		const int flags = -1,
+		vmime::datetime* date = NULL,
+		utility::progressListener* progress = NULL
+	);
+
+	messageSet copyMessages(const folder::path& dest, const messageSet& msgs);
+
+	void status(size_t& count, size_t& unseen);
+	shared_ptr <folderStatus> getStatus();
+
+	void noop();
+
+	void expunge();
+
+	shared_ptr <folder> getParent();
+
+	shared_ptr <const store> getStore() const;
+	shared_ptr <store> getStore();
+
+
+	void fetchMessages(
+		std::vector <shared_ptr <message> >& msg,
+		const fetchAttributes& options,
+		utility::progressListener* progress = NULL
+	);
+
+	void fetchMessage(const shared_ptr <message>& msg, const fetchAttributes& options);
+
+	std::vector <shared_ptr <message> > getAndFetchMessages(
+		const messageSet& msgs,
+		const fetchAttributes& attribs
+	);
+
+	int getFetchCapabilities() const;
+
+	/** Returns the UID validity of the folder for the current session.
+	  * If the server is capable of persisting UIDs accross sessions,
+	  * this value should never change for a folder. If the UID validity
+	  * differs across sessions, then the UIDs obtained during a previous
+	  * session may not correspond to the UIDs of the same messages in
+	  * this session.
+	  *
+	  * @return UID validity of the folder
+	  */
+	vmime_uint32 getUIDValidity() const;
+
+	/** Returns the highest modification sequence of this folder, ie the
+	  * modification sequence of the last message that changed in this
+	  * folder.
+	  *
+	  * @return modification sequence, or zero if not supported by
+	  * the underlying protocol
+	  */
+	vmime_uint64 getHighestModSequence() const;
+
+private:
+
+	void registerMessage(IMAPMessage* msg);
+	void unregisterMessage(IMAPMessage* msg);
+
+	void onStoreDisconnected();
+
+	void onClose();
+
+	int testExistAndGetType();
+
+	void setMessageFlagsImpl(const string& set, const int flags, const int mode);
+
+	void copyMessagesImpl(const string& set, const folder::path& dest);
+
+
+	/** Process status updates ("unsolicited responses") contained in the
+	  * specified response. Example:
+	  *
+	  *    C: a006 NOOP
+	  *    S: * 930 EXISTS       <-- this is a status update
+	  *    S: a006 OK Success
+	  *
+	  * @param resp parsed IMAP response
+	  */
+	void processStatusUpdate(const IMAPParser::response* resp);
+
+
+	weak_ptr <IMAPStore> m_store;
+	shared_ptr <IMAPConnection> m_connection;
+
+	folder::path m_path;
+	folder::path::component m_name;
+
+	int m_mode;
+	bool m_open;
+
+	shared_ptr <folderAttributes> m_attribs;
+
+	shared_ptr <IMAPFolderStatus> m_status;
+
+	std::vector <IMAPMessage*> m_messages;
+};
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+#endif // VMIME_NET_IMAP_IMAPFOLDER_HPP_INCLUDED
diff --git a/vmime-master/src/vmime/net/imap/IMAPFolderStatus.cpp b/vmime-master/src/vmime/net/imap/IMAPFolderStatus.cpp
new file mode 100644
index 0000000..55df337
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPFolderStatus.cpp
@@ -0,0 +1,292 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/imap/IMAPFolderStatus.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+IMAPFolderStatus::IMAPFolderStatus()
+	: m_count(0),
+	  m_unseen(0),
+	  m_recent(0),
+	  m_uidValidity(0),
+	  m_uidNext(0),
+	  m_highestModSeq(0) {
+
+}
+
+
+IMAPFolderStatus::IMAPFolderStatus(const IMAPFolderStatus& other)
+	: folderStatus(),
+	  m_count(other.m_count),
+	  m_unseen(other.m_unseen),
+	  m_recent(other.m_recent),
+	  m_uidValidity(other.m_uidValidity),
+	  m_uidNext(other.m_uidNext),
+	  m_highestModSeq(other.m_highestModSeq) {
+
+}
+
+
+size_t IMAPFolderStatus::getMessageCount() const {
+
+	return m_count;
+}
+
+
+size_t IMAPFolderStatus::getUnseenCount() const {
+
+	return m_unseen;
+}
+
+
+size_t IMAPFolderStatus::getRecentCount() const {
+
+	return m_recent;
+}
+
+
+vmime_uint32 IMAPFolderStatus::getUIDValidity() const {
+
+	return m_uidValidity;
+}
+
+
+vmime_uint32 IMAPFolderStatus::getUIDNext() const {
+
+	return m_uidNext;
+}
+
+
+vmime_uint64 IMAPFolderStatus::getHighestModSeq() const {
+
+	return m_highestModSeq;
+}
+
+
+shared_ptr <folderStatus> IMAPFolderStatus::clone() const {
+
+	return make_shared <IMAPFolderStatus>(*this);
+}
+
+
+bool IMAPFolderStatus::updateFromResponse(const IMAPParser::mailbox_data& resp) {
+
+	bool changed = false;
+
+	if (resp.type == IMAPParser::mailbox_data::STATUS) {
+
+		for (auto &attval : resp.status_att_list->values) {
+
+			switch (attval->type) {
+
+				case IMAPParser::status_att_val::MESSAGES: {
+
+					const size_t count =
+						static_cast <size_t>(attval->value_as_number()->value);
+
+					if (m_count != count) {
+						m_count = count;
+						changed = true;
+					}
+
+					break;
+				}
+				case IMAPParser::status_att_val::UNSEEN: {
+
+					const size_t unseen =
+						static_cast <size_t>(attval->value_as_number()->value);
+
+					if (m_unseen != unseen) {
+						m_unseen = unseen;
+						changed = true;
+					}
+
+					break;
+				}
+				case IMAPParser::status_att_val::RECENT: {
+
+					const size_t recent =
+						static_cast <size_t>(attval->value_as_number()->value);
+
+					if (m_recent != recent) {
+						m_recent = recent;
+						changed = true;
+					}
+
+					break;
+				}
+				case IMAPParser::status_att_val::UIDNEXT: {
+
+					const vmime_uint32 uidNext =
+						static_cast <vmime_uint32>(attval->value_as_number()->value);
+
+					if (m_uidNext != uidNext) {
+						m_uidNext = uidNext;
+						changed = true;
+					}
+
+					break;
+				}
+				case IMAPParser::status_att_val::UIDVALIDITY: {
+
+					const vmime_uint32 uidValidity =
+						static_cast <vmime_uint32>(attval->value_as_number()->value);
+
+					if (m_uidValidity != uidValidity) {
+						m_uidValidity = uidValidity;
+						changed = true;
+					}
+
+					break;
+				}
+				case IMAPParser::status_att_val::HIGHESTMODSEQ: {
+
+					const vmime_uint64 highestModSeq =
+						static_cast <vmime_uint64>(attval->value_as_mod_sequence_value()->value);
+
+					if (m_highestModSeq != highestModSeq) {
+						m_highestModSeq = highestModSeq;
+						changed = true;
+					}
+
+					break;
+				}
+
+			}
+		}
+
+	} else if (resp.type == IMAPParser::mailbox_data::EXISTS) {
+
+		const size_t count =
+			static_cast <size_t>(resp.number->value);
+
+		if (m_count != count) {
+			m_count = count;
+			changed = true;
+		}
+
+	} else if (resp.type == IMAPParser::mailbox_data::RECENT) {
+
+		const size_t recent =
+			static_cast <size_t>(resp.number->value);
+
+		if (m_recent != recent) {
+			m_recent = recent;
+			changed = true;
+		}
+	}
+
+	return changed;
+}
+
+
+bool IMAPFolderStatus::updateFromResponse(const IMAPParser::resp_text_code& resp) {
+
+	bool changed = false;
+
+	switch (resp.type) {
+
+		case IMAPParser::resp_text_code::UIDVALIDITY: {
+
+			const vmime_uint32 uidValidity =
+				static_cast <vmime_uint32>(resp.nz_number->value);
+
+			if (m_uidValidity != uidValidity) {
+				m_uidValidity = uidValidity;
+				changed = true;
+			}
+
+			break;
+		}
+		case IMAPParser::resp_text_code::UIDNEXT: {
+
+			const vmime_uint32 uidNext =
+				static_cast <vmime_uint32>(resp.nz_number->value);
+
+			if (m_uidNext != uidNext) {
+				m_uidNext = uidNext;
+				changed = true;
+			}
+
+			break;
+		}
+		case IMAPParser::resp_text_code::UNSEEN: {
+
+			const size_t unseen =
+				static_cast <size_t>(resp.nz_number->value);
+
+			if (m_unseen != unseen)
+			{
+				m_unseen = unseen;
+				changed = true;
+			}
+
+			break;
+		}
+		case IMAPParser::resp_text_code::HIGHESTMODSEQ: {
+
+			const vmime_uint64 highestModSeq =
+				static_cast <vmime_uint64>(resp.mod_sequence_value->value);
+
+			if (m_highestModSeq != highestModSeq) {
+				m_highestModSeq = highestModSeq;
+				changed = true;
+			}
+
+			break;
+		}
+		case IMAPParser::resp_text_code::NOMODSEQ: {
+
+			if (m_highestModSeq != 0) {
+				m_highestModSeq = 0;
+				changed = true;
+			}
+
+			break;
+		}
+		default:
+
+			break;
+	}
+
+	return changed;
+}
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
diff --git a/vmime-master/src/vmime/net/imap/IMAPFolderStatus.hpp b/vmime-master/src/vmime/net/imap/IMAPFolderStatus.hpp
new file mode 100644
index 0000000..b9a73ec
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPFolderStatus.hpp
@@ -0,0 +1,123 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_NET_IMAP_IMAPFOLDERSTATUS_HPP_INCLUDED
+#define VMIME_NET_IMAP_IMAPFOLDERSTATUS_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/folderStatus.hpp"
+
+#include "vmime/net/imap/IMAPParser.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+/** Holds the status of an IMAP folder.
+  */
+class VMIME_EXPORT IMAPFolderStatus : public folderStatus {
+
+public:
+
+	IMAPFolderStatus();
+	IMAPFolderStatus(const IMAPFolderStatus& other);
+
+	// Inherited from folderStatus
+	size_t getMessageCount() const;
+	size_t getUnseenCount() const;
+
+	shared_ptr <folderStatus> clone() const;
+
+	/** Returns the the number of messages with the Recent flag set.
+	  *
+	  * @return number of messages flagged Recent
+	  */
+	size_t getRecentCount() const;
+
+	/** Returns the UID validity of the folder for the current session.
+	  * If the server is capable of persisting UIDs accross sessions,
+	  * this value should never change for a folder.
+	  *
+	  * @return UID validity of the folder
+	  */
+	vmime_uint32 getUIDValidity() const;
+
+	/** Returns the UID value that will be assigned to a new message
+	  * in the folder. If the server does not support the UIDPLUS
+	  * extension, it will return 0.
+	  *
+	  * @return UID of the next message
+	  */
+	vmime_uint32 getUIDNext() const;
+
+	/** Returns the highest modification sequence of all messages
+	  * in the folder, or 0 if not available for this folder, or not
+	  * supported by the server. The server must support the CONDSTORE
+	  * extension for this to be available.
+	  *
+	  * @return highest modification sequence
+	  */
+	vmime_uint64 getHighestModSeq() const;
+
+
+	/** Reads the folder status from the specified IMAP response.
+	  *
+	  * @param resp parsed IMAP response
+	  * @return true if the status changed, or false otherwise
+	  */
+	bool updateFromResponse(const IMAPParser::mailbox_data& resp);
+
+	/** Reads the folder status from the specified IMAP response.
+	  *
+	  * @param resp parsed IMAP response
+	  * @return true if the status changed, or false otherwise
+	  */
+	bool updateFromResponse(const IMAPParser::resp_text_code& resp);
+
+private:
+
+	size_t m_count;
+	size_t m_unseen;
+	size_t m_recent;
+	vmime_uint32 m_uidValidity;
+	vmime_uint32 m_uidNext;
+	vmime_uint64 m_highestModSeq;
+};
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+#endif // VMIME_NET_IMAP_IMAPFOLDERSTATUS_HPP_INCLUDED
diff --git a/vmime-master/src/vmime/net/imap/IMAPMessage.cpp b/vmime-master/src/vmime/net/imap/IMAPMessage.cpp
new file mode 100644
index 0000000..f74a4a4
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPMessage.cpp
@@ -0,0 +1,760 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/imap/IMAPParser.hpp"
+#include "vmime/net/imap/IMAPMessage.hpp"
+#include "vmime/net/imap/IMAPFolder.hpp"
+#include "vmime/net/imap/IMAPFolderStatus.hpp"
+#include "vmime/net/imap/IMAPStore.hpp"
+#include "vmime/net/imap/IMAPConnection.hpp"
+#include "vmime/net/imap/IMAPUtils.hpp"
+#include "vmime/net/imap/IMAPMessageStructure.hpp"
+#include "vmime/net/imap/IMAPMessagePart.hpp"
+#include "vmime/net/imap/IMAPMessagePartContentHandler.hpp"
+
+#include "vmime/utility/outputStreamAdapter.hpp"
+
+#include <sstream>
+#include <iterator>
+#include <typeinfo>
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+#ifndef VMIME_BUILDING_DOC
+
+//
+// IMAPMessage_literalHandler
+//
+
+class IMAPMessage_literalHandler : public IMAPParser::literalHandler {
+
+public:
+
+	IMAPMessage_literalHandler(utility::outputStream& os, utility::progressListener* progress) {
+
+		m_target = shared_ptr <target>(new targetStream(progress, os));
+	}
+
+	shared_ptr <target> targetFor(const IMAPParser::component& comp, const int /* data */) {
+
+		if (typeid(comp) == typeid(IMAPParser::msg_att_item)) {
+
+			const int type = static_cast
+				<const IMAPParser::msg_att_item&>(comp).type;
+
+			if (type == IMAPParser::msg_att_item::BODY_SECTION ||
+			    type == IMAPParser::msg_att_item::RFC822_TEXT) {
+
+				return m_target;
+			}
+		}
+
+		return shared_ptr <target>();
+	}
+
+	shared_ptr <target> getTarget() {
+
+		return m_target;
+	}
+
+private:
+
+	shared_ptr <target> m_target;
+};
+
+#endif // VMIME_BUILDING_DOC
+
+
+
+//
+// IMAPMessage
+//
+
+
+IMAPMessage::IMAPMessage(
+	const shared_ptr <IMAPFolder>& folder,
+	const size_t num
+)
+	: m_folder(folder),
+	  m_num(num),
+	  m_size(-1U),
+	  m_flags(FLAG_UNDEFINED),
+	  m_expunged(false),
+	  m_modseq(0),
+	  m_structure(null) {
+
+	folder->registerMessage(this);
+}
+
+
+IMAPMessage::IMAPMessage(
+	const shared_ptr <IMAPFolder>& folder,
+	const size_t num,
+	const uid& uid
+)
+	: m_folder(folder),
+	  m_num(num),
+	  m_size(-1),
+	  m_flags(FLAG_UNDEFINED),
+	  m_expunged(false),
+	  m_uid(uid),
+	  m_modseq(0),
+	  m_structure(null) {
+
+	folder->registerMessage(this);
+}
+
+
+IMAPMessage::~IMAPMessage() {
+
+	try {
+
+		shared_ptr <IMAPFolder> folder = m_folder.lock();
+
+		if (folder) {
+			folder->unregisterMessage(this);
+		}
+
+	} catch (...) {
+
+		// Don't throw in destructor
+	}
+}
+
+
+void IMAPMessage::onFolderClosed() {
+
+	m_folder.reset();
+}
+
+
+size_t IMAPMessage::getNumber() const {
+
+	return m_num;
+}
+
+
+const message::uid IMAPMessage::getUID() const {
+
+	return m_uid;
+}
+
+
+vmime_uint64 IMAPMessage::getModSequence() const {
+
+	return m_modseq;
+}
+
+
+size_t IMAPMessage::getSize() const {
+
+	if (m_size == -1U) {
+		throw exceptions::unfetched_object();
+	}
+
+	return m_size;
+}
+
+
+bool IMAPMessage::isExpunged() const {
+
+	return m_expunged;
+}
+
+
+int IMAPMessage::getFlags() const {
+
+	if (m_flags == FLAG_UNDEFINED) {
+		throw exceptions::unfetched_object();
+	}
+
+	return m_flags;
+}
+
+
+shared_ptr <const messageStructure> IMAPMessage::getStructure() const {
+
+	if (m_structure == NULL) {
+		throw exceptions::unfetched_object();
+	}
+
+	return m_structure;
+}
+
+
+shared_ptr <messageStructure> IMAPMessage::getStructure() {
+
+	if (m_structure == NULL) {
+		throw exceptions::unfetched_object();
+	}
+
+	return m_structure;
+}
+
+
+shared_ptr <const header> IMAPMessage::getHeader() const {
+
+	if (m_header == NULL) {
+		throw exceptions::unfetched_object();
+	}
+
+	return m_header;
+}
+
+
+void IMAPMessage::extract(
+	utility::outputStream& os,
+	utility::progressListener* progress,
+    const size_t start,
+    const size_t length,
+    const bool peek
+) const {
+
+	shared_ptr <const IMAPFolder> folder = m_folder.lock();
+
+	if (!folder) {
+		throw exceptions::folder_not_found();
+	}
+
+	extractImpl(
+		null, os, progress, start, length,
+		EXTRACT_HEADER | EXTRACT_BODY | (peek ? EXTRACT_PEEK : 0)
+	);
+}
+
+
+void IMAPMessage::extractPart(
+	const shared_ptr <const messagePart>& p,
+	utility::outputStream& os,
+	utility::progressListener* progress,
+	const size_t start,
+	const size_t length,
+	const bool peek
+) const {
+
+	shared_ptr <const IMAPFolder> folder = m_folder.lock();
+
+	if (!folder) {
+		throw exceptions::folder_not_found();
+	}
+
+	extractImpl(
+		p, os, progress, start, length,
+		EXTRACT_HEADER | EXTRACT_BODY | (peek ? EXTRACT_PEEK : 0)
+	);
+}
+
+
+void IMAPMessage::fetchPartHeader(const shared_ptr <messagePart>& p) {
+
+	shared_ptr <IMAPFolder> folder = m_folder.lock();
+
+	if (!folder) {
+		throw exceptions::folder_not_found();
+	}
+
+	std::ostringstream oss;
+	utility::outputStreamAdapter ossAdapter(oss);
+
+	extractImpl(p, ossAdapter, NULL, 0, -1, EXTRACT_HEADER | EXTRACT_PEEK);
+
+	dynamicCast <IMAPMessagePart>(p)->getOrCreateHeader().parse(oss.str());
+}
+
+
+void IMAPMessage::fetchPartHeaderForStructure(const shared_ptr <messageStructure>& str) {
+
+	for (size_t i = 0, n = str->getPartCount() ; i < n ; ++i) {
+
+		shared_ptr <messagePart> part = str->getPartAt(i);
+
+		// Fetch header of current part
+		fetchPartHeader(part);
+
+		// Fetch header of sub-parts
+		fetchPartHeaderForStructure(part->getStructure());
+	}
+}
+
+
+size_t IMAPMessage::extractImpl(
+	const shared_ptr <const messagePart>& p,
+	utility::outputStream& os,
+	utility::progressListener* progress,
+	const size_t start,
+	const size_t length,
+	const int extractFlags
+) const {
+
+	shared_ptr <const IMAPFolder> folder = m_folder.lock();
+
+	IMAPMessage_literalHandler literalHandler(os, progress);
+
+	if (length == 0) {
+		return 0;
+	}
+
+	// Construct section identifier
+	std::ostringstream section;
+	section.imbue(std::locale::classic());
+
+	if (p != NULL) {
+
+		shared_ptr <const IMAPMessagePart> currentPart = dynamicCast <const IMAPMessagePart>(p);
+		std::vector <size_t> numbers;
+
+		numbers.push_back(currentPart->getNumber());
+		currentPart = currentPart->getParent();
+
+		while (currentPart != NULL) {
+			numbers.push_back(currentPart->getNumber());
+			currentPart = currentPart->getParent();
+		}
+
+		numbers.erase(numbers.end() - 1);
+
+		for (std::vector <size_t>::reverse_iterator it = numbers.rbegin() ; it != numbers.rend() ; ++it) {
+			if (it != numbers.rbegin()) section << ".";
+			section << (*it + 1);
+		}
+	}
+
+	// Build the body descriptor for FETCH
+	/*
+	   BODY[]               header + body
+	   BODY.PEEK[]          header + body (peek)
+	   BODY[HEADER]         header
+	   BODY.PEEK[HEADER]    header (peek)
+	   BODY[TEXT]           body
+	   BODY.PEEK[TEXT]      body (peek)
+	*/
+	std::ostringstream bodyDesc;
+	bodyDesc.imbue(std::locale::classic());
+
+	bodyDesc << "BODY";
+
+	if (extractFlags & EXTRACT_PEEK) {
+		bodyDesc << ".PEEK";
+	}
+
+	bodyDesc << "[";
+
+	if (section.str().empty()) {
+
+		// header + body
+		if ((extractFlags & EXTRACT_HEADER) && (extractFlags & EXTRACT_BODY)) {
+			bodyDesc << "";
+		// body only
+		} else if (extractFlags & EXTRACT_BODY) {
+			bodyDesc << "TEXT";
+		// header only
+		} else if (extractFlags & EXTRACT_HEADER) {
+			bodyDesc << "HEADER";
+		}
+
+	} else {
+
+		bodyDesc << section.str();
+
+		// header + body
+		if ((extractFlags & EXTRACT_HEADER) && (extractFlags & EXTRACT_BODY)) {
+
+			// First, extract header
+			std::ostringstream header;
+			utility::outputStreamAdapter headerStream(header);
+
+			const size_t headerLength = extractImpl(
+				p, headerStream, /* progress */ NULL,
+				/* start */ 0, /* length */ -1, extractFlags & ~EXTRACT_BODY
+			);
+
+			size_t s = start;
+			size_t l = length;
+
+			if (s < headerLength) {
+
+				if (l == static_cast <size_t>(-1)) {
+
+					os.write(header.str().data() + s, headerLength - s);
+
+				} else {
+
+					size_t headerCopyLength = l;
+
+					if (start + headerCopyLength > headerLength) {
+						headerCopyLength = headerLength - start;
+					}
+
+					os.write(header.str().data() + s, headerCopyLength);
+
+					l -= headerCopyLength;
+				}
+
+				s = 0;
+
+			} else {
+
+				s -= headerLength;
+			}
+
+			// Then, extract body
+			return extractImpl(p, os, progress, s, l, extractFlags & ~EXTRACT_HEADER);
+
+		// header only
+		} else if (extractFlags & EXTRACT_HEADER) {
+
+			bodyDesc << ".MIME";   // "MIME" not "HEADER" for parts
+		}
+	}
+
+	bodyDesc << "]";
+
+	if (start != 0 || length != static_cast <size_t>(-1)) {
+
+		if (length == static_cast <size_t>(-1)) {
+			bodyDesc << "<" << start << "." << static_cast <unsigned int>(-1) << ">";
+		} else {
+			bodyDesc << "<" << start << "." << length << ">";
+		}
+	}
+
+	std::vector <std::string> fetchParams;
+	fetchParams.push_back(bodyDesc.str());
+
+	// Send the request
+	IMAPCommand::FETCH(
+		m_uid.empty() ? messageSet::byNumber(m_num) : messageSet::byUID(m_uid),
+		fetchParams
+	)->send(folder->m_connection);
+
+	// Get the response
+	scoped_ptr <IMAPParser::response> resp(folder->m_connection->readResponse(&literalHandler));
+
+	if (resp->isBad() || resp->response_done->response_tagged->
+		resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		throw exceptions::command_error("FETCH", resp->getErrorLog(), "bad response");
+	}
+
+
+	if (extractFlags & EXTRACT_BODY) {
+		// TODO: update the flags (eg. flag "\Seen" may have been set)
+	}
+
+	return literalHandler.getTarget()->getBytesWritten();
+}
+
+
+int IMAPMessage::processFetchResponse(
+	const fetchAttributes& options,
+	const IMAPParser::message_data& msgData
+) {
+
+	shared_ptr <IMAPFolder> folder = m_folder.lock();
+
+	// Get message attributes
+	int changes = 0;
+
+	for (auto &att : msgData.msg_att->items) {
+
+		switch (att->type) {
+
+			case IMAPParser::msg_att_item::FLAGS: {
+
+				int flags = IMAPUtils::messageFlagsFromFlags(*att->flag_list);
+
+				if (m_flags != flags) {
+					m_flags = flags;
+					changes |= events::messageChangedEvent::TYPE_FLAGS;
+				}
+
+				break;
+			}
+			case IMAPParser::msg_att_item::UID: {
+
+				m_uid = att->uniqueid->value;
+				break;
+			}
+			case IMAPParser::msg_att_item::MODSEQ: {
+
+				m_modseq = att->mod_sequence_value->value;
+				break;
+			}
+			case IMAPParser::msg_att_item::ENVELOPE: {
+
+				if (!options.has(fetchAttributes::FULL_HEADER)) {
+
+					auto* env = att->envelope.get();
+					shared_ptr <vmime::header> hdr = getOrCreateHeader();
+
+					// Date
+					hdr->Date()->setValue(env->env_date->value);
+
+					// Subject
+					text subject;
+					text::decodeAndUnfold(env->env_subject->value, &subject);
+
+					hdr->Subject()->setValue(subject);
+
+					// From
+					mailboxList from;
+					IMAPUtils::convertAddressList(*(env->env_from), from);
+
+					if (!from.isEmpty()) {
+						hdr->From()->setValue(*(from.getMailboxAt(0)));
+					}
+
+					// To
+					mailboxList to;
+					IMAPUtils::convertAddressList(*(env->env_to), to);
+
+					hdr->To()->setValue(to.toAddressList());
+
+					// Sender
+					mailboxList sender;
+					IMAPUtils::convertAddressList(*(env->env_sender), sender);
+
+					if (!sender.isEmpty()) {
+						hdr->Sender()->setValue(*(sender.getMailboxAt(0)));
+					}
+
+					// Reply-to
+					mailboxList replyTo;
+					IMAPUtils::convertAddressList(*(env->env_reply_to), replyTo);
+
+					if (!replyTo.isEmpty()) {
+						hdr->ReplyTo()->setValue(*(replyTo.getMailboxAt(0)));
+					}
+
+					// Cc
+					mailboxList cc;
+					IMAPUtils::convertAddressList(*(env->env_cc), cc);
+
+					if (!cc.isEmpty()) {
+						hdr->Cc()->setValue(cc.toAddressList());
+					}
+
+					// Bcc
+					mailboxList bcc;
+					IMAPUtils::convertAddressList(*(env->env_bcc), bcc);
+
+					if (!bcc.isEmpty()) {
+						hdr->Bcc()->setValue(bcc.toAddressList());
+					}
+				}
+
+				break;
+			}
+			case IMAPParser::msg_att_item::BODY_STRUCTURE: {
+
+				m_structure = make_shared <IMAPMessageStructure>(att->body.get());
+				break;
+			}
+			case IMAPParser::msg_att_item::RFC822_HEADER: {
+
+				getOrCreateHeader()->parse(att->nstring->value);
+				break;
+			}
+			case IMAPParser::msg_att_item::RFC822_SIZE: {
+
+				m_size = static_cast <size_t>(att->number->value);
+				break;
+			}
+			case IMAPParser::msg_att_item::BODY_SECTION: {
+
+				if (!options.has(fetchAttributes::FULL_HEADER)) {
+
+					if (att->section->section_text1 &&
+					    att->section->section_text1->type
+					        == IMAPParser::section_text::HEADER_FIELDS) {
+
+						header tempHeader;
+						tempHeader.parse(att->nstring->value);
+
+						vmime::header& hdr = *getOrCreateHeader();
+
+						for (auto& fld : tempHeader.getFieldList()) {
+							hdr.appendField(vmime::clone(fld));
+						}
+					}
+				}
+
+				break;
+			}
+			case IMAPParser::msg_att_item::INTERNALDATE:
+			case IMAPParser::msg_att_item::RFC822:
+			case IMAPParser::msg_att_item::RFC822_TEXT:
+			case IMAPParser::msg_att_item::BODY: {
+
+				break;
+			}
+
+		}
+	}
+
+	return changes;
+}
+
+
+shared_ptr <header> IMAPMessage::getOrCreateHeader() {
+
+	if (m_header != NULL) {
+		return m_header;
+	} else {
+		return m_header = make_shared <header>();
+	}
+}
+
+
+void IMAPMessage::setFlags(const int flags, const int mode) {
+
+	shared_ptr <IMAPFolder> folder = m_folder.lock();
+
+	if (!folder) {
+		throw exceptions::folder_not_found();
+	}
+
+	if (!m_uid.empty()) {
+		folder->setMessageFlags(messageSet::byUID(m_uid), flags, mode);
+	} else {
+		folder->setMessageFlags(messageSet::byNumber(m_num), flags, mode);
+	}
+}
+
+
+void IMAPMessage::constructParsedMessage(
+	const shared_ptr <bodyPart>& parentPart,
+	const shared_ptr <messageStructure>& str,
+	int level
+) {
+
+	if (level == 0) {
+
+		shared_ptr <messagePart> part = str->getPartAt(0);
+
+		// Copy header
+		shared_ptr <const header> hdr = part->getHeader();
+		parentPart->getHeader()->copyFrom(*hdr);
+
+		// Initialize body
+		parentPart->getBody()->setContents(
+			make_shared <IMAPMessagePartContentHandler>(
+				dynamicCast <IMAPMessage>(shared_from_this()),
+				part, parentPart->getBody()->getEncoding()
+			)
+		);
+
+		constructParsedMessage(parentPart, part->getStructure(), 1);
+
+	} else {
+
+		for (size_t i = 0, n = str->getPartCount() ; i < n ; ++i) {
+
+			shared_ptr <messagePart> part = str->getPartAt(i);
+
+			shared_ptr <bodyPart> childPart = make_shared <bodyPart>();
+
+			// Copy header
+			shared_ptr <const header> hdr = part->getHeader();
+			childPart->getHeader()->copyFrom(*hdr);
+
+			// Initialize body
+			childPart->getBody()->setContents(
+				make_shared <IMAPMessagePartContentHandler>(
+					dynamicCast <IMAPMessage>(shared_from_this()),
+					part, childPart->getBody()->getEncoding()
+				)
+			);
+
+			// Add child part
+			parentPart->getBody()->appendPart(childPart);
+
+			// Construct sub parts
+			constructParsedMessage(childPart, part->getStructure(), ++level);
+		}
+	}
+}
+
+
+shared_ptr <vmime::message> IMAPMessage::getParsedMessage() {
+
+	// Fetch structure
+	shared_ptr <messageStructure> structure;
+
+	try {
+
+		structure = getStructure();
+
+	} catch (exceptions::unfetched_object&) {
+
+		std::vector <shared_ptr <message> > msgs;
+		msgs.push_back(dynamicCast <IMAPMessage>(shared_from_this()));
+
+		m_folder.lock()->fetchMessages(
+			msgs, fetchAttributes(fetchAttributes::STRUCTURE), /* progress */ NULL
+		);
+
+		structure = getStructure();
+	}
+
+	// Fetch header for each part
+	fetchPartHeaderForStructure(structure);
+
+	// Construct message from structure
+	shared_ptr <vmime::message> msg = make_shared <vmime::message>();
+
+	constructParsedMessage(msg, structure);
+
+	return msg;
+}
+
+
+void IMAPMessage::renumber(const size_t number) {
+
+	m_num = number;
+}
+
+
+void IMAPMessage::setExpunged() {
+
+	m_expunged = true;
+}
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
diff --git a/vmime-master/src/vmime/net/imap/IMAPMessage.hpp b/vmime-master/src/vmime/net/imap/IMAPMessage.hpp
new file mode 100644
index 0000000..6d82a3e
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPMessage.hpp
@@ -0,0 +1,200 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_NET_IMAP_IMAPMESSAGE_HPP_INCLUDED
+#define VMIME_NET_IMAP_IMAPMESSAGE_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/message.hpp"
+#include "vmime/net/folder.hpp"
+
+#include "vmime/net/imap/IMAPParser.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+class IMAPFolder;
+
+
+/** IMAP message implementation.
+  */
+class VMIME_EXPORT IMAPMessage : public message {
+
+private:
+
+	friend class IMAPFolder;
+	friend class IMAPMessagePartContentHandler;
+
+	IMAPMessage(const IMAPMessage&) : message() { }
+
+public:
+
+	IMAPMessage(const shared_ptr <IMAPFolder>& folder, const size_t num);
+	IMAPMessage(const shared_ptr <IMAPFolder>& folder, const size_t num, const uid& uid);
+
+	~IMAPMessage();
+
+	size_t getNumber() const;
+
+	const uid getUID() const;
+
+	/** Returns the modification sequence for this message.
+	  *
+	  * Every time metadata for this message changes, the modification
+	  * sequence is updated, and is greater than the previous one. The
+	  * server must support the CONDSTORE extension for this to be
+	  * available.
+	  *
+	  * @return modification sequence, or zero if not supported by
+	  * the underlying protocol
+	  */
+	vmime_uint64 getModSequence() const;
+
+	size_t getSize() const;
+
+	bool isExpunged() const;
+
+	shared_ptr <const messageStructure> getStructure() const;
+	shared_ptr <messageStructure> getStructure();
+
+	shared_ptr <const header> getHeader() const;
+
+	int getFlags() const;
+	void setFlags(const int flags, const int mode = FLAG_MODE_SET);
+
+	void extract(
+		utility::outputStream& os,
+		utility::progressListener* progress = NULL,
+		const size_t start = 0,
+		const size_t length = -1,
+		const bool peek = false
+	) const;
+
+	void extractPart(
+		const shared_ptr <const messagePart>& p,
+		utility::outputStream& os,
+		utility::progressListener* progress = NULL,
+		const size_t start = 0,
+		const size_t length = -1,
+		const bool peek = false
+	) const;
+
+	void fetchPartHeader(const shared_ptr <messagePart>& p);
+
+	shared_ptr <vmime::message> getParsedMessage();
+
+private:
+
+	/** Renumbers the message.
+	  *
+	  * @param number new sequence number
+	  */
+	void renumber(const size_t number);
+
+	/** Marks the message as expunged.
+	  */
+	void setExpunged();
+
+	/** Processes the parsed response to fill in the attributes
+	  * and metadata of this message.
+	  *
+	  * @param options one or more fetch options (see folder::fetchAttributes)
+	  * @param msgData pointer to message_data component of the parsed response
+	  * @return a combination of flags that specify what changed exactly on
+	  * this message (see events::messageChangedEvent::Types)
+	  */
+	int processFetchResponse(const fetchAttributes& options, const IMAPParser::message_data& msgData);
+
+	/** Recursively fetch part header for all parts in the structure.
+	  *
+	  * @param str structure for which to fetch parts headers
+	  */
+	void fetchPartHeaderForStructure(const shared_ptr <messageStructure>& str);
+
+	/** Recursively contruct parsed message from structure.
+	  * Called by getParsedMessage().
+	  *
+	  * @param parentPart root body part (the message)
+	  * @param str structure for which to construct part
+	  * @param level current nesting level (0 is root)
+	  */
+	void constructParsedMessage(
+		const shared_ptr <bodyPart>& parentPart,
+		const shared_ptr <messageStructure>& str,
+		int level = 0
+	);
+
+
+	enum ExtractFlags
+	{
+		EXTRACT_HEADER = 0x1,
+		EXTRACT_BODY = 0x2,
+		EXTRACT_PEEK = 0x10
+	};
+
+	size_t extractImpl(
+		const shared_ptr <const messagePart>& p,
+		utility::outputStream& os,
+		utility::progressListener* progress,
+		const size_t start,
+		const size_t length,
+		const int extractFlags
+	) const;
+
+
+	shared_ptr <header> getOrCreateHeader();
+
+
+	void onFolderClosed();
+
+	weak_ptr <IMAPFolder> m_folder;
+
+	size_t m_num;
+	size_t m_size;
+	int m_flags;
+	bool m_expunged;
+	uid m_uid;
+	vmime_uint64 m_modseq;
+
+	shared_ptr <header> m_header;
+	shared_ptr <messageStructure> m_structure;
+};
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+#endif // VMIME_NET_IMAP_IMAPMESSAGE_HPP_INCLUDED
diff --git a/vmime-master/src/vmime/net/imap/IMAPMessagePart.cpp b/vmime-master/src/vmime/net/imap/IMAPMessagePart.cpp
new file mode 100644
index 0000000..ed2c0bd
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPMessagePart.cpp
@@ -0,0 +1,225 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/imap/IMAPMessagePart.hpp"
+#include "vmime/net/imap/IMAPMessageStructure.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+IMAPMessagePart::IMAPMessagePart(
+	const shared_ptr <IMAPMessagePart>& parent,
+	const size_t number,
+	const IMAPParser::body_type_mpart* mpart
+)
+	: m_parent(parent),
+	  m_header(null),
+	  m_number(number),
+	  m_size(0) {
+
+	m_mediaType = vmime::mediaType(
+		"multipart",
+		mpart->media_subtype->value
+	);
+}
+
+namespace {
+	template<typename T>
+	vmime::string getPartName(const T& body_type) {
+		if (const auto* pparam = body_type->body_fields->body_fld_param.get()) {
+			for (const auto& param : pparam->items) {
+				if (param->string1->value == "NAME") {
+					return param->string2->value;
+				}
+			}
+		}
+
+		return {};
+	}
+}
+
+
+IMAPMessagePart::IMAPMessagePart(
+	const shared_ptr <IMAPMessagePart>& parent,
+	const size_t number,
+	const IMAPParser::body_type_1part* part
+)
+	: m_parent(parent),
+	  m_header(null),
+	  m_number(number),
+	  m_size(0) {
+
+	if (part->body_type_text) {
+
+		m_mediaType = vmime::mediaType(
+			"text",
+			part->body_type_text->media_text->media_subtype->value
+		);
+
+		m_size = part->body_type_text->body_fields->body_fld_octets->value;
+
+		m_name = getPartName(part->body_type_text);
+
+	} else if (part->body_type_msg) {
+
+		m_mediaType = vmime::mediaType(
+			"message",
+			part->body_type_msg->media_message->media_subtype->value
+		);
+
+	} else {
+
+		m_mediaType = vmime::mediaType(
+			part->body_type_basic->media_basic->media_type->value,
+			part->body_type_basic->media_basic->media_subtype->value
+		);
+
+		m_size = part->body_type_basic->body_fields->body_fld_octets->value;
+
+		m_name = getPartName(part->body_type_basic);
+	}
+
+	if (part->body_ext_1part && part->body_ext_1part->body_fld_dsp) {
+		auto *cdisp = part->body_ext_1part->body_fld_dsp->str();
+		if (cdisp) {
+			m_dispType = contentDisposition(cdisp->value);
+		}
+	}
+
+	m_structure = null;
+}
+
+
+shared_ptr <const messageStructure> IMAPMessagePart::getStructure() const {
+
+	if (m_structure) {
+		return m_structure;
+	} else {
+		return IMAPMessageStructure::emptyStructure();
+	}
+}
+
+
+shared_ptr <messageStructure> IMAPMessagePart::getStructure() {
+
+	if (m_structure) {
+		return m_structure;
+	} else {
+		return IMAPMessageStructure::emptyStructure();
+	}
+}
+
+
+shared_ptr <const IMAPMessagePart> IMAPMessagePart::getParent() const {
+
+	return m_parent.lock();
+}
+
+
+const mediaType& IMAPMessagePart::getType() const {
+
+	return m_mediaType;
+}
+
+
+const contentDisposition &IMAPMessagePart::getDisposition() const {
+
+	return m_dispType;
+}
+
+
+size_t IMAPMessagePart::getSize() const {
+
+	return m_size;
+}
+
+
+size_t IMAPMessagePart::getNumber() const {
+
+	return m_number;
+}
+
+
+string IMAPMessagePart::getName() const {
+
+	return m_name;
+}
+
+
+shared_ptr <const header> IMAPMessagePart::getHeader() const {
+
+	if (!m_header) {
+		throw exceptions::unfetched_object();
+	} else {
+		return m_header;
+	}
+}
+
+
+// static
+shared_ptr <IMAPMessagePart> IMAPMessagePart::create(
+	const shared_ptr <IMAPMessagePart>& parent,
+	const size_t number,
+	const IMAPParser::body* body
+) {
+
+	if (body->body_type_mpart) {
+
+		auto part = make_shared <IMAPMessagePart>(parent, number, body->body_type_mpart.get());
+		part->m_structure = make_shared <IMAPMessageStructure>(part, body->body_type_mpart->list);
+
+		return part;
+
+	} else {
+
+		return make_shared <IMAPMessagePart>(parent, number, body->body_type_1part.get());
+	}
+}
+
+
+header& IMAPMessagePart::getOrCreateHeader() {
+
+	if (m_header) {
+		return *m_header;
+	} else {
+		return *(m_header = make_shared <header>());
+	}
+}
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
diff --git a/vmime-master/src/vmime/net/imap/IMAPMessagePart.hpp b/vmime-master/src/vmime/net/imap/IMAPMessagePart.hpp
new file mode 100644
index 0000000..34ea172
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPMessagePart.hpp
@@ -0,0 +1,108 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_NET_IMAP_IMAPMESSAGEPART_HPP_INCLUDED
+#define VMIME_NET_IMAP_IMAPMESSAGEPART_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/message.hpp"
+
+#include "vmime/net/imap/IMAPParser.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+class IMAPMessageStructure;
+
+
+class VMIME_EXPORT IMAPMessagePart : public messagePart {
+
+public:
+
+	IMAPMessagePart(
+		const shared_ptr <IMAPMessagePart>& parent,
+		const size_t number,
+		const IMAPParser::body_type_mpart* mpart
+	);
+
+	IMAPMessagePart(
+		const shared_ptr <IMAPMessagePart>& parent,
+		const size_t number,
+		const IMAPParser::body_type_1part* part
+	);
+
+	shared_ptr <const messageStructure> getStructure() const;
+	shared_ptr <messageStructure> getStructure();
+
+	shared_ptr <const IMAPMessagePart> getParent() const;
+
+	const mediaType& getType() const;
+	const contentDisposition &getDisposition() const;
+	size_t getSize() const;
+	size_t getNumber() const;
+	string getName() const;
+
+	shared_ptr <const header> getHeader() const;
+
+
+	static shared_ptr <IMAPMessagePart> create(
+		const shared_ptr <IMAPMessagePart>& parent,
+		const size_t number,
+		const IMAPParser::body* body
+	);
+
+
+	header& getOrCreateHeader();
+
+private:
+
+	shared_ptr <IMAPMessageStructure> m_structure;
+	weak_ptr <IMAPMessagePart> m_parent;
+	shared_ptr <header> m_header;
+
+	size_t m_number;
+	size_t m_size;
+	string m_name;
+	mediaType m_mediaType;
+	contentDisposition m_dispType;
+};
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+#endif // VMIME_NET_IMAP_IMAPMESSAGEPART_HPP_INCLUDED
+
diff --git a/vmime-master/src/vmime/net/imap/IMAPMessagePartContentHandler.cpp b/vmime-master/src/vmime/net/imap/IMAPMessagePartContentHandler.cpp
new file mode 100644
index 0000000..85f6cb6
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPMessagePartContentHandler.cpp
@@ -0,0 +1,227 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/imap/IMAPMessagePartContentHandler.hpp"
+#include "vmime/net/imap/IMAPFolder.hpp"
+#include "vmime/net/imap/IMAPConnection.hpp"
+#include "vmime/net/imap/IMAPFolderStatus.hpp"
+#include "vmime/net/imap/IMAPStore.hpp"
+
+#include "vmime/utility/outputStreamAdapter.hpp"
+#include "vmime/utility/inputStreamStringAdapter.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+IMAPMessagePartContentHandler::IMAPMessagePartContentHandler(
+	const shared_ptr <IMAPMessage>& msg,
+	const shared_ptr <messagePart>& part,
+	const vmime::encoding& encoding
+)
+	: m_message(msg),
+	  m_part(part),
+	  m_encoding(encoding) {
+
+}
+
+
+shared_ptr <contentHandler> IMAPMessagePartContentHandler::clone() const {
+
+	return make_shared <IMAPMessagePartContentHandler>(
+		m_message.lock(), m_part.lock(), m_encoding
+	);
+}
+
+
+void IMAPMessagePartContentHandler::generate(
+	utility::outputStream& os,
+	const vmime::encoding& enc,
+	const size_t maxLineLength
+) const {
+
+	shared_ptr <IMAPMessage> msg = m_message.lock();
+	shared_ptr <messagePart> part = m_part.lock();
+
+	// Data is already encoded
+	if (isEncoded()) {
+
+		// The data is already encoded but the encoding specified for
+		// the generation is different from the current one. We need
+		// to re-encode data: decode from input buffer to temporary
+		// buffer, and then re-encode to output stream...
+		if (m_encoding != enc) {
+
+			// Extract part contents to temporary buffer
+			std::ostringstream oss;
+			utility::outputStreamAdapter tmp(oss);
+
+			msg->extractPart(part, tmp, NULL);
+
+			// Decode to another temporary buffer
+			utility::inputStreamStringAdapter in(oss.str());
+
+			std::ostringstream oss2;
+			utility::outputStreamAdapter tmp2(oss2);
+
+			shared_ptr <utility::encoder::encoder> theDecoder = m_encoding.getEncoder();
+			theDecoder->decode(in, tmp2);
+
+			// Reencode to output stream
+			string str = oss2.str();
+			utility::inputStreamStringAdapter tempIn(str);
+
+			shared_ptr <utility::encoder::encoder> theEncoder = enc.getEncoder();
+			theEncoder->getProperties()["maxlinelength"] = maxLineLength;
+			theEncoder->getProperties()["text"] = (m_contentType.getType() == mediaTypes::TEXT);
+
+			theEncoder->encode(tempIn, os);
+
+		// No encoding to perform
+		} else {
+
+			msg->extractPart(part, os);
+		}
+
+	// Need to encode data before
+	} else {
+
+		// Extract part contents to temporary buffer
+		std::ostringstream oss;
+		utility::outputStreamAdapter tmp(oss);
+
+		msg->extractPart(part, tmp, NULL);
+
+		// Encode temporary buffer to output stream
+		shared_ptr <utility::encoder::encoder> theEncoder = enc.getEncoder();
+		theEncoder->getProperties()["maxlinelength"] = maxLineLength;
+		theEncoder->getProperties()["text"] = (m_contentType.getType() == mediaTypes::TEXT);
+
+		utility::inputStreamStringAdapter is(oss.str());
+
+		theEncoder->encode(is, os);
+	}
+}
+
+
+void IMAPMessagePartContentHandler::extract(
+	utility::outputStream& os,
+	utility::progressListener* progress
+) const {
+
+	shared_ptr <IMAPMessage> msg = m_message.lock();
+	shared_ptr <messagePart> part = m_part.lock();
+
+	// No decoding to perform
+	if (!isEncoded()) {
+
+		msg->extractImpl(part, os, progress, 0, -1, IMAPMessage::EXTRACT_BODY);
+
+	// Need to decode data
+	} else {
+
+		// Extract part contents to temporary buffer
+		std::ostringstream oss;
+		utility::outputStreamAdapter tmp(oss);
+
+		msg->extractImpl(part, tmp, NULL, 0, -1, IMAPMessage::EXTRACT_BODY);
+
+		// Encode temporary buffer to output stream
+		utility::inputStreamStringAdapter is(oss.str());
+		utility::progressListenerSizeAdapter plsa(progress, getLength());
+
+		shared_ptr <utility::encoder::encoder> theDecoder = m_encoding.getEncoder();
+		theDecoder->decode(is, os, &plsa);
+	}
+}
+
+
+void IMAPMessagePartContentHandler::extractRaw(
+	utility::outputStream& os,
+	utility::progressListener* progress
+) const {
+
+	shared_ptr <IMAPMessage> msg = m_message.lock();
+	shared_ptr <messagePart> part = m_part.lock();
+
+	msg->extractPart(part, os, progress);
+}
+
+
+size_t IMAPMessagePartContentHandler::getLength() const {
+
+	return m_part.lock()->getSize();
+}
+
+
+bool IMAPMessagePartContentHandler::isEncoded() const {
+
+	return m_encoding != NO_ENCODING;
+}
+
+
+const vmime::encoding& IMAPMessagePartContentHandler::getEncoding() const {
+
+	return m_encoding;
+}
+
+
+bool IMAPMessagePartContentHandler::isEmpty() const {
+
+	return getLength() == 0;
+}
+
+
+bool IMAPMessagePartContentHandler::isBuffered() const {
+
+	return true;
+}
+
+
+void IMAPMessagePartContentHandler::setContentTypeHint(const mediaType& type) {
+
+	m_contentType = type;
+}
+
+
+const mediaType IMAPMessagePartContentHandler::getContentTypeHint() const {
+
+	return m_contentType;
+}
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
diff --git a/vmime-master/src/vmime/net/imap/IMAPMessagePartContentHandler.hpp b/vmime-master/src/vmime/net/imap/IMAPMessagePartContentHandler.hpp
new file mode 100644
index 0000000..17f53e3
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPMessagePartContentHandler.hpp
@@ -0,0 +1,95 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_NET_IMAP_IMAPMESSAGEPARTCONTENTHANDLER_HPP_INCLUDED
+#define VMIME_NET_IMAP_IMAPMESSAGEPARTCONTENTHANDLER_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/contentHandler.hpp"
+#include "vmime/net/imap/IMAPMessage.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+class VMIME_EXPORT IMAPMessagePartContentHandler : public contentHandler {
+
+public:
+
+	IMAPMessagePartContentHandler(
+		const shared_ptr <IMAPMessage>& msg,
+		const shared_ptr <messagePart>& part,
+		const vmime::encoding& encoding
+	);
+
+	shared_ptr <contentHandler> clone() const;
+
+	void generate(
+		utility::outputStream& os,
+		const vmime::encoding& enc,
+		const size_t maxLineLength = lineLengthLimits::infinite
+	) const;
+
+	void extract(utility::outputStream& os, utility::progressListener* progress = NULL) const;
+	void extractRaw(utility::outputStream& os, utility::progressListener* progress = NULL) const;
+
+	size_t getLength() const;
+
+	bool isEncoded() const;
+
+	const vmime::encoding& getEncoding() const;
+
+	bool isEmpty() const;
+
+	bool isBuffered() const;
+
+	void setContentTypeHint(const mediaType& type);
+	const mediaType getContentTypeHint() const;
+
+private:
+
+	weak_ptr <IMAPMessage> m_message;
+	weak_ptr <messagePart> m_part;
+
+	vmime::encoding m_encoding;
+	vmime::mediaType m_contentType;
+};
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+#endif // VMIME_NET_IMAP_IMAPMESSAGEPARTCONTENTHANDLER_HPP_INCLUDED
+
diff --git a/vmime-master/src/vmime/net/imap/IMAPMessageStructure.cpp b/vmime-master/src/vmime/net/imap/IMAPMessageStructure.cpp
new file mode 100644
index 0000000..c7ee809
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPMessageStructure.cpp
@@ -0,0 +1,94 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/imap/IMAPMessageStructure.hpp"
+#include "vmime/net/imap/IMAPMessagePart.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+IMAPMessageStructure::IMAPMessageStructure() {
+}
+
+
+IMAPMessageStructure::IMAPMessageStructure(const IMAPParser::body* body) {
+
+	m_parts.push_back(IMAPMessagePart::create(null, 0, body));
+}
+
+
+IMAPMessageStructure::IMAPMessageStructure(
+	const shared_ptr <IMAPMessagePart>& parent,
+	const std::vector <std::unique_ptr <IMAPParser::body>>& list
+) {
+
+	size_t number = 0;
+
+	for (auto it = list.begin() ; it != list.end() ; ++it, ++number) {
+		m_parts.push_back(IMAPMessagePart::create(parent, number, it->get()));
+	}
+}
+
+
+shared_ptr <const messagePart> IMAPMessageStructure::getPartAt(const size_t x) const {
+
+	return m_parts[x];
+}
+
+
+shared_ptr <messagePart> IMAPMessageStructure::getPartAt(const size_t x) {
+
+	return m_parts[x];
+}
+
+
+size_t IMAPMessageStructure::getPartCount() const {
+
+	return m_parts.size();
+}
+
+
+// static
+shared_ptr <IMAPMessageStructure> IMAPMessageStructure::emptyStructure() {
+
+	static shared_ptr <IMAPMessageStructure> emptyStructure = make_shared <IMAPMessageStructure>();
+	return emptyStructure;
+}
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
diff --git a/vmime-master/src/vmime/net/imap/IMAPMessageStructure.hpp b/vmime-master/src/vmime/net/imap/IMAPMessageStructure.hpp
new file mode 100644
index 0000000..ee1eac4
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPMessageStructure.hpp
@@ -0,0 +1,75 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_NET_IMAP_IMAPMESSAGESTRUCTURE_HPP_INCLUDED
+#define VMIME_NET_IMAP_IMAPMESSAGESTRUCTURE_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/message.hpp"
+
+#include "vmime/net/imap/IMAPParser.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+class IMAPMessagePart;
+
+
+class VMIME_EXPORT IMAPMessageStructure : public messageStructure {
+
+public:
+
+	IMAPMessageStructure();
+	IMAPMessageStructure(const IMAPParser::body* body);
+	IMAPMessageStructure(const shared_ptr <IMAPMessagePart>& parent, const std::vector <std::unique_ptr <IMAPParser::body>>& list);
+
+	shared_ptr <const messagePart> getPartAt(const size_t x) const;
+	shared_ptr <messagePart> getPartAt(const size_t x);
+	size_t getPartCount() const;
+
+	static shared_ptr <IMAPMessageStructure> emptyStructure();
+
+private:
+
+	std::vector <shared_ptr <IMAPMessagePart> > m_parts;
+};
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+#endif // VMIME_NET_IMAP_IMAPMESSAGESTRUCTURE_HPP_INCLUDED
+
diff --git a/vmime-master/src/vmime/net/imap/IMAPParser.hpp b/vmime-master/src/vmime/net/imap/IMAPParser.hpp
new file mode 100644
index 0000000..281fcb6
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPParser.hpp
@@ -0,0 +1,4986 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_NET_IMAP_IMAPPARSER_HPP_INCLUDED
+#define VMIME_NET_IMAP_IMAPPARSER_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/base.hpp"
+#include "vmime/dateTime.hpp"
+#include "vmime/charset.hpp"
+#include "vmime/exception.hpp"
+
+#include "vmime/utility/stringUtils.hpp"
+#include "vmime/utility/progressListener.hpp"
+
+#include "vmime/utility/encoder/b64Encoder.hpp"
+#include "vmime/utility/encoder/qpEncoder.hpp"
+
+#include "vmime/utility/inputStreamStringAdapter.hpp"
+#include "vmime/utility/outputStreamStringAdapter.hpp"
+
+#include "vmime/platform.hpp"
+
+#include "vmime/net/timeoutHandler.hpp"
+#include "vmime/net/socket.hpp"
+#include "vmime/net/tracer.hpp"
+
+#include "vmime/net/imap/IMAPTag.hpp"
+
+#include <vector>
+#include <stdexcept>
+#include <memory>
+
+
+//#define DEBUG_RESPONSE 1
+
+
+#if DEBUG_RESPONSE
+#   include <iostream>
+#endif
+
+
+/** Make the parsing of a component fail.
+  */
+#define VIMAP_PARSER_FAIL() \
+	{  \
+		parser.m_errorResponseLine = makeResponseLine(getComponentName(), line, pos);  \
+		return false;  \
+	}
+
+/** Make the parsing of a component fail if a condition is not matched.
+  * If the specified expression does not resolve to "true", the parsing
+  * will fail.
+  *
+  * @param cond condition expression
+  */
+#define VIMAP_PARSER_FAIL_UNLESS(cond) \
+	if (!(cond))  \
+	{  \
+		VIMAP_PARSER_FAIL();  \
+	}
+
+/** Check for a token and advance.
+  * If the token is not matched, parsing will fail.
+  *
+  * @param type token class
+  */
+#define VIMAP_PARSER_CHECK(type) \
+	VIMAP_PARSER_FAIL_UNLESS(parser.check <type>(line, &pos))
+
+/** Check for an optional token and advance.
+  * If the token is not matched, parsing will continue anyway.
+  *
+  * @param type token class
+  */
+#define VIMAP_PARSER_TRY_CHECK(type) \
+	(parser.check <type>(line, &pos))
+
+/** Get a token and advance.
+  * If the token is not matched, parsing will fail.
+  *
+  * @param type token class
+  * @param variable variable which will receive pointer to the retrieved token
+  */
+#define VIMAP_PARSER_GET(type, variable) \
+	{ \
+		variable.reset(parser.get <type>(line, &pos));  \
+		VIMAP_PARSER_FAIL_UNLESS(variable.get());  \
+	}
+
+/** Get an optional token and advance.
+  * If the token is not matched, parsing will continue anyway.
+  */
+#define VIMAP_PARSER_TRY_GET(type, variable) \
+	(variable.reset(parser.get <type>(line, &pos)), variable.get())
+
+/** Get an optional token and advance. If found, token will be pushed back
+  * to a vector. If the token is not matched, stopInstr will be executed.
+  *
+  * @param type token class
+  * @param variable variable of type std::vector<> to which the retrieved
+  * token will be pushed
+  * @param stopInstr instruction to execute if token is not found
+  */
+#define VIMAP_PARSER_TRY_GET_PUSHBACK_OR_ELSE(type, variable, stopInstr) \
+	{  \
+		std::unique_ptr <type> v;  \
+		try  \
+		{  \
+			v.reset(parser.get <type>(line, &pos));  \
+			if (!v)  \
+			{  \
+				stopInstr;  \
+			}  \
+			variable.push_back(std::move(v));  \
+		}  \
+		catch (...)  \
+		{  \
+			throw;  \
+		}  \
+	}
+
+/** Get a token and advance. Token will be pushed back to a vector.
+  * If the token is not matched, parsing will fail.
+  *
+  * @param type token class
+  * @param variable variable of type std::vector<> to which the retrieved
+  * token will be pushed
+  */
+#define VIMAP_PARSER_GET_PUSHBACK(type, variable) \
+	VIMAP_PARSER_TRY_GET_PUSHBACK_OR_ELSE(type, variable, VIMAP_PARSER_FAIL())
+
+
+/** Check for a token which takes an argument and advance.
+  * If the token is not matched, parsing will fail.
+  *
+  * @param type token class
+  */
+#define VIMAP_PARSER_CHECK_WITHARG(type, arg) \
+	VIMAP_PARSER_FAIL_UNLESS(parser.checkWithArg <type>(line, &pos, arg))
+
+/** Check for an optional token which takes an argument and advance.
+  * If the token is not matched, parsing will continue anyway.
+  *
+  * @param type token class
+  */
+#define VIMAP_PARSER_TRY_CHECK_WITHARG(type, arg) \
+	(parser.checkWithArg <type>(line, &pos, arg))
+
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+#if DEBUG_RESPONSE
+	static int IMAPParserDebugResponse_level = 0;
+	static std::vector <string> IMAPParserDebugResponse_stack;
+
+	class IMAPParserDebugResponse {
+
+	public:
+
+		IMAPParserDebugResponse(
+			const string& name,
+			string& line,
+			const size_t currentPos,
+			const bool &result
+		)
+			: m_name(name),
+			  m_line(line),
+			  m_pos(currentPos),
+			  m_result(result) {
+
+			++IMAPParserDebugResponse_level;
+			IMAPParserDebugResponse_stack.push_back(name);
+
+			for (int i = 0 ; i < IMAPParserDebugResponse_level ; ++i) {
+				std::cout << "  ";
+			}
+
+			std::cout << "ENTER(" << m_name << "), pos=" << m_pos;
+			std::cout << std::endl;
+
+			for (std::vector <string>::iterator it = IMAPParserDebugResponse_stack.begin() ;
+			     it != IMAPParserDebugResponse_stack.end() ; ++it) {
+
+				std::cout << "> " << *it << " ";
+			}
+
+			std::cout << std::endl;
+			std::cout << string(m_line.begin() + (m_pos < 30 ? 0U : m_pos - 30),
+				m_line.begin() + std::min(m_line.length(), m_pos + 30)) << std::endl;
+
+			for (size_t i = (m_pos < 30 ? m_pos : (m_pos - (m_pos - 30))) ; i != 0 ; --i) {
+				std::cout << " ";
+			}
+
+			std::cout << "^" << std::endl;
+		}
+
+		~IMAPParserDebugResponse() {
+
+			for (int i = 0 ; i < IMAPParserDebugResponse_level ; ++i) {
+				std::cout << "  ";
+			}
+
+			std::cout << "LEAVE(" << m_name << "), result=";
+			std::cout << (m_result ? "TRUE" : "FALSE") << ", pos=" << m_pos;
+			std::cout << std::endl;
+
+			--IMAPParserDebugResponse_level;
+			IMAPParserDebugResponse_stack.pop_back();
+		}
+
+	private:
+
+		const string m_name;
+		string m_line;
+		size_t m_pos;
+		const bool& m_result;
+	};
+
+
+	#define DEBUG_ENTER_COMPONENT(x, result) \
+		IMAPParserDebugResponse dbg(x, line, *currentPos, result)
+
+	#define DEBUG_FOUND(x, y) \
+		std::cout << "FOUND: " << x << ": " << y << std::endl;
+#else
+	#define DEBUG_ENTER_COMPONENT(x, result)
+	#define DEBUG_FOUND(x, y)
+#endif
+
+
+class VMIME_EXPORT IMAPParser : public object {
+
+public:
+
+	IMAPParser()
+		: m_progress(NULL),
+		  m_strict(false),
+		  m_literalHandler(NULL) {
+
+	}
+
+	~IMAPParser() {
+
+		for (auto it = m_pendingResponses.begin() ; it != m_pendingResponses.end() ; ++it) {
+			delete it->second;
+		}
+	}
+
+
+	/** Set the socket currently used by this parser to receive data
+	  * from server.
+	  *
+	  * @param sok socket
+	  */
+	void setSocket(const shared_ptr <socket>& sok) {
+
+		m_socket = sok;
+	}
+
+	/** Set the timeout handler currently used by this parser.
+	  *
+	  * @param toh timeout handler
+	  */
+	void setTimeoutHandler(const shared_ptr <timeoutHandler>& toh) {
+
+		m_timeoutHandler = toh;
+	}
+
+	/** Set the tracer currently used by this parser.
+	  *
+	  * @param tr tracer
+	  */
+	void setTracer(const shared_ptr <tracer>& tr) {
+
+		m_tracer = tr;
+	}
+
+	/** Set whether we operate in strict mode (this may not work
+	  * with some servers which are not fully standard-compliant).
+	  *
+	  * @param strict true to operate in strict mode, or false
+	  * to operate in default, relaxed mode
+	  */
+	void setStrict(const bool strict) {
+
+		m_strict = strict;
+	}
+
+	/** Return true if the parser operates in strict mode, or
+	  * false otherwise.
+	  *
+	  * @return true if we are in strict mode, false otherwise
+	  */
+	bool isStrict() const {
+
+		return m_strict;
+	}
+
+
+
+	//
+	// literalHandler : literal content handler
+	//
+
+	class component;
+
+	class literalHandler {
+
+	public:
+
+		virtual ~literalHandler() { }
+
+
+		// Abstract target class
+		class target {
+
+		protected:
+
+			target(utility::progressListener* progress) : m_progress(progress) {}
+			target(const target&) {}
+
+		public:
+
+			virtual ~target() { }
+
+
+			utility::progressListener* progressListener() { return (m_progress); }
+
+			virtual void putData(const string& chunk) = 0;
+
+			virtual size_t getBytesWritten() const = 0;
+
+		private:
+
+			utility::progressListener* m_progress;
+		};
+
+
+		// Target: put in a string
+		class targetString : public target {
+
+		public:
+
+			targetString(utility::progressListener* progress, vmime::string& str)
+				: target(progress), m_string(str), m_bytesWritten(0) { }
+
+			const vmime::string& string() const { return (m_string); }
+			vmime::string& string() { return (m_string); }
+
+
+			void putData(const vmime::string& chunk) {
+
+				m_string += chunk;
+				m_bytesWritten += chunk.length();
+			}
+
+			size_t getBytesWritten() const {
+
+				return m_bytesWritten;
+			}
+
+		private:
+
+			vmime::string& m_string;
+			size_t m_bytesWritten;
+		};
+
+
+		// Target: redirect to an output stream
+		class targetStream : public target {
+
+		public:
+
+			targetStream(
+				utility::progressListener* progress,
+				utility::outputStream& stream
+			)
+				: target(progress),
+				  m_stream(stream),
+				  m_bytesWritten(0) {
+
+			}
+
+			const utility::outputStream& stream() const { return (m_stream); }
+			utility::outputStream& stream() { return (m_stream); }
+
+
+			void putData(const string& chunk) {
+
+				m_stream.write(chunk.data(), chunk.length());
+				m_bytesWritten += chunk.length();
+			}
+
+			size_t getBytesWritten() const {
+
+				return m_bytesWritten;
+			}
+
+		private:
+
+			utility::outputStream& m_stream;
+			size_t m_bytesWritten;
+		};
+
+
+		// Called when the parser needs to know what to do with a literal
+		//    . comp: the component in which we are at this moment
+		//    . data: data specific to the component (may not be used)
+		//
+		// Returns :
+		//    . == NULL to put the literal into the response
+		//    . != NULL to redirect the literal to the specified target
+
+		virtual shared_ptr <target> targetFor(const component& comp, const int data) = 0;
+	};
+
+
+	//
+	// Base class for a terminal or a non-terminal
+	//
+
+	class component {
+
+	public:
+
+		component() { }
+		virtual ~component() { }
+
+		virtual const string getComponentName() const = 0;
+
+		bool parse(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			bool res = false;
+			DEBUG_ENTER_COMPONENT(getComponentName(), res);
+			res = parseImpl(parser, line, currentPos);
+			return res;
+		}
+
+		virtual bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) = 0;
+
+
+		const string makeResponseLine(
+			const string& comp,
+			const string& line,
+			const size_t pos
+		) {
+
+#if DEBUG_RESPONSE
+			if (pos > line.length()) {
+				std::cout << "WARNING: component::makeResponseLine(): pos > line.length()" << std::endl;
+			}
+#endif
+
+			string result(line.substr(0, pos));
+			result += "[^]";   // indicates current parser position
+			result += line.substr(pos, line.length());
+			if (!comp.empty()) result += " [" + comp + "]";
+
+			return (result);
+		}
+	};
+
+
+#define COMPONENT_ALIAS(parent, name) \
+	class name : public parent { \
+		virtual const string getComponentName() const { return #name; }  \
+	public: \
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) { \
+			return parent::parseImpl(parser, line, currentPos); \
+		} \
+	}
+
+#define DECLARE_COMPONENT(name) \
+	class name : public component {  \
+		virtual const string getComponentName() const { return #name; }  \
+	public:
+
+
+	//
+	// Parse one character
+	//
+
+	template <char C>
+	class one_char : public component {
+
+	public:
+
+		const string getComponentName() const {
+
+			return string("one_char <") + C + ">";
+		}
+
+		bool parseImpl(IMAPParser& /* parser */, string& line, size_t* currentPos) {
+
+			const size_t pos = *currentPos;
+
+			if (pos < line.length() && line[pos] == C) {
+				*currentPos = pos + 1;
+				return true;
+			} else {
+				return false;
+			}
+		}
+	};
+
+
+	//
+	// SPACE  ::= <ASCII SP, space, 0x20>
+	//
+
+	DECLARE_COMPONENT(SPACE)
+
+		bool parseImpl(IMAPParser& /* parser */, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			while (pos < line.length() && (line[pos] == ' ' || line[pos] == '\t')) {
+				++pos;
+			}
+
+			if (pos > *currentPos) {
+				*currentPos = pos;
+				return true;
+			} else {
+				return false;
+			}
+		}
+	};
+
+
+	//
+	// CR    ::= <ASCII CR, carriage return, 0x0D>
+	// LF    ::= <ASCII LF, line feed, 0x0A>
+	// CRLF  ::= CR LF
+	//
+
+	DECLARE_COMPONENT(CRLF)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_TRY_CHECK(SPACE);
+
+			if (pos + 1 < line.length() &&
+			    line[pos] == 0x0d && line[pos + 1] == 0x0a) {
+
+				*currentPos = pos + 2;
+				return true;
+
+			} else {
+
+				return false;
+			}
+		}
+	};
+
+
+	//
+	// SPACE           ::= <ASCII SP, space, 0x20>
+	// CTL             ::= <any ASCII control character and DEL, 0x00 - 0x1f, 0x7f>
+	// CHAR            ::= <any 7-bit US-ASCII character except NUL, 0x01 - 0x7f>
+	// ATOM_CHAR       ::= <any CHAR except atom_specials>
+	// atom_specials   ::= "(" / ")" / "{" / SPACE / CTL / list_wildcards / quoted_specials
+	// list_wildcards  ::= "%" / "*"
+	// quoted_specials ::= <"> / "\"
+	//
+	// tag             ::= 1*<any ATOM_CHAR except "+">    (named "xtag")
+	//
+
+	DECLARE_COMPONENT(xtag)
+
+		bool parseImpl(IMAPParser& /* parser */, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			bool end = false;
+
+			tagString.reserve(10);
+
+			while (!end && pos < line.length()) {
+
+				const unsigned char c = line[pos];
+
+				switch (c) {
+
+					case '+':
+					case '(':
+					case ')':
+					case '{':
+					case 0x20:  // SPACE
+					case '%':   // list_wildcards
+					case '*':   // list_wildcards
+					case '"':   // quoted_specials
+					case '\\':  // quoted_specials
+
+						end = true;
+						break;
+
+					default:
+
+						if (c <= 0x1f || c >= 0x7f) {
+							end = true;
+						} else {
+							tagString += c;
+							++pos;
+						}
+
+						break;
+				}
+			}
+
+			*currentPos = pos;
+			return true;
+		}
+
+		string tagString;
+	};
+
+
+	//
+	// digit     ::= "0" / digit_nz
+	// digit_nz  ::= "1" / "2" / "3" / "4" / "5" / "6" / "7" / "8" / "9"
+	//
+	// number    ::= 1*digit
+	//               ;; Unsigned 32-bit integer
+	//               ;; (0 <= n < 4,294,967,296)
+	//
+
+	DECLARE_COMPONENT(number)
+
+		number(const bool nonZero = false)
+			: value(0),
+			  m_nonZero(nonZero) {
+
+		}
+
+		bool parseImpl(IMAPParser& /* parser */, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			bool valid = true;
+			unsigned int val = 0;
+
+			while (valid && pos < line.length()) {
+
+				const char c = line[pos];
+
+				if (c >= '0' && c <= '9') {
+					val = (val * 10) + (c - '0');
+					++pos;
+				} else {
+					valid = false;
+				}
+			}
+
+			// Check for non-null length (and for non-zero number)
+			if (!(m_nonZero && val == 0) && pos != *currentPos) {
+				value = val;
+				*currentPos = pos;
+				return true;
+			} else {
+				return false;
+			}
+		}
+
+
+		unsigned long value;
+
+	private:
+
+		const bool m_nonZero;
+	};
+
+
+	// nz_number  ::= digit_nz *digit
+	//                ;; Non-zero unsigned 32-bit integer
+	//                ;; (0 < n < 4,294,967,296)
+	//
+
+	class nz_number : public number {
+
+	public:
+
+		nz_number()
+			: number(true) {
+
+		}
+	};
+
+
+	//
+	// uniqueid    ::= nz_number
+	//                 ;; Strictly ascending
+	//
+
+	class uniqueid : public nz_number {
+
+	public:
+
+		uniqueid()
+			: nz_number() {
+
+		}
+	};
+
+
+	// uid-range       = (uniqueid ":" uniqueid)
+	//                   ; two uniqueid values and all values
+	//                   ; between these two regards of order.
+	//                   ; Example: 2:4 and 4:2 are equivalent.
+
+	DECLARE_COMPONENT(uid_range)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(uniqueid, uniqueid1);
+			VIMAP_PARSER_CHECK(one_char <':'>);
+			VIMAP_PARSER_GET(uniqueid, uniqueid2);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <uniqueid> uniqueid1;
+		std::unique_ptr <uniqueid> uniqueid2;
+	};
+
+
+	//
+	// uid-set         = (uniqueid / uid-range) *("," uid-set)
+	//
+
+	DECLARE_COMPONENT(uid_set)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			// We have either a 'uid_range' or a 'uniqueid'
+			if (!VIMAP_PARSER_TRY_GET(IMAPParser::uid_range, uid_range)) {
+				VIMAP_PARSER_GET(IMAPParser::uniqueid, uniqueid);
+			}
+
+			// And maybe another 'uid-set' following
+			if (VIMAP_PARSER_TRY_CHECK(one_char <','>)) {
+				VIMAP_PARSER_GET(IMAPParser::uid_set, next_uid_set);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::uniqueid> uniqueid;
+		std::unique_ptr <IMAPParser::uid_range> uid_range;
+
+		std::unique_ptr <IMAPParser::uid_set> next_uid_set;
+	};
+
+
+	//
+	// text       ::= 1*TEXT_CHAR
+	//
+	// CHAR       ::= <any 7-bit US-ASCII character except NUL, 0x01 - 0x7f>
+	// TEXT_CHAR  ::= <any CHAR except CR and LF>
+	//
+
+	DECLARE_COMPONENT(text)
+
+		text(bool allow8bits = false, const char except = 0)
+			: m_allow8bits(allow8bits),
+			  m_except(except) {
+		}
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+			size_t len = 0;
+
+			if (m_allow8bits || !parser.isStrict()) {
+
+				const unsigned char except = m_except;
+
+				for (bool end = false ; !end && pos < line.length() ; ) {
+
+					const unsigned char c = line[pos];
+
+					if (c == 0x00 || c == 0x0d || c == 0x0a || c == except) {
+						end = true;
+					} else {
+						++pos;
+						++len;
+					}
+				}
+
+			} else {
+
+				const unsigned char except = m_except;
+
+				for (bool end = false ; !end && pos < line.length() ; ) {
+
+					const unsigned char c = line[pos];
+
+					if (c < 0x01 || c > 0x7f || c == 0x0d || c == 0x0a || c == except) {
+						end = true;
+					} else {
+						++pos;
+						++len;
+					}
+				}
+			}
+
+			if (len == 0) {
+				VIMAP_PARSER_FAIL();
+			}
+
+			value.resize(len);
+			std::copy(line.begin() + *currentPos, line.begin() + pos, value.begin());
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		string value;
+
+	private:
+
+		const bool m_allow8bits;
+		const char m_except;
+	};
+
+
+	class text8 : public text {
+
+	public:
+
+		text8() : text(true) {
+
+		}
+	};
+
+
+	template <char C>
+	class text_except : public text {
+
+	public:
+
+		text_except() : text(false, C) {
+
+		}
+	};
+
+
+	template <char C>
+	class text8_except : public text {
+
+	public:
+
+		text8_except() : text(true, C) {
+
+		}
+	};
+
+
+	//
+	// QUOTED_CHAR     ::= <any TEXT_CHAR except quoted_specials> / "\" quoted_specials
+	// quoted_specials ::= <"> / "\"
+	// TEXT_CHAR       ::= <any CHAR except CR and LF>
+	// CHAR            ::= <any 7-bit US-ASCII character except NUL, 0x01 - 0x7f>
+	//
+
+	DECLARE_COMPONENT(QUOTED_CHAR)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			const unsigned char c = static_cast <unsigned char>(pos < line.length() ? line[pos] : 0);
+
+			if (c >= 0x01 && c <= 0x7f &&   // 0x01 - 0x7f
+			    c != '"' && c != '\\' &&    // quoted_specials
+			    c != '\r' && c != '\n') {   // CR and LF
+
+				value = c;
+				*currentPos = pos + 1;
+
+			} else if (c == '\\' && pos + 1 < line.length() &&
+			           (line[pos + 1] == '"' || line[pos + 1] == '\\')) {
+
+				value = line[pos + 1];
+				*currentPos = pos + 2;
+
+			} else {
+
+				VIMAP_PARSER_FAIL();
+			}
+
+			return true;
+		}
+
+
+		char value;
+	};
+
+
+	//
+	// quoted          ::= <"> *QUOTED_CHAR <">
+	// QUOTED_CHAR     ::= <any TEXT_CHAR except quoted_specials> / "\" quoted_specials
+	// quoted_specials ::= <"> / "\"
+	// TEXT_CHAR       ::= <any CHAR except CR and LF>
+	// CHAR            ::= <any 7-bit US-ASCII character except NUL, 0x01 - 0x7f>
+	//
+
+	DECLARE_COMPONENT(quoted_text)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+			size_t len = 0;
+			bool valid = false;
+
+			value.reserve(line.length() - pos);
+
+			for (bool end = false, quoted = false ; !end && pos < line.length() ; ) {
+
+				const unsigned char c = line[pos];
+
+				if (quoted) {
+
+					if (c == '"' || c == '\\') {
+						value += c;
+					} else {
+						value += '\\';
+						value += c;
+					}
+
+					quoted = false;
+
+					++pos;
+					++len;
+
+				} else {
+
+					if (c == '\\') {
+
+						quoted = true;
+
+						++pos;
+						++len;
+
+					} else if (c == '"') {
+
+						valid = true;
+						end = true;
+
+					} else if (c >= 0x01 && c <= 0x7f &&  // CHAR
+					           c != 0x0a && c != 0x0d) {  // CR and LF
+
+						value += c;
+
+						++pos;
+						++len;
+
+					} else {
+
+						valid = false;
+						end = true;
+					}
+				}
+			}
+
+			if (!valid) {
+				VIMAP_PARSER_FAIL();
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		string value;
+	};
+
+
+	//
+	// nil  ::= "NIL"
+	//
+
+	DECLARE_COMPONENT(NIL)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK_WITHARG(special_atom, "nil");
+
+			*currentPos = pos;
+
+			return true;
+		}
+	};
+
+
+	//
+	// string          ::= quoted / literal    ----> named 'xstring'
+	//
+	// nil             ::= "NIL"
+	// quoted          ::= <"> *QUOTED_CHAR <">
+	// QUOTED_CHAR     ::= <any TEXT_CHAR except quoted_specials> / "\" quoted_specials
+	// quoted_specials ::= <"> / "\"
+	// TEXT_CHAR       ::= <any CHAR except CR and LF>
+	// CHAR            ::= <any 7-bit US-ASCII character except NUL, 0x01 - 0x7f>
+	// literal         ::= "{" number "}" CRLF *CHAR8
+	//                     ;; Number represents the number of CHAR8 octets
+	// CHAR8           ::= <any 8-bit octet except NUL, 0x01 - 0xff>
+	//
+
+	DECLARE_COMPONENT(xstring)
+
+		xstring(
+			const bool canBeNIL = false,
+			component* comp = NULL,
+			const int data = 0
+		)
+			: isNIL(true),
+			  m_canBeNIL(canBeNIL),
+			  m_component(comp),
+			  m_data(data) {
+
+		}
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (m_canBeNIL &&
+			    VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "nil")) {
+
+				// NIL
+				isNIL = true;
+
+			} else {
+
+				pos = *currentPos;
+
+				isNIL = false;
+
+				// quoted ::= <"> *QUOTED_CHAR <">
+				if (VIMAP_PARSER_TRY_CHECK(one_char <'"'>)) {
+
+					shared_ptr <quoted_text> text;
+					VIMAP_PARSER_GET(quoted_text, text);
+					VIMAP_PARSER_CHECK(one_char <'"'>);
+
+					if (parser.m_literalHandler != NULL) {
+
+						shared_ptr <literalHandler::target> target =
+							parser.m_literalHandler->targetFor(*m_component, m_data);
+
+						if (target != NULL) {
+
+							value = "[literal-handler]";
+
+							const size_t length = text->value.length();
+							utility::progressListener* progress = target->progressListener();
+
+							if (progress) {
+								progress->start(length);
+							}
+
+							target->putData(text->value);
+
+							if (progress) {
+								progress->progress(length, length);
+								progress->stop(length);
+							}
+
+						} else {
+
+							value = text->value;
+						}
+
+					} else {
+
+						value = text->value;
+					}
+
+					DEBUG_FOUND("string[quoted]", "<length=" << value.length() << ", value='" << value << "'>");
+
+				// literal ::= "{" number "}" CRLF *CHAR8
+				} else {
+
+					VIMAP_PARSER_CHECK(one_char <'{'>);
+
+					shared_ptr <number> num;
+					VIMAP_PARSER_GET(number, num);
+
+					const size_t length = num->value;
+
+					VIMAP_PARSER_CHECK(one_char <'}'> );
+
+					VIMAP_PARSER_CHECK(CRLF);
+
+
+					if (parser.m_literalHandler != NULL) {
+
+						shared_ptr <literalHandler::target> target =
+							parser.m_literalHandler->targetFor(*m_component, m_data);
+
+						if (target != NULL) {
+
+							value = "[literal-handler]";
+
+							parser.m_progress = target->progressListener();
+							parser.readLiteral(*target, length);
+							parser.m_progress = NULL;
+
+						} else {
+
+							literalHandler::targetString target(NULL, value);
+							parser.readLiteral(target, length);
+						}
+
+					} else {
+
+						literalHandler::targetString target(NULL, value);
+						parser.readLiteral(target, length);
+					}
+
+					line += parser.readLine();
+
+					DEBUG_FOUND("string[literal]", "<length=" << length << ", value='" << value << "'>");
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		bool isNIL;
+		string value;
+
+	private:
+
+		bool m_canBeNIL;
+
+		component* m_component;
+		const int m_data;
+	};
+
+
+	//
+	// nstring         ::= string / nil
+	//
+
+	class nstring : public xstring {
+
+	public:
+
+		const string getComponentName() const {
+
+			return "nstring";
+		}
+
+		nstring(component* comp = NULL, const int data = 0)
+			: xstring(true, comp, data) {
+
+		}
+	};
+
+
+	//
+	// astring ::= atom / string
+	//
+
+	DECLARE_COMPONENT(astring)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			std::unique_ptr <xstring> str;
+			VIMAP_PARSER_TRY_GET(xstring, str);
+
+			if (str) {
+				value = str->value;
+			} else {
+				std::unique_ptr <atom> at;
+				VIMAP_PARSER_GET(atom, at);
+				value = at->value;
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		string value;
+	};
+
+
+	//
+	// atom            ::= 1*ATOM_CHAR
+	//
+	// ATOM_CHAR       ::= <any CHAR except atom_specials>
+	// atom_specials   ::= "(" / ")" / "{" / SPACE / CTL / list_wildcards / quoted_specials
+	// CHAR            ::= <any 7-bit US-ASCII character except NUL, 0x01 - 0x7f>
+	// CTL             ::= <any ASCII control character and DEL, 0x00 - 0x1f, 0x7f>
+	// list_wildcards  ::= "%" / "*"
+	// quoted_specials ::= <"> / "\"
+	// SPACE           ::= <ASCII SP, space, 0x20>
+	//
+
+	DECLARE_COMPONENT(atom)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+			size_t len = 0;
+
+			for (bool end = false ; !end && pos < line.length() ; ) {
+
+				const unsigned char c = line[pos];
+
+				switch (c) {
+
+					case '(':
+					case ')':
+					case '{':
+					case 0x20:  // SPACE
+					case '%':   // list_wildcards
+					case '*':   // list_wildcards
+					case '"':   // quoted_specials
+					case '\\':  // quoted_specials
+
+					case '[':
+					case ']':   // for "special_atom"
+
+						end = true;
+						break;
+
+					default:
+
+						if (c <= 0x1f || c >= 0x7f) {
+							end = true;
+						} else {
+							++pos;
+							++len;
+						}
+					}
+			}
+
+			if (len != 0) {
+
+				value.resize(len);
+				std::copy(line.begin() + *currentPos, line.begin() + pos, value.begin());
+
+				*currentPos = pos;
+
+			} else {
+
+				VIMAP_PARSER_FAIL();
+			}
+
+			return true;
+		}
+
+
+		string value;
+	};
+
+
+	//
+	// special atom (eg. "CAPABILITY", "FLAGS", "STATUS"...)
+	//
+	//  " Except as noted otherwise, all alphabetic characters are case-
+	//    insensitive. The use of upper or lower case characters to define
+	//    token strings is for editorial clarity only. Implementations MUST
+	//    accept these strings in a case-insensitive fashion. "
+	//
+
+	class special_atom : public atom {
+
+	public:
+
+		const std::string getComponentName() const {
+
+			return string("special_atom <") + m_string + ">";
+		}
+
+		special_atom(const char* str)
+			: m_string(str) {  // 'string' must be in lower-case
+
+		}
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (!atom::parseImpl(parser, line, &pos)) {
+				return false;
+			}
+
+			const char* cmp = value.c_str();
+			const char* with = m_string;
+
+			bool ok = true;
+
+			while (ok && *cmp && *with) {
+
+				ok = (std::tolower(*cmp, std::locale()) == *with);
+
+				++cmp;
+				++with;
+			}
+
+			if (!ok || *cmp || *with) {
+				VIMAP_PARSER_FAIL();
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+	private:
+
+		const char* m_string;
+	};
+
+
+	//
+	// text_mime2 ::= "=?" <charset> "?" <encoding> "?" <encoded-text> "?="
+	//                ;; Syntax defined in [MIME-HDRS]
+	//
+
+	DECLARE_COMPONENT(text_mime2)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			std::unique_ptr <atom> theCharset, theEncoding;
+			std::unique_ptr <text> theText;
+
+			VIMAP_PARSER_CHECK(one_char <'='> );
+			VIMAP_PARSER_CHECK(one_char <'?'> );
+
+			VIMAP_PARSER_GET(atom, theCharset);
+
+			VIMAP_PARSER_CHECK(one_char <'?'> );
+
+			VIMAP_PARSER_GET(atom, theEncoding);
+
+			VIMAP_PARSER_CHECK(one_char <'?'> );
+
+			VIMAP_PARSER_GET(text8_except <'?'> , theText);
+
+			VIMAP_PARSER_CHECK(one_char <'?'> );
+			VIMAP_PARSER_CHECK(one_char <'='> );
+
+			charset = theCharset->value;
+
+			// Decode text
+			scoped_ptr <utility::encoder::encoder> theEncoder;
+
+			if (theEncoding->value[0] == 'q' || theEncoding->value[0] == 'Q') {
+
+				// Quoted-printable
+				theEncoder.reset(new utility::encoder::qpEncoder());
+				theEncoder->getProperties()["rfc2047"] = true;
+
+			} else if (theEncoding->value[0] == 'b' || theEncoding->value[0] == 'B') {
+
+				// Base64
+				theEncoder.reset(new utility::encoder::b64Encoder());
+			}
+
+			if (theEncoder.get()) {
+
+				utility::inputStreamStringAdapter in(theText->value);
+				utility::outputStreamStringAdapter out(value);
+
+				theEncoder->decode(in, out);
+
+			// No decoder available
+			} else {
+
+				value = theText->value;
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		vmime::charset charset;
+		string value;
+	};
+
+
+	// seq-number      = nz-number / "*"
+	//                    ; message sequence number (COPY, FETCH, STORE
+	//                    ; commands) or unique identifier (UID COPY,
+	//                    ; UID FETCH, UID STORE commands).
+
+	DECLARE_COMPONENT(seq_number)
+
+		seq_number()
+			: star(false) {
+
+		}
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK(one_char <'*'> )) {
+
+				star = true;
+				number.reset();
+
+			} else {
+
+				star = false;
+				VIMAP_PARSER_GET(IMAPParser::number, number);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::number> number;
+		bool star;
+	};
+
+
+	// seq-range       = seq-number ":" seq-number
+	//                    ; two seq-number values and all values between
+	//                    ; these two regardless of order.
+	//                    ; Example: 2:4 and 4:2 are equivalent and indicate
+	//                    ; values 2, 3, and 4.
+
+	DECLARE_COMPONENT(seq_range)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(seq_number, first);
+
+			VIMAP_PARSER_CHECK(one_char <'*'> );
+
+			VIMAP_PARSER_GET(seq_number, last);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::seq_number> first;
+		std::unique_ptr <IMAPParser::seq_number> last;
+	};
+
+
+	// sequence-set    = (seq-number / seq-range) *("," sequence-set)
+	//                    ; set of seq-number values, regardless of order.
+	//                    ; Servers MAY coalesce overlaps and/or execute the
+	//                    ; sequence in any order.
+	//                    ; Example: a message sequence number set of
+	//                    ; 2,4:7,9,12:* for a mailbox with 15 messages is
+	//                    ; equivalent to 2,4,5,6,7,9,12,13,14,15
+
+	DECLARE_COMPONENT(sequence_set)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (!VIMAP_PARSER_TRY_GET(IMAPParser::seq_range, range)) {
+				VIMAP_PARSER_GET(IMAPParser::seq_number, number);
+			}
+
+			if (VIMAP_PARSER_TRY_CHECK(one_char <','> )) {
+				VIMAP_PARSER_GET(sequence_set, nextSet);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::seq_number> number;
+		std::unique_ptr <IMAPParser::seq_range> range;
+		std::unique_ptr <IMAPParser::sequence_set> nextSet;
+	};
+
+
+	// mod-sequence-value  = 1*DIGIT
+	//                        ;; Positive unsigned 64-bit integer
+	//                        ;; (mod-sequence)
+	//                        ;; (1 <= n < 18,446,744,073,709,551,615)
+
+	DECLARE_COMPONENT(mod_sequence_value)
+
+		mod_sequence_value()
+			: value(0) {
+
+		}
+
+		bool parseImpl(IMAPParser& /* parser */, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			bool valid = true;
+			vmime_uint64 val = 0;
+
+			while (valid && pos < line.length()) {
+
+				const char c = line[pos];
+
+				if (c >= '0' && c <= '9') {
+					val = (val * 10) + (c - '0');
+					++pos;
+				} else {
+					valid = false;
+				}
+			}
+
+			value = val;
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		vmime_uint64 value;
+	};
+
+
+	//
+	// flag            ::= "\Answered" / "\Flagged" / "\Deleted" /
+	//                     "\Seen" / "\Draft" / flag_keyword / flag_extension
+	//
+	// flag_extension  ::= "\" atom
+	//                     ;; Future expansion.  Client implementations
+	//                     ;; MUST accept flag_extension flags.  Server
+	//                     ;; implementations MUST NOT generate
+	//                     ;; flag_extension flags except as defined by
+	//                     ;; future standard or standards-track
+	//                     ;; revisions of this specification.
+	//
+	// flag_keyword    ::= atom
+	//
+
+	DECLARE_COMPONENT(flag)
+
+		flag()
+			: type(UNKNOWN) {
+
+		}
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK(one_char <'\\'> )) {
+
+				if (VIMAP_PARSER_TRY_CHECK(one_char <'*'> )) {
+
+					type = STAR;
+
+				} else {
+
+					shared_ptr <atom> at;
+					VIMAP_PARSER_GET(atom, at);
+
+					const string tname = utility::stringUtils::toLower(at->value);
+
+					if (tname == "answered") {
+						type = ANSWERED;
+					} else if (tname == "flagged") {
+						type = FLAGGED;
+					} else if (tname == "deleted") {
+						type = DELETED;
+					} else if (tname == "seen") {
+						type = SEEN;
+					} else if (tname == "draft") {
+						type = DRAFT;
+					} else {
+						type = UNKNOWN;
+						name = tname;
+					}
+				}
+
+			} else {
+
+				if (!parser.isStrict() && VIMAP_PARSER_TRY_CHECK(one_char <'*'> )) {
+					type = STAR;  // map "*" to "\*"
+				} else {
+					type = KEYWORD_OR_EXTENSION;
+					VIMAP_PARSER_GET(atom, flag_keyword);
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Type {
+			UNKNOWN,
+			ANSWERED,
+			FLAGGED,
+			DELETED,
+			SEEN,
+			DRAFT,
+			KEYWORD_OR_EXTENSION,
+			STAR       // * = custom flags allowed
+		};
+
+
+		Type type;
+		string name;
+
+		std::unique_ptr <IMAPParser::atom> flag_keyword;
+	};
+
+
+	//
+	// flag_list ::= "(" #flag ")"
+	//
+
+	DECLARE_COMPONENT(flag_list)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'('> );
+
+			while (!VIMAP_PARSER_TRY_CHECK(one_char <')'> )) {
+				VIMAP_PARSER_GET_PUSHBACK(flag, flags);
+				VIMAP_PARSER_TRY_CHECK(SPACE);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::vector <std::unique_ptr <flag>> flags;
+	};
+
+
+	//
+	// mailbox ::= "INBOX" / astring
+	//             ;; INBOX is case-insensitive.  All case variants of
+	//             ;; INBOX (e.g. "iNbOx") MUST be interpreted as INBOX
+	//             ;; not as an astring.  Refer to section 5.1 for
+	//             ;; further semantic details of mailbox names.
+	//
+
+	DECLARE_COMPONENT(mailbox)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "inbox")) {
+
+				type = INBOX;
+				name = "INBOX";
+
+			} else {
+
+				type = OTHER;
+
+				std::unique_ptr <astring> astr;
+				VIMAP_PARSER_GET(astring, astr);
+				name = astr->value;
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Type {
+			INBOX,
+			OTHER
+		};
+
+
+		Type type;
+		string name;
+	};
+
+
+	//
+	// mailbox_flag := "\Marked" / "\Noinferiors" /
+	//                 "\Noselect" / "\Unmarked" / flag_extension
+	//
+
+	DECLARE_COMPONENT(mailbox_flag)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK(one_char <'\\'> )) {
+
+				std::unique_ptr <atom> at;
+				VIMAP_PARSER_GET(atom, at);
+
+				const string tname = utility::stringUtils::toLower(at->value);
+
+				type = UNKNOWN;  // default
+
+				switch (tname[0]) {
+
+					case 'a':
+
+						if (tname == "all") {
+							type = SPECIALUSE_ALL;
+						} else if (tname == "archive") {
+							type = SPECIALUSE_ARCHIVE;
+						}
+
+						break;
+
+					case 'd':
+
+						if (tname == "drafts") {
+							type = SPECIALUSE_DRAFTS;
+						}
+
+						break;
+
+					case 'f':
+
+						if (tname == "flagged") {
+							type = SPECIALUSE_FLAGGED;
+						}
+
+						break;
+
+					case 'h':
+
+						if (tname == "haschildren") {
+							type = HASCHILDREN;
+						} else if (tname == "hasnochildren") {
+							type = HASNOCHILDREN;
+						}
+
+						break;
+
+					case 'i':
+
+						if (tname == "important") {
+							type = SPECIALUSE_IMPORTANT;
+						}
+
+						break;
+
+					case 'j':
+
+						if (tname == "junk") {
+							type = SPECIALUSE_JUNK;
+						}
+
+						break;
+
+					case 'm':
+
+						if (tname == "marked") {
+							type = MARKED;
+						}
+
+						break;
+
+					case 'n':
+
+						if (tname == "noinferiors") {
+							type = NOINFERIORS;
+						} else if (tname == "noselect") {
+							type = NOSELECT;
+						}
+
+						break;
+
+					case 's':
+
+						if (tname == "sent") {
+							type = SPECIALUSE_SENT;
+						}
+
+						break;
+
+					case 't':
+
+						if (tname == "trash") {
+							type = SPECIALUSE_TRASH;
+						}
+
+						break;
+
+					case 'u':
+
+						if (tname == "unmarked") {
+							type = UNMARKED;
+						}
+
+						break;
+				}
+
+				if (type == UNKNOWN) {
+					name = "\\" + tname;
+				}
+
+			} else {
+
+				std::unique_ptr <atom> at;
+				VIMAP_PARSER_GET(atom, at);
+				const string tname = utility::stringUtils::toLower(at->value);
+
+				type = UNKNOWN;
+				name = tname;
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Type {
+			// RFC-3348 - Child Mailbox Extension
+			HASCHILDREN,
+			HASNOCHILDREN,
+
+			// RFC-6154 - Special-Use Mailboxes
+			SPECIALUSE_ALL,
+			SPECIALUSE_ARCHIVE,
+			SPECIALUSE_DRAFTS,
+			SPECIALUSE_FLAGGED,
+			SPECIALUSE_JUNK,
+			SPECIALUSE_SENT,
+			SPECIALUSE_TRASH,
+			SPECIALUSE_IMPORTANT,    // draft
+
+			// Standard mailbox flags
+			UNKNOWN,
+			MARKED,
+			NOINFERIORS,
+			NOSELECT,
+			UNMARKED
+		};
+
+
+		Type type;
+		string name;
+	};
+
+
+	//
+	// mailbox_flag_list ::= "(" #(mailbox_flag) ")"
+	//
+
+	DECLARE_COMPONENT(mailbox_flag_list)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'('> );
+
+			while (!VIMAP_PARSER_TRY_CHECK(one_char <')'> )) {
+				VIMAP_PARSER_GET_PUSHBACK(mailbox_flag, flags);
+				VIMAP_PARSER_TRY_CHECK(SPACE);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::vector <std::unique_ptr <mailbox_flag>> flags;
+	};
+
+
+	//
+	// mailbox_list ::= mailbox_flag_list SPACE
+	//                  (<"> QUOTED_CHAR <"> / nil) SPACE mailbox
+	//
+
+	DECLARE_COMPONENT(mailbox_list)
+
+		mailbox_list()
+			: quoted_char('\0') {
+
+		}
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(IMAPParser::mailbox_flag_list, mailbox_flag_list);
+
+			VIMAP_PARSER_CHECK(SPACE);
+
+			if (!VIMAP_PARSER_TRY_CHECK(NIL)) {
+
+				VIMAP_PARSER_CHECK(one_char <'"'> );
+
+				std::unique_ptr <QUOTED_CHAR> qc;
+				VIMAP_PARSER_GET(QUOTED_CHAR, qc);
+				quoted_char = qc->value;
+
+				VIMAP_PARSER_CHECK(one_char <'"'> );
+			}
+
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::mailbox, mailbox);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::mailbox_flag_list> mailbox_flag_list;
+		std::unique_ptr <IMAPParser::mailbox> mailbox;
+
+		char quoted_char;
+	};
+
+
+	//
+	// auth_type ::= atom
+	//               ;; Defined by [IMAP-AUTH]
+	//
+
+	DECLARE_COMPONENT(auth_type)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			std::unique_ptr <atom> at;
+			VIMAP_PARSER_GET(atom, at);
+
+			name = utility::stringUtils::toLower(at->value);
+
+			if (name == "kerberos_v4") {
+				type = KERBEROS_V4;
+			} else if (name == "gssapi") {
+				type = GSSAPI;
+			} else if (name == "skey") {
+				type = SKEY;
+			} else {
+				type = UNKNOWN;
+			}
+
+			return true;
+		}
+
+
+		enum Type {
+			UNKNOWN,
+
+			// RFC 1731 - IMAP4 Authentication Mechanisms
+			KERBEROS_V4,
+			GSSAPI,
+			SKEY
+		};
+
+
+		Type type;
+		string name;
+	};
+
+
+	//
+	// status-att-val  = ("MESSAGES" SP number) /
+	//                   ("RECENT" SP number) /
+	//                   ("UIDNEXT" SP nz-number) /
+	//                   ("UIDVALIDITY" SP nz-number) /
+	//                   ("UNSEEN" SP number)
+	//
+	// IMAP Extension for Conditional STORE (RFC-4551):
+	//
+	//   status-att-val      =/ "HIGHESTMODSEQ" SP mod-sequence-valzer
+	//                          ;; extends non-terminal defined in [IMAPABNF].
+	//                          ;; Value 0 denotes that the mailbox doesn't
+	//                          ;; support persistent mod-sequences
+	//
+
+	DECLARE_COMPONENT(status_att_val)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			// "HIGHESTMODSEQ" SP mod-sequence-valzer
+			if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "highestmodseq")) {
+
+				type = HIGHESTMODSEQ;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::mod_sequence_value, value);
+
+			} else {
+
+				if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "messages")) {
+					type = MESSAGES;
+				} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "recent")) {
+					type = RECENT;
+				} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "uidnext")) {
+					type = UIDNEXT;
+				} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "uidvalidity")) {
+					type = UIDVALIDITY;
+				} else {
+					VIMAP_PARSER_CHECK_WITHARG(special_atom, "unseen");
+					type = UNSEEN;
+				}
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::number, value);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Type {
+			// Extensions
+			HIGHESTMODSEQ,
+
+			// Standard IMAP
+			MESSAGES,
+			RECENT,
+			UIDNEXT,
+			UIDVALIDITY,
+			UNSEEN
+		};
+
+
+		Type type;
+		std::unique_ptr <IMAPParser::component> value;
+
+
+		const IMAPParser::number* value_as_number() const {
+			return dynamic_cast <IMAPParser::number *>(value.get());
+		}
+
+		const IMAPParser::mod_sequence_value* value_as_mod_sequence_value() const {
+			return dynamic_cast <IMAPParser::mod_sequence_value *>(value.get());
+		}
+	};
+
+
+	// status-att-list = status-att-val *(SP status-att-val)
+
+	DECLARE_COMPONENT(status_att_list)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET_PUSHBACK(IMAPParser::status_att_val, values);
+
+			while (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+				VIMAP_PARSER_GET_PUSHBACK(IMAPParser::status_att_val, values);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::vector <std::unique_ptr <status_att_val>> values;
+	};
+
+
+	//
+	// capability ::= "AUTH=" auth_type / atom
+	//                ;; New capabilities MUST begin with "X" or be
+	//                ;; registered with IANA as standard or standards-track
+	//
+
+	DECLARE_COMPONENT(capability)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(IMAPParser::atom, atom);
+
+			string value = atom->value;
+			const char* str = value.c_str();
+
+			if ((str[0] == 'a' || str[0] == 'A') &&
+			    (str[1] == 'u' || str[1] == 'U') &&
+			    (str[2] == 't' || str[2] == 'T') &&
+			    (str[3] == 'h' || str[3] == 'H') &&
+			    (str[4] == '=')) {
+
+				size_t pos = 5;
+				auth_type.reset(parser.get <IMAPParser::auth_type>(value, &pos));
+
+				atom.reset();
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::auth_type> auth_type;
+		std::unique_ptr <IMAPParser::atom> atom;
+	};
+
+
+	//
+	// capability_data ::= "CAPABILITY" SPACE [1#capability SPACE] "IMAP4rev1"
+	//                     [SPACE 1#capability]
+	//                     ;; IMAP4rev1 servers which offer RFC 1730
+	//                     ;; compatibility MUST list "IMAP4" as the first
+	//                     ;; capability.
+	//
+
+	DECLARE_COMPONENT(capability_data)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK_WITHARG(special_atom, "capability");
+
+			while (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+
+				std::unique_ptr <capability> cap;
+
+				if (parser.isStrict() || capabilities.empty()) {
+					VIMAP_PARSER_GET(capability, cap);
+				} else {
+					VIMAP_PARSER_TRY_GET(capability, cap);  // allow SPACE at end of line (Apple iCloud IMAP server)
+				}
+
+				if (!cap) {
+					break;
+				}
+
+				capabilities.push_back(std::move(cap));
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::vector <std::unique_ptr <capability>> capabilities;
+	};
+
+
+	//
+	// date_day_fixed  ::= (SPACE digit) / 2digit
+	//                    ;; Fixed-format version of date_day
+	//
+	// date_month      ::= "Jan" / "Feb" / "Mar" / "Apr" / "May" / "Jun" /
+	//                    "Jul" / "Aug" / "Sep" / "Oct" / "Nov" / "Dec"
+	//
+	// date_year       ::= 4digit
+	//
+	// time            ::= 2digit ":" 2digit ":" 2digit
+	//                     ;; Hours minutes seconds
+	//
+	// zone            ::= ("+" / "-") 4digit
+	//                     ;; Signed four-digit value of hhmm representing
+	//                     ;; hours and minutes west of Greenwich (that is,
+	//                     ;; (the amount that the given time differs from
+	//                     ;; Universal Time).  Subtracting the timezone
+	//                     ;; from the given time will give the UT form.
+	//                     ;; The Universal Time zone is "+0000".
+	//
+	// date_time       ::= <"> date_day_fixed "-" date_month "-" date_year
+	//                     SPACE time SPACE zone <">
+	//
+
+	DECLARE_COMPONENT(date_time)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			// <"> date_day_fixed "-" date_month "-" date_year
+			VIMAP_PARSER_CHECK(one_char <'"'> );
+			VIMAP_PARSER_TRY_CHECK(SPACE);
+
+			shared_ptr <number> nd;
+			VIMAP_PARSER_GET(number, nd);
+
+			VIMAP_PARSER_CHECK(one_char <'-'> );
+
+			shared_ptr <atom> amo;
+			VIMAP_PARSER_GET(atom, amo);
+
+			VIMAP_PARSER_CHECK(one_char <'-'> );
+
+			shared_ptr <number> ny;
+			VIMAP_PARSER_GET(number, ny);
+
+			VIMAP_PARSER_TRY_CHECK(SPACE);
+
+			// 2digit ":" 2digit ":" 2digit
+			shared_ptr <number> nh;
+			VIMAP_PARSER_GET(number, nh);
+
+			VIMAP_PARSER_CHECK(one_char <':'> );
+
+			shared_ptr <number> nmi;
+			VIMAP_PARSER_GET(number, nmi);
+
+			VIMAP_PARSER_CHECK(one_char <':'> );
+
+			shared_ptr <number> ns;
+			VIMAP_PARSER_GET(number, ns);
+
+			VIMAP_PARSER_TRY_CHECK(SPACE);
+
+			// ("+" / "-") 4digit
+			int sign = 1;
+
+			if (!(VIMAP_PARSER_TRY_CHECK(one_char <'+'> ))) {
+				VIMAP_PARSER_CHECK(one_char <'-'> );
+			}
+
+			shared_ptr <number> nz;
+			VIMAP_PARSER_GET(number, nz);
+
+			VIMAP_PARSER_CHECK(one_char <'"'> );
+
+
+			m_datetime.setHour(static_cast <int>(std::min(std::max(nh->value, 0ul), 23ul)));
+			m_datetime.setMinute(static_cast <int>(std::min(std::max(nmi->value, 0ul), 59ul)));
+			m_datetime.setSecond(static_cast <int>(std::min(std::max(ns->value, 0ul), 59ul)));
+
+			const int zone = static_cast <int>(nz->value);
+			const int zh = zone / 100;   // hour offset
+			const int zm = zone % 100;   // minute offset
+
+			m_datetime.setZone(((zh * 60) + zm) * sign);
+
+			m_datetime.setDay(static_cast <int>(std::min(std::max(nd->value, 1ul), 31ul)));
+			m_datetime.setYear(static_cast <int>(ny->value));
+
+			const string month(utility::stringUtils::toLower(amo->value));
+			int mon = vmime::datetime::JANUARY;
+
+			if (month.length() >= 3) {
+
+				switch (month[0]) {
+
+					case 'j': {
+
+						switch (month[1]) {
+
+							case 'a': mon = vmime::datetime::JANUARY; break;
+							case 'u': {
+
+								switch (month[2]) {
+
+									case 'n': mon = vmime::datetime::JUNE; break;
+									default:  mon = vmime::datetime::JULY; break;
+								}
+
+								break;
+							}
+
+						}
+
+						break;
+					}
+					case 'f': mon = vmime::datetime::FEBRUARY; break;
+					case 'm': {
+
+						switch (month[2]) {
+							case 'r': mon = vmime::datetime::MARCH; break;
+							default:  mon = vmime::datetime::MAY; break;
+						}
+
+						break;
+					}
+					case 'a':
+					{
+						switch (month[1]) {
+							case 'p': mon = vmime::datetime::APRIL; break;
+							default:  mon = vmime::datetime::AUGUST; break;
+						}
+
+						break;
+					}
+					case 's': mon = vmime::datetime::SEPTEMBER; break;
+					case 'o': mon = vmime::datetime::OCTOBER; break;
+					case 'n': mon = vmime::datetime::NOVEMBER; break;
+					case 'd': mon = vmime::datetime::DECEMBER; break;
+				}
+			}
+
+			m_datetime.setMonth(mon);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+	private:
+
+		vmime::datetime m_datetime;
+	};
+
+
+	//
+	// header_fld_name ::= astring
+	//
+
+	COMPONENT_ALIAS(astring, header_fld_name);
+
+
+	//
+	// header_list     ::= "(" 1#header_fld_name ")"
+	//
+
+	DECLARE_COMPONENT(header_list)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'('> );
+
+			while (!VIMAP_PARSER_TRY_CHECK(one_char <')'> )) {
+				VIMAP_PARSER_GET_PUSHBACK(header_fld_name, fld_names);
+				VIMAP_PARSER_TRY_CHECK(SPACE);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::vector <std::unique_ptr <header_fld_name>> fld_names;
+	};
+
+
+	//
+	// 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.
+	//
+
+	DECLARE_COMPONENT(body_extension)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK(one_char <'('> )) {
+
+				VIMAP_PARSER_GET_PUSHBACK(body_extension, body_extensions);
+
+				while (!VIMAP_PARSER_TRY_CHECK(one_char <')'> )) {
+					VIMAP_PARSER_GET_PUSHBACK(body_extension, body_extensions);
+					VIMAP_PARSER_TRY_CHECK(SPACE);
+				}
+
+			} else {
+
+				if (!VIMAP_PARSER_TRY_GET(IMAPParser::nstring, nstring)) {
+					VIMAP_PARSER_GET(IMAPParser::number, number);
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::nstring> nstring;
+		std::unique_ptr <IMAPParser::number> number;
+
+		std::vector <std::unique_ptr <body_extension>> body_extensions;
+	};
+
+
+	//
+	// section_text    ::= "HEADER" / "HEADER.FIELDS" [".NOT"]
+	//                     SPACE header_list / "TEXT" / "MIME"
+	//
+
+	DECLARE_COMPONENT(section_text)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			// "HEADER.FIELDS" [".NOT"] SPACE header_list
+			const bool b1 = VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "header.fields.not");
+			const bool b2 = (b1 ? false : VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "header.fields"));
+
+			if (b1 || b2) {
+
+				type = b1 ? HEADER_FIELDS_NOT : HEADER_FIELDS;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::header_list, header_list);
+
+			// "HEADER"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "header")) {
+
+				type = HEADER;
+
+			// "MIME"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "mime")) {
+
+				type = MIME;
+
+			// "TEXT"
+			} else {
+
+				type = TEXT;
+
+				VIMAP_PARSER_CHECK_WITHARG(special_atom, "text");
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Type {
+			HEADER,
+			HEADER_FIELDS,
+			HEADER_FIELDS_NOT,
+			MIME,
+			TEXT
+		};
+
+
+		Type type;
+		std::unique_ptr <IMAPParser::header_list> header_list;
+	};
+
+
+	//
+	// section         ::= "[" [section_text / (nz_number *["." nz_number]
+	//                     ["." (section_text / "MIME")])] "]"
+	//
+
+	DECLARE_COMPONENT(section)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'['> );
+
+			if (!VIMAP_PARSER_TRY_CHECK(one_char <']'> )) {
+
+				if (!VIMAP_PARSER_TRY_GET(section_text, section_text1)) {
+
+					std::unique_ptr <nz_number> num;
+					VIMAP_PARSER_GET(nz_number, num);
+					nz_numbers.push_back(static_cast <unsigned int>(num->value));
+
+					while (VIMAP_PARSER_TRY_CHECK(one_char <'.'> )) {
+
+						if (VIMAP_PARSER_TRY_GET(nz_number, num)) {
+							nz_numbers.push_back(static_cast <unsigned int>(num->value));
+						} else {
+							VIMAP_PARSER_GET(section_text, section_text2);
+							break;
+						}
+					}
+				}
+
+				VIMAP_PARSER_CHECK(one_char <']'> );
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <section_text> section_text1;
+		std::unique_ptr <section_text> section_text2;
+		std::vector <unsigned int> nz_numbers;
+	};
+
+
+	//
+	// addr_adl        ::= nstring
+	//                     ;; Holds route from [RFC-822] route-addr if
+	//                     ;; non-NIL
+	//
+	// addr_host       ::= nstring
+	//                     ;; NIL indicates [RFC-822] group syntax.
+	//                     ;; Otherwise, holds [RFC-822] domain name
+	//
+	// addr_mailbox    ::= nstring
+	//                     ;; NIL indicates end of [RFC-822] group; if
+	//                     ;; non-NIL and addr_host is NIL, holds
+	//                     ;; [RFC-822] group name.
+	//                     ;; Otherwise, holds [RFC-822] local-part
+	//
+	// addr_name       ::= nstring
+	//                     ;; Holds phrase from [RFC-822] mailbox if
+	//                     ;; non-NIL
+	//
+	// address         ::= "(" addr_name SPACE addr_adl SPACE addr_mailbox
+	//                     SPACE addr_host ")"
+	//
+
+	DECLARE_COMPONENT(address)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'('> );
+			VIMAP_PARSER_GET(nstring, addr_name);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(nstring, addr_adl);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(nstring, addr_mailbox);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(nstring, addr_host);
+			VIMAP_PARSER_CHECK(one_char <')'> );
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <nstring> addr_name;
+		std::unique_ptr <nstring> addr_adl;
+		std::unique_ptr <nstring> addr_mailbox;
+		std::unique_ptr <nstring> addr_host;
+	};
+
+
+	//
+	// address_list ::= "(" 1*address ")" / nil
+	//
+
+	DECLARE_COMPONENT(address_list)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (!VIMAP_PARSER_TRY_CHECK(NIL)) {
+
+				VIMAP_PARSER_CHECK(one_char <'('> );
+
+				while (!VIMAP_PARSER_TRY_CHECK(one_char <')'> )) {
+					VIMAP_PARSER_GET_PUSHBACK(address, addresses);
+					VIMAP_PARSER_TRY_CHECK(SPACE);
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::vector <std::unique_ptr <address>> addresses;
+	};
+
+
+	//
+	// env_bcc         ::= "(" 1*address ")" / nil
+	//
+
+	COMPONENT_ALIAS(address_list, env_bcc);
+
+
+	//
+	// env_cc          ::= "(" 1*address ")" / nil
+	//
+
+	COMPONENT_ALIAS(address_list, env_cc);
+
+
+	//
+	// env_date        ::= nstring
+	//
+
+	COMPONENT_ALIAS(nstring, env_date);
+
+
+	//
+	// env_from        ::= "(" 1*address ")" / nil
+	//
+
+	COMPONENT_ALIAS(address_list, env_from);
+
+
+	//
+	// env_in_reply_to ::= nstring
+	//
+
+	COMPONENT_ALIAS(nstring, env_in_reply_to);
+
+
+	//
+	// env_message_id  ::= nstring
+	//
+
+	COMPONENT_ALIAS(nstring, env_message_id);
+
+
+	//
+	// env_reply_to    ::= "(" 1*address ")" / nil
+	//
+
+	COMPONENT_ALIAS(address_list, env_reply_to);
+
+
+	//
+	// env_sender      ::= "(" 1*address ")" / nil
+	//
+
+	COMPONENT_ALIAS(address_list, env_sender);
+
+
+	//
+	// env_subject     ::= nstring
+	//
+
+	COMPONENT_ALIAS(nstring, env_subject);
+
+
+	//
+	// env_to          ::= "(" 1*address ")" / nil
+	//
+
+	COMPONENT_ALIAS(address_list, env_to);
+
+
+	//
+	// 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 ")"
+	//
+
+	DECLARE_COMPONENT(envelope)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'('> );
+
+			VIMAP_PARSER_GET(IMAPParser::env_date, env_date);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::env_subject, env_subject);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::env_from, env_from);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::env_sender, env_sender);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::env_reply_to, env_reply_to);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::env_to, env_to);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::env_cc, env_cc);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::env_bcc, env_bcc);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::env_in_reply_to, env_in_reply_to);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::env_message_id, env_message_id);
+
+			VIMAP_PARSER_CHECK(one_char <')'> );
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::env_date> env_date;
+		std::unique_ptr <IMAPParser::env_subject> env_subject;
+		std::unique_ptr <IMAPParser::env_from> env_from;
+		std::unique_ptr <IMAPParser::env_sender> env_sender;
+		std::unique_ptr <IMAPParser::env_reply_to> env_reply_to;
+		std::unique_ptr <IMAPParser::env_to> env_to;
+		std::unique_ptr <IMAPParser::env_cc> env_cc;
+		std::unique_ptr <IMAPParser::env_bcc> env_bcc;
+		std::unique_ptr <IMAPParser::env_in_reply_to> env_in_reply_to;
+		std::unique_ptr <IMAPParser::env_message_id> env_message_id;
+	};
+
+
+	//
+	// body_fld_desc   ::= nstring
+	//
+
+	COMPONENT_ALIAS(nstring, body_fld_desc);
+
+
+	//
+	// body_fld_id     ::= nstring
+	//
+
+	COMPONENT_ALIAS(nstring, body_fld_id);
+
+
+	//
+	// body_fld_md5    ::= nstring
+	//
+
+	COMPONENT_ALIAS(nstring, body_fld_md5);
+
+
+	//
+	// body_fld_octets ::= number
+	//
+
+	COMPONENT_ALIAS(number, body_fld_octets);
+
+
+	//
+	// body_fld_lines  ::= number
+	//
+
+	COMPONENT_ALIAS(number, body_fld_lines);
+
+
+	//
+	// body_fld_enc    ::= (<"> ("7BIT" / "8BIT" / "BINARY" / "BASE64"/
+	//                     "QUOTED-PRINTABLE") <">) / string
+	//
+
+	class body_fld_enc : public nstring {
+
+	public:
+
+		const string getComponentName() const {
+
+			return "body_fld_enc";
+		}
+
+		body_fld_enc() {
+
+		}
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (!xstring::parseImpl(parser, line, &pos)) {
+				return false;
+			}
+
+			// " When an IMAP4 client sends a FETCH (bodystructure) request
+			//   to a server that is running the Exchange Server 2007 IMAP4
+			//   service, a corrupted response is sent as a reply "
+			//   (see http://support.microsoft.com/kb/975918/en-us)
+			//
+			// Fail in strict mode
+			if (isNIL && parser.isStrict()) {
+				VIMAP_PARSER_FAIL();
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+	};
+
+
+	//
+	// body_fld_param_item ::= string SPACE string
+	//
+
+	DECLARE_COMPONENT(body_fld_param_item)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (!parser.isStrict()) {
+
+				// Some servers send an <atom> instead of a <string> here:
+				// eg. ... (CHARSET "X-UNKNOWN") ...
+				if (!VIMAP_PARSER_TRY_GET(xstring, string1)) {
+
+					std::unique_ptr <atom> at;
+					VIMAP_PARSER_GET(atom, at);
+
+					string1.reset(new xstring());
+					string1->value = at->value;
+				}
+
+			} else {
+
+				VIMAP_PARSER_GET(xstring, string1);
+			}
+
+			VIMAP_PARSER_CHECK(SPACE);
+
+			if (!parser.isStrict()) {
+
+				// In non-strict mode, allow NIL in value
+				std::unique_ptr <nstring> nstr;
+				VIMAP_PARSER_GET(nstring, nstr);
+
+				string2.reset(new xstring());
+				string2->value = nstr->value;
+
+			} else {
+
+				VIMAP_PARSER_GET(xstring, string2);
+			}
+
+			DEBUG_FOUND("body_fld_param_item", "<" << string1->value << ", " << string2->value << ">");
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <xstring> string1;
+		std::unique_ptr <xstring> string2;
+	};
+
+
+	//
+	// body_fld_param  ::= "(" 1#(body_fld_param_item) ")" / nil
+	//
+
+	DECLARE_COMPONENT(body_fld_param)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK(one_char <'('> )) {
+
+				bool isNIL = false;
+
+				if (!parser.isStrict()) {
+
+					// In non-strict mode, allow "()" instead of "NIL"
+					if (VIMAP_PARSER_TRY_CHECK(one_char <')'> )) {
+						isNIL = true;
+					}
+				}
+
+				if (!isNIL) {
+
+					VIMAP_PARSER_GET_PUSHBACK(body_fld_param_item, items);
+
+					while (!VIMAP_PARSER_TRY_CHECK(one_char <')'> )) {
+						VIMAP_PARSER_CHECK(SPACE);
+						VIMAP_PARSER_GET_PUSHBACK(body_fld_param_item, items);
+					}
+				}
+
+			} else {
+
+				VIMAP_PARSER_CHECK(NIL);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::vector <std::unique_ptr <body_fld_param_item>> items;
+	};
+
+
+	//
+	// body_fld_dsp    ::= "(" string SPACE body_fld_param ")" / nil
+	//
+
+	DECLARE_COMPONENT(body_fld_dsp)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK(one_char <'('> )) {
+
+				VIMAP_PARSER_GET(xstring, m_string);
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(class body_fld_param, m_body_fld_param);
+				VIMAP_PARSER_CHECK(one_char <')'> );
+
+			} else {
+
+				VIMAP_PARSER_CHECK(NIL);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+	private:
+
+		std::unique_ptr <class xstring> m_string;
+		std::unique_ptr <class body_fld_param> m_body_fld_param;
+
+	public:
+
+		const class xstring* str() const { return m_string.get(); }
+		const class body_fld_param* body_fld_param() const { return m_body_fld_param.get(); }
+	};
+
+
+	//
+	// body_fld_lang   ::= nstring / "(" 1#string ")"
+	//
+
+	DECLARE_COMPONENT(body_fld_lang)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK(one_char <'('> )) {
+
+				VIMAP_PARSER_GET_PUSHBACK(xstring, strings);
+
+				while (!VIMAP_PARSER_TRY_CHECK(one_char <')'> )) {
+					VIMAP_PARSER_CHECK(SPACE);
+					VIMAP_PARSER_GET_PUSHBACK(xstring, strings);
+				}
+
+			} else {
+
+				VIMAP_PARSER_GET_PUSHBACK(nstring, strings);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::vector <std::unique_ptr <xstring>> strings;
+	};
+
+
+	//
+	// body_fields     ::= body_fld_param SPACE body_fld_id SPACE
+	//                     body_fld_desc SPACE body_fld_enc SPACE
+	//                     body_fld_octets
+	//
+
+	DECLARE_COMPONENT(body_fields)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(IMAPParser::body_fld_param, body_fld_param);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::body_fld_id, body_fld_id);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::body_fld_desc, body_fld_desc);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::body_fld_enc, body_fld_enc);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::body_fld_octets, body_fld_octets);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::body_fld_param> body_fld_param;
+		std::unique_ptr <IMAPParser::body_fld_id> body_fld_id;
+		std::unique_ptr <IMAPParser::body_fld_desc> body_fld_desc;
+		std::unique_ptr <IMAPParser::body_fld_enc> body_fld_enc;
+		std::unique_ptr <IMAPParser::body_fld_octets> body_fld_octets;
+	};
+
+
+	//
+	// media_subtype   ::= string
+	//                     ;; Defined in [MIME-IMT]
+	//
+
+	COMPONENT_ALIAS(xstring, media_subtype);
+
+
+	//
+	// media_text      ::= <"> "TEXT" <"> SPACE media_subtype
+	//                     ;; Defined in [MIME-IMT]
+	//
+
+	DECLARE_COMPONENT(media_text)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'"'> );
+			VIMAP_PARSER_CHECK_WITHARG(special_atom, "text");
+			VIMAP_PARSER_CHECK(one_char <'"'> );
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::media_subtype, media_subtype);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::media_subtype> media_subtype;
+	};
+
+
+	//
+	// media_message   ::= <"> "MESSAGE" <"> SPACE <"> "RFC822" <">
+	//                     ;; Defined in [MIME-IMT]
+	//
+
+	DECLARE_COMPONENT(media_message)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'"'> );
+			VIMAP_PARSER_CHECK_WITHARG(special_atom, "message");
+			VIMAP_PARSER_CHECK(one_char <'"'> );
+			VIMAP_PARSER_CHECK(SPACE);
+
+			//VIMAP_PARSER_CHECK(one_char <'"'> );
+			//VIMAP_PARSER_CHECK_WITHARG(special_atom, "rfc822");
+			//VIMAP_PARSER_CHECK(one_char <'"'> );
+
+			VIMAP_PARSER_GET(IMAPParser::media_subtype, media_subtype);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::media_subtype> media_subtype;
+	};
+
+
+	//
+	// media_basic     ::= (<"> ("APPLICATION" / "AUDIO" / "IMAGE" /
+	//                     "MESSAGE" / "VIDEO") <">) / string)
+	//                     SPACE media_subtype
+	//                     ;; Defined in [MIME-IMT]
+
+	DECLARE_COMPONENT(media_basic)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(xstring, media_type);
+
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::media_subtype, media_subtype);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::xstring> media_type;
+		std::unique_ptr <IMAPParser::media_subtype> media_subtype;
+	};
+
+
+	//
+	// 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
+	//
+
+	DECLARE_COMPONENT(body_ext_1part)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos)
+		{
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(IMAPParser::body_fld_md5, body_fld_md5);
+
+			// [SPACE body_fld_dsp
+			if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+
+				VIMAP_PARSER_GET(IMAPParser::body_fld_dsp, body_fld_dsp);
+
+				// [SPACE body_fld_lang
+				if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+
+					VIMAP_PARSER_GET(IMAPParser::body_fld_lang, body_fld_lang);
+
+					// [SPACE 1#body_extension]
+					if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+
+						VIMAP_PARSER_GET_PUSHBACK(body_extension, body_extensions);
+
+						while (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+							VIMAP_PARSER_GET_PUSHBACK(body_extension, body_extensions);
+						}
+					}
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::body_fld_md5> body_fld_md5;
+		std::unique_ptr <IMAPParser::body_fld_dsp> body_fld_dsp;
+		std::unique_ptr <IMAPParser::body_fld_lang> body_fld_lang;
+
+		std::vector <std::unique_ptr <body_extension>> body_extensions;
+	};
+
+
+	//
+	// 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
+
+	DECLARE_COMPONENT(body_ext_mpart)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(IMAPParser::body_fld_param, body_fld_param);
+
+			// [SPACE body_fld_dsp [SPACE body_fld_lang [SPACE 1#body_extension]]]
+			if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+
+				VIMAP_PARSER_GET(IMAPParser::body_fld_dsp, body_fld_dsp);
+
+				if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+
+					VIMAP_PARSER_GET(IMAPParser::body_fld_lang, body_fld_lang);
+
+					// [SPACE 1#body_extension]
+					if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+
+						VIMAP_PARSER_GET_PUSHBACK(body_extension, body_extensions);
+
+						while (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+							VIMAP_PARSER_GET_PUSHBACK(body_extension, body_extensions);
+						}
+					}
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::body_fld_param> body_fld_param;
+		std::unique_ptr <IMAPParser::body_fld_dsp> body_fld_dsp;
+		std::unique_ptr <IMAPParser::body_fld_lang> body_fld_lang;
+
+		std::vector <std::unique_ptr <body_extension>> body_extensions;
+	};
+
+
+	//
+	// body_type_basic ::= media_basic SPACE body_fields
+	//                     ;; MESSAGE subtype MUST NOT be "RFC822"
+	//
+
+	DECLARE_COMPONENT(body_type_basic)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(IMAPParser::media_basic, media_basic);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::body_fields, body_fields);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::media_basic> media_basic;
+		std::unique_ptr <IMAPParser::body_fields> body_fields;
+	};
+
+
+	//
+	// body_type_msg   ::= media_message SPACE body_fields SPACE envelope
+	//                     SPACE body SPACE body_fld_lines
+	//
+
+	class xbody;
+	typedef xbody body;
+
+	DECLARE_COMPONENT(body_type_msg)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(IMAPParser::media_message, media_message);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::body_fields, body_fields);
+			VIMAP_PARSER_CHECK(SPACE);
+
+			// BUGFIX: made SPACE optional. This is not standard, but some servers
+			// seem to return responses like that...
+			VIMAP_PARSER_GET(IMAPParser::envelope, envelope);
+			VIMAP_PARSER_TRY_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::xbody, body);
+			VIMAP_PARSER_TRY_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::body_fld_lines, body_fld_lines);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::media_message> media_message;
+		std::unique_ptr <IMAPParser::body_fields> body_fields;
+		std::unique_ptr <IMAPParser::envelope> envelope;
+		std::unique_ptr <IMAPParser::xbody> body;
+		std::unique_ptr <IMAPParser::body_fld_lines> body_fld_lines;
+	};
+
+
+	//
+	// body_type_text  ::= media_text SPACE body_fields SPACE body_fld_lines
+	//
+
+	DECLARE_COMPONENT(body_type_text)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(IMAPParser::media_text, media_text);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::body_fields, body_fields);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::body_fld_lines, body_fld_lines);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::media_text> media_text;
+		std::unique_ptr <IMAPParser::body_fields> body_fields;
+		std::unique_ptr <IMAPParser::body_fld_lines> body_fld_lines;
+	};
+
+
+	//
+	// body_type_1part ::= (body_type_basic / body_type_msg / body_type_text)
+	//                     [SPACE body_ext_1part]
+	//
+
+	DECLARE_COMPONENT(body_type_1part)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (!VIMAP_PARSER_TRY_GET(IMAPParser::body_type_text, body_type_text)) {
+				if (!VIMAP_PARSER_TRY_GET(IMAPParser::body_type_msg, body_type_msg)) {
+					VIMAP_PARSER_GET(IMAPParser::body_type_basic, body_type_basic);
+				}
+			}
+
+			if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+				if (!VIMAP_PARSER_TRY_GET(IMAPParser::body_ext_1part, body_ext_1part)) {
+					--pos;
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::body_type_basic> body_type_basic;
+		std::unique_ptr <IMAPParser::body_type_msg> body_type_msg;
+		std::unique_ptr <IMAPParser::body_type_text> body_type_text;
+
+		std::unique_ptr <IMAPParser::body_ext_1part> body_ext_1part;
+	};
+
+
+	//
+	// body_type_mpart ::= 1*body SPACE media_subtype
+	//                     [SPACE body_ext_mpart]
+	//
+
+	DECLARE_COMPONENT(body_type_mpart)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET_PUSHBACK(xbody, list);
+
+			while (true) {
+				VIMAP_PARSER_TRY_GET_PUSHBACK_OR_ELSE(xbody, list, break);
+			}
+
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::media_subtype, media_subtype);
+
+			if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+				VIMAP_PARSER_GET(IMAPParser::body_ext_mpart, body_ext_mpart);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::media_subtype> media_subtype;
+		std::unique_ptr <IMAPParser::body_ext_mpart> body_ext_mpart;
+
+		std::vector <std::unique_ptr <xbody>> list;
+	};
+
+
+	//
+	// xbody ::= "(" body_type_1part / body_type_mpart ")"
+	//
+
+	DECLARE_COMPONENT(xbody)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'('> );
+
+			if (!VIMAP_PARSER_TRY_GET(IMAPParser::body_type_mpart, body_type_mpart)) {
+				VIMAP_PARSER_GET(IMAPParser::body_type_1part, body_type_1part);
+			}
+
+			VIMAP_PARSER_CHECK(one_char <')'> );
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::body_type_1part> body_type_1part;
+		std::unique_ptr <IMAPParser::body_type_mpart> body_type_mpart;
+	};
+
+
+	// msg_att_item ::= "ENVELOPE" SPACE envelope /
+	//                  "FLAGS" SPACE "(" #(flag / "\Recent") ")" /
+	//                  "INTERNALDATE" SPACE date_time /
+	//                  "RFC822" [".HEADER" / ".TEXT"] SPACE nstring /
+	//                  "RFC822.SIZE" SPACE number /
+	//                  "BODY" ["STRUCTURE"] SPACE body /
+	//                  "BODY" section ["<" number ">"] SPACE nstring /
+	//                  "UID" SPACE uniqueid
+	//
+	// IMAP Extension for Conditional STORE (RFC-4551):
+	//
+	//   msg_att_item      /= "MODSEQ" SP "(" mod_sequence_value ")"
+
+	DECLARE_COMPONENT(msg_att_item)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			// "ENVELOPE" SPACE envelope
+			if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "envelope")) {
+
+				type = ENVELOPE;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::envelope, envelope);
+
+			// "FLAGS" SPACE "(" #(flag / "\Recent") ")"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "flags")) {
+
+				type = FLAGS;
+
+				VIMAP_PARSER_CHECK(SPACE);
+
+				VIMAP_PARSER_GET(IMAPParser::flag_list, flag_list);
+
+			// "INTERNALDATE" SPACE date_time
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "internaldate")) {
+
+				type = INTERNALDATE;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::date_time, date_time);
+
+			// "RFC822" ".HEADER" SPACE nstring
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "rfc822.header")) {
+
+				type = RFC822_HEADER;
+
+				VIMAP_PARSER_CHECK(SPACE);
+
+				VIMAP_PARSER_GET(IMAPParser::nstring, nstring);
+
+			// "RFC822" ".TEXT" SPACE nstring
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "rfc822.text")) {
+
+				type = RFC822_TEXT;
+
+				VIMAP_PARSER_CHECK(SPACE);
+
+				nstring.reset(parser.getWithArgs <IMAPParser::nstring>(line, &pos, this, RFC822_TEXT));
+
+				VIMAP_PARSER_FAIL_UNLESS(nstring);
+
+			// "RFC822.SIZE" SPACE number
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "rfc822.size")) {
+
+				type = RFC822_SIZE;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::number, number);
+
+			// "RFC822" SPACE nstring
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "rfc822")) {
+
+				type = RFC822;
+
+				VIMAP_PARSER_CHECK(SPACE);
+
+				VIMAP_PARSER_GET(IMAPParser::nstring, nstring);
+
+			// "BODY" "STRUCTURE" SPACE body
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "bodystructure")) {
+
+				type = BODY_STRUCTURE;
+
+				VIMAP_PARSER_CHECK(SPACE);
+
+				VIMAP_PARSER_GET(IMAPParser::body, body);
+
+			// "BODY" section ["<" number ">"] SPACE nstring
+			// "BODY" SPACE body
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "body")) {
+
+				VIMAP_PARSER_TRY_GET(IMAPParser::section, section);
+
+				// "BODY" section ["<" number ">"] SPACE nstring
+				if (section != NULL) {
+
+					type = BODY_SECTION;
+
+					if (VIMAP_PARSER_TRY_CHECK(one_char <'<'> )) {
+						VIMAP_PARSER_GET(IMAPParser::number, number);
+						VIMAP_PARSER_CHECK(one_char <'>'> );
+					}
+
+					VIMAP_PARSER_CHECK(SPACE);
+
+					nstring.reset(parser.getWithArgs <IMAPParser::nstring>(line, &pos, this, BODY_SECTION));
+
+					VIMAP_PARSER_FAIL_UNLESS(nstring);
+
+				// "BODY" SPACE body
+				} else {
+
+					type = BODY;
+
+					VIMAP_PARSER_CHECK(SPACE);
+
+					VIMAP_PARSER_GET(IMAPParser::body, body);
+				}
+
+			// "MODSEQ" SP "(" mod_sequence_value ")"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "modseq")) {
+
+				type = MODSEQ;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_CHECK(one_char <'('> );
+
+				VIMAP_PARSER_GET(IMAPParser::mod_sequence_value, mod_sequence_value);
+
+				VIMAP_PARSER_CHECK(one_char <')'> );
+
+			// "UID" SPACE uniqueid
+			} else {
+
+				type = UID;
+
+				VIMAP_PARSER_CHECK_WITHARG(special_atom, "uid");
+				VIMAP_PARSER_CHECK(SPACE);
+
+				VIMAP_PARSER_GET(IMAPParser::uniqueid, uniqueid);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Type {
+			ENVELOPE,
+			FLAGS,
+			INTERNALDATE,
+			RFC822,
+			RFC822_SIZE,
+			RFC822_HEADER,
+			RFC822_TEXT,
+			BODY,
+			BODY_SECTION,
+			BODY_STRUCTURE,
+			UID,
+			MODSEQ
+		};
+
+
+		Type type;
+
+		std::unique_ptr <IMAPParser::date_time> date_time;
+		std::unique_ptr <IMAPParser::number> number;
+		std::unique_ptr <IMAPParser::envelope> envelope;
+		std::unique_ptr <IMAPParser::uniqueid> uniqueid;
+		std::unique_ptr <IMAPParser::nstring> nstring;
+		std::unique_ptr <IMAPParser::xbody> body;
+		std::unique_ptr <IMAPParser::flag_list> flag_list;
+		std::unique_ptr <IMAPParser::section> section;
+		std::unique_ptr <IMAPParser::mod_sequence_value> mod_sequence_value;
+	};
+
+
+	//
+	// msg_att ::= "(" 1#(msg_att_item) ")"
+	//
+
+	DECLARE_COMPONENT(msg_att)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'('> );
+
+			items.push_back(std::move(std::unique_ptr <msg_att_item>(parser.get <msg_att_item>(line, &pos))));
+
+			while (!VIMAP_PARSER_TRY_CHECK(one_char <')'> )) {
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET_PUSHBACK(msg_att_item, items);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::vector <std::unique_ptr <msg_att_item>> items;
+	};
+
+
+	//
+	// message_data ::= nz_number SPACE ("EXPUNGE" /
+	//                  ("FETCH" SPACE msg_att))
+	//
+
+	DECLARE_COMPONENT(message_data)
+
+		message_data()
+			: number(0) {
+
+		}
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			scoped_ptr <nz_number> num;
+			VIMAP_PARSER_GET(nz_number, num);
+			number = static_cast <unsigned int>(num->value);
+
+			VIMAP_PARSER_CHECK(SPACE);
+
+			if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "expunge")) {
+
+				type = EXPUNGE;
+
+			} else {
+
+				type = FETCH;
+
+				VIMAP_PARSER_CHECK_WITHARG(special_atom, "fetch");
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::msg_att, msg_att);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Type {
+			EXPUNGE,
+			FETCH
+		};
+
+
+		Type type;
+		unsigned int number;
+		std::unique_ptr <IMAPParser::msg_att> msg_att;
+	};
+
+
+	//
+	// resp_text_code ::= "ALERT" / "PARSE" /
+	//                    capability-data /
+	//                    "PERMANENTFLAGS" SPACE "(" #(flag / "\*") ")" /
+	//                    "READ-ONLY" / "READ-WRITE" / "TRYCREATE" /
+	//                    "UIDVALIDITY" SPACE nz_number /
+	//                    "UNSEEN" SPACE nz_number /
+	//                    "UIDNEXT" SPACE nz-number /
+	//                    atom [SPACE 1*<any TEXT_CHAR except "]">]
+	//
+	// IMAP Extension for Conditional STORE (RFC-4551):
+	//
+	//   resp-text-code      =/ "HIGHESTMODSEQ" SP mod-sequence-value /
+	//                          "NOMODSEQ" /
+	//                          "MODIFIED" SP set
+	//
+	// IMAP UIDPLUS Extension (RFC-4315):
+	//
+	//   resp-text-code      =/ "APPENDUID" SP nz-number SP append-uid /
+	//                          "COPYUID" SP nz-number SP uid-set SP uid-set /
+	//                          "UIDNOTSTICKY"
+
+	DECLARE_COMPONENT(resp_text_code)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			// "ALERT"
+			if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "alert")) {
+
+				type = ALERT;
+
+			// "PARSE"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "parse")) {
+
+				type = PARSE;
+
+			// capability_data
+			} else if (VIMAP_PARSER_TRY_GET(IMAPParser::capability_data, capability_data)) {
+
+				type = CAPABILITY;
+
+			// "PERMANENTFLAGS" SPACE flag_list
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "permanentflags")) {
+
+				type = PERMANENTFLAGS;
+
+				VIMAP_PARSER_CHECK(SPACE);
+
+				VIMAP_PARSER_GET(IMAPParser::flag_list, flag_list);
+
+			// "READ-ONLY"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "read-only")) {
+
+				type = READ_ONLY;
+
+			// "READ-WRITE"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "read-write")) {
+
+				type = READ_WRITE;
+
+			// "TRYCREATE"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "trycreate")) {
+
+				type = TRYCREATE;
+
+			// "UIDVALIDITY" SPACE nz_number
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "uidvalidity")) {
+
+				type = UIDVALIDITY;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::nz_number, nz_number);
+
+			// "UIDNEXT" SPACE nz_number
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "uidnext")) {
+
+				type = UIDNEXT;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::nz_number, nz_number);
+
+			// "UNSEEN" SPACE nz_number
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "unseen")) {
+
+				type = UNSEEN;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::nz_number, nz_number);
+
+			// "HIGHESTMODSEQ" SP mod-sequence-value
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "highestmodseq")) {
+
+				type = HIGHESTMODSEQ;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::mod_sequence_value, mod_sequence_value);
+
+			// "NOMODSEQ"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "nomodseq")) {
+
+				type = NOMODSEQ;
+
+			// "MODIFIED" SP sequence-set
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "modified")) {
+
+				type = MODIFIED;
+
+				VIMAP_PARSER_CHECK(SPACE);
+
+				VIMAP_PARSER_GET(IMAPParser::sequence_set, sequence_set);
+
+			// "APPENDUID" SP nz-number SP append-uid
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "appenduid")) {
+
+				type = APPENDUID;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::nz_number, nz_number);
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::uid_set, uid_set);
+
+			// "COPYUID" SP nz-number SP uid-set SP uid-set
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "copyuid")) {
+
+				type = COPYUID;
+
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::nz_number, nz_number);
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::uid_set, uid_set);
+				VIMAP_PARSER_CHECK(SPACE);
+				VIMAP_PARSER_GET(IMAPParser::uid_set, uid_set2);
+
+			// "UIDNOTSTICKY"
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "uidnotsticky")) {
+
+				type = UIDNOTSTICKY;
+
+			// atom [SPACE 1*<any TEXT_CHAR except "]">]
+			} else {
+
+				type = OTHER;
+
+				VIMAP_PARSER_GET(IMAPParser::atom, atom);
+
+				if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+					VIMAP_PARSER_GET(text_except <']'> , text);
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Type {
+			// Extensions
+			HIGHESTMODSEQ,
+			NOMODSEQ,
+			MODIFIED,
+			APPENDUID,
+			COPYUID,
+			UIDNOTSTICKY,
+
+			// Standard IMAP
+			ALERT,
+			PARSE,
+			CAPABILITY,
+			PERMANENTFLAGS,
+			READ_ONLY,
+			READ_WRITE,
+			TRYCREATE,
+			UIDVALIDITY,
+			UIDNEXT,
+			UNSEEN,
+			OTHER
+		};
+
+
+		Type type;
+
+		std::unique_ptr <IMAPParser::nz_number> nz_number;
+		std::unique_ptr <IMAPParser::atom> atom;
+		std::unique_ptr <IMAPParser::flag_list> flag_list;
+		std::unique_ptr <IMAPParser::text> text;
+		std::unique_ptr <IMAPParser::mod_sequence_value> mod_sequence_value;
+		std::unique_ptr <IMAPParser::sequence_set> sequence_set;
+		std::unique_ptr <IMAPParser::capability_data> capability_data;
+		std::unique_ptr <IMAPParser::uid_set> uid_set;
+		std::unique_ptr <IMAPParser::uid_set> uid_set2;
+	};
+
+
+	//
+	// resp_text ::= ["[" resp_text_code "]" SPACE] (text_mime2 / text)
+	//               ;; text SHOULD NOT begin with "[" or "="
+
+	DECLARE_COMPONENT(resp_text)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK(one_char <'['> )) {
+
+				VIMAP_PARSER_GET(IMAPParser::resp_text_code, resp_text_code);
+
+				VIMAP_PARSER_CHECK(one_char <']'> );
+				VIMAP_PARSER_TRY_CHECK(SPACE);
+			}
+
+			std::unique_ptr <text_mime2> text1;
+			VIMAP_PARSER_TRY_GET(text_mime2, text1);
+
+			if (text1.get()) {
+
+				text = text1->value;
+
+			} else {
+
+				std::unique_ptr <IMAPParser::text> text2;
+				VIMAP_PARSER_TRY_GET(IMAPParser::text, text2);
+
+				if (text2.get()) {
+					text = text2->value;
+				} else {
+					// Empty response text
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::resp_text_code> resp_text_code;
+		string text;
+	};
+
+
+	//
+	// continue_req   ::= "+" SPACE (resp_text / base64)
+	//
+
+	DECLARE_COMPONENT(continue_req)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'+'> );
+
+			if (!parser.isStrict()) {
+
+				// Some servers do not send SPACE when response text is empty
+				if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+					VIMAP_PARSER_GET(IMAPParser::resp_text, resp_text);
+				} else {
+					resp_text.reset(new IMAPParser::resp_text());  // empty
+				}
+
+			} else {
+
+				VIMAP_PARSER_CHECK(SPACE);
+
+				VIMAP_PARSER_GET(IMAPParser::resp_text, resp_text);
+			}
+
+			VIMAP_PARSER_CHECK(CRLF);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::resp_text> resp_text;
+	};
+
+
+	//
+	// resp_cond_state ::= ("OK" / "NO" / "BAD") SPACE resp_text
+	//                     ;; Status condition
+	//
+
+	DECLARE_COMPONENT(resp_cond_state)
+
+		resp_cond_state()
+			: status(BAD) {
+
+		}
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "ok")) {
+				status = OK;
+			} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "no")) {
+				status = NO;
+			} else {
+				VIMAP_PARSER_CHECK_WITHARG(special_atom, "bad");
+				status = BAD;
+			}
+
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::resp_text, resp_text);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Status {
+			OK,
+			NO,
+			BAD
+		};
+
+
+		std::unique_ptr <IMAPParser::resp_text> resp_text;
+		Status status;
+	};
+
+
+	//
+	// resp_cond_bye ::= "BYE" SPACE resp_text
+	//
+
+	DECLARE_COMPONENT(resp_cond_bye)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK_WITHARG(special_atom, "bye");
+
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::resp_text, resp_text);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::resp_text> resp_text;
+	};
+
+
+	//
+	// resp_cond_auth  ::= ("OK" / "PREAUTH") SPACE resp_text
+	//                     ;; Authentication condition
+	//
+
+	DECLARE_COMPONENT(resp_cond_auth)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "ok")) {
+				condition = OK;
+			} else {
+				VIMAP_PARSER_CHECK_WITHARG(special_atom, "preauth");
+				condition = PREAUTH;
+			}
+
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::resp_text, resp_text);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Condition {
+			OK,
+			PREAUTH
+		};
+
+
+		Condition condition;
+		std::unique_ptr <IMAPParser::resp_text> resp_text;
+	};
+
+
+	//
+	// mailbox_data ::= "FLAGS" SPACE mailbox_flag_list /
+	//                  "LIST" SPACE mailbox_list /
+	//                  "LSUB" SPACE mailbox_list /
+	//                  "MAILBOX" SPACE text /
+	//                  "SEARCH" [SPACE 1#nz_number] /
+	//                  "STATUS" SPACE mailbox SPACE
+	//                    "(" [status-att-list] ")" /
+	//                  number SPACE "EXISTS" /
+	//                  number SPACE "RECENT"
+	//
+
+	DECLARE_COMPONENT(mailbox_data)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (VIMAP_PARSER_TRY_GET(IMAPParser::number, number)) {
+
+				VIMAP_PARSER_CHECK(SPACE);
+
+				if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "exists")) {
+					type = EXISTS;
+				} else {
+					VIMAP_PARSER_CHECK_WITHARG(special_atom, "recent");
+					type = RECENT;
+				}
+
+			} else {
+
+				// "FLAGS" SPACE mailbox_flag_list
+				if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "flags")) {
+
+					VIMAP_PARSER_CHECK(SPACE);
+
+					VIMAP_PARSER_GET(IMAPParser::mailbox_flag_list, mailbox_flag_list);
+
+					type = FLAGS;
+
+				// "LIST" SPACE mailbox_list
+				} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "list")) {
+
+					VIMAP_PARSER_CHECK(SPACE);
+
+					VIMAP_PARSER_GET(IMAPParser::mailbox_list, mailbox_list);
+
+					type = LIST;
+
+				// "LSUB" SPACE mailbox_list
+				} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "lsub")) {
+
+					VIMAP_PARSER_CHECK(SPACE);
+
+					VIMAP_PARSER_GET(IMAPParser::mailbox_list, mailbox_list);
+
+					type = LSUB;
+
+				// "MAILBOX" SPACE text
+				} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "mailbox")) {
+
+					VIMAP_PARSER_CHECK(SPACE);
+
+					VIMAP_PARSER_GET(IMAPParser::text, text);
+
+					type = MAILBOX;
+
+				// "SEARCH" [SPACE 1#nz_number]
+				} else if (VIMAP_PARSER_TRY_CHECK_WITHARG(special_atom, "search")) {
+
+					if (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+
+						VIMAP_PARSER_GET_PUSHBACK(nz_number, search_nz_number_list);
+
+						while (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+							VIMAP_PARSER_GET_PUSHBACK(nz_number, search_nz_number_list);
+						}
+					}
+
+					type = SEARCH;
+
+				// "STATUS" SPACE mailbox SPACE
+				// "(" [status_att_list] ")"
+				} else {
+
+					VIMAP_PARSER_CHECK_WITHARG(special_atom, "status");
+					VIMAP_PARSER_CHECK(SPACE);
+
+					VIMAP_PARSER_GET(IMAPParser::mailbox, mailbox);
+
+					VIMAP_PARSER_CHECK(SPACE);
+
+					VIMAP_PARSER_CHECK(one_char <'('> );
+					VIMAP_PARSER_TRY_GET(IMAPParser::status_att_list, status_att_list);
+					VIMAP_PARSER_CHECK(one_char <')'> );
+
+					type = STATUS;
+				}
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		enum Type {
+
+			FLAGS,
+			LIST,
+			LSUB,
+			MAILBOX,
+			SEARCH,
+			STATUS,
+			EXISTS,
+			RECENT
+		};
+
+
+		Type type;
+
+		std::unique_ptr <IMAPParser::number> number;
+		std::unique_ptr <IMAPParser::mailbox_flag_list> mailbox_flag_list;
+		std::unique_ptr <IMAPParser::mailbox_list> mailbox_list;
+		std::unique_ptr <IMAPParser::mailbox> mailbox;
+		std::unique_ptr <IMAPParser::text> text;
+		std::vector <std::unique_ptr <nz_number>> search_nz_number_list;
+		std::unique_ptr <IMAPParser::status_att_list> status_att_list;
+	};
+
+
+	//
+	// response_data  ::= "*" SPACE (resp_cond_state / resp_cond_bye /
+	//                    mailbox_data / message_data / capability_data) CRLF
+	//
+
+	DECLARE_COMPONENT(response_data)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'*'> );
+			VIMAP_PARSER_CHECK(SPACE);
+
+			if (!VIMAP_PARSER_TRY_GET(IMAPParser::resp_cond_state, resp_cond_state)) {
+				if (!VIMAP_PARSER_TRY_GET(IMAPParser::resp_cond_bye, resp_cond_bye)) {
+					if (!VIMAP_PARSER_TRY_GET(IMAPParser::mailbox_data, mailbox_data)) {
+						if (!VIMAP_PARSER_TRY_GET(IMAPParser::message_data, message_data)) {
+							VIMAP_PARSER_GET(IMAPParser::capability_data, capability_data);
+						}
+					}
+				}
+			}
+
+			if (!parser.isStrict()) {
+
+				// Allow SPACEs at end of line
+				while (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+					;
+				}
+			}
+
+			VIMAP_PARSER_CHECK(CRLF);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::resp_cond_state> resp_cond_state;
+		std::unique_ptr <IMAPParser::resp_cond_bye> resp_cond_bye;
+		std::unique_ptr <IMAPParser::mailbox_data> mailbox_data;
+		std::unique_ptr <IMAPParser::message_data> message_data;
+		std::unique_ptr <IMAPParser::capability_data> capability_data;
+	};
+
+
+	DECLARE_COMPONENT(continue_req_or_response_data)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (!VIMAP_PARSER_TRY_GET(IMAPParser::continue_req, continue_req)) {
+				VIMAP_PARSER_GET(IMAPParser::response_data, response_data);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::continue_req> continue_req;
+		std::unique_ptr <IMAPParser::response_data> response_data;
+	};
+
+
+	//
+	// response_fatal ::= "*" SPACE resp_cond_bye CRLF
+	//                    ;; Server closes connection immediately
+	//
+
+	DECLARE_COMPONENT(response_fatal)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'*'> );
+			VIMAP_PARSER_CHECK(SPACE);
+
+			VIMAP_PARSER_GET(IMAPParser::resp_cond_bye, resp_cond_bye);
+
+			if (!parser.isStrict()) {
+
+				// Allow SPACEs at end of line
+				while (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+					;
+				}
+			}
+
+			VIMAP_PARSER_CHECK(CRLF);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::resp_cond_bye> resp_cond_bye;
+	};
+
+
+	//
+	// response_tagged ::= tag SPACE resp_cond_state CRLF
+	//
+
+	DECLARE_COMPONENT(response_tagged)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_GET(IMAPParser::xtag, tag);
+			VIMAP_PARSER_CHECK(SPACE);
+			VIMAP_PARSER_GET(IMAPParser::resp_cond_state, resp_cond_state);
+
+			if (!parser.isStrict()) {
+
+				// Allow SPACEs at end of line
+				while (VIMAP_PARSER_TRY_CHECK(SPACE)) {
+					;
+				}
+			}
+
+			VIMAP_PARSER_CHECK(CRLF);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::xtag> tag;
+		std::unique_ptr <IMAPParser::resp_cond_state> resp_cond_state;
+	};
+
+
+	//
+	// response_done ::= response_tagged / response_fatal
+	//
+
+	DECLARE_COMPONENT(response_done)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			if (!VIMAP_PARSER_TRY_GET(IMAPParser::response_tagged, response_tagged)) {
+				VIMAP_PARSER_GET(IMAPParser::response_fatal, response_fatal);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		std::unique_ptr <IMAPParser::response_tagged> response_tagged;
+		std::unique_ptr <IMAPParser::response_fatal> response_fatal;
+	};
+
+
+	//
+	// response ::= *(continue_req / response_data) response_done
+	//
+
+	DECLARE_COMPONENT(response)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+			string curLine = line;
+			bool partial = false;  // partial response
+
+			IMAPParser::continue_req_or_response_data* resp = NULL;
+
+			while ((resp = parser.get <IMAPParser::continue_req_or_response_data>(curLine, &pos))) {
+
+				continue_req_or_response_data.push_back(
+					std::move(
+						std::unique_ptr <IMAPParser::continue_req_or_response_data>(resp)
+					)
+				);
+
+				// Partial response (continue_req)
+				if (resp->continue_req) {
+					partial = true;
+					break;
+				}
+
+				// We have read a CRLF, read another line
+				curLine = parser.readLine();
+				pos = 0;
+			}
+
+			if (!partial) {
+				response_done.reset(parser.get <IMAPParser::response_done>(curLine, &pos));
+				VIMAP_PARSER_FAIL_UNLESS(response_done);
+			}
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+
+		bool isBad() const {
+
+			if (!response_done) {  // incomplete (partial) response
+				return true;
+			}
+
+			if (response_done->response_fatal) {
+				return true;
+			}
+
+			if (response_done->response_tagged->resp_cond_state->status == IMAPParser::resp_cond_state::BAD) {
+
+				return true;
+			}
+
+			return false;
+		}
+
+		void setErrorLog(const string& errorLog) {
+
+			m_errorLog = errorLog;
+		}
+
+		const string& getErrorLog() const {
+
+			return m_errorLog;
+		}
+
+
+		std::vector <std::unique_ptr <IMAPParser::continue_req_or_response_data>> continue_req_or_response_data;
+		std::unique_ptr <IMAPParser::response_done> response_done;
+
+	private:
+
+		string m_errorLog;
+	};
+
+
+	//
+	// greeting ::= "*" SPACE (resp_cond_auth / resp_cond_bye) CRLF
+	//
+
+	DECLARE_COMPONENT(greeting)
+
+		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+
+			size_t pos = *currentPos;
+
+			VIMAP_PARSER_CHECK(one_char <'*'> );
+			VIMAP_PARSER_CHECK(SPACE);
+
+			if (!VIMAP_PARSER_TRY_GET(IMAPParser::resp_cond_auth, resp_cond_auth)) {
+				VIMAP_PARSER_GET(IMAPParser::resp_cond_bye, resp_cond_bye);
+			}
+
+			VIMAP_PARSER_CHECK(CRLF);
+
+			*currentPos = pos;
+
+			return true;
+		}
+
+		void setErrorLog(const string& errorLog) {
+
+			m_errorLog = errorLog;
+		}
+
+		const string& getErrorLog() const {
+
+			return m_errorLog;
+		}
+
+
+		std::unique_ptr <IMAPParser::resp_cond_auth> resp_cond_auth;
+		std::unique_ptr <IMAPParser::resp_cond_bye> resp_cond_bye;
+
+	private:
+
+		string m_errorLog;
+	};
+
+
+
+	//
+	// The main functions used to parse a response
+	//
+
+	response* readResponse(const IMAPTag& tag, literalHandler* lh = NULL) {
+
+		while (true) {
+
+			auto it = m_pendingResponses.find(std::string(tag));
+
+			if (it != m_pendingResponses.end()) {
+				auto* resp = it->second;
+				m_pendingResponses.erase(it);
+				return resp;
+			}
+
+			size_t pos = 0;
+			string line = readLine();
+
+			m_literalHandler = lh;
+			response* resp = get <response>(line, &pos);
+			m_literalHandler = NULL;
+
+			if (!resp) {
+				throw exceptions::invalid_response("", m_errorResponseLine);
+			}
+
+			resp->setErrorLog(lastLine());
+
+			// If there is a continue_req, return the response immediately
+			for (auto &respData : resp->continue_req_or_response_data) {
+				if (respData->continue_req) {
+					return resp;
+				}
+			}
+
+			// Else, return response if the tag is the one we expect
+			if (resp->response_done && resp->response_done->response_tagged &&
+			    resp->response_done->response_tagged->tag) {
+
+				if (tag == resp->response_done->response_tagged->tag->tagString) {
+					return resp;
+				} else {
+					// Not our response tag, cache it for later
+					m_pendingResponses[resp->response_done->response_tagged->tag->tagString] = resp;
+				}
+			} else {
+				// Untagged response
+				return resp;
+			}
+		}
+	}
+
+
+	greeting* readGreeting() {
+
+		size_t pos = 0;
+		string line = readLine();
+
+		greeting* greet = get <greeting>(line, &pos);
+
+		if (!greet) {
+			throw exceptions::invalid_response("", m_errorResponseLine);
+		}
+
+		greet->setErrorLog(lastLine());
+
+		return greet;
+	}
+
+
+	/** Parse a token and advance.
+	  * If the token has been parsed successfully, a raw pointer to it
+	  * will be returned. The caller is responsible to free the memory.
+	  *
+	  * @param TYPE token type (class)
+	  * @param line line which is currently being parsed
+	  * @param currentPos current position in the line (will be updated
+	  * when the function returns)
+	  * @return a raw pointer to the parsed token, or NULL otherwise
+	  */
+	template <class TYPE>
+	TYPE* get(string& line, size_t* currentPos) {
+
+		component* resp = new TYPE;
+		return internalGet <TYPE>(resp, line, currentPos);
+	}
+
+	/** Parse a token which takes 2 arguments and advance.
+	  * If the token has been parsed successfully, a raw pointer to it
+	  * will be returned. The caller is responsible to free the memory.
+	  *
+	  * @param TYPE token type (class)
+	  * @param ARG1_TYPE type of argument #1 (class)
+	  * @param ARG2_TYPE type of argument #2 (class)
+	  * @param line line which is currently being parsed
+	  * @param currentPos current position in the line (will be updated
+	  * when the function returns)
+	  * @param arg1 value of argument 1 to be passed to the token
+	  * @param arg2 value of argument 2 to be passed to the token
+	  * @return a raw pointer to the parsed token, or NULL otherwise
+	  */
+	template <class TYPE, class ARG1_TYPE, class ARG2_TYPE>
+	TYPE* getWithArgs(string& line, size_t* currentPos, ARG1_TYPE arg1, ARG2_TYPE arg2) {
+
+		component* resp = new TYPE(arg1, arg2);
+		return internalGet <TYPE>(resp, line, currentPos);
+	}
+
+private:
+
+	template <class TYPE>
+	TYPE* internalGet(component* resp, string& line, size_t* currentPos) {
+
+		const size_t oldPos = *currentPos;
+
+		if (!resp->parse(*this, line, currentPos)) {
+
+			*currentPos = oldPos;
+
+			delete resp;
+
+			return NULL;
+		}
+
+		return static_cast <TYPE*>(resp);
+	}
+
+	const string lastLine() const {
+
+		// Remove blanks and new lines at the end of the line.
+		string line(m_lastLine);
+
+		string::const_iterator it = line.end();
+		int count = 0;
+
+		while (it != line.begin()) {
+
+			const unsigned char c = *(it - 1);
+
+			if (!(c == ' ' || c == '\t' || c == '\n' || c == '\r')) {
+				break;
+			}
+
+			++count;
+			--it;
+		}
+
+		line.resize(line.length() - count);
+
+		return (line);
+	}
+
+public:
+
+	/** Check for a token and advance.
+	  *
+	  * @param TYPE token type (class)
+	  * @param line line which is currently being parsed
+	  * @param currentPos current position in the line (will be updated
+	  * when the function returns)
+	  * @return true if the token has been parsed, or false otherwise
+	  */
+	template <class TYPE>
+	bool check(string& line, size_t* currentPos) {
+
+		const size_t oldPos = *currentPos;
+
+		TYPE term;
+
+		if (!term.parse(*this, line, currentPos)) {
+			*currentPos = oldPos;
+			return false;
+		} else {
+			return true;
+		}
+	}
+
+	/** Check for a token which takes an argument and advance.
+	  *
+	  * @param TYPE token type (class)
+	  * @param ARG_TYPE argument type (class)
+	  * @param line line which is currently being parsed
+	  * @param currentPos current position in the line (will be updated
+	  * when the function returns)
+	  * @param arg argument to be passed to the token
+	  * @return true if the token has been parsed, or false otherwise
+	  */
+	template <class TYPE, class ARG_TYPE>
+	bool checkWithArg(string& line, size_t* currentPos, const ARG_TYPE arg) {
+
+		const size_t oldPos = *currentPos;
+
+		TYPE term(arg);
+
+		if (!term.parse(*this, line, currentPos)) {
+			*currentPos = oldPos;
+			return false;
+		} else {
+			return true;
+		}
+	}
+
+
+private:
+
+	weak_ptr <socket> m_socket;
+	shared_ptr <tracer> m_tracer;
+
+	utility::progressListener* m_progress;
+
+	bool m_strict;
+
+	literalHandler* m_literalHandler;
+
+	weak_ptr <timeoutHandler> m_timeoutHandler;
+
+
+	string m_buffer;
+
+	string m_lastLine;
+	string m_errorResponseLine;
+
+	std::map <std::string, response*> m_pendingResponses;
+
+public:
+
+	/** Read a line from the input buffer. The function blocks until a
+	  * complete line is read from the buffer. Position in input buffer
+	  * will be updated.
+	  *
+	  * @return next line
+	  */
+	const string readLine() {
+
+		size_t pos;
+
+		while ((pos = m_buffer.find('\n')) == string::npos) {
+			read();
+		}
+
+		string line;
+		line.resize(pos + 1);
+		std::copy(m_buffer.begin(), m_buffer.begin() + pos + 1, line.begin());
+
+		m_buffer.erase(m_buffer.begin(), m_buffer.begin() + pos + 1);
+
+		m_lastLine = line;
+
+#if DEBUG_RESPONSE
+		std::cout << std::endl << "Read line:" << std::endl << line << std::endl;
+#endif
+
+		if (m_tracer) {
+			string::size_type len = line.length();
+			while (len != 0 && (line[len - 1] == '\r' || line[len - 1] == '\n')) --len;
+			m_tracer->traceReceive(line.substr(0, len));
+		}
+
+		return (line);
+	}
+
+	/** Fill in the input buffer with data available from the socket stream.
+	  * The function blocks until some data is available.
+	  */
+	void read() {
+
+		string receiveBuffer;
+
+		shared_ptr <timeoutHandler> toh = m_timeoutHandler.lock();
+		shared_ptr <socket> sok = m_socket.lock();
+
+		if (toh) {
+			toh->resetTimeOut();
+		}
+
+		while (receiveBuffer.empty()) {
+
+			// Check whether the time-out delay is elapsed
+			if (toh && toh->isTimeOut()) {
+				if (!toh->handleTimeOut()) {
+					throw exceptions::operation_timed_out();
+				}
+			}
+
+			// We have received data: reset the time-out counter
+			sok->receive(receiveBuffer);
+
+			if (receiveBuffer.empty()) {   // buffer is empty
+
+				if (sok->getStatus() & socket::STATUS_WANT_WRITE) {
+					sok->waitForWrite();
+				} else {
+					sok->waitForRead();
+				}
+
+				continue;
+			}
+
+			// We have received data ...
+			if (toh) {
+				toh->resetTimeOut();
+			}
+		}
+
+		m_buffer += receiveBuffer;
+	}
+
+
+	void readLiteral(literalHandler::target& buffer, size_t count) {
+
+		size_t len = 0;
+		string receiveBuffer;
+
+		shared_ptr <timeoutHandler> toh = m_timeoutHandler.lock();
+		shared_ptr <socket> sok = m_socket.lock();
+
+		if (m_progress) {
+			m_progress->start(count);
+		}
+
+		if (toh) {
+			toh->resetTimeOut();
+		}
+
+		if (!m_buffer.empty()) {
+
+			if (m_buffer.length() > count) {
+
+				buffer.putData(string(m_buffer.begin(), m_buffer.begin() + count));
+				m_buffer.erase(m_buffer.begin(), m_buffer.begin() + count);
+				len = count;
+
+			} else {
+
+				len += m_buffer.length();
+				buffer.putData(m_buffer);
+				m_buffer.clear();
+			}
+		}
+
+		while (len < count) {
+
+			// Check whether the time-out delay is elapsed
+			if (toh && toh->isTimeOut()) {
+
+				if (!toh->handleTimeOut()) {
+					throw exceptions::operation_timed_out();
+				}
+
+				toh->resetTimeOut();
+			}
+
+			// Receive data from the socket
+			sok->receive(receiveBuffer);
+
+			if (receiveBuffer.empty()) {  // buffer is empty
+
+				if (sok->getStatus() & socket::STATUS_WANT_WRITE) {
+					sok->waitForWrite();
+				} else {
+					sok->waitForRead();
+				}
+
+				continue;
+			}
+
+			// We have received data: reset the time-out counter
+			if (toh) {
+				toh->resetTimeOut();
+			}
+
+			if (len + receiveBuffer.length() > count) {
+
+				const size_t remaining = count - len;
+
+				// Get the needed amount of data
+				buffer.putData(string(receiveBuffer.begin(), receiveBuffer.begin() + remaining));
+
+				// Put the remaining data into the internal response buffer
+				receiveBuffer.erase(receiveBuffer.begin(), receiveBuffer.begin() + remaining);
+				m_buffer += receiveBuffer;
+
+				len = count;
+
+			} else {
+
+				buffer.putData(receiveBuffer);
+				len += receiveBuffer.length();
+			}
+
+			// Notify progress
+			if (m_progress) {
+				m_progress->progress(len, count);
+			}
+		}
+
+		if (m_tracer) {
+			m_tracer->traceReceiveBytes(count);
+		}
+
+		if (m_progress) {
+			m_progress->stop(count);
+		}
+	}
+};
+
+
+} // imap
+} // net
+} // vmime
+
+
+#undef VIMAP_PARSER_FAIL
+#undef VIMAP_PARSER_FAIL_UNLESS
+#undef VIMAP_PARSER_CHECK
+#undef VIMAP_PARSER_TRY_CHECK
+#undef VIMAP_PARSER_GET
+#undef VIMAP_PARSER_GET
+#undef VIMAP_PARSER_TRY_GET
+#undef VIMAP_PARSER_TRY_GET
+#undef VIMAP_PARSER_GET_PUSHBACK
+#undef VIMAP_PARSER_CHECK_WITHARG
+#undef VIMAP_PARSER_TRY_CHECK_WITHARG
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+#endif // VMIME_NET_IMAP_IMAPPARSER_HPP_INCLUDED
diff --git a/vmime-master/src/vmime/net/imap/IMAPSStore.cpp b/vmime-master/src/vmime/net/imap/IMAPSStore.cpp
new file mode 100644
index 0000000..dd9c318
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPSStore.cpp
@@ -0,0 +1,82 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/imap/IMAPSStore.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+IMAPSStore::IMAPSStore(
+	const shared_ptr <session>& sess,
+	const shared_ptr <security::authenticator>& auth
+)
+	: IMAPStore(sess, auth, true) {
+
+}
+
+
+IMAPSStore::~IMAPSStore() {
+
+}
+
+
+const string IMAPSStore::getProtocolName() const {
+
+	return "imaps";
+}
+
+
+
+// Service infos
+
+IMAPServiceInfos IMAPSStore::sm_infos(true);
+
+
+const serviceInfos& IMAPSStore::getInfosInstance() {
+
+	return sm_infos;
+}
+
+
+const serviceInfos& IMAPSStore::getInfos() const {
+
+	return sm_infos;
+}
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
diff --git a/vmime-master/src/vmime/net/imap/IMAPSStore.hpp b/vmime-master/src/vmime/net/imap/IMAPSStore.hpp
new file mode 100644
index 0000000..e18a067
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPSStore.hpp
@@ -0,0 +1,70 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_NET_IMAP_IMAPSSTORE_HPP_INCLUDED
+#define VMIME_NET_IMAP_IMAPSSTORE_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/imap/IMAPStore.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+/** IMAPS store service.
+  */
+class VMIME_EXPORT IMAPSStore : public IMAPStore {
+
+public:
+
+	IMAPSStore(const shared_ptr <session>& sess, const shared_ptr <security::authenticator>& auth);
+	~IMAPSStore();
+
+	const string getProtocolName() const;
+
+	static const serviceInfos& getInfosInstance();
+	const serviceInfos& getInfos() const;
+
+private:
+
+	static IMAPServiceInfos sm_infos;
+};
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+#endif // VMIME_NET_IMAP_IMAPSSTORE_HPP_INCLUDED
+
diff --git a/vmime-master/src/vmime/net/imap/IMAPServiceInfos.cpp b/vmime-master/src/vmime/net/imap/IMAPServiceInfos.cpp
new file mode 100644
index 0000000..baed6ba
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPServiceInfos.cpp
@@ -0,0 +1,135 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/imap/IMAPServiceInfos.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+IMAPServiceInfos::IMAPServiceInfos(const bool imaps)
+	: m_imaps(imaps) {
+
+}
+
+
+const string IMAPServiceInfos::getPropertyPrefix() const {
+
+	if (m_imaps) {
+		return "store.imaps.";
+	} else {
+		return "store.imap.";
+	}
+}
+
+
+const IMAPServiceInfos::props& IMAPServiceInfos::getProperties() const {
+
+	static props imapProps = {
+		// IMAP-specific options
+#if VMIME_HAVE_SASL_SUPPORT
+		property("options.sasl", serviceInfos::property::TYPE_BOOLEAN, "true"),
+		property("options.sasl.fallback", serviceInfos::property::TYPE_BOOLEAN, "true"),
+#endif // VMIME_HAVE_SASL_SUPPORT
+
+		// Common properties
+		property(serviceInfos::property::AUTH_USERNAME, serviceInfos::property::FLAG_REQUIRED),
+		property(serviceInfos::property::AUTH_PASSWORD, serviceInfos::property::FLAG_REQUIRED),
+
+#if VMIME_HAVE_TLS_SUPPORT
+		property(serviceInfos::property::CONNECTION_TLS),
+		property(serviceInfos::property::CONNECTION_TLS_REQUIRED),
+#endif // VMIME_HAVE_TLS_SUPPORT
+
+		property(serviceInfos::property::SERVER_ADDRESS, serviceInfos::property::FLAG_REQUIRED),
+		property(serviceInfos::property::SERVER_PORT, "143"),
+	};
+
+	static props imapsProps = {
+		// IMAP-specific options
+#if VMIME_HAVE_SASL_SUPPORT
+		property("options.sasl", serviceInfos::property::TYPE_BOOLEAN, "true"),
+		property("options.sasl.fallback", serviceInfos::property::TYPE_BOOLEAN, "true"),
+#endif // VMIME_HAVE_SASL_SUPPORT
+
+		// Common properties
+		property(serviceInfos::property::AUTH_USERNAME, serviceInfos::property::FLAG_REQUIRED),
+		property(serviceInfos::property::AUTH_PASSWORD, serviceInfos::property::FLAG_REQUIRED),
+
+#if VMIME_HAVE_TLS_SUPPORT
+		property(serviceInfos::property::CONNECTION_TLS),
+		property(serviceInfos::property::CONNECTION_TLS_REQUIRED),
+#endif // VMIME_HAVE_TLS_SUPPORT
+
+		property(serviceInfos::property::SERVER_ADDRESS, serviceInfos::property::FLAG_REQUIRED),
+		property(serviceInfos::property::SERVER_PORT, "993"),
+	};
+
+	return m_imaps ? imapsProps : imapProps;
+}
+
+
+const std::vector <serviceInfos::property> IMAPServiceInfos::getAvailableProperties() const {
+
+	std::vector <property> list;
+	const props& p = getProperties();
+
+	// IMAP-specific options
+#if VMIME_HAVE_SASL_SUPPORT
+	list.push_back(p.PROPERTY_OPTIONS_SASL);
+	list.push_back(p.PROPERTY_OPTIONS_SASL_FALLBACK);
+#endif // VMIME_HAVE_SASL_SUPPORT
+
+	// Common properties
+	list.push_back(p.PROPERTY_AUTH_USERNAME);
+	list.push_back(p.PROPERTY_AUTH_PASSWORD);
+
+#if VMIME_HAVE_TLS_SUPPORT
+	if (!m_imaps) {
+		list.push_back(p.PROPERTY_CONNECTION_TLS);
+		list.push_back(p.PROPERTY_CONNECTION_TLS_REQUIRED);
+	}
+#endif // VMIME_HAVE_TLS_SUPPORT
+
+	list.push_back(p.PROPERTY_SERVER_ADDRESS);
+	list.push_back(p.PROPERTY_SERVER_PORT);
+
+	return list;
+}
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
diff --git a/vmime-master/src/vmime/net/imap/IMAPServiceInfos.hpp b/vmime-master/src/vmime/net/imap/IMAPServiceInfos.hpp
new file mode 100644
index 0000000..73fca7a
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPServiceInfos.hpp
@@ -0,0 +1,89 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_NET_IMAP_IMAPSERVICEINFOS_HPP_INCLUDED
+#define VMIME_NET_IMAP_IMAPSERVICEINFOS_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/serviceInfos.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+/** Information about IMAP service.
+  */
+class VMIME_EXPORT IMAPServiceInfos : public serviceInfos {
+
+public:
+
+	IMAPServiceInfos(const bool imaps);
+
+	struct props {
+		// IMAP-specific options
+#if VMIME_HAVE_SASL_SUPPORT
+		serviceInfos::property PROPERTY_OPTIONS_SASL;
+		serviceInfos::property PROPERTY_OPTIONS_SASL_FALLBACK;
+#endif // VMIME_HAVE_SASL_SUPPORT
+
+		// Common properties
+		serviceInfos::property PROPERTY_AUTH_USERNAME;
+		serviceInfos::property PROPERTY_AUTH_PASSWORD;
+
+#if VMIME_HAVE_TLS_SUPPORT
+		serviceInfos::property PROPERTY_CONNECTION_TLS;
+		serviceInfos::property PROPERTY_CONNECTION_TLS_REQUIRED;
+#endif // VMIME_HAVE_TLS_SUPPORT
+
+		serviceInfos::property PROPERTY_SERVER_ADDRESS;
+		serviceInfos::property PROPERTY_SERVER_PORT;
+	};
+
+	const props& getProperties() const;
+
+	const string getPropertyPrefix() const;
+	const std::vector <serviceInfos::property> getAvailableProperties() const;
+
+private:
+
+	const bool m_imaps;
+};
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+#endif // VMIME_NET_IMAP_IMAPSERVICEINFOS_HPP_INCLUDED
+
diff --git a/vmime-master/src/vmime/net/imap/IMAPStore.cpp b/vmime-master/src/vmime/net/imap/IMAPStore.cpp
new file mode 100644
index 0000000..eafa444
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPStore.cpp
@@ -0,0 +1,287 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/imap/IMAPStore.hpp"
+#include "vmime/net/imap/IMAPFolder.hpp"
+#include "vmime/net/imap/IMAPConnection.hpp"
+#include "vmime/net/imap/IMAPFolderStatus.hpp"
+#include "vmime/net/imap/IMAPCommand.hpp"
+
+#include "vmime/exception.hpp"
+#include "vmime/platform.hpp"
+
+#include <map>
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+IMAPStore::IMAPStore(
+	const shared_ptr <session>& sess,
+	const shared_ptr <security::authenticator>& auth,
+	const bool secured
+)
+	: store(sess, getInfosInstance(), auth),
+	  m_connection(null),
+	  m_isIMAPS(secured) {
+
+}
+
+
+IMAPStore::~IMAPStore() {
+
+	try {
+
+		if (isConnected()) {
+			disconnect();
+		}
+
+	} catch (...) {
+
+		// Don't throw in destructor
+	}
+}
+
+
+const string IMAPStore::getProtocolName() const {
+
+	return "imap";
+}
+
+
+shared_ptr <folder> IMAPStore::getRootFolder() {
+
+	if (!isConnected()) {
+		throw exceptions::illegal_state("Not connected");
+	}
+
+	return make_shared <IMAPFolder>(
+		folder::path(),
+		dynamicCast <IMAPStore>(shared_from_this()),
+		shared_ptr <folderAttributes>()
+	);
+}
+
+
+shared_ptr <folder> IMAPStore::getDefaultFolder() {
+
+	if (!isConnected()) {
+		throw exceptions::illegal_state("Not connected");
+	}
+
+	return make_shared <IMAPFolder>(
+		folder::path::component("INBOX"),
+		dynamicCast <IMAPStore>(shared_from_this()),
+		shared_ptr <folderAttributes>()
+	);
+}
+
+
+shared_ptr <folder> IMAPStore::getFolder(const folder::path& path) {
+
+	if (!isConnected()) {
+		throw exceptions::illegal_state("Not connected");
+	}
+
+	return make_shared <IMAPFolder>(
+		path,
+		dynamicCast <IMAPStore>(shared_from_this()),
+		shared_ptr <folderAttributes>()
+	);
+}
+
+
+bool IMAPStore::isValidFolderName(const folder::path::component& /* name */) const {
+
+	return true;
+}
+
+
+void IMAPStore::connect() {
+
+	if (isConnected()) {
+		throw exceptions::already_connected();
+	}
+
+	m_connection = make_shared <IMAPConnection>(
+		dynamicCast <IMAPStore>(shared_from_this()), getAuthenticator()
+	);
+
+	m_connection->connect();
+}
+
+
+bool IMAPStore::isConnected() const {
+
+	return m_connection && m_connection->isConnected();
+}
+
+
+bool IMAPStore::isIMAPS() const {
+
+	return m_isIMAPS;
+}
+
+
+bool IMAPStore::isSecuredConnection() const {
+
+	if (!m_connection) {
+		return false;
+	}
+
+	return m_connection->isSecuredConnection();
+}
+
+
+shared_ptr <connectionInfos> IMAPStore::getConnectionInfos() const {
+
+	if (!m_connection) {
+		return null;
+	}
+
+	return m_connection->getConnectionInfos();
+}
+
+
+shared_ptr <IMAPConnection> IMAPStore::getConnection() {
+
+	return m_connection;
+}
+
+
+void IMAPStore::disconnect() {
+
+	if (!isConnected()) {
+		throw exceptions::not_connected();
+	}
+
+	for (std::list <IMAPFolder*>::iterator it = m_folders.begin() ;
+	     it != m_folders.end() ; ++it) {
+
+		(*it)->onStoreDisconnected();
+	}
+
+	m_folders.clear();
+
+
+	m_connection->disconnect();
+
+	m_connection = null;
+}
+
+
+void IMAPStore::noop() {
+
+	if (!isConnected()) {
+		throw exceptions::not_connected();
+	}
+
+	IMAPCommand::NOOP()->send(m_connection);
+
+	scoped_ptr <IMAPParser::response> resp(m_connection->readResponse());
+
+	if (resp->isBad() || resp->response_done->response_tagged->
+			resp_cond_state->status != IMAPParser::resp_cond_state::OK) {
+
+		throw exceptions::command_error("NOOP", resp->getErrorLog());
+	}
+
+
+	for (std::list <IMAPFolder*>::iterator it = m_folders.begin() ;
+	     it != m_folders.end() ; ++it) {
+
+		if ((*it)->isOpen()) {
+			(*it)->noop();
+		}
+	}
+}
+
+
+shared_ptr <IMAPConnection> IMAPStore::connection() {
+
+	return m_connection;
+}
+
+
+void IMAPStore::registerFolder(IMAPFolder* folder) {
+
+	m_folders.push_back(folder);
+}
+
+
+void IMAPStore::unregisterFolder(IMAPFolder* folder) {
+
+	std::list <IMAPFolder*>::iterator it = std::find(m_folders.begin(), m_folders.end(), folder);
+
+	if (it != m_folders.end()) {
+		m_folders.erase(it);
+	}
+}
+
+
+int IMAPStore::getCapabilities() const {
+
+	return CAPABILITY_CREATE_FOLDER |
+	       CAPABILITY_RENAME_FOLDER |
+	       CAPABILITY_ADD_MESSAGE |
+	       CAPABILITY_COPY_MESSAGE |
+	       CAPABILITY_DELETE_MESSAGE |
+	       CAPABILITY_PARTIAL_FETCH |
+	       CAPABILITY_MESSAGE_FLAGS |
+	       CAPABILITY_EXTRACT_PART;
+}
+
+
+
+// Service infos
+
+IMAPServiceInfos IMAPStore::sm_infos(false);
+
+
+const serviceInfos& IMAPStore::getInfosInstance() {
+
+	return sm_infos;
+}
+
+
+const serviceInfos& IMAPStore::getInfos() const {
+
+	return sm_infos;
+}
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
diff --git a/vmime-master/src/vmime/net/imap/IMAPStore.hpp b/vmime-master/src/vmime/net/imap/IMAPStore.hpp
new file mode 100644
index 0000000..018c195
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPStore.hpp
@@ -0,0 +1,124 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_NET_IMAP_IMAPSTORE_HPP_INCLUDED
+#define VMIME_NET_IMAP_IMAPSTORE_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/store.hpp"
+#include "vmime/net/socket.hpp"
+#include "vmime/net/folder.hpp"
+
+#include "vmime/net/imap/IMAPServiceInfos.hpp"
+#include "vmime/net/imap/IMAPConnection.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+class IMAPParser;
+class IMAPTag;
+class IMAPFolder;
+
+
+/** IMAP store service.
+  */
+class VMIME_EXPORT IMAPStore : public store {
+
+	friend class IMAPFolder;
+	friend class IMAPMessage;
+	friend class IMAPConnection;
+
+public:
+
+	IMAPStore(
+		const shared_ptr <session>& sess,
+		const shared_ptr <security::authenticator>& auth,
+		const bool secured = false
+	);
+
+	~IMAPStore();
+
+	const string getProtocolName() const;
+
+	shared_ptr <folder> getDefaultFolder();
+	shared_ptr <folder> getRootFolder();
+	shared_ptr <folder> getFolder(const folder::path& path);
+
+	bool isValidFolderName(const folder::path::component& name) const;
+
+	static const serviceInfos& getInfosInstance();
+	const serviceInfos& getInfos() const;
+
+	void connect();
+	bool isConnected() const;
+	void disconnect();
+
+	void noop();
+
+	int getCapabilities() const;
+
+	bool isIMAPS() const;
+
+	bool isSecuredConnection() const;
+	shared_ptr <connectionInfos> getConnectionInfos() const;
+	shared_ptr <IMAPConnection> getConnection();
+
+protected:
+
+	// Connection
+	shared_ptr <IMAPConnection> m_connection;
+
+
+
+	shared_ptr <IMAPConnection> connection();
+
+
+	void registerFolder(IMAPFolder* folder);
+	void unregisterFolder(IMAPFolder* folder);
+
+	std::list <IMAPFolder*> m_folders;
+
+	const bool m_isIMAPS;  // Use IMAPS
+
+
+	static IMAPServiceInfos sm_infos;
+};
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+#endif // VMIME_NET_IMAP_IMAPSTORE_HPP_INCLUDED
diff --git a/vmime-master/src/vmime/net/imap/IMAPTag.cpp b/vmime-master/src/vmime/net/imap/IMAPTag.cpp
new file mode 100644
index 0000000..52cd212
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPTag.cpp
@@ -0,0 +1,148 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/imap/IMAPTag.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+const int IMAPTag::sm_maxNumber = 52 * 10 * 10 * 10;
+
+
+IMAPTag::IMAPTag(const int number)
+	: m_number(number) {
+
+	m_tag.resize(4);
+	generate();
+}
+
+
+IMAPTag::IMAPTag(const IMAPTag& tag)
+	: object(),
+	  m_number(tag.m_number) {
+
+	m_tag.resize(4);
+	generate();
+}
+
+
+IMAPTag::IMAPTag()
+	: m_number(1) {
+
+	m_tag.resize(4);
+	generate();
+}
+
+
+IMAPTag& IMAPTag::operator++() {
+
+	++m_number;
+
+	if (m_number >= sm_maxNumber) {
+		m_number = 1;
+	}
+
+	generate();
+
+	return *this;
+}
+
+
+const IMAPTag IMAPTag::operator++(int) {
+
+	IMAPTag old(*this);
+	operator++();
+	return old;
+}
+
+
+bool IMAPTag::operator<(const IMAPTag &other) const {
+
+	return m_number < other.m_number;
+}
+
+
+bool IMAPTag::operator==(const IMAPTag &other) const {
+
+	return m_number == other.m_number;
+}
+
+
+bool IMAPTag::operator!=(const IMAPTag &other) const {
+
+	return m_number != other.m_number;
+}
+
+
+bool IMAPTag::operator==(const std::string &tag) const {
+
+	return m_tag == tag;
+}
+
+
+int IMAPTag::maximumNumber() const {
+
+	return sm_maxNumber - 1;
+}
+
+
+int IMAPTag::number() const {
+
+	return m_number;
+}
+
+
+IMAPTag::operator string() const
+{
+	return m_tag;
+}
+
+
+void IMAPTag::generate() {
+
+	static const char prefixChars[53] =
+		"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+	m_tag[0] = prefixChars[m_number / 1000];
+	m_tag[1] = static_cast <char>('0' + (m_number % 1000) / 100);
+	m_tag[2] = static_cast <char>('0' + (m_number % 100) / 10);
+	m_tag[3] = static_cast <char>('0' + m_number % 10);
+}
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
diff --git a/vmime-master/src/vmime/net/imap/IMAPTag.hpp b/vmime-master/src/vmime/net/imap/IMAPTag.hpp
new file mode 100644
index 0000000..cbab942
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPTag.hpp
@@ -0,0 +1,85 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_NET_IMAP_IMAPTAG_HPP_INCLUDED
+#define VMIME_NET_IMAP_IMAPTAG_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/types.hpp"
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+class VMIME_EXPORT IMAPTag : public object {
+
+private:
+
+	IMAPTag(const int number);
+
+public:
+
+	IMAPTag();
+	IMAPTag(const IMAPTag& tag);
+
+	IMAPTag& operator++();           // ++IMAPTag
+	const IMAPTag operator++(int);   // IMAPTag++
+
+	int maximumNumber() const;
+	int number() const;
+
+	operator string() const;
+
+	bool operator<(const IMAPTag &other) const;
+	bool operator==(const IMAPTag &other) const;
+	bool operator!=(const IMAPTag &other) const;
+
+	bool operator==(const std::string &tag) const;
+
+private:
+
+	void generate();
+
+	static const int sm_maxNumber;
+
+	int m_number;
+	string m_tag;
+};
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+#endif // VMIME_NET_IMAP_IMAPTAG_HPP_INCLUDED
diff --git a/vmime-master/src/vmime/net/imap/IMAPUtils.cpp b/vmime-master/src/vmime/net/imap/IMAPUtils.cpp
new file mode 100644
index 0000000..59b1e18
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPUtils.cpp
@@ -0,0 +1,854 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/net/imap/IMAPUtils.hpp"
+#include "vmime/net/imap/IMAPStore.hpp"
+
+#include "vmime/net/message.hpp"
+#include "vmime/net/folder.hpp"
+
+#include <sstream>
+#include <iterator>
+#include <algorithm>
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+// static
+const string IMAPUtils::quoteString(const string& text) {
+
+	//
+	// ATOM_CHAR       ::= <any CHAR except atom_specials>
+	//
+	// atom_specials   ::= "(" / ")" / "{" / SPACE / CTL /
+	//                     list_wildcards / quoted_specials
+	//
+	// list_wildcards  ::= "%" / "*"
+	//
+	// quoted_specials ::= <"> / "\"
+	//
+	// CHAR            ::= <any 7-bit US-ASCII character except NUL,
+	//                      0x01 - 0x7f>
+	//
+	// CTL             ::= <any ASCII control character and DEL,
+	//                      0x00 - 0x1f, 0x7f>
+	//
+
+	bool needQuoting = text.empty();
+
+	for (string::const_iterator it = text.begin() ;
+	     !needQuoting && it != text.end() ; ++it) {
+
+		const unsigned char c = *it;
+
+		switch (c) {
+
+			case '(':
+			case ')':
+			case '{':
+			case 0x20:   // SPACE
+			case '%':
+			case '*':
+			case '"':
+			case '\\':
+
+				needQuoting = true;
+				break;
+
+			default:
+
+				if (c <= 0x1f || c >= 0x7f) {
+					needQuoting = true;
+				}
+			}
+	}
+
+	if (needQuoting) {
+
+		string quoted;
+		quoted.reserve((text.length() * 3) / 2 + 2);
+
+		quoted += '"';
+
+		for (string::const_iterator it = text.begin() ; it != text.end() ; ++it) {
+
+			const unsigned char c = *it;
+
+			if (c == '\\' || c == '"') {
+				quoted += '\\';
+			}
+
+			quoted += c;
+		}
+
+		quoted += '"';
+
+		return quoted;
+
+	} else {
+
+		return text;
+	}
+}
+
+
+const string IMAPUtils::pathToString(
+	const char hierarchySeparator,
+	const folder::path& path
+) {
+
+	string result;
+
+	for (size_t i = 0 ; i < path.getSize() ; ++i) {
+
+		if (i > 0) result += hierarchySeparator;
+		result += toModifiedUTF7(hierarchySeparator, path[i]);
+	}
+
+	return (result);
+}
+
+
+const folder::path IMAPUtils::stringToPath(
+	const char hierarchySeparator,
+	const string& str
+) {
+
+	folder::path result;
+	string::const_iterator begin = str.begin();
+
+	for (string::const_iterator it = str.begin() ; it != str.end() ; ++it) {
+
+		if (*it == hierarchySeparator) {
+			result /= fromModifiedUTF7(string(begin, it));
+			begin = it + 1;
+		}
+	}
+
+	if (begin != str.end()) {
+		result /= fromModifiedUTF7(string(begin, str.end()));
+	}
+
+	return result;
+}
+
+
+const string IMAPUtils::toModifiedUTF7(
+	const char hierarchySeparator,
+	const folder::path::component& text
+) {
+
+	// We will replace the hierarchy separator with an equivalent
+	// UTF-7 sequence, so we compute it here...
+	const char base64alphabet[] =
+		"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,=";
+
+	const unsigned int hs = static_cast <unsigned int>(static_cast <unsigned char>(hierarchySeparator));
+
+	string hsUTF7;
+	hsUTF7.resize(3);
+
+	hsUTF7[0] = base64alphabet[0];
+	hsUTF7[1] = base64alphabet[(hs & 0xF0) >> 4];
+	hsUTF7[2] = base64alphabet[(hs & 0x0F) << 2];
+
+	// iconv() is buggy with UTF-8 to UTF-7 conversion, so we do it "by hand".
+	// This code is largely inspired from "imap/utf7.c", in mutt 1.4.
+	// Copyright (C) 2000 Edmund Grimley Evans <edmundo@rano.org>
+
+	// WARNING: This may throw "exceptions::charset_conv_error"
+	const string cvt = text.getConvertedText(charset(charsets::UTF_8));
+
+	// In the worst case we convert 2 chars to 7 chars.
+	// For example: "\x10&\x10&..." -> "&ABA-&-&ABA-&-...".
+	string out;
+	out.reserve((cvt.length() / 2) * 7 + 6);
+
+	int b = 0, k = 0;
+	bool base64 = false;
+
+	size_t remaining = cvt.length();
+
+	for (size_t i = 0, len = cvt.length() ; i < len ; ) {
+
+		const unsigned char c = cvt[i];
+
+		// Replace hierarchy separator with an equivalent UTF-7 Base64 sequence
+		if (!base64 && c == hierarchySeparator) {
+
+			out += "&" + hsUTF7 + "-";
+
+			++i;
+			--remaining;
+			continue;
+		}
+
+		size_t n = 0;
+		int ch = 0;
+
+		if (c < 0x80) {
+			ch = c, n = 0;
+		} else if (c < 0xc2) {
+			return "";
+		} else if (c < 0xe0) {
+			ch = c & 0x1f, n = 1;
+		} else if (c < 0xf0) {
+			ch = c & 0x0f, n = 2;
+		} else if (c < 0xf8) {
+			ch = c & 0x07, n = 3;
+		} else if (c < 0xfc) {
+			ch = c & 0x03, n = 4;
+		} else if (c < 0xfe) {
+			ch = c & 0x01, n = 5;
+		} else {
+			return "";
+		}
+
+		if (n > remaining) {
+			return "";  // error
+		}
+
+		++i;
+		--remaining;
+
+		for (size_t j = 0 ; j < n ; j++) {
+
+			if ((cvt[i + j] & 0xc0) != 0x80) {
+				return "";  // error
+			}
+
+			ch = (ch << 6) | (cvt[i + j] & 0x3f);
+		}
+
+		if (n > 1 && !(ch >> (n * 5 + 1))) {
+			return "";  // error
+		}
+
+		i += n;
+		remaining -= n;
+
+		if (ch < 0x20 || ch >= 0x7f) {
+
+			if (!base64) {
+				out += '&';
+				base64 = true;
+				b = 0;
+				k = 10;
+			}
+
+			if (ch & ~0xffff) {
+				ch = 0xfffe;
+			}
+
+			out += base64alphabet[b | ch >> k];
+
+			k -= 6;
+
+			for ( ; k >= 0 ; k -= 6) {
+				out += base64alphabet[(ch >> k) & 0x3f];
+			}
+
+			b = (ch << (-k)) & 0x3f;
+			k += 16;
+
+		} else {
+
+			if (base64) {
+
+				if (k > 10) {
+					out += base64alphabet[b];
+				}
+
+				out += '-';
+				base64 = false;
+			}
+
+			out += static_cast <char>(ch);
+
+			if (ch == '&') {
+				out += '-';
+			}
+		}
+	}
+
+	if (base64) {
+
+		if (k > 10) {
+			out += base64alphabet[b];
+		}
+
+		out += '-';
+	}
+
+	return (out);
+}
+
+
+const folder::path::component IMAPUtils::fromModifiedUTF7(const string& text) {
+
+	// Transcode from modified UTF-7 (RFC-2060).
+	string out;
+	out.reserve(text.length());
+
+	bool inB64sequence = false;
+	bool plusOutput = false;
+	unsigned char prev = 0;
+
+	for (string::const_iterator it = text.begin() ; it != text.end() ; ++it) {
+
+		const unsigned char c = *it;
+
+		switch (c) {
+
+			// Start of Base64 sequence
+			case '&': {
+
+				if (!inB64sequence) {
+					inB64sequence = true;
+					plusOutput = false;
+				} else {
+					out += '&';
+				}
+
+				break;
+			}
+			// End of Base64 sequence (or "&-" --> "&")
+			case '-': {
+
+				if (inB64sequence && prev == '&') {  // special case "&-" --> "&"
+					out += '&';
+				} else {
+					out += '-';
+				}
+
+				inB64sequence = false;
+				break;
+			}
+			// ',' is used instead of '/' in modified Base64
+			case ',': {
+
+				if (inB64sequence && !plusOutput) {
+					out += '+';
+					plusOutput = true;
+				}
+
+				out += (inB64sequence ? '/' : ',');
+				break;
+			}
+			default: {
+
+				if (inB64sequence && !plusOutput) {
+					out += '+';
+					plusOutput = true;
+				}
+
+				out += c;
+				break;
+			}
+		}
+
+		prev = c;
+	}
+
+	// Store it as UTF-8 by default
+	string cvt;
+	charset::convert(out, cvt, charset(charsets::UTF_7), charset(charsets::UTF_8));
+
+	return folder::path::component(cvt, charset(charsets::UTF_8));
+}
+
+
+// static
+void IMAPUtils::mailboxFlagsToFolderAttributes(
+	const shared_ptr <const IMAPConnection>& cnt,
+	const folder::path &path,
+	const IMAPParser::mailbox_flag_list& list,
+	folderAttributes& attribs
+) {
+
+	int specialUse = folderAttributes::SPECIALUSE_NONE;
+	int type = folderAttributes::TYPE_CONTAINS_MESSAGES | folderAttributes::TYPE_CONTAINS_FOLDERS;
+	int flags = 0;
+
+	// If CHILDREN extension (RFC-3348) is not supported, assume folder has children
+	// as we have no hint about it
+	if (!cnt->hasCapability("CHILDREN")) {
+		flags |= folderAttributes::FLAG_HAS_CHILDREN;
+	}
+
+	for (auto it = list.flags.begin() ; it != list.flags.end() ; ++it) {
+
+		switch ((*it)->type) {
+
+			case IMAPParser::mailbox_flag::NOSELECT:
+
+				type &= ~folderAttributes::TYPE_CONTAINS_MESSAGES;
+				flags |= folderAttributes::FLAG_NO_OPEN;
+				break;
+
+			case IMAPParser::mailbox_flag::NOINFERIORS:
+			case IMAPParser::mailbox_flag::HASNOCHILDREN:
+
+				flags &= ~folderAttributes::FLAG_HAS_CHILDREN;
+				break;
+
+			case IMAPParser::mailbox_flag::HASCHILDREN:
+
+				flags |= folderAttributes::FLAG_HAS_CHILDREN;
+				break;
+
+			case IMAPParser::mailbox_flag::SPECIALUSE_ALL:
+
+				specialUse = folderAttributes::SPECIALUSE_ALL;
+				break;
+
+			case IMAPParser::mailbox_flag::SPECIALUSE_ARCHIVE:
+
+				specialUse = folderAttributes::SPECIALUSE_ARCHIVE;
+				break;
+
+			case IMAPParser::mailbox_flag::SPECIALUSE_DRAFTS:
+
+				specialUse = folderAttributes::SPECIALUSE_DRAFTS;
+				break;
+
+			case IMAPParser::mailbox_flag::SPECIALUSE_FLAGGED:
+
+				specialUse = folderAttributes::SPECIALUSE_FLAGGED;
+				break;
+
+			case IMAPParser::mailbox_flag::SPECIALUSE_JUNK:
+
+				specialUse = folderAttributes::SPECIALUSE_JUNK;
+				break;
+
+			case IMAPParser::mailbox_flag::SPECIALUSE_SENT:
+
+				specialUse = folderAttributes::SPECIALUSE_SENT;
+				break;
+
+			case IMAPParser::mailbox_flag::SPECIALUSE_TRASH:
+
+				specialUse = folderAttributes::SPECIALUSE_TRASH;
+				break;
+
+			case IMAPParser::mailbox_flag::SPECIALUSE_IMPORTANT:
+
+				specialUse = folderAttributes::SPECIALUSE_IMPORTANT;
+				break;
+
+			default:
+
+				break;
+		}
+	}
+
+	if (path.getSize() == 1 && path.getLastComponent().getBuffer() == "INBOX") {
+		specialUse = folderAttributes::SPECIALUSE_INBOX;
+	}
+
+	attribs.setSpecialUse(specialUse);
+	attribs.setType(type);
+	attribs.setFlags(flags);
+}
+
+
+int IMAPUtils::messageFlagsFromFlags(const IMAPParser::flag_list& list) {
+
+	int flags = 0;
+
+	for (auto &flag : list.flags) {
+
+		switch (flag->type) {
+
+			case IMAPParser::flag::ANSWERED:
+
+				flags |= message::FLAG_REPLIED;
+				break;
+
+			case IMAPParser::flag::FLAGGED:
+
+				flags |= message::FLAG_MARKED;
+				break;
+
+			case IMAPParser::flag::DELETED:
+
+				flags |= message::FLAG_DELETED;
+				break;
+
+			case IMAPParser::flag::SEEN:
+
+				flags |= message::FLAG_SEEN;
+				break;
+
+			case IMAPParser::flag::DRAFT:
+
+				flags |= message::FLAG_DRAFT;
+				break;
+
+			default:
+			//case IMAPParser::flag::UNKNOWN:
+
+				break;
+		}
+	}
+
+	return flags;
+}
+
+
+// static
+const std::vector <string> IMAPUtils::messageFlagList(const int flags) {
+
+	std::vector <string> flagList;
+
+	if (flags == -1) {
+		return flagList;  // default flags
+	}
+
+	if (flags & message::FLAG_REPLIED) flagList.push_back("\\Answered");
+	if (flags & message::FLAG_MARKED) flagList.push_back("\\Flagged");
+	if (flags & message::FLAG_DELETED) flagList.push_back("\\Deleted");
+	if (flags & message::FLAG_SEEN) flagList.push_back("\\Seen");
+	if (flags & message::FLAG_DRAFT) flagList.push_back("\\Draft");
+
+	return flagList;
+}
+
+
+// static
+const string IMAPUtils::dateTime(const vmime::datetime& date) {
+
+	std::ostringstream res;
+	res.imbue(std::locale::classic());
+
+	// date_time ::= <"> date_day_fixed "-" date_month "-" date_year
+	//               SPACE time SPACE zone <">
+	//
+	// time      ::= 2digit ":" 2digit ":" 2digit
+	//               ;; Hours minutes seconds
+	// zone      ::= ("+" / "-") 4digit
+	//               ;; Signed four-digit value of hhmm representing
+	//               ;; hours and minutes west of Greenwich
+	res << '"';
+
+	// Date
+	if (date.getDay() < 10) res << ' ';
+	res << date.getDay();
+
+	res << '-';
+
+	static const char* monthNames[12] = {
+		"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+		"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+	};
+
+	res << monthNames[std::min(std::max(date.getMonth() - 1, 0), 11)];
+
+	res << '-';
+
+	if (date.getYear() < 10) res << '0';
+	if (date.getYear() < 100) res << '0';
+	if (date.getYear() < 1000) res << '0';
+	res << date.getYear();
+
+	res << ' ';
+
+	// Time
+	if (date.getHour() < 10) res << '0';
+	res << date.getHour() << ':';
+
+	if (date.getMinute() < 10) res << '0';
+	res << date.getMinute() << ':';
+
+	if (date.getSecond() < 10) res << '0';
+	res << date.getSecond();
+
+	res << ' ';
+
+	// Zone
+	const int zs = (date.getZone() < 0 ? -1 : 1);
+	const int zh = (date.getZone() * zs) / 60;
+	const int zm = (date.getZone() * zs) % 60;
+
+	res << (zs < 0 ? '-' : '+');
+
+	if (zh < 10) res << '0';
+	res << zh;
+
+	if (zm < 10) res << '0';
+	res << zm;
+
+	res << '"';
+
+	return res.str();
+}
+
+
+// static
+shared_ptr <IMAPCommand> IMAPUtils::buildFetchCommand(
+	const shared_ptr <IMAPConnection>& cnt,
+	const messageSet& msgs,
+	const fetchAttributes& options
+) {
+
+	// Example:
+	//   C: A654 FETCH 2:4 (FLAGS BODY[HEADER.FIELDS (DATE FROM)])
+	//   S: * 2 FETCH ....
+	//   S: * 3 FETCH ....
+	//   S: * 4 FETCH ....
+	//   S: A654 OK FETCH completed
+
+	std::vector <string> items;
+
+	if (options.has(fetchAttributes::SIZE)) {
+		items.push_back("RFC822.SIZE");
+	}
+
+	if (options.has(fetchAttributes::FLAGS)) {
+		items.push_back("FLAGS");
+	}
+
+	if (options.has(fetchAttributes::STRUCTURE)) {
+		items.push_back("BODYSTRUCTURE");
+	}
+
+	if (options.has(fetchAttributes::UID)) {
+
+		items.push_back("UID");
+
+		// Also fetch MODSEQ if CONDSTORE is supported
+		if (cnt && cnt->hasCapability("CONDSTORE") && !cnt->isMODSEQDisabled()) {
+			items.push_back("MODSEQ");
+		}
+	}
+
+	if (options.has(fetchAttributes::FULL_HEADER)) {
+
+		items.push_back("RFC822.HEADER");
+
+	} else {
+
+		if (options.has(fetchAttributes::ENVELOPE)) {
+			items.push_back("ENVELOPE");
+		}
+
+		std::vector <string> headerFields;
+
+		if (options.has(fetchAttributes::CONTENT_INFO)) {
+			headerFields.push_back("CONTENT_TYPE");
+		}
+
+		if (options.has(fetchAttributes::IMPORTANCE)) {
+			headerFields.push_back("IMPORTANCE");
+			headerFields.push_back("X-PRIORITY");
+		}
+
+		// Also add custom header fields to fetch, if any
+		const std::vector <string> customHeaderFields = options.getHeaderFields();
+		std::copy(customHeaderFields.begin(), customHeaderFields.end(), std::back_inserter(headerFields));
+
+		if (!headerFields.empty()) {
+
+			string list;
+
+			for (std::vector <string>::iterator it = headerFields.begin() ;
+			     it != headerFields.end() ; ++it) {
+
+				if (it != headerFields.begin()) {
+					list += " ";
+				}
+
+				list += *it;
+			}
+
+			items.push_back("BODY[HEADER.FIELDS (" + list + ")]");
+		}
+	}
+
+	return IMAPCommand::FETCH(msgs, items);
+}
+
+
+// static
+void IMAPUtils::convertAddressList(
+	const IMAPParser::address_list& src,
+	mailboxList& dest
+) {
+
+	for (auto& addr : src.addresses) {
+
+		text name;
+		text::decodeAndUnfold(addr->addr_name->value, &name);
+
+		string email = addr->addr_mailbox->value
+			+ "@" + addr->addr_host->value;
+
+		dest.appendMailbox(make_shared <mailbox>(name, email));
+	}
+}
+
+
+
+class IMAPUIDMessageSetEnumerator : public messageSetEnumerator {
+
+public:
+
+	IMAPUIDMessageSetEnumerator()
+		: m_first(true) {
+
+		m_oss.imbue(std::locale::classic());
+	}
+
+	void enumerateNumberMessageRange(const vmime::net::numberMessageRange& range) {
+
+		if (!m_first) {
+			m_oss << ",";
+		}
+
+		if (range.getFirst() == range.getLast()) {
+			m_oss << range.getFirst();
+		} else if (range.getLast() == size_t(-1)) {
+			m_oss << range.getFirst() << ":*";
+		} else {
+			m_oss << range.getFirst() << ":" << range.getLast();
+		}
+
+		m_first = false;
+	}
+
+	void enumerateUIDMessageRange(const vmime::net::UIDMessageRange& range) {
+
+		if (!m_first) {
+			m_oss << ",";
+		}
+
+		if (range.getFirst() == range.getLast()) {
+			m_oss << range.getFirst();
+		} else if (range.getLast() == size_t(-1)) {
+			m_oss << range.getFirst() << ":*";
+		} else {
+			m_oss << range.getFirst() << ":" << range.getLast();
+		}
+
+		m_first = false;
+	}
+
+	const std::string str() const {
+
+		return m_oss.str();
+	}
+
+private:
+
+	std::ostringstream m_oss;
+	bool m_first;
+};
+
+
+class IMAPMessageSetEnumerator : public messageSetEnumerator {
+
+public:
+
+	void enumerateNumberMessageRange(const vmime::net::numberMessageRange& range) {
+
+		for (size_t i = range.getFirst(), last = range.getLast() ; i <= last ; ++i) {
+			m_list.push_back(i);
+		}
+	}
+
+	void enumerateUIDMessageRange(const vmime::net::UIDMessageRange& /* range */) {
+
+		// Not used
+	}
+
+	const std::vector <size_t>& list() const {
+
+		return m_list;
+	}
+
+public:
+
+	std::vector <size_t> m_list;
+};
+
+
+
+// static
+const string IMAPUtils::messageSetToSequenceSet(const messageSet& msgs) {
+
+	IMAPUIDMessageSetEnumerator en;
+	msgs.enumerate(en);
+
+	return en.str();
+}
+
+
+// static
+messageSet IMAPUtils::buildMessageSet(const IMAPParser::uid_set& uidSetRef) {
+
+	messageSet set = messageSet::empty();
+
+	const IMAPParser::uid_set* uidSet = &uidSetRef;
+
+	for ( ; uidSet ; uidSet = uidSet->next_uid_set.get()) {
+
+		if (uidSet->uid_range) {
+
+			set.addRange(
+				UIDMessageRange(
+					message::uid(uidSet->uid_range->uniqueid1->value),
+					message::uid(uidSet->uid_range->uniqueid2->value)
+				)
+			);
+
+		} else {
+
+			set.addRange(
+				UIDMessageRange(
+					message::uid(uidSet->uniqueid->value)
+				)
+			);
+		}
+	}
+
+	return set;
+}
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
diff --git a/vmime-master/src/vmime/net/imap/IMAPUtils.hpp b/vmime-master/src/vmime/net/imap/IMAPUtils.hpp
new file mode 100644
index 0000000..d4bd135
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/IMAPUtils.hpp
@@ -0,0 +1,144 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_NET_IMAP_IMAPUTILS_HPP_INCLUDED
+#define VMIME_NET_IMAP_IMAPUTILS_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+
+#include "vmime/types.hpp"
+#include "vmime/dateTime.hpp"
+
+#include "vmime/net/folder.hpp"
+#include "vmime/net/message.hpp"
+#include "vmime/net/imap/IMAPParser.hpp"
+#include "vmime/net/imap/IMAPConnection.hpp"
+#include "vmime/net/imap/IMAPCommand.hpp"
+
+#include "vmime/mailboxList.hpp"
+
+#include <vector>
+
+
+namespace vmime {
+namespace net {
+namespace imap {
+
+
+class VMIME_EXPORT IMAPUtils
+{
+public:
+
+	static const string pathToString(const char hierarchySeparator, const folder::path& path);
+	static const folder::path stringToPath(const char hierarchySeparator, const string& str);
+
+	static const string toModifiedUTF7(const char hierarchySeparator, const folder::path::component& text);
+	static const folder::path::component fromModifiedUTF7(const string& text);
+
+	/** Quote string if it contains IMAP-special characters.
+	  *
+	  * @param text string to quote
+	  * @return quoted string
+	  */
+	static const string quoteString(const string& text);
+
+	/** Parse mailbox flags and fill in folder attributes.
+	  *
+	  * @param cnt reference to current IMAP connection (for testing capabilities)
+	  * @param path folder full path
+	  * @param list list of mailbox flags
+	  * @param attribs reference to an object holding folder attributes
+	  */
+	static void mailboxFlagsToFolderAttributes(
+		const shared_ptr <const IMAPConnection>& cnt,
+		const folder::path &path,
+		const IMAPParser::mailbox_flag_list& list,
+		folderAttributes& attribs
+	);
+
+	static int messageFlagsFromFlags(const IMAPParser::flag_list& list);
+
+	static const std::vector <string> messageFlagList(const int flags);
+
+	/** Format a date/time to IMAP date/time format.
+	  *
+	  * @param date date/time to format
+	  * @return IMAP-formatted date/time
+	  */
+	static const string dateTime(const vmime::datetime& date);
+
+	/** Construct a fetch request for the specified messages, designated
+	  * either by their sequence numbers or their UIDs.
+	  *
+	  * @param cnt connection
+	  * @param msgs message set
+	  * @param options fetch options
+	  * @return fetch request
+	  */
+	static shared_ptr <IMAPCommand> buildFetchCommand(
+		const shared_ptr <IMAPConnection>& cnt,
+		const messageSet& msgs,
+		const fetchAttributes& options
+	);
+
+	/** Convert a parser-style address list to a mailbox list.
+	  *
+	  * @param src input address list
+	  * @param dest output mailbox list
+	  */
+	static void convertAddressList(const IMAPParser::address_list& src, mailboxList& dest);
+
+	/** Returns an IMAP-formatted sequence set given a message set.
+	  *
+	  * @param msgs message set
+	  * @return IMAP sequence set (eg. "1:5,7,15:*")
+	  */
+	static const string messageSetToSequenceSet(const messageSet& msgs);
+
+	/** Constructs a message set from a parser 'uid_set' structure.
+	  *
+	  * @param uidSet UID set, as returned by the parser
+	  * @return message set
+	  */
+	static messageSet buildMessageSet(const IMAPParser::uid_set& uidSet);
+
+private:
+
+	static const string buildFetchRequestImpl
+		(const shared_ptr <IMAPConnection>& cnt, const string& mode, const string& set, const int options);
+};
+
+
+} // imap
+} // net
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP
+
+#endif // VMIME_NET_IMAP_IMAPUTILS_HPP_INCLUDED
diff --git a/vmime-master/src/vmime/net/imap/imap.hpp b/vmime-master/src/vmime/net/imap/imap.hpp
new file mode 100644
index 0000000..f25baa4
--- /dev/null
+++ b/vmime-master/src/vmime/net/imap/imap.hpp
@@ -0,0 +1,35 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_NET_IMAP_IMAP_HPP_INCLUDED
+#define VMIME_NET_IMAP_IMAP_HPP_INCLUDED
+
+
+#include "vmime/net/imap/IMAPFolder.hpp"
+#include "vmime/net/imap/IMAPFolderStatus.hpp"
+#include "vmime/net/imap/IMAPMessage.hpp"
+#include "vmime/net/imap/IMAPStore.hpp"
+#include "vmime/net/imap/IMAPSStore.hpp"
+
+
+#endif // VMIME_NET_IMAP_IMAP_HPP_INCLUDED