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::connectWaitingUsers() {

	// 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(true, false, true) == 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::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();

		}

		connectWaitingUsers();

	}

	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::handleElement(boost::shared_ptr<Swift::Element> element) {

	boost::shared_ptr<Swift::Stanza> stanza = boost::dynamic_pointer_cast<Swift::Stanza>(element);

	if (!stanza) {

		return;

	}

	User *user = m_userManager->getUser(stanza->getTo().toBare());

	if (!user)

		return;

	Swift::JID originalJID = stanza->getFrom();

	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(originalJID.toBare());

	LocalBuddy *buddy = (LocalBuddy *) user->getRosterManager()->getBuddy(stanza->getFrom().toBare());

	if (buddy) {

		const Swift::JID &jid = buddy->getJID();

		if (stanza->getFrom().getResource().empty()) {

			stanza->setFrom(Swift::JID(jid.getNode(), jid.getDomain()));

		}

		else {

			stanza->setFrom(Swift::JID(jid.getNode(), jid.getDomain(), stanza->getFrom().getResource()));

		}

	}

	else {

		std::string name = stanza->getFrom().toBare();

		if (conv && conv->isMUC()) {

			if (name.find_last_of("@") != std::string::npos) {

				name.replace(name.find_last_of("@"), 1, "%");

			}

		}

		else {

			if (CONFIG_BOOL_DEFAULTED(m_config, "service.jid_escaping", true)) {

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

			}

			else {

				if (name.find_last_of("@") != std::string::npos) {

					name.replace(name.find_last_of("@"), 1, "%");

				}

			}

		}

		if (stanza->getFrom().getResource().empty()) {

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

		}

		else {

			stanza->setFrom(Swift::JID(name, m_component->getJID().toString(), stanza->getFrom().getResource()));

		}

	}

	boost::shared_ptr<Swift::Message> message = boost::dynamic_pointer_cast<Swift::Message>(stanza);

	if (message) {

		if (conv) {

			conv->handleRawMessage(message);

			return;

		}

		m_component->getStanzaChannel()->sendMessage(message);

		return;

	}

	boost::shared_ptr<Swift::Presence> presence = boost::dynamic_pointer_cast<Swift::Presence>(stanza);

	if (presence) {

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

		if (buddy) {

			buddy->m_statusMessage = presence->getStatus();

			buddy->m_status = Swift::StatusShow(presence->getShow());

		}

		return;

	}

	boost::shared_ptr<Swift::IQ> iq = boost::dynamic_pointer_cast<Swift::IQ>(stanza);

	if (iq) {

		if (m_id2resource.find(stanza->getTo().toBare().toString() + stanza->getID()) != m_id2resource.end()) {

			iq->setTo(Swift::JID(iq->getTo().getNode(), iq->getTo().getDomain(), m_id2resource[stanza->getTo().toBare().toString() + stanza->getID()]));

			m_id2resource.erase(stanza->getTo().toBare().toString() + stanza->getID());

		}

		m_component->getIQRouter()->sendIQ(iq);

		return;

	}

}

void NetworkPluginServer::handleRawXML(const std::string &xml) {

	m_xmppParser->parse(xml);

}

void NetworkPluginServer::handleRawPresenceReceived(boost::shared_ptr<Swift::Presence> presence) {

	User *user = m_userManager->getUser(presence->getFrom().toBare());

	if (!user)

		return;

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

	if (!c) {

		return;

	}

	Swift::JID legacyname = Swift::JID(Buddy::JIDToLegacyName(presence->getTo()));

	if (!presence->getTo().getResource().empty()) {

		presence->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain(), presence->getTo().getResource()));

	}

	else {

		presence->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain()));

	}

	std::string xml = safeByteArrayToString(m_serializer->serializeElement(presence));

	WRAP(xml, pbnetwork::WrapperMessage_Type_TYPE_RAW_XML);

	send(c->connection, xml);

}

void NetworkPluginServer::handleRawIQReceived(boost::shared_ptr<Swift::IQ> iq) {

	User *user = m_userManager->getUser(iq->getFrom().toBare());

	if (!user)

		return;

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

	if (!c) {

		return;

	}

	if (iq->getType() == Swift::IQ::Get) {

		m_id2resource[iq->getFrom().toBare().toString() + iq->getID()] = iq->getFrom().getResource();

	}

	Swift::JID legacyname = Swift::JID(Buddy::JIDToLegacyName(iq->getTo()));

	if (!iq->getTo().getResource().empty()) {

		iq->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain(), iq->getTo().getResource()));

	}

	else {

		iq->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain()));

	}

	std::string xml = safeByteArrayToString(m_serializer->serializeElement(iq));

	WRAP(xml, pbnetwork::WrapperMessage_Type_TYPE_RAW_XML);

	send(c->connection, xml);

}

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

		// If backend is slow and it is sending us lot of message, there is possibility

		// that we don't receive PONG response before timeout. However, if we received

		// at least some data, it means backend is not dead and we can treat it as

		// PONG received event.

		if (c->pongReceived == false) {

			c->pongReceived = true;

		}

		// 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:

				handleStatsPayload(c, wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_FT_START:

				handleFTStartPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_FT_FINISH:

				handleFTFinishPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_FT_DATA:

				handleFTDataPayload(c, wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_REMOVED:

				handleBuddyRemovedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_QUERY:

				handleQueryPayload(c, wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BACKEND_CONFIG:

				handleBackendConfigPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_ROOM_LIST:

				handleRoomListPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE_ACK:

				handleConvMessageAckPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_RAW_XML:

				handleRawXML(wrapper.payload());

				break;

			default:

				return;

		}

	}

}

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

	// generate header - size of wrapper message

	uint32_t size = htonl(data.size());

	char *header = (char *) &size;

	// send header together with wrapper message

	c->write(Swift::createSafeByteArray(std::string(header, 4) + data));

}

void NetworkPluginServer::pingTimeout() {

	// TODO: move to separate timer, those 2 loops could be expensive

	// Some users are connected for weeks and they are blocking backend to be destroyed and its memory

	// to be freed. We are finding users who are inactive for more than "idle_reconnect_time" seconds and