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 (CONFIG_BOOL(m_config, "service.enable_xhtml") && !payload.xhtml().empty()) {

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

	}

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

		boost::posix_time::ptime timestamp = boost::posix_time::from_iso_string(payload.timestamp());

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

	}

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

	// We can't create Conversation for payload with nickname, because this means the message is from room,

	// but this user is not in any room, so it's OK to just reject this message

	if (!conv && !payload.nickname().empty()) {

		return;

	}

	// Create new Conversation if it does not exist

	if (!conv) {

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

		user->getConversationManager()->addConversation(conv);

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

	}

	// Forward it

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

	m_userManager->messageToXMPPSent();

}

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

		user->getConversationManager()->addConversation(conv);

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

	c->id = payload.id();

}

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;

	}

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

// 	if (!user)

// 		return;

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

	MemoryReadBytestream *bytestream = (MemoryReadBytestream *) transfer.readByteStream.get();

	if (bytestream->appendData(payload.data()) > 5000000) {

		pbnetwork::FileTransferData f;

		f.set_ftid(payload.ftid());

		f.set_data("");

		std::string message;

		f.SerializeToString(&message);

		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_PAUSE);

		send(b->connection, message);

	}

}

void NetworkPluginServer::handleFTDataNeeded(Backend *b, unsigned long ftid) {

	pbnetwork::FileTransferData f;

	f.set_ftid(ftid);

	f.set_data("");

	std::string message;

	f.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_CONTINUE);

	send(b->connection, message);

}

void NetworkPluginServer::handlePongReceived(Backend *c) {

	// This could be first PONG from the backend

	if (c->pongReceived == -1) {

		// Backend is fully ready to handle requests

		c->willDie = false;

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

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

			m_component->start();

		}

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

			}

		}

	}

	c->pongReceived = true;

}

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

	pbnetwork::BackendConfig payload;

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

		// TODO: ERROR

		return;

	}

	if (!m_adminInterface) {

		return;

	}

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

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

	m_adminInterface->handleQuery(msg);

	pbnetwork::BackendConfig response;

	response.set_config(msg->getBody());

	std::string message;

	response.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_QUERY);

	send(b->connection, message);

}

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

	pbnetwork::BackendConfig payload;

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

		// TODO: ERROR

		return;

	}

	m_config->updateBackendConfig(payload.config());

}

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

	pbnetwork::RoomList payload;

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

		// TODO: ERROR

		return;

	}

	m_discoItemsResponder->clearRooms();

	for (int i = 0; i < payload.room_size() && i < payload.name_size(); i++) {

		m_discoItemsResponder->addRoom(Swift::JID::getEscapedNode(payload.room(i)) + "@" + m_component->getJID().toString(), payload.name(i));

	}

}

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

	// Append data to buffer

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

	// Parse data while there are some

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

		// expected_size of wrapper message

		unsigned int expected_size;

		// if data is >= 4, we have whole header and we can

		// read expected_size.

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

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

			expected_size = ntohl(expected_size);

			// If we don't have whole wrapper message, wait for next

			// handleDataRead call.

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

				return;

		}

		else {

			return;

		}

		// Parse wrapper message and erase it from buffer.

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

		// Handle payload in wrapper message

		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:

				handlePongReceived(c);

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_PARTICIPANT_CHANGED:

				handleParticipantChangedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_ROOM_NICKNAME_CHANGED:

				handleRoomChangedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_VCARD:

				handleVCardPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING:

				handleChatStatePayload(wrapper.payload(), Swift::ChatState::Composing);

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPED:

				handleChatStatePayload(wrapper.payload(), Swift::ChatState::Paused);

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_STOPPED_TYPING:

				handleChatStatePayload(wrapper.payload(), Swift::ChatState::Active);

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_AUTH_REQUEST:

				handleAuthorizationPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_ATTENTION:

				handleAttentionPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_STATS: