iter = iter->next;

					if (purple_conversation_get_account(conv) == account)

						purple_conversation_destroy(conv);

				}

				g_free(account->ui_data);

				account->ui_data = NULL;

				m_accounts.erase(account);

			}

		}

		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, legacyName.c_str(), account);

				if (!conv) {

					conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, legacyName.c_str());

				}

				gchar *_markup = purple_markup_escape_text(message.c_str(), -1);

				purple_conv_im_send(PURPLE_CONV_IM(conv), _markup);

				g_free(_markup);

			}

		}

			PurpleAccount *account = m_sessions[user];

			if (account) {

				serv_get_info(purple_account_get_connection(account), legacyName.c_str());

				m_vcards[user + legacyName] = id;

			}

		}

		std::map<std::string, PurpleAccount *> m_sessions;

		std::map<PurpleAccount *, std::string> m_accounts;

		std::map<std::string, unsigned int> m_vcards;

	private:

		Config *config;

};

static std::string getAlias(PurpleBuddy *m_buddy) {

	std::string alias;

	if (purple_buddy_get_server_alias(m_buddy))

		alias = (std::string) purple_buddy_get_server_alias(m_buddy);

	else

		alias = (std::string) purple_buddy_get_alias(m_buddy);

	return alias;

}

static bool getStatus(PurpleBuddy *m_buddy, Swift::StatusShow &status, std::string &statusMessage) {

	PurplePresence *pres = purple_buddy_get_presence(m_buddy);

	if (pres == NULL)

		return false;

	PurpleStatus *stat = purple_presence_get_active_status(pres);

	if (stat == NULL)

		return false;

	int st = purple_status_type_get_primitive(purple_status_get_type(stat));

		void handleBuddyChanged(const std::string &user, const std::string &buddyName, const std::string &alias,

			const std::string &groups, int status, const std::string &statusMessage = "", const std::string &iconHash = ""

		);

		void handleParticipantChanged(const std::string &user, const std::string &nickname, const std::string &room, int flags, int status = Swift::StatusShow::None, const std::string &statusMessage = "", const std::string &newname = "");

		void handleDisconnected(const std::string &user, const std::string &legacyName, int error, const std::string &message);

		void handleConnected(const std::string &user);

		void handleMessage(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &nickname = "");

		void handleSubject(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &nickname = "");

		void handleRoomChanged(const std::string &user, const std::string &room, const std::string &nickname);

		void handleVCard(const std::string &user, unsigned int id, const std::string &legacyName, const std::string &fullName, const std::string &nickname, const std::string &photo);

		virtual void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) = 0;

		virtual void handleLogoutRequest(const std::string &user, const std::string &legacyName) = 0;

		virtual void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message) = 0;

		virtual void handleVCardRequest(const std::string &/*user*/, const std::string &/*legacyName*/, unsigned int /*id*/) {}

		virtual void handleJoinRoomRequest(const std::string &/*user*/, const std::string &/*room*/, const std::string &/*nickname*/, const std::string &/*pasword*/) {}

		virtual void handleLeaveRoomRequest(const std::string &/*user*/, const std::string &/*room*/) {}

	private:

		void connect();

		void handleLoginPayload(const std::string &payload);

		void handleLogoutPayload(const std::string &payload);

		void handleConvMessagePayload(const std::string &payload);

		void handleJoinRoomPayload(const std::string &payload);

		void handleLeaveRoomPayload(const std::string &payload);

		void handleVCardPayload(const std::string &payload);

		void handleDataRead(const Swift::SafeByteArray&);

		void _handleConnected(bool error);

		void handleDisconnected();

		void send(const std::string &data);

		void sendPong();

		void pingTimeout();

		Swift::SafeByteArray m_data;

		std::string m_host;

		int m_port;

		Swift::BoostNetworkFactories *m_factories;

		Swift::BoostIOServiceThread m_boostIOServiceThread;

		boost::shared_ptr<Swift::Connection> m_conn;

		Swift::Timer::ref m_pingTimer;

		bool m_pingReceived;

};

}

		virtual ~NetworkPluginServer();

		void handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &message);

	private:

		void handleNewClientConnection(boost::shared_ptr<Swift::Connection> c);

		void handleSessionFinished(Client *c);

		void handleDataRead(Client *c, const Swift::SafeByteArray&);

		void handleConnectedPayload(const std::string &payload);

		void handleDisconnectedPayload(const std::string &payload);

		void handleBuddyChangedPayload(const std::string &payload);

		void handleConvMessagePayload(const std::string &payload, bool subject = false);

		void handleParticipantChangedPayload(const std::string &payload);

		void handleRoomChangedPayload(const std::string &payload);

		void handleVCardPayload(const std::string &payload);

		void handleUserCreated(User *user);

		void handleRoomJoined(User *user, const std::string &room, const std::string &nickname, const std::string &password);

		void handleRoomLeft(User *user, const std::string &room);

		void handleUserReadyToConnect(User *user);

		void handleUserDestroyed(User *user);

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

		void send(boost::shared_ptr<Swift::Connection> &, const std::string &data);

		void pingTimeout();

		void sendPing(Client *c);

		Client *getFreeClient();

		UserManager *m_userManager;

		VCardResponder *m_vcardResponder;

		RosterResponder *m_rosterResponder;

		Config *m_config;

		boost::shared_ptr<Swift::ConnectionServer> m_server;

		std::list<Client *>  m_clients;

		Swift::Timer::ref m_pingTimer;

		Component *m_component;

};

}

	public:

		/// Creates new RosterManager.

		/// \param user User associated with this RosterManager.

		/// \param component Transport instance associated with this roster.

		RosterManager(User *user, Component *component);

		/// Destructor.

		virtual ~RosterManager();

		/// Associates the buddy with this roster,

		/// and if the buddy is not already in XMPP user's server-side roster, the proper requests

		/// are sent to XMPP user (subscribe presences, Roster Item Exchange stanza or

		/// the buddy is added to server-side roster using remote-roster protoXEP).

		/// \param buddy Buddy

		void setBuddy(Buddy *buddy);

		/// Deassociates the buddy with this roster.

		/// \param buddy Buddy.

		void unsetBuddy(Buddy *buddy);

		Buddy *getBuddy(const std::string &name);

		void setStorageBackend(StorageBackend *storageBackend);

		Swift::RosterPayload::ref generateRosterPayload();

		/// Returns user associated with this roster.

		/// \return User

		User *getUser() { return m_user; }

		/// Called when new Buddy is added to this roster.

		/// \param buddy newly added Buddy

		boost::signal<void (Buddy *buddy)> onBuddySet;

		/// Called when Buddy has been removed from this roster.

		/// \param buddy removed Buddy

		boost::signal<void (Buddy *buddy)> onBuddyUnset;

		void handleSubscription(Swift::Presence::ref presence);

	private:

		void setBuddyCallback(Buddy *buddy);

		void sendBuddyRosterPush(Buddy *buddy);

		void sendRIE();

		void handleBuddyRosterPushResponse(Swift::ErrorPayload::ref error, const std::string &key);

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

