Version 2.0.0-beta3 (2012-XX-XX):

	General:

	* Log errors related to backend spawning (Show proper log message for

	  example when path to backend binary is not found).

	* Update buddies in database only when it's needed and do not execute

	  useless database statements.

	* Send roster changes also when buddy's group change.

	* Fixed bug when transport contact we in all groups.

	* Answer to disco#info IQ with proper node (#206).

	* Set SQLite3 as default database backend.

	* Fixed disconnecting from server caused by sending VCard response

	  with bad "from" attribute.

	* Added Munin plugin (Thanks to Askovpen).

	* Added support for more admin_jid JIDs (Thanks to Askovpen).

	* Fixed allowed_servers option.

	Libpurple:

	* prpl-gg: Fetch the contact list properly (#252).

	Skype:

	* Log more errors.

	Backend API:

	* Added Python NetworkPlugin class, so it is now easier to write backends

	  in Python (Thanks to Sarang).

Version 2.0.0-beta2 (2012-03-28):

	General:

	* Fixed bug when Roster Item Exchange and subscribe stanzas were sent

	  repeatedly.

	* Backends related logs now contain the backend PID.

	* Fixed username_mask setting.

	* Added new fields into statistics (backends_crashed, messages related

	  stats).

	* Chatstates are now not counted as incoming messages in stats.

	* Log4cxx is now optional dependency. Without Log4cxx, Spectrum 2 logs

	  to standard output.

	* Fixed crash when Log4cxx configuration file didn't exist.

	* Admin can now see "Admin" contact in server-mode.

	libpurple:

	* Added initial support for MUC for prpl-jabber protocol.

	LibCommuni IRC backend:

	* Fixed sending/receiving UTF8 messages.

	* Using the [registration] auto_register=1 config option, users don't

 * 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 <vector>

#include "Swiften/Swiften.h"

#include "Swiften/Queries/GetResponder.h"

#include "Swiften/Elements/DiscoItems.h"

namespace Transport {

class DiscoItemsResponder : public Swift::GetResponder<Swift::DiscoItems> {

	public:

		~DiscoItemsResponder();

	private:

		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::DiscoItems> payload);

};

}

		/// \param loop Event loop.

		/// \param host Host where Spectrum2 NetworkPluginServer runs.

		/// \param port Port.

		NetworkPlugin();

		/// Destructor.

		virtual ~NetworkPlugin();

		void sendConfig(const PluginConfig &cfg);

		/// Call this function when legacy network buddy changed.

		/// \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 alias Alias of legacy network buddy. If empty, then it's not changed on XMPP side.

		/// \param groups Groups in which buddy currently is. If empty, then it's not changed on XMPP side.

		/// \param status Status of this buddy.

		/// \param statusMessage Status message of this buddy.

		/// \param iconHash MD5 hash of buddy icon. Empty if none buddy icon.

		/// \param blocked True if this buddy is blocked in privacy lists in legacy network.

		void handleBuddyChanged(const std::string &user, const std::string &buddyName, const std::string &alias,

			const std::vector<std::string> &groups, pbnetwork::StatusType status, const std::string &statusMessage = "", const std::string &iconHash = "",

			bool blocked = false

		);

		/// Call this function when participant in room changed.

		/// \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 nickname Nickname of participant. If participant renamed, this is old name of participant. (eg. "HanzZ")

		/// \param room Room in which participant changed. (eg. #spectrum)

		/// \param flags Participant flags.

		/// \param status Current status of participant. Swift::StatusShow::None if participant left the room.

		/// \param statusMessage Current status message of participant.

		/// \param newname New name of participant if he changed the nickname. Otherwise empty.

		void handleParticipantChanged(const std::string &user, const std::string &nickname, const std::string &room, int flags,

			pbnetwork::StatusType = pbnetwork::STATUS_NONE, const std::string &statusMessage = "", const std::string &newname = "");

		/// Call this function when user disconnected the legacy network because of some legacy network error.

		/// \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 error Reserved for future use, currently keep it on 0.

		/// \param message XMPP message which is sent to XMPP user.

		void handleDisconnected(const std::string &user, int error = 0, const std::string &message = "");

		/// Call this function when user connected the legacy network and is logged in.

		/// \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")

		void handleConnected(const std::string &user);

		/// Call this function when new message is received from legacy network for user.

		/// \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 legacyName Name of legacy network buddy or name of room. (eg. "user2@gmail.com")

		}

		const std::list<Backend *> &getBackends() {

			return m_clients;

		}

		const std::vector<std::string> &getCrashedBackends() {

			return m_crashedBackends;

		}

		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 handleDataRead(Backend *c, boost::shared_ptr<Swift::SafeByteArray> data);

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

		void handleFTDataPayload(Backend *b ,const std::string &payload);

		void handleUserCreated(User *user);

		void handleRoomJoined(User *user, const Swift::JID &who, 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);

