libtransport.git Changeset - 0b0e020cdf91

Changeset - 0b0e020cdf91

Parent rev.

Child rev.

[Not reviewed]

0 13 0

Jan Kaluza - 13 years ago 2012-12-18 10:59:52
hanzz.k@gmail.com

Add general API to set per user settings using adhoc commands which can be defaulted from config file. Add 'Send messages as headlines' Transport setting

13 files changed with 196 insertions and 8 deletions:

include/transport/adhoccommandfactory.h

include/transport/adhocmanager.h

include/transport/protocol.proto

include/transport/settingsadhoccommand.h

include/transport/user.h

src/adhocmanager.cpp

src/conversation.cpp

src/conversationmanager.cpp

src/networkpluginserver.cpp

src/settingsadhoccommand.cpp

src/tests/basictest.h

src/tests/conversationmanager.cpp

src/tests/settingsadhoccommand.cpp

0 comments (0 inline, 0 general)

include/transport/adhoccommandfactory.h

➞

Show inline comments

 /**
  * 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
  */
 #pragma once
 #include <string>
 #include <algorithm>
 #include <map>
 #include "transport/adhoccommand.h"
 #include "Swiften/Swiften.h"
 namespace Transport {
 class Component;
 class UserManager;
 class StorageBackend;
 class AdHocCommandFactory {
 	public:
 		AdHocCommandFactory() {}
 		/// Destructor.
 		virtual ~AdHocCommandFactory() {}
 		virtual AdHocCommand *createAdHocCommand(Component *component, UserManager *userManager, StorageBackend *storageBackend, const Swift::JID &initiator, const Swift::JID &to) = 0;
 		virtual std::string getNode() = 0;
 		virtual std::string getName() = 0;
 		virtual std::map<std::string, std::string> &getUserSettings() {
 			return m_userSettings;
+		}
 	protected:
 		std::map<std::string, std::string> m_userSettings;
 };
+}

include/transport/adhocmanager.h

➞

Show inline comments

 /**
  * 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
  */
 #pragma once
 #include <string>
 #include <algorithm>
 #include <map>
 #include "Swiften/Swiften.h"
 namespace Transport {
 class Conversation;
 class User;
 class Component;
 class DiscoItemsResponder;
 class AdHocCommandFactory;
 class AdHocCommand;
 class UserManager;
 class StorageBackend;
 /// Listens for AdHoc commands and manages all AdHoc commands sessions
 class AdHocManager : public Swift::Responder<Swift::Command> {
 	public:
 		typedef std::map<std::string, AdHocCommand *> CommandsMap;
 		typedef std::map<Swift::JID, CommandsMap> SessionsMap;
 		/// Creates new AdHocManager.
 		/// \param component Transport instance associated with this AdHocManager.
 		AdHocManager(Component *component, DiscoItemsResponder *discoItemsResponder, UserManager *userManager, StorageBackend *storageBackend = NULL);
 		/// Destructor.
 		virtual ~AdHocManager();
 		/// Starts handling AdHoc commands payloads.
 		void start();
 		/// Stops handling AdHoc commands payloads and destroys all existing
 		/// AdHoc commands sessions.
 		void stop();
 		/// Adds factory to create new AdHoc commands sessions of particular type.
 		void addAdHocCommand(AdHocCommandFactory *factory);
 		/// Remove sessions older than N seconds.
 		void removeOldSessions();
 	private:
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::Command> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::Command> payload);
 		void handleUserCreated(User *user);
 		Component *m_component;
 		DiscoItemsResponder *m_discoItemsResponder;
 		std::map<std::string, AdHocCommandFactory *> m_factories;
 		SessionsMap m_sessions;
 		Swift::Timer::ref m_collectTimer;
 		UserManager *m_userManager;
 		StorageBackend *m_storageBackend;
 };
+}

include/transport/protocol.proto

➞

Show inline comments

 package pbnetwork;
 enum ConnectionError {
 	CONNECTION_ERROR_NETWORK_ERROR = 0;
 	CONNECTION_ERROR_INVALID_USERNAME = 1;
 	CONNECTION_ERROR_AUTHENTICATION_FAILED = 2;
 	CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE = 3;
 	CONNECTION_ERROR_NO_SSL_SUPPORT = 4;
 	CONNECTION_ERROR_ENCRYPTION_ERROR = 5;
 	CONNECTION_ERROR_NAME_IN_USE = 6;
 	CONNECTION_ERROR_INVALID_SETTINGS = 7;
 	CONNECTION_ERROR_CERT_NOT_PROVIDED = 8;
 	CONNECTION_ERROR_CERT_UNTRUSTED = 9;
 	CONNECTION_ERROR_CERT_EXPIRED = 10;
 	CONNECTION_ERROR_CERT_NOT_ACTIVATED = 11;
 	CONNECTION_ERROR_CERT_HOSTNAME_MISMATCH = 12;
 	CONNECTION_ERROR_CERT_FINGERPRINT_MISMATCH = 13;
 	CONNECTION_ERROR_CERT_SELF_SIGNED = 14;
 	CONNECTION_ERROR_CERT_OTHER_ERROR = 15;
 	CONNECTION_ERROR_OTHER_ERROR = 16;
+}
 enum StatusType {
 	STATUS_ONLINE		= 0;
 	STATUS_AWAY			= 1;
 	STATUS_FFC			= 2;
 	STATUS_XA			= 3;
 	STATUS_DND			= 4;
 	STATUS_NONE			= 5;
 	STATUS_INVISIBLE	= 6;
+}
 message Connected {
 	required string user = 1;
+}
 message Disconnected {
 	required string user = 1;
 	required int32 error = 2;
 	optional string message = 3;
+}
 message Login {
 	required string user = 1;
 	required string legacyName = 2;
 	required string password = 3;
 	repeated string extraFields = 4;
+}
 message Logout {
 	required string user = 1;
 	required string legacyName = 2;
+}
 message Buddy {
 	required string userName = 1;
 	required string buddyName = 2;
 	optional string alias = 3;
 	repeated string group = 4;
 	optional StatusType status = 5;
 	optional string statusMessage = 6;
 	optional string iconHash = 7;
 	optional bool blocked = 8;
+}
 message ConversationMessage {
 	required string userName = 1;
 	required string buddyName = 2;
 	required string message = 3;
 	optional string nickname = 4;
 	optional string xhtml = 5;
 	optional string timestamp = 6;
 	optional bool headline = 7;
+}
 message Room {
 	required string userName = 1;
 	required string nickname = 2;
 	required string room = 3;
 	optional string password = 4;
+}
 message RoomList {
 	repeated string room = 1;
 	repeated string name = 2;
+}
 message Participant {
 	required string userName = 1;
 	required string room = 2;
 	required string nickname = 3;
 	required int32 flag = 4;
 	required StatusType status = 5;
 	optional string statusMessage = 6;
 	optional string newname = 7;
+}
 message VCard {
 	required string userName = 1;
 	required string buddyName = 2;
 	required int32 id = 3;
 	optional string fullname = 4;
 	optional string nickname = 5;
 	optional bytes photo = 6;
+}
 message Status {
 	required string userName = 1;
 	required StatusType status = 3;
 	optional string statusMessage = 4;
+}
 message Stats {
 	required int32 res = 1;
 	required int32 init_res = 2;
 	required int32 shared = 3;
 	required string id = 4;
+}
 message File {
 	required string userName = 1;
 	required string buddyName = 2;
 	required string fileName = 3;
 	required int32 size = 4;
 	optional int32 ftID = 5;
+}
 message FileTransferData {
 	required int32 ftID = 1;
 	required bytes data = 2;
+}
 message BackendConfig {
 	required string config = 1;
+}
 message WrapperMessage {
 	enum Type {
 		TYPE_CONNECTED 				= 1;
 		TYPE_DISCONNECTED 			= 2;
 		TYPE_LOGIN 					= 3;
 		TYPE_LOGOUT 				= 4;
 		TYPE_BUDDY_CHANGED			= 6;
 		TYPE_BUDDY_REMOVED			= 7;
 		TYPE_CONV_MESSAGE			= 8;
 		TYPE_PING					= 9;
 		TYPE_PONG					= 10;
 		TYPE_JOIN_ROOM				= 11;
 		TYPE_LEAVE_ROOM				= 12;
 		TYPE_PARTICIPANT_CHANGED	= 13;
 		TYPE_ROOM_NICKNAME_CHANGED	= 14;
 		TYPE_ROOM_SUBJECT_CHANGED	= 15;
 		TYPE_VCARD					= 16;
 		TYPE_STATUS_CHANGED			= 17;
 		TYPE_BUDDY_TYPING			= 18;
 		TYPE_BUDDY_STOPPED_TYPING	= 19;
 		TYPE_BUDDY_TYPED			= 20;
 		TYPE_AUTH_REQUEST			= 21;
 		TYPE_ATTENTION				= 22;
 		TYPE_STATS					= 23;
 		TYPE_FT_START				= 24;
 		TYPE_FT_FINISH				= 25;
 		TYPE_FT_DATA				= 26;
 		TYPE_FT_PAUSE				= 27;
 		TYPE_FT_CONTINUE			= 28;
 		TYPE_EXIT					= 29;
 		TYPE_BACKEND_CONFIG			= 30;
 		TYPE_QUERY					= 31;
 		TYPE_ROOM_LIST				= 32;
+	}
 	required Type type = 1;
 	optional bytes payload = 2;
+}
+;

include/transport/settingsadhoccommand.h

➞

Show inline comments

 /**
  * 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
  */
 #pragma once
 #include <string>
 #include <algorithm>
 #include <map>
 #include "Swiften/Swiften.h"
 #include "transport/adhoccommand.h"
 #include "transport/adhoccommandfactory.h"
 namespace Transport {
 class Component;
 class UserManager;
 class StorageBackend;
 class SettingsAdHocCommand : public AdHocCommand {
 	public:
 		typedef enum { Init, WaitingForResponse } State;
 		SettingsAdHocCommand(Component *component, UserManager *userManager, StorageBackend *storageBackend, const Swift::JID &initiator, const Swift::JID &to);
 		/// Destructor.
 		virtual ~SettingsAdHocCommand();
 		virtual boost::shared_ptr<Swift::Command> handleRequest(boost::shared_ptr<Swift::Command> payload);
 	private:
 		boost::shared_ptr<Swift::Command> getForm();
 		boost::shared_ptr<Swift::Command> handleResponse(boost::shared_ptr<Swift::Command> payload);
 		State m_state;
 };
 class SettingsAdHocCommandFactory : public AdHocCommandFactory {
 	public:
 		SettingsAdHocCommandFactory() {}
 		SettingsAdHocCommandFactory() {
 			m_userSettings["send_headlines"] = "0";
+		}
 		virtual ~SettingsAdHocCommandFactory() {}
 		AdHocCommand *createAdHocCommand(Component *component, UserManager *userManager, StorageBackend *storageBackend, const Swift::JID &initiator, const Swift::JID &to) {
 			return new SettingsAdHocCommand(component, userManager, storageBackend, initiator, to);
+		}
 		std::string getNode() {
 			return "settings";
+		}
 		std::string getName() {
 			return "Transport settings";
+		}
 };
+}

include/transport/user.h

➞

