14 files changed, 51 insertions, 30 deletions
diff --git a/Swiften/Serializer/GenericStanzaSerializer.h b/Swiften/Serializer/GenericStanzaSerializer.h
index a85d3ba..e8f3787 100644
--- a/Swiften/Serializer/GenericStanzaSerializer.h
+++ b/Swiften/Serializer/GenericStanzaSerializer.h
@@ -1,32 +1,32 @@
 /*
  * Copyright (c) 2010-2014 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <Swiften/Serializer/StanzaSerializer.h>
 
 namespace Swift {
 	template<typename STANZA_TYPE>
 	class GenericStanzaSerializer : public StanzaSerializer {
 		public:
-			GenericStanzaSerializer(const std::string& tag, PayloadSerializerCollection* payloadSerializers) : StanzaSerializer(tag, payloadSerializers) {}
+			GenericStanzaSerializer(const std::string& tag, PayloadSerializerCollection* payloadSerializers, const boost::optional<std::string>& explicitNS = boost::optional<std::string>()) : StanzaSerializer(tag, payloadSerializers, explicitNS) {}
 
 			virtual bool canSerialize(boost::shared_ptr<ToplevelElement> element) const {
 				return dynamic_cast<STANZA_TYPE*>(element.get()) != 0;
 			}
 
 			virtual void setStanzaSpecificAttributes(
 					boost::shared_ptr<ToplevelElement> stanza, 
 					XMLElement& element) const {
 				setStanzaSpecificAttributesGeneric(
 						boost::dynamic_pointer_cast<STANZA_TYPE>(stanza), element);
 			}
 
 			virtual void setStanzaSpecificAttributesGeneric(
 					boost::shared_ptr<STANZA_TYPE>, 
 					XMLElement&) const = 0;
 	};
 }
diff --git a/Swiften/Serializer/IQSerializer.h b/Swiften/Serializer/IQSerializer.h
index 76a9cb7..7ebafa0 100644
--- a/Swiften/Serializer/IQSerializer.h
+++ b/Swiften/Serializer/IQSerializer.h
@@ -1,31 +1,34 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
+ * Copyright (c) 2010-2014 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <Swiften/Serializer/GenericStanzaSerializer.h>
 #include <Swiften/Elements/IQ.h>
 #include <Swiften/Serializer/XML/XMLElement.h>
 
+#include <boost/optional.hpp>
+
 namespace Swift {
 	class IQSerializer : public GenericStanzaSerializer<IQ> {
 		public:
-			IQSerializer(PayloadSerializerCollection* payloadSerializers) : 
-					GenericStanzaSerializer<IQ>("iq", payloadSerializers) {}
+			IQSerializer(PayloadSerializerCollection* payloadSerializers, const boost::optional<std::string>& explicitNS = boost::optional<std::string>()) :
+					GenericStanzaSerializer<IQ>("iq", payloadSerializers, explicitNS) {
+			}
 
 		private:
 			virtual void setStanzaSpecificAttributesGeneric(
 					boost::shared_ptr<IQ> iq, 
 					XMLElement& element) const {
 				switch (iq->getType()) {
 					case IQ::Get: element.setAttribute("type","get"); break;
 					case IQ::Set: element.setAttribute("type","set"); break;
 					case IQ::Result: element.setAttribute("type","result"); break;
 					case IQ::Error: element.setAttribute("type","error"); break;
 				}
 			}
 	};
 }
diff --git a/Swiften/Serializer/MessageSerializer.cpp b/Swiften/Serializer/MessageSerializer.cpp
index c221680..f944f9b 100644
--- a/Swiften/Serializer/MessageSerializer.cpp
+++ b/Swiften/Serializer/MessageSerializer.cpp
@@ -1,33 +1,33 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
+ * Copyright (c) 2010-2014 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include <Swiften/Serializer/MessageSerializer.h>
 #include <Swiften/Serializer/XML/XMLElement.h>
 
 namespace Swift {
 
-MessageSerializer::MessageSerializer(PayloadSerializerCollection* payloadSerializers) : 
-		GenericStanzaSerializer<Message>("message", payloadSerializers) {
+MessageSerializer::MessageSerializer(PayloadSerializerCollection* payloadSerializers, const boost::optional<std::string>& explicitNS) :
+		GenericStanzaSerializer<Message>("message", payloadSerializers, explicitNS) {
 }
 
 void MessageSerializer::setStanzaSpecificAttributesGeneric(
 		boost::shared_ptr<Message> message, 
 		XMLElement& element) const {
 	if (message->getType() == Message::Chat) {
 		element.setAttribute("type", "chat");
 	}
 	else if (message->getType() == Message::Groupchat) {
 		element.setAttribute("type", "groupchat");
 	}
 	else if (message->getType() == Message::Headline) {
 		element.setAttribute("type", "headline");
 	}
 	else if (message->getType() == Message::Error) {
 		element.setAttribute("type", "error");
 	}
 }
 
 }
diff --git a/Swiften/Serializer/MessageSerializer.h b/Swiften/Serializer/MessageSerializer.h
index 8e9e941..dd8ca21 100644
--- a/Swiften/Serializer/MessageSerializer.h
+++ b/Swiften/Serializer/MessageSerializer.h
@@ -1,24 +1,26 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
+ * Copyright (c) 2010-2014 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <Swiften/Serializer/GenericStanzaSerializer.h>
 #include <Swiften/Elements/Message.h>
 
+#include <boost/optional.hpp>
+
 namespace Swift {
 	class XMLElement;
 
 	class MessageSerializer : public GenericStanzaSerializer<Message> {
 		public:
-			MessageSerializer(PayloadSerializerCollection* payloadSerializers);
+			MessageSerializer(PayloadSerializerCollection* payloadSerializers, const boost::optional<std::string>& explitNS = boost::optional<std::string>());
 
 		private:
 			void setStanzaSpecificAttributesGeneric(
 					boost::shared_ptr<Message> message, 
 					XMLElement& element) const;
 	};
 }
diff --git a/Swiften/Serializer/PresenceSerializer.cpp b/Swiften/Serializer/PresenceSerializer.cpp
index 20eda4b..a192bb5 100644
--- a/Swiften/Serializer/PresenceSerializer.cpp
+++ b/Swiften/Serializer/PresenceSerializer.cpp
@@ -1,33 +1,34 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
+ * Copyright (c) 2010-2014 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include <Swiften/Serializer/PresenceSerializer.h>
 #include <Swiften/Serializer/XML/XMLElement.h>
-
+#include <Swiften/Base/Log.h>
 #include <boost/shared_ptr.hpp>
 
 namespace Swift {
 
-PresenceSerializer::PresenceSerializer(PayloadSerializerCollection* payloadSerializers) : 
-		GenericStanzaSerializer<Presence>("presence", payloadSerializers) {
+PresenceSerializer::PresenceSerializer(PayloadSerializerCollection* payloadSerializers, const boost::optional<std::string>& explicitNS) :
+		GenericStanzaSerializer<Presence>("presence", payloadSerializers, explicitNS) {
+
 }
 
 void PresenceSerializer::setStanzaSpecificAttributesGeneric(
 		boost::shared_ptr<Presence> presence, 
 		XMLElement& element) const {
 	switch (presence->getType()) {
 		case Presence::Unavailable: element.setAttribute("type","unavailable"); break;
 		case Presence::Probe: element.setAttribute("type","probe"); break;
 		case Presence::Subscribe: element.setAttribute("type","subscribe"); break;
 		case Presence::Subscribed: element.setAttribute("type","subscribed"); break;
 		case Presence::Unsubscribe: element.setAttribute("type","unsubscribe"); break;
 		case Presence::Unsubscribed: element.setAttribute("type","unsubscribed"); break;
 		case Presence::Error: element.setAttribute("type","error"); break;
 		case Presence::Available: break;
 	}
 }
 
 }
diff --git a/Swiften/Serializer/PresenceSerializer.h b/Swiften/Serializer/PresenceSerializer.h
index e5d9f30..b3ed721 100644
--- a/Swiften/Serializer/PresenceSerializer.h
+++ b/Swiften/Serializer/PresenceSerializer.h
@@ -1,22 +1,25 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
+ * Copyright (c) 2010-2014 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <Swiften/Serializer/GenericStanzaSerializer.h>
 #include <Swiften/Elements/Presence.h>
 
+#include <boost/optional.hpp>
+
 namespace Swift {
 	class PresenceSerializer : public GenericStanzaSerializer<Presence> {
 		public:
-			PresenceSerializer(PayloadSerializerCollection* payloadSerializers);
+			PresenceSerializer(PayloadSerializerCollection* payloadSerializers, const boost::optional<std::string>& explicitNS = boost::optional<std::string>());
+			~PresenceSerializer() {}
 
 		private:
 			virtual void setStanzaSpecificAttributesGeneric(
 					boost::shared_ptr<Presence> presence, 
 					XMLElement& element) const;
 	};
 }
diff --git a/Swiften/Serializer/StanzaSerializer.cpp b/Swiften/Serializer/StanzaSerializer.cpp
index 358e4b8..d097bbf 100644
--- a/Swiften/Serializer/StanzaSerializer.cpp
+++ b/Swiften/Serializer/StanzaSerializer.cpp
@@ -1,61 +1,66 @@
 /*
  * Copyright (c) 2010-2014 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include <Swiften/Serializer/StanzaSerializer.h>
 
 #include <sstream>
 #include <typeinfo>
 #include <iostream>
 
 #include <Swiften/Base/foreach.h>
 #include <Swiften/Serializer/XML/XMLElement.h>
 #include <Swiften/Serializer/XML/XMLRawTextNode.h>
 #include <Swiften/Serializer/PayloadSerializer.h>
 #include <Swiften/Serializer/PayloadSerializerCollection.h>
 #include <Swiften/Elements/Stanza.h>
 
 namespace Swift {
 
-StanzaSerializer::StanzaSerializer(const std::string& tag, PayloadSerializerCollection* payloadSerializers) : tag_(tag), payloadSerializers_(payloadSerializers) {
+StanzaSerializer::StanzaSerializer(const std::string& tag, PayloadSerializerCollection* payloadSerializers, const boost::optional<std::string>& explicitNS) : tag_(tag), payloadSerializers_(payloadSerializers), explicitDefaultNS_(explicitNS) {
 }
 
 SafeByteArray StanzaSerializer::serialize(boost::shared_ptr<ToplevelElement> element) const {
-	return serialize(element, "");
+	if (explicitDefaultNS_) {
+		return serialize(element, explicitDefaultNS_.get());
+	}
+	else {
+		return serialize(element, "");
+	}
 }
 
 SafeByteArray StanzaSerializer::serialize(boost::shared_ptr<ToplevelElement> element, const std::string& xmlns) const {
 	boost::shared_ptr<Stanza> stanza(boost::dynamic_pointer_cast<Stanza>(element));
 
-	XMLElement stanzaElement(tag_, xmlns);
+	XMLElement stanzaElement(tag_, explicitDefaultNS_ ? explicitDefaultNS_.get() : xmlns);
 	if (stanza->getFrom().isValid()) {
 		stanzaElement.setAttribute("from", stanza->getFrom());
 	}
 	if (stanza->getTo().isValid()) {
 		stanzaElement.setAttribute("to", stanza->getTo());
 	}
 	if (!stanza->getID().empty()) {
 		stanzaElement.setAttribute("id", stanza->getID());
 	}
 	setStanzaSpecificAttributes(stanza, stanzaElement);
 
 	std::string serializedPayloads;
 	foreach (const boost::shared_ptr<Payload>& payload, stanza->getPayloads()) {
 		PayloadSerializer* serializer = payloadSerializers_->getPayloadSerializer(payload);
 		if (serializer) {
 			serializedPayloads += serializer->serialize(payload);
 		}
 		else {
 			std::cerr << "Could not find serializer for " << typeid(*(payload.get())).name() << std::endl;
 		}
 	}
 	if (!serializedPayloads.empty()) {
 		stanzaElement.addNode(boost::shared_ptr<XMLNode>(new XMLRawTextNode(serializedPayloads)));
 	}
 
 	return createSafeByteArray(stanzaElement.serialize());
 }
 
 }
diff --git a/Swiften/Serializer/StanzaSerializer.h b/Swiften/Serializer/StanzaSerializer.h
index 6b46670..766b58c 100644
--- a/Swiften/Serializer/StanzaSerializer.h
+++ b/Swiften/Serializer/StanzaSerializer.h
@@ -1,29 +1,32 @@
 /*
  * Copyright (c) 2013-2014 Kevin Smith and Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <Swiften/Elements/Stanza.h>
 #include <Swiften/Serializer/ElementSerializer.h>
+
 #include <string>
+#include <boost/optional.hpp>
 
 namespace Swift {
 	class PayloadSerializerCollection;
 	class XMLElement;
 
 	class StanzaSerializer : public ElementSerializer {
 		public:
-			StanzaSerializer(const std::string& tag, PayloadSerializerCollection* payloadSerializers);
+			StanzaSerializer(const std::string& tag, PayloadSerializerCollection* payloadSerializers, const boost::optional<std::string>& explicitNS = boost::optional<std::string>());
 
 			virtual SafeByteArray serialize(boost::shared_ptr<ToplevelElement> element) const;
 			virtual SafeByteArray serialize(boost::shared_ptr<ToplevelElement> element, const std::string& xmlns) const;
 			virtual void setStanzaSpecificAttributes(boost::shared_ptr<ToplevelElement>, XMLElement&) const = 0;
 
 		private:
 			std::string tag_;
 			PayloadSerializerCollection* payloadSerializers_;
+			boost::optional<std::string> explicitDefaultNS_;
 	};
 }
diff --git a/Swiften/Serializer/UnitTest/XMPPSerializerTest.cpp b/Swiften/Serializer/UnitTest/XMPPSerializerTest.cpp
index c0ab841..83daf36 100644
--- a/Swiften/Serializer/UnitTest/XMPPSerializerTest.cpp
+++ b/Swiften/Serializer/UnitTest/XMPPSerializerTest.cpp
@@ -1,75 +1,75 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
+ * Copyright (c) 2010-2014 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
 #include <Swiften/Serializer/XMPPSerializer.h>
 #include <Swiften/Elements/AuthChallenge.h>
 #include <Swiften/Serializer/PayloadSerializerCollection.h>
 #include <Swiften/Elements/ProtocolHeader.h>
 
 using namespace Swift;
 
 class XMPPSerializerTest : public CppUnit::TestFixture {
 		CPPUNIT_TEST_SUITE(XMPPSerializerTest);
 		CPPUNIT_TEST(testSerializeHeader_Client);
 		CPPUNIT_TEST(testSerializeHeader_Component);
 		CPPUNIT_TEST(testSerializeHeader_Server);
 		CPPUNIT_TEST_SUITE_END();
 
 	public:
 		void setUp() {
 			payloadSerializerCollection = new PayloadSerializerCollection();
 		}
 
 		void tearDown() {
 			delete payloadSerializerCollection;
 		}
 
 		void testSerializeHeader_Client() {
 			boost::shared_ptr<XMPPSerializer> testling(createSerializer(ClientStreamType));
 			ProtocolHeader protocolHeader;
 			protocolHeader.setFrom("bla@foo.com");
 			protocolHeader.setTo("foo.com");
 			protocolHeader.setID("myid");
 			protocolHeader.setVersion("0.99");
 
 			CPPUNIT_ASSERT_EQUAL(std::string("<?xml version=\"1.0\"?><stream:stream xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" from=\"bla@foo.com\" to=\"foo.com\" id=\"myid\" version=\"0.99\">"), testling->serializeHeader(protocolHeader));
 		}
 
 		void testSerializeHeader_Component() {
 			boost::shared_ptr<XMPPSerializer> testling(createSerializer(ComponentStreamType));
 			ProtocolHeader protocolHeader;
 			protocolHeader.setFrom("bla@foo.com");
 			protocolHeader.setTo("foo.com");
 			protocolHeader.setID("myid");
 			protocolHeader.setVersion("0.99");
 
 			CPPUNIT_ASSERT_EQUAL(std::string("<?xml version=\"1.0\"?><stream:stream xmlns=\"jabber:component:accept\" xmlns:stream=\"http://etherx.jabber.org/streams\" from=\"bla@foo.com\" to=\"foo.com\" id=\"myid\" version=\"0.99\">"), testling->serializeHeader(protocolHeader));
 		}
 
 		void testSerializeHeader_Server() {
 			boost::shared_ptr<XMPPSerializer> testling(createSerializer(ServerStreamType));
 			ProtocolHeader protocolHeader;
 			protocolHeader.setFrom("bla@foo.com");
 			protocolHeader.setTo("foo.com");
 			protocolHeader.setID("myid");
 			protocolHeader.setVersion("0.99");
 
 			CPPUNIT_ASSERT_EQUAL(std::string("<?xml version=\"1.0\"?><stream:stream xmlns=\"jabber:server\" xmlns:stream=\"http://etherx.jabber.org/streams\" from=\"bla@foo.com\" to=\"foo.com\" id=\"myid\" version=\"0.99\">"), testling->serializeHeader(protocolHeader));
 		}
 
 	private:
 		XMPPSerializer* createSerializer(StreamType type) {
-			return new XMPPSerializer(payloadSerializerCollection, type);
+			return new XMPPSerializer(payloadSerializerCollection, type, false);
 		}
 
 	private:
 		PayloadSerializerCollection* payloadSerializerCollection;
 };
 
 CPPUNIT_TEST_SUITE_REGISTRATION(XMPPSerializerTest);
diff --git a/Swiften/Serializer/XMPPSerializer.cpp b/Swiften/Serializer/XMPPSerializer.cpp
index e3f43cd..1fb79e4 100644
--- a/Swiften/Serializer/XMPPSerializer.cpp
+++ b/Swiften/Serializer/XMPPSerializer.cpp
@@ -7,74 +7,74 @@
 #include <Swiften/Serializer/XMPPSerializer.h>
 
 #include <boost/bind.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 #include <iostream>
 #include <cassert>
 
 #include <Swiften/Elements/ProtocolHeader.h>
 #include <Swiften/Base/foreach.h>
 #include <Swiften/Serializer/CompressRequestSerializer.h>
 #include <Swiften/Serializer/CompressFailureSerializer.h>
 #include <Swiften/Serializer/StreamErrorSerializer.h>
 #include <Swiften/Serializer/StreamFeaturesSerializer.h>
 #include <Swiften/Serializer/AuthRequestSerializer.h>
 #include <Swiften/Serializer/AuthFailureSerializer.h>
 #include <Swiften/Serializer/AuthSuccessSerializer.h>
 #include <Swiften/Serializer/AuthChallengeSerializer.h>
 #include <Swiften/Serializer/AuthResponseSerializer.h>
 #include <Swiften/Serializer/EnableStreamManagementSerializer.h>
 #include <Swiften/Serializer/StreamManagementEnabledSerializer.h>
 #include <Swiften/Serializer/StreamResumeSerializer.h>
 #include <Swiften/Serializer/StreamResumedSerializer.h>
 #include <Swiften/Serializer/StreamManagementFailedSerializer.h>
 #include <Swiften/Serializer/StanzaAckSerializer.h>
 #include <Swiften/Serializer/StanzaAckRequestSerializer.h>
 #include <Swiften/Serializer/StartTLSRequestSerializer.h>
 #include <Swiften/Serializer/StartTLSFailureSerializer.h>
 #include <Swiften/Serializer/TLSProceedSerializer.h>
 #include <Swiften/Serializer/MessageSerializer.h>
 #include <Swiften/Serializer/PresenceSerializer.h>
 #include <Swiften/Serializer/IQSerializer.h>
 #include <Swiften/Serializer/ComponentHandshakeSerializer.h>
 
 namespace Swift {
 
-XMPPSerializer::XMPPSerializer(PayloadSerializerCollection* payloadSerializers, StreamType type) : type_(type) {
-	serializers_.push_back(boost::make_shared<PresenceSerializer>(payloadSerializers));
-	serializers_.push_back(boost::make_shared<IQSerializer>(payloadSerializers));
-	serializers_.push_back(boost::make_shared<MessageSerializer>(payloadSerializers));
+XMPPSerializer::XMPPSerializer(PayloadSerializerCollection* payloadSerializers, StreamType type, bool setExplictNSonTopLevelElements) : type_(type) {
+	serializers_.push_back(boost::make_shared<PresenceSerializer>(payloadSerializers, setExplictNSonTopLevelElements ? getDefaultNamespace() : boost::optional<std::string>()));
+	serializers_.push_back(boost::make_shared<IQSerializer>(payloadSerializers, setExplictNSonTopLevelElements ? getDefaultNamespace() : boost::optional<std::string>()));
+	serializers_.push_back(boost::make_shared<MessageSerializer>(payloadSerializers, setExplictNSonTopLevelElements ? getDefaultNamespace() : boost::optional<std::string>()));
 	serializers_.push_back(boost::make_shared<CompressRequestSerializer>());
 	serializers_.push_back(boost::make_shared<CompressFailureSerializer>());
 	serializers_.push_back(boost::make_shared<AuthRequestSerializer>());
 	serializers_.push_back(boost::make_shared<AuthFailureSerializer>());
 	serializers_.push_back(boost::make_shared<AuthSuccessSerializer>());
 	serializers_.push_back(boost::make_shared<AuthChallengeSerializer>());
 	serializers_.push_back(boost::make_shared<AuthResponseSerializer>());
 	serializers_.push_back(boost::make_shared<StartTLSRequestSerializer>());
 	serializers_.push_back(boost::make_shared<StartTLSFailureSerializer>());
 	serializers_.push_back(boost::make_shared<TLSProceedSerializer>());
 	serializers_.push_back(boost::make_shared<StreamFeaturesSerializer>());
 	serializers_.push_back(boost::make_shared<StreamErrorSerializer>());
 	serializers_.push_back(boost::make_shared<EnableStreamManagementSerializer>());
 	serializers_.push_back(boost::make_shared<StreamManagementEnabledSerializer>());
 	serializers_.push_back(boost::make_shared<StreamManagementFailedSerializer>());
 	serializers_.push_back(boost::make_shared<StreamResumeSerializer>());
 	serializers_.push_back(boost::make_shared<StreamResumedSerializer>());
 	serializers_.push_back(boost::make_shared<StanzaAckSerializer>());
 	serializers_.push_back(boost::make_shared<StanzaAckRequestSerializer>());
 	serializers_.push_back(boost::make_shared<ComponentHandshakeSerializer>());
 }
 
 std::string XMPPSerializer::serializeHeader(const ProtocolHeader& header) const {
 	std::string result = "<?xml version=\"1.0\"?><stream:stream xmlns=\"" + getDefaultNamespace() + "\" xmlns:stream=\"http://etherx.jabber.org/streams\"";
 	if (!header.getFrom().empty()) {
 		result += " from=\"" + header.getFrom() + "\"";
 	}
 	if (!header.getTo().empty()) {
 		result += " to=\"" + header.getTo() + "\"";
 	}
 	if (!header.getID().empty()) {
 		result += " id=\"" + header.getID() + "\"";
 	}
 	if (!header.getVersion().empty()) {
 		result += " version=\"" + header.getVersion() + "\"";
diff --git a/Swiften/Serializer/XMPPSerializer.h b/Swiften/Serializer/XMPPSerializer.h
index cbcdccb..d1aa386 100644
--- a/Swiften/Serializer/XMPPSerializer.h
+++ b/Swiften/Serializer/XMPPSerializer.h
@@ -1,38 +1,38 @@
 /*
  * Copyright (c) 2010-2014 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <boost/shared_ptr.hpp>
 #include <vector>
 
 #include <Swiften/Base/API.h>
 #include <Swiften/Elements/ToplevelElement.h>
 #include <Swiften/Elements/StreamType.h>
 #include <string>
 #include <Swiften/Serializer/ElementSerializer.h>
 
 namespace Swift {
 	class PayloadSerializerCollection;
 	class CompressRequestSerializer;
 	class ProtocolHeader;
 
 	class SWIFTEN_API XMPPSerializer {
 		public:
-			XMPPSerializer(PayloadSerializerCollection*, StreamType type);
+			XMPPSerializer(PayloadSerializerCollection*, StreamType type, bool setExplictNSonTopLevelElements);
 
 			std::string serializeHeader(const ProtocolHeader&) const;
 			SafeByteArray serializeElement(boost::shared_ptr<ToplevelElement> stanza) const;
 			std::string serializeFooter() const;
 		
 		private:
 			std::string getDefaultNamespace() const;
 
 		private:
 			StreamType type_;
 			std::vector< boost::shared_ptr<ElementSerializer> > serializers_;
 	};
 }
diff --git a/Swiften/Session/BOSHSessionStream.cpp b/Swiften/Session/BOSHSessionStream.cpp
index 8cdbdb0..63e35b8 100644
--- a/Swiften/Session/BOSHSessionStream.cpp
+++ b/Swiften/Session/BOSHSessionStream.cpp
@@ -24,71 +24,71 @@
 #include <Swiften/TLS/TLSContext.h>
 #include <Swiften/EventLoop/EventLoop.h>
 
 namespace Swift {
 
 BOSHSessionStream::BOSHSessionStream(
 		const URL& boshURL,
 		PayloadParserFactoryCollection* payloadParserFactories, 
 		PayloadSerializerCollection* payloadSerializers, 
 		ConnectionFactory* connectionFactory,
 		TLSContextFactory* tlsContextFactory, 
 		TimerFactory* timerFactory,
 		XMLParserFactory* xmlParserFactory,
 		EventLoop* eventLoop,
 		DomainNameResolver* resolver,
 		const std::string& to,
 		const URL& boshHTTPConnectProxyURL,
 		const SafeString& boshHTTPConnectProxyAuthID,
 		const SafeString& boshHTTPConnectProxyAuthPassword) :
 			available(false), 
 			eventLoop(eventLoop),
 			firstHeader(true) {
 
 	boost::mt19937 random;
 	boost::uniform_int<unsigned long long> dist(0, (1LL<<53) - 1);
 	random.seed(static_cast<unsigned int>(time(NULL)));
 	unsigned long long initialRID = boost::variate_generator<boost::mt19937&, boost::uniform_int<unsigned long long> >(random, dist)();
 
 	connectionPool = new BOSHConnectionPool(boshURL, resolver, connectionFactory, xmlParserFactory, tlsContextFactory, timerFactory, eventLoop, to, initialRID, boshHTTPConnectProxyURL, boshHTTPConnectProxyAuthID, boshHTTPConnectProxyAuthPassword);
 	connectionPool->onSessionTerminated.connect(boost::bind(&BOSHSessionStream::handlePoolSessionTerminated, this, _1));
 	connectionPool->onSessionStarted.connect(boost::bind(&BOSHSessionStream::handlePoolSessionStarted, this));
 	connectionPool->onXMPPDataRead.connect(boost::bind(&BOSHSessionStream::handlePoolXMPPDataRead, this, _1));
 	connectionPool->onBOSHDataRead.connect(boost::bind(&BOSHSessionStream::handlePoolBOSHDataRead, this, _1));
 	connectionPool->onBOSHDataWritten.connect(boost::bind(&BOSHSessionStream::handlePoolBOSHDataWritten, this, _1));
 
-	xmppLayer = new XMPPLayer(payloadParserFactories, payloadSerializers, xmlParserFactory, ClientStreamType);
+	xmppLayer = new XMPPLayer(payloadParserFactories, payloadSerializers, xmlParserFactory, ClientStreamType, true);
 	xmppLayer->onStreamStart.connect(boost::bind(&BOSHSessionStream::handleStreamStartReceived, this, _1));
 	xmppLayer->onElement.connect(boost::bind(&BOSHSessionStream::handleElementReceived, this, _1));
 	xmppLayer->onError.connect(boost::bind(&BOSHSessionStream::handleXMPPError, this));
 	xmppLayer->onWriteData.connect(boost::bind(&BOSHSessionStream::handleXMPPLayerDataWritten, this, _1));
 
 	available = true;
 }
 
 BOSHSessionStream::~BOSHSessionStream() {
 	close();
 	connectionPool->onSessionTerminated.disconnect(boost::bind(&BOSHSessionStream::handlePoolSessionTerminated, this, _1));
 	connectionPool->onSessionStarted.disconnect(boost::bind(&BOSHSessionStream::handlePoolSessionStarted, this));
 	connectionPool->onXMPPDataRead.disconnect(boost::bind(&BOSHSessionStream::handlePoolXMPPDataRead, this, _1));
 	connectionPool->onBOSHDataRead.disconnect(boost::bind(&BOSHSessionStream::handlePoolBOSHDataRead, this, _1));
 	connectionPool->onBOSHDataWritten.disconnect(boost::bind(&BOSHSessionStream::handlePoolBOSHDataWritten, this, _1));
 	delete connectionPool;
 	connectionPool = NULL;
 	xmppLayer->onStreamStart.disconnect(boost::bind(&BOSHSessionStream::handleStreamStartReceived, this, _1));
 	xmppLayer->onElement.disconnect(boost::bind(&BOSHSessionStream::handleElementReceived, this, _1));
 	xmppLayer->onError.disconnect(boost::bind(&BOSHSessionStream::handleXMPPError, this));
 	xmppLayer->onWriteData.disconnect(boost::bind(&BOSHSessionStream::handleXMPPLayerDataWritten, this, _1));
 	delete xmppLayer;
 	xmppLayer = NULL;
 }
 
 void BOSHSessionStream::handlePoolXMPPDataRead(const SafeByteArray& data) {
 	xmppLayer->handleDataRead(data);
 }
 
 void BOSHSessionStream::writeElement(boost::shared_ptr<ToplevelElement> element) {
 	assert(available);
 	xmppLayer->writeElement(element);
 }
 
 void BOSHSessionStream::writeFooter() {
diff --git a/Swiften/StreamStack/XMPPLayer.cpp b/Swiften/StreamStack/XMPPLayer.cpp
index 59418a2..1f06b06 100644
--- a/Swiften/StreamStack/XMPPLayer.cpp
+++ b/Swiften/StreamStack/XMPPLayer.cpp
@@ -1,60 +1,62 @@
 /*
  * Copyright (c) 2010-2014 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include <Swiften/StreamStack/XMPPLayer.h>
 #include <Swiften/Parser/XMPPParser.h>
 #include <Swiften/Serializer/XMPPSerializer.h>
 #include <Swiften/Elements/ProtocolHeader.h>
 
 namespace Swift {
 
 XMPPLayer::XMPPLayer(
 		PayloadParserFactoryCollection* payloadParserFactories,
 		PayloadSerializerCollection* payloadSerializers,
 		XMLParserFactory* xmlParserFactory,
-		StreamType streamType) :
+		StreamType streamType,
+		bool setExplictNSonTopLevelElements) :
 			payloadParserFactories_(payloadParserFactories), 
 			payloadSerializers_(payloadSerializers),
 			xmlParserFactory_(xmlParserFactory),
+			setExplictNSonTopLevelElements_(setExplictNSonTopLevelElements),
 			resetParserAfterParse_(false),
 			inParser_(false) {
 	xmppParser_ = new XMPPParser(this, payloadParserFactories_, xmlParserFactory);
-	xmppSerializer_ = new XMPPSerializer(payloadSerializers_, streamType);
+	xmppSerializer_ = new XMPPSerializer(payloadSerializers_, streamType, setExplictNSonTopLevelElements);
 }
 
 XMPPLayer::~XMPPLayer() {
 	delete xmppSerializer_;
 	delete xmppParser_;
 }
 
 void XMPPLayer::writeHeader(const ProtocolHeader& header) {
 	writeDataInternal(createSafeByteArray(xmppSerializer_->serializeHeader(header)));
 }
 
 void XMPPLayer::writeFooter() {
 	writeDataInternal(createSafeByteArray(xmppSerializer_->serializeFooter()));
 }
 
 void XMPPLayer::writeElement(boost::shared_ptr<ToplevelElement> element) {
 	writeDataInternal(xmppSerializer_->serializeElement(element));
 }
 
 void XMPPLayer::writeData(const std::string& data) {
 	writeDataInternal(createSafeByteArray(data));
 }
 
 void XMPPLayer::writeDataInternal(const SafeByteArray& data) {
 	onWriteData(data);
 	writeDataToChildLayer(data);
 }
 
 void XMPPLayer::handleDataRead(const SafeByteArray& data) {
 	onDataRead(data);
 	inParser_ = true;
 	// FIXME: Converting to unsafe string. Should be ok, since we don't take passwords
 	// from the stream in clients. If servers start using this, and require safe storage,
 	// we need to fix this.
 	if (!xmppParser_->parse(byteArrayToString(ByteArray(data.begin(), data.end())))) {
diff --git a/Swiften/StreamStack/XMPPLayer.h b/Swiften/StreamStack/XMPPLayer.h
index bb0e498..13266e4 100644
--- a/Swiften/StreamStack/XMPPLayer.h
+++ b/Swiften/StreamStack/XMPPLayer.h
@@ -1,73 +1,75 @@
 /*
  * Copyright (c) 2010-2014 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <boost/shared_ptr.hpp>
 #include <Swiften/Base/boost_bsignals.h>
 #include <boost/noncopyable.hpp>
 
 #include <Swiften/Base/API.h>
 #include <Swiften/StreamStack/HighLayer.h>
 #include <Swiften/Base/SafeByteArray.h>
 #include <Swiften/Elements/ToplevelElement.h>
 #include <Swiften/Elements/StreamType.h>
 #include <Swiften/Parser/XMPPParserClient.h>
 
 namespace Swift {
 	class ProtocolHeader;
 	class XMPPParser;
 	class PayloadParserFactoryCollection;
 	class XMPPSerializer;
 	class PayloadSerializerCollection;
 	class XMLParserFactory;
 	class BOSHSessionStream;
 
 	class SWIFTEN_API XMPPLayer : public XMPPParserClient, public HighLayer, boost::noncopyable {
 		friend class BOSHSessionStream;
 		public:
 			XMPPLayer(
 					PayloadParserFactoryCollection* payloadParserFactories,
 					PayloadSerializerCollection* payloadSerializers,
 					XMLParserFactory* xmlParserFactory,
-					StreamType streamType);
+					StreamType streamType,
+					bool setExplictNSonTopLevelElements = false);
 			~XMPPLayer();
 
 			void writeHeader(const ProtocolHeader& header);
 			void writeFooter();
 			void writeElement(boost::shared_ptr<ToplevelElement>);
 			void writeData(const std::string& data);
 
 			void resetParser();
 
 		protected:
 			void handleDataRead(const SafeByteArray& data);
 			void writeDataInternal(const SafeByteArray& data);
 
 		public:
 			boost::signal<void (const ProtocolHeader&)> onStreamStart;
 			boost::signal<void (boost::shared_ptr<ToplevelElement>)> onElement;
 			boost::signal<void (const SafeByteArray&)> onWriteData;
 			boost::signal<void (const SafeByteArray&)> onDataRead;
 			boost::signal<void ()> onError;
 
 		private:
 			void handleStreamStart(const ProtocolHeader&);
 			void handleElement(boost::shared_ptr<ToplevelElement>);
 			void handleStreamEnd();
 
 			void doResetParser();
 
 		private:
 			PayloadParserFactoryCollection* payloadParserFactories_;
 			XMPPParser* xmppParser_;
 			PayloadSerializerCollection* payloadSerializers_;
 			XMLParserFactory* xmlParserFactory_;
 			XMPPSerializer* xmppSerializer_;
+			bool setExplictNSonTopLevelElements_;
 			bool resetParserAfterParse_;
 			bool inParser_;
 	};
 }