#pragma once

#include <vector>

#include "Swiften/Swiften.h"

#include "Swiften/Queries/Responder.h"

#include "Swiften/Elements/RosterPayload.h"

namespace Transport {

class UserManager;

class RosterResponder : public Swift::Responder<Swift::RosterPayload> {

	public:

		RosterResponder(Swift::IQRouter *router, UserManager *userManager);

		~RosterResponder();

	private:

		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload);

		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload);

		UserManager *m_userManager;

};

}

	handleJoinRoomRequest(payload.username(), payload.room(), payload.nickname(), payload.password());

}

void NetworkPlugin::handleLeaveRoomPayload(const std::string &data) {

	pbnetwork::Room payload;

	if (payload.ParseFromString(data) == false) {

		// TODO: ERROR

		return;

	}

	handleLeaveRoomRequest(payload.username(), payload.room());

}

void NetworkPlugin::handleVCardPayload(const std::string &data) {

	pbnetwork::VCard payload;

	if (payload.ParseFromString(data) == false) {

		// TODO: ERROR

		return;

	}

	handleVCardRequest(payload.username(), payload.buddyname(), payload.id());

}

void NetworkPlugin::handleDataRead(const Swift::SafeByteArray &data) {

	m_data.insert(m_data.end(), data.begin(), data.end());

	while (m_data.size() != 0) {

		unsigned int expected_size;

		if (m_data.size() >= 4) {

			expected_size = *((unsigned int*) &m_data[0]);

			expected_size = ntohl(expected_size);

			if (m_data.size() - 4 < expected_size)

				return;

		}

		else {

			return;

		}

		pbnetwork::WrapperMessage wrapper;

		if (wrapper.ParseFromArray(&m_data[4], expected_size) == false) {

			m_data.erase(m_data.begin(), m_data.begin() + 4 + expected_size);

			return;

		}

		m_data.erase(m_data.begin(), m_data.begin() + 4 + expected_size);

		switch(wrapper.type()) {

			case pbnetwork::WrapperMessage_Type_TYPE_LOGIN:

				handleLoginPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_LOGOUT:

				handleLogoutPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_PING:

				sendPong();

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE:

				handleConvMessagePayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_JOIN_ROOM:

				handleJoinRoomPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_LEAVE_ROOM:

				handleLeaveRoomPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_VCARD:

				handleVCardPayload(wrapper.payload());

				break;

			default:

				return;

		}

	}

}