Show inline comments

 /**
  * 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/Disco/EntityCapsManager.h"
 #include "Swiften/Disco/EntityCapsProvider.h"
 #include "storagebackend.h"
 #include <Swiften/FileTransfer/OutgoingFileTransfer.h>
 #include "Swiften/Elements/SpectrumErrorPayload.h"
 namespace Transport {
 class Component;
 class RosterManager;
 class ConversationManager;
 class UserManager;
 class PresenceOracle;
 struct UserInfo;
 /// Represents online XMPP user.
 class User : public Swift::EntityCapsProvider {
 	public:
 		/// Creates new User class.
 		/// \param jid XMPP JID associated with this user
 		/// \param userInfo UserInfo struct with informations needed to connect
 		/// this user to legacy network
 		/// \param component Component associated with this user
 		User(const Swift::JID &jid, UserInfo &userInfo, Component * component, UserManager *userManager);
 		/// Destroyes User.
 		virtual ~User();
 		/// Returns JID of XMPP user who is currently connected using this User class.
 		/// \return full JID
 		const Swift::JID &getJID();
 		/// Returns full JID which supports particular feature or invalid JID.
 		/// \param feature disco#info feature.
 		/// \return full JID which supports particular feature or invalid JID.
 		Swift::JID getJIDWithFeature(const std::string &feature);
 		Swift::DiscoInfo::ref getCaps(const Swift::JID &jid) const;
 		/// Returns UserInfo struct with informations needed to connect the legacy network.
 		/// \return UserInfo struct
 		UserInfo &getUserInfo() { return m_userInfo; }
 		RosterManager *getRosterManager() { return m_rosterManager; }
 		ConversationManager *getConversationManager() { return m_conversationManager; }
 		Component *getComponent() { return m_component; }
 		UserManager *getUserManager() { return m_userManager; }
 		void setData(void *data) { m_data = data; }
 		void *getData() { return m_data; }
 		/// Handles presence from XMPP JID associated with this user.
 		/// \param presence Swift::Presence.
 		void handlePresence(Swift::Presence::ref presence, bool forceJoin = false);
 		void handleSubscription(Swift::Presence::ref presence);
 		void handleDiscoInfo(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info);
 		time_t &getLastActivity() {
 			return m_lastActivity;
+		}
 		void updateLastActivity() {
 			m_lastActivity = time(NULL);
+		}
 		/// Returns language.
 		/// \return language
 		const char *getLang() { return "en"; }
 		void handleDisconnected(const std::string &error, Swift::SpectrumErrorPayload::Error e = Swift::SpectrumErrorPayload::CONNECTION_ERROR_OTHER_ERROR);
 		bool isReadyToConnect() {
 			return m_readyForConnect;
+		}
 		void setConnected(bool connected);
 		void sendCurrentPresence();
 		void setIgnoreDisconnect(bool ignoreDisconnect);
 		bool isConnected() {
 			return m_connected;
+		}
 		int getResourceCount() {
 			return m_resources;
+		}
 		void addUserSetting(const std::string &key, const std::string &value) {
 			m_settings[key] = value;
+		}
 		const std::string &getUserSetting(const std::string &key) {
 			return m_settings[key];
+		}
 		boost::signal<void ()> onReadyToConnect;
 		boost::signal<void (Swift::Presence::ref presence)> onPresenceChanged;
 		boost::signal<void (const Swift::JID &who, const std::string &room, const std::string &nickname, const std::string &password)> onRoomJoined;
 		boost::signal<void (const std::string &room)> onRoomLeft;
 		boost::signal<void ()> onDisconnected;
 	private:
 		void onConnectingTimeout();
 		Swift::JID m_jid;
 		Component *m_component;
 		RosterManager *m_rosterManager;
 		UserManager *m_userManager;
 		ConversationManager *m_conversationManager;
 		Swift::EntityCapsManager *m_entityCapsManager;
 		PresenceOracle *m_presenceOracle;
 		UserInfo m_userInfo;
 		void *m_data;
 		bool m_connected;
 		bool m_readyForConnect;
 		bool m_ignoreDisconnect;
 		Swift::Timer::ref m_reconnectTimer;
 		boost::shared_ptr<Swift::Connection> connection;
 		time_t m_lastActivity;
 		std::map<Swift::JID, Swift::DiscoInfo::ref> m_legacyCaps;
 		std::vector<boost::shared_ptr<Swift::OutgoingFileTransfer> > m_filetransfers;
 		int m_resources;
 		int m_reconnectCounter;
 		std::list<Swift::Presence::ref> m_joinedRooms;
 		std::map<std::string, std::string> m_settings;
 };
+}

src/adhocmanager.cpp

➞

Show inline comments

 /**
  * XMPP - libpurple transport
+ *
  * Copyright (C) 2012, 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 "transport/adhocmanager.h"
 #include "transport/adhoccommandfactory.h"
 #include "transport/discoitemsresponder.h"
 #include "transport/conversation.h"
 #include "transport/usermanager.h"
 #include "transport/buddy.h"
 #include "transport/factory.h"
 #include "transport/user.h"
 #include "transport/logging.h"
 #include "transport/storagebackend.h"
 namespace Transport {
 DEFINE_LOGGER(logger, "AdHocManager");
 AdHocManager::AdHocManager(Component *component, DiscoItemsResponder *discoItemsResponder, UserManager *userManager, StorageBackend *storageBackend) : Swift::Responder<Swift::Command>(component->getIQRouter()){
 	m_component = component;
 	m_discoItemsResponder = discoItemsResponder;
 	m_userManager = userManager;
 	m_storageBackend = storageBackend;
 	m_collectTimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(20);
 	m_collectTimer->onTick.connect(boost::bind(&AdHocManager::removeOldSessions, this));
 	m_collectTimer->start();
 	m_userManager->onUserCreated.connect(boost::bind(&AdHocManager::handleUserCreated, this, _1));
+}
 AdHocManager::~AdHocManager() {
 	m_collectTimer->stop();
 	stop();
+}
 void AdHocManager::start() {
 	Swift::Responder<Swift::Command>::start();
+}
 void AdHocManager::stop() {
 	Swift::Responder<Swift::Command>::stop();
 	for (SessionsMap::iterator it = m_sessions.begin(); it != m_sessions.end(); it++) {
 		std::vector<std::string> candidates;
 		for (CommandsMap::iterator ct = it->second.begin(); ct != it->second.end(); ct++) {
 			delete ct->second;
+		}
+	}
 	m_sessions.clear();
+}
 void AdHocManager::handleUserCreated(User *user) {
 	if (!m_storageBackend) {
 		return;
+	}
 	for (std::map<std::string, AdHocCommandFactory *>::const_iterator it = m_factories.begin(); it != m_factories.end(); it++) {
 		for (std::map<std::string, std::string>::const_iterator it2 = it->second->getUserSettings().begin(); it2 != it->second->getUserSettings().end(); it2++) {
 			std::string value = CONFIG_STRING_DEFAULTED(m_component->getConfig(), it->second->getNode() + "." + it2->first, it2->second);
 			int type = (int) TYPE_BOOLEAN;
 			m_storageBackend->getUserSetting(user->getUserInfo().id, it2->first, type, value);
 			user->addUserSetting(it2->first, value);
+		}
+	}
+}
 void AdHocManager::addAdHocCommand(AdHocCommandFactory *factory) {
 	if (m_factories.find(factory->getNode()) != m_factories.end()) {
 		LOG4CXX_ERROR(logger, "Command with node " << factory->getNode() << " is already registered. Ignoring this attempt.");
 		return;
+	}
 	m_factories[factory->getNode()] = factory;
 	m_discoItemsResponder->addAdHocCommand(factory->getNode(), factory->getName());
+}
 void AdHocManager::removeOldSessions() {
 	unsigned long removedCommands = 0;
 	time_t now = time(NULL);
 	std::vector<std::string> toRemove;
 	for (SessionsMap::iterator it = m_sessions.begin(); it != m_sessions.end(); it++) {
 		std::vector<std::string> candidates;
 		for (CommandsMap::iterator ct = it->second.begin(); ct != it->second.end(); ct++) {
 			if (now - ct->second->getLastActivity() > 15*60) {
 				candidates.push_back(it->first);
 				delete ct->second;
 				removedCommands++;
+			}
+		}
 		BOOST_FOREACH(std::string &key, candidates) {
 			it->second.erase(key);
+		}
 		if (it->second.empty()) {
 			toRemove.push_back(it->first);
+		}
+	}
 	BOOST_FOREACH(std::string &key, toRemove) {
 		m_sessions.erase(key);
+	}
 	if (removedCommands > 0) {
 		LOG4CXX_INFO(logger, "Removed " << removedCommands << " old commands sessions.");
+	}
+}
 bool AdHocManager::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::Command> payload) {
 	return false;
+}
 bool AdHocManager::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::Command> payload) {
 	AdHocCommand *command = NULL;
 	// Try to find AdHocCommand according to 'from' and session_id
 	if (!payload->getSessionID().empty() && m_sessions.find(from) != m_sessions.end()) {
 		if (m_sessions[from].find(payload->getSessionID()) != m_sessions[from].end()) {
 			command = m_sessions[from][payload->getSessionID()];
+		}
 		else {
 			LOG4CXX_ERROR(logger, from.toString() << ": Unknown session id " << payload->getSessionID() << " - ignoring");
 			sendError(from, id, Swift::ErrorPayload::BadRequest, Swift::ErrorPayload::Modify);
 			return true;
+		}
+	}
 	// Check if we can create command with this node
 	else if (m_factories.find(payload->getNode()) != m_factories.end()) {
 		command = m_factories[payload->getNode()]->createAdHocCommand(m_component, m_userManager, m_storageBackend, from, to);
 		m_sessions[from][command->getId()] = command;
 		LOG4CXX_INFO(logger, from.toString() << ": Started new AdHoc command session with node " << payload->getNode());
+	}
 	else {
 		LOG4CXX_INFO(logger, from.toString() << ": Unknown node " << payload->getNode() << ". Can't start AdHoc command session.");
 		sendError(from, id, Swift::ErrorPayload::BadRequest, Swift::ErrorPayload::Modify);
 		return true;
+	}
 	if (!command) {
 		LOG4CXX_ERROR(logger, from.toString() << ": createAdHocCommand for node " << payload->getNode() << " returned NULL pointer");
 		sendError(from, id, Swift::ErrorPayload::BadRequest, Swift::ErrorPayload::Modify);
 		return true;
+	}
 	boost::shared_ptr<Swift::Command> response = command->handleRequest(payload);
 	if (!response) {
 		LOG4CXX_ERROR(logger, from.toString() << ": handleRequest for node " << payload->getNode() << " returned NULL pointer");
 		sendError(from, id, Swift::ErrorPayload::BadRequest, Swift::ErrorPayload::Modify);
 		return true;
+	}
 	response->setSessionID(command->getId());
 	sendResponse(from, id, response);
 	command->refreshLastActivity();
 	// Command completed, so we can remove it now
 	if (response->getStatus() == Swift::Command::Completed || response->getStatus() == Swift::Command::Canceled) {
 		// update userSettings map if user is already connected
 		User *user = m_userManager->getUser(from.toBare().toString());
 		if (user) {
 			handleUserCreated(user);
+		}
 		m_sessions[from].erase(command->getId());
 		if (m_sessions[from].empty()) {
 			m_sessions.erase(from);
+		}
 		delete command;
+	}
 	return true;
+}
+}

src/conversation.cpp

➞

Show inline comments

 /**
  * 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 "transport/conversation.h"
 #include "transport/conversationmanager.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/buddy.h"
 #include "transport/rostermanager.h"
 namespace Transport {
 Conversation::Conversation(ConversationManager *conversationManager, const std::string &legacyName, bool isMUC) : m_conversationManager(conversationManager) {
 	m_legacyName = legacyName;
 // 	m_conversationManager->addConversation(this);
 	m_muc = isMUC;
 	m_jid = m_conversationManager->getUser()->getJID().toBare();
 	m_sentInitialPresence = false;
+}
 Conversation::~Conversation() {
+}
 void Conversation::destroyRoom() {
 	if (m_muc) {
 		Swift::Presence::ref presence = Swift::Presence::create();
 		std::string legacyName = m_legacyName;
 		if (legacyName.find_last_of("@") != std::string::npos) {
 			legacyName.replace(legacyName.find_last_of("@"), 1, "%"); // OK
+		}
 		presence->setFrom(Swift::JID(legacyName, m_conversationManager->getComponent()->getJID().toBare(), m_nickname));
 		presence->setType(Swift::Presence::Unavailable);
 		Swift::MUCItem item;
 		item.affiliation = Swift::MUCOccupant::NoAffiliation;
 		item.role = Swift::MUCOccupant::NoRole;
 		item.actor = "Transport";
 		item.reason = "Spectrum 2 transport is being shut down.";
 		Swift::MUCUserPayload *p = new Swift::MUCUserPayload ();
 		p->addItem(item);
 		Swift::MUCUserPayload::StatusCode c;
 		c.code = 332;
 		p->addStatusCode(c);
 		Swift::MUCUserPayload::StatusCode c2;
 		c2.code = 307;
 		p->addStatusCode(c2);
 		presence->addPayload(boost::shared_ptr<Swift::Payload>(p));
 		BOOST_FOREACH(const Swift::JID &jid, m_jids) {
 			presence->setTo(jid);
 			m_conversationManager->getComponent()->getStanzaChannel()->sendPresence(presence);
+		}
+	}
+}
 void Conversation::setRoom(const std::string &room) {
 	m_room = room;
 	m_legacyName = m_room + "/" + m_legacyName;
+}
 void Conversation::handleMessage(boost::shared_ptr<Swift::Message> &message, const std::string &nickname) {
 	if (m_muc) {
 		message->setType(Swift::Message::Groupchat);
+	}
 	else {
 		message->setType(Swift::Message::Chat);
 		if (message->getType() != Swift::Message::Headline) {
 			if (m_conversationManager->getUser()->getUserSetting("send_headlines") == "1") {
 				message->setType(Swift::Message::Headline);
+			}
 			else {
 				message->setType(Swift::Message::Chat);
+			}
+		}
+	}
 	std::string n = nickname;
 	if (n.empty() && !m_room.empty() && !m_muc) {
 		n = m_nickname;
+	}
 	if (message->getType() != Swift::Message::Groupchat) {
 		message->setTo(m_jid);
 		// normal message
 		if (n.empty()) {
 			Buddy *buddy = m_conversationManager->getUser()->getRosterManager()->getBuddy(m_legacyName);
 			if (buddy) {
 				message->setFrom(buddy->getJID());
+			}
 			else {
 				std::string name = m_legacyName;
 				if (CONFIG_BOOL_DEFAULTED(m_conversationManager->getComponent()->getConfig(), "service.jid_escaping", true)) {
 					name = Swift::JID::getEscapedNode(m_legacyName);
+				}
 				else {
 					if (name.find_last_of("@") != std::string::npos) {
 						name.replace(name.find_last_of("@"), 1, "%");
+					}
+				}
 				message->setFrom(Swift::JID(name, m_conversationManager->getComponent()->getJID().toBare(), "bot"));
+			}
+		}
 		// PM message
 		else {
 			if (m_room.empty()) {
 				message->setFrom(Swift::JID(n, m_conversationManager->getComponent()->getJID().toBare(), "user"));
+			}
 			else {
 				message->setFrom(Swift::JID(m_room, m_conversationManager->getComponent()->getJID().toBare(), n));
+			}
+		}
 		m_conversationManager->getComponent()->getStanzaChannel()->sendMessage(message);
+	}
 	else {
 		std::string legacyName = m_legacyName;
 		if (legacyName.find_last_of("@") != std::string::npos) {
 			legacyName.replace(legacyName.find_last_of("@"), 1, "%"); // OK
+		}
 		std::string n = nickname;
 		if (n.empty()) {
 			n = " ";
+		}
 		BOOST_FOREACH(const Swift::JID &jid, m_jids) {
 			message->setTo(jid);
 			message->setFrom(Swift::JID(legacyName, m_conversationManager->getComponent()->getJID().toBare(), n));
 			// Subject has to be sent after our own presence (the one with code 110)
 			if (!message->getSubject().empty() && m_sentInitialPresence == false) {
 				m_subject = message;
 				return;
+			}
 			m_conversationManager->getComponent()->getStanzaChannel()->sendMessage(message);
+		}
+	}
+}
 void Conversation::sendParticipants(const Swift::JID &to) {
 	for (std::map<std::string, Participant>::iterator it = m_participants.begin(); it != m_participants.end(); it++) {
 		Swift::Presence::ref presence = generatePresence(it->first, it->second.flag, it->second.status, it->second.statusMessage, "");
 		presence->setTo(to);
 		m_conversationManager->getComponent()->getStanzaChannel()->sendPresence(presence);
+	}
+}
 Swift::Presence::ref Conversation::generatePresence(const std::string &nick, int flag, int status, const std::string &statusMessage, const std::string &newname) {
 	std::string nickname = nick;
 	Swift::Presence::ref presence = Swift::Presence::create();
 	std::string legacyName = m_legacyName;
 	if (m_muc) {
 		if (legacyName.find_last_of("@") != std::string::npos) {
 			legacyName.replace(legacyName.find_last_of("@"), 1, "%"); // OK
+		}
+	}
 	presence->setFrom(Swift::JID(legacyName, m_conversationManager->getComponent()->getJID().toBare(), nickname));
 	presence->setType(Swift::Presence::Available);
 	if (!statusMessage.empty())
 		presence->setStatus(statusMessage);
 	Swift::StatusShow s((Swift::StatusShow::Type) status);
 	if (s.getType() == Swift::StatusShow::None) {
 		presence->setType(Swift::Presence::Unavailable);
+	}
 	presence->setShow(s.getType());
 	Swift::MUCUserPayload *p = new Swift::MUCUserPayload ();
 	if (m_nickname == nickname) {
 		Swift::MUCUserPayload::StatusCode c;
 		c.code = 110;
 		p->addStatusCode(c);
 		m_sentInitialPresence = true;
+	}
 	Swift::MUCItem item;
 	item.affiliation = Swift::MUCOccupant::Member;
 	item.role = Swift::MUCOccupant::Participant;
 	if (flag & Moderator) {
 		item.affiliation = Swift::MUCOccupant::Admin;
 		item.role = Swift::MUCOccupant::Moderator;
+	}
 	if (!newname.empty()) {
 		item.nick = newname;
 		Swift::MUCUserPayload::StatusCode c;
 		c.code = 303;
 		p->addStatusCode(c);
 		presence->setType(Swift::Presence::Unavailable);
+	}
 	p->addItem(item);
 	presence->addPayload(boost::shared_ptr<Swift::Payload>(p));
 	return presence;
+}
 void Conversation::handleParticipantChanged(const std::string &nick, int flag, int status, const std::string &statusMessage, const std::string &newname) {
 	Swift::Presence::ref presence = generatePresence(nick, flag, status, statusMessage, newname);
 	if (presence->getType() == Swift::Presence::Unavailable) {
 		m_participants.erase(nick);
+	}
 	else {
 		Participant p;
 		p.flag = flag;
 		p.status = status;
 		p.statusMessage = statusMessage;
 		m_participants[nick] = p;
+	}
 	BOOST_FOREACH(const Swift::JID &jid, m_jids) {
 		presence->setTo(jid);
 		m_conversationManager->getComponent()->getStanzaChannel()->sendPresence(presence);
+	}
 	if (!newname.empty()) {
 		handleParticipantChanged(newname, flag, status, statusMessage);
+	}
 	if (m_sentInitialPresence && m_subject) {
 		m_conversationManager->getComponent()->getStanzaChannel()->sendMessage(m_subject);
 		m_subject.reset();
+	}
+}
+}

src/conversationmanager.cpp

➞

Show inline comments

 /**
  * 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 "transport/conversationmanager.h"
 #include "transport/conversation.h"
 #include "transport/usermanager.h"
 #include "transport/buddy.h"
 #include "transport/factory.h"
 #include "transport/user.h"
 #include "transport/logging.h"
 #include "Swiften/Roster/SetRosterRequest.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/Elements/RosterItemPayload.h"
 namespace Transport {
 DEFINE_LOGGER(logger, "ConversationManager");
 ConversationManager::ConversationManager(User *user, Component *component){
 	m_user = user;
 	m_component = component;
+}
 ConversationManager::~ConversationManager() {
 	while(!m_convs.empty()) {
 		LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Removing conversation " << (*m_convs.begin()).first);
 		(*m_convs.begin()).second->destroyRoom();
 		delete (*m_convs.begin()).second;
 		m_convs.erase(m_convs.begin());
+	}
 	deleteAllConversations();
+}
 void ConversationManager::deleteAllConversations() {
 	while(!m_convs.empty()) {
 		LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Removing conversation " << (*m_convs.begin()).first);
 		(*m_convs.begin()).second->destroyRoom();
 		delete (*m_convs.begin()).second;
 		m_convs.erase(m_convs.begin());
+	}
+}
 Conversation *ConversationManager::getConversation(const std::string &name) {
 	if (m_convs.find(name) != m_convs.end())
 		return m_convs[name];
 	if (name.find("/") == std::string::npos) {
 		return NULL;
+	}
 	// handle PMs
 	std::string room = name.substr(0, name.find("/"));
 	std::string nick = name.substr(name.find("/") + 1);
 	if (getConversation(room) == NULL) {
 		return NULL;
+	}
 	return getConversation(nick);
+}
 void ConversationManager::addConversation(Conversation *conv) {
 	m_convs[conv->getLegacyName()] = conv;
 	LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Adding conversation " << conv->getLegacyName());
+}
 void ConversationManager::removeConversation(Conversation *conv) {
 	for (std::map<std::string, Conversation *>::const_iterator it = m_convs.begin(); it != m_convs.end(); it++) {
 		if ((*it).second->getRoom() == conv->getLegacyName()) {
 			(*it).second->setRoom("");
+		}
+	}
 	m_convs.erase(conv->getLegacyName());
+}
 void ConversationManager::resetResources() {
 	for (std::map<std::string, Conversation *>::const_iterator it = m_convs.begin(); it != m_convs.end(); it++) {
 		if ((*it).second->isMUC()) {
 			continue;
+		}
 		(*it).second->setJID(m_user->getJID().toBare());
+	}
+}
 void ConversationManager::removeJID(const Swift::JID &jid) {
 	for (std::map<std::string, Conversation *>::const_iterator it = m_convs.begin(); it != m_convs.end(); it++) {
 		(*it).second->removeJID(jid);
+	}
+}
 void ConversationManager::handleMessageReceived(Swift::Message::ref message) {
 // 	std::string name = message->getTo().getUnescapedNode();
 // 	if (name.find_last_of("%") != std::string::npos) { // OK when commented
 // 		name.replace(name.find_last_of("%"), 1, "@"); // OK when commented
 // 	}
 	std::string name = Buddy::JIDToLegacyName(message->getTo());
 	if (name.empty()) {
 		LOG4CXX_WARN(logger, m_user->getJID().toString() << ": Tried to create empty conversation");
 		return;
+	}
 	// create conversation if it does not exist.
 	if (!m_convs[name]) {
 		Conversation *conv = m_component->getFactory()->createConversation(this, name);
 		addConversation(conv);
+	}
 	// if it exists and it's MUC, but this message is PM, get PM conversation or create new one.
 	else if (m_convs[name]->isMUC() && message->getType() != Swift::Message::Groupchat) {
 		std::string room_name = name;
 		name = room_name + "/" + message->getTo().getResource();
 		if (m_convs.find(name) == m_convs.end()) {
 			Conversation *conv = m_component->getFactory()->createConversation(this, message->getTo().getResource());
 			conv->setRoom(room_name);
 			conv->setNickname(name);
 			addConversation(conv);
+		}
+	}
 	// update resource and send the message
 	m_convs[name]->setJID(message->getFrom());
 	m_convs[name]->sendMessage(message);
+}
+}

src/networkpluginserver.cpp

➞

Show inline comments

 /**
  * 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
  */
 #include "transport/networkpluginserver.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/storagebackend.h"
 #include "transport/rostermanager.h"
 #include "transport/usermanager.h"
 #include "transport/conversationmanager.h"
 #include "transport/localbuddy.h"
 #include "transport/config.h"
 #include "transport/conversation.h"
 #include "transport/vcardresponder.h"
 #include "transport/rosterresponder.h"
 #include "transport/memoryreadbytestream.h"
 #include "transport/logging.h"
 #include "transport/admininterface.h"
 #include "blockresponder.h"
 #include "Swiften/Swiften.h"
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Elements/StreamError.h"
 #include "Swiften/Network/BoostConnectionServer.h"
 #include "Swiften/Elements/AttentionPayload.h"
 #include "Swiften/Elements/XHTMLIMPayload.h"
 #include "Swiften/Elements/InvisiblePayload.h"
 #include "Swiften/Elements/SpectrumErrorPayload.h"
 #include "transport/protocol.pb.h"
 #include "transport/util.h"
 #include "transport/discoitemsresponder.h"
 #include "utf8.h"
 #include <Swiften/FileTransfer/ReadBytestream.h>
 #include <Swiften/Elements/StreamInitiationFileInfo.h>
 #ifdef _WIN32
 #include "windows.h"
 #include <stdint.h>
 #else
 #include "sys/wait.h"
 #include "sys/signal.h"
 #include <sys/types.h>
 #include <signal.h>
 #include "popt.h"
 #endif
 using namespace Transport::Util;
 namespace Transport {
 static unsigned long backend_id;
 static unsigned long bytestream_id;
 DEFINE_LOGGER(logger, "NetworkPluginServer");
 class NetworkConversation : public Conversation {
 	public:
 		NetworkConversation(ConversationManager *conversationManager, const std::string &legacyName, bool muc = false) : Conversation(conversationManager, legacyName, muc) {
+		}
 		// Called when there's new message to legacy network from XMPP network
 		void sendMessage(boost::shared_ptr<Swift::Message> &message) {
 			onMessageToSend(this, message);
+		}
 		boost::signal<void (NetworkConversation *, boost::shared_ptr<Swift::Message> &)> onMessageToSend;
 };
 class NetworkFactory : public Factory {
 	public:
 		NetworkFactory(NetworkPluginServer *nps) {
 			m_nps = nps;
+		}
 		virtual ~NetworkFactory() {}
 		// Creates new conversation (NetworkConversation in this case)
 		Conversation *createConversation(ConversationManager *conversationManager, const std::string &legacyName, bool isMuc) {
 			NetworkConversation *nc = new NetworkConversation(conversationManager, legacyName, isMuc);
 			nc->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, m_nps, _1, _2));
 			return nc;
+		}
 		// Creates new LocalBuddy
 		Buddy *createBuddy(RosterManager *rosterManager, const BuddyInfo &buddyInfo) {
 			LocalBuddy *buddy = new LocalBuddy(rosterManager, buddyInfo.id, buddyInfo.legacyName, buddyInfo.alias, buddyInfo.groups, (BuddyFlag) buddyInfo.flags);
 			if (!buddy->isValid()) {
 				delete buddy;
 				return NULL;
+			}
 			if (buddyInfo.subscription == "both") {
 				buddy->setSubscription(Buddy::Both);
+			}
 			else {
 				buddy->setSubscription(Buddy::Ask);
+			}
 			if (buddyInfo.settings.find("icon_hash") != buddyInfo.settings.end())
 				buddy->setIconHash(buddyInfo.settings.find("icon_hash")->second.s);
 			return buddy;
+		}
 	private:
 		NetworkPluginServer *m_nps;
 };
 // Wraps google protobuf payload into WrapperMessage and serialize it to string
 #define WRAP(MESSAGE, TYPE) 	pbnetwork::WrapperMessage wrap; \
 	wrap.set_type(TYPE); \
 	wrap.set_payload(MESSAGE); \
 	wrap.SerializeToString(&MESSAGE);
 // Executes new backend
 static unsigned long exec_(const std::string& exePath, const char *host, const char *port, const char *cmdlineArgs) {
 	// BACKEND_ID is replaced with unique ID. The ID is increasing for every backend.
 	std::string finalExePath = boost::replace_all_copy(exePath, "BACKEND_ID", boost::lexical_cast<std::string>(backend_id++));
 #ifdef _WIN32
 	// Add host and port.
 	std::ostringstream fullCmdLine;
 	fullCmdLine << "\"" << finalExePath << "\" --host " << host << " --port " << port;
 	if (cmdlineArgs)
 		fullCmdLine << " " << cmdlineArgs;
 	LOG4CXX_INFO(logger, "Starting new backend " << fullCmdLine.str());
 	// We must provide a non-const buffer to CreateProcess below
 	std::vector<wchar_t> rawCommandLineArgs( fullCmdLine.str().size() + 1 );
 	wcscpy_s(&rawCommandLineArgs[0], rawCommandLineArgs.size(), utf8ToUtf16(fullCmdLine.str()).c_str());
 	STARTUPINFO         si;
 	PROCESS_INFORMATION pi;
 	ZeroMemory (&si, sizeof(si));
 	si.cb=sizeof (si);
 	if (! CreateProcess(
 		utf8ToUtf16(finalExePath).c_str(),
 		&rawCommandLineArgs[0],
 ,                    // process attributes
 ,                    // thread attributes
 ,                    // inherit handles
 ,                    // creation flags
 ,                    // environment
 ,                    // cwd
 		&si,
 		&pi
+		)
 	)  {
 		LOG4CXX_ERROR(logger, "Could not start process");
+	}
 	return 0;
 #else
 	// Add host and port.
 	finalExePath += std::string(" --host ") + host + " --port " + port + " " + cmdlineArgs;
 	LOG4CXX_INFO(logger, "Starting new backend " << finalExePath);
 	// Create array of char * from string using -lpopt library
 	char *p = (char *) malloc(finalExePath.size() + 1);
 	strcpy(p, finalExePath.c_str());
 	int argc;
 	char **argv;
 	poptParseArgvString(p, &argc, (const char ***) &argv);
 	// fork and exec
 	pid_t pid = fork();
 	if ( pid == 0 ) {
 		setsid();
 		// close all files
 		int maxfd=sysconf(_SC_OPEN_MAX);
 		for(int fd=3; fd<maxfd; fd++) {
 			close(fd);
+		}
 		// child process
 		errno = 0;
 		int ret = execv(argv[0], argv);
 		if (ret == -1) {
 			exit(errno);
+		}
 		exit(0);
 	} else if ( pid < 0 ) {
 		LOG4CXX_ERROR(logger, "Fork failed");
+	}
 	free(p);
 	return (unsigned long) pid;
 #endif
+}
 #ifndef _WIN32
 static void SigCatcher(int n) {
 	pid_t result;
 	int status;
 	// Read exit code from all children to not have zombies arround
 	// WARNING: Do not put LOG4CXX_ here, because it can lead to deadlock
 	while ((result = waitpid(-1, &status, WNOHANG)) > 0) {
 		if (result != 0) {
 			if (WIFEXITED(status)) {
 				if (WEXITSTATUS(status) != 0) {
 // 					LOG4CXX_ERROR(logger, "Backend can not be started, exit_code=" << WEXITSTATUS(status));
+				}
+			}
 			else {
 // 				LOG4CXX_ERROR(logger, "Backend can not be started");
+			}
+		}
+	}
+}
 #endif
 static void handleBuddyPayload(LocalBuddy *buddy, const pbnetwork::Buddy &payload) {
 	// Set alias only if it's not empty. Backends are allowed to send empty alias if it has
 	// not changed.
 	if (!payload.alias().empty()) {
 		buddy->setAlias(payload.alias());
+	}
 	// Change groups if it's not empty. The same as above...
 	std::vector<std::string> groups;
 	for (int i = 0; i < payload.group_size(); i++) {
 		std::string group = payload.group(i);
 		utf8::replace_invalid(payload.group(i).begin(), payload.group(i).end(), group.begin(), '_');
 		groups.push_back(group);
+	}
 	if (!groups.empty()) {
 		buddy->setGroups(groups);
+	}
 	buddy->setStatus(Swift::StatusShow((Swift::StatusShow::Type) payload.status()), payload.statusmessage());
 	buddy->setIconHash(payload.iconhash());
 	buddy->setBlocked(payload.blocked());
+}
 NetworkPluginServer::NetworkPluginServer(Component *component, Config *config, UserManager *userManager, FileTransferManager *ftManager, DiscoItemsResponder *discoItemsResponder) {
 	m_ftManager = ftManager;
 	m_userManager = userManager;
 	m_config = config;
 	m_component = component;
 	m_isNextLongRun = false;
 	m_adminInterface = NULL;
 	m_startingBackend = false;
 	m_discoItemsResponder = discoItemsResponder;
 	m_component->m_factory = new NetworkFactory(this);
 	m_userManager->onUserCreated.connect(boost::bind(&NetworkPluginServer::handleUserCreated, this, _1));
 	m_userManager->onUserDestroyed.connect(boost::bind(&NetworkPluginServer::handleUserDestroyed, this, _1));
 	m_pingTimer = component->getNetworkFactories()->getTimerFactory()->createTimer(20000);
 	m_pingTimer->onTick.connect(boost::bind(&NetworkPluginServer::pingTimeout, this));
 	m_pingTimer->start();
 	if (CONFIG_INT(m_config, "service.memory_collector_time") != 0) {
 		m_collectTimer = component->getNetworkFactories()->getTimerFactory()->createTimer(CONFIG_INT(m_config, "service.memory_collector_time"));
 		m_collectTimer->onTick.connect(boost::bind(&NetworkPluginServer::collectBackend, this));
 		m_collectTimer->start();
+	}
 	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));