/// Manages roster of one XMPP user.

class RosterManager {

	public:

		typedef std::map<std::string, Buddy *, std::less<std::string>, boost::pool_allocator< std::pair<std::string, Buddy *> > > BuddiesMap;

		/// Creates new RosterManager.

		/// \param user User associated with this RosterManager.

		/// \param component Transport instance associated with this roster.

		RosterManager(User *user, Component *component);

		/// Destructor.

		virtual ~RosterManager();

		/// Associates the buddy with this roster,

		/// and if the buddy is not already in XMPP user's server-side roster, the proper requests

		/// are sent to XMPP user (subscribe presences, Roster Item Exchange stanza or

		/// the buddy is added to server-side roster using remote-roster protoXEP).

		/// \param buddy Buddy

		void setBuddy(Buddy *buddy);

		/// Deassociates the buddy with this roster.

		/// \param buddy Buddy.

		void unsetBuddy(Buddy *buddy);

		Buddy *getBuddy(const std::string &name);

		void setStorageBackend(StorageBackend *storageBackend);

		void storeBuddy(Buddy *buddy);

		Swift::RosterPayload::ref generateRosterPayload();

		/// Returns user associated with this roster.

		/// \return User

		User *getUser() { return m_user; }

		const BuddiesMap &getBuddies() {

			return m_buddies;

		}

		bool isRemoteRosterSupported() {

			return m_supportRemoteRoster;

		}

		/// Called when new Buddy is added to this roster.

		/// \param buddy newly added Buddy

		boost::signal<void (Buddy *buddy)> onBuddySet;

		/// Called when Buddy has been removed from this roster.

		/// \param buddy removed Buddy

		boost::signal<void (Buddy *buddy)> onBuddyUnset;

		boost::signal<void (Buddy *buddy)> onBuddyAdded;

		boost::signal<void (Buddy *buddy)> onBuddyRemoved;

		void handleBuddyChanged(Buddy *buddy);

		void handleSubscription(Swift::Presence::ref presence);

		void sendBuddyRosterPush(Buddy *buddy);

		void sendBuddySubscribePresence(Buddy *buddy);

		void sendCurrentPresences(const Swift::JID &to);

		void sendCurrentPresence(const Swift::JID &from, const Swift::JID &to);

		void sendUnavailablePresences(const Swift::JID &to);

	private:

		void setBuddyCallback(Buddy *buddy);

		void sendRIE();

		void handleBuddyRosterPushResponse(Swift::ErrorPayload::ref error, Swift::SetRosterRequest::ref request, const std::string &key);

		void handleRemoteRosterResponse(boost::shared_ptr<Swift::RosterPayload> roster, Swift::ErrorPayload::ref error);

		std::map<std::string, Buddy *, std::less<std::string>, boost::pool_allocator< std::pair<std::string, Buddy *> > > m_buddies;

		Component *m_component;

		RosterStorage *m_rosterStorage;

		User *m_user;

		Swift::Timer::ref m_setBuddyTimer;

		Swift::Timer::ref m_RIETimer;

		std::list <Swift::SetRosterRequest::ref> m_requests;

		bool m_supportRemoteRoster;

		AddressedRosterRequest::ref m_remoteRosterRequest;

};

#include "Swiften/Disco/EntityCapsManager.h"

#include "Swiften/Disco/CapsManager.h"

#include "Swiften/Disco/CapsMemoryStorage.h"

#include "Swiften/Network/BoostTimerFactory.h"

#include "Swiften/Network/BoostIOServiceThread.h"

#include "Swiften/Server/UserRegistry.h"

#include "Swiften/Base/SafeByteArray.h"

#include "Swiften/Jingle/JingleSessionManager.h"

#include <boost/bind.hpp>

#include "transport/config.h"

#include "transport/factory.h"

#include "transport/presenceoracle.h"

#include <Swiften/Network/BoostConnectionServer.h>

namespace Transport {

