Merge branch 'swift-1.x'

* swift-1.x: Fixed bug with illegal resource in JID resulting in empty resource. Updated the german translation Conflicts: Swiften/IDN/StringPrep.cpp Swiften/SASL/SCRAMSHA1ClientAuthenticator.cpp
author: Remko Tronçon <git@el-tramo.be> 2011-07-12 18:47:03 (GMT)
committer: Remko Tronçon <git@el-tramo.be> 2011-07-12 18:47:03 (GMT)
commit: 63b311c1bb60469eb5e2ccd2107739e11b189a15 (patch)
tree: 870057043f88e91b71b961a821a4dace859fc839 /Swiften
parent: c6819a5fd632d03cfe72a58922054765c7383aa6 (diff)
parent: 08536b4ed31c30a25a343c3c2619676e67a0c692 (diff)
download: swift-contrib-63b311c1bb60469eb5e2ccd2107739e11b189a15.zip
swift-contrib-63b311c1bb60469eb5e2ccd2107739e11b189a15.tar.bz2
5 files changed, 63 insertions, 28 deletions
diff --git a/Swiften/IDN/StringPrep.cpp b/Swiften/IDN/StringPrep.cpp
index 140e130..db09523 100644
--- a/Swiften/IDN/StringPrep.cpp
+++ b/Swiften/IDN/StringPrep.cpp
@@ -37,17 +37,25 @@ using namespace Swift;
 		else {
 			return ContainerType();
 		}
 	}
 }
 
 namespace Swift {
 
 std::string StringPrep::getPrepared(const std::string& s, Profile profile) {
-	return std::string(vecptr(getStringPrepared< std::string, std::vector<char> >(s, profile)));
+	std::vector<char> preparedData = getStringPrepared< std::string, std::vector<char> >(s, profile);
+	if (preparedData.empty()) {
+		throw std::exception();
+	}
+	return std::string(vecptr(preparedData));
 }
 
 SafeByteArray StringPrep::getPrepared(const SafeByteArray& s, Profile profile) {
-	return createSafeByteArray(reinterpret_cast<const char*>(vecptr(getStringPrepared<SafeByteArray, std::vector<char, SafeAllocator<char> > >(s, profile))));
+	std::vector<char, SafeAllocator<char> > preparedData = getStringPrepared<SafeByteArray, std::vector<char, SafeAllocator<char> > >(s, profile);
+	if (preparedData.empty()) {
+		throw std::exception();
+	}
+	return createSafeByteArray(reinterpret_cast<const char*>(vecptr(preparedData)));
 }
 
 }