+}
 NetworkPluginServer::~NetworkPluginServer() {
 	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {
 		LOG4CXX_INFO(logger, "Stopping backend " << *it);
 		std::string message;
 		pbnetwork::WrapperMessage wrap;
 		wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_EXIT);
 		wrap.SerializeToString(&message);
 		Backend *c = (Backend *) *it;
 		send(c->connection, message);
+	}
 	m_pingTimer->stop();
 	m_server->stop();
 	m_server.reset();
 	delete m_component->m_factory;
 	delete m_vcardResponder;
 	delete m_rosterResponder;
 	delete m_blockResponder;
+}
 void NetworkPluginServer::start() {
 	m_server->start();
 	LOG4CXX_INFO(logger, "Listening on host " << CONFIG_STRING(m_config, "service.backend_host") << " port " << CONFIG_STRING(m_config, "service.backend_port"));
 	while (true) {
 		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->getCommandLineArgs().c_str());
 		LOG4CXX_INFO(logger, "Tried to spawn first backend with pid " << pid);
 		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) {
 					if (status == 254) {
 						LOG4CXX_ERROR(logger, "Backend can not be started, because it needs database to store data, but the database backend is not configured.");
+					}
 					else {
 						LOG4CXX_ERROR(logger, "Backend can not be started, exit_code=" << WEXITSTATUS(status) << ", possible error: " << strerror(WEXITSTATUS(status)));
+					}
 					LOG4CXX_ERROR(logger, "Check backend log for more details");
 					continue;
+				}
+			}
 			else {
 				LOG4CXX_ERROR(logger, "Backend can not be started");
 				continue;
+			}
+		}
 		signal(SIGCHLD, SigCatcher);
 #endif
 		// quit the while loop
 		break;
