set(purple_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(purple)

set(glib_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(glib)

set(popt_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(popt)

set(event_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(event)

set(Swiften_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(Swiften REQUIRED)

set(Boost_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(Boost COMPONENTS date_time system filesystem regex thread signals REQUIRED)

message( STATUS "Found Boost: ${Boost_LIBRARIES}, ${Boost_INCLUDE_DIR}")

set(Protobuf_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(Protobuf REQUIRED)

set(IRCClientQt_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(IRCClientQt)

set(log4cxx_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")

find_package(log4cxx)

find_package(Doxygen)

INCLUDE(FindQt4)

FIND_PACKAGE(Qt4 COMPONENTS QtCore)

# ADD_DEFINITIONS(${SWIFTEN_CFLAGS})

ADD_DEFINITIONS(-DSUPPORT_LEGACY_CAPS)

ADD_DEFINITIONS(-DBOOST_FILESYSTEM_VERSION=2)

message("  Supported features")

message("-----------------------")

if (SQLITE3_FOUND)

	ADD_DEFINITIONS(-DWITH_SQLITE)

	include_directories(${SQLITE3_INCLUDE_DIR})

	message("SQLite3           : yes")

else (SQLITE3_FOUND)

	set(SQLITE3_LIBRARIES "")

	message("SQLite3           : no")

endif (SQLITE3_FOUND)

if (MYSQL_FOUND)

	ADD_DEFINITIONS(-DWITH_MYSQL)

	include_directories(${MYSQL_INCLUDE_DIR})

	message("MySQL             : yes")

else (MYSQL_FOUND)

	set(MYSQL_LIBRARIES "")

	message("MySQL             : no (install mysql-devel)")

endif (MYSQL_FOUND)

if (PROTOBUF_FOUND)

	ADD_DEFINITIONS(-DWITH_PROTOBUF)

	include_directories(${PROTOBUF_INCLUDE_DIRS})

	message("Network plugins   : yes")

	if(PURPLE_LIBRARY AND PURPLE_INCLUDE_DIR)

		message("Libpurple plugin  : yes")

		include_directories(${PURPLE_INCLUDE_DIR})

		include_directories(${GLIB2_INCLUDE_DIR})

	else()

		message("Libpurple plugin  : no (install libpurple)")

	endif()

	if(IRC_FOUND)

		ADD_DEFINITIONS(-DIRC_SHARED)

		message("IRC plugin        : yes")

		include_directories(${IRC_INCLUDE_DIR})

		include(${QT_USE_FILE})

	else()

		message("IRC plugin        : no (install libircclient-qt and libprotobuf-dev)")

	endif()

	message("Frotz plugin      : yes")

else()

	message("Network plugins   : no (install libprotobuf-dev)")

	message("Libpurple plugin  : no (install libpurple and libprotobuf-dev)")

	message("IRC plugin        : no (install libircclient-qt and libprotobuf-dev)")

	message("Frotz plugin      : no (install libprotobuf-dev)")

endif()

if (LOG4CXX_FOUND)

	message("Logging           : yes")

	include_directories(${LOG4CXX_INCLUDE_DIR})

else()

	message(FATAL_ERROR "Logging           : no (install log4cxx-devel)")

endif()

if(CMAKE_BUILD_TYPE MATCHES Debug)

	ADD_DEFINITIONS(-ggdb)

	ADD_DEFINITIONS(-DDEBUG)

	ADD_DEFINITIONS(-Wall)

	ADD_DEFINITIONS(-W)

	ADD_DEFINITIONS(-Wcast-align)

	ADD_DEFINITIONS(-Wextra -Wno-sign-compare -Wno-unused-parameter)

	ADD_DEFINITIONS(-Winit-self)

	ADD_DEFINITIONS(-Wmissing-declarations)

	ADD_DEFINITIONS(-Wpointer-arith)

	ADD_DEFINITIONS(-Wreorder)

	ADD_DEFINITIONS(-Woverloaded-virtual)

	ADD_DEFINITIONS(-Wsign-promo)

	ADD_DEFINITIONS(-Wundef -Wunused)

	message("Debug             : yes")

else(CMAKE_BUILD_TYPE MATCHES Debug)

	message("Debug             : no (run \"cmake . -DCMAKE_BUILD_TYPE=Debug\")")

endif(CMAKE_BUILD_TYPE MATCHES Debug)

SET(TRANSPORT_VERSION 2.0)

SET(PROJECT_VERSION 2.0)

include_directories(include)

include_directories(${EVENT_INCLUDE_DIRS})

include_directories(${SWIFTEN_INCLUDE_DIR})

include_directories(${Boost_INCLUDE_DIRS})

ADD_SUBDIRECTORY(src)

ADD_SUBDIRECTORY(include)

#ADD_SUBDIRECTORY(examples)

ADD_SUBDIRECTORY(spectrum)

ADD_SUBDIRECTORY(backends)

#ADD_SUBDIRECTORY(tests)

ADD_SUBDIRECTORY(spectrum_manager)

if (CPPUNIT_FOUND)

	message("tests             : yes")

	include_directories(${CPPUNIT_INCLUDE_DIR})

else()

	message("tests             : no (install CPPUnit)")

endif()

if(DOXYGEN_FOUND)

	message("Docs              : yes")

	ADD_SUBDIRECTORY(docs)

else(DOXYGEN_FOUND)

	message("Docs              : no (install doxygen)")

endif(DOXYGEN_FOUND)

message("----------------------")

		/// Call this function when attention request arrived from legacy network.

		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")

		/// \param buddyName Name of legacy network buddy. (eg. "user2@gmail.com")

		/// \param message Message.

		void handleAttention(const std::string &user, const std::string &buddyName, const std::string &message);

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

		void handleFTData(unsigned long ftID, const std::string &data);

		/// Called when XMPP user wants to connect legacy network.

		/// You should connect him to legacy network and call handleConnected or handleDisconnected function later.

		/// \param user XMPP JID of user for which this event occurs.

		/// \param legacyName Legacy network name of this user used for login.

		/// \param password Legacy network password of this user.

		/**

			\msc

			NetworkPlugin,YourNetworkPlugin,LegacyNetwork;

			NetworkPlugin->YourNetworkPlugin [label="handleLoginRequest(...)", URL="\ref NetworkPlugin::handleLoginRequest()"];

			YourNetworkPlugin->LegacyNetwork [label="connect the legacy network"];

			--- [label="If password was valid and user is connected and logged in"];

			YourNetworkPlugin<-LegacyNetwork [label="connected"];

			YourNetworkPlugin->NetworkPlugin [label="handleConnected()", URL="\ref NetworkPlugin::handleConnected()"];

			--- [label="else"];

			YourNetworkPlugin<-LegacyNetwork [label="disconnected"];

			YourNetworkPlugin->NetworkPlugin [label="handleDisconnected()", URL="\ref NetworkPlugin::handleDisconnected()"];

			\endmsc

		*/

		virtual void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) = 0;

		/// Called when XMPP user wants to disconnect legacy network.

		/// You should disconnect him from legacy network.

		/// \param user XMPP JID of user for which this event occurs.

		/// \param legacyName Legacy network name of this user used for login.

		virtual void handleLogoutRequest(const std::string &user, const std::string &legacyName) = 0;

		/// Called when XMPP user sends message to legacy network.

		/// \param user XMPP JID of user for which this event occurs.

		/// \param legacyName Legacy network name of buddy or room.

		/// \param message Plain text message.

		/// \param xhtml XHTML message.

		virtual void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml = "") = 0;

		/// Called when XMPP user requests VCard of buddy.

		/// \param user XMPP JID of user for which this event occurs.

		/// \param legacyName Legacy network name of buddy whose VCard is requested.

		/// \param id ID which is associated with this request. You have to pass it to handleVCard function when you receive VCard.

		/**

			\msc

			NetworkPlugin,YourNetworkPlugin,LegacyNetwork;

			NetworkPlugin->YourNetworkPlugin [label="handleVCardRequest(...)", URL="\ref NetworkPlugin::handleVCardRequest()"];

			YourNetworkPlugin->LegacyNetwork [label="start VCard fetching"];

			YourNetworkPlugin<-LegacyNetwork [label="VCard fetched"];

			YourNetworkPlugin->NetworkPlugin [label="handleVCard()", URL="\ref NetworkPlugin::handleVCard()"];

			\endmsc

		*/

		virtual void handleVCardRequest(const std::string &/*user*/, const std::string &/*legacyName*/, unsigned int /*id*/) {}

		/// Called when XMPP user updates his own VCard.

		/// You should update the VCard in legacy network too.

		/// \param user XMPP JID of user for which this event occurs.

		/// \param photo Raw photo data.

		virtual void handleVCardUpdatedRequest(const std::string &/*user*/, const std::string &/*photo*/) {}

		virtual void handleJoinRoomRequest(const std::string &/*user*/, const std::string &/*room*/, const std::string &/*nickname*/, const std::string &/*pasword*/) {}

		virtual void handleLeaveRoomRequest(const std::string &/*user*/, const std::string &/*room*/) {}

		virtual void handleStatusChangeRequest(const std::string &/*user*/, int status, const std::string &statusMessage) {}

		virtual void handleBuddyUpdatedRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::string &/*alias*/, const std::string &/*groups*/) {}

		virtual void handleBuddyRemovedRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::string &/*groups*/) {}

		virtual void handleBuddyBlockToggled(const std::string &/*user*/, const std::string &/*buddyName*/, bool /*blocked*/) {}

		virtual void handleTypingRequest(const std::string &/*user*/, const std::string &/*buddyName*/) {}

		virtual void handleTypedRequest(const std::string &/*user*/, const std::string &/*buddyName*/) {}

		virtual void handleStoppedTypingRequest(const std::string &/*user*/, const std::string &/*buddyName*/) {}

		virtual void handleAttentionRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::string &/*message*/) {}

		virtual void handleFTStartRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::string &/*fileName*/, unsigned long size, unsigned long ftID) {}

		virtual void handleExit() { std::cout << "EXITING\n"; exit(1); }

	private:

		void connect();

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

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

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

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

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

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

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

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

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

		void handleChatStatePayload(const std::string &payload, Swift::ChatState::ChatStateType type);

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

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

		void _handleConnected(bool error);

		void handleDisconnected();

		void send(const std::string &data);

		void sendPong();

		void sendMemoryUsage();

		void pingTimeout();

		Swift::SafeByteArray m_data;

		std::string m_host;

		int m_port;

		Swift::BoostNetworkFactories *m_factories;

		Swift::BoostIOServiceThread m_boostIOServiceThread;

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

		Swift::EventLoop *m_loop;

		Swift::Timer::ref m_pingTimer;

		bool m_pingReceived;

		double m_init_res;

};

}

/**

 * libtransport -- C++ library for easy XMPP Transports development

 *

 * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

#pragma once

#include <time.h>

#include "Swiften/Swiften.h"

#include "Swiften/Presence/PresenceOracle.h"

#include "Swiften/Disco/EntityCapsManager.h"

#include "Swiften/Network/BoostConnectionServer.h"

#include "Swiften/Network/Connection.h"

#include "storagebackend.h"

namespace Transport {

class UserManager;

class User;

class Component;

class Buddy;

class LocalBuddy;

class Config;

class NetworkConversation;

class VCardResponder;

class RosterResponder;

class BlockResponder;

class NetworkPluginServer {

	public:

		struct Backend {

			int pongReceived;

			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;

		};

		NetworkPluginServer(Component *component, Config *config, UserManager *userManager);

		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 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 handleFTDataPayload(const std::string &payload);

		void handleUserCreated(User *user);

		void handleRoomJoined(User *user, const std::string &room, const std::string &nickname, const std::string &password);

		void handleRoomLeft(User *user, const std::string &room);

		void handleUserReadyToConnect(User *user);

		void handleUserPresenceChanged(User *user, Swift::Presence::ref presence);

		void handleUserDestroyed(User *user);

		void handleBuddyUpdated(Buddy *buddy, const Swift::RosterItemPayload &item);

		void handleBuddyRemoved(Buddy *buddy);

		void handleBuddyAdded(Buddy *buddy, const Swift::RosterItemPayload &item);

		void handleBlockToggled(Buddy *buddy);

		void handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> vcard);

		void handleVCardRequired(User *user, const std::string &name, unsigned int id);

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

};

}

	}

	handleAttentionRequest(payload.username(), payload.buddyname(), payload.message());

}

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

	pbnetwork::File payload;

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

		// TODO: ERROR

		return;

	}

	handleFTStartRequest(payload.username(), payload.buddyname(), payload.filename(), payload.size(), payload.ftid());

}

void NetworkPlugin::handleJoinRoomPayload(const std::string &data) {

	pbnetwork::Room payload;

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

		// TODO: ERROR

		return;

	}

	handleJoinRoomRequest(payload.username(), payload.room(), payload.nickname(), payload.password());

}

void NetworkPlugin::handleLeaveRoomPayload(const std::string &data) {

	pbnetwork::Room payload;

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

		// TODO: ERROR

		return;

	}

	handleLeaveRoomRequest(payload.username(), payload.room());

}

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

	pbnetwork::VCard payload;

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

		// TODO: ERROR

		return;

	}

	if (payload.has_photo()) {

		handleVCardUpdatedRequest(payload.username(), payload.photo());

	}

	else if (!payload.buddyname().empty()) {

		handleVCardRequest(payload.username(), payload.buddyname(), payload.id());

	}

}

void NetworkPlugin::handleBuddyChangedPayload(const std::string &data) {

	pbnetwork::Buddy payload;

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

		// TODO: ERROR

		return;

	}

	if (payload.has_blocked()) {

		handleBuddyBlockToggled(payload.username(), payload.buddyname(), payload.blocked());

	}

	else {

		handleBuddyUpdatedRequest(payload.username(), payload.buddyname(), payload.alias(), payload.groups());

	}

}

void NetworkPlugin::handleBuddyRemovedPayload(const std::string &data) {

	pbnetwork::Buddy payload;

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

		// TODO: ERROR

		return;

	}

	handleBuddyRemovedRequest(payload.username(), payload.buddyname(), payload.groups());

}

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

	pbnetwork::Buddy payload;

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

		// TODO: ERROR

		return;

	}

	switch(type) {

		case Swift::ChatState::Composing:

			handleTypingRequest(payload.username(), payload.buddyname());

			break;

		case Swift::ChatState::Paused:

			handleTypedRequest(payload.username(), payload.buddyname());

			break;

		case Swift::ChatState::Active:

			handleStoppedTypingRequest(payload.username(), payload.buddyname());

			break;

		default:

			break;

	}

}

	while (m_data.size() != 0) {

		unsigned int expected_size;

		if (m_data.size() >= 4) {

			expected_size = *((unsigned int*) &m_data[0]);

			expected_size = ntohl(expected_size);

			if (m_data.size() - 4 < expected_size)

				return;

		}

		else {

			return;

		}

		pbnetwork::WrapperMessage wrapper;

		if (wrapper.ParseFromArray(&m_data[4], expected_size) == false) {

			m_data.erase(m_data.begin(), m_data.begin() + 4 + expected_size);

			return;

		}

		m_data.erase(m_data.begin(), m_data.begin() + 4 + expected_size);

		switch(wrapper.type()) {

			case pbnetwork::WrapperMessage_Type_TYPE_LOGIN:

				handleLoginPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_LOGOUT:

				handleLogoutPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_PING:

				sendPong();

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE:

				handleConvMessagePayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_JOIN_ROOM:

				handleJoinRoomPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_LEAVE_ROOM:

				handleLeaveRoomPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_VCARD:

				handleVCardPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED:

				handleBuddyChangedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_REMOVED:

				handleBuddyRemovedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_STATUS_CHANGED:

				handleStatusChangedPayload(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_ATTENTION:

				handleAttentionPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_FT_START:

				handleFTStartPayload(wrapper.payload());

				break;

			default:

				return;

		}

	}

}

void NetworkPlugin::send(const std::string &data) {

	char header[4];

	*((int*)(header)) = htonl(data.size());

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

}

void NetworkPlugin::sendPong() {

	m_pingReceived = true;

	std::string message;

	pbnetwork::WrapperMessage wrap;

	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_PONG);

	wrap.SerializeToString(&message);

	send(message);

	LOG4CXX_INFO(logger, "PONG");

	sendMemoryUsage();

}

void NetworkPlugin::sendMemoryUsage() {

	pbnetwork::Stats stats;

	stats.set_init_res(m_init_res);

	double res;

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

	handleFTAccepted(user, payload.buddyname(), payload.filename(), payload.size(), 255);

}

void NetworkPluginServer::handleFTDataPayload(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;

	LOG4CXX_INFO(logger, "handleFTDataPayload size=" << payload.data().size());

}

	// Append data to buffer

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