3 files changed, 275 insertions, 8 deletions
diff --git a/Swiften/JID/JID.cpp b/Swiften/JID/JID.cpp
index e4611b3..2ebbdd6 100644
--- a/Swiften/JID/JID.cpp
+++ b/Swiften/JID/JID.cpp
@@ -7,17 +7,24 @@
 #define SWIFTEN_CACHE_JID_PREP
 
 #include <vector>
+#include <list>
 #include <iostream>
 
 #include <string>
 #ifdef SWIFTEN_CACHE_JID_PREP
 #include <boost/unordered_map.hpp>
 #endif
+#include <boost/assign/list_of.hpp>
+#include <boost/algorithm/string/find_format.hpp>
+#include <boost/algorithm/string/finder.hpp>
+#include <sstream>
 #include <stringprep.h>
 
 #include <Swiften/Base/String.h>
-#include "Swiften/JID/JID.h"
-#include "Swiften/IDN/StringPrep.h"
+#include <Swiften/JID/JID.h>
+#include <Swiften/IDN/StringPrep.h>
+
+using namespace Swift;
 
 #ifdef SWIFTEN_CACHE_JID_PREP
 typedef boost::unordered_map<std::string, std::string> PrepCache;
@@ -27,7 +34,81 @@ static PrepCache domainPrepCache;
 static PrepCache resourcePrepCache;
 #endif
 