void NetworkPlugin::send(const std::string &data) {

	char header[4];

	*((int*)(header)) = htonl(data.size());

	m_conn->write(Swift::createSafeByteArray(std::string(header, 4) + data));

}

void NetworkPlugin::sendPong() {

	m_pingReceived = true;

	std::string message;

	pbnetwork::WrapperMessage wrap;

	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_PONG);

	wrap.SerializeToString(&message);

	send(message);

	std::cout << "SENDING PONG\n";

}

void NetworkPlugin::pingTimeout() {

	buddy->setAlias(payload.alias());

	std::vector<std::string> groups;

	groups.push_back(payload.groups());

	buddy->setGroups(groups);

	buddy->setStatus(Swift::StatusShow((Swift::StatusShow::Type) payload.status()), payload.statusmessage());

	buddy->setIconHash(payload.iconhash());

}

NetworkPluginServer::NetworkPluginServer(Component *component, Config *config, UserManager *userManager) {

	m_userManager = userManager;

	m_config = config;

	m_component = component;

	m_component->m_factory = new NetworkFactory(this);

	m_userManager->onUserCreated.connect(boost::bind(&NetworkPluginServer::handleUserCreated, this, _1));

	m_userManager->onUserDestroyed.connect(boost::bind(&NetworkPluginServer::handleUserDestroyed, this, _1));

	m_pingTimer = component->getFactories()->getTimerFactory()->createTimer(10000);

	m_pingTimer->onTick.connect(boost::bind(&NetworkPluginServer::pingTimeout, this)); 

	m_vcardResponder = new VCardResponder(component->getIQRouter(), userManager);

	m_vcardResponder->onVCardRequired.connect(boost::bind(&NetworkPluginServer::handleVCardRequired, this, _1, _2, _3));

	m_vcardResponder->start();

	m_rosterResponder = new RosterResponder(component->getIQRouter(), userManager);

	m_rosterResponder->start();

	m_server = component->getFactories()->getConnectionFactory()->createConnectionServer(10000);

	m_server->onNewConnection.connect(boost::bind(&NetworkPluginServer::handleNewClientConnection, this, _1));

	m_server->start();

	signal(SIGCHLD, SigCatcher);

	exec_(CONFIG_STRING(m_config, "service.backend").c_str(), "localhost", "10000", m_config->getConfigFile().c_str());

}

