client->connection = c;

	client->res = 0;

	client->init_res = 0;

	client->shared = 0;

	client->willDie = 0;

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

	if (m_clients.size() == 0) {

		// first backend connected, start the server, we're ready.

		m_component->start();

	}

	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;

	// some users are in queue waiting for this backend

	while(!m_waitingUsers.empty()) {

		// There's no new backend, so stop associating users and wait for new backend,

		// which has been already spawned in getFreeClient() call.

		if (getFreeClient() == NULL)

			break;

		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;

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

		// TODO: ERROR

		return;

	}

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

	if (!user) {

		LOG4CXX_ERROR(logger, "Connected payload received for unknown user " << payload.user());

		return;

	}

	user->setConnected(true);

	m_component->m_userRegistry->onPasswordValid(payload.user());

}

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

	pbnetwork::Disconnected payload;

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

		// TODO: ERROR

		return;

	}

	m_component->m_userRegistry->onPasswordInvalid(payload.user(), payload.message());

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

	if (!user) {

		return;

	}

	user->handleDisconnected(payload.message(), (Swift::SpectrumErrorPayload::Error) payload.error());

}

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

	pbnetwork::VCard payload;

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

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

		// TODO: ERROR

		return;

	}

	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::handleAuthorizationPayload(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;

	// Create subscribe presence and forward it to XMPP side

	Swift::Presence::ref response = Swift::Presence::create();

	response->setTo(user->getJID());

	std::string name = payload.buddyname();

	name = Swift::JID::getEscapedNode(name);

// 	if (name.find_last_of("@") != std::string::npos) { // OK when commented

// 		name.replace(name.find_last_of("@"), 1, "%"); // OK when commented

// 	}

	response->setFrom(Swift::JID(name, m_component->getJID().toString()));

	response->setType(Swift::Presence::Subscribe);

	m_component->getStanzaChannel()->sendPresence(response);

}

void NetworkPluginServer::handleChatStatePayload(const std::string &data, Swift::ChatState::ChatStateType type) {

	pbnetwork::Buddy payload;

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

		// TODO: ERROR

		return;

	}

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

	if (!user)

		return;

	// We're not creating new Conversation just because of chatstates.

	// Some networks/clients spams with chatstates a lot and it leads to bigger memory usage.

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

	if (!conv) {

		return;

	}

	// Forward chatstate

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

	msg->addPayload(boost::make_shared<Swift::ChatState>(type));

	conv->handleMessage(msg);

}

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

	}

	else {

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

		buddy->setFlags(BUDDY_JID_ESCAPING);

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

	if (!user)

		return;

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

	if (!conv) {

		return;

	}

	conv->handleParticipantChanged(payload.nickname(), payload.flag(), payload.status(), payload.statusmessage(), payload.newname());

}

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

	pbnetwork::Room payload;

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

		return;

	}

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

	if (!user)

		return;

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

	if (!conv) {

		return;

	}

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

}

void NetworkPluginServer::handleConvMessagePayload(const std::string &data, bool subject) {

	pbnetwork::ConversationMessage payload;

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

		// TODO: ERROR

		return;

	}

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

	if (!user)

		return;

	// Message from legacy network triggers network acticity

	user->updateLastActivity();

	// Set proper body.

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

	if (subject) {

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

	}

	else {

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

	}

	// Add xhtml-im payload.

	if (!payload.xhtml().empty()) {

		msg->addPayload(boost::make_shared<Swift::XHTMLIMPayload>(payload.xhtml()));

	}

	// Create new Conversation if it does not exist

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

	}

	// Forward it

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

}

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

	pbnetwork::ConversationMessage payload;

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

		// TODO: ERROR

		return;

	}

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

	if (!user)

		return;

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

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

	msg->addPayload(boost::make_shared<Swift::AttentionPayload>());

	// Attentions trigger new Conversation creation

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

}

void NetworkPluginServer::handleStatsPayload(Backend *c, const std::string &data) {

	pbnetwork::Stats payload;

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

		// TODO: ERROR

		return;

	}

	c->res = payload.res();

	c->init_res = payload.init_res();

	c->shared = payload.shared();

}

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

	pbnetwork::File payload;

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

		// TODO: ERROR

		return;

	}

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

	if (!user)

		return;

	LOG4CXX_INFO(logger, "handleFTStartPayload " << payload.filename() << " " << payload.buddyname());

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

	if (!buddy) {

		// TODO: escape? reject?

		return;

	}

	Swift::StreamInitiationFileInfo fileInfo;

	fileInfo.setSize(payload.size());

	fileInfo.setName(payload.filename());

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

	boost::shared_ptr<MemoryReadBytestream> bytestream(new MemoryReadBytestream(payload.size()));

	bytestream->onDataNeeded.connect(boost::bind(&NetworkPluginServer::handleFTDataNeeded, this, c, bytestream_id + 1));

	LOG4CXX_INFO(logger, "jid=" << buddy->getJID());

	FileTransferManager::Transfer transfer = m_ftManager->sendFile(user, buddy, bytestream, fileInfo);

	if (!transfer.ft) {

		handleFTRejected(user, payload.buddyname(), payload.filename(), payload.size());

		return;

	}

	m_filetransfers[++bytestream_id] = transfer;

	transfer.ft->onStateChange.connect(boost::bind(&NetworkPluginServer::handleFTStateChanged, this, _1, payload.username(), payload.buddyname(), payload.filename(), payload.size(), bytestream_id));

	transfer.ft->start();

}

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

	pbnetwork::File payload;

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

		// TODO: ERROR

		return;

	}

	if (payload.has_ftid()) {

		if (m_filetransfers.find(payload.ftid()) != m_filetransfers.end()) {

			FileTransferManager::Transfer &transfer = m_filetransfers[payload.ftid()];

			transfer.ft->cancel();

		}

		else {

			LOG4CXX_ERROR(logger, "FTFinishPayload for unknown ftid=" << payload.ftid());

		}

	}

}

void NetworkPluginServer::handleFTDataPayload(Backend *b, const std::string &data) {

	pbnetwork::FileTransferData payload;

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

		// TODO: ERROR

		return;

	}