+	}
+}
 void NetworkPluginServer::handleNewClientConnection(boost::shared_ptr<Swift::Connection> c) {
 	// Create new Backend instance
 	Backend *client = new Backend;
 	client->pongReceived = -1;
 	client->connection = c;
 	client->res = 0;
 	client->init_res = 0;
 	client->shared = 0;
 	// Until we receive first PONG from backend, backend is in willDie state.
 	client->willDie = true;
 	// Backend does not accept new clients automatically if it's long-running
 	client->acceptUsers = !m_isNextLongRun;
 	client->longRun = m_isNextLongRun;
 	m_startingBackend = false;
 	LOG4CXX_INFO(logger, "New" + (client->longRun ? std::string(" long-running") : "") +  " backend " << client << " connected. Current backend count=" << (m_clients.size() + 1));
 	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;
+}
 void NetworkPluginServer::handleSessionFinished(Backend *c) {
 	LOG4CXX_INFO(logger, "Backend " << c << " (ID=" << c->id << ") 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
 	if (!c->users.empty()) {
 		m_crashedBackends.push_back(c->id);
+	}
 	for (std::list<User *>::const_iterator it = c->users.begin(); it != c->users.end(); it++) {
 		LOG4CXX_ERROR(logger, "Backend " << c << " (ID=" << c->id << ") 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;
+	}
 	std::string field = payload.fullname();
 	boost::shared_ptr<Swift::VCard> vcard(new Swift::VCard());
 	utf8::replace_invalid(payload.fullname().begin(), payload.fullname().end(), field.begin(), '_');
 	vcard->setFullName(field);
 	field = payload.nickname();
 	utf8::replace_invalid(payload.nickname().begin(), payload.nickname().end(), field.begin(), '_');
 	vcard->setNickname(field);
 	vcard->setPhoto(Swift::createByteArray(payload.photo()));
 	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();
 	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, "%");
+		}
+	}
 	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 {
 		if (payload.buddyname() == user->getUserInfo().uin) {
 			return;
+		}
 		std::vector<std::string> groups;
 		for (int i = 0; i < payload.group_size(); i++) {
 			groups.push_back(payload.group(i));
+		}
 		if (CONFIG_BOOL_DEFAULTED(m_config, "service.jid_escaping", true)) {
 			buddy = new LocalBuddy(user->getRosterManager(), -1, payload.buddyname(), payload.alias(), groups, BUDDY_JID_ESCAPING);
+		}
 		else {
 			buddy = new LocalBuddy(user->getRosterManager(), -1, payload.buddyname(), payload.alias(), groups, BUDDY_NO_FLAG);
+		}
 		if (!buddy->isValid()) {
 			delete buddy;
 			return;
+		}
 		buddy->setStatus(Swift::StatusShow((Swift::StatusShow::Type) payload.status()), payload.statusmessage());
 		buddy->setIconHash(payload.iconhash());
 		buddy->setBlocked(payload.blocked());
 		user->getRosterManager()->setBuddy(buddy);
+	}
+}
 void NetworkPluginServer::handleBuddyRemovedPayload(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;
 	user->getRosterManager()->removeBuddy(payload.buddyname());
+}
 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());
+	}
 	if (payload.headline()) {
 		msg->setType(Swift::Message::Headline);
+	}
 	// 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());
 		boost::shared_ptr<Swift::Delay> delay(boost::make_shared<Swift::Delay>());
 		delay->setStamp(timestamp);
 		msg->addPayload(delay);