NetworkPluginServer::~NetworkPluginServer() {

	m_pingTimer->stop();

	delete m_vcardResponder;

	delete m_rosterResponder;

}

void NetworkPluginServer::handleNewClientConnection(boost::shared_ptr<Swift::Connection> c) {

	Client *client = new Client;

	client->pongReceived = true;

	client->connection = c;

	m_clients.push_back(client);

}

void NetworkPluginServer::handleVCardPayload(const std::string &data) {

	pbnetwork::VCard payload;

	if (payload.ParseFromString(data) == false) {

		std::cout << "PARSING ERROR\n";

		// TODO: ERROR

		return;

	}

	std::cout << "OMG?\n";

	boost::shared_ptr<Swift::VCard> vcard(new Swift::VCard());

	vcard->setFullName(payload.fullname());

	vcard->setPhoto(Swift::createByteArray(payload.photo()));

	vcard->setNickname(payload.nickname());

	m_vcardResponder->sendVCard(payload.id(), vcard);

}

void NetworkPluginServer::handleBuddyChangedPayload(const std::string &data) {

	pbnetwork::Buddy payload;

	if (payload.ParseFromString(data) == false) {

		// TODO: ERROR

		return;

	}

	User *user = m_userManager->getUser(payload.username());

	if (!user)

		return;

	LocalBuddy *buddy = (LocalBuddy *) user->getRosterManager()->getBuddy(payload.buddyname());

	if (buddy) {

		handleBuddyPayload(buddy, payload);

		buddy->buddyChanged();

	}

	else {

		buddy = new LocalBuddy(user->getRosterManager(), -1);

		handleBuddyPayload(buddy, payload);

		user->getRosterManager()->setBuddy(buddy);

	}

}

void NetworkPluginServer::handleParticipantChangedPayload(const std::string &data) {

	pbnetwork::Participant payload;

	if (payload.ParseFromString(data) == false) {

		// TODO: ERROR

		return;

	}

	User *user = m_userManager->getUser(payload.username());

// 	std::cout << "payload 2...\n";

	User *user = m_userManager->getUser(payload.username());

	if (!user)

		return;

	boost::shared_ptr<Swift::Message> msg(new Swift::Message());

	if (subject) {

		msg->setSubject(payload.message());

	}

	else {

		msg->setBody(payload.message());

	}

	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(payload.buddyname());

	if (!conv) {

		conv = new NetworkConversation(user->getConversationManager(), payload.buddyname());

		conv->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, this, _1, _2));

	}

	conv->handleMessage(msg, payload.nickname());

}

void NetworkPluginServer::handleDataRead(Client *c, const Swift::SafeByteArray &data) {

	c->data.insert(c->data.end(), data.begin(), data.end());

	while (c->data.size() != 0) {

		unsigned int expected_size;

		if (c->data.size() >= 4) {

			expected_size = *((unsigned int*) &c->data[0]);

			expected_size = ntohl(expected_size);

			if (c->data.size() - 4 < expected_size)

				return;

		}

		else {

			return;

		}

		pbnetwork::WrapperMessage wrapper;

		if (wrapper.ParseFromArray(&c->data[4], expected_size) == false) {

			std::cout << "PARSING ERROR " << expected_size << "\n";

			c->data.erase(c->data.begin(), c->data.begin() + 4 + expected_size);

			continue;

		}

		c->data.erase(c->data.begin(), c->data.begin() + 4 + expected_size);

		switch(wrapper.type()) {

			case pbnetwork::WrapperMessage_Type_TYPE_CONNECTED:

				handleConnectedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_DISCONNECTED:

				handleDisconnectedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED:

				handleBuddyChangedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE:

				handleConvMessagePayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_ROOM_SUBJECT_CHANGED:

				handleConvMessagePayload(wrapper.payload(), true);

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_PONG:

				c->pongReceived = true;

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_PARTICIPANT_CHANGED:

				handleParticipantChangedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_ROOM_NICKNAME_CHANGED:

				handleRoomChangedPayload(wrapper.payload());

	c->users.remove(user);

	if (c->users.size() == 0) {

		std::cout << "DISCONNECTING\n";

		c->connection->disconnect();

		c->connection.reset();

// 		m_clients.erase(user->connection);

	}

}

void NetworkPluginServer::handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &msg) {

	pbnetwork::ConversationMessage m;

	m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());

	m.set_buddyname(conv->getLegacyName());

	m.set_message(msg->getBody());

	std::string message;

	m.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE);

	Client *c = (Client *) conv->getConversationManager()->getUser()->getData();

	send(c->connection, message);

}

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

	std::cout << "VCARD REQUIRED " << name << " " << id << "\n";

	pbnetwork::VCard vcard;

	vcard.set_username(user->getJID().toBare());

	vcard.set_buddyname(name);

	vcard.set_id(id);

	std::string message;

	vcard.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_VCARD);

	Client *c = (Client *) user->getData();

	send(c->connection, message);

}

