Added support for pipelined and out-of-order replies.

src/vmime/net/imap/IMAPConnection.cpp

@@ -92,7 +92,6 @@ IMAPConnection::IMAPConnection(
 	}
 
 	m_parser = make_shared <IMAPParser>();
-	m_parser->setTag(m_tag);
 	m_parser->setTracer(m_tracer);
 }
 
@@ -287,7 +286,7 @@ void IMAPConnection::authenticate() {
 	shared_ptr <IMAPConnection> conn = dynamicCast <IMAPConnection>(shared_from_this());
 	IMAPCommand::LOGIN(username, password)->send(conn);
 
-	scoped_ptr <IMAPParser::response> resp(m_parser->readResponse());
+	scoped_ptr <IMAPParser::response> resp(m_parser->readResponse(*m_tag));
 
 	if (resp->isBad()) {
 
@@ -409,7 +408,7 @@ void IMAPConnection::authenticateSASL() {
 
 		for (bool cont = true ; cont ; ) {
 
-			scoped_ptr <IMAPParser::response> resp(m_parser->readResponse());
+			scoped_ptr <IMAPParser::response> resp(m_parser->readResponse(*m_tag));
 
 			if (resp->response_done &&
 			    resp->response_done->response_tagged &&
@@ -522,7 +521,7 @@ void IMAPConnection::startTLS() {
 
 		IMAPCommand::STARTTLS()->send(dynamicCast <IMAPConnection>(shared_from_this()));
 
-		scoped_ptr <IMAPParser::response> resp(m_parser->readResponse());
+		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) {
@@ -624,7 +623,7 @@ void IMAPConnection::fetchCapabilities() {
 
 	IMAPCommand::CAPABILITY()->send(dynamicCast <IMAPConnection>(shared_from_this()));
 
-	scoped_ptr <IMAPParser::response> resp(m_parser->readResponse());
+	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) {
@@ -733,7 +732,7 @@ void IMAPConnection::initHierarchySeparator() {
 
 	IMAPCommand::LIST("", "")->send(dynamicCast <IMAPConnection>(shared_from_this()));
 
-	scoped_ptr <IMAPParser::response> resp(m_parser->readResponse());
+	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) {
@@ -801,7 +800,7 @@ void IMAPConnection::sendRaw(const byte_t* buffer, const size_t count) {
 
 IMAPParser::response* IMAPConnection::readResponse(IMAPParser::literalHandler* lh) {
 
-	return m_parser->readResponse(lh);
+	return m_parser->readResponse(*m_tag, lh);
 }
 
 

src/vmime/net/imap/IMAPParser.hpp

@@ -271,24 +271,13 @@ public:
 
 	}
 
+	~IMAPParser() {
 
-	/** Set the tag currently used by this parser.
+		for (auto it = m_pendingResponses.begin() ; it != m_pendingResponses.end() ; ++it) {
-	  *
+			delete it->second;
-	  * @param tag IMAP command tag
+		}
-	  */
-	void setTag(const shared_ptr <IMAPTag>& tag) {
-
-		m_tag = tag;
 	}
 
-	/** Return the tag currently used by this parser.
-	  *
-	  * @return IMAP command tag
-	  */
-	shared_ptr <const IMAPTag> getTag() const {
-
-		return m_tag.lock();
-	}
 
 	/** Set the socket currently used by this parser to receive data
 	  * from server.
@@ -613,13 +602,12 @@ public:
 
 	DECLARE_COMPONENT(xtag)
 
-		bool parseImpl(IMAPParser& parser, string& line, size_t* currentPos) {
+		bool parseImpl(IMAPParser& /* parser */, string& line, size_t* currentPos) {
 
 			size_t pos = *currentPos;
 
 			bool end = false;
 
-			string tagString;
 			tagString.reserve(10);
 
 			while (!end && pos < line.length()) {
@@ -654,14 +642,11 @@ public:
 				}
 			}
 
-			if (tagString == string(*parser.getTag())) {
+			*currentPos = pos;
-				*currentPos = pos;
+			return true;
-				return true;
-			} else {
-				// Invalid tag
-				return false;
-			}
 		}
+
+		string tagString;
 	};
 
 
@@ -1141,7 +1126,7 @@ public:
 						value = text->value;
 					}
 
-					DEBUG_FOUND("string[quoted]", "<length=" << m_value.length() << ", value='" << m_value << "'>");
+					DEBUG_FOUND("string[quoted]", "<length=" << value.length() << ", value='" << value << "'>");
 
 				// literal ::= "{" number "}" CRLF *CHAR8
 				} else {
@@ -4389,7 +4374,7 @@ public:
 
 			size_t pos = *currentPos;
 
-			VIMAP_PARSER_CHECK(IMAPParser::xtag);
+			VIMAP_PARSER_GET(IMAPParser::xtag, tag);
 			VIMAP_PARSER_CHECK(SPACE);
 			VIMAP_PARSER_GET(IMAPParser::resp_cond_state, resp_cond_state);
 
@@ -4409,6 +4394,7 @@ public:
 		}
 
 
+		std::unique_ptr <IMAPParser::xtag> tag;
 		std::unique_ptr <IMAPParser::resp_cond_state> resp_cond_state;
 	};
 
@@ -4569,22 +4555,53 @@ public:
 	// The main functions used to parse a response
 	//
 
-	response* readResponse(literalHandler* lh = NULL) {
+	response* readResponse(const IMAPTag& tag, literalHandler* lh = NULL) {
 
-		size_t pos = 0;
+		while (true) {
-		string line = readLine();
 
-		m_literalHandler = lh;
+			auto it = m_pendingResponses.find(std::string(tag));
-		response* resp = get <response>(line, &pos);
-		m_literalHandler = NULL;
 
-		if (!resp) {
+			if (it != m_pendingResponses.end()) {
-			throw exceptions::invalid_response("", m_errorResponseLine);
+				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;
+			}
 		}
-
-		resp->setErrorLog(lastLine());
-
-		return (resp);
 	}
 
 
@@ -4740,7 +4757,6 @@ public:
 
 private:
 
-	weak_ptr <IMAPTag> m_tag;
 	weak_ptr <socket> m_socket;
 	shared_ptr <tracer> m_tracer;
 
@@ -4758,6 +4774,8 @@ private:
 	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

src/vmime/net/imap/IMAPTag.cpp

@@ -85,6 +85,30 @@ const IMAPTag IMAPTag::operator++(int) {
 }
 
 
+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;

src/vmime/net/imap/IMAPTag.hpp

@@ -44,11 +44,11 @@ class VMIME_EXPORT IMAPTag : public object {
 private:
 
 	IMAPTag(const int number);
-	IMAPTag(const IMAPTag& tag);
 
 public:
 
 	IMAPTag();
+	IMAPTag(const IMAPTag& tag);
 
 	IMAPTag& operator++();           // ++IMAPTag
 	const IMAPTag operator++(int);   // IMAPTag++
@@ -58,6 +58,12 @@ public:
 
 	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();

tests/net/imap/IMAPParserTest.cpp

@@ -36,6 +36,7 @@ VMIME_TEST_SUITE_BEGIN(IMAPParserTest)
 		VMIME_TEST(testFETCHResponse_optional_body_fld_lang)
 		VMIME_TEST(testFETCHBodyStructure_NIL_body_fld_param_value)
 		VMIME_TEST(testFETCHBodyStructure_empty_body_fld_param_instead_of_NIL)
+		VMIME_TEST(testPipelining)
 	VMIME_TEST_LIST_END
 
 
@@ -56,12 +57,11 @@ VMIME_TEST_SUITE_BEGIN(IMAPParserTest)
 		vmime::shared_ptr <vmime::net::imap::IMAPParser> parser =
 			vmime::make_shared <vmime::net::imap::IMAPParser>();
 
-		parser->setTag(tag);
 		parser->setSocket(socket);
 		parser->setTimeoutHandler(toh);
 
 		parser->setStrict(false);
-		VASSERT_NO_THROW("non-strict mode", parser->readResponse(/* literalHandler */ NULL));
+		VASSERT_NO_THROW("non-strict mode", parser->readResponse(*tag, /* literalHandler */ NULL));
 
 		++(*tag);
 
@@ -71,7 +71,7 @@ VMIME_TEST_SUITE_BEGIN(IMAPParserTest)
 		);
 
 		parser->setStrict(true);
-		VASSERT_THROW("strict mode", parser->readResponse(/* literalHandler */ NULL), vmime::exceptions::invalid_response);
+		VASSERT_THROW("strict mode", parser->readResponse(*tag, /* literalHandler */ NULL), vmime::exceptions::invalid_response);
 	}
 
 	// For Apple iCloud/Exchange IMAP server
@@ -98,19 +98,18 @@ VMIME_TEST_SUITE_BEGIN(IMAPParserTest)
 		vmime::shared_ptr <vmime::net::imap::IMAPParser> parser =
 			vmime::make_shared <vmime::net::imap::IMAPParser>();
 
-		parser->setTag(tag);
 		parser->setSocket(socket);
 		parser->setTimeoutHandler(toh);
 
 		parser->setStrict(false);
-		VASSERT_NO_THROW("non-strict mode", parser->readResponse());
+		VASSERT_NO_THROW("non-strict mode", parser->readResponse(*tag));
 
 		++(*tag);
 
 		socket->localSend("+\r\n");
 
 		parser->setStrict(true);
-		VASSERT_THROW("strict mode", parser->readResponse(), vmime::exceptions::invalid_response);
+		VASSERT_THROW("strict mode", parser->readResponse(*tag), vmime::exceptions::invalid_response);
 	}
 
 	// When an IMAP4 client sends a FETCH (bodystructure) request to a server
@@ -132,19 +131,18 @@ VMIME_TEST_SUITE_BEGIN(IMAPParserTest)
 		vmime::shared_ptr <vmime::net::imap::IMAPParser> parser =
 			vmime::make_shared <vmime::net::imap::IMAPParser>();
 
-		parser->setTag(tag);
 		parser->setSocket(socket);
 		parser->setTimeoutHandler(toh);
 
 		parser->setStrict(false);
-		VASSERT_NO_THROW("non-strict mode", parser->readResponse());
+		VASSERT_NO_THROW("non-strict mode", parser->readResponse(*tag));
 
 		++(*tag);
 
 		socket->localSend(resp);
 
 		parser->setStrict(true);
-		VASSERT_THROW("strict mode", parser->readResponse(), vmime::exceptions::invalid_response);
+		VASSERT_THROW("strict mode", parser->readResponse(*tag), vmime::exceptions::invalid_response);
 	}
 
 	// "body_fld_lang" is optional after "body_fld_dsp" in "body_ext_mpart" (Yahoo)
@@ -163,11 +161,10 @@ VMIME_TEST_SUITE_BEGIN(IMAPParserTest)
 		vmime::shared_ptr <vmime::net::imap::IMAPParser> parser =
 			vmime::make_shared <vmime::net::imap::IMAPParser>();
 
-		parser->setTag(tag);
 		parser->setSocket(socket);
 		parser->setTimeoutHandler(toh);
 
-		VASSERT_NO_THROW("parse", parser->readResponse());
+		VASSERT_NO_THROW("parse", parser->readResponse(*tag));
 	}
 
 	// Support for NIL boundary, for mail.ru IMAP server:
@@ -188,19 +185,18 @@ VMIME_TEST_SUITE_BEGIN(IMAPParserTest)
 		vmime::shared_ptr <vmime::net::imap::IMAPParser> parser =
 			vmime::make_shared <vmime::net::imap::IMAPParser>();
 
-		parser->setTag(tag);
 		parser->setSocket(socket);
 		parser->setTimeoutHandler(toh);
 
 		parser->setStrict(false);
-		VASSERT_NO_THROW("non-strict mode", parser->readResponse());
+		VASSERT_NO_THROW("non-strict mode", parser->readResponse(*tag));
 
 		++(*tag);
 
 		socket->localSend(resp);
 
 		parser->setStrict(true);
-		VASSERT_THROW("strict mode", parser->readResponse(), vmime::exceptions::invalid_response);
+		VASSERT_THROW("strict mode", parser->readResponse(*tag), vmime::exceptions::invalid_response);
 	}
 
 	void testFETCHBodyStructure_empty_body_fld_param_instead_of_NIL() {
@@ -218,19 +214,94 @@ VMIME_TEST_SUITE_BEGIN(IMAPParserTest)
 		vmime::shared_ptr <vmime::net::imap::IMAPParser> parser =
 			vmime::make_shared <vmime::net::imap::IMAPParser>();
 
-		parser->setTag(tag);
 		parser->setSocket(socket);
 		parser->setTimeoutHandler(toh);
 
 		parser->setStrict(false);
-		VASSERT_NO_THROW("non-strict mode", parser->readResponse());
+		VASSERT_NO_THROW("non-strict mode", parser->readResponse(*tag));
 
 		++(*tag);
 
 		socket->localSend(resp);
 
 		parser->setStrict(true);
-		VASSERT_THROW("strict mode", parser->readResponse(), vmime::exceptions::invalid_response);
+		VASSERT_THROW("strict mode", parser->readResponse(*tag), vmime::exceptions::invalid_response);
+	}
+
+	// Test pipelined and out-of-order replies
+	void testPipelining() {
+
+		/*
+		[C] a001 SELECT "INBOX"
+		[C] a002 UID FETCH 42 (INTERNALDATE)
+		[C] a003 UID FETCH 43 (INTERNALDATE)
+		[S] * NO Error for a001
+		[S] a001 NO Access denied
+		[S] * NO Error for a003
+		[S] a003 BAD No mailbox selected
+		[S] * NO Error for a002
+		[S] a002 BAD No mailbox selected
+		*/
+
+		vmime::shared_ptr <testSocket> socket = vmime::make_shared <testSocket>();
+		vmime::shared_ptr <vmime::net::timeoutHandler> toh = vmime::make_shared <testTimeoutHandler>();
+
+		vmime::net::imap::IMAPTag tag1;  // a001
+		vmime::net::imap::IMAPTag tag2(tag1);  // a002
+		++tag2;
+		vmime::net::imap::IMAPTag tag3(tag2);  // a003
+		++tag3;
+
+		socket->localSend(
+			"* NO Error for a001\r\n"
+			"a001 NO Access denied\r\n"
+			"* NO Error for a003\r\n"
+			"a003 BAD No mailbox selected a003\r\n"
+			"* NO Error for a002\r\n"
+			"a002 BAD No mailbox selected a002\r\n"
+		);
+
+		vmime::shared_ptr <vmime::net::imap::IMAPParser> parser =
+			vmime::make_shared <vmime::net::imap::IMAPParser>();
+
+		parser->setSocket(socket);
+		parser->setTimeoutHandler(toh);
+
+		// Test response a001
+		vmime::scoped_ptr <vmime::net::imap::IMAPParser::response> resp1(parser->readResponse(tag1, /* literalHandler */ NULL));
+		VASSERT("a001 response", resp1);
+		VASSERT("a001 response_done", resp1->response_done);
+		VASSERT_EQ("a001 response tag", "a001", resp1->response_done->response_tagged->tag->tagString);
+		VASSERT_EQ("a001 response text", "Access denied", resp1->response_done->response_tagged->resp_cond_state->resp_text->text);
+		VASSERT_EQ("a001 resp_data.size()", 1, resp1->continue_req_or_response_data.size());
+		VASSERT("a001 resp_data[0]", resp1->continue_req_or_response_data[0]->response_data);
+		VASSERT("a001 resp_cond_state", resp1->continue_req_or_response_data[0]->response_data->resp_cond_state);
+		VASSERT_EQ("a001 resp_cond_state.text", "Error for a001", resp1->continue_req_or_response_data[0]->response_data->resp_cond_state->resp_text->text);
+		VASSERT_EQ("a001 resp_cond_state.status", vmime::net::imap::IMAPParser::resp_cond_state::NO, resp1->continue_req_or_response_data[0]->response_data->resp_cond_state->status);
+
+		// Test response a002
+		vmime::scoped_ptr <vmime::net::imap::IMAPParser::response> resp2(parser->readResponse(tag2, /* literalHandler */ NULL));
+		VASSERT("a002 response", resp2);
+		VASSERT("a002 response_done", resp2->response_done);
+		VASSERT_EQ("a002 response tag", "a002", resp2->response_done->response_tagged->tag->tagString);
+		VASSERT_EQ("a002 response text", "No mailbox selected a002", resp2->response_done->response_tagged->resp_cond_state->resp_text->text);
+		VASSERT_EQ("a002 resp_data.size()", 1, resp2->continue_req_or_response_data.size());
+		VASSERT("a002 resp_data[0]", resp2->continue_req_or_response_data[0]->response_data);
+		VASSERT("a002 resp_cond_state", resp2->continue_req_or_response_data[0]->response_data->resp_cond_state);
+		VASSERT_EQ("a002 resp_cond_state.text", "Error for a002", resp2->continue_req_or_response_data[0]->response_data->resp_cond_state->resp_text->text);
+		VASSERT_EQ("a002 resp_cond_state.status", vmime::net::imap::IMAPParser::resp_cond_state::NO, resp2->continue_req_or_response_data[0]->response_data->resp_cond_state->status);
+
+		// Test response a003
+		vmime::scoped_ptr <vmime::net::imap::IMAPParser::response> resp3(parser->readResponse(tag3, /* literalHandler */ NULL));
+		VASSERT("a003 response", resp3);
+		VASSERT("a003 response_done", resp3->response_done);
+		VASSERT_EQ("a003 response tag", "a003", resp3->response_done->response_tagged->tag->tagString);
+		VASSERT_EQ("a003 response text", "No mailbox selected a003", resp3->response_done->response_tagged->resp_cond_state->resp_text->text);
+		VASSERT_EQ("a003 resp_data.size()", 1, resp3->continue_req_or_response_data.size());
+		VASSERT("a003 resp_data[0]", resp3->continue_req_or_response_data[0]->response_data);
+		VASSERT("a003 resp_cond_state", resp3->continue_req_or_response_data[0]->response_data->resp_cond_state);
+		VASSERT_EQ("a003 resp_cond_state.text", "Error for a003", resp3->continue_req_or_response_data[0]->response_data->resp_cond_state->resp_text->text);
+		VASSERT_EQ("a003 resp_cond_state.status", vmime::net::imap::IMAPParser::resp_cond_state::NO, resp3->continue_req_or_response_data[0]->response_data->resp_cond_state->status);
 	}
 
 VMIME_TEST_SUITE_END