+	}
 	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;
 	if (m_filetransfers.find(payload.ftid()) == m_filetransfers.end()) {
 		LOG4CXX_ERROR(logger, "Uknown filetransfer with id " << payload.ftid());
 		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);
 		// 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;
 			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
 	// reconnect them to long-running backend, where they can idle hapilly till the end of ages.
 	time_t now = time(NULL);
 	std::vector<User *> usersToMove;
 	unsigned long diff = CONFIG_INT(m_config, "service.idle_reconnect_time");
 	if (diff != 0) {
 		for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {
 			// Users from long-running backends can't be moved
 			if ((*it)->longRun) {
 				continue;
+			}
 			// Find users which are inactive for more than 'diff'
 			BOOST_FOREACH(User *u, (*it)->users) {
 				if (now - u->getLastActivity() > diff) {
 					usersToMove.push_back(u);
+				}
+			}
+		}
 		// Move inactive users to long-running backend.
 		BOOST_FOREACH(User *u, usersToMove) {
 			LOG4CXX_INFO(logger, "Moving user " << u->getJID().toString() << " to long-running backend");
 			if (!moveToLongRunBackend(u))
 				break;
+		}
+	}
 	// We have to remove startingBackend flag otherwise 1 broken backend start could
 	// block the backend.
 	m_startingBackend = false;
 	// check ping responses
 	std::vector<Backend *> toRemove;
 	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {
 		// pong has been received OR backend just connected and did not have time to answer the ping
 		// request.
 		if ((*it)->pongReceived || (*it)->pongReceived == -1) {
 			// Don't send another ping if pongReceived == -1, because we've already sent one
 			// when registering backend.
 			if ((*it)->pongReceived) {
 				sendPing((*it));
+			}
+		}
 		else {
 			LOG4CXX_INFO(logger, "Disconnecting backend " << (*it) << " (ID=" << (*it)->id << "). PING response not received.");
 			toRemove.push_back(*it);
 #ifndef WIN32
 			// generate coredump for this backend to find out why it wasn't able to respond to PING
 			std::string pid = (*it)->id;
 			if (!pid.empty()) {
 				try {
 					kill(boost::lexical_cast<int>(pid), SIGABRT);
+				}
 				catch (...) { }
+			}
 #endif
+		}
 		if ((*it)->users.size() == 0) {
 			LOG4CXX_INFO(logger, "Disconnecting backend " << (*it) << " (ID=" << (*it)->id << "). There are no users.");
 			toRemove.push_back(*it);
+		}
+	}
 	BOOST_FOREACH(Backend *b, toRemove) {
 		handleSessionFinished(b);
+	}
 	m_pingTimer->start();
+}
 void NetworkPluginServer::collectBackend() {
 	// Stop accepting new users to backend with the biggest memory usage. This prevents backends
 	// which are leaking to eat whole memory by connectin new users to legacy network.
 	LOG4CXX_INFO(logger, "Collect backend called, finding backend which will be set to die");
 	unsigned long max = 0;
 	Backend *backend = NULL;
 	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {
 		if ((*it)->res > max) {
 			max = (*it)->res;
 			backend = (*it);
+		}
+	}
 	if (backend) {
 		if (m_collectTimer) {
 			m_collectTimer->start();
+		}
 		LOG4CXX_INFO(logger, "Backend " << backend << " (ID=" << backend->id << ") is set to die");
 		backend->acceptUsers = false;
+	}
+}
 bool NetworkPluginServer::moveToLongRunBackend(User *user) {
 	// Check if user has already some backend
 	Backend *old = (Backend *) user->getData();
 	if (!old) {
 		LOG4CXX_INFO(logger, "User " << user->getJID().toString() << " does not have old backend. Not moving.");
 		return true;
+	}
 	// if he's already on long run, do nothing
 	if (old->longRun) {
 		LOG4CXX_INFO(logger, "User " << user->getJID().toString() << " is already on long-running backend. Not moving.");
 		return true;
+	}
 	// Get free longrun backend, if there's no longrun backend, create one and wait
 	// for its connection
 	Backend *backend = getFreeClient(false, true);
 	if (!backend) {
 		LOG4CXX_INFO(logger, "No free long-running backend for user " << user->getJID().toString() << ". Will try later");
 		return false;
+	}
 	// old backend will trigger disconnection which has to be ignored to keep user online
 	user->setIgnoreDisconnect(true);
 	// remove user from the old backend
 	// If backend is empty, it will be collected by pingTimeout
 	old->users.remove(user);
 	// switch to new backend and connect
 	user->setData(backend);
 	backend->users.push_back(user);
 	// connect him
 	handleUserReadyToConnect(user);
 	return true;
+}
 void NetworkPluginServer::handleUserCreated(User *user) {
 	// Get free backend to handle this user or spawn new one if there's no free one.
 	Backend *c = getFreeClient();
 	// Add user to queue if there's no free backend to handle him so far.
 	if (!c) {
 		LOG4CXX_INFO(logger, "There is no backend to handle user " << user->getJID().toString() << ". Adding him to queue.");
 		m_waitingUsers.push_back(user);
 		return;
+	}
 	// Associate users with backend
 	user->setData(c);
 	c->users.push_back(user);
 	// Don't forget to disconnect these in handleUserDestroyed!!!
 	user->onReadyToConnect.connect(boost::bind(&NetworkPluginServer::handleUserReadyToConnect, this, user));
 	user->onPresenceChanged.connect(boost::bind(&NetworkPluginServer::handleUserPresenceChanged, this, user, _1));
 	user->onRoomJoined.connect(boost::bind(&NetworkPluginServer::handleRoomJoined, this, user, _1, _2, _3, _4));
 	user->onRoomLeft.connect(boost::bind(&NetworkPluginServer::handleRoomLeft, this, user, _1));
+}
 void NetworkPluginServer::handleUserReadyToConnect(User *user) {
 	UserInfo userInfo = user->getUserInfo();
 	pbnetwork::Login login;
 	login.set_user(user->getJID().toBare());
 	login.set_legacyname(userInfo.uin);
 	login.set_password(userInfo.password);
 	std::string message;
 	login.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_LOGIN);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleUserPresenceChanged(User *user, Swift::Presence::ref presence) {
 	if (presence->getShow() == Swift::StatusShow::None)
 		return;
 	UserInfo userInfo = user->getUserInfo();
 	pbnetwork::Status status;
 	status.set_username(user->getJID().toBare());
 	bool isInvisible = presence->getPayload<Swift::InvisiblePayload>() != NULL;
 	if (isInvisible) {
 		LOG4CXX_INFO(logger, "This presence is invisible");
 		status.set_status((pbnetwork::STATUS_INVISIBLE));
+	}
 	else {
 		status.set_status((pbnetwork::StatusType) presence->getShow());
+	}
 	status.set_statusmessage(presence->getStatus());
 	std::string message;
 	status.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_STATUS_CHANGED);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleRoomJoined(User *user, const Swift::JID &who, const std::string &r, const std::string &nickname, const std::string &password) {
 	UserInfo userInfo = user->getUserInfo();
 	pbnetwork::Room room;
 	room.set_username(user->getJID().toBare());
 	room.set_nickname(nickname);
 	room.set_room(r);
 	room.set_password(password);
 	std::string message;
 	room.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_JOIN_ROOM);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleRoomLeft(User *user, const std::string &r) {
 	UserInfo userInfo = user->getUserInfo();
 	pbnetwork::Room room;
 	room.set_username(user->getJID().toBare());
 	room.set_nickname("");
 	room.set_room(r);
 	room.set_password("");
 	std::string message;
 	room.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_LEAVE_ROOM);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleUserDestroyed(User *user) {
 	m_waitingUsers.remove(user);
 	UserInfo userInfo = user->getUserInfo();
 	user->onReadyToConnect.disconnect(boost::bind(&NetworkPluginServer::handleUserReadyToConnect, this, user));
 	user->onPresenceChanged.disconnect(boost::bind(&NetworkPluginServer::handleUserPresenceChanged, this, user, _1));
 	user->onRoomJoined.disconnect(boost::bind(&NetworkPluginServer::handleRoomJoined, this, user, _1, _2, _3, _4));
 	user->onRoomLeft.disconnect(boost::bind(&NetworkPluginServer::handleRoomLeft, this, user, _1));
 	pbnetwork::Logout logout;
 	logout.set_user(user->getJID().toBare());
 	logout.set_legacyname(userInfo.uin);
 	std::string message;
 	logout.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_LOGOUT);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
 	c->users.remove(user);
 	// If backend should handle only one user, it must not accept another one before
 	// we kill it, so set up willDie to true
 	if (c->users.size() == 0 && CONFIG_INT(m_config, "service.users_per_backend") == 1) {
 		LOG4CXX_INFO(logger, "Backend " << c->id << " will die, because the last user disconnected");
 		c->willDie = true;
+	}
+}
 void NetworkPluginServer::handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &msg) {
 	conv->getConversationManager()->getUser()->updateLastActivity();
 	boost::shared_ptr<Swift::ChatState> statePayload = msg->getPayload<Swift::ChatState>();
 	if (statePayload) {
 		pbnetwork::WrapperMessage_Type type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED;
 		switch (statePayload->getChatState()) {
 			case Swift::ChatState::Active:
 				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_STOPPED_TYPING;
 				break;
 			case Swift::ChatState::Composing:
 				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING;
 				break;
 			case Swift::ChatState::Paused:
 				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPED;
 				break;
 			default:
 				break;
+		}
 		if (type != pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED) {
 			pbnetwork::Buddy buddy;
 			buddy.set_username(conv->getConversationManager()->getUser()->getJID().toBare());
 			buddy.set_buddyname(conv->getLegacyName());
 			std::string message;
 			buddy.SerializeToString(&message);
 			WRAP(message, type);
 			Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 			if (!c) {
 				return;
+			}
 			send(c->connection, message);
+		}
+	}
 	boost::shared_ptr<Swift::AttentionPayload> attentionPayload = msg->getPayload<Swift::AttentionPayload>();
 	if (attentionPayload) {
 		pbnetwork::ConversationMessage m;
 		m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());
 		m.set_buddyname(conv->getLegacyName());
 		m.set_message(msg->getBody());
 		std::string message;
 		m.SerializeToString(&message);
 		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_ATTENTION);
 		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 		send(c->connection, message);
 		return;
+	}
 	if (!msg->getSubject().empty()) {
 		pbnetwork::ConversationMessage m;
 		m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());
 		m.set_buddyname(conv->getLegacyName());
 		m.set_message(msg->getSubject());
 		std::string message;
 		m.SerializeToString(&message);
 		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_ROOM_SUBJECT_CHANGED);
 		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 		send(c->connection, message);
 		return;
+	}
 	std::string xhtml;
 	boost::shared_ptr<Swift::XHTMLIMPayload> xhtmlPayload = msg->getPayload<Swift::XHTMLIMPayload>();
 	if (xhtmlPayload) {
 		xhtml = xhtmlPayload->getBody();
+	}
 	// Send normal message
 	if (!msg->getBody().empty() || !xhtml.empty()) {
 		pbnetwork::ConversationMessage m;
 		m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());
 		m.set_buddyname(conv->getLegacyName());
 		m.set_message(msg->getBody());
 		m.set_xhtml(xhtml);
 		std::string message;
 		m.SerializeToString(&message);
 		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE);
 		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 		if (!c) {
 			return;
+		}
 		send(c->connection, message);