	// typedef enum { 	CLIENT_FEATURE_ROSTERX = 2,

	// 				CLIENT_FEATURE_XHTML_IM = 4,

	// 				CLIENT_FEATURE_FILETRANSFER = 8,

	// 				CLIENT_FEATURE_CHATSTATES = 16

	// 				} SpectrumImportantFeatures;

	// 

	class StorageBackend;

	class DiscoInfoResponder;

	class Factory;

	class UserRegistry;

	/// Represents one transport instance.

	/// It's used to connect the Jabber server and provides transaction layer

	/// between Jabber server and other classes.

	///

	/// In server mode it represents Jabber server to which users can connect and use

	/// it as transport.

	class Component {

		public:

			/// Creates new Component instance.

			/// \param loop Main event loop.

			/// \param config Cofiguration; this class uses following Config values:

			/// 	- service.jid

			/// 	- service.password

			/// 	- service.server

			/// 	- service.port

			/// 	- service.server_mode

			/// \param factory Transport Abstract factory used to create basic transport structures.

			Component(Swift::EventLoop *loop, Swift::NetworkFactories *factories, Config *config, Factory *factory, Transport::UserRegistry *userRegistry = NULL);

			void handleConnected();

			void handleConnectionError(const Swift::ComponentError &error);

			void handleServerStopped(boost::optional<Swift::BoostConnectionServer::Error> e);

			void handlePresence(Swift::Presence::ref presence);

			void handleDataRead(const Swift::SafeByteArray &data);

			void handleDataWritten(const Swift::SafeByteArray &data);

			void handleDiscoInfoResponse(boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid);

			void handleCapsChanged(const Swift::JID& jid);

			Swift::NetworkFactories *m_factories;

			Swift::Component *m_component;

			Swift::Server *m_server;

			Swift::Timer::ref m_reconnectTimer;

			Swift::EntityCapsManager *m_entityCapsManager;

			Swift::CapsManager *m_capsManager;

			Swift::CapsMemoryStorage *m_capsMemoryStorage;

			PresenceOracle *m_presenceOracle;

			Swift::StanzaChannel *m_stanzaChannel;

			Swift::IQRouter *m_iqRouter;

			Transport::UserRegistry *m_userRegistry;

			StorageBackend *m_storageBackend;

 			DiscoInfoResponder *m_discoInfoResponder;

			int m_reconnectCount;

			Config* m_config;

			std::string m_protocol;

			Swift::JID m_jid;

			Factory *m_factory;

			Swift::EventLoop *m_loop;

		friend class User;

		friend class UserRegistration;

		friend class NetworkPluginServer;

	};

}

}

void NetworkPlugin::handleBuddyChanged(const std::string &user, const std::string &buddyName, const std::string &alias,

			const std::vector<std::string> &groups, pbnetwork::StatusType status, const std::string &statusMessage, const std::string &iconHash, bool blocked) {

	pbnetwork::Buddy buddy;

	buddy.set_username(user);

	buddy.set_buddyname(buddyName);

	buddy.set_alias(alias);

	for (std::vector<std::string>::const_iterator it = groups.begin(); it != groups.end(); it++) {

		buddy.add_group(*it);

	}

	buddy.set_status((pbnetwork::StatusType) status);

	buddy.set_statusmessage(statusMessage);

	buddy.set_iconhash(iconHash);

	buddy.set_blocked(blocked);

	std::string message;

	buddy.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);

	send(message);

}

void NetworkPlugin::handleBuddyTyping(const std::string &user, const std::string &buddyName) {

	pbnetwork::Buddy buddy;

	buddy.set_username(user);

	buddy.set_buddyname(buddyName);

	std::string message;

	buddy.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING);

	send(message);

}

void NetworkPlugin::handleBuddyTyped(const std::string &user, const std::string &buddyName) {

	pbnetwork::Buddy buddy;

	buddy.set_username(user);

	buddy.set_buddyname(buddyName);

	std::string message;

	buddy.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPED);

	send(message);

#include "transport/config.h"

#include "transport/transport.h"

#include "transport/filetransfermanager.h"

#include "transport/usermanager.h"

#include "transport/logger.h"

#include "transport/sqlite3backend.h"

#include "transport/mysqlbackend.h"

#include "transport/pqxxbackend.h"

#include "transport/userregistration.h"

#include "transport/networkpluginserver.h"

#include "transport/admininterface.h"

