UserRegistry *userRegistry,

		const JID& jid,

		const std::string &address,

		int port) :

			userRegistry_(userRegistry),

			port_(port),

			eventLoop(eventLoop),

			networkFactories_(networkFactories),

			stopping(false),

			selfJID(jid),

			stanzaChannel_(),

			address_(address){

	iqRouter_ = new IQRouter(stanzaChannel_);

	tlsFactory = NULL;

	parserFactory_ = new PlatformXMLParserFactory();

}

Server::~Server() {

	stop();

	delete iqRouter_;

	delete stanzaChannel_;

	delete parserFactory_;

}

		}

	}

}

std::string ServerStanzaChannel::getNewIQID() {

	return idGenerator.generateID();

}

void ServerStanzaChannel::send(boost::shared_ptr<Stanza> stanza) {

	JID to = stanza->getTo();

	assert(to.isValid());

	// For a full JID, first try to route to a session with the full JID

	if (!to.isBare()) {

		std::list<boost::shared_ptr<ServerFromClientSession> >::const_iterator i = std::find_if(sessions[stanza->getTo().toBare().toString()].begin(), sessions[stanza->getTo().toBare().toString()].end(), HasJID(to));

		if (i != sessions[stanza->getTo().toBare().toString()].end()) {

			(*i)->sendElement(stanza);

			return;

		}

	}

	// Look for candidate sessions

	to = to.toBare();

	std::vector<boost::shared_ptr<ServerFromClientSession> > candidateSessions;

#include "Swiften/Client/StanzaChannel.h"

#include "Swiften/Elements/Message.h"

#include "Swiften/Elements/IQ.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/TLS/Certificate.h"

#include <Swiften/Version.h>

#define HAVE_SWIFTEN_3  (SWIFTEN_VERSION >= 0x030000)

namespace Swift {

	class Error;

	class ServerStanzaChannel : public StanzaChannel {

		public:

			void addSession(boost::shared_ptr<ServerFromClientSession> session);

			void removeSession(boost::shared_ptr<ServerFromClientSession> session);

			void sendIQ(boost::shared_ptr<IQ> iq);

			void sendMessage(boost::shared_ptr<Message> message);

			void sendPresence(boost::shared_ptr<Presence> presence);

#if HAVE_SWIFTEN_3

			void finishSession(const JID& to, boost::shared_ptr<ToplevelElement> element, bool last = false);

#else

			void finishSession(const JID& to, boost::shared_ptr<Element> element, bool last = false);

#endif

			bool getStreamManagementEnabled() const {

				return std::vector<Certificate::ref>();

			}

		private:

			std::string getNewIQID();

			void send(boost::shared_ptr<Stanza> stanza);

			void handleSessionFinished(const boost::optional<Session::SessionError>&, const boost::shared_ptr<ServerFromClientSession> &session);

			void handleElement(boost::shared_ptr<Element> element, const boost::shared_ptr<ServerFromClientSession> &session);

			void handleDataRead(const SafeByteArray &data, const boost::shared_ptr<ServerFromClientSession> &session);

			void handleSessionInitialized();

		private:

			IDGenerator idGenerator;

			// [JID][resources][ServerFromClientSession]

			std::map<std::string, std::list<boost::shared_ptr<ServerFromClientSession> > > sessions;

	};

}

#include "XMPPUserRegistration.h"

#include "transport/User.h"

#include "transport/Transport.h"

#include "transport/StorageBackend.h"

#include "transport/Logging.h"

#include "transport/Frontend.h"

#include "storageresponder.h"

#include "vcardresponder.h"

#include "XMPPFrontend.h"

#include "gatewayresponder.h"

#include "adhocmanager.h"

#include "settingsadhoccommand.h"

#include "Swiften/Server/ServerStanzaChannel.h"

#include "Swiften/Elements/StreamError.h"

#include "Swiften/Elements/MUCPayload.h"

#include "Swiften/Elements/ChatState.h"

#ifndef __FreeBSD__ 

#ifndef __MACH__

#include "malloc.h"

#endif

#endif

// #include "valgrind/memcheck.h"

		m_userRegistration->start();

	}

	else {

		m_userRegistration = NULL;

	}

// 	StatsResponder statsResponder(component, this, &plugin, storageBackend);

// 	statsResponder.start();

	m_gatewayResponder = new GatewayResponder(frontend->getIQRouter(), this);

	m_gatewayResponder->start();

	m_adHocManager = new AdHocManager(component, frontend->getDiscoItemsResponder(), this, storageBackend);

	m_adHocManager->start();

	SettingsAdHocCommandFactory *m_settings = new SettingsAdHocCommandFactory();

	m_adHocManager->addAdHocCommand(m_settings);

}