void NetworkPluginServer::sendPing(Client *c) {

	std::string message;

	pbnetwork::WrapperMessage wrap;

	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_PING);

	wrap.SerializeToString(&message);

	send(c->connection, message);

	// In component mode we send RIE or Subscribe presences, based on features.

	if (m_component->inServerMode()) {

		sendBuddyRosterPush(buddy);

	}

	else {

		if (m_setBuddyTimer->onTick.empty()) {

			m_setBuddyTimer->stop();

			if (true /*&& rie_is_supported*/) {

				m_RIETimer->start();

			}

		}

	}

	if (m_rosterStorage)

		m_rosterStorage->storeBuddy(buddy);

}

void RosterManager::unsetBuddy(Buddy *buddy) {

	m_buddies.erase(buddy->getName());

	if (m_rosterStorage)

		m_rosterStorage->removeBuddyFromQueue(buddy);

	onBuddyUnset(buddy);

}

void RosterManager::handleBuddyRosterPushResponse(Swift::ErrorPayload::ref error, const std::string &key) {

	if (m_buddies[key] != NULL) {

		m_buddies[key]->buddyChanged();

	}

}

Buddy *RosterManager::getBuddy(const std::string &name) {

	return m_buddies[name];

}

void RosterManager::sendRIE() {

	m_RIETimer->stop();

	Swift::RosterItemExchangePayload::ref payload = Swift::RosterItemExchangePayload::ref(new Swift::RosterItemExchangePayload());

	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {

		Buddy *buddy = (*it).second;

		Swift::RosterItemExchangePayload::Item item;

		item.setJID(buddy->getJID().toBare());

		item.setName(buddy->getAlias());

		item.setAction(Swift::RosterItemExchangePayload::Item::Add);

		item.setGroups(buddy->getGroups());

		payload->addItem(item);

	}

			return true;

		}

	}

	sendResponse(from, id, user->getRosterManager()->generateRosterPayload());

	return true;

}

bool RosterResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload) {

	sendResponse(from, id, boost::shared_ptr<RosterPayload>(new RosterPayload()));

	User *user = m_userManager->getUser(from.toBare().toString());

	if (!user) {

		return true;

	}

	if (payload->getItems().size() == 0) {

		return true;

	}

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

	Buddy *buddy = user->getRosterManager()->getBuddy(Buddy::JIDToLegacyName(item.getJID()));

	if (buddy) {

		if (item.getSubscription() == Swift::RosterItemPayload::Remove) {

		}

		else {

		}

	}

	else if (item.getSubscription() != Swift::RosterItemPayload::Remove) {

		// Roster push for this new buddy is sent by RosterManager

		BuddyInfo buddyInfo;

		buddyInfo.id = -1;

		buddyInfo.alias = item.getName();

		buddyInfo.legacyName = Buddy::JIDToLegacyName(item.getJID());

		buddyInfo.subscription = "both";

		buddyInfo.flags = 0;

		buddy = user->getComponent()->getFactory()->createBuddy(user->getRosterManager(), buddyInfo);

		user->getRosterManager()->setBuddy(buddy);

	}

	return true;