-namespace Swift {
+static const std::list<char> escapedChars = boost::assign::list_of(' ')('"')('&')('\'')('/')('<')('>')('@')(':');
+
+static std::string getEscaped(char c) {
+	return makeString() << '\\' << std::hex << static_cast<int>(c);
+}
+
+static bool getEscapeSequenceValue(const std::string& sequence, unsigned char& value) {
+	std::stringstream s;
+	unsigned int v;
+	s << std::hex << sequence;
+	s >> v;
+	value = static_cast<unsigned char>(v);
+	return (!s.fail() && !s.bad() && (value == 0x5C || std::find(escapedChars.begin(), escapedChars.end(), value) != escapedChars.end()));
+}
+
+// Disabling this code for now, since GCC4.5+boost1.42 (on ubuntu) seems to
+// result in a bug. Replacing it with naive code.
+#if 0
+struct UnescapedCharacterFinder {
+	template<typename Iterator>	boost::iterator_range<Iterator> operator()(Iterator begin, Iterator end) {
+		for (; begin != end; ++begin) {
+			if (std::find(escapedChars.begin(), escapedChars.end(), *begin) != escapedChars.end()) {
+				return boost::iterator_range<Iterator>(begin, begin + 1);
+			}
+			else if (*begin == '\\') {
+				// Check if we have an escaped dissalowed character sequence
+				Iterator innerBegin = begin + 1;
+				if (innerBegin != end && innerBegin + 1 != end) {
+					Iterator innerEnd = innerBegin + 2;
+					unsigned char value;
+					if (getEscapeSequenceValue(std::string(innerBegin, innerEnd), value)) {
+						return boost::iterator_range<Iterator>(begin, begin + 1);
+					}
+				}
+			}
+		}
+		return boost::iterator_range<Iterator>(end, end);
+	}
+};
+
+struct UnescapedCharacterFormatter {
+	template<typename FindResult>	std::string operator()(const FindResult& match) const {
+		std::ostringstream s;
+		s << '\\' << std::hex << static_cast<int>(*match.begin());
+		return s.str();
+	}
+};
+
+struct EscapedCharacterFinder {
+	template<typename Iterator>	boost::iterator_range<Iterator> operator()(Iterator begin, Iterator end) {
+		for (; begin != end; ++begin) {
+			if (*begin == '\\') {
+				Iterator innerEnd = begin + 1;
+				for (size_t i = 0; i < 2 && innerEnd != end; ++i, ++innerEnd) {
+				}
+				unsigned char value;
+				if (getEscapeSequenceValue(std::string(begin + 1, innerEnd), value)) {
+					return boost::iterator_range<Iterator>(begin, innerEnd);
+				}
+			}
+		}
+		return boost::iterator_range<Iterator>(end, end);
+	}
+};
+
+struct EscapedCharacterFormatter {
+	template<typename FindResult>	std::string operator()(const FindResult& match) const {
+		unsigned char value;
+		if (getEscapeSequenceValue(std::string(match.begin() + 1, match.end()), value)) {
+			return std::string(reinterpret_cast<const char*>(&value), 1);
+		}
+		return boost::copy_range<std::string>(match);
+	}
+};
+#endif
 
 JID::JID(const char* jid) {
 	initializeFromString(std::string(jid));
@@ -126,5 +207,48 @@ int JID::compare(const Swift::JID& o, CompareType compareType) const {
 	return 0;
 }
 
-} // namespace Swift
-
+std::string JID::getEscapedNode(const std::string& node) {
+	std::string result;
+	for (std::string::const_iterator i = node.begin(); i != node.end(); ++i) {
+		if (std::find(escapedChars.begin(), escapedChars.end(), *i) != escapedChars.end()) {
+			result += getEscaped(*i);
+			continue;
+		}
+		else if (*i == '\\') {
+			// Check if we have an escaped dissalowed character sequence
+			std::string::const_iterator innerBegin = i + 1;
+			if (innerBegin != node.end() && innerBegin + 1 != node.end()) {
+				std::string::const_iterator innerEnd = innerBegin + 2;
+				unsigned char value;
+				if (getEscapeSequenceValue(std::string(innerBegin, innerEnd), value)) {
+					result += getEscaped(*i);
+					continue;
+				}
+			}
+		}
+		result += *i;
+	}
+	return result;
+	//return boost::find_format_all_copy(node, UnescapedCharacterFinder(), UnescapedCharacterFormatter());
+}
+					
+std::string JID::getUnescapedNode() const {
+	std::string result;
+	for (std::string::const_iterator j = node_.begin(); j != node_.end();) {
+		if (*j == '\\') {
+			std::string::const_iterator innerEnd = j + 1;
+			for (size_t i = 0; i < 2 && innerEnd != node_.end(); ++i, ++innerEnd) {
+			}
+			unsigned char value;
+			if (getEscapeSequenceValue(std::string(j + 1, innerEnd), value)) {
+				result += std::string(reinterpret_cast<const char*>(&value), 1);
+				j = innerEnd;
+				continue;
+			}
+		}
+		result += *j;
+		++j;
+	}
+	return result;
+	//return boost::find_format_all_copy(node_, EscapedCharacterFinder(), EscapedCharacterFormatter());
+}
diff --git a/Swiften/JID/JID.h b/Swiften/JID/JID.h
index 63e063d..756db98 100644
--- a/Swiften/JID/JID.h
+++ b/Swiften/JID/JID.h
@@ -7,37 +7,120 @@
 #pragma once
 
 #include <string>
-#include <ostream>
+//#include <iosfwd>
+#include <iostream>
 
 namespace Swift {
+	/**
+	 * This represents the JID used in XMPP
+	 * (RFC6120 - http://tools.ietf.org/html/rfc6120 ).
+	 * For a description of format, see the RFC or page 14 of
+	 * XMPP: The Definitive Guide (Saint-Andre et al.)
+	 *
+	 * Particularly - a Bare JID is a JID without a resource part.
+	 *
+	 * A JID can be invalid (when isValid() returns false). No member methods are 
+	 * guaranteed to work correctly if they do.
+	 */
 	class JID {
 		public:
 			enum CompareType {
 				WithResource, WithoutResource
 			};
 
-			JID(const std::string& = std::string());
+			/**
+			 * Create a JID from its String representation.
+			 *
+			 * e.g.
+			 * wonderland.lit
+			 * wonderland.lit/rabbithole
+			 * alice@wonderland.lit
+			 * alice@wonderland.lit/TeaParty
+			 *
+			 * @param jid String representation. Invalid JID if empty or invalid.
+			 */
+			JID(const std::string& jid = std::string());
+
+			/**
+			 * See std::string constructor.
+			 */
 			JID(const char*);
+
+			/**
+			 * Create a bare JID from the node and domain parts.
+			 *
+			 * JID("node@domain") == JID("node", "domain")
+			 * unless you pass in empty values.
+			 *
+			 * @param node JID node part.
+			 * @param domain JID domain part.
+			 */
 			JID(const std::string& node, const std::string& domain);
+			/**
+			 * Create a bare JID from the node, domain and resource parts.
+			 *
+			 * JID("node@domain/resource") == JID("node", "domain", "resource")
+			 * unless you pass in empty values.
+			 *
+			 * @param node JID node part.
+			 * @param domain JID domain part.
+			 * @param resource JID resource part.
+			 */
 			JID(const std::string& node, const std::string& domain, const std::string& resource);
 
+			/**
+			 * @return Is a correctly-formatted JID.
+			 */
 			bool isValid() const {
 				return !domain_.empty(); /* FIXME */
 			}
 
+			/**
+			 * e.g. JID("node@domain").getNode() == "node"
+			 * @return could be empty.
+			 */
 			const std::string& getNode() const {
 				return node_;
 			}
+
+			/**
+			 * e.g. JID("node@domain").getDomain() == "domain"
+			 */
 			const std::string& getDomain() const {
 				return domain_;
 			}
+
+			/**
+			 * e.g. JID("node@domain/resource").getResource() == "resource"
+			 * @return could be empty.
+			 */
 			const std::string& getResource() const {
 				return resource_;
 			}
+
+			/**
+			 * Is a bare JID, i.e. has no resource part.
+			 */
 			bool isBare() const {
 				return !hasResource_;
 			}
 
+			/**
+			 * Returns the given node, escaped according to XEP-0106.
+			 * The resulting node is a valid node for a JID, whereas the input value can contain characters
+			 * that are not allowed.
+			 */
+			static std::string getEscapedNode(const std::string& node);
+
+			/**
+			 * Returns the node of the current JID, unescaped according to XEP-0106.
+			 */
+			std::string getUnescapedNode() const;
+
+			/**
+			 * Get the JID without a resource.
+			 * @return Invalid if the original is invalid.
+			 */
 			JID toBare() const {
 				JID result(*this);
 				result.hasResource_ = false;
diff --git a/Swiften/JID/UnitTest/JIDTest.cpp b/Swiften/JID/UnitTest/JIDTest.cpp
index 0f22e15..6f7895a 100644
--- a/Swiften/JID/UnitTest/JIDTest.cpp
+++ b/Swiften/JID/UnitTest/JIDTest.cpp
@@ -7,7 +7,7 @@
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
-#include "Swiften/JID/JID.h"
+#include <Swiften/JID/JID.h>
 
 using namespace Swift;
 
@@ -51,6 +51,11 @@ class JIDTest : public CppUnit::TestFixture
 		CPPUNIT_TEST(testSmallerThan_Larger);
 		CPPUNIT_TEST(testHasResource);
 		CPPUNIT_TEST(testHasResource_NoResource);
+		CPPUNIT_TEST(testGetEscapedNode);
+		CPPUNIT_TEST(testGetEscapedNode_XEP106Examples);
+		CPPUNIT_TEST(testGetEscapedNode_BackslashAtEnd);
+		CPPUNIT_TEST(testGetUnescapedNode);
+		CPPUNIT_TEST(testGetUnescapedNode_XEP106Examples);
 		CPPUNIT_TEST_SUITE_END();
 
 	public:
@@ -311,6 +316,61 @@ class JIDTest : public CppUnit::TestFixture
 
 			CPPUNIT_ASSERT(testling.isBare());
 		}
+
+		void testGetEscapedNode() {
+			std::string escaped = JID::getEscapedNode("alice@wonderland.lit");
+			CPPUNIT_ASSERT_EQUAL(std::string("alice\\40wonderland.lit"), escaped);
+
+			escaped = JID::getEscapedNode("\\& \" ' / <\\\\> @ :\\3a\\40");
+			CPPUNIT_ASSERT_EQUAL(std::string("\\\\26\\20\\22\\20\\27\\20\\2f\\20\\3c\\\\\\3e\\20\\40\\20\\3a\\5c3a\\5c40"), escaped);
+		}
+
+		void testGetEscapedNode_XEP106Examples() {
+			CPPUNIT_ASSERT_EQUAL(std::string("\\2plus\\2is\\4"), JID::getEscapedNode("\\2plus\\2is\\4"));
+			CPPUNIT_ASSERT_EQUAL(std::string("foo\\bar"), JID::getEscapedNode("foo\\bar"));
+			CPPUNIT_ASSERT_EQUAL(std::string("foob\\41r"), JID::getEscapedNode("foob\\41r"));
+			CPPUNIT_ASSERT_EQUAL(JID::getEscapedNode("space cadet"), std::string("space\\20cadet"));
+			CPPUNIT_ASSERT_EQUAL(JID::getEscapedNode("call me \"ishmael\""), std::string("call\\20me\\20\\22ishmael\\22"));
+			CPPUNIT_ASSERT_EQUAL(JID::getEscapedNode("at&t guy"), std::string("at\\26t\\20guy"));
+			CPPUNIT_ASSERT_EQUAL(JID::getEscapedNode("d'artagnan"), std::string("d\\27artagnan"));
+			CPPUNIT_ASSERT_EQUAL(JID::getEscapedNode("/.fanboy"), std::string("\\2f.fanboy"));
+			CPPUNIT_ASSERT_EQUAL(JID::getEscapedNode("::foo::"), std::string("\\3a\\3afoo\\3a\\3a"));
+			CPPUNIT_ASSERT_EQUAL(JID::getEscapedNode("<foo>"), std::string("\\3cfoo\\3e"));
+			CPPUNIT_ASSERT_EQUAL(JID::getEscapedNode("user@host"), std::string("user\\40host"));
+			CPPUNIT_ASSERT_EQUAL(JID::getEscapedNode("c:\\net"), std::string("c\\3a\\net"));
+			CPPUNIT_ASSERT_EQUAL(JID::getEscapedNode("c:\\\\net"), std::string("c\\3a\\\\net"));
+			CPPUNIT_ASSERT_EQUAL(JID::getEscapedNode("c:\\cool stuff"), std::string("c\\3a\\cool\\20stuff"));
+			CPPUNIT_ASSERT_EQUAL(JID::getEscapedNode("c:\\5commas"), std::string("c\\3a\\5c5commas"));
+		}
+
+		void testGetEscapedNode_BackslashAtEnd() {
+			CPPUNIT_ASSERT_EQUAL(std::string("foo\\"), JID::getEscapedNode("foo\\"));
+		}
+
+		void testGetUnescapedNode() {
+			std::string input = "\\& \" ' / <\\\\> @ : \\5c\\40";
+			JID testling(JID::getEscapedNode(input) + "@y");
+			CPPUNIT_ASSERT(testling.isValid());
+			CPPUNIT_ASSERT_EQUAL(input, testling.getUnescapedNode());
+		}
+
+		void testGetUnescapedNode_XEP106Examples() {
+			CPPUNIT_ASSERT_EQUAL(std::string("\\2plus\\2is\\4"), JID("\\2plus\\2is\\4@example.com").getUnescapedNode());
+			CPPUNIT_ASSERT_EQUAL(std::string("foo\\bar"), JID("foo\\bar@example.com").getUnescapedNode());
+			CPPUNIT_ASSERT_EQUAL(std::string("foob\\41r"), JID("foob\\41r@example.com").getUnescapedNode());
+			CPPUNIT_ASSERT_EQUAL(std::string("space cadet"), JID("space\\20cadet@example.com").getUnescapedNode());
+			CPPUNIT_ASSERT_EQUAL(std::string("call me \"ishmael\""), JID("call\\20me\\20\\22ishmael\\22@example.com").getUnescapedNode());
+			CPPUNIT_ASSERT_EQUAL(std::string("at&t guy"), JID("at\\26t\\20guy@example.com").getUnescapedNode());
+			CPPUNIT_ASSERT_EQUAL(std::string("d'artagnan"), JID("d\\27artagnan@example.com").getUnescapedNode());
+			CPPUNIT_ASSERT_EQUAL(std::string("/.fanboy"), JID("\\2f.fanboy@example.com").getUnescapedNode());
+			CPPUNIT_ASSERT_EQUAL(std::string("::foo::"), JID("\\3a\\3afoo\\3a\\3a@example.com").getUnescapedNode());
+			CPPUNIT_ASSERT_EQUAL(std::string("<foo>"), JID("\\3cfoo\\3e@example.com").getUnescapedNode());
+			CPPUNIT_ASSERT_EQUAL(std::string("user@host"), JID("user\\40host@example.com").getUnescapedNode());
+			CPPUNIT_ASSERT_EQUAL(std::string("c:\\net"), JID("c\\3a\\net@example.com").getUnescapedNode());
+			CPPUNIT_ASSERT_EQUAL(std::string("c:\\\\net"), JID("c\\3a\\\\net@example.com").getUnescapedNode());
+			CPPUNIT_ASSERT_EQUAL(std::string("c:\\cool stuff"), JID("c\\3a\\cool\\20stuff@example.com").getUnescapedNode());
+			CPPUNIT_ASSERT_EQUAL(std::string("c:\\5commas"), JID("c\\3a\\5c5commas@example.com").getUnescapedNode());
+		}
 };
 
 CPPUNIT_TEST_SUITE_REGISTRATION(JIDTest);