std::list<User *> users;

			Swift::SafeByteArray data;

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

			unsigned long res;

			unsigned long init_res;

			unsigned long shared;

			bool acceptUsers;

			bool longRun;

			bool willDie;

			std::string id;

		};

		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);

		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 handleChatStatePayload(const std::string &payload, Swift::ChatState::ChatStateType type);

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

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

		void handleStatsPayload(Backend *c, const std::string &payload);

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

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

		void handleFTAccepted(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID);

		void handleFTRejected(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size);

		void handleFTDataNeeded(Backend *b, unsigned long ftid);

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

		void pingTimeout();

		void sendPing(Backend *c);

		Backend *getFreeClient(bool acceptUsers = true, bool longRun = false);

		UserManager *m_userManager;

		VCardResponder *m_vcardResponder;

		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;

};

}

		/// Returns true if user is connected.

		/// \return True if user is connected.

		bool isUserConnected(const std::string &barejid) const {

			return m_users.find(barejid) != m_users.end();

		}

		/// Returns pointer to UserRegistry.

		/// \return Pointer to UserRegistry.

		UserRegistry *getUserRegistry() {

			return m_userRegistry;

		}

		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;

};

}

		User *u = m_waitingUsers.front();

		m_waitingUsers.pop_front();

		LOG4CXX_INFO(logger, "Associating " << u->getJID().toString() << " with this backend");

		// associate backend with user

		handleUserCreated(u);

		// connect user if it's ready

		if (u->isReadyToConnect()) {

			handleUserReadyToConnect(u);

		}

	}

}

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);

	c->connection->onDisconnected.disconnect_all_slots();

	c->connection->onDataRead.disconnect_all_slots();

	c->connection->disconnect();

	c->connection.reset();

	m_clients.remove(c);

	delete c;

}

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

	pbnetwork::Connected payload;

unsigned long StatsResponder::usedMemory() {

	double shared = 0;

	double rss = 0;

#ifndef WIN32

	process_mem_usage(shared, rss);

#endif

	rss -= shared;

	const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();

	BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {

		rss += backend->res - backend->shared;

	}

	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;

			}

			const RosterManager::BuddiesMap &buddies = (*it).second->getRosterManager()->getBuddies();

			contactsTotal += buddies.size();

			for(RosterManager::BuddiesMap::const_iterator bt = buddies.begin(); bt != buddies.end(); bt++) {

				if (!(*bt).second) {

					continue;

				}

				if (!(*bt).second->getStatus(s, statusMessage))

					continue;

				if (s.getType() != Swift::StatusShow::None) {

					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 "transport/usermanager.h"

#include "transport/user.h"

#include "transport/transport.h"

#include "transport/storagebackend.h"

#include "transport/conversationmanager.h"

#include "transport/rostermanager.h"

#include "transport/userregistry.h"

#include "storageresponder.h"

#include "log4cxx/logger.h"

#include "Swiften/Swiften.h"

#include "Swiften/Server/ServerStanzaChannel.h"

#include "Swiften/Elements/StreamError.h"

#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));

	m_component->getStanzaChannel()->onMessageReceived.connect(bind(&UserManager::handleMessageReceived, this, _1));

	m_component->getStanzaChannel()->onPresenceReceived.connect(bind(&UserManager::handleGeneralPresenceReceived, this, _1));

	m_userRegistry->onConnectUser.connect(bind(&UserManager::connectUser, this, _1));

	m_userRegistry->onDisconnectUser.connect(bind(&UserManager::disconnectUser, this, _1));

	m_removeTimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(1);

}

UserManager::~UserManager(){

	if (m_storageResponder) {

		m_storageResponder->stop();