diff --git a/Swiften/JID/JID.cpp b/Swiften/JID/JID.cpp
index 2ebbdd6..653ac6a 100644
--- a/Swiften/JID/JID.cpp
+++ b/Swiften/JID/JID.cpp
@@ -104,36 +104,37 @@ struct EscapedCharacterFormatter {
 		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) {
+JID::JID(const char* jid) : valid_(true) {
 	initializeFromString(std::string(jid));
 }
 
-JID::JID(const std::string& jid) {
+JID::JID(const std::string& jid) : valid_(true) {
 	initializeFromString(jid);
 }
 
-JID::JID(const std::string& node, const std::string& domain) : hasResource_(false) {
+JID::JID(const std::string& node, const std::string& domain) : valid_(true), hasResource_(false) {
 	nameprepAndSetComponents(node, domain, "");
 }
 
-JID::JID(const std::string& node, const std::string& domain, const std::string& resource) : hasResource_(true) {
+JID::JID(const std::string& node, const std::string& domain, const std::string& resource) : valid_(true), hasResource_(true) {
 	nameprepAndSetComponents(node, domain, resource);
 }
 
 void JID::initializeFromString(const std::string& jid) {
 	if (String::beginsWith(jid, '@')) {
+		valid_ = false;
 		return;
 	}
 
 	std::string bare, resource;
 	size_t slashIndex = jid.find('/');
 	if (slashIndex != jid.npos) {
 		hasResource_ = true;
 		bare = jid.substr(0, slashIndex);
 		resource = jid.substr(slashIndex + 1, jid.npos);
@@ -147,43 +148,52 @@ void JID::initializeFromString(const std::string& jid) {
 		nameprepAndSetComponents("", nodeAndDomain.first, resource);
 	}
 	else {
 		nameprepAndSetComponents(nodeAndDomain.first, nodeAndDomain.second, resource);
 	}
 }
 
 
 void JID::nameprepAndSetComponents(const std::string& node, const std::string& domain, const std::string& resource) {
+	try {
 #ifndef SWIFTEN_CACHE_JID_PREP
-	node_ = StringPrep::getPrepared(node, StringPrep::NamePrep);
-	domain_ = StringPrep::getPrepared(domain, StringPrep::XMPPNodePrep);
-	resource_ = StringPrep::getPrepared(resource, StringPrep::XMPPResourcePrep);
+		node_ = StringPrep::getPrepared(node, StringPrep::NamePrep);
+		domain_ = StringPrep::getPrepared(domain, StringPrep::XMPPNodePrep);
+		resource_ = StringPrep::getPrepared(resource, StringPrep::XMPPResourcePrep);
 #else
-	std::pair<PrepCache::iterator, bool> r;
+		std::pair<PrepCache::iterator, bool> r;
 
-	r = nodePrepCache.insert(std::make_pair(node, std::string()));
-	if (r.second) {
-		r.first->second = StringPrep::getPrepared(node, StringPrep::NamePrep);
-	}
-	node_ = r.first->second;
+		r = nodePrepCache.insert(std::make_pair(node, std::string()));
+		if (r.second) {
+			r.first->second = StringPrep::getPrepared(node, StringPrep::NamePrep);
+		}
+		node_ = r.first->second;
 
-	r = domainPrepCache.insert(std::make_pair(domain, std::string()));
-	if (r.second) {
-		r.first->second = StringPrep::getPrepared(domain, StringPrep::XMPPNodePrep);
-	}
-	domain_ = r.first->second;
+		r = domainPrepCache.insert(std::make_pair(domain, std::string()));
+		if (r.second) {
+			r.first->second = StringPrep::getPrepared(domain, StringPrep::XMPPNodePrep);
+		}
+		domain_ = r.first->second;
+		if (domain_.empty()) {
+			valid_ = false;
+			return;
+		}
 
-	r = resourcePrepCache.insert(std::make_pair(resource, std::string()));
-	if (r.second) {
-		r.first->second = StringPrep::getPrepared(resource, StringPrep::XMPPResourcePrep);
-	}
-	resource_ = r.first->second;
+		r = resourcePrepCache.insert(std::make_pair(resource, std::string()));
+		if (r.second) {
+			r.first->second = StringPrep::getPrepared(resource, StringPrep::XMPPResourcePrep);
+		}
+		resource_ = r.first->second;
 #endif
+	}
+	catch (const std::exception&) {
+		valid_ = false;
+	}
 }
 
 std::string JID::toString() const {
 	std::string string;
 	if (!node_.empty()) {
 		string += node_ + "@";
 	}
 	string += domain_;
 	if (!isBare()) {
diff --git a/Swiften/JID/JID.h b/Swiften/JID/JID.h
index 756db98..a4461ba 100644
--- a/Swiften/JID/JID.h
+++ b/Swiften/JID/JID.h
@@ -66,19 +66,19 @@ namespace Swift {
 			 * @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 */
+				return valid_;
 			}
 
 			/**
 			 * e.g. JID("node@domain").getNode() == "node"
 			 * @return could be empty.
 			 */
 			const std::string& getNode() const {
 				return node_;
 			}
@@ -156,15 +156,16 @@ namespace Swift {
 			friend bool operator!=(const Swift::JID& a, const Swift::JID& b) {
 				return a.compare(b, Swift::JID::WithResource) != 0;
 			}
 
 		private:
 			void nameprepAndSetComponents(const std::string& node, const std::string& domain, const std::string& resource);
 			void initializeFromString(const std::string&);
 	
 		private:
+			bool valid_;
 			std::string node_;
 			std::string domain_;
 			bool hasResource_;
 			std::string resource_;
 	};
 }
diff --git a/Swiften/JID/UnitTest/JIDTest.cpp b/Swiften/JID/UnitTest/JIDTest.cpp
index 6f7895a..cd21d03 100644
--- a/Swiften/JID/UnitTest/JIDTest.cpp
+++ b/Swiften/JID/UnitTest/JIDTest.cpp
@@ -17,18 +17,19 @@ class JIDTest : public CppUnit::TestFixture
 		CPPUNIT_TEST(testConstructorWithString);
 		CPPUNIT_TEST(testConstructorWithString_NoResource);
 		CPPUNIT_TEST(testConstructorWithString_NoNode);
 		CPPUNIT_TEST(testConstructorWithString_EmptyResource);
 		CPPUNIT_TEST(testConstructorWithString_OnlyDomain);
 		CPPUNIT_TEST(testConstructorWithString_UpperCaseNode);
 		CPPUNIT_TEST(testConstructorWithString_UpperCaseDomain);
 		CPPUNIT_TEST(testConstructorWithString_UpperCaseResource);
 		CPPUNIT_TEST(testConstructorWithString_EmptyNode);
+		CPPUNIT_TEST(testConstructorWithString_IllegalResource);
 		CPPUNIT_TEST(testConstructorWithStrings);
 		CPPUNIT_TEST(testIsBare);
 		CPPUNIT_TEST(testIsBare_NotBare);
 		CPPUNIT_TEST(testToBare);
 		CPPUNIT_TEST(testToBare_EmptyNode);
 		CPPUNIT_TEST(testToBare_EmptyResource);
 		CPPUNIT_TEST(testToString);
 		CPPUNIT_TEST(testToString_EmptyNode);
 		CPPUNIT_TEST(testToString_EmptyResource);
@@ -123,18 +124,24 @@ class JIDTest : public CppUnit::TestFixture
 			CPPUNIT_ASSERT_EQUAL(testling.getResource(), std::string("Fo\xCE\xA9"));
 		}
 
 		void testConstructorWithString_EmptyNode() {
 			JID testling("@bar");
 
 			CPPUNIT_ASSERT(!testling.isValid());
 		}
 
+		void testConstructorWithString_IllegalResource() {
+			JID testling("foo@bar.com/\xd8\xb1\xd9\x85\xd9\x82\xd9\x87\x20\xd8\xaa\xd8\xb1\xd9\x86\xd8\xb3\x20");
+
+			CPPUNIT_ASSERT(!testling.isValid());
+		}
+
 		void testConstructorWithStrings() {
 			JID testling("foo", "bar", "baz");
 
 			CPPUNIT_ASSERT_EQUAL(std::string("foo"), testling.getNode());
 			CPPUNIT_ASSERT_EQUAL(std::string("bar"), testling.getDomain());
 			CPPUNIT_ASSERT_EQUAL(std::string("baz"), testling.getResource());
 		}
 
 		void testIsBare() {
diff --git a/Swiften/SASL/SCRAMSHA1ClientAuthenticator.cpp b/Swiften/SASL/SCRAMSHA1ClientAuthenticator.cpp
index 5fa1f05..20b3d8a 100644
--- a/Swiften/SASL/SCRAMSHA1ClientAuthenticator.cpp
+++ b/Swiften/SASL/SCRAMSHA1ClientAuthenticator.cpp
@@ -94,19 +94,23 @@ bool SCRAMSHA1ClientAuthenticator::setChallenge(const boost::optional<ByteArray>
 			return false;
 		}
 
 		ByteArray channelBindData;
 		if (useChannelBinding && tlsChannelBindingData) {
 			channelBindData = *tlsChannelBindingData;
 		}
 
 		// Compute all the values needed for the server signature
-		saltedPassword = PBKDF2::encode(StringPrep::getPrepared(getPassword(), StringPrep::SASLPrep), salt, iterations);
+		try {
+			saltedPassword = PBKDF2::encode(StringPrep::getPrepared(getPassword(), StringPrep::SASLPrep), salt, iterations);
+		}
+		catch (const std::exception&) {
+		}
 		authMessage = concat(getInitialBareClientMessage(), createByteArray(","), initialServerMessage, createByteArray(","), getFinalMessageWithoutProof());
 		ByteArray serverKey = HMACSHA1::getResult(saltedPassword, createByteArray("Server Key"));
 		serverSignature = HMACSHA1::getResult(serverKey, authMessage);
 
 		step = Proof;
 		return true;
 	}
 	else if (step == Proof) {
 		ByteArray result = concat(createByteArray("v="), createByteArray(Base64::encode(serverSignature)));
@@ -141,19 +145,24 @@ std::map<char, std::string> SCRAMSHA1ClientAuthenticator::parseMap(const std::st
 			}
 			i++;
 		}
 		result[key] = value;
 	}
 	return result;
 }
 
 ByteArray SCRAMSHA1ClientAuthenticator::getInitialBareClientMessage() const {
-	std::string authenticationID = StringPrep::getPrepared(getAuthenticationID(), StringPrep::SASLPrep);
+	std::string authenticationID;
+	try {
+		authenticationID = StringPrep::getPrepared(getAuthenticationID(), StringPrep::SASLPrep);
+	}
+	catch (const std::exception&) {
+	}
 	return createByteArray(std::string("n=" + escape(authenticationID) + ",r=" + clientnonce));
 }
 
 ByteArray SCRAMSHA1ClientAuthenticator::getGS2Header() const {
 	ByteArray channelBindingHeader(createByteArray("n"));
 	if (tlsChannelBindingData) {
 		if (useChannelBinding) {
 			channelBindingHeader = createByteArray("p=tls-unique");
 		}
author	Remko Tronçon <git@el-tramo.be>	2011-07-12 18:47:03 (GMT)
committer	Remko Tronçon <git@el-tramo.be>	2011-07-12 18:47:03 (GMT)
commit	63b311c1bb60469eb5e2ccd2107739e11b189a15 (patch)
tree	870057043f88e91b71b961a821a4dace859fc839 /Swiften
parent	c6819a5fd632d03cfe72a58922054765c7383aa6 (diff)
parent	08536b4ed31c30a25a343c3c2619676e67a0c692 (diff)
download	swift-contrib-63b311c1bb60469eb5e2ccd2107739e11b189a15.zip swift-contrib-63b311c1bb60469eb5e2ccd2107739e11b189a15.tar.bz2