+	}
+}
 void NetworkPluginServer::handleBuddyRemoved(Buddy *b) {
 	User *user = b->getRosterManager()->getUser();
 	pbnetwork::Buddy buddy;
 	buddy.set_username(user->getJID().toBare());
 	buddy.set_buddyname(b->getName());
 	buddy.set_alias(b->getAlias());
 	BOOST_FOREACH(const std::string &g, b->getGroups()) {
 		buddy.add_group(g);
+	}
 	buddy.set_status(pbnetwork::STATUS_NONE);
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_REMOVED);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleBuddyUpdated(Buddy *b, const Swift::RosterItemPayload &item) {
 	User *user = b->getRosterManager()->getUser();
 	dynamic_cast<LocalBuddy *>(b)->setAlias(item.getName());
 	dynamic_cast<LocalBuddy *>(b)->setGroups(item.getGroups());
 	pbnetwork::Buddy buddy;
 	buddy.set_username(user->getJID().toBare());
 	buddy.set_buddyname(b->getName());
 	buddy.set_alias(b->getAlias());
 	BOOST_FOREACH(const std::string &g, b->getGroups()) {
 		buddy.add_group(g);
+	}
 	buddy.set_status(pbnetwork::STATUS_NONE);
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleBuddyAdded(Buddy *buddy, const Swift::RosterItemPayload &item) {
 	handleBuddyUpdated(buddy, item);
+}
 void NetworkPluginServer::handleBlockToggled(Buddy *b) {
 	User *user = b->getRosterManager()->getUser();
 	pbnetwork::Buddy buddy;
 	buddy.set_username(user->getJID().toBare());
 	buddy.set_buddyname(b->getName());
 	buddy.set_alias(b->getAlias());
 	BOOST_FOREACH(const std::string &g, b->getGroups()) {
 		buddy.add_group(g);
+	}
 	buddy.set_status(pbnetwork::STATUS_NONE);
 	buddy.set_blocked(!b->isBlocked());
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> v) {
 	pbnetwork::VCard vcard;
 	vcard.set_username(user->getJID().toBare());
 	vcard.set_buddyname("");
 	vcard.set_id(0);
 	vcard.set_photo(&v->getPhoto()[0], v->getPhoto().size());
 	vcard.set_nickname(v->getNickname());
 	std::string message;
 	vcard.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_VCARD);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleVCardRequired(User *user, const std::string &name, unsigned int id) {
 	pbnetwork::VCard vcard;
 	vcard.set_username(user->getJID().toBare());
 	vcard.set_buddyname(name);
 	vcard.set_id(id);
 	std::string message;
 	vcard.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_VCARD);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleFTAccepted(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID) {
 	pbnetwork::File f;
 	f.set_username(user->getJID().toBare());
 	f.set_buddyname(buddyName);
 	f.set_filename(fileName);
 	f.set_size(size);
 	f.set_ftid(ftID);
 	std::string message;
 	f.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_START);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleFTRejected(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size) {
 	pbnetwork::File f;
 	f.set_username(user->getJID().toBare());
 	f.set_buddyname(buddyName);
 	f.set_filename(fileName);
 	f.set_size(size);
 	f.set_ftid(0);
 	std::string message;
 	f.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_FINISH);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleFTStateChanged(Swift::FileTransfer::State state, const std::string &userName, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long id) {
 	User *user = m_userManager->getUser(userName);
 	if (!user) {
 		// TODO: FIXME We have to remove filetransfer when use disconnects
 		return;
+	}
 	if (state.state == Swift::FileTransfer::State::Transferring) {
 		handleFTAccepted(user, buddyName, fileName, size, id);
+	}
 	else if (state.state == Swift::FileTransfer::State::Canceled) {
 		handleFTRejected(user, buddyName, fileName, size);
+	}
+}
 void NetworkPluginServer::sendPing(Backend *c) {
 	std::string message;
 	pbnetwork::WrapperMessage wrap;
 	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_PING);
 	wrap.SerializeToString(&message);
 	if (c->connection) {
 		LOG4CXX_INFO(logger, "PING to " << c << " (ID=" << c->id << ")");
 		send(c->connection, message);
 		c->pongReceived = false;
+	}
 // 	LOG4CXX_INFO(logger, "PING to " << c);
+}
 NetworkPluginServer::Backend *NetworkPluginServer::getFreeClient(bool acceptUsers, bool longRun) {
 	NetworkPluginServer::Backend *c = NULL;
 	// Check all backends and find free one
 	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {
 		if ((*it)->willDie == false && (*it)->acceptUsers == acceptUsers && (*it)->users.size() < CONFIG_INT(m_config, "service.users_per_backend") && (*it)->connection && (*it)->longRun == longRun) {
 			c = *it;
 			// if we're not reusing all backends and backend is full, stop accepting new users on this backend
 			if (!CONFIG_BOOL(m_config, "service.reuse_old_backends")) {
 				if (c->users.size() + 1 >= CONFIG_INT(m_config, "service.users_per_backend")) {
 					c->acceptUsers = false;
+				}
+			}
 			break;
+		}
+	}
 	// there's no free backend, so spawn one.
 	if (c == NULL && !m_startingBackend) {
 		m_isNextLongRun = longRun;
 		m_startingBackend = true;
 		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->getCommandLineArgs().c_str());
+	}
 	return c;
+}
+}

src/settingsadhoccommand.cpp

➞

