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;

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

@@ @@ -23,128 +23,137 @@ @@
 #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) {

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

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

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

@@ @@ -100,165 +100,174 @@ class TestingStorageBackend : public StorageBackend { @@
 		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());

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