#include "transport/statsresponder.h"

#include "transport/usersreconnecter.h"

#include "transport/util.h"

#include "transport/gatewayresponder.h"

#include "transport/logging.h"

#include "Swiften/EventLoop/SimpleEventLoop.h"

#include <boost/filesystem.hpp>

#include <boost/algorithm/string.hpp>

#ifndef WIN32

#include "sys/signal.h"

#include <pwd.h>

#include <grp.h>

#include <sys/resource.h>

#include "libgen.h"

#else

#include <windows.h>

#endif

#include <sys/stat.h>

using namespace Transport;

DEFINE_LOGGER(logger, "Spectrum");

Swift::SimpleEventLoop *eventLoop_ = NULL;

Component *component_ = NULL;

UserManager *userManager_ = NULL;

static void stop_spectrum() {

	userManager_->removeAllUsers(false);

	UserManager userManager(&transport, &userRegistry, storageBackend);

	userManager_ = &userManager;

	UserRegistration *userRegistration = NULL;

	UsersReconnecter *usersReconnecter = NULL;

	if (storageBackend) {

		userRegistration = new UserRegistration(&transport, &userManager, storageBackend);

		userRegistration->start();

		usersReconnecter = new UsersReconnecter(&transport, storageBackend);

	}

	FileTransferManager ftManager(&transport, &userManager);

	NetworkPluginServer plugin(&transport, &config, &userManager, &ftManager);

	AdminInterface adminInterface(&transport, &userManager, &plugin, storageBackend);

	StatsResponder statsResponder(&transport, &userManager, &plugin, storageBackend);

	statsResponder.start();

	GatewayResponder gatewayResponder(transport.getIQRouter(), &userManager);

	gatewayResponder.start();

	eventLoop_ = &eventLoop;

	eventLoop.run();

	if (userRegistration) {

		userRegistration->stop();

		delete userRegistration;

	}

	if (usersReconnecter) {

		delete usersReconnecter;

	}

	delete storageBackend;

	delete factories;

	return 0;

}

/**

 * XMPP - libpurple transport

 *

 * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>

 *

 * 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

 */

#include <iostream>

#include <boost/bind.hpp>

#include "Swiften/Queries/IQRouter.h"

#include "Swiften/Swiften.h"

using namespace Swift;

using namespace boost;

namespace Transport {

}

DiscoItemsResponder::~DiscoItemsResponder() {

}

bool DiscoItemsResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::DiscoItems> info) {

		sendResponse(from, id, boost::shared_ptr<DiscoItems>(new DiscoItems()));

	}

	else {

		sendResponse(from, id, boost::shared_ptr<DiscoItems>(new DiscoItems()));

	}

	return true;

}

}

	}

	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_blockResponder = new BlockResponder(component->getIQRouter(), userManager);

	m_blockResponder->onBlockToggled.connect(boost::bind(&NetworkPluginServer::handleBlockToggled, this, _1));

	m_blockResponder->start();

	m_server = component->getNetworkFactories()->getConnectionServerFactory()->createConnectionServer(Swift::HostAddress(CONFIG_STRING(m_config, "service.backend_host")), boost::lexical_cast<int>(CONFIG_STRING(m_config, "service.backend_port")));

	m_server->onNewConnection.connect(boost::bind(&NetworkPluginServer::handleNewClientConnection, this, _1));

	m_server->start();

	LOG4CXX_INFO(logger, "Listening on host " << CONFIG_STRING(m_config, "service.backend_host") << " port " << CONFIG_STRING(m_config, "service.backend_port"));

	unsigned long pid = 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());

	LOG4CXX_INFO(logger, "Backend should now connect to Spectrum2 instance. Spectrum2 won't accept any connection before backend connects");

#ifndef _WIN32

	// wait if the backend process will still be alive after 1 second

	sleep(1);

	pid_t result;

	int status;

	result = waitpid(-1, &status, WNOHANG);

	if (result != 0) {

		if (WIFEXITED(status)) {

			if (WEXITSTATUS(status) != 0) {

				LOG4CXX_ERROR(logger, "Backend can not be started, exit_code=" << WEXITSTATUS(status) << ", possible error: " << strerror(WEXITSTATUS(status)));

			}

		}

		else {

			LOG4CXX_ERROR(logger, "Backend can not be started");

		}

	}

	signal(SIGCHLD, SigCatcher);

#endif

}

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;

	}

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