XMPPUserManager::~XMPPUserManager() {

	if (m_storageResponder) {

		m_storageResponder->stop();

		delete m_storageResponder;

	}

	if (m_userRegistration) {

		m_userRegistration->stop();

		delete m_userRegistration;

	}

	delete m_gatewayResponder;

	delete m_adHocManager;

	delete m_settings;

	delete m_vcardResponder;

}

void XMPPUserManager::sendVCard(unsigned int id, Swift::VCard::ref vcard) {

	m_vcardResponder->sendVCard(id, vcard);

}

void XMPPUserManager::handleVCardRequired(User *user, const std::string &name, unsigned int id) {

	m_component->getFrontend()->onVCardRequired(user, name, id);

}

void XMPPUserManager::handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> vcard) {

	m_component->getFrontend()->onVCardUpdated(user, vcard);

#include "Swiften/Network/Timer.h"

namespace Transport {

class Component;

class StorageBackend;

class StorageResponder;

class VCardResponder;

class XMPPUserRegistration;

class GatewayResponder;

class AdHocManager;

class SettingsAdHocCommandFactory;

class XMPPUserManager : public UserManager {

	public:

		XMPPUserManager(Component *component, UserRegistry *userRegistry, StorageBackend *storageBackend = NULL);

		virtual ~XMPPUserManager();

		virtual void sendVCard(unsigned int id, Swift::VCard::ref vcard);

		UserRegistration *getUserRegistration();

	private:

		void handleVCardRequired(User *, const std::string &name, unsigned int id);

		void handleVCardUpdated(User *, boost::shared_ptr<Swift::VCard> vcard);

		StorageResponder *m_storageResponder;

		VCardResponder *m_vcardResponder;

		Component *m_component;

		XMPPUserRegistration *m_userRegistration;

		GatewayResponder *m_gatewayResponder;

		AdHocManager *m_adHocManager;

		SettingsAdHocCommandFactory *m_settings;

};

}

		self.room = room

		self.nick = nick

		self.echo_received = False

		self.add_event_handler("session_start", self.start)

		self.add_event_handler("groupchat_message", self.muc_message)

	def muc_message(self, msg):

		if msg['mucnick'] != self.nick:

			if msg['body'] == "echo abc":

				self.echo_received = True

	def start(self, event):

		self.plugin['xep_0045'].joinMUC(self.room, self.nick, wait=True)

		self.send_message(mto=self.room, mbody="abc", mtype='groupchat')

		#time.sleep(10)

		#self.disconnect()

if __name__ == '__main__':

	os.system("../spectrum2 -n ./irc_test.cfg &")

	os.system("ngircd -f ngircd.conf &")

	time.sleep(1)

	responder = Responder("responder@localhost", "password", "#channel@localhost", "responder")

	responder.register_plugin('xep_0030')  # Service Discovery

	responder.register_plugin('xep_0045')  # Multi-User Chat

	}

	void setBuddy() {

		add2Buddies();

		CPPUNIT_ASSERT_EQUAL(4, (int) received.size());

		Swift::RosterPayload::ref payload1 = getStanza(received[0])->getPayload<Swift::RosterPayload>();

		CPPUNIT_ASSERT(payload1);

		CPPUNIT_ASSERT_EQUAL(1, (int) payload1->getItems().size());

		Swift::RosterItemPayload item = payload1->getItems()[0];

		CPPUNIT_ASSERT_EQUAL(std::string("buddy1"), Buddy::JIDToLegacyName(item.getJID()));

		CPPUNIT_ASSERT_EQUAL(std::string("Buddy 1"), item.getName());

		Swift::RosterPayload::ref payload2 = getStanza(received[2])->getPayload<Swift::RosterPayload>();

		CPPUNIT_ASSERT(payload2);

		CPPUNIT_ASSERT_EQUAL(1, (int) payload2->getItems().size());

		item = payload2->getItems()[0];

		CPPUNIT_ASSERT_EQUAL(std::string("buddy2"), Buddy::JIDToLegacyName(item.getJID()));

		CPPUNIT_ASSERT_EQUAL(std::string("Buddy 2"), item.getName());

		// send responses back

		injectIQ(Swift::IQ::createResult(getStanza(received[0])->getFrom(), getStanza(received[0])->getTo(), getStanza(received[0])->getID()));

		injectIQ(Swift::IQ::createResult(getStanza(received[2])->getFrom(), getStanza(received[2])->getTo(), getStanza(received[2])->getID()));