NetworkPluginServer(Component *component, Config *config, UserManager *userManager, FileTransferManager *ftManager);

		virtual ~NetworkPluginServer();

		int getBackendCount() {

			return m_clients.size();

		}

		const std::list<Backend *> &getBackends() {

			return m_clients;

		}

		void collectBackend();

		bool moveToLongRunBackend(User *user);

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

	private:

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

		void handleSessionFinished(Backend *c);

		void handleDataRead(Backend *c, boost::shared_ptr<Swift::SafeByteArray> data);

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

		RosterResponder *m_rosterResponder;

		BlockResponder *m_blockResponder;

		Config *m_config;

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

		std::list<Backend *>  m_clients;

		Swift::Timer::ref m_pingTimer;

		Swift::Timer::ref m_collectTimer;

		Component *m_component;

		std::list<User *> m_waitingUsers;

		bool m_isNextLongRun;

		std::map<unsigned long, FileTransferManager::Transfer> m_filetransfers;

		FileTransferManager *m_ftManager;

};

}

		Component *getComponent() {

			return m_component;

		}

		/// Connects user manually.

		/// \param user JID of user.

		void connectUser(const Swift::JID &user);

		/// Disconnects user manually.

		/// \param user JID of user.

		void disconnectUser(const Swift::JID &user);

	private:

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

		void handleMessageReceived(Swift::Message::ref message);

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

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

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

		void handleRemoveTimeout(const std::string jid, User *user, bool reconnect);

		void handleDiscoInfo(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info);

		void addUser(User *user);

		long m_onlineBuddies;

		User *m_cachedUser;

		std::map<std::string, User *> m_users;

		Component *m_component;

		StorageBackend *m_storageBackend;

		StorageResponder *m_storageResponder;

		UserRegistry *m_userRegistry;

		Swift::Timer::ref m_removeTimer;

		friend class RosterResponder;

};

}

	}

}

void NetworkPluginServer::handleSessionFinished(Backend *c) {

	LOG4CXX_INFO(logger, "Backend " << c << " disconnected. Current backend count=" << (m_clients.size() - 1));

	// This backend will do, so we can't reconnect users to it in User::handleDisconnected call

	c->willDie = true;

	// If there are users associated with this backend, it must have crashed, so print error output

	// and disconnect users

	for (std::list<User *>::const_iterator it = c->users.begin(); it != c->users.end(); it++) {

		LOG4CXX_ERROR(logger, "Backend " << c << " disconnected (probably crashed) with active user " << (*it)->getJID().toString());

		(*it)->setData(NULL);

		(*it)->handleDisconnected("Internal Server Error, please reconnect.");

	}

	std::string message;

	pbnetwork::WrapperMessage wrap;

	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_EXIT);

	wrap.SerializeToString(&message);

	send(c->connection, message);

	return (unsigned long) rss;

}

bool StatsResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<StatsPayload> stats) {

	boost::shared_ptr<StatsPayload> response(new StatsPayload());

	if (stats->getItems().empty()) {

		response->addItem(StatsPayload::Item("uptime"));

		response->addItem(StatsPayload::Item("users/online"));

		response->addItem(StatsPayload::Item("contacts/online"));

		response->addItem(StatsPayload::Item("contacts/total"));

		response->addItem(StatsPayload::Item("memory-usage"));

	}

	else {

		unsigned long contactsOnline = 0;

		unsigned long contactsTotal = 0;

		Swift::StatusShow s;

		std::string statusMessage;

		for (std::map<std::string, User *>::const_iterator it = m_userManager->getUsers().begin(); it != m_userManager->getUsers().end(); it++) {

			if (!(*it).second) {

				continue;

			}

					contactsOnline++;

				}

			}

		}

		BOOST_FOREACH(const StatsPayload::Item &item, stats->getItems()) {

			if (item.getName() == "uptime") {

				response->addItem(StatsPayload::Item("uptime", "seconds", boost::lexical_cast<std::string>(time(0) - m_start)));

			}

			else if (item.getName() == "users/online") {

				response->addItem(StatsPayload::Item("users/online", "users", boost::lexical_cast<std::string>(m_userManager->getUserCount())));

			}

			}

			else if (item.getName() == "memory-usage") {

				response->addItem(StatsPayload::Item("memory-usage", "KB", boost::lexical_cast<std::string>(usedMemory())));

			}

			else if (item.getName() == "contacts/online") {

				response->addItem(StatsPayload::Item("contacts/online", "contacts", boost::lexical_cast<std::string>(contactsOnline)));

			}

			else if (item.getName() == "contacts/total") {

				response->addItem(StatsPayload::Item("contacts/total", "contacts", boost::lexical_cast<std::string>(contactsTotal)));

			}

		}

	}

	sendResponse(from, id, response);

	return true;

}

bool StatsResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<StatsPayload> stats) {

	return false;

}

#include "malloc.h"

// #include "valgrind/memcheck.h"

using namespace log4cxx;

namespace Transport {

static LoggerPtr logger = Logger::getLogger("UserManager");

UserManager::UserManager(Component *component, UserRegistry *userRegistry, StorageBackend *storageBackend) {

	m_cachedUser = NULL;

	m_onlineBuddies = 0;

	m_component = component;

	m_storageBackend = storageBackend;

	m_storageResponder = NULL;

	m_userRegistry = userRegistry;

	if (m_storageBackend) {

		m_storageResponder = new StorageResponder(component->getIQRouter(), m_storageBackend, this);

		m_storageResponder->start();

	}

	component->onUserPresenceReceived.connect(bind(&UserManager::handlePresence, this, _1));

	component->onUserDiscoInfoReceived.connect(bind(&UserManager::handleDiscoInfo, this, _1, _2));