Show inline comments

 /**
  * XMPP - libpurple transport
+ *
  * Copyright (C) 2012, 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 "transport/settingsadhoccommand.h"
 #include "transport/conversation.h"
 #include "transport/usermanager.h"
 #include "transport/buddy.h"
 #include "transport/factory.h"
 #include "transport/user.h"
 #include "transport/logging.h"
 #include "transport/storagebackend.h"
 namespace Transport {
 DEFINE_LOGGER(logger, "SettingsAdHocCommand");
 SettingsAdHocCommand::SettingsAdHocCommand(Component *component, UserManager *userManager, StorageBackend *storageBackend, const Swift::JID &initiator, const Swift::JID &to) : AdHocCommand(component, userManager, storageBackend, initiator, to) {
 	m_state = Init;
 	Swift::BooleanFormField::ref field;
 	field = Swift::BooleanFormField::create(true);
 	field->setName("enable_transport");
 	field->setLabel("Enable transport");
 	addFormField(field);
 	field = Swift::BooleanFormField::create(CONFIG_STRING_DEFAULTED(component->getConfig(), "settings.send_headlines", "0") == "1");
 	field->setName("send_headlines");
 	field->setLabel("Send messages as headlines");
 	addFormField(field);
+}
 SettingsAdHocCommand::~SettingsAdHocCommand() {
+}
 boost::shared_ptr<Swift::Command> SettingsAdHocCommand::getForm() {
 	if (!m_storageBackend) {
 		boost::shared_ptr<Swift::Command> response(new Swift::Command("settings", m_id, Swift::Command::Completed));
 		boost::shared_ptr<Swift::Form> form(new Swift::Form());
 		form->addField(Swift::FixedFormField::create("This server does not support transport settings. There is no storage backend configured"));
 		return response;
+	}
 	UserInfo user;
 	if (m_storageBackend->getUser(m_initiator.toBare().toString(), user) == false) {
 		boost::shared_ptr<Swift::Command> response(new Swift::Command("settings", m_id, Swift::Command::Completed));
 		boost::shared_ptr<Swift::Form> form(new Swift::Form());
 		form->addField(Swift::FixedFormField::create("You are not registered."));
 		return response;
+	}
 	boost::shared_ptr<Swift::Command> response(new Swift::Command("settings", m_id, Swift::Command::Executing));
 	boost::shared_ptr<Swift::Form> form(new Swift::Form());
 	BOOST_FOREACH(Swift::FormField::ref field, m_fields) {
 		// FIXME: Support for more types than boolean
 		if (boost::dynamic_pointer_cast<Swift::BooleanFormField>(field)) {
 			Swift::BooleanFormField::ref f(boost::dynamic_pointer_cast<Swift::BooleanFormField>(field));
 			std::string value = f->getValue() ? "1" : "0";
 			int type = (int) TYPE_BOOLEAN;
 			m_storageBackend->getUserSetting(user.id, f->getName(), type, value);
 			f->setValue(value == "1");
+		}
 		form->addField(field);
+	}
 	response->setForm(form);
 	return response;
+}
 boost::shared_ptr<Swift::Command> SettingsAdHocCommand::handleResponse(boost::shared_ptr<Swift::Command> payload) {
 	UserInfo user;
 	bool registered = m_storageBackend->getUser(m_initiator.toBare().toString(), user);
 	if (registered && payload->getForm()) {
 		BOOST_FOREACH(Swift::FormField::ref field, m_fields) {
 			Swift::FormField::ref received = payload->getForm()->getField(field->getName());
 			if (!received) {
 				continue;
+			}
 			// FIXME: Support for more types than boolean
 			if (boost::dynamic_pointer_cast<Swift::BooleanFormField>(received)) {
 				Swift::BooleanFormField::ref f(boost::dynamic_pointer_cast<Swift::BooleanFormField>(received));
 				std::string value = f->getValue() ? "1" : "0";
 				m_storageBackend->updateUserSetting(user.id, f->getName(), value);
+			}
 			else if (boost::dynamic_pointer_cast<Swift::TextSingleFormField>(received)) {
 				Swift::TextSingleFormField::ref f(boost::dynamic_pointer_cast<Swift::TextSingleFormField>(received));
 				m_storageBackend->updateUserSetting(user.id, f->getName(), f->getValue());
+			}
+		}
+	}
 	boost::shared_ptr<Swift::Command> response(new Swift::Command("settings", m_id, Swift::Command::Completed));
 	return response;
+}
 boost::shared_ptr<Swift::Command> SettingsAdHocCommand::handleRequest(boost::shared_ptr<Swift::Command> payload) {
 	boost::shared_ptr<Swift::Command> response;
 	if (payload->getAction() == Swift::Command::Cancel) {
 		response = boost::shared_ptr<Swift::Command>(new Swift::Command("settings", m_id, Swift::Command::Canceled));
 		return response;
+	}
 	switch (m_state) {
 		case Init:
 			response = getForm();
 			m_state = WaitingForResponse;
 			break;
 		case WaitingForResponse:
 			response = handleResponse(payload);
 			break;
 		default:
 			break;
+	}
 	return response;
+}
+}

src/tests/basictest.h

➞

Show inline comments

 /**
  * 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 <vector>
 #include "Swiften/Swiften.h"
 #include "Swiften/Queries/SetResponder.h"
 #include "transport/conversation.h"
 #include "transport/conversationmanager.h"
 #include "transport/userregistry.h"
 #include "transport/config.h"
 #include "transport/storagebackend.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/conversation.h"
 #include "transport/usermanager.h"
 #include "transport/userregistration.h"
 #include "transport/discoitemsresponder.h"
 #include "transport/localbuddy.h"
 #include "transport/storagebackend.h"
 #include <Swiften/Swiften.h>
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/Server/Server.h>
 #include <Swiften/Network/DummyNetworkFactories.h>
 #include <Swiften/Network/DummyConnectionServer.h>
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Server/ServerFromClientSession.h"
 #include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"
 using namespace Transport;
 class TestingConversation : public Conversation {
 	public:
 		TestingConversation(ConversationManager *conversationManager, const std::string &legacyName, bool muc = false) : Conversation(conversationManager, legacyName, muc) {
+		}
 		// Called when there's new message to legacy network from XMPP network
 		void sendMessage(boost::shared_ptr<Swift::Message> &message) {
 			onMessageToSend(this, message);
+		}
 		boost::signal<void (TestingConversation *, boost::shared_ptr<Swift::Message> &)> onMessageToSend;
 };
 class TestingFactory : public Factory {
 	public:
 		TestingFactory() {
+		}
 		// Creates new conversation (NetworkConversation in this case)
 		Conversation *createConversation(ConversationManager *conversationManager, const std::string &legacyName, bool isMuc = false) {
 			TestingConversation *nc = new TestingConversation(conversationManager, legacyName, isMuc);
 			nc->onMessageToSend.connect(boost::bind(&TestingFactory::handleMessageToSend, this, _1, _2));
 			return nc;
+		}
 		void handleMessageToSend(TestingConversation *_conv, boost::shared_ptr<Swift::Message> &_msg) {
 			onMessageToSend(_conv, _msg);
+		}
 		// Creates new LocalBuddy
 		Buddy *createBuddy(RosterManager *rosterManager, const BuddyInfo &buddyInfo) {
 			LocalBuddy *buddy = new LocalBuddy(rosterManager, buddyInfo.id, buddyInfo.legacyName, buddyInfo.alias, buddyInfo.groups, (BuddyFlag) buddyInfo.flags);
 			if (!buddy->isValid()) {
 				delete buddy;
 				return NULL;
+			}
 			buddy->setSubscription(Buddy::Ask);
 			if (buddyInfo.settings.find("icon_hash") != buddyInfo.settings.end())
 				buddy->setIconHash(buddyInfo.settings.find("icon_hash")->second.s);
 			return buddy;
+		}
 		boost::signal<void (TestingConversation *, boost::shared_ptr<Swift::Message> &)> onMessageToSend;
 };
 class TestingStorageBackend : public StorageBackend {
 	public:
 		bool connected;
 		std::map<std::string, UserInfo> users;
 		std::map<std::string, bool> online_users;
 		std::map<int, std::map<std::string, std::string> > settings;
 		long buddyid;
 		TestingStorageBackend() {
 			buddyid = 0;
 			connected = false;
+		}
 		/// connect
 		virtual bool connect() {
 			connected = true;
 			return true;
+		}
 		/// createDatabase
 		virtual bool createDatabase() {return true;}
 		/// setUser
 		virtual void setUser(const UserInfo &user) {
 			users[user.jid] = user;
+		}
 		/// getuser
 		virtual bool getUser(const std::string &barejid, UserInfo &user) {
 			if (users.find(barejid) == users.end()) {
 				return false;
+			}
 			user = users[barejid];
 			return true;
+		}
 		std::string findUserByID(long id) {
 			for (std::map<std::string, UserInfo>::const_iterator it = users.begin(); it != users.end(); it++) {
 				if (it->second.id == id) {
 					return it->first;
+				}
+			}
 			return "";
+		}
 		/// setUserOnline
 		virtual void setUserOnline(long id, bool online) {
 			std::string user = findUserByID(id);
 			if (user.empty()) {
 				return;
+			}
 			online_users[user] = online;
+		}
 		/// removeUser
 		virtual bool removeUser(long id) {
 			std::string user = findUserByID(id);
 			if (user.empty()) {
 				return false;
+			}
 			users.erase(user);
 			return true;
+		}
 		/// getBuddies
 		virtual bool getBuddies(long id, std::list<BuddyInfo> &roster) {
 			return true;
+		}
 		/// getOnlineUsers
 		virtual bool getOnlineUsers(std::vector<std::string> &users) {
 			return true;
+		}
 		virtual long addBuddy(long userId, const BuddyInfo &buddyInfo) {
 			return buddyid++;
+		}
 		virtual void updateBuddy(long userId, const BuddyInfo &buddyInfo) {
+		}
 		virtual void removeBuddy(long id) {
+		}
 		virtual void getBuddySetting(long userId, long buddyId, const std::string &variable, int &type, std::string &value) {}
 		virtual void updateBuddySetting(long userId, long buddyId, const std::string &variable, int type, const std::string &value) {}
 		virtual void getUserSetting(long userId, const std::string &variable, int &type, std::string &value) {
 			if (settings[userId].find(variable) == settings[userId].end()) {
 				settings[userId][variable] = value;
 				return;
+			}
 			value = settings[userId][variable];
+		}
 		virtual void updateUserSetting(long userId, const std::string &variable, const std::string &value) {
 			settings[userId][variable] = value;
+		}
 		void dumpUserSettings() {
 			std::cout << "\n\nUserSettings dump:\n";
 			for (std::map<int, std::map<std::string, std::string> >::const_iterator it = settings.begin(); it != settings.end(); it++) {
 				for (std::map<std::string, std::string>::const_iterator it2 = it->second.begin(); it2 != it->second.end(); it2++) {
 					std::cout << it->first << ":" << it2->first << "=" << it2->second << "\n";
+				}
+			}
+		}
 		virtual void beginTransaction() {}
 		virtual void commitTransaction() {}
 };
 class BasicTest : public Swift::XMPPParserClient {
 	public:
 		void setMeUp (void);
 		void tearMeDown (void);
 	void handleDataReceived(const Swift::SafeByteArray &data);
 	void handleDataReceived2(const Swift::SafeByteArray &data);
 	void handleStreamStart(const Swift::ProtocolHeader&);
 	void handleElement(boost::shared_ptr<Swift::Element> element);
 	void handleStreamEnd();
 	void injectPresence(boost::shared_ptr<Swift::Presence> &response);
 	void injectIQ(boost::shared_ptr<Swift::IQ> iq);
 	void injectMessage(boost::shared_ptr<Swift::Message> msg);
 	void dumpReceived();
 	void addUser() {
 		UserInfo user;
 		user.id = 1;
 		user.jid = "user@localhost";
 		user.uin = "legacyname";
 		user.password = "password";
 		user.vip = 0;
 		storage->setUser(user);
+	}
 	void connectUser();
 	void connectSecondResource();
 	void disconnectUser();
 	void add2Buddies();
 	Swift::Stanza *getStanza(boost::shared_ptr<Swift::Element> element);
 	protected:
 		bool streamEnded;
 		UserManager *userManager;
 		boost::shared_ptr<Swift::ServerFromClientSession> serverFromClientSession;
 		boost::shared_ptr<Swift::ServerFromClientSession> serverFromClientSession2;
 		Swift::FullPayloadSerializerCollection* payloadSerializers;
 		Swift::FullPayloadParserFactoryCollection* payloadParserFactories;
 		Swift::XMPPParser *parser;
 		Swift::XMPPParser *parser2;
 		UserRegistry *userRegistry;
 		Config *cfg;
 		Swift::Server *server;
 		Swift::DummyNetworkFactories *factories;
 		Swift::DummyEventLoop *loop;
 		TestingFactory *factory;
 		Component *component;
 		std::vector<boost::shared_ptr<Swift::Element> > received;
 		std::vector<boost::shared_ptr<Swift::Element> > received2;
 		std::string receivedData;
 		std::string receivedData2;
 		StorageBackend *storage;
 		UserRegistration *userRegistration;
 		DiscoItemsResponder *itemsResponder;
 		bool stream1_active;
 };

src/tests/conversationmanager.cpp

➞

Show inline comments

 #include "transport/userregistry.h"
 #include "transport/config.h"
 #include "transport/storagebackend.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/conversation.h"
 #include "transport/usermanager.h"
 #include "transport/conversationmanager.h"
 #include "transport/localbuddy.h"
 #include <cppunit/TestFixture.h>
 #include <cppunit/extensions/HelperMacros.h>
 #include <Swiften/Swiften.h>
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/Server/Server.h>
 #include <Swiften/Network/DummyNetworkFactories.h>
 #include <Swiften/Network/DummyConnectionServer.h>
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Server/ServerFromClientSession.h"
 #include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"
 #include "basictest.h"
 using namespace Transport;
 class ConversationManagerTest : public CPPUNIT_NS :: TestFixture, public BasicTest {
 	CPPUNIT_TEST_SUITE(ConversationManagerTest);
 	CPPUNIT_TEST(handleNormalMessages);
 	CPPUNIT_TEST(handleNormalMessagesHeadline);
 	CPPUNIT_TEST(handleGroupchatMessages);
 	CPPUNIT_TEST(handleGroupchatMessagesTwoResources);
 	CPPUNIT_TEST(handleChatstateMessages);
 	CPPUNIT_TEST(handleSubjectMessages);
 	CPPUNIT_TEST(handleParticipantChanged);
 	CPPUNIT_TEST(handleParticipantChangedTwoResources);
 	CPPUNIT_TEST(handlePMFromXMPP);
 	CPPUNIT_TEST(handleGroupchatRemoved);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		TestingConversation *m_conv;
 		boost::shared_ptr<Swift::Message> m_msg;
 		void setUp (void) {
 			m_conv = NULL;
 			m_msg.reset();
 			setMeUp();
 			connectUser();
 			add2Buddies();
 			factory->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 			received.clear();
+		}
 		void tearDown (void) {
 			received.clear();
 			disconnectUser();
 			factory->onMessageToSend.disconnect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 			tearMeDown();
+		}
 	void handleMessageReceived(TestingConversation *_conv, boost::shared_ptr<Swift::Message> &_msg) {
 		m_conv = _conv;
 		m_msg = _msg;
+	}
 	void handleChatstateMessages() {
 		User *user = userManager->getUser("user@localhost");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "buddy1");
 		user->getConversationManager()->addConversation(conv);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->addPayload(boost::make_shared<Swift::ChatState>(Swift::ChatState::Composing));
 		// Forward it
 		conv->handleMessage(msg);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0]))->getPayload<Swift::ChatState>());
 		received.clear();
 		// send response
 		msg->setFrom("user@localhost/resource");
 		msg->setTo("buddy1@localhost/bot");
 		injectMessage(msg);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT(m_msg);
 		CPPUNIT_ASSERT(m_msg->getPayload<Swift::ChatState>());
 		received.clear();
+	}
 	void handleSubjectMessages() {
 		User *user = userManager->getUser("user@localhost");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "#room", true);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 		conv->setNickname("nickname");
 		conv->addJID("user@localhost/resource");
 		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setSubject("subject");
 		msg->setType(Swift::Message::Groupchat);
 		conv->handleMessage(msg);
 		loop->processEvents();
 		// No response, because presence with code 110 has not been sent yet and we must not send
 		// subject before this one.
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		// this user presence - status code 110
 		conv->handleParticipantChanged("nickname", 1, Swift::StatusShow::Away, "my status message");
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[1])));
 		CPPUNIT_ASSERT_EQUAL(std::string("subject"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getSubject());
 		received.clear();
 		// send response
 		msg->setFrom("user@localhost/resource");
 		msg->setTo("#room@localhost");
 		injectMessage(msg);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT(m_msg);
 		CPPUNIT_ASSERT_EQUAL(std::string("subject"), m_msg->getSubject());
 		received.clear();
+	}
 	void handleNormalMessages() {
 		User *user = userManager->getUser("user@localhost");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "buddy1@test");
 		user->getConversationManager()->addConversation(conv);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setBody("hi there<>!");
 		// Forward it
 		conv->handleMessage(msg);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there<>!"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getBody());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("buddy1\\40test@localhost/bot"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getFrom().toString());
 		received.clear();
 		// send response
 		msg->setFrom("user@localhost/resource");
 		msg->setTo("buddy1\\40test@localhost/bot");
 		msg->setBody("response<>!");
 		injectMessage(msg);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT(m_msg);
 		CPPUNIT_ASSERT_EQUAL(std::string("response<>!"), m_msg->getBody());
 		// send another message from legacy network, should be sent to user@localhost/resource now
 		boost::shared_ptr<Swift::Message> msg2(new Swift::Message());
 		msg2->setBody("hi there!");
 		// Forward it
 		conv->handleMessage(msg2);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there!"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getBody());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("buddy1\\40test@localhost/bot"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getFrom().toString());
 		received.clear();
 		// disable jid_escaping
 		std::istringstream ifs("service.server_mode = 1\nservice.jid_escaping=0\nservice.jid=localhost\nservice.more_resources=1\n");
 		cfg->load(ifs);
 		// and now to bare JID again...
 		user->getConversationManager()->resetResources();
 		conv->handleMessage(msg2);
 		loop->processEvents();
 		// enable jid_escaping again
 		std::istringstream ifs2("service.server_mode = 1\nservice.jid_escaping=1\nservice.jid=localhost\nservice.more_resources=1\n");
 		cfg->load(ifs2);
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there!"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getBody());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("buddy1%test@localhost/bot"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getFrom().toString());
 		received.clear();
+	}
 	void handleNormalMessagesHeadline() {
 		User *user = userManager->getUser("user@localhost");
 		user->addUserSetting("send_headlines", "1");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "buddy1@test");
 		user->getConversationManager()->addConversation(conv);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setBody("hi there<>!");
 		// Forward it
 		conv->handleMessage(msg);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::Message::Headline, dynamic_cast<Swift::Message *>(getStanza(received[0]))->getType());
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there<>!"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getBody());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("buddy1\\40test@localhost/bot"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getFrom().toString());
 		received.clear();
 		user->addUserSetting("send_headlines", "0");
 		// Forward it - Conversation should keep the Headline type, because msg->getType() is Headline
 		conv->handleMessage(msg);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::Message::Headline, dynamic_cast<Swift::Message *>(getStanza(received[0]))->getType());
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there<>!"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getBody());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("buddy1\\40test@localhost/bot"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getFrom().toString());
 		received.clear();
 		msg->setType(Swift::Message::Chat);
 		// Forward it
 		conv->handleMessage(msg);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::Message::Chat, dynamic_cast<Swift::Message *>(getStanza(received[0]))->getType());
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there<>!"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getBody());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("buddy1\\40test@localhost/bot"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getFrom().toString());
+	}
 	void handleGroupchatMessages() {
 		User *user = userManager->getUser("user@localhost");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "#room", true);
 		user->getConversationManager()->addConversation(conv);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 		conv->setNickname("nickname");
 		conv->addJID("user@localhost/resource");
 		// reset resources should not touch this resource
 		user->getConversationManager()->resetResources();
 		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setBody("hi there!");
 		// Forward it
 		conv->handleMessage(msg, "anotheruser");
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there!"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getBody());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/anotheruser"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getFrom().toString());
 		received.clear();
 		// send response
 		msg->setFrom("user@localhost/resource");
 		msg->setTo("#room@localhost");
 		msg->setBody("response!");
 		msg->setType(Swift::Message::Groupchat);
 		injectMessage(msg);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT(m_msg);
 		CPPUNIT_ASSERT_EQUAL(std::string("response!"), m_msg->getBody());
+	}
 	void handleGroupchatMessagesTwoResources() {
 		connectSecondResource();
 		received2.clear();
 		User *user = userManager->getUser("user@localhost");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "#room", true);
 		user->getConversationManager()->addConversation(conv);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 		conv->setNickname("nickname");
 		conv->addJID("user@localhost/resource");
 		conv->addJID("user@localhost/resource2");
 		// reset resources should not touch this resource
 		user->getConversationManager()->resetResources();
 		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setBody("hi there!");
 		// Forward it
 		conv->handleMessage(msg, "anotheruser");
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received2.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received2[0])));
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there!"), dynamic_cast<Swift::Message *>(getStanza(received2[0]))->getBody());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource2"), dynamic_cast<Swift::Message *>(getStanza(received2[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/anotheruser"), dynamic_cast<Swift::Message *>(getStanza(received2[0]))->getFrom().toString());
 		received.clear();
 		// send response
 		msg->setFrom("user@localhost/resource2");
 		msg->setTo("#room@localhost");
 		msg->setBody("response!");
 		msg->setType(Swift::Message::Groupchat);
 		injectMessage(msg);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT(m_msg);
 		CPPUNIT_ASSERT_EQUAL(std::string("response!"), m_msg->getBody());
+	}
 	void handleParticipantChanged() {
 		User *user = userManager->getUser("user@localhost");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "#room", true);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 		conv->setNickname("nickname");
 		conv->addJID("user@localhost/resource");
 		// normal presence
 		conv->handleParticipantChanged("anotheruser", 0, Swift::StatusShow::Away, "my status message");
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::StatusShow::Away, dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getShow());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/anotheruser"), dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getFrom().toString());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::MUCUserPayload>());
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Member, *getStanza(received[0])->getPayload<Swift::MUCUserPayload>()->getItems()[0].affiliation);
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Participant, *getStanza(received[0])->getPayload<Swift::MUCUserPayload>()->getItems()[0].role);
 		received.clear();
 		// this user presence - status code 110
 		conv->handleParticipantChanged("nickname", 1, Swift::StatusShow::Away, "my status message");
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::StatusShow::Away, dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getShow());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/nickname"), dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getFrom().toString());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::MUCUserPayload>());
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Admin, *getStanza(received[0])->getPayload<Swift::MUCUserPayload>()->getItems()[0].affiliation);
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Moderator, *getStanza(received[0])->getPayload<Swift::MUCUserPayload>()->getItems()[0].role);
 		CPPUNIT_ASSERT_EQUAL(110, getStanza(received[0])->getPayload<Swift::MUCUserPayload>()->getStatusCodes()[0].code);
 		received.clear();
 		// renamed - status code 303
 		conv->handleParticipantChanged("anotheruser", 1, Swift::StatusShow::Away, "my status message", "hanzz");
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::Presence::Unavailable, dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getType());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/anotheruser"), dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getFrom().toString());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::MUCUserPayload>());
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Admin, *getStanza(received[0])->getPayload<Swift::MUCUserPayload>()->getItems()[0].affiliation);
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Moderator, *getStanza(received[0])->getPayload<Swift::MUCUserPayload>()->getItems()[0].role);
 		CPPUNIT_ASSERT_EQUAL(std::string("hanzz"), *getStanza(received[0])->getPayload<Swift::MUCUserPayload>()->getItems()[0].nick);
 		CPPUNIT_ASSERT_EQUAL(303, getStanza(received[0])->getPayload<Swift::MUCUserPayload>()->getStatusCodes()[0].code);
+	}
 	void handleParticipantChangedTwoResources() {
 		connectSecondResource();
 		received2.clear();
 		User *user = userManager->getUser("user@localhost");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "#room", true);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 		conv->setNickname("nickname");
 		conv->addJID("user@localhost/resource");
 		conv->addJID("user@localhost/resource2");
 		// normal presence
 		conv->handleParticipantChanged("anotheruser", 0, Swift::StatusShow::Away, "my status message");
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received2.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received2[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::StatusShow::Away, dynamic_cast<Swift::Presence *>(getStanza(received2[0]))->getShow());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource2"), dynamic_cast<Swift::Presence *>(getStanza(received2[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/anotheruser"), dynamic_cast<Swift::Presence *>(getStanza(received2[0]))->getFrom().toString());
 		CPPUNIT_ASSERT(getStanza(received2[0])->getPayload<Swift::MUCUserPayload>());
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Member, *getStanza(received2[0])->getPayload<Swift::MUCUserPayload>()->getItems()[0].affiliation);
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Participant, *getStanza(received2[0])->getPayload<Swift::MUCUserPayload>()->getItems()[0].role);
+	}
 	void handlePMFromXMPP() {
 		User *user = userManager->getUser("user@localhost");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "#room", true);
 		user->getConversationManager()->addConversation(conv);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 		conv->setNickname("nickname");
 		conv->setJID("user@localhost/resource");
 		conv->handleParticipantChanged("anotheruser", 0, Swift::StatusShow::Away, "my status message");
 		loop->processEvents();
 		received.clear();
 		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setBody("hi there!");
 		msg->setFrom("user@localhost/resource");
 		msg->setTo("#room@localhost/anotheruser");
 		msg->setBody("hi there!");
 		injectMessage(msg);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT(m_msg);
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there!"), m_msg->getBody());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room/anotheruser"), m_conv->getLegacyName());
 		Conversation *pmconv = user->getConversationManager()->getConversation("#room/anotheruser");
 		boost::shared_ptr<Swift::Message> msg2(new Swift::Message());
 		msg2->setBody("response!");
 		pmconv->handleMessage(msg2);
+	}
 	void handleGroupchatRemoved() {
 		User *user = userManager->getUser("user@localhost");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "#room", true);
 		conv->setNickname("nickname");
 		conv->addJID("user@localhost/resource");
 		received.clear();
 		conv->destroyRoom();
 		delete conv;
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::StatusShow::None, dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getShow());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/nickname"), dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getFrom().toString());
 		CPPUNIT_ASSERT_EQUAL(332, getStanza(received[0])->getPayload<Swift::MUCUserPayload>()->getStatusCodes()[0].code);
+	}
 };
 CPPUNIT_TEST_SUITE_REGISTRATION (ConversationManagerTest);

src/tests/settingsadhoccommand.cpp

➞

Show inline comments

 #include "transport/userregistry.h"
 #include "transport/userregistration.h"
 #include "transport/config.h"
 #include "transport/storagebackend.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/conversation.h"
 #include "transport/usermanager.h"
 #include "transport/localbuddy.h"
 #include "transport/settingsadhoccommand.h"
 #include "transport/adhocmanager.h"
 #include <cppunit/TestFixture.h>
 #include <cppunit/extensions/HelperMacros.h>
 #include <Swiften/Swiften.h>
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/Server/Server.h>
 #include <Swiften/Network/DummyNetworkFactories.h>
 #include <Swiften/Network/DummyConnectionServer.h>
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Server/ServerFromClientSession.h"
 #include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"
 #include "basictest.h"
 using namespace Transport;
 class SettingsAdHocCommandTest : public CPPUNIT_NS :: TestFixture, public BasicTest {
 	CPPUNIT_TEST_SUITE(SettingsAdHocCommandTest);
 	CPPUNIT_TEST(getItems);
 	CPPUNIT_TEST(getInfo);
 	CPPUNIT_TEST(getInfoBare);
 	CPPUNIT_TEST(execute);
 	CPPUNIT_TEST(executeTwoCommands);
 	CPPUNIT_TEST(executeBadSessionID);
 	CPPUNIT_TEST(executeNotRegistered);
 	CPPUNIT_TEST(cancel);
 	CPPUNIT_TEST(propagateUserSetting);
 	CPPUNIT_TEST(defaultAccordingToConfig);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		AdHocManager *adhoc;
 		SettingsAdHocCommandFactory *settings;
 		void setUp (void) {
 			setMeUp();
 			adhoc = new AdHocManager(component, itemsResponder, userManager, storage);
 			adhoc->start();
 			settings = new SettingsAdHocCommandFactory();
 			adhoc->addAdHocCommand(settings);
 			received.clear();
+		}
 		void tearDown (void) {
 			received.clear();
 			delete adhoc;
 			delete settings;
 			tearMeDown();
+		}
 		void getItems() {
 			boost::shared_ptr<Swift::DiscoItems> payload(new Swift::DiscoItems());
 			payload->setNode("http://jabber.org/protocol/commands");
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoItems>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::DiscoItems>()->getItems()[0].getNode());
+		}
 		void getInfo() {
 			boost::shared_ptr<Swift::DiscoInfo> payload(new Swift::DiscoInfo());
 			payload->setNode("settings");
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 			CPPUNIT_ASSERT_EQUAL(std::string("automation"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getCategory());
 			CPPUNIT_ASSERT_EQUAL(std::string("command-node"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getType());
+		}
 		void getInfoBare() {
 			boost::shared_ptr<Swift::DiscoInfo> payload(new Swift::DiscoInfo());
 			payload->setNode("http://jabber.org/protocol/commands");
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 			CPPUNIT_ASSERT_EQUAL(std::string("automation"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getCategory());
 			CPPUNIT_ASSERT_EQUAL(std::string("command-list"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getType());
+		}
 		void executeNotRegistered() {
 			boost::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Completed, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
+		}
 		void execute() {
 			addUser();
 			boost::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Executing, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
 			// form element
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm()->getField("enable_transport"));
 			// set enabled_transport = 0
 			Swift::FormField::ref f = getStanza(received[0])->getPayload<Swift:: Command>()->getForm()->getField("enable_transport");
 			boost::dynamic_pointer_cast<Swift::BooleanFormField>(f)->setValue(false);
 			std::string sessionId = getStanza(received[0])->getPayload<Swift::Command>()->getSessionID();
+			{
 			std::string value = "0";
 			int type;
 			storage->getUserSetting(1, "enable_transport", type, value);
 			CPPUNIT_ASSERT_EQUAL(std::string("1"), value);
+			}
 			// finish the command
 			payload = boost::shared_ptr<Swift::Command>(new Swift::Command("settings"));
 			payload->setSessionID(sessionId);
 			payload->setForm(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			received.clear();
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Completed, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
+			{
 			std::string value = "1";
 			int type;
 			storage->getUserSetting(1, "enable_transport", type, value);
 			CPPUNIT_ASSERT_EQUAL(std::string("0"), value);
+			}
 			received.clear();
 			payload = boost::shared_ptr<Swift::Command>(new Swift::Command("settings"));
 			iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Executing, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
 			// form element
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm()->getField("enable_transport"));
 			// set enabled_transport = 0
 			f = getStanza(received[0])->getPayload<Swift:: Command>()->getForm()->getField("enable_transport");
 			CPPUNIT_ASSERT_EQUAL(false, boost::dynamic_pointer_cast<Swift::BooleanFormField>(f)->getValue());
+		}
 		void executeTwoCommands() {
 			addUser();
 			boost::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Executing, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
 			// form element
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm()->getField("enable_transport"));
 			received.clear();
 			payload = boost::shared_ptr<Swift::Command>(new Swift::Command("settings"));
 			iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Executing, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
 			// form element
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm()->getField("enable_transport"));
+		}
 		void executeBadSessionID() {
 			addUser();
 			boost::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Executing, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			std::string sessionId = "somethingwrong";
 			// finish the command
 			payload = boost::shared_ptr<Swift::Command>(new Swift::Command("settings"));
 			payload->setSessionID(sessionId);
 			payload->setForm(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			received.clear();
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Error, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
+		}
 		void cancel() {
 			addUser();
 			boost::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Executing, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			std::string sessionId = getStanza(received[0])->getPayload<Swift::Command>()->getSessionID();
 			// cancel the command
 			payload = boost::shared_ptr<Swift::Command>(new Swift::Command("settings"));
 			payload->setSessionID(sessionId);
 			payload->setAction(Swift::Command::Cancel);
 			iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			received.clear();
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Canceled, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
+		}
 		void propagateUserSetting() {
 			connectUser();
 			User *user = userManager->getUser("user@localhost");
 			CPPUNIT_ASSERT_EQUAL(std::string("0"), user->getUserSetting("send_headlines"));
 			boost::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Executing, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
 			// form element
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm()->getField("send_headlines"));
 			// set enabled_transport = 0
 			Swift::FormField::ref f = getStanza(received[0])->getPayload<Swift:: Command>()->getForm()->getField("send_headlines");
 			boost::dynamic_pointer_cast<Swift::BooleanFormField>(f)->setValue(true);
 			std::string sessionId = getStanza(received[0])->getPayload<Swift::Command>()->getSessionID();
 			// finish the command
 			payload = boost::shared_ptr<Swift::Command>(new Swift::Command("settings"));
 			payload->setSessionID(sessionId);
 			payload->setForm(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			received.clear();
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(std::string("1"), user->getUserSetting("send_headlines"));
+		}
 		void defaultAccordingToConfig() {
 			std::istringstream ifs("service.server_mode = 1\nservice.jid_escaping=0\nservice.jid=localhost\nsettings.send_headlines=1\n");
 			cfg->load(ifs);
 			connectUser();
 			User *user = userManager->getUser("user@localhost");
 			CPPUNIT_ASSERT_EQUAL(std::string("1"), user->getUserSetting("send_headlines"));
 			boost::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Executing, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
 			// form element
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>()->getForm()->getField("send_headlines"));
 			Swift::FormField::ref f = getStanza(received[0])->getPayload<Swift:: Command>()->getForm()->getField("send_headlines");
 			CPPUNIT_ASSERT_EQUAL(true, boost::dynamic_pointer_cast<Swift::BooleanFormField>(f)->getValue());
+		}
 };
 CPPUNIT_TEST_SUITE_REGISTRATION (SettingsAdHocCommandTest);

0 comments (0 inline, 0 general)