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;

		std::vector<std::string> m_crashedBackends;

		AdminInterface *m_adminInterface;

};

}

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

	}

	// Change groups if it's not empty. The same as above...

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

	for (int i = 0; i < payload.group_size(); i++) {

		groups.push_back(payload.group(i));

	}

	if (!groups.empty()) {

		buddy->setGroups(groups);

	}

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

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

	buddy->setBlocked(payload.blocked());

}

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

	m_ftManager = ftManager;

	m_userManager = userManager;

	m_config = config;

	m_component = component;

	m_isNextLongRun = false;

	m_adminInterface = NULL;

	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->getNetworkFactories()->getTimerFactory()->createTimer(20000);

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

	m_pingTimer->start();

	if (CONFIG_INT(m_config, "service.memory_collector_time") != 0) {

		m_collectTimer = component->getNetworkFactories()->getTimerFactory()->createTimer(CONFIG_INT(m_config, "service.memory_collector_time"));

		m_collectTimer->onTick.connect(boost::bind(&NetworkPluginServer::collectBackend, this));

		m_collectTimer->start();

	}

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

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

	m_vcardResponder->onVCardUpdated.connect(boost::bind(&NetworkPluginServer::handleVCardUpdated, this, _1, _2));

	m_vcardResponder->start();

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

	m_rosterResponder->onBuddyAdded.connect(boost::bind(&NetworkPluginServer::handleBuddyAdded, this, _1, _2));

	m_rosterResponder->onBuddyRemoved.connect(boost::bind(&NetworkPluginServer::handleBuddyRemoved, this, _1));

	m_rosterResponder->onBuddyUpdated.connect(boost::bind(&NetworkPluginServer::handleBuddyUpdated, this, _1, _2));

	m_rosterResponder->start();

	m_pingTimer->stop();

	m_server->stop();

	m_server.reset();

	delete m_component->m_factory;

	delete m_vcardResponder;

	delete m_rosterResponder;

	delete m_blockResponder;

}

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

	// Create new Backend instance

	Backend *client = new Backend;

	client->pongReceived = -1;

	client->connection = c;

	client->res = 0;

	client->init_res = 0;

	client->shared = 0;

	// Until we receive first PONG from backend, backend is in willDie state.

	client->willDie = true;

	// Backend does not accept new clients automatically if it's long-running

	client->acceptUsers = !m_isNextLongRun;

	client->longRun = m_isNextLongRun;

	LOG4CXX_INFO(logger, "New" + (client->longRun ? std::string(" long-running") : "") +  " backend " << client << " connected. Current backend count=" << (m_clients.size() + 1));

	m_clients.push_front(client);

	c->onDisconnected.connect(boost::bind(&NetworkPluginServer::handleSessionFinished, this, client));

	c->onDataRead.connect(boost::bind(&NetworkPluginServer::handleDataRead, this, client, _1));

	sendPing(client);

	// sendPing sets pongReceived to 0, but we want to have it -1 to ignore this backend

	// in first ::pingTimeout call, because it can be called right after this function

	// and backend wouldn't have any time to response to ping.

	client->pongReceived = -1;

}

void NetworkPluginServer::handleSessionFinished(Backend *c) {

	LOG4CXX_INFO(logger, "Backend " << c << " (ID=" << c->id << ") 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

	if (!c->users.empty()) {

		m_crashedBackends.push_back(c->id);

	unsigned long diff = CONFIG_INT(m_config, "service.idle_reconnect_time");

	if (diff != 0) {

		for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {

			// Users from long-running backends can't be moved

			if ((*it)->longRun) {

				continue;

			}

			// Find users which are inactive for more than 'diff'

			BOOST_FOREACH(User *u, (*it)->users) {

				if (now - u->getLastActivity() > diff) {

					usersToMove.push_back(u);

				}

			}

		}

		// Move inactive users to long-running backend.

		BOOST_FOREACH(User *u, usersToMove) {

			LOG4CXX_INFO(logger, "Moving user " << u->getJID().toString() << " to long-running backend");

			if (!moveToLongRunBackend(u))

				break;

		}

	}

	// check ping responses

	std::vector<Backend *> toRemove;

	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {

		// pong has been received OR backend just connected and did not have time to answer the ping

		// request.

		if ((*it)->pongReceived || (*it)->pongReceived == -1) {

			// Don't send another ping if pongReceived == -1, because we've already sent one

			// when registering backend.

			if ((*it)->pongReceived) {

				sendPing((*it));

			}

		}

		else {

			LOG4CXX_INFO(logger, "Disconnecting backend " << (*it) << " (ID=" << (*it)->id << "). PING response not received.");

			toRemove.push_back(*it);

		}

		if ((*it)->users.size() == 0) {

			LOG4CXX_INFO(logger, "Disconnecting backend " << (*it) << " (ID=" << (*it)->id << "). There are no users.");

			toRemove.push_back(*it);

		}

	}

		send(c->connection, message);

		c->pongReceived = false;

	}

// 	LOG4CXX_INFO(logger, "PING to " << c);

}

NetworkPluginServer::Backend *NetworkPluginServer::getFreeClient(bool acceptUsers, bool longRun) {

	NetworkPluginServer::Backend *c = NULL;

	// Check all backends and find free one

	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {

		if ((*it)->willDie == false && (*it)->acceptUsers == acceptUsers && (*it)->users.size() < CONFIG_INT(m_config, "service.users_per_backend") && (*it)->connection && (*it)->longRun == longRun) {

			c = *it;

			// if we're not reusing all backends and backend is full, stop accepting new users on this backend

			if (!CONFIG_BOOL(m_config, "service.reuse_old_backends")) {

				if (c->users.size() + 1 >= CONFIG_INT(m_config, "service.users_per_backend")) {

					c->acceptUsers = false;

				}

			}

			break;

		}

	}

	// there's no free backend, so spawn one.

		m_isNextLongRun = longRun;

		exec_(CONFIG_STRING(m_config, "service.backend"), CONFIG_STRING(m_config, "service.backend_host").c_str(), CONFIG_STRING(m_config, "service.backend_port").c_str(), m_config->getConfigFile().c_str());

	}

	return c;

}

}