libtransport.git Changeset - 317b82998a01

Changeset - 317b82998a01

Parent rev.

Child rev.

[Not reviewed]

Merge

! ! !

Vitaly Takmazov - 13 years ago 2013-01-29 08:22:01
vitalyster@gmail.com

Merge branch 'master' of https://github.com/hanzz/libtransport

66 files changed:

CMakeLists.txt

backends/libcommuni/ircnetworkplugin.cpp

backends/libcommuni/main.cpp

backends/libcommuni/session.cpp

backends/libpurple/main.cpp

backends/skype/main.cpp

backends/swiften/main.cpp

172

include/transport/adhoccommand.h

include/transport/adhoccommandfactory.h

include/transport/adhocmanager.h

include/transport/admininterface.h

include/transport/buddy.h

include/transport/conversation.h

include/transport/conversationmanager.h

include/transport/discoitemsresponder.h

include/transport/factory.h

include/transport/gatewayresponder.h

include/transport/memoryreadbytestream.h

include/transport/mysqlbackend.h

include/transport/networkplugin.h

include/transport/networkpluginserver.h

include/transport/pqxxbackend.h

include/transport/protocol.proto

include/transport/rostermanager.h

include/transport/rosterresponder.h

include/transport/rosterstorage.h

include/transport/settingsadhoccommand.h

include/transport/sqlite3backend.h

include/transport/statsresponder.h

include/transport/threadpool.h

include/transport/transport.h

include/transport/user.h

include/transport/usermanager.h

include/transport/userregistration.h

include/transport/userregistry.h

include/transport/usersreconnecter.h

include/transport/vcardresponder.h

plugin/cpp/networkplugin.cpp

spectrum/src/main.cpp

spectrum/src/sample.cfg

spectrum/src/sample2.cfg

spectrum_manager/src/main.cpp

src/blockresponder.cpp

src/blockresponder.h

src/buddy.cpp

src/config.cpp

src/conversation.cpp

src/discoinforesponder.cpp

src/discoinforesponder.h

src/discoitemsresponder.cpp

src/filetransfermanager.cpp

src/gatewayresponder.cpp

src/logging.cpp

src/networkpluginserver.cpp

src/presenceoracle.cpp

src/rostermanager.cpp

src/rosterresponder.cpp

src/rosterstorage.cpp

src/statsresponder.cpp

src/storagebackend.cpp

src/storageresponder.cpp

src/storageresponder.h

src/tests/conversationmanager.cpp

src/tests/rostermanager.cpp

src/tests/user.cpp

src/tests/userregistry.cpp

Changeset was too big and was cut off... Show full diff anyway

0 comments (0 inline, 0 general)

CMakeLists.txt

➞

Show inline comments

@@ @@ -8,49 +8,49 @@ message(STATUS " |- zlib : -DZLIB_LIBRARY") @@
 message(STATUS "  |- expat :                         -DEXPAT_LIBRARY")
 message(STATUS "  |-libidn :                         -DLIBIDN_LIBRARY")
 message(STATUS "  |-libxml :                         -DLIBXML_LIBRARY")
 message(STATUS "|- boost   : -DBOOST_INCLUDEDIR,     -DBOOST_LIBRARYDIR")
 message(STATUS "|- protobuf: -DPROTOBUF_INCLUDE_DIR, -DPROTOBUF_LIBRARY")
 message(STATUS "           : -DPROTOBUF_PROTOC_EXECUTABLE")
 message(STATUS "|- log4cxx : -DLOG4CXX_INCLUDE_DIR,  -DLOG4CXX_LIBRARY")
 message(STATUS "|- purple  : -DPURPLE_INCLUDE_DIR,   -DPURPLE_LIBRARY")
 message(STATUS "           : -DPURPLE_NOT_RUNTIME - enables compilation with libpurple.lib")
 option(ENABLE_SQLITE3 "Build with SQLite3 support" ON)
 option(ENABLE_MYSQL "Build with MySQL support" ON)
 option(ENABLE_PQXX "Build with Postgres supoort" ON)
 option(ENABLE_FROTZ "Build Frotz plugin" ON)
 option(ENABLE_IRC "Build IRC plugin" ON)
 option(ENABLE_PURPLE "Build Libpurple plugin" ON)
 option(ENABLE_SMSTOOLS3 "Build SMSTools3 plugin" ON)
 option(ENABLE_SKYPE "Build Skype plugin" ON)
 option(ENABLE_SWIFTEN "Build Swiften plugin" ON)
 option(ENABLE_TWITTER "Build Twitter plugin" ON)
 option(ENABLE_YAHOO2 "Build Libyahoo2 plugin" ON)
 option(ENABLE_DOCS "Build Docs" ON)
 option(ENABLE_LOG "Build with logging using Log4cxx" ON)
+# option(ENABLE_LOG "Build with logging using Log4cxx" ON)
 option(ENABLE_TESTS "Build Tests using CppUnit" OFF)
 MACRO(LIST_CONTAINS var value)
 	SET(${var})
 	FOREACH (value2 ${ARGN})
 		IF (${value} STREQUAL ${value2})
 		SET(${var} TRUE)
 		ENDIF (${value} STREQUAL ${value2})
 	ENDFOREACH (value2)
 ENDMACRO(LIST_CONTAINS)
 if(NOT LIB_INSTALL_DIR)
 	set(LIB_INSTALL_DIR "lib")
 endif()
 set(CMAKE_MODULE_PATH "cmake_modules")
 ###### Prerequisites ######
 # FIND SWIFTEN
 set(Swiften_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(Swiften)
@@ @@ -204,58 +204,58 @@ if(ENABLE_IRC) @@
 	# ADD_DEFINITIONS(${SWIFTEN_CFLAGS})
 	ADD_DEFINITIONS(-DSUPPORT_LEGACY_CAPS)
 	# ADD_DEFINITIONS(-DBOOST_FILESYSTEM_VERSION=2)
 endif()
 set(event_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(event)
 if (NOT WIN32 AND ENABLE_SKYPE)
 set(dbus_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(dbus)
 endif()
 # if(ENABLE_YAHOO2)
 # 	set(yahoo2_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 # 	find_package(yahoo2)
 # endif()
 ####### Miscallanous ######
 if(ENABLE_DOCS)
 	find_package(Doxygen)
 endif()
 if(ENABLE_LOG)
+# if(ENABLE_LOG)
 	if(LOG4CXX_INCLUDE_DIR AND LOG4CXX_LIBRARY)
 		set(LOG4CXX_LIBRARIES ${LOG4CXX_LIBRARY})
 		set(LOG4CXX_FOUND 1)
 		message(STATUS "Using log4cxx: ${CPPUNIT_INCLUDE_DIR} ${LOG4CXX_INCLUDE_DIR}")
 	else()
 		set(log4cxx_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 		find_package(log4cxx)
 	endif()
 endif()
+# endif()
 # FIND CPPUNIT
 if(ENABLE_TESTS)
 	set(cppunit_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 	find_package(cppunit)
 	if(NOT CPPUNIT_FOUND AND CPPUNIT_INCLUDE_DIR AND CPPUNIT_LIBRARY)
 		set(CCPUNIT_LIBRARIES ${CPPUNIT_LIBRARY})
 		set(CPPUNIT_FOUND 1)
 		message(STATUS "Using cppunit: ${CPPUNIT_INCLUDE_DIR} ${CPPUNIT_LIBRARIES}")
 	endif()
 endif()
 message("  Supported features")
 message("-----------------------")
 if (SPECTRUM_VERSION)
 	ADD_DEFINITIONS(-DSPECTRUM_VERSION="${SPECTRUM_VERSION}")
 else (SPECTRUM_VERSION)
 	if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
 		if (NOT GIT_EXECUTABLE)
 		set (GIT_EXECUTABLE git)
 		endif()
 		execute_process(COMMAND ${GIT_EXECUTABLE} "--git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git" rev-parse --short HEAD
@@ @@ -402,52 +402,52 @@ if (PROTOBUF_FOUND) @@
 		endif()
 #  	endif()
 	if(ENABLE_SWIFTEN)
 		message("Swiften plugin    : yes")
 	else()
 		message("Swiften plugin    : no (user disabled)")
 	endif()
 else()
 	message("Network plugins   : no (install libprotobuf-dev)")
 	message("Libpurple plugin  : no (install libpurple and libprotobuf-dev)")
 	message("IRC plugin        : no (install libircclient-qt and libprotobuf-dev)")
 	message("Frotz plugin      : no (install libprotobuf-dev)")
 	message("SMSTools3 plugin  : no (install libprotobuf-dev)")
 	message("Swiften plugin    : no (install libprotobuf-dev)")
     message("Twitter plugin    : no (install libprotobuf-dev)")
 endif()
 if (LOG4CXX_FOUND)
 	message("Log4cxx           : yes")
 	include_directories(${LOG4CXX_INCLUDE_DIR})
 	ADD_DEFINITIONS(-DWITH_LOG4CXX)
 else()
 	set(LOG4CXX_LIBRARIES "")
-	if(ENABLE_LOG)
+	if (WIN32)
 		message("Log4cxx           : no (install log4cxx-devel)")
 	else(ENABLE_LOG)
 		message("Log4cxx           : no (user disabled)")
 	else()
 		message(FATAL_ERROR "Log4cxx           : no (install log4cxx-devel)")
 	endif()
 endif()
 if (WIN32)
 	ADD_DEFINITIONS(-DLOG4CXX_STATIC)
 	ADD_DEFINITIONS(-D_WIN32_WINNT=0x501)
 	ADD_DEFINITIONS(-DWIN32_LEAN_AND_MEAN)
 	ADD_DEFINITIONS(-DBOOST_USE_WINDOWS_H)
 	ADD_DEFINITIONS(-DBOOST_THREAD_USE_LIB)
 endif()
 if(CMAKE_BUILD_TYPE MATCHES Debug)
 	if (CMAKE_COMPILER_IS_GNUCXX)
 		ADD_DEFINITIONS(-O0)
 		ADD_DEFINITIONS(-ggdb)
 	endif()
 	ADD_DEFINITIONS(-DDEBUG)
 	message("Debug             : yes")
 else(CMAKE_BUILD_TYPE MATCHES Debug)
 	message("Debug             : no (run \"cmake . -DCMAKE_BUILD_TYPE=Debug\")")
 endif(CMAKE_BUILD_TYPE MATCHES Debug)
 SET(TRANSPORT_VERSION 2.0)

backends/libcommuni/ircnetworkplugin.cpp

➞

Show inline comments

 		m_identify = "NickServ identify $name $password";
+	}
+}
 void IRCNetworkPlugin::tryNextServer() {
 	if (!m_servers.empty()) {
 		int nextServer = (m_currentServer + 1) % m_servers.size();
 		LOG4CXX_INFO(logger, "Server " << m_servers[m_currentServer] << " disconnected user. Next server to try will be " << m_servers[nextServer]);
 		m_currentServer = nextServer;
+	}
+}
 void IRCNetworkPlugin::readData() {
 	size_t availableBytes = m_socket->bytesAvailable();
 	if (availableBytes == 0)
 		return;
 	if (m_firstPing) {
 		m_firstPing = false;
 		// Users can join the network without registering if we allow
 		// one user to connect multiple IRC networks.
 		if (m_servers.empty()) {
 			NetworkPlugin::PluginConfig cfg;
 			cfg.setNeedRegistration(false);
 			cfg.setSupportMUC(true);
 			sendConfig(cfg);
+		}
+	}
 	std::string d = std::string(m_socket->readAll().data(), availableBytes);
 	handleDataRead(d);
+}
 void IRCNetworkPlugin::sendData(const std::string &string) {
 	m_socket->write(string.c_str(), string.size());
+}
 MyIrcSession *IRCNetworkPlugin::createSession(const std::string &user, const std::string &hostname, const std::string &nickname, const std::string &password, const std::string &suffix) {
 	MyIrcSession *session = new MyIrcSession(user, this, suffix);
 	session->setUserName(FROM_UTF8(nickname));
 	session->setNickName(FROM_UTF8(nickname));
 	session->setRealName(FROM_UTF8(nickname));
 	session->setHost(FROM_UTF8(hostname));
 	session->setPort(6667);
 // 	session->setEncoding("UTF8");
 	if (!password.empty()) {
 		std::string identify = m_identify;
 		boost::replace_all(identify, "$password", password);

backends/libcommuni/main.cpp

➞

Show inline comments

@@ @@ -12,34 +12,34 @@ @@
 #include "transport/networkplugin.h"
 #include "transport/logging.h"
 #include "session.h"
 #include <QtCore>
 #include <QtNetwork>
 #include "Swiften/EventLoop/Qt/QtEventLoop.h"
 #include "ircnetworkplugin.h"
 using namespace boost::program_options;
 using namespace Transport;
 NetworkPlugin * np = NULL;
 int main (int argc, char* argv[]) {
 	std::string host;
 	int port;
 	std::string error;
 	Config *cfg = Config::createFromArgs(argc, argv, error, host, port);
 	if (cfg == NULL) {
 		std::cerr << error;
 		return 1;
+	}
 	QCoreApplication app(argc, argv);
 	Logging::initBackendLogging(cfg);
 	QCoreApplication app(argc, argv);
 	Swift::QtEventLoop eventLoop;
 	np = new IRCNetworkPlugin(cfg, &eventLoop, host, port);
 	return app.exec();
+}

backends/libcommuni/session.cpp

➞

Show inline comments

@@ @@ -65,72 +65,75 @@ void MyIrcSession::on_connected() { @@
 	if (getIdentify().find(" ") != std::string::npos) {
 		std::string to = getIdentify().substr(0, getIdentify().find(" "));
 		std::string what = getIdentify().substr(getIdentify().find(" ") + 1);
 		sendCommand(IrcCommand::createMessage(FROM_UTF8(to), FROM_UTF8(what)));
+	}
+}
 void MyIrcSession::on_socketError(QAbstractSocket::SocketError error) {
 	on_disconnected();
+}
 void MyIrcSession::on_disconnected() {
 	if (suffix.empty()) {
 		np->handleDisconnected(user, 0, "");
 		np->tryNextServer();
+	}
 	m_connected = false;
+}
 bool MyIrcSession::correctNickname(std::string &nickname) {
 	bool flags = 0;
 	switch(nickname.at(0)) {
 		case '@': nickname = nickname.substr(1); flags = 1; break;
 		case '+': nickname = nickname.substr(1); break;
 		case '~': nickname = nickname.substr(1); break;
 		case '&': nickname = nickname.substr(1); break;
 		case '%': nickname = nickname.substr(1); break;
 		default: break;
+	}
 	return flags;
+}
 void MyIrcSession::on_joined(IrcMessage *message) {
 	IrcJoinMessage *m = (IrcJoinMessage *) message;
 	bool op = 0;
 	std::string nickname = TO_UTF8(m->sender().name());
 	op = correctNickname(nickname);
 	getIRCBuddy(TO_UTF8(m->channel()), nickname).setOp(op);
 	np->handleParticipantChanged(user, nickname, TO_UTF8(m->channel()) + suffix, op, pbnetwork::STATUS_ONLINE);
 	LOG4CXX_INFO(logger, user << ": " << nickname << " joined " << TO_UTF8(m->channel()) + suffix);
 	getIRCBuddy(TO_UTF8(m->channel().toLower()), nickname).setOp(op);
 	np->handleParticipantChanged(user, nickname, TO_UTF8(m->channel().toLower()) + suffix, op, pbnetwork::STATUS_ONLINE);
 	LOG4CXX_INFO(logger, user << ": " << nickname << " joined " << TO_UTF8(m->channel().toLower()) + suffix);
+}
 void MyIrcSession::on_parted(IrcMessage *message) {
 	IrcPartMessage *m = (IrcPartMessage *) message;
 	bool op = 0;
 	std::string nickname = TO_UTF8(m->sender().name());
 	op = correctNickname(nickname);
 	removeIRCBuddy(TO_UTF8(m->channel()), nickname);
 	LOG4CXX_INFO(logger, user << ": " << nickname << " parted " << TO_UTF8(m->channel()) + suffix);
 	np->handleParticipantChanged(user, nickname, TO_UTF8(m->channel()) + suffix, op, pbnetwork::STATUS_NONE, TO_UTF8(m->reason()));
 	removeIRCBuddy(TO_UTF8(m->channel().toLower()), nickname);
 	LOG4CXX_INFO(logger, user << ": " << nickname << " parted " << TO_UTF8(m->channel().toLower()) + suffix);
 	np->handleParticipantChanged(user, nickname, TO_UTF8(m->channel().toLower()) + suffix, op, pbnetwork::STATUS_NONE, TO_UTF8(m->reason()));
+}
 void MyIrcSession::on_quit(IrcMessage *message) {
 	IrcQuitMessage *m = (IrcQuitMessage *) message;
 	for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
 		bool op = 0;
 		std::string nickname = TO_UTF8(m->sender().name());
 		if (!hasIRCBuddy(it->second->getChannel(), nickname)) {
 			continue;
+		}
 		op = correctNickname(nickname);
 		removeIRCBuddy(it->second->getChannel(), nickname);
 		LOG4CXX_INFO(logger, user << ": " << nickname << " quit " << it->second->getChannel() + suffix);
 		np->handleParticipantChanged(user, nickname, it->second->getChannel() + suffix, op, pbnetwork::STATUS_NONE, TO_UTF8(m->reason()));
+	}
+}
 void MyIrcSession::on_nickChanged(IrcMessage *message) {
 	IrcNickMessage *m = (IrcNickMessage *) message;
 	for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
 		std::string nickname = TO_UTF8(m->sender().name());
 		if (!hasIRCBuddy(it->second->getChannel(), nickname)) {
 			continue;
 		return;
 	LOG4CXX_INFO(logger, user << ": " << nickname << " changed mode to " << mode);
 	for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
 		if (!hasIRCBuddy(it->second->getChannel(), nickname)) {
 			continue;
+		}
 		IRCBuddy &buddy = getIRCBuddy(it->second->getChannel(), nickname);
 		if (mode == "+o") {
 			buddy.setOp(true);
+		}
 		else {
 			buddy.setOp(false);
+		}
 		np->handleParticipantChanged(user, nickname, it->second->getChannel() + suffix,(int) buddy.isOp(), pbnetwork::STATUS_ONLINE, "");
+	}
+}
 void MyIrcSession::on_topicChanged(IrcMessage *message) {
 	IrcTopicMessage *m = (IrcTopicMessage *) message;
 	std::string nickname = TO_UTF8(m->sender().name());
 	correctNickname(nickname);
 	LOG4CXX_INFO(logger, user << ": " << nickname << " topic changed to " << TO_UTF8(m->topic()));
 	np->handleSubject(user, TO_UTF8(m->channel()) + suffix, TO_UTF8(m->topic()), nickname);
+	np->handleSubject(user, TO_UTF8(m->channel().toLower()) + suffix, TO_UTF8(m->topic()), nickname);
+}
 void MyIrcSession::on_messageReceived(IrcMessage *message) {
 	IrcPrivateMessage *m = (IrcPrivateMessage *) message;
 	if (m->isRequest()) {
 		QString request = m->message().split(" ", QString::SkipEmptyParts).value(0).toUpper();
 		if (request == "PING" || request == "TIME" || request == "VERSION") {
 			LOG4CXX_INFO(logger, user << ": " << TO_UTF8(request) << " received and has been answered");
 			return;
+		}
+	}
 	QString msg = m->message();
 	if (m->isAction()) {
 		msg = QString("/me ") + msg;
+	}
 	std::string target = TO_UTF8(m->target());
+	std::string target = TO_UTF8(m->target().toLower());
 	LOG4CXX_INFO(logger, user << ": Message from " << target);
 	if (target.find("#") == 0) {
 		std::string nickname = TO_UTF8(m->sender().name());
 		correctNickname(nickname);
 		np->handleMessage(user, target + suffix, TO_UTF8(msg), nickname);
+	}
 	else {
 		std::string nickname = TO_UTF8(m->sender().name());
 		correctNickname(nickname);
 		LOG4CXX_INFO(logger, nickname + suffix);
 		np->handleMessage(user, nickname + suffix, TO_UTF8(msg));
+	}
+}
 void MyIrcSession::on_numericMessageReceived(IrcMessage *message) {
 	QString channel;
 	QStringList members;
 	std::string nick;
 	IrcNumericMessage *m = (IrcNumericMessage *) message;
 	QStringList parameters = m->parameters();
 	switch (m->code()) {
 		case 301:
 			break;
 		case 315:
 			LOG4CXX_INFO(logger, "End of /who request " << TO_UTF8(parameters[1]));
 			break;
 		case 332:
 			m_topicData = TO_UTF8(parameters[2]);
 			break;
 		case 333:
 			nick = TO_UTF8(parameters[2]);
 			if (nick.find("!") != std::string::npos) {
 				nick = nick.substr(0, nick.find("!"));
+			}
 			if (nick.find("/") != std::string::npos) {
 				nick = nick.substr(0, nick.find("/"));
+			}
 			np->handleSubject(user, TO_UTF8(parameters[1]) + suffix, m_topicData, nick);
+			np->handleSubject(user, TO_UTF8(parameters[1].toLower()) + suffix, m_topicData, nick);
 			break;
 		case 352: {
 			channel = parameters[1];
+			channel = parameters[1].toLower();
 			nick = TO_UTF8(parameters[5]);
 			IRCBuddy &buddy = getIRCBuddy(TO_UTF8(channel), nick);
 			if (parameters[6].toUpper().startsWith("G")) {
 				if (!buddy.isAway()) {
 					buddy.setAway(true);
 					np->handleParticipantChanged(user, nick, TO_UTF8(channel) + suffix, buddy.isOp(), pbnetwork::STATUS_AWAY);
+				}
+			}
 			else if (buddy.isAway()) {
 				buddy.setAway(false);
 				np->handleParticipantChanged(user, nick, TO_UTF8(channel) + suffix, buddy.isOp(), pbnetwork::STATUS_ONLINE);
+			}
 			break;
+		}
 		case 353:
 			channel = parameters[2];
+			channel = parameters[2].toLower();
 			members = parameters[3].split(" ");
 			LOG4CXX_INFO(logger, user << ": Received members for " << TO_UTF8(channel) << suffix);
 			for (int i = 0; i < members.size(); i++) {
 				bool op = 0;
 				std::string nickname = TO_UTF8(members.at(i));
 				op = correctNickname(nickname);
 				IRCBuddy &buddy = getIRCBuddy(TO_UTF8(channel), nickname);
 				buddy.setOp(op);
 				np->handleParticipantChanged(user, nickname, TO_UTF8(channel) + suffix, buddy.isOp(), pbnetwork::STATUS_ONLINE);
+			}
 			break;
 		case 366:
 			// ask /who to get away states
 			channel = parameters[1];
+			channel = parameters[1].toLower();
 			LOG4CXX_INFO(logger, user << "Asking /who for channel " << TO_UTF8(channel));
 			sendCommand(IrcCommand::createWho(channel));
 			break;
 		case 432:
 			np->handleDisconnected(user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Erroneous Nickname");
 			break;
 		case 433:
 			for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
 				np->handleParticipantChanged(user, TO_UTF8(nickName()), it->second->getChannel() + suffix, pbnetwork::PARTICIPANT_FLAG_CONFLICT);
+			}
 			if (suffix.empty()) {
 				np->handleDisconnected(user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Nickname is already in use");
+			}
 			break;
 		case 436:
 			for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
 				np->handleParticipantChanged(user, TO_UTF8(nickName()), it->second->getChannel() + suffix, pbnetwork::PARTICIPANT_FLAG_CONFLICT);
+			}
 			np->handleDisconnected(user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Nickname collision KILL");
 		case 464:
 			for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
 				np->handleParticipantChanged(user, TO_UTF8(nickName()), it->second->getChannel() + suffix, pbnetwork::PARTICIPANT_FLAG_NOT_AUTHORIZED);
+			}
 			if (suffix.empty()) {
 				np->handleDisconnected(user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Password incorrect");
+			}
 		case 321:
 			m_rooms.clear();
 			m_names.clear();
 			break;
 		case 322:
 			m_rooms.push_back(TO_UTF8(parameters[1]));
 			m_names.push_back(TO_UTF8(parameters[1]));
 			break;
 		case 323:
 			np->handleRoomList("", m_rooms, m_names);
 			break;
 		default:
 			break;
+	}
 	if (m->code() >= 400 && m->code() < 500) {
 			LOG4CXX_INFO(logger, user << ": Error message received: " << message->toData().data());
+	}
 	//qDebug() << "numeric message received:" << receiver() << origin << code << params;
+}
 void MyIrcSession::awayTimeout() {
 	for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
 		if (it->second->shouldAskWho()) {
 			LOG4CXX_INFO(logger, "The time has come. Asking /who " << it->second->getChannel() << " again to get current away states.");
 			sendCommand(IrcCommand::createWho(FROM_UTF8(it->second->getChannel())));
+		}
+	}
+}
 void MyIrcSession::onMessageReceived(IrcMessage *message) {
 // 	LOG4CXX_INFO(logger, user << ": " << TO_UTF8(message->toString()));
 	switch (message->type()) {
 		case IrcMessage::Join:
 			on_joined(message);
 			break;
 		case IrcMessage::Part:
 			on_parted(message);
 			break;
 		case IrcMessage::Quit:
 			on_quit(message);
 			break;

backends/libpurple/main.cpp

➞

Show inline comments

@@ @@ -22,48 +22,49 @@ @@
 #endif
 #include <algorithm>
 #include "errno.h"
 #include <boost/make_shared.hpp>
 #ifdef WITH_LIBEVENT
 #include <event.h>
 #endif
 #ifdef WIN32
 #include "win32/win32dep.h"
 #define close closesocket
 #define ssize_t SSIZE_T
 #include <process.h>
 #define getpid _getpid
 #endif
 #include "purple_defs.h"
 DEFINE_LOGGER(logger_libpurple, "libpurple");
 DEFINE_LOGGER(logger, "backend");
 int main_socket;
 static int writeInput;
 bool firstPing = true;
 using namespace Transport;
 template <class T> T fromString(const std::string &str) {
 	T i;
 	std::istringstream os(str);
 	os >> i;
 	return i;
+}
 template <class T> std::string stringOf(T object) {
 	std::ostringstream os;
 	os << object;
 	return (os.str());
+}
 static std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
     std::stringstream ss(s);
     std::string item;
     while(std::getline(ss, item, delim)) {
         elems.push_back(item);
+    }
     return elems;
+}
@@ @@ -528,48 +529,49 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 				PurpleBuddy *buddy = purple_find_buddy_wrapped(account, buddyName.c_str());
 				if (buddy) {
 					if (getAlias(buddy) != alias) {
 						purple_blist_alias_buddy_wrapped(buddy, alias.c_str());
 						purple_blist_server_alias_buddy_wrapped(buddy, alias.c_str());
 						serv_alias_buddy_wrapped(buddy);
+					}
 					PurpleGroup *group = purple_find_group_wrapped(groups.c_str());
 					if (!group) {
 						group = purple_group_new_wrapped(groups.c_str());
+					}
 					purple_blist_add_contact_wrapped(purple_buddy_get_contact_wrapped(buddy), group ,NULL);
+				}
 				else {
 					PurpleBuddy *buddy = purple_buddy_new_wrapped(account, buddyName.c_str(), alias.c_str());
 					// Add newly created buddy to legacy network roster.
 					PurpleGroup *group = purple_find_group_wrapped(groups.c_str());
 					if (!group) {
 						group = purple_group_new_wrapped(groups.c_str());
+					}
 					purple_blist_add_buddy_wrapped(buddy, NULL, group ,NULL);
 					purple_account_add_buddy_wrapped(account, buddy);
 					LOG4CXX_INFO(logger, "Adding new buddy " << buddyName.c_str() << " to legacy network roster");
+				}
+			}
+		}
 		void handleBuddyBlockToggled(const std::string &user, const std::string &buddyName, bool blocked) {
 			if (CONFIG_BOOL(config, "service.enable_privacy_lists")) {
 				PurpleAccount *account = m_sessions[user];
 				if (account) {
 					if (blocked) {
 						purple_privacy_deny_wrapped(account, buddyName.c_str(), FALSE, FALSE);
+					}
 					else {
 						purple_privacy_allow_wrapped(account, buddyName.c_str(), FALSE, FALSE);
+					}
+				}
+			}
+		}
 		void handleTypingRequest(const std::string &user, const std::string &buddyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				LOG4CXX_INFO(logger, user << ": sending typing notify to " << buddyName);
 				serv_send_typing_wrapped(purple_account_get_connection_wrapped(account), buddyName.c_str(), PURPLE_TYPING);
+			}
@@ @@ -887,93 +889,93 @@ static PurpleBlistUiOps blistUiOps = @@
 	buddyListUpdate,
 	NULL, //NodeRemoved,
 	NULL,
 	NULL,
 	NULL, // buddyListAddBuddy,
 	NULL,
 	NULL,
 	NULL, //buddyListSaveNode,
 	NULL, //buddyListRemoveNode,
 	NULL, //buddyListSaveAccount,
 	NULL
 };
 static void conv_write_im(PurpleConversation *conv, const char *who, const char *msg, PurpleMessageFlags flags, time_t mtime) {
 	// Don't forwards our own messages.
 	if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_IM && (flags & PURPLE_MESSAGE_SEND || flags & PURPLE_MESSAGE_SYSTEM)) {
 		return;
+	}
 	PurpleAccount *account = purple_conversation_get_account_wrapped(conv);
 // 	char *striped = purple_markup_strip_html_wrapped(message);
 // 	std::string msg = striped;
 // 	g_free(striped);
 	std::string w = purple_normalize_wrapped(account, who);
 	size_t pos = w.find("/");
 	if (pos != std::string::npos)
 		w.erase((int) pos, w.length() - (int) pos);
 	// Escape HTML characters.
 	char *newline = purple_strdup_withhtml_wrapped(msg);
 	char *strip, *xhtml;
 	purple_markup_html_to_xhtml_wrapped(newline, &xhtml, &strip);
 // 	xhtml_linkified = spectrum_markup_linkify(xhtml);
 	std::string message_(strip);
 	std::string xhtml_(xhtml);
 	g_free(newline);
 	g_free(xhtml);
 // 	g_free(xhtml_linkified);
 	g_free(strip);
 	// AIM and XMPP adds <body>...</body> here...
 	if (xhtml_.find("<body>") == 0) {
 		xhtml_ = xhtml_.substr(6);
 		if (xhtml_.find("</body>") != std::string::npos) {
 			xhtml_ = xhtml_.substr(0, xhtml_.find("</body>"));
+		}
+	}
 	if (xhtml_ == message_) {
 		xhtml_ = "";
+	}
 	std::string timestamp;
 	if (mtime && (unsigned long) time(NULL)-10 > (unsigned long) mtime/* && (unsigned long) time(NULL) - 31536000 < (unsigned long) mtime*/) {
 		char buf[80];
 		strftime(buf, sizeof(buf), "%Y%m%dT%H%M%S", gmtime(&mtime));
 		timestamp = buf;
+	}
 // 	LOG4CXX_INFO(logger, "Received message body='" << message_ << "' xhtml='" << xhtml_ << "'");
 	if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_IM) {
 		std::string w = purple_normalize_wrapped(account, who);
 		size_t pos = w.find("/");
 		if (pos != std::string::npos)
 			w.erase((int) pos, w.length() - (int) pos);
 		np->handleMessage(np->m_accounts[account], w, message_, "", xhtml_, timestamp);
+	}
 	else {
 		LOG4CXX_INFO(logger, "Received message body='" << message_ << "' name='" << purple_conversation_get_name_wrapped(conv) << "' " << w);
 		np->handleMessage(np->m_accounts[account], purple_conversation_get_name_wrapped(conv), message_, w, xhtml_, timestamp);
 		LOG4CXX_INFO(logger, "Received message body='" << message_ << "' name='" << purple_conversation_get_name_wrapped(conv) << "' " << who);
 		np->handleMessage(np->m_accounts[account], purple_conversation_get_name_wrapped(conv), message_, who, xhtml_, timestamp);
+	}
+}
 static void conv_chat_add_users(PurpleConversation *conv, GList *cbuddies, gboolean new_arrivals) {
 	PurpleAccount *account = purple_conversation_get_account_wrapped(conv);
 	GList *l = cbuddies;
 	while (l != NULL) {
 		PurpleConvChatBuddy *cb = (PurpleConvChatBuddy *)l->data;
 		std::string name(cb->name);
 		int flags = GPOINTER_TO_INT(cb->flags);
 		if (flags & PURPLE_CBFLAGS_OP || flags & PURPLE_CBFLAGS_HALFOP) {
 // 			item->addAttribute("affiliation", "admin");
 // 			item->addAttribute("role", "moderator");
 			flags = 1;
+		}
 		else if (flags & PURPLE_CBFLAGS_FOUNDER) {
 // 			item->addAttribute("affiliation", "owner");
 // 			item->addAttribute("role", "moderator");
 			flags = 1;
+		}
 		else {
 			flags = 0;
 // 			item->addAttribute("affiliation", "member");
@@ @@ -1634,48 +1636,56 @@ static bool initPurple() { @@
 // 		purple_commands_init();
+	}
 	return ret;
+}
 static void transportDataReceived(gpointer data, gint source, PurpleInputCondition cond) {
 	if (cond & PURPLE_INPUT_READ) {
 		char buffer[65535];
 		char *ptr = buffer;
 #ifdef WIN32
 		ssize_t n = recv(source, ptr, sizeof(buffer), 0);
 #else
 		ssize_t n = read(source, ptr, sizeof(buffer));
 #endif
 		if (n <= 0) {
 			if (errno == EAGAIN) {
 				return;
+			}
 			LOG4CXX_INFO(logger, "Diconnecting from spectrum2 server");
 			exit(errno);
+		}
 		std::string d = std::string(buffer, n);
 		if (firstPing) {
 			firstPing = false;
 			NetworkPlugin::PluginConfig cfg;
 			cfg.setSupportMUC(true);
 			np->sendConfig(cfg);
+		}
 		np->handleDataRead(d);
+	}
 	else {
 		if (writeInput != 0) {
 			purple_input_remove_wrapped(writeInput);
 			writeInput = 0;
+		}
 		np->readyForData();
+	}
+}
 int main(int argc, char **argv) {
 #ifndef WIN32
 #ifndef __FreeBSD__
 		mallopt(M_CHECK_ACTION, 2);
 		mallopt(M_PERTURB, 0xb);
 #endif
 		signal(SIGPIPE, SIG_IGN);
 		if (signal(SIGCHLD, spectrum_sigchld_handler) == SIG_ERR) {
 			std::cout << "SIGCHLD handler can't be set\n";
 			return -1;
+		}

backends/skype/main.cpp

➞

Show inline comments

@@ @@ -181,48 +181,49 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 					break;
 				default:
 					st = "ONLINE";
 					break;
+			}
 			skype->send_command("SET USERSTATUS " + st);
 			if (!statusMessage.empty()) {
 				skype->send_command("SET PROFILE MOOD_TEXT " + statusMessage);
+			}
+		}
 		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups) {
 			Skype *skype = m_sessions[user];
 			if (skype) {
 				skype->send_command("SET USER " + buddyName + " BUDDYSTATUS 2 Please authorize me");
 				skype->send_command("SET USER " + buddyName + " ISAUTHORIZED TRUE");
+			}
+		}
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups) {
 			Skype *skype = m_sessions[user];
 			if (skype) {
 				skype->send_command("SET USER " + buddyName + " BUDDYSTATUS 1");
 				skype->send_command("SET USER " + buddyName + " ISAUTHORIZED FALSE");
+			}
+		}
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml = "", const std::string &id = "") {
 			Skype *skype = m_sessions[user];
 			if (skype) {
 				skype->send_command("MESSAGE " + legacyName + " " + message);
+			}
+		}
 		void handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id) {
 			Skype *skype = m_sessions[user];
 			if (skype) {
 				std::string name = legacyName;
 				if (name.find("skype.") == 0) {
 					name = name.substr(6);
+				}
 				std::string photo;
 				gchar *filename = NULL;
 				gchar *new_filename = NULL;
 				gchar *image_data = NULL;
 				gsize image_data_len = 0;
 				gchar *ret;
@@ @@ -584,52 +585,54 @@ bool Skype::loadSkypeBuddies() { @@
 			std::string alias = full_friends_list[i + 6];
 			std::string mood_text = "";
 			if (full_friends_list[i + 8] && *full_friends_list[i + 8] != '\0' && *full_friends_list[i + 8] != ',') {
 				mood_text = full_friends_list[i + 8];
+			}
 			std::vector<std::string> groups;
 			if (group_map.find(buddy) != group_map.end()) {
 				groups.push_back(group_map[buddy]);
+			}
 			np->handleBuddyChanged(m_user, buddy, alias, groups, status, mood_text);
+		}
+	}
 	g_strfreev(full_friends_list);
 	send_command("SET AUTOAWAY OFF");
 	send_command("SET USERSTATUS ONLINE");
 	return FALSE;
+}
 void Skype::logout() {
 	if (m_pid != 0) {
 		if (m_proxy) {
 			send_command("SET USERSTATUS INVISIBLE");
 			send_command("SET USERSTATUS OFFLINE");
 			sleep(2);
 			g_object_unref(m_proxy);
+		}
 		LOG4CXX_INFO(logger,  m_username << ": Terminating Skype instance (SIGTERM)");
 		kill((int) m_pid, SIGTERM);
 		// Give skype a chance
 		sleep(2);
 		LOG4CXX_INFO(logger,  m_username << ": Killing Skype instance (SIGKILL)");
 		kill((int) m_pid, SIGKILL);
 		m_pid = 0;
+	}
+}
 std::string Skype::send_command(const std::string &message) {
 	GError *error = NULL;
 	gchar *str = NULL;
 // 			int message_num;
 // 			gchar error_return[30];
 	LOG4CXX_INFO(logger, "Sending: '" << message << "'");
 	if (!dbus_g_proxy_call (m_proxy, "Invoke", &error, G_TYPE_STRING, message.c_str(), G_TYPE_INVALID,
 						G_TYPE_STRING, &str, G_TYPE_INVALID))
+	{
 			if (error && error->message)
+			{
 			LOG4CXX_INFO(logger,  m_username << ": DBUS Error: " << error->message);
 			g_error_free(error);
 			pbnetwork::StatusType status = getStatus(st);
 			std::string mood_text = GET_RESPONSE_DATA(message, "MOOD_TEXT");
 			std::vector<std::string> groups;
 			np->handleBuddyChanged(sk->getUser(), cmd[1], "", groups, status, mood_text);
+		}
 		else if (cmd[2] == "BUDDYSTATUS" && cmd[3] == "3") {
 			GET_PROPERTY(mood_text, "USER", cmd[1], "MOOD_TEXT");
 			GET_PROPERTY(st, "USER", cmd[1], "ONLINESTATUS");
 			pbnetwork::StatusType status = getStatus(st);
 			std::vector<std::string> groups;
 			np->handleBuddyChanged(sk->getUser(), cmd[1], "", groups, status, mood_text);
+		}
 		else if (cmd[2] == "FULLNAME") {
 			GET_PROPERTY(alias, "USER", cmd[1], "FULLNAME");
 			GET_PROPERTY(mood_text, "USER", cmd[1], "MOOD_TEXT");
 			GET_PROPERTY(st, "USER", cmd[1], "ONLINESTATUS");
 			pbnetwork::StatusType status = getStatus(st);
 			std::vector<std::string> groups;
 			np->handleBuddyChanged(sk->getUser(), cmd[1], alias, groups, status, mood_text);
+		}
 		//TODO: handle RECEIVEDAUTHREQUEST and reply it with:
 // 				void
 // 				skype_auth_allow(gpointer sender)
 // 				{
 // 					skype_send_message("SET USER %s ISAUTHORIZED TRUE", sender);
 // 					g_free(sender);
 // 				}
 //
 // 				void
 // 				skype_auth_deny(gpointer sender)
 // 				{
 // 					skype_send_message("SET USER %s ISAUTHORIZED FALSE", sender);
 // 					g_free(sender);
 // 				}
 		else if(cmd[2] == "RECEIVEDAUTHREQUEST") {
 			np->handleAuthorization(sk->getUser(), cmd[1]);
+		}
+	}
 	else if (cmd[0] == "CHATMESSAGE") {
 		if (cmd[3] == "RECEIVED") {
 			GET_PROPERTY(body, "CHATMESSAGE", cmd[1], "BODY");
 			GET_PROPERTY(from_handle, "CHATMESSAGE", cmd[1], "FROM_HANDLE");
 			if (from_handle == sk->getUsername())
 				return;
 			np->handleMessage(sk->getUser(), from_handle, body);
 			sk->send_command("SET CHATMESSAGE " + cmd[1] + " SEEN");
+		}
+	}
 	else if (cmd[0] == "CALL") {
 		// CALL 884 STATUS RINGING
 		if (cmd[2] == "STATUS") {
 			if (cmd[3] == "RINGING" || cmd[3] == "MISSED") {
 				// handle only incoming calls
 				GET_PROPERTY(type, "CALL", cmd[1], "TYPE");
 				if (type.find("INCOMING") != 0) {
 					return;
+				}

backends/swiften/main.cpp

➞

Show inline comments

 // Transport includes
 #include "transport/config.h"
 #include "transport/networkplugin.h"
 #include "transport/logging.h"
 #include "boost/date_time/posix_time/posix_time.hpp"
 // Swiften
 #include "Swiften/Swiften.h"
 #ifndef WIN32
 // for signal handler
 #include "unistd.h"
 #include "signal.h"
 #include "sys/wait.h"
 #include "sys/signal.h"
 #endif
 #ifndef __FreeBSD__
 // malloc_trim
 #include "malloc.h"
 #endif
 // Boost
 #include <boost/algorithm/string.hpp>
 using namespace boost::filesystem;
 using namespace boost::program_options;
 using namespace Transport;
 DEFINE_LOGGER(logger, "Swiften");
 // eventloop
 Swift::SimpleEventLoop *loop_;
 // Plugins
 class SwiftenPlugin;
 SwiftenPlugin *np = NULL;
 NetworkPlugin *np = NULL;
 class MUCController {
 	public:
 		MUCController(const std::string &user, boost::shared_ptr<Swift::Client> client, const std::string &room, const std::string &nickname, const std::string &password) {
 			m_user = user;
 			m_room = room;
 			muc = client->getMUCManager()->createMUC(room);
 			if (!password.empty()) {
 				muc->setPassword(password);
+			}
 			muc->onJoinComplete.connect(boost::bind(&MUCController::handleJoinComplete, this, _1));
 			muc->onJoinFailed.connect(boost::bind(&MUCController::handleJoinFailed, this, _1));
 			muc->onOccupantJoined.connect(boost::bind(&MUCController::handleOccupantJoined, this, _1));
 			muc->onOccupantPresenceChange.connect(boost::bind(&MUCController::handleOccupantPresenceChange, this, _1));
 			muc->onOccupantLeft.connect(boost::bind(&MUCController::handleOccupantLeft, this, _1, _2, _3));
 			muc->onOccupantRoleChanged.connect(boost::bind(&MUCController::handleOccupantRoleChanged, this, _1, _2, _3));
 			muc->onOccupantAffiliationChanged.connect(boost::bind(&MUCController::handleOccupantAffiliationChanged, this, _1, _2, _3));
 			muc->joinAs(nickname);
+		}
 		virtual ~MUCController() {
 			muc->onJoinComplete.disconnect(boost::bind(&MUCController::handleJoinComplete, this, _1));
 			muc->onJoinFailed.disconnect(boost::bind(&MUCController::handleJoinFailed, this, _1));
 			muc->onOccupantJoined.disconnect(boost::bind(&MUCController::handleOccupantJoined, this, _1));
 			muc->onOccupantPresenceChange.disconnect(boost::bind(&MUCController::handleOccupantPresenceChange, this, _1));
 			muc->onOccupantLeft.disconnect(boost::bind(&MUCController::handleOccupantLeft, this, _1, _2, _3));
 			muc->onOccupantRoleChanged.disconnect(boost::bind(&MUCController::handleOccupantRoleChanged, this, _1, _2, _3));
 			muc->onOccupantAffiliationChanged.disconnect(boost::bind(&MUCController::handleOccupantAffiliationChanged, this, _1, _2, _3));
+		}
 		const std::string &getNickname() {
 			//return muc->getCurrentNick();
 			return m_nick;
+		}
 		void handleOccupantJoined(const Swift::MUCOccupant& occupant) {
 			np->handleParticipantChanged(m_user, occupant.getNick(), m_room, occupant.getRole() == Swift::MUCOccupant::Moderator, pbnetwork::STATUS_ONLINE);
+		}
 		void handleOccupantLeft(const Swift::MUCOccupant& occupant, Swift::MUC::LeavingType type, const std::string& reason) {
 			np->handleParticipantChanged(m_user, occupant.getNick(), m_room, occupant.getRole() == Swift::MUCOccupant::Moderator, pbnetwork::STATUS_NONE);
+		}
 		void handleOccupantPresenceChange(boost::shared_ptr<Swift::Presence> presence) {
 			const Swift::MUCOccupant& occupant = muc->getOccupant(presence->getFrom().getResource());
 			np->handleParticipantChanged(m_user, presence->getFrom().getResource(), m_room, (int) occupant.getRole() == Swift::MUCOccupant::Moderator, (pbnetwork::StatusType) presence->getShow(), presence->getStatus());
+		}
 		void handleOccupantRoleChanged(const std::string& nick, const Swift::MUCOccupant& occupant, const Swift::MUCOccupant::Role& oldRole) {
+		}
 		void handleOccupantAffiliationChanged(const std::string& nick, const Swift::MUCOccupant::Affiliation& affiliation, const Swift::MUCOccupant::Affiliation& oldAffiliation) {
 // 			np->handleParticipantChanged(m_user, occupant->getNick(), m_room, (int) occupant.getRole() == Swift::MUCOccupant::Moderator, pbnetwork::STATUS_ONLINE);
+		}
 		void handleJoinComplete(const std::string& nick) {
 			m_nick = nick;
+		}
 		void handleJoinFailed(boost::shared_ptr<Swift::ErrorPayload> error) {
+		}
 		void part() {
 			muc->part();
+		}
 	private:
 		Swift::MUC::ref muc;
 		std::string m_user;
 		std::string m_room;
 		std::string m_nick;
 };
 class SwiftenPlugin : public NetworkPlugin {
 	public:
 		Swift::BoostNetworkFactories *m_factories;
 		Swift::BoostIOServiceThread m_boostIOServiceThread;
 		boost::shared_ptr<Swift::Connection> m_conn;
 		SwiftenPlugin(Config *config, Swift::SimpleEventLoop *loop, const std::string &host, int port) : NetworkPlugin() {
 			this->config = config;
 			m_factories = new Swift::BoostNetworkFactories(loop);
 			m_conn = m_factories->getConnectionFactory()->createConnection();
 			m_conn->onDataRead.connect(boost::bind(&SwiftenPlugin::_handleDataRead, this, _1));
 			m_conn->connect(Swift::HostAddressPort(Swift::HostAddress(host), port));
 			LOG4CXX_INFO(logger, "Starting the plugin.");
+		}
 		// NetworkPlugin uses this method to send the data to networkplugin server
 		void sendData(const std::string &string) {
 			m_conn->write(Swift::createSafeByteArray(string));
+		}
 		// This method has to call handleDataRead with all received data from network plugin server
 		void _handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data) {
@@ @@ -85,179 +163,271 @@ class SwiftenPlugin : public NetworkPlugin { @@
 					case Swift::ClientError::ClientCertificateError: message = ("Certificate not authorized"); break;
 					case Swift::ClientError::UnknownCertificateError: message = ("Unknown certificate"); break;
 					case Swift::ClientError::CertificateExpiredError: message = ("Certificate has expired"); break;
 					case Swift::ClientError::CertificateNotYetValidError: message = ("Certificate is not yet valid"); break;
 					case Swift::ClientError::CertificateSelfSignedError: message = ("Certificate is self-signed"); break;
 					case Swift::ClientError::CertificateRejectedError: message = ("Certificate has been rejected"); break;
 					case Swift::ClientError::CertificateUntrustedError: message = ("Certificate is not trusted"); break;
 					case Swift::ClientError::InvalidCertificatePurposeError: message = ("Certificate cannot be used for encrypting your connection"); break;
 					case Swift::ClientError::CertificatePathLengthExceededError: message = ("Certificate path length constraint exceeded"); break;
 					case Swift::ClientError::InvalidCertificateSignatureError: message = ("Invalid certificate signature"); break;
 					case Swift::ClientError::InvalidCAError: message = ("Invalid Certificate Authority"); break;
 					case Swift::ClientError::InvalidServerIdentityError: message = ("Certificate does not match the host identity"); break;
+				}
+			}
 			LOG4CXX_INFO(logger, user << ": Disconnected " << message);
 			handleDisconnected(user, reconnect ? 0 : 3, message);
 			boost::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				client->onConnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftConnected, this, user));
 				client->onDisconnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftDisconnected, this, user, _1));
 				client->onMessageReceived.disconnect(boost::bind(&SwiftenPlugin::handleSwiftMessageReceived, this, user, _1));
 				m_users.erase(user);
 				m_mucs.erase(user);
+			}
 #ifndef WIN32
 #ifndef __FreeBSD__
 			// force returning of memory chunks allocated by libxml2 to kernel
 			malloc_trim(0);
 #endif
 #endif
+		}
 		void handleSwiftConnected(const std::string &user) {
 			LOG4CXX_INFO(logger, user << ": Connected to XMPP server.");
 			handleConnected(user);
 			m_users[user]->requestRoster();
 			Swift::Presence::ref response = Swift::Presence::create();
 			response->setFrom(m_users[user]->getJID());
 			m_users[user]->sendPresence(response);
+		}
 		void handleSwiftRosterReceived(const std::string &user) {
 			Swift::PresenceOracle *oracle = m_users[user]->getPresenceOracle();
 			BOOST_FOREACH(const Swift::XMPPRosterItem &item, m_users[user]->getRoster()->getItems()) {
 				Swift::Presence::ref lastPresence = oracle->getLastPresence(item.getJID());
 				pbnetwork::StatusType status = lastPresence ? ((pbnetwork::StatusType) lastPresence->getShow()) : pbnetwork::STATUS_NONE;
 				handleBuddyChanged(user, item.getJID().toBare().toString(),
 								   item.getName(), item.getGroups(), status);
+			}
+		}
 		void handleSwiftPresenceChanged(const std::string &user, Swift::Presence::ref presence) {
 			boost::shared_ptr<Swift::Client> client = m_users[user];
 			if (client->getMUCRegistry()->isMUC(presence->getFrom().toBare())) {
 				return;
+			}
 			LOG4CXX_INFO(logger, user << ": " << presence->getFrom().toBare().toString() << " presence changed");
 			std::string message = presence->getStatus();
 			std::string photo = "";
 			boost::shared_ptr<Swift::VCardUpdate> update = presence->getPayload<Swift::VCardUpdate>();
 			if (update) {
 				photo = update->getPhotoHash();
+			}
 			boost::optional<Swift::XMPPRosterItem> item = m_users[user]->getRoster()->getItem(presence->getFrom());
 			if (item) {
 				handleBuddyChanged(user, presence->getFrom().toBare().toString(), item->getName(), item->getGroups(), (pbnetwork::StatusType) presence->getShow(), message, photo);
+			}
 			else {
 				std::vector<std::string> groups;
 				handleBuddyChanged(user, presence->getFrom().toBare().toString(), presence->getFrom().toBare(), groups, (pbnetwork::StatusType) presence->getShow(), message, photo);
+			}
+		}
 		void handleSwiftMessageReceived(const std::string &user, Swift::Message::ref message) {
 			std::string body = message->getBody();
 			boost::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				if (message->getType() == Swift::Message::Groupchat) {
 					boost::shared_ptr<Swift::Delay> delay = message->getPayload<Swift::Delay>();
 					std::string timestamp = "";
 					if (delay) {
 						timestamp = boost::posix_time::to_iso_string(delay->getStamp());
+					}
 					handleMessage(user, message->getFrom().toBare().toString(), body, message->getFrom().getResource(), "", timestamp);
+				}
 				else {
 					if (client->getMUCRegistry()->isMUC(message->getFrom().toBare())) {
 						handleMessage(user, message->getFrom().toBare().toString(), body, message->getFrom().getResource(), "", "", false, true);
+					}
 					else {
 						handleMessage(user, message->getFrom().toBare().toString(), body, "", "");
+					}
+				}
+			}
+		}
 		void handleSwiftVCardReceived(const std::string &user, unsigned int id, Swift::VCard::ref vcard, Swift::ErrorPayload::ref error) {
 			if (error || !vcard) {
 				LOG4CXX_INFO(logger, user << ": error fetching VCard with id=" << id);
 				handleVCard(user, id, "", "", "", "");
 				return;
+			}
 			LOG4CXX_INFO(logger, user << ": VCard fetched - id=" << id);
 			std::string photo((const char *)&vcard->getPhoto()[0], vcard->getPhoto().size());
 			handleVCard(user, id, vcard->getFullName(), vcard->getFullName(), vcard->getNickname(), photo);
+		}
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 			LOG4CXX_INFO(logger, user << ": connecting as " << legacyName);
 			boost::shared_ptr<Swift::Client> client = boost::make_shared<Swift::Client>(Swift::JID(legacyName), password, m_factories);
 			m_users[user] = client;
 			client->setAlwaysTrustCertificates();
 			client->onConnected.connect(boost::bind(&SwiftenPlugin::handleSwiftConnected, this, user));
 			client->onDisconnected.connect(boost::bind(&SwiftenPlugin::handleSwiftDisconnected, this, user, _1));
 			client->onMessageReceived.connect(boost::bind(&SwiftenPlugin::handleSwiftMessageReceived, this, user, _1));
 			client->getRoster()->onInitialRosterPopulated.connect(boost::bind(&SwiftenPlugin::handleSwiftRosterReceived, this, user));
 			client->getPresenceOracle()->onPresenceChange.connect(boost::bind(&SwiftenPlugin::handleSwiftPresenceChanged, this, user, _1));
 			Swift::ClientOptions opt;
 			opt.allowPLAINWithoutTLS = true;
 			client->connect(opt);
+		}
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 			boost::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				client->onConnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftConnected, this, user));
 // 				client->onDisconnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftDisconnected, this, user, _1));
 				client->onMessageReceived.disconnect(boost::bind(&SwiftenPlugin::handleSwiftMessageReceived, this, user, _1));
 				client->getRoster()->onInitialRosterPopulated.disconnect(boost::bind(&SwiftenPlugin::handleSwiftRosterReceived, this, user));
 				client->getPresenceOracle()->onPresenceChange.disconnect(boost::bind(&SwiftenPlugin::handleSwiftPresenceChanged, this, user, _1));
 				client->disconnect();
 				m_mucs.erase(user);
 				m_users.erase(user);
+			}
+		}
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &msg, const std::string &xhtml = "", const std::string &id = "") {
 			LOG4CXX_INFO(logger, "Sending message from " << user << " to " << legacyName << ".");
 			boost::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				boost::shared_ptr<Swift::Message> message(new Swift::Message());
 				message->setTo(Swift::JID(legacyName));
 				message->setFrom(client->getJID());
 				message->setBody(msg);
 				if (client->getMUCRegistry()->isMUC(legacyName)) {
 					message->setType(Swift::Message::Groupchat);
 					boost::shared_ptr<MUCController> muc = m_mucs[user][legacyName];
 					handleMessage(user, legacyName, msg, muc->getNickname(), xhtml);
+				}
 				client->sendMessage(message);
+			}
+		}
 		void handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id) {
 			boost::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				LOG4CXX_INFO(logger, user << ": fetching VCard of " << legacyName << " id=" << id);
 				Swift::GetVCardRequest::ref request = Swift::GetVCardRequest::create(Swift::JID(legacyName), client->getIQRouter());
 				request->onResponse.connect(boost::bind(&SwiftenPlugin::handleSwiftVCardReceived, this, user, id, _1, _2));
 				request->send();
+			}
+		}
 		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups) {
 			boost::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				LOG4CXX_INFO(logger, user << ": Added/Updated buddy " << buddyName << ".");
 // 			handleBuddyChanged(user, buddyName, alias, groups, pbnetwork::STATUS_ONLINE);
 				if (!client->getRoster()->containsJID(buddyName)) {
 					Swift::RosterItemPayload item;
 					item.setName(alias);
 					item.setJID(buddyName);
 					item.setGroups(groups);
 					boost::shared_ptr<Swift::RosterPayload> roster(new Swift::RosterPayload());
 					roster->addItem(item);
 					Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(roster, client->getIQRouter());
 // 					request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));
 					request->send();
 					client->getSubscriptionManager()->requestSubscription(buddyName);
+				}
 				else {
 					Swift::JID contact(buddyName);
 					Swift::RosterItemPayload item(contact, alias, client->getRoster()->getSubscriptionStateForJID(contact));
 					item.setGroups(groups);
 					boost::shared_ptr<Swift::RosterPayload> roster(new Swift::RosterPayload());
 					roster->addItem(item);
 					Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(roster, client->getIQRouter());
 // 					request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));
 					request->send();
+				}
+			}
+		}
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups) {
 			boost::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				Swift::RosterItemPayload item(buddyName, "", Swift::RosterItemPayload::Remove);
 				boost::shared_ptr<Swift::RosterPayload> roster(new Swift::RosterPayload());
 				roster->addItem(item);
 				Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(roster, client->getIQRouter());
 // 				request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));
 				request->send();
+			}
+		}
 		void handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &password) {
 			boost::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				if (client->getMUCRegistry()->isMUC(room)) {
 					return;
+				}
 				boost::shared_ptr<MUCController> muc = boost::shared_ptr<MUCController>( new MUCController(user, client, room, nickname, password));
 				m_mucs[user][room] = muc;
+			}
+		}
 		void handleLeaveRoomRequest(const std::string &user, const std::string &room) {
 			boost::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				if (!client->getMUCRegistry()->isMUC(room)) {
 					return;
+				}
 				boost::shared_ptr<MUCController> muc = m_mucs[user][room];
 				if (!muc) {
 					m_mucs[user].erase(room);
 					return;
+				}
 				muc->part();
 				m_mucs[user].erase(room);
+			}
+		}
 	private:
 		Config *config;
 		std::map<std::string, boost::shared_ptr<Swift::Client> > m_users;
 		std::map<std::string, std::map<std::string, boost::shared_ptr<MUCController> > > m_mucs;
 };
 #ifndef WIN32
 static void spectrum_sigchld_handler(int sig)
+{
 	int status;
 	pid_t pid;
 	do {
 		pid = waitpid(-1, &status, WNOHANG);
 	} while (pid != 0 && pid != (pid_t)-1);
 	if ((pid == (pid_t) - 1) && (errno != ECHILD)) {
 		char errmsg[BUFSIZ];
 		snprintf(errmsg, BUFSIZ, "Warning: waitpid() returned %d", pid);
 		perror(errmsg);
+	}
+}
 #endif
 int main (int argc, char* argv[]) {
 	std::string host;
 	int port;

include/transport/adhoccommand.h

➞

Show inline comments

@@ @@ -2,49 +2,52 @@ @@
  * 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 <time.h>
 #include "Swiften/Elements/FormField.h"
 #include "Swiften/Elements/Command.h"
 namespace Transport {
 class Component;
 class UserManager;
 class StorageBackend;
 class AdHocCommand {
 	public:
 		/// Creates new AdHocManager.
 		/// \param component Transport instance associated with this AdHocManager.
 		AdHocCommand(Component *component, UserManager *userManager, StorageBackend *storageBackend, const Swift::JID &initiator, const Swift::JID &to);
 		/// Destructor.
 		virtual ~AdHocCommand();
 		virtual boost::shared_ptr<Swift::Command> handleRequest(boost::shared_ptr<Swift::Command> payload) = 0;
 		void addFormField(Swift::FormField::ref field);
 		const std::string &getId() {
 			return m_id;
+		}

include/transport/adhoccommandfactory.h

➞

Show inline comments

@@ @@ -3,49 +3,48 @@ @@
+ *
  * 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;
+		}

include/transport/adhocmanager.h

➞

Show inline comments

@@ @@ -2,49 +2,52 @@ @@
  * 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 "Swiften/Queries/Responder.h"
 #include "Swiften/Elements/Command.h"
 #include "Swiften/Network/Timer.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();

include/transport/admininterface.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 <string>
 #include <map>
 #include "Swiften/Swiften.h"
 #include "Swiften/Elements/Message.h"
 namespace Transport {
 class Component;
 class StorageBackend;
 class UserManager;
 class NetworkPluginServer;
 class UserRegistration;
 class AdminInterface {
 	public:
 		AdminInterface(Component *component, UserManager *userManager, NetworkPluginServer *server = NULL, StorageBackend *storageBackend = NULL, UserRegistration *userRegistration = NULL);
 		~AdminInterface();
 		void handleQuery(Swift::Message::ref message);
 	private:
 		void handleMessageReceived(Swift::Message::ref message);
 		Component *m_component;
 		StorageBackend *m_storageBackend;
 		UserManager *m_userManager;
 		NetworkPluginServer *m_server;

include/transport/buddy.h

➞

Show inline comments

@@ @@ -2,50 +2,50 @@ @@
  * 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 "transport/transport.h"
 #include "Swiften/Elements/VCard.h"
 #include "Swiften/Swiften.h"
 namespace Transport {
 class RosterManager;
 typedef enum { 	BUDDY_NO_FLAG = 0,
 				BUDDY_JID_ESCAPING = 2,
 				BUDDY_IGNORE = 4,
 				BUDDY_BLOCKED = 8,
 			} BuddyFlag;
 /// Represents one legacy network Buddy.
 class Buddy {
 	public:
 		typedef enum { 	Ask,
 						Both,
 					} Subscription;
 		/// Constructor.
 		/// \param rosterManager RosterManager associated with this buddy.
 		/// \param id ID which identifies the buddy in database or -1 if it's new buddy which is
 		/// not in database yet.
 		Buddy(RosterManager *rosterManager, long id = -1, BuddyFlag flags = BUDDY_NO_FLAG);

include/transport/conversation.h

➞

Show inline comments

@@ @@ -3,96 +3,102 @@ @@
+ *
  * 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 "transport/transport.h"
 #include "Swiften/Swiften.h"
 #include "Swiften/Elements/Message.h"
 namespace Transport {
 class ConversationManager;
 /// Represents one XMPP-Legacy network conversation.
 class Conversation {
 	public:
 		typedef enum {
 			PARTICIPANT_FLAG_NONE = 0,
 			PARTICIPANT_FLAG_MODERATOR = 1,
 			PARTICIPANT_FLAG_CONFLICT = 2,
 			PARTICIPANT_FLAG_BANNED = 4,
 			PARTICIPANT_FLAG_NOT_AUTHORIZED = 8,
 			PARTICIPANT_FLAG_ME = 16,
 			PARTICIPANT_FLAG_KICKED = 32
 		} ParticipantFlag;
 		typedef struct _Participant {
-			int flag;
+			ParticipantFlag flag;
 			int status;
 			std::string statusMessage;
 		} Participant;
 		/// Type of participants in MUC rooms.
 		enum ParticipantFlag {None, Moderator};
 		/// Creates new conversation.
 		/// \param conversationManager ConversationManager associated with this Conversation.
 		/// \param legacyName Legacy network name of recipient.
 		/// \param muc True if this conversation is Multi-user chat.
 		Conversation(ConversationManager *conversationManager, const std::string &legacyName, bool muc = false);
 		/// Destructor.
 		virtual ~Conversation();
 		/// Returns legacy network name of this conversation.
 		/// \return legacy network name of this conversation.
 		const std::string &getLegacyName() { return m_legacyName; }
 		/// Handles new message from Legacy network and forwards it to XMPP.
 		/// \param message Message received from legacy network.
 		/// \param nickname For MUC conversation this is nickname of room participant who sent this message.
 		void handleMessage(boost::shared_ptr<Swift::Message> &message, const std::string &nickname = "");
 		/// Handles participant change in MUC.
 		/// \param nickname Nickname of participant which changed.
 		/// \param flag ParticipantFlag.
 		/// \param status Current status of this participant.
 		/// \param statusMessage Current status message of this participant.
 		/// \param newname If participant was renamed, this variable contains his new name.
-		void handleParticipantChanged(const std::string &nickname, int flag, int status = Swift::StatusShow::None, const std::string &statusMessage = "", const std::string &newname = "");
+		void handleParticipantChanged(const std::string &nickname, ParticipantFlag flag, int status = Swift::StatusShow::None, const std::string &statusMessage = "", const std::string &newname = "");
 		/// Sets XMPP user nickname in MUC rooms.
 		/// \param nickname XMPP user nickname in MUC rooms.
 		void setNickname(const std::string &nickname) {
 			m_nickname = nickname;
+		}
 		const std::string &getNickname() {
 			return m_nickname;
+		}
 		void setJID(const Swift::JID &jid) {
 			m_jid = jid;
+		}
 		void addJID(const Swift::JID &jid) {
 			m_jids.push_back(jid);
+		}
 		void clearJIDs() {
 			m_jids.clear();
+		}

include/transport/conversationmanager.h

➞

Show inline comments

@@ @@ -2,49 +2,50 @@ @@
  * 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 "Swiften/Elements/Message.h"
 namespace Transport {
 class Conversation;
 class User;
 class Component;
 /// Manages all Conversations of particular User.
 class ConversationManager {
 	public:
 		/// Creates new ConversationManager.
 		/// \param user User associated with this ConversationManager.
 		/// \param component Transport instance associated with this ConversationManager.
 		ConversationManager(User *user, Component *component);
 		/// Destructor.
 		virtual ~ConversationManager();
 		/// Returns user associated with this manager.
 		/// \return User
 		User *getUser() { return m_user; }

include/transport/discoitemsresponder.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/GetResponder.h"
 #include "Swiften/Elements/DiscoItems.h"
 #include "Swiften/Elements/CapsInfo.h"
 namespace Transport {
 class Component;
 class DiscoInfoResponder;
 class DiscoItemsResponder : public Swift::GetResponder<Swift::DiscoItems> {
 	public:
 		DiscoItemsResponder(Component *component);
 		~DiscoItemsResponder();
 		Swift::CapsInfo &getBuddyCapsInfo();
 		void addAdHocCommand(const std::string &node, const std::string &name);
 // 		void removeAdHocCommand(const std::string &node);
 		void addRoom(const std::string &node, const std::string &name);
 		void clearRooms();
 	private:
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::DiscoItems> payload);
 	private:

include/transport/factory.h

➞

Show inline comments

@@ @@ -3,46 +3,45 @@ @@
+ *
  * 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 "transport/transport.h"
 #include "Swiften/Swiften.h"
 #include "Swiften/Elements/Message.h"
 #include "transport/conversation.h"
 #include "transport/buddy.h"
 #include "transport/storagebackend.h"
 namespace Transport {
 class Conversation;
 class Buddy;
 class ConversationManager;
 class RosterManager;
 class Factory {
 	public:
 		virtual Conversation *createConversation(ConversationManager *conversationManager, const std::string &legacyName, bool isMuc = false) = 0;
 		virtual Buddy *createBuddy(RosterManager *rosterManager, const BuddyInfo &buddyInfo) = 0;
 };
+}

include/transport/gatewayresponder.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/Responder.h"
 #include "Swiften/Elements/GatewayPayload.h"
 namespace Transport {
 class UserManager;
 class GatewayResponder : public Swift::Responder<Swift::GatewayPayload> {
 	public:
 		GatewayResponder(Swift::IQRouter *router, UserManager *userManager);
 		~GatewayResponder();
 	private:
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::GatewayPayload> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::GatewayPayload> payload);
 		UserManager *m_userManager;
 };
+}

include/transport/memoryreadbytestream.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 <string>
 #include <map>
 #include "Swiften/Swiften.h"
 #include "Swiften/FileTransfer/ReadBytestream.h"
 namespace Transport {
 class MemoryReadBytestream : public Swift::ReadBytestream {
 	public:
 		MemoryReadBytestream(unsigned long size);
 		virtual ~MemoryReadBytestream();
 		unsigned long appendData(const std::string &data);
 		virtual boost::shared_ptr<std::vector<unsigned char> > read(size_t size);
 		void setFinished() { m_finished = true; }
 		bool isFinished() const;
 		boost::signal<void ()> onDataNeeded;
 	private:
 		bool m_finished;
 		std::string m_data;
 		bool neededData;
 		unsigned long m_sent;
 		unsigned long m_size;
 };

include/transport/mysqlbackend.h

➞

Show inline comments

@@ @@ -3,49 +3,48 @@ @@
+ *
  * 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
 #ifdef WITH_MYSQL
 #include <string>
 #include <map>
 #include "Swiften/Swiften.h"
 #include "transport/storagebackend.h"
 #include "transport/config.h"
 #include "mysql.h"
 namespace Transport {
 /// Used to store transport data into SQLite3 database.
 class MySQLBackend : public StorageBackend
+{
 	public:
 		/// Creates new MySQLBackend instance.
 		/// \param config cofiguration, this class uses following Config values:
 		/// 	- database.database - path to SQLite3 database file, database file is created automatically
 		/// 	- service.prefix - prefix for tables created by createDatabase method
 		MySQLBackend(Config *config);
 		/// Destructor.
 		~MySQLBackend();
 		/// Connects to the database and creates it if it's needed. This method call createDatabase() function
 		/// automatically.
 		/// \return true if database is opened successfully.
 		bool connect();
 		void disconnect();

include/transport/networkplugin.h

➞

Show inline comments

@@ @@ -18,58 +18,60 @@ @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <time.h>
 #include "transport/protocol.pb.h"
 // #include "conversation.h"
 #include <iostream>
 #include <list>
 namespace Transport {
 /// Represents Spectrum2 legacy network plugin.
 /// This class is base class for all C++ legacy network plugins. It provides a way to connect
 /// Spectrum2 NetworkPluginServer and allows to use high-level API for legacy network plugins
 /// development.
 class NetworkPlugin {
 	public:
 		enum ExitCode { StorageBackendNeeded = -2 };
 		class PluginConfig {
 			public:
 				PluginConfig() : m_needPassword(true), m_needRegistration(false) {}
+				PluginConfig() : m_needPassword(true), m_needRegistration(false), m_supportMUC(false) {}
 				virtual ~PluginConfig() {}
 				void setNeedRegistration(bool needRegistration = false) { m_needRegistration = needRegistration; }
 				void setNeedPassword(bool needPassword = true) { m_needPassword = needPassword; }
 				void setSupportMUC(bool supportMUC = true) { m_supportMUC = supportMUC; }
 				void setExtraFields(const std::vector<std::string> &fields) { m_extraFields = fields; }
 			private:
 				bool m_needPassword;
 				bool m_needRegistration;
 				bool m_supportMUC;
 				std::vector<std::string> m_extraFields;
 				friend class NetworkPlugin;
 		};
 		/// Creates new NetworkPlugin and connects the Spectrum2 NetworkPluginServer.
 		/// \param loop Event loop.
 		/// \param host Host where Spectrum2 NetworkPluginServer runs.
 		/// \param port Port.
 		NetworkPlugin();
 		/// Destructor.
 		virtual ~NetworkPlugin();
 		void sendConfig(const PluginConfig &cfg);
 		/// Call this function when legacy network buddy changed.
 		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")
 		/// \param buddyName Name of legacy network buddy. (eg. "user2@gmail.com")
 		/// \param alias Alias of legacy network buddy. If empty, then it's not changed on XMPP side.
 		/// \param groups Groups in which buddy currently is. If empty, then it's not changed on XMPP side.
 		/// \param status Status of this buddy.
 		/// \param statusMessage Status message of this buddy.
 		/// \param iconHash MD5 hash of buddy icon. Empty if none buddy icon.
@@ @@ -90,49 +92,49 @@ class NetworkPlugin { @@
 		/// \param room Room in which participant changed. (eg. #spectrum)
 		/// \param flags Participant flags.
 		/// \param status Current status of participant. Swift::StatusShow::None if participant left the room.
 		/// \param statusMessage Current status message of participant.
 		/// \param newname New name of participant if he changed the nickname. Otherwise empty.
 		void handleParticipantChanged(const std::string &user, const std::string &nickname, const std::string &room, int flags,
 			pbnetwork::StatusType = pbnetwork::STATUS_NONE, const std::string &statusMessage = "", const std::string &newname = "");
 		/// Call this function when user disconnected the legacy network because of some legacy network error.
 		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")
 		/// \param error Reserved for future use, currently keep it on 0.
 		/// \param message XMPP message which is sent to XMPP user.
 		void handleDisconnected(const std::string &user, int error = 0, const std::string &message = "");
 		/// Call this function when user connected the legacy network and is logged in.
 		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")
 		void handleConnected(const std::string &user);
 		/// Call this function when new message is received from legacy network for user.
 		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")
 		/// \param legacyName Name of legacy network buddy or name of room. (eg. "user2@gmail.com")
 		/// \param message Plain text message.
 		/// \param nickname Nickname of buddy in room. Empty if it's normal chat message.
 		/// \param xhtml XHTML message.
 		void handleMessage(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &nickname = "", const std::string &xhtml = "", const std::string &timestamp = "", bool headline = false);
+		void handleMessage(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &nickname = "", const std::string &xhtml = "", const std::string &timestamp = "", bool headline = false, bool pm = false);
 		void handleMessageAck(const std::string &user, const std::string &legacyName, const std::string &id);
 		/// Call this function when subject in room changed.
 		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")
 		/// \param legacyName Name of room. (eg. "#spectrum")
 		/// \param message Subject message.
 		/// \param nickname Nickname of user who changed subject.
 		void handleSubject(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &nickname = "");
 		/// Call this function XMPP user's nickname changed.
 		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")
 		/// \param room Room in which participant changed. (eg. #spectrum)
 		/// \param nickname New nickname.
 		void handleRoomNicknameChanged(const std::string &user, const std::string &room, const std::string &nickname);
 		/// Call this function when requested VCard arrived.
 		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")
 		/// \param id VCard ID.
 		/// \param legacyName Name of legacy network buddy. (eg. "user2@gmail.com")
 		/// \param fullName Name of legacy network buddy. (eg. "Monty Python")
 		/// \param nickname Nickname.
 		/// \param photo Raw photo.
 		void handleVCard(const std::string &user, unsigned int id, const std::string &legacyName, const std::string &fullName, const std::string &nickname, const std::string &photo);

include/transport/networkpluginserver.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/Presence/PresenceOracle.h"
 #include "Swiften/Disco/EntityCapsManager.h"
 #include "Swiften/Network/BoostConnectionServer.h"
 #include "Swiften/Network/Connection.h"
 #include "Swiften/Elements/ChatState.h"
 #include "Swiften/Elements/RosterItemPayload.h"
 #include "Swiften/Elements/VCard.h"
 #include "storagebackend.h"
 #include "transport/filetransfermanager.h"
 namespace Transport {
 class UserManager;
 class User;
 class Component;
 class Buddy;
 class LocalBuddy;
 class Config;
 class NetworkConversation;
 class VCardResponder;
 class RosterResponder;
 class BlockResponder;
 class DummyReadBytestream;
 class AdminInterface;
 class DiscoItemsResponder;
 class NetworkPluginServer {
 	public:
 		struct Backend {
 			int pongReceived;
 			std::list<User *> users;
@@ @@ -104,48 +106,50 @@ class NetworkPluginServer { @@
 		void handleParticipantChangedPayload(const std::string &payload);
 		void handleRoomChangedPayload(const std::string &payload);
 		void handleVCardPayload(const std::string &payload);
 		void handleChatStatePayload(const std::string &payload, Swift::ChatState::ChatStateType type);
 		void handleAuthorizationPayload(const std::string &payload);
 		void handleAttentionPayload(const std::string &payload);
 		void handleStatsPayload(Backend *c, const std::string &payload);
 		void handleFTStartPayload(const std::string &payload);
 		void handleFTFinishPayload(const std::string &payload);
 		void handleFTDataPayload(Backend *b, const std::string &payload);
 		void handleQueryPayload(Backend *b, const std::string &payload);
 		void handleBackendConfigPayload(const std::string &payload);
 		void handleRoomListPayload(const std::string &payload);
 		void handleUserCreated(User *user);
 		void handleRoomJoined(User *user, const Swift::JID &who, const std::string &room, const std::string &nickname, const std::string &password);
 		void handleRoomLeft(User *user, const std::string &room);
 		void handleUserReadyToConnect(User *user);
 		void handleUserPresenceChanged(User *user, Swift::Presence::ref presence);
 		void handleUserDestroyed(User *user);
 		void handleBuddyUpdated(Buddy *buddy, const Swift::RosterItemPayload &item);
 		void handleBuddyRemoved(Buddy *buddy);
 		void handleBuddyAdded(Buddy *buddy, const Swift::RosterItemPayload &item);
 		void handleUserBuddyAdded(User *user, Buddy *buddy);
 		void handleUserBuddyRemoved(User *user, Buddy *buddy);
 		void handleBlockToggled(Buddy *buddy);
 		void handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> vcard);
 		void handleVCardRequired(User *user, const std::string &name, unsigned int id);
 		void handleFTStateChanged(Swift::FileTransfer::State state, const std::string &userName, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long id);
 		void handleFTAccepted(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID);
 		void handleFTRejected(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size);
 		void handleFTDataNeeded(Backend *b, unsigned long ftid);
 		void handlePIDTerminated(unsigned long pid);
 	private:
 		void send(boost::shared_ptr<Swift::Connection> &, const std::string &data);
 		void pingTimeout();
 		void sendPing(Backend *c);
 		Backend *getFreeClient(bool acceptUsers = true, bool longRun = false, bool check = false);
 		void connectWaitingUsers();
 		void loginDelayFinished();
 		UserManager *m_userManager;
 		VCardResponder *m_vcardResponder;
 		RosterResponder *m_rosterResponder;

include/transport/pqxxbackend.h

➞

Show inline comments

@@ @@ -3,49 +3,48 @@ @@
+ *
  * 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
 #ifdef WITH_PQXX
 #include <string>
 #include <map>
 #include "Swiften/Swiften.h"
 #include "transport/storagebackend.h"
 #include "transport/config.h"
 #include <pqxx/pqxx>
 namespace Transport {
 /// Used to store transport data into SQLite3 database.
 class PQXXBackend : public StorageBackend
+{
 	public:
 		/// Creates new PQXXBackend instance.
 		/// \param config cofiguration, this class uses following Config values:
 		/// 	- database.database - path to SQLite3 database file, database file is created automatically
 		/// 	- service.prefix - prefix for tables created by createDatabase method
 		PQXXBackend(Config *config);
 		/// Destructor.
 		~PQXXBackend();
 		/// Connects to the database and creates it if it's needed. This method call createDatabase() function
 		/// automatically.
 		/// \return true if database is opened successfully.
 		bool connect();
 		void disconnect();

include/transport/protocol.proto

➞

Show inline comments

@@ @@ -51,62 +51,73 @@ 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;
 	optional string id = 8;
 	optional bool pm = 9;
+}
 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;
+}
 enum ParticipantFlag {
 	PARTICIPANT_FLAG_NONE = 0;
 	PARTICIPANT_FLAG_MODERATOR = 1;
 	PARTICIPANT_FLAG_CONFLICT = 2;
 	PARTICIPANT_FLAG_BANNED = 4;
 	PARTICIPANT_FLAG_NOT_AUTHORIZED = 8;
 	PARTICIPANT_FLAG_ME = 16;
 	PARTICIPANT_FLAG_KICKED = 32;
+}
 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;
+}

include/transport/rostermanager.h

➞

Show inline comments

@@ @@ -4,50 +4,54 @@ @@
  * 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 <boost/pool/pool_alloc.hpp>
 #include <boost/pool/object_pool.hpp>
 #include "Swiften/Swiften.h"
 // #include "rosterstorage.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/Queries/GenericRequest.h"
 #include "Swiften/Roster/SetRosterRequest.h"
 #include "Swiften/Elements/Presence.h"
 #include "Swiften/Network/Timer.h"
 namespace Transport {
 class Buddy;
 class User;
 class Component;
 class StorageBackend;
 class RosterStorage;
 // TODO: Once Swiften GetRosterRequest will support setting to="", this can be removed
 class AddressedRosterRequest : public Swift::GenericRequest<Swift::RosterPayload> {
 	public:
 		typedef boost::shared_ptr<AddressedRosterRequest> ref;
 		AddressedRosterRequest(Swift::IQRouter* router, Swift::JID to) :
 				Swift::GenericRequest<Swift::RosterPayload>(Swift::IQ::Get, to, boost::shared_ptr<Swift::Payload>(new Swift::RosterPayload()), router) {
+		}
 };
 /// Manages roster of one XMPP user.
 class RosterManager {
 	public:
 		typedef std::map<std::string, Buddy *, std::less<std::string>, boost::pool_allocator< std::pair<std::string, Buddy *> > > BuddiesMap;
 		/// Creates new RosterManager.

include/transport/rosterresponder.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/Responder.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include <boost/signal.hpp>
 namespace Transport {
 class UserManager;
 class Buddy;
 class RosterResponder : public Swift::Responder<Swift::RosterPayload> {
 	public:
 		RosterResponder(Swift::IQRouter *router, UserManager *userManager);
 		~RosterResponder();
 		boost::signal<void (Buddy *, const Swift::RosterItemPayload &item)> onBuddyUpdated;
 		boost::signal<void (Buddy *)> onBuddyRemoved;
 		boost::signal<void (Buddy *, const Swift::RosterItemPayload &item)> onBuddyAdded;
 	private:
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload);
 		UserManager *m_userManager;
 };
+}

include/transport/rosterstorage.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 "Swiften/Swiften.h"
 #include <map>
 #include "Swiften/Network/Timer.h"
 namespace Transport {
 class User;
 class StorageBackend;
 class Buddy;
 // Stores buddies into DB Backend.
 class RosterStorage {
 	public:
 		RosterStorage(User *user, StorageBackend *storageBackend);
 		virtual ~RosterStorage();
 		// Add buddy to store queue and store it in future. Nothing
 		// will happen if buddy is already added.
 		void storeBuddy(Buddy *buddy);
 		void removeBuddy(Buddy *buddy);
 		// Store all buddies from queue immediately. Returns true
 		// if some buddies were stored.
 		bool storeBuddies();
 		// Remove buddy from storage queue.

include/transport/settingsadhoccommand.h

➞

Show inline comments

@@ @@ -2,49 +2,48 @@ @@
  * 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);

include/transport/sqlite3backend.h

➞

Show inline comments

@@ @@ -3,49 +3,48 @@ @@
+ *
  * 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
 #ifdef WITH_SQLITE
 #include <string>
 #include <map>
 #include "Swiften/Swiften.h"
 #include "transport/storagebackend.h"
 #include "transport/config.h"
 #include "sqlite3.h"
 namespace Transport {
 /// Used to store transport data into SQLite3 database.
 class SQLite3Backend : public StorageBackend
+{
 	public:
 		/// Creates new SQLite3Backend instance.
 		/// \param config cofiguration, this class uses following Config values:
 		/// 	- database.database - path to SQLite3 database file, database file is created automatically
 		/// 	- service.prefix - prefix for tables created by createDatabase method
 		SQLite3Backend(Config *config);
 		/// Destructor.
 		~SQLite3Backend();
 		/// Connects to the database and creates it if it's needed. This method call createDatabase() function
 		/// automatically.
 		/// \return true if database is opened successfully.
 		bool connect();

include/transport/statsresponder.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 "Swiften/Elements/StatsPayload.h"
 namespace Transport {
 class Component;
 class UserManager;
 class NetworkPluginServer;
 class StorageBackend;
 class StatsResponder : public Swift::Responder<Swift::StatsPayload> {
 	public:
 		StatsResponder(Component *component, UserManager *userManager, NetworkPluginServer *server, StorageBackend *storageBackend);
 		~StatsResponder();
 	private:
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::StatsPayload> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::StatsPayload> payload);
 		unsigned long usedMemory();
 		Component *m_component;
 		UserManager *m_userManager;
 		NetworkPluginServer *m_server;

include/transport/threadpool.h

➞

Show inline comments

 #ifndef THREAD_POOL
 #define THREAD_POOL
 #include <boost/thread.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/signals2/signal.hpp>
 #include <queue>
 #include <iostream>
 #include "transport/logging.h"
-#include "Swiften/Swiften.h"
+#include "Swiften/EventLoop/EventLoop.h"
 /*
  * Thread serves as a base class for any code that has to be excuted as a thread
  * by the ThreadPool class. The run method defines the code that has to be run
  * as a theard. For example, code in run could be sendinga request to a server
  * waiting for the response and storing the response. When the thread finishes
  * execution, the ThreadPool invokes finalize where one could have the code necessary
  * to collect all the responses and release any resources.
+ *
  * NOTE: The object of the Thread class must be valid (in scope) throughout the
  * execution of the thread.
  */
 class Thread
+{
 	int threadID;
 	public:
 	Thread() {}
 	virtual ~Thread() {}
 	virtual void run() = 0;
 	virtual void finalize() {}

include/transport/transport.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/Server/Server.h"
 #include "Swiften/Disco/GetDiscoInfoRequest.h"
 #include "Swiften/Disco/EntityCapsManager.h"
 #include "Swiften/Disco/CapsManager.h"
 #include "Swiften/Disco/CapsMemoryStorage.h"
 #include "Swiften/Network/BoostTimerFactory.h"
 #include "Swiften/Network/BoostIOServiceThread.h"
 #include "Swiften/Server/UserRegistry.h"
 #include "Swiften/Base/SafeByteArray.h"
 #include "Swiften/Jingle/JingleSessionManager.h"
 #include "Swiften/Component/ComponentError.h"
 #include "Swiften/Component/Component.h"
 #include <boost/bind.hpp>
 #include "transport/config.h"
 #include "transport/factory.h"
 #include "transport/presenceoracle.h"
 #include <Swiften/Network/BoostConnectionServer.h>
 namespace Transport {
 	// typedef enum { 	CLIENT_FEATURE_ROSTERX = 2,
 	// 				CLIENT_FEATURE_XHTML_IM = 4,
 	// 				CLIENT_FEATURE_FILETRANSFER = 8,
 	// 				CLIENT_FEATURE_CHATSTATES = 16
 	// 				} SpectrumImportantFeatures;
 	//
 	class StorageBackend;
 	class Factory;
 	class UserRegistry;
 	/// Represents one transport instance.
 	/// It's used to connect the Jabber server and provides transaction layer
 	/// between Jabber server and other classes.
 	///
 	/// In server mode it represents Jabber server to which users can connect and use
 	/// it as transport.
 	class Component {
 		public:
 			/// Creates new Component instance.
 			/// \param loop Main event loop.
 			/// \param config Cofiguration; this class uses following Config values:
 			/// 	- service.jid
 			/// 	- service.password
 			/// 	- service.server
 			/// 	- service.port
 			/// 	- service.server_mode
 			/// \param factories Swift::NetworkFactories.
 			/// \param factory Transport Abstract factory used to create basic transport structures.
 			/// \param userRegistery UserRegistry class instance. It's needed only when running transport in server-mode.
 			Component(Swift::EventLoop *loop, Swift::NetworkFactories *factories, Config *config, Factory *factory, Transport::UserRegistry *userRegistry = NULL);
 			/// Component destructor.
 			~Component();
 			/// Returns Swift::StanzaChannel associated with this Transport::Component.
 			/// It can be used to send presences and other stanzas.
 			/// \return Swift::StanzaChannel associated with this Transport::Component.
 			Swift::StanzaChannel *getStanzaChannel();
 			/// Returns Swift::IQRouter associated with this Component.
 			/// \return Swift::IQRouter associated with this Component.
 			Swift::IQRouter *getIQRouter() { return m_iqRouter; }
 			/// Returns Swift::PresenceOracle associated with this Transport::Component.
 			/// You can use it to check current resource connected for particular user.
 			/// \return Swift::PresenceOracle associated with this Transport::Component.
 			PresenceOracle *getPresenceOracle();
 			/// Returns True if the component is in server mode.
 			/// \return True if the component is in server mode.
 			bool inServerMode() { return m_server != NULL; }
-			/// Connects the Jabber server.
+			/// Starts the Component.
 			/// In server-mode, it starts listening on particular port for new client connections.
 			/// In gateway-mode, it connects the XMPP server.
 			void start();
 			/// Stops the component.
 			void stop();
 			/// Returns Jabber ID of this transport.
 			/// \return Jabber ID of this transport
 			Swift::JID &getJID() { return m_jid; }
 			/// Returns Swift::NetworkFactories which can be used to create new connections.
 			/// \return Swift::NetworkFactories which can be used to create new connections.
 			Swift::NetworkFactories *getNetworkFactories() { return m_factories; }
 			/// Returns Transport Factory used to create basic Transport components.
 			/// \return Transport Factory used to create basic Transport components.
 			Factory *getFactory() { return m_factory; }
 			/// This signal is emitted when server disconnects the transport because of some error.
 			/// \param error disconnection error
 			boost::signal<void (const Swift::ComponentError &error)> onConnectionError;
 			/// This signal is emitted when transport successfully connects the server.
 			boost::signal<void ()> onConnected;
 			/// This signal is emitted when XML stanza is sent to server.
 			/// \param xml xml stanza
 			boost::signal<void (const std::string &xml)> onXMLOut;
 			/// This signal is emitted when XML stanza is received from server.
 			/// \param xml xml stanza
 			boost::signal<void (const std::string &xml)> onXMLIn;
 			Config *getConfig() { return m_config; }
 			/// This signal is emitted when presence from XMPP user is received.
 			/// It's emitted only for presences addressed to transport itself
 			/// (for example to="j2j.domain.tld").
 			/// \param presence presence data
 			/// (for example to="j2j.domain.tld") and for presences comming to
 			/// MUC (for example to="#chat%irc.freenode.org@irc.domain.tld")
 			/// \param presence Presence.
 			boost::signal<void (Swift::Presence::ref presence)> onUserPresenceReceived;
 			/// Component class asks the XMPP clients automatically for their capabilities.
 			/// This signal is emitted when capabilities have been received or changed.
 			/// \param jid JID of the client for which we received capabilities
 			/// \param info disco#info with response.
 			boost::signal<void (const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info)> onUserDiscoInfoReceived;
 // 			boost::signal<void (boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid)> onDiscoInfoResponse;
 		private:
 			void handleConnected();
 			void handleConnectionError(const Swift::ComponentError &error);
 			void handleServerStopped(boost::optional<Swift::BoostConnectionServer::Error> e);
 			void handlePresence(Swift::Presence::ref presence);
 			void handleDataRead(const Swift::SafeByteArray &data);
 			void handleDataWritten(const Swift::SafeByteArray &data);
 			void handleDiscoInfoResponse(boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid);
 			void handleCapsChanged(const Swift::JID& jid);
 			Swift::NetworkFactories *m_factories;
 			Swift::Component *m_component;
 			Swift::Server *m_server;
 			Swift::Timer::ref m_reconnectTimer;
 			Swift::EntityCapsManager *m_entityCapsManager;
 			Swift::CapsManager *m_capsManager;
 			Swift::CapsMemoryStorage *m_capsMemoryStorage;
 			PresenceOracle *m_presenceOracle;
 			Swift::StanzaChannel *m_stanzaChannel;
 			Swift::IQRouter *m_iqRouter;
 			Transport::UserRegistry *m_userRegistry;
 			StorageBackend *m_storageBackend;

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"
 #include "Swiften/Network/Timer.h"
 #include "Swiften/Network/Connection.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.

include/transport/usermanager.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 <string>
 #include <map>
 #include "Swiften/Swiften.h"
 #include "transport/userregistry.h"
 #include "Swiften/Elements/Message.h"
 #include "Swiften/Elements/Presence.h"
 #include "Swiften/Disco/EntityCapsProvider.h"
 #include "Swiften/Elements/DiscoInfo.h"
 #include "Swiften/Network/Timer.h"
 namespace Transport {
 class User;
 class Component;
 class StorageBackend;
 class StorageResponder;
 class RosterResponder;
 class DiscoItemsResponder;
 /// Manages online XMPP Users.
 /// This class handles presences and creates User classes when new user connects.
 /// It also removes the User class once the last user's resource disconnected.
 /// Basic user creation process:
 /**
 	\msc
 	Component,UserManager,User,StorageBackend,Slot;
 	---  [ label = "Available presence received"];
 	Component->UserManager [label="handlePresence(...)", URL="\ref UserManager::handlePresence()"];
 	UserManager->StorageBackend [label="getUser(...)", URL="\ref StorageBackend::getUser()"];
 	UserManager->User [label="User::User(...)", URL="\ref User"];
 	UserManager->Slot [label="onUserCreated(...)", URL="\ref UserManager::onUserCreated()"];
@@ @@ -112,43 +116,44 @@ class UserManager : public Swift::EntityCapsProvider { @@
+		}
 		/// Connects user manually.
 		/// \param user JID of user.
 		void connectUser(const Swift::JID &user);
 		/// Disconnects user manually.
 		/// \param user JID of user.
 		void disconnectUser(const Swift::JID &user);
 		void messageToXMPPSent() { m_sentToXMPP++; }
 		void messageToBackendSent() { m_sentToBackend++; }
 		unsigned long getMessagesToXMPP() { return m_sentToXMPP; }
 		unsigned long getMessagesToBackend() { return m_sentToBackend; }
 	private:
 		void handlePresence(Swift::Presence::ref presence);
 		void handleMessageReceived(Swift::Message::ref message);
 		void handleGeneralPresenceReceived(Swift::Presence::ref presence);
 		void handleProbePresence(Swift::Presence::ref presence);
 		void handleErrorPresence(Swift::Presence::ref presence);
 		void handleSubscription(Swift::Presence::ref presence);
 		void handleMUCPresence(Swift::Presence::ref presence);
 		void handleRemoveTimeout(const std::string jid, User *user, bool reconnect);
 		void handleDiscoInfo(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info);
 		void addUser(User *user);
 		long m_onlineBuddies;
 		User *m_cachedUser;
 		std::map<std::string, User *> m_users;
 		Component *m_component;
 		StorageBackend *m_storageBackend;
 		StorageResponder *m_storageResponder;
 		UserRegistry *m_userRegistry;
 		Swift::Timer::ref m_removeTimer;
 		unsigned long m_sentToXMPP;
 		unsigned long m_sentToBackend;
 		DiscoItemsResponder *m_discoItemsResponder;
 		friend class RosterResponder;
 };
+}

include/transport/userregistration.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 "Swiften/Swiften.h"
 #include "Swiften/Queries/Responder.h"
 #include "Swiften/Elements/InBandRegistrationPayload.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include <boost/signal.hpp>
 namespace Transport {
 struct UserInfo;
 class Component;
 class StorageBackend;
 class UserManager;
 class Config;
 /// Allows users to register the transport using service discovery.
 class UserRegistration : public Swift::Responder<Swift::InBandRegistrationPayload> {
 	public:
 		/// Creates new UserRegistration handler.
 		/// \param component Component associated with this class
 		/// \param userManager UserManager associated with this class
 		/// \param storageBackend StorageBackend where the registered users will be stored
 		UserRegistration(Component *component, UserManager *userManager, StorageBackend *storageBackend);
 		/// Destroys UserRegistration.
 		~UserRegistration();
 		/// Registers new user. This function stores user into database and subscribe user to transport.
 		/// \param userInfo UserInfo struct with informations about registered user
 		/// \return false if user is already registered

include/transport/userregistry.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 <string>
 #include <map>
 #include "Swiften/Swiften.h"
 #include "Swiften/Server/UserRegistry.h"
 #include "Swiften/Network/NetworkFactories.h"
 #include "Swiften/Network/Timer.h"
 #include "Swiften/Network/TimerFactory.h"
 #include "transport/config.h"
 namespace Transport {
 /// Validates passwords in Server mode.
 /// Normal login workflow could work like following:
 /**
 	\msc
 	UserManager,UserRegistry,ServerFromClientSession;
 	ServerFromClientSession->UserRegistry [label="isValidUserPassword(...)", URL="\ref UserRegistry::isValidUserPassword()"];
 	UserManager<-UserRegistry [label="onConnectUser(...)", URL="\ref UserRegistry::onConnectUser()"];
 	---  [ label = "UserManager logins user and validates password"];
 	UserManager->UserRegistry [label="onPasswordValid(...)", URL="\ref UserRegistry::onPasswordValid()"];
 	ServerFromClientSession<-UserRegistry [label="handlePasswordValid(...)", URL="\ref ServerFromClientSession::handlePasswordValid()"];
 	\endmsc
 */
 /// User can of course disconnect during login process. In this case, stopLogin() method is called which informs upper layer
 /// that user disconnected:
 /**
 	\msc
 	UserManager,UserRegistry,ServerFromClientSession;
 	ServerFromClientSession->UserRegistry [label="isValidUserPassword(...)", URL="\ref UserRegistry::isValidUserPassword()"];
 	UserManager<-UserRegistry [label="onConnectUser(...)", URL="\ref UserRegistry::onConnectUser()"];

include/transport/usersreconnecter.h

➞

Show inline comments

@@ @@ -2,49 +2,50 @@ @@
  * 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 <vector>
 #include "Swiften/Swiften.h"
 #include "Swiften/Network/Timer.h"
 namespace Transport {
 class StorageBackend;
 class Component;
 /// Tries to reconnect users who have been online before crash/restart.
 class UsersReconnecter {
 	public:
 		/// Creates new UsersReconnecter.
 		/// \param component Transport instance associated with this roster.
 		/// \param storageBackend StorageBackend from which the users will be fetched.
 		UsersReconnecter(Component *component, StorageBackend *storageBackend);
 		/// Destructor.
 		virtual ~UsersReconnecter();
 		void reconnectNextUser();
 	private:
 		void handleConnected();
 		Component *m_component;
 		StorageBackend *m_storageBackend;

include/transport/vcardresponder.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/Responder.h"
 #include "Swiften/Elements/VCard.h"
 #include "Swiften/Network/NetworkFactories.h"
 #include "Swiften/Network/Timer.h"
 #include <boost/signal.hpp>
 namespace Transport {
 class StorageBackend;
 class UserManager;
 class User;
 class VCardResponder : public Swift::Responder<Swift::VCard> {
 	public:
 		VCardResponder(Swift::IQRouter *router, Swift::NetworkFactories *factories, UserManager *userManager);
 		~VCardResponder();
 		void sendVCard(unsigned int id, boost::shared_ptr<Swift::VCard> vcard);
 		boost::signal<void (User *, const std::string &name, unsigned int id)> onVCardRequired;
 		boost::signal<void (User *, boost::shared_ptr<Swift::VCard> vcard)> onVCardUpdated;
 		void collectTimeouted();
 	private:
 		struct VCardData {
 			Swift::JID from;
 			Swift::JID to;
 			std::string id;

plugin/cpp/networkplugin.cpp

➞

Show inline comments

@@ @@ -50,68 +50,72 @@ template <class T> std::string stringOf(T object) { @@
 	return (os.str());
+}
 NetworkPlugin::NetworkPlugin() {
 	m_pingReceived = false;
 	double shared;
 #ifndef WIN32
 	process_mem_usage(shared, m_init_res);
 #endif
+}
 NetworkPlugin::~NetworkPlugin() {
+}
 void NetworkPlugin::sendConfig(const PluginConfig &cfg) {
 	std::string data = "[registration]\n";
 	data += std::string("needPassword=") + (cfg.m_needPassword ? "1" : "0") + "\n";
 	data += std::string("needRegistration=") + (cfg.m_needRegistration ? "1" : "0") + "\n";
 	for (std::vector<std::string>::const_iterator it = cfg.m_extraFields.begin(); it != cfg.m_extraFields.end(); it++) {
 		data += std::string("extraField=") + (*it) + "\n";
+	}
 	data += "[features]\n";
 	data += std::string("muc=") + (cfg.m_supportMUC ? "1" : "0") + "\n";
 	pbnetwork::BackendConfig m;
 	m.set_config(data);
 	std::string message;
 	m.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BACKEND_CONFIG);
 	send(message);
+}
 void NetworkPlugin::handleMessage(const std::string &user, const std::string &legacyName, const std::string &msg, const std::string &nickname, const std::string &xhtml, const std::string &timestamp, bool headline) {
+void NetworkPlugin::handleMessage(const std::string &user, const std::string &legacyName, const std::string &msg, const std::string &nickname, const std::string &xhtml, const std::string &timestamp, bool headline, bool pm) {
 	pbnetwork::ConversationMessage m;
 	m.set_username(user);
 	m.set_buddyname(legacyName);
 	m.set_message(msg);
 	m.set_nickname(nickname);
 	m.set_xhtml(xhtml);
 	m.set_timestamp(timestamp);
 	m.set_headline(headline);
 	m.set_pm(pm);
 	std::string message;
 	m.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE);
 	send(message);
+}
 void NetworkPlugin::handleMessageAck(const std::string &user, const std::string &legacyName, const std::string &id) {
 	pbnetwork::ConversationMessage m;
 	m.set_username(user);
 	m.set_buddyname(legacyName);
 	m.set_message("");
 	m.set_id(id);
 	std::string message;
 	m.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE_ACK);
 	send(message);
+}

spectrum/src/main.cpp

➞

Show inline comments

 #include "transport/config.h"
 #include "transport/transport.h"
 #include "transport/filetransfermanager.h"
 #include "transport/usermanager.h"
 #include "transport/sqlite3backend.h"
 #include "transport/mysqlbackend.h"
 #include "transport/pqxxbackend.h"
 #include "transport/userregistration.h"
 #include "transport/networkpluginserver.h"
 #include "transport/admininterface.h"
 #include "transport/statsresponder.h"
 #include "transport/usersreconnecter.h"
 #include "transport/util.h"
 #include "transport/gatewayresponder.h"
 #include "transport/logging.h"
 #include "transport/discoitemsresponder.h"
 #include "transport/adhocmanager.h"
 #include "transport/settingsadhoccommand.h"
 #include "Swiften/EventLoop/SimpleEventLoop.h"
 #include "Swiften/Network/BoostNetworkFactories.h"
 #include <boost/filesystem.hpp>
 #include <boost/algorithm/string.hpp>
 #ifndef WIN32
 #include "sys/signal.h"
 #include "sys/stat.h"
 #include <pwd.h>
 #include <grp.h>
 #include <sys/resource.h>
 #include "libgen.h"
 #ifndef __FreeBSD__
 #include <malloc.h>
 #endif
 #else
 #include <process.h>
 #define getpid _getpid
 #include "win32/ServiceWrapper.h"
 #endif
 #include <sys/stat.h>
 using namespace Transport;
 using namespace Transport::Util;
 DEFINE_LOGGER(logger, "Spectrum");

spectrum/src/sample.cfg

➞

Show inline comments

 [service]
 jid = localhost
 password = secret
 server = 127.0.0.1
 port = 5222
 server_mode = 1
 backend_host=localhost
 pidfile=./test.pid
 # < this option doesn't work yet
 #backend_port=10001
 #admin_jid=admin@localhost
 admin_password=test
 #cert=server.pfx #patch to PKCS#12 certificate
 #cert_password=test #password to that certificate if any
 users_per_backend=10
 backend=../..//backends/swiften/spectrum2_swiften_backend
+#backend=../..//backends/swiften/spectrum2_swiften_backend
 #backend=../../backends/twitter/spectrum2_twitter_backend
-#backend=/home/hanzz/code/libtransport/backends/libcommuni/spectrum2_libcommuni_backend
 backend=/home/hanzz/code/libtransport/backends/libcommuni/spectrum2_libcommuni_backend
 protocol=prpl-jabber
 #protocol=prpl-msn
 #protocol=any
 #protocol=prpl-icq
 working_dir=./
 portfile=$jid.port
+portfile=./$jid.port
 irc_server=irc.freenode.org
 [backend]
 #default_avatar=catmelonhead.jpg
 #no_vcard_fetch=true
 [logging]
 #config=logging.cfg # log4cxx/log4j logging configuration file
 #backend_config=/home/hanzz/code/libtransport/spectrum/src/backend-logging.cfg # log4cxx/log4j logging configuration file for backends
 [database]
 type=sqlite3 # or "none" without database backend
 database=users.sqlite
 prefix=twitter
 #type = mysql # or "none" without database backend.......................................................................................................................
 #database = test
 #prefix=
 #user=root
 #password=yourrootsqlpassword
 #encryption_key=hanzzik

spectrum/src/sample2.cfg

➞

Show inline comments

@@ @@ -20,49 +20,49 @@ server = 127.0.0.1 @@
 # XMPP server port.
 port = 5222
 # Interface on which Spectrum listens for backends.
 backend_host = localhost
 # Port on which Spectrum listens for backends.
 # By default Spectrum chooses random backend port and there's
 # no need to change it normally
 #backend_port=10001
 # Full path to PKCS#12 cetficiate used for TLS in server mode.
 #cert=
 # Certificate password if any.
 #cert_password=
 # Number of users per one legacy network backend.
 users_per_backend=10
 # Full path to backend binary.
 backend=/usr/bin/spectrum2_libpurple_backend
 #backend=/usr/bin/spectrum2_libcommuni_backend
 # For skype:
-#backend=/usr/bin/xvfb-run -n BACKEND_ID -s "-screen 0 10x10x8" -f /tmp/x-skype-gw /usr/bin/spectrum2_skype_backend
+#backend=/usr/bin/xvfb-run -a -s "-screen 0 10x10x8" -f /tmp/x-skype-gw /usr/bin/spectrum2_skype_backend
 # Libpurple protocol-id for spectrum_libpurple_backend
 protocol=prpl-jabber
 #protocol=prpl-msn
 #protocol=prpl-icq
 # prpl-any means that user sets his protocol in his JID which has to be
 # in following format: protocol.username@domain.tld
 # So for example: prpl-jabber.hanzz.k%gmail.com@domain.tld
 #protocol=prpl-any
 [identity]
 # Name of Spectrum instance in service discovery
 name=Spectrum Jabber Transport
 # Type of transport ("msn", "icq", "xmpp").
 # Check http://xmpp.org/registrar/disco-categories.html#gateway
 type=xmpp
 # Category of transport, default is "gateway
 #category=gateway
 [logging]
 # log4cxx/log4j logging configuration file in ini format used for main spectrum2 instance.

spectrum_manager/src/main.cpp

➞

Show inline comments

@@ @@ -117,48 +117,51 @@ int main(int argc, char **argv) @@
+	}
 	if (!config.load(config_file)) {
 		std::cerr << "Can't load configuration file.\n";
 		return 4;
+	}
 	if (command.empty()) {
 		std::cout << desc << "\n";
 		return 1;
+	}
 	if (command[0] == "start") {
 		return start_instances(&config);
+	}
 	else if (command[0] == "stop") {
 		stop_instances(&config);
+	}
 	else if (command[0] == "status") {
 		return show_status(&config);
+	}
 	else if (command[0] == "list") {
 		std::vector<std::string> list = show_list(&config);
+	}
 	else if (command[0] == "restart") {
 		return restart_instances(&config);
+	}
 	else if (command[0] == "server") {
 		Server server(&config);
 		if (server.start() == false) {
 			std::cerr << "Can't set up server handler.\n";
 			return 1;
+		}
 		while (1) { sleep(10); }
+	}
 	else {
 		if (command.size() < 2) {
 			std::cout << desc << "\n";
 			return 11;
+		}
 		Swift::SimpleEventLoop eventLoop;
 		Swift::BoostNetworkFactories networkFactories(&eventLoop);
 		std::string jid = command[0];
 		command.erase(command.begin());
 		std::string cmd = boost::algorithm::join(command, " ");
 		if (cmd == "start") {
 			return start_instances(&config, jid);
+		}
 		else if (cmd == "stop") {

src/blockresponder.cpp

➞

Show inline comments

@@ @@ -3,49 +3,48 @@ @@
+ *
  * 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 "blockresponder.h"
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "transport/BlockPayload.h"
 #include "Swiften/Swiften.h"
 #include "transport/usermanager.h"
 #include "transport/user.h"
 #include "transport/buddy.h"
 #include "transport/rostermanager.h"
 #include "transport/logging.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "BlockResponder");
 BlockResponder::BlockResponder(Swift::IQRouter *router, UserManager *userManager) : Swift::SetResponder<BlockPayload>(router) {
 	m_userManager = userManager;
+}
 BlockResponder::~BlockResponder() {
+}
 bool BlockResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Transport::BlockPayload> info) {
 	User *user = m_userManager->getUser(from.toBare().toString());
 	if (!user) {

src/blockresponder.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/BlockPayload.h"
 #include <boost/signal.hpp>
 namespace Transport {
 class UserManager;
 class Buddy;
 class BlockResponder : public Swift::SetResponder<Transport::BlockPayload> {
 	public:
 		BlockResponder(Swift::IQRouter *router, UserManager *userManager);
 		~BlockResponder();
 		boost::signal<void (Buddy *)> onBlockToggled;
 	private:
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Transport::BlockPayload> payload);
 		UserManager *m_userManager;
 };
+}

src/buddy.cpp

➞

Show inline comments

@@ @@ -5,48 +5,50 @@ @@
+ *
  * 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/buddy.h"
 #include "transport/rostermanager.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/BlockPayload.h"
 #include "transport/usermanager.h"
 #include "transport/discoitemsresponder.h"
 #include "Swiften/Elements/VCardUpdate.h"
 namespace Transport {
 Buddy::Buddy(RosterManager *rosterManager, long id, BuddyFlag flags) : m_id(id), m_flags(flags), m_rosterManager(rosterManager),
 	m_subscription(Ask) {
 // 	m_rosterManager->setBuddy(this);
+}
 Buddy::~Buddy() {
 // 	m_rosterManager->unsetBuddy(this);
+}
 void Buddy::sendPresence() {
 	Swift::Presence::ref presence = generatePresenceStanza(255);
 	if (presence) {
 		m_rosterManager->getUser()->getComponent()->getStanzaChannel()->sendPresence(presence);
+	}
+}
 void Buddy::generateJID() {
 	m_jid = Swift::JID();
 	m_jid = Swift::JID(getSafeName(), m_rosterManager->getUser()->getComponent()->getJID().toString(), "bot");
+}
 void Buddy::setID(long id) {

src/config.cpp

➞

Show inline comments

 			sectionValues[varItem.first] = varItem.second;
+	}
 	return sectionValues;
+}
 std::string Config::getCommandLineArgs() const {
 	std::ostringstream commandLineArgs;
 	// Return the command-line arguments that were passed to us originally (but remove the initial .exe part)
 	for (int i = 1; i < m_argc; ++i) 	{
 		commandLineArgs << "\"" << m_argv[i] << "\" ";
+	}
 	return commandLineArgs.str();
+}
 void Config::updateBackendConfig(const std::string &backendConfig) {
 	options_description opts("Backend options");
 	opts.add_options()
 		("registration.needPassword", value<bool>()->default_value(true), "")
 		("registration.needRegistration", value<bool>()->default_value(false), "")
 		("registration.extraField", value<std::vector<std::string> >()->multitoken(), "")
 		("features.receipts", value<bool>()->default_value(false), "")
 		("features.muc", value<bool>()->default_value(false), "")
+	;
 	std::stringstream ifs(backendConfig);
 	parsed_options parsed = parse_config_file(ifs, opts, true);
 	store(parsed, m_backendConfig);
 	notify(m_backendConfig);
 	onBackendConfigUpdated();
+}
 Config *Config::createFromArgs(int argc, char **argv, std::string &error, std::string &host, int &port) {
 	std::string jid;
 	std::ostringstream os;
 	std::string configFile;
 	boost::program_options::variables_map vm;
 	boost::program_options::options_description desc("Usage: spectrum <config_file.cfg>\nAllowed options");
 	desc.add_options()
 		("help", "help")
 		("host,h", boost::program_options::value<std::string>(&host)->default_value(""), "Host to connect to")
 		("port,p", boost::program_options::value<int>(&port)->default_value(10000), "Port to connect to")
 		("no-daemonize,n", "Do not run spectrum as daemon")
 		("no-debug,d", "Create coredumps on crash")
 		("jid,j", boost::program_options::value<std::string>(&jid)->default_value(""), "Specify JID of transport manually")

src/conversation.cpp

➞

Show inline comments

@@ @@ -5,48 +5,54 @@ @@
+ *
  * 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"
 #include "Swiften/Elements/MUCItem.h"
 #include "Swiften/Elements/MUCOccupant.h"
 #include "Swiften/Elements/MUCUserPayload.h"
 #include "Swiften/Elements/Delay.h"
 #include "Swiften/Elements/MUCPayload.h"
 namespace Transport {
 Conversation::Conversation(ConversationManager *conversationManager, const std::string &legacyName, bool isMUC) : m_conversationManager(conversationManager) {
 	m_legacyName = legacyName;
 	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;
 			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));
 				std::string legacyName = m_room;
 				if (legacyName.find_last_of("@") != std::string::npos) {
 					legacyName.replace(legacyName.find_last_of("@"), 1, "%"); // OK
+				}
 				message->setFrom(Swift::JID(legacyName, m_conversationManager->getComponent()->getJID().toBare(), n));
+			}
+		}
 		if (m_conversationManager->getComponent()->inServerMode() && m_conversationManager->getUser()->shouldCacheMessages()) {
 			boost::posix_time::ptime timestamp = boost::posix_time::second_clock::universal_time();
 			boost::shared_ptr<Swift::Delay> delay(boost::make_shared<Swift::Delay>());
 			delay->setStamp(timestamp);
 			message->addPayload(delay);
 			m_cachedMessages.push_back(message);
 			if (m_cachedMessages.size() > 100) {
 				m_cachedMessages.pop_front();
+			}
+		}
 		else {
 			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;
 	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) {
 		if (flag & PARTICIPANT_FLAG_CONFLICT) {
 			delete p;
 			presence->setType(Swift::Presence::Error);
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::ErrorPayload(Swift::ErrorPayload::Conflict)));
 			return presence;
+		}
 		else if (flag & PARTICIPANT_FLAG_NOT_AUTHORIZED) {
 			delete p;
 			presence->setType(Swift::Presence::Error);
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::ErrorPayload(Swift::ErrorPayload::NotAuthorized, Swift::ErrorPayload::Auth)));
 			return presence;
+		}
 		else {
 			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) {
+	if (flag & PARTICIPANT_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) {
+void Conversation::handleParticipantChanged(const std::string &nick, Conversation::ParticipantFlag 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);

src/discoinforesponder.cpp

➞

Show inline comments

@@ @@ -5,83 +5,86 @@ @@
+ *
  * 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 "discoinforesponder.h"
 #include <iostream>
 #include <boost/bind.hpp>
 #include <boost/algorithm/string.hpp>
 #include "Swiften/Disco/DiscoInfoResponder.h"
 #include "Swiften/Queries/IQRouter.h"
 #include "Swiften/Elements/DiscoInfo.h"
 #include "Swiften/Swiften.h"
 #include "transport/config.h"
 #include "transport/logging.h"
 #include "Swiften/Disco/CapsInfoGenerator.h"
 using namespace Swift;
 using namespace boost;
 DEFINE_LOGGER(logger, "DiscoInfoResponder");
 namespace Transport {
 DiscoInfoResponder::DiscoInfoResponder(Swift::IQRouter *router, Config *config) : Swift::GetResponder<DiscoInfo>(router) {
 	m_config = config;
-	m_config->onBackendConfigUpdated.connect(boost::bind(&DiscoInfoResponder::updateBuddyFeatures, this));
+	m_config->onBackendConfigUpdated.connect(boost::bind(&DiscoInfoResponder::updateFeatures, this));
 	m_buddyInfo = NULL;
 	m_transportInfo.addIdentity(DiscoInfo::Identity(CONFIG_STRING(m_config, "identity.name"),
 													CONFIG_STRING(m_config, "identity.category"),
 													CONFIG_STRING(m_config, "identity.type")));
 	std::list<std::string> features;
 	features.push_back("jabber:iq:register");
 	features.push_back("jabber:iq:gateway");
 	features.push_back("jabber:iq:private");
 	features.push_back("http://jabber.org/protocol/disco#info");
 	features.push_back("http://jabber.org/protocol/commands");
 	setTransportFeatures(features);
 	updateBuddyFeatures();
 	updateFeatures();
+}
 DiscoInfoResponder::~DiscoInfoResponder() {
 	delete m_buddyInfo;
+}
 void DiscoInfoResponder::updateBuddyFeatures() {
 void DiscoInfoResponder::updateFeatures() {
 	std::list<std::string> features2;
 	features2.push_back("jabber:iq:register");
 	features2.push_back("jabber:iq:gateway");
 	features2.push_back("jabber:iq:private");
 	features2.push_back("http://jabber.org/protocol/disco#info");
 	features2.push_back("http://jabber.org/protocol/commands");
 	if (CONFIG_BOOL_DEFAULTED(m_config, "features.muc", false)) {
 		features2.push_back("http://jabber.org/protocol/muc");
+	}
 	setTransportFeatures(features2);
 	std::list<std::string> features;
 	features.push_back("http://jabber.org/protocol/disco#items");
 	features.push_back("http://jabber.org/protocol/disco#info");
 	features.push_back("http://jabber.org/protocol/chatstates");
 	features.push_back("http://jabber.org/protocol/xhtml-im");
 	if (CONFIG_BOOL_DEFAULTED(m_config, "features.receipts", false)) {
 		features.push_back("urn:xmpp:receipts");
+	}
 	setBuddyFeatures(features);
+}
 void DiscoInfoResponder::setTransportFeatures(std::list<std::string> &features) {
 	for (std::list<std::string>::iterator it = features.begin(); it != features.end(); it++) {
 		if (!m_transportInfo.hasFeature(*it)) {
 			m_transportInfo.addFeature(*it);
+		}
+	}
+}
 void DiscoInfoResponder::setBuddyFeatures(std::list<std::string> &f) {
 	delete m_buddyInfo;
 	m_buddyInfo = new Swift::DiscoInfo;
 	m_buddyInfo->addIdentity(DiscoInfo::Identity(CONFIG_STRING(m_config, "identity.name"), "client", "pc"));

src/discoinforesponder.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 <list>
 #include <boost/signal.hpp>
 #include "Swiften/Queries/GetResponder.h"
 #include "Swiften/Elements/DiscoInfo.h"
 #include "Swiften/Elements/CapsInfo.h"
 namespace Transport {
 class Config;
 class DiscoInfoResponder : public Swift::GetResponder<Swift::DiscoInfo> {
 	public:
 		DiscoInfoResponder(Swift::IQRouter *router, Config *config);
 		~DiscoInfoResponder();
 		void setTransportFeatures(std::list<std::string> &features);
 		void setBuddyFeatures(std::list<std::string> &features);
 		void addRoom(const std::string &jid, const std::string &name);
 		void clearRooms();
 		void addAdHocCommand(const std::string &node, const std::string &name);
 		boost::signal<void (const Swift::CapsInfo &capsInfo)> onBuddyCapsInfoChanged;
 		Swift::CapsInfo &getBuddyCapsInfo() {
 				return m_capsInfo;
+		}
 	private:
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::DiscoInfo> payload);
-		void updateBuddyFeatures();
+		void updateFeatures();
 		Swift::DiscoInfo m_transportInfo;
 		Swift::DiscoInfo *m_buddyInfo;
 		Config *m_config;
 		Swift::CapsInfo m_capsInfo;
 		std::map<std::string, std::string> m_rooms;
 		std::map<std::string, std::string> m_commands;
 };
+}

src/discoitemsresponder.cpp

➞

Show inline comments

@@ @@ -2,49 +2,48 @@ @@
  * 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/discoitemsresponder.h"
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "Swiften/Swiften.h"
 #include "transport/transport.h"
 #include "transport/logging.h"
 #include "discoinforesponder.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "DiscoItemsResponder");
 DiscoItemsResponder::DiscoItemsResponder(Component *component) : Swift::GetResponder<DiscoItems>(component->getIQRouter()) {
 	m_component = component;
 	m_commands = boost::shared_ptr<DiscoItems>(new DiscoItems());
 	m_commands->setNode("http://jabber.org/protocol/commands");
 	m_rooms = boost::shared_ptr<DiscoItems>(new DiscoItems());
 	m_discoInfoResponder = new DiscoInfoResponder(component->getIQRouter(), component->getConfig());
 	m_discoInfoResponder->start();
+}
 DiscoItemsResponder::~DiscoItemsResponder() {
 	delete m_discoInfoResponder;
+}

src/filetransfermanager.cpp

➞

Show inline comments

@@ @@ -3,48 +3,49 @@ @@
+ *
  * 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/filetransfermanager.h"
 #include "transport/transport.h"
 #include "transport/usermanager.h"
 #include "transport/user.h"
 #include "transport/buddy.h"
 #include "transport/logging.h"
 #include "Swiften/Network/ConnectionServerFactory.h"
 namespace Transport {
 DEFINE_LOGGER(logger, "FileTransferManager");
 FileTransferManager::FileTransferManager(Component *component, UserManager *userManager) {
 	m_component = component;
 	m_userManager = userManager;
 	m_jingleSessionManager = new Swift::JingleSessionManager(m_component->getIQRouter());
 	m_connectivityManager = new Swift::ConnectivityManager(m_component->getNetworkFactories()->getNATTraverser());
 	m_bytestreamRegistry = new Swift::SOCKS5BytestreamRegistry();
 	m_bytestreamProxy = new Swift::SOCKS5BytestreamProxy(m_component->getNetworkFactories()->getConnectionFactory(), m_component->getNetworkFactories()->getTimerFactory());
 	m_localCandidateGeneratorFactory = new Swift::DefaultLocalJingleTransportCandidateGeneratorFactory(m_connectivityManager, m_bytestreamRegistry, m_bytestreamProxy, "thishouldnotbeused");
 	m_remoteCandidateSelectorFactory = new Swift::DefaultRemoteJingleTransportCandidateSelectorFactory(m_component->getNetworkFactories()->getConnectionFactory(), m_component->getNetworkFactories()->getTimerFactory());
 	boost::shared_ptr<Swift::ConnectionServer> server = m_component->getNetworkFactories()->getConnectionServerFactory()->createConnectionServer(19645);
 	server->start();
 	m_bytestreamServer = new Swift::SOCKS5BytestreamServer(server, m_bytestreamRegistry);
 	m_bytestreamServer->start();
 	m_outgoingFTManager = new Swift::CombinedOutgoingFileTransferManager(m_jingleSessionManager, m_component->getIQRouter(),
 																	m_userManager, m_remoteCandidateSelectorFactory,

src/gatewayresponder.cpp

➞

Show inline comments

@@ @@ -3,68 +3,74 @@ @@
+ *
  * 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/gatewayresponder.h"
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "Swiften/Elements/RawXMLPayload.h"
 #include "Swiften/Swiften.h"
 #include "transport/usermanager.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/logging.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "GatewayResponder");
 GatewayResponder::GatewayResponder(Swift::IQRouter *router, UserManager *userManager) : Swift::Responder<GatewayPayload>(router) {
 	m_userManager = userManager;
+}
 GatewayResponder::~GatewayResponder() {
+}
 bool GatewayResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::GatewayPayload> payload) {
 	std::string prompt = CONFIG_STRING(m_userManager->getComponent()->getConfig(), "gateway_responder.prompt");
 	std::string label = CONFIG_STRING(m_userManager->getComponent()->getConfig(), "gateway_responder.label");
 	sendResponse(from, id, boost::shared_ptr<GatewayPayload>(new GatewayPayload(Swift::JID(), label, prompt)));
 	return true;
+}
 bool GatewayResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::GatewayPayload> payload) {
 	std::string prompt = payload->getPrompt();
 	std::string escaped = Swift::JID::getEscapedNode(prompt);
 	if (!CONFIG_BOOL_DEFAULTED(m_userManager->getComponent()->getConfig(), "service.jid_escaping", true)) {
 		escaped = prompt;
 		if (escaped.find_last_of("@") != std::string::npos) {
 			escaped.replace(escaped.find_last_of("@"), 1, "%");
+		}
+	}
 	// This code is here to workaround Gajim (and probably other clients bug too) bug
 	// https://trac.gajim.org/ticket/7277
 	if (prompt.find("\\40") != std::string::npos) {
 		LOG4CXX_WARN(logger, from.toString() << " Received already escaped JID " << prompt << ". Not escaping again.");
 		escaped = prompt;
+	}
 	std::string jid = escaped + "@" + m_userManager->getComponent()->getJID().toBare().toString();
 	sendResponse(from, id, boost::shared_ptr<GatewayPayload>(new GatewayPayload(jid)));
 	return true;
+}
+}

src/logging.cpp

➞

Show inline comments

+		}
 		catch (...) {
 			std::cerr << "Can't create FileInputStream logger instance\n";
+		}
 		if (!istream) {
 			return;
+		}
 		p.load(istream);
 		LogString pid, jid, id;
 		log4cxx::helpers::Transcoder::decode(boost::lexical_cast<std::string>(getpid()), pid);
 		log4cxx::helpers::Transcoder::decode(CONFIG_STRING(config, "service.jid"), jid);
 		log4cxx::helpers::Transcoder::decode(CONFIG_STRING_DEFAULTED(config, "service.backend_id", ""), id);
 #ifdef _MSC_VER
 		p.setProperty(L"pid", pid);
 		p.setProperty(L"jid", jid);
 		p.setProperty(L"id", id);
 #else
 		p.setProperty("pid", pid);
 		p.setProperty("jid", jid);
 		p.setProperty("id", id);
 #endif
-		std::string dir;
+		std::vector<std::string> dirs;
 		BOOST_FOREACH(const log4cxx::LogString &prop, p.propertyNames()) {
 // 			if (boost::ends_with(prop, ".File")) {
 			if (boost::ends_with(prop, ".File")) {
 				std::string dir;
 				log4cxx::helpers::Transcoder::encode(p.get(prop), dir);
 				boost::replace_all(dir, "${jid}", jid);
 				boost::replace_all(dir, "${pid}", pid);
 				boost::replace_all(dir, "${id}", id);
 				break;
 // 			}
 				dirs.push_back(dir);
+			}
+		}
 		mode_t old_cmask;
 		if (!dir.empty()) {
 		// create directories
 #ifndef WIN32
 		old_cmask = umask(0007);
 #endif
 		BOOST_FOREACH(std::string &dir, dirs) {
 			if (!dir.empty()) {
 				try {
 					Transport::Util::createDirectories(config, boost::filesystem::path(dir).parent_path());
+				}
 				catch (const boost::filesystem::filesystem_error &e) {
 					std::cerr << "Can't create logging directory directory " << boost::filesystem::path(dir).parent_path().string() << ": " << e.what() << ".\n";
+				}
+			}
+		}
 #ifndef WIN32
 		umask(old_cmask);
 #endif
 		if (only_create_dir) {
 			return;
+		}
 		log4cxx::PropertyConfigurator::configure(p);
 		// Change owner of main log file
 #ifndef WIN32
 	BOOST_FOREACH(std::string &dir, dirs) {
 		if (!CONFIG_STRING(config, "service.group").empty() && !CONFIG_STRING(config, "service.user").empty()) {
 			struct group *gr;
 			if ((gr = getgrnam(CONFIG_STRING(config, "service.group").c_str())) == NULL) {
 				std::cerr << "Invalid service.group name " << CONFIG_STRING(config, "service.group") << "\n";
+			}
 			struct passwd *pw;
 			if ((pw = getpwnam(CONFIG_STRING(config, "service.user").c_str())) == NULL) {
 				std::cerr << "Invalid service.user name " << CONFIG_STRING(config, "service.user") << "\n";
+			}
 			chown(dir.c_str(), pw->pw_uid, gr->gr_gid);
+		}
 #endif
 #ifndef WIN32
 		if (!dir.empty()) {
 			umask(old_cmask);
+	}
 #endif
+	}
+}
 void initBackendLogging(Config *config) {
 	initLogging(config, "logging.backend_config");
 	redirect_stderr();
+}
 void initMainLogging(Config *config) {
 	initLogging(config, "logging.config");
 	initLogging(config, "logging.backend_config", true);
+}
 void redirect_stderr() {
 	 intercepter_cerr = new intercept_stream(std::cerr, "cerr");
 	 intercepter_cout = new intercept_stream(std::cout, "cout");
+}
 void shutdownLogging() {
 	delete intercepter_cerr;
 	delete intercepter_cout;

src/networkpluginserver.cpp

➞

Show inline comments

@@ @@ -13,60 +13,66 @@ @@
  * 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/Network/ConnectionServerFactory.h"
 #include "Swiften/Elements/AttentionPayload.h"
 #include "Swiften/Elements/XHTMLIMPayload.h"
 #include "Swiften/Elements/Delay.h"
 #include "Swiften/Elements/DeliveryReceipt.h"
 #include "Swiften/Elements/DeliveryReceiptRequest.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 "boost/date_time/posix_time/posix_time.hpp"
 #include "boost/signal.hpp"
 #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");
 	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());
+	conv->handleParticipantChanged(payload.nickname(), (Conversation::ParticipantFlag) 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) {
 	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;
+	}
 	if (conv && payload.pm()) {
 		conv = (NetworkConversation *) user->getConversationManager()->getConversation(payload.buddyname() + "/" + payload.nickname());
 		if (!conv) {
 			conv = new NetworkConversation(user->getConversationManager(), payload.nickname());
 			std::string name = payload.buddyname();
 			conv->setRoom(name);
 			conv->setNickname(payload.buddyname() + "/" + payload.nickname());
 			user->getConversationManager()->addConversation(conv);
 			conv->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, this, _1, _2));
+		}
+	}
 	// 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::handleConvMessageAckPayload(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;
 	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));
 	user->getRosterManager()->onBuddyAdded.connect(boost::bind(&NetworkPluginServer::handleUserBuddyAdded, this, user, _1));
 	user->getRosterManager()->onBuddyRemoved.connect(boost::bind(&NetworkPluginServer::handleUserBuddyRemoved, 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)
 	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));
 	user->getRosterManager()->onBuddyAdded.disconnect(boost::bind(&NetworkPluginServer::handleUserBuddyAdded, this, user, _1));
 	user->getRosterManager()->onBuddyRemoved.disconnect(boost::bind(&NetworkPluginServer::handleUserBuddyRemoved, 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;
+	}
+}
 	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::handleUserBuddyAdded(User *user, Buddy *b) {
 	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::handleUserBuddyRemoved(User *user, Buddy *b) {
 	handleBuddyRemoved(b);
+}
 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);
+}

src/presenceoracle.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/presenceoracle.h"
-#include "Swiften/Swiften.h"
+#include "Swiften/Elements/MUCPayload.h"
 #include <boost/bind.hpp>
 using namespace Swift;
 namespace Transport {
 PresenceOracle::PresenceOracle(StanzaChannel* stanzaChannel) {
 	stanzaChannel_ = stanzaChannel;
 	stanzaChannel_->onPresenceReceived.connect(boost::bind(&PresenceOracle::handleIncomingPresence, this, _1));
 	stanzaChannel_->onAvailableChanged.connect(boost::bind(&PresenceOracle::handleStanzaChannelAvailableChanged, this, _1));
+}
 PresenceOracle::~PresenceOracle() {
 	stanzaChannel_->onPresenceReceived.disconnect(boost::bind(&PresenceOracle::handleIncomingPresence, this, _1));
 	stanzaChannel_->onAvailableChanged.disconnect(boost::bind(&PresenceOracle::handleStanzaChannelAvailableChanged, this, _1));
+}
 void PresenceOracle::handleStanzaChannelAvailableChanged(bool available) {
 	if (available) {
 		entries_.clear();
+	}
+}
 void PresenceOracle::clearPresences(const Swift::JID& bareJID) {
 	std::map<JID, boost::shared_ptr<Presence> > jidMap = entries_[bareJID];
 	jidMap.clear();
 	entries_[bareJID] = jidMap;
+}
 void PresenceOracle::handleIncomingPresence(Presence::ref presence) {
 	// ignore presences for some contact, we're checking only presences for the transport itself here.
 	bool isMUC = presence->getPayload<MUCPayload>() != NULL || *presence->getTo().getNode().c_str() == '#';
 	// filter out login/logout presence spam
-	if (!presence->getTo().getNode().empty() && isMUC == false)
 	if (!presence->getTo().getNode().empty())
 		return;
 	JID bareJID(presence->getFrom().toBare());
 	if (presence->getType() == Presence::Subscribe || presence->getType() == Presence::Subscribed) {
+	}
 	else {
 		Presence::ref passedPresence = presence;
 		if (!isMUC) {
 		if (presence->getType() == Presence::Unsubscribe || presence->getType() == Presence::Unsubscribed) {
 			/* 3921bis says that we don't follow up with an unavailable, so simulate this ourselves */
 			passedPresence = Presence::ref(new Presence());
 			passedPresence->setType(Presence::Unavailable);
 			passedPresence->setFrom(bareJID);
 			passedPresence->setStatus(presence->getStatus());
+		}
 		std::map<JID, boost::shared_ptr<Presence> > jidMap = entries_[bareJID];
 		if (passedPresence->getFrom().isBare() && presence->getType() == Presence::Unavailable) {
 			/* Have a bare-JID only presence of offline */
 			jidMap.clear();
 		} else if (passedPresence->getType() == Presence::Available) {
 			/* Don't have a bare-JID only offline presence once there are available presences */
 			jidMap.erase(bareJID);
+		}
 		if (passedPresence->getType() == Presence::Unavailable && jidMap.size() > 1) {
 			jidMap.erase(passedPresence->getFrom());
 		} else {
 			jidMap[passedPresence->getFrom()] = passedPresence;
+		}
 		entries_[bareJID] = jidMap;
+		}
 		onPresenceChange(passedPresence);
+	}
+}
 Presence::ref PresenceOracle::getLastPresence(const JID& jid) const {
 	PresencesMap::const_iterator i = entries_.find(jid.toBare());
 	if (i == entries_.end()) {
 		return Presence::ref();
+	}
 	PresenceMap presenceMap = i->second;
 	PresenceMap::const_iterator j = presenceMap.find(jid);
 	if (j != presenceMap.end()) {
 		return j->second;
+	}
 	else {
 		return Presence::ref();
+	}
+}
 std::vector<Presence::ref> PresenceOracle::getAllPresence(const JID& bareJID) const {
 	std::vector<Presence::ref> results;
 	PresencesMap::const_iterator i = entries_.find(bareJID);
 	if (i == entries_.end()) {
 		return results;

src/rostermanager.cpp

➞

Show inline comments

@@ @@ -9,49 +9,52 @@ @@
  * (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/rostermanager.h"
 #include "transport/rosterstorage.h"
 #include "transport/storagebackend.h"
 #include "transport/buddy.h"
 #include "transport/usermanager.h"
 #include "transport/buddy.h"
 #include "transport/user.h"
 #include "transport/logging.h"
 #include "Swiften/Roster/SetRosterRequest.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/Elements/RosterItemPayload.h"
 #include "Swiften/Elements/RosterItemExchangePayload.h"
 #include "Swiften/Elements/Nickname.h"
 #include "Swiften/Queries/IQRouter.h"
 #include <boost/foreach.hpp>
 #include <boost/make_shared.hpp>
 #include <map>
 #include <iterator>
 namespace Transport {
 DEFINE_LOGGER(logger, "RosterManager");
 RosterManager::RosterManager(User *user, Component *component){
 	m_rosterStorage = NULL;
 	m_user = user;
 	m_component = component;
 	m_setBuddyTimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(1000);
 	m_RIETimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(5000);
 	m_RIETimer->onTick.connect(boost::bind(&RosterManager::sendRIE, this));
 	m_supportRemoteRoster = false;
 	if (!m_component->inServerMode()) {
 		m_remoteRosterRequest = AddressedRosterRequest::ref(new AddressedRosterRequest(m_component->getIQRouter(), m_user->getJID().toBare()));
 		m_remoteRosterRequest->onResponse.connect(boost::bind(&RosterManager::handleRemoteRosterResponse, this, _1, _2));
 		m_remoteRosterRequest->send();
+	}
+}
@@ @@ -130,54 +133,49 @@ void RosterManager::sendBuddyRosterRemove(Buddy *buddy) { @@
 	// In server mode we have to send pushes to all resources, but in gateway-mode we send it only to bare JID
 	if (m_component->inServerMode()) {
 		std::vector<Swift::Presence::ref> presences = m_component->getPresenceOracle()->getAllPresence(m_user->getJID().toBare());
 		BOOST_FOREACH(Swift::Presence::ref presence, presences) {
 			Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(p, presence->getFrom(), m_component->getIQRouter());
 			request->send();
+		}
+	}
 	else {
 		Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(p, m_user->getJID().toBare(), m_component->getIQRouter());
 		request->send();
+	}
+}
 void RosterManager::sendBuddyRosterPush(Buddy *buddy) {
 	// user can't receive anything in server mode if he's not logged in.
 	// He will ask for roster later (handled in rosterreponsder.cpp)
 	if (m_component->inServerMode() && (!m_user->isConnected() || m_user->shouldCacheMessages()))
 		return;
 	Swift::RosterPayload::ref payload = Swift::RosterPayload::ref(new Swift::RosterPayload());
 	Swift::RosterItemPayload item;
 	item.setJID(buddy->getJID().toBare());
 	if (buddy->getAlias().empty()) {
 		item.setName(buddy->getJID().toBare().toString());
+	}
 	else {
 	item.setName(buddy->getAlias());
+	}
 	item.setGroups(buddy->getGroups());
 	item.setSubscription(Swift::RosterItemPayload::Both);
 	payload->addItem(item);
 	// In server mode we have to send pushes to all resources, but in gateway-mode we send it only to bare JID
 	if (m_component->inServerMode()) {
 		std::vector<Swift::Presence::ref> presences = m_component->getPresenceOracle()->getAllPresence(m_user->getJID().toBare());
 		BOOST_FOREACH(Swift::Presence::ref presence, presences) {
 			Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, presence->getFrom(), m_component->getIQRouter());
 			request->onResponse.connect(boost::bind(&RosterManager::handleBuddyRosterPushResponse, this, _1, request, buddy->getName()));
 			request->send();
 			m_requests.push_back(request);
+		}
+	}
 	else {
 		Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, m_user->getJID().toBare(), m_component->getIQRouter());
 		request->onResponse.connect(boost::bind(&RosterManager::handleBuddyRosterPushResponse, this, _1, request, buddy->getName()));
 		request->send();
 		m_requests.push_back(request);
+	}
 	if (buddy->getSubscription() != Buddy::Both) {
 		buddy->setSubscription(Buddy::Both);
 	if (m_buddies[key] != NULL) {
 		Swift::Presence::ref presence = m_buddies[key]->generatePresenceStanza(255);
 		if (presence && presence->getType() == Swift::Presence::Available) {
 			m_component->getStanzaChannel()->sendPresence(presence);
+		}
+	}
 	else {
 		LOG4CXX_WARN(logger, "handleBuddyRosterPushResponse called for unknown buddy " << key);
+	}
 	m_requests.remove(request);
 	request->onResponse.disconnect_all_slots();
+}
 void RosterManager::handleRemoteRosterResponse(boost::shared_ptr<Swift::RosterPayload> payload, Swift::ErrorPayload::ref error) {
 	m_remoteRosterRequest.reset();
 	if (error) {
 		m_supportRemoteRoster = false;
 		LOG4CXX_INFO(logger, m_user->getJID().toString() << ": This server does not support remote roster protoXEP");
 		return;
+	}
 	LOG4CXX_INFO(logger, m_user->getJID().toString() << ": This server supports remote roster protoXEP");
 	m_supportRemoteRoster = true;
 	//If we receive empty RosterPayload on login (not register) initiate full RosterPush
 	if(!m_buddies.empty() && payload->getItems().empty()){
 			LOG4CXX_INFO(logger, "Received empty Roster upon login. Pushing full Roster.");
 			for(std::map<std::string, Buddy *, std::less<std::string>, boost::pool_allocator< std::pair<std::string, Buddy *> > >::const_iterator c_it = m_buddies.begin();
 					c_it != m_buddies.end(); c_it++) {
 				sendBuddyRosterPush(c_it->second);
+			}
+	}
 	return;
 	BOOST_FOREACH(const Swift::RosterItemPayload &item, payload->getItems()) {
 		std::string legacyName = Buddy::JIDToLegacyName(item.getJID());
 		if (m_buddies.find(legacyName) != m_buddies.end()) {
 			continue;
+		}
 		if (legacyName.empty()) {
 			continue;
+		}
 		BuddyInfo buddyInfo;
 		buddyInfo.id = -1;
 		buddyInfo.alias = item.getName();
 		buddyInfo.legacyName = legacyName;
 		buddyInfo.subscription = "both";
 		buddyInfo.flags = Buddy::buddyFlagsFromJID(item.getJID());
 		buddyInfo.groups = item.getGroups();
 		Buddy *buddy = m_component->getFactory()->createBuddy(this, buddyInfo);
 		if (buddy) {
 			setBuddy(buddy);
+		}
 				case Swift::Presence::Subscribed:
 					if (buddy->getSubscription() != Buddy::Both) {
 						buddy->setSubscription(Buddy::Both);
 						storeBuddy(buddy);
+					}
 					return;
 				default:
 					return;
+			}
+		}
 		else {
 			BuddyInfo buddyInfo;
 			switch (presence->getType()) {
 				// buddy is not in roster, so add him
 				case Swift::Presence::Subscribe:
 					buddyInfo.id = -1;
 					buddyInfo.alias = "";
 					buddyInfo.legacyName = Buddy::JIDToLegacyName(presence->getTo());
 					buddyInfo.subscription = "both";
 					buddyInfo.flags = Buddy::buddyFlagsFromJID(presence->getTo());
 					buddy = m_component->getFactory()->createBuddy(this, buddyInfo);
 					setBuddy(buddy);
 					onBuddyAdded(buddy);
 					LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Subscription received for new buddy " << buddyInfo.legacyName << " => adding to legacy network");
 					response->setType(Swift::Presence::Subscribed);
 					break;
 				case Swift::Presence::Unsubscribe:
 					buddyInfo.id = -1;
 					buddyInfo.alias = "";
 					buddyInfo.legacyName = Buddy::JIDToLegacyName(presence->getTo());
 					buddyInfo.subscription = "both";
 					buddyInfo.flags = Buddy::buddyFlagsFromJID(presence->getTo());
 					response->setType(Swift::Presence::Unsubscribed);
 					buddy = m_component->getFactory()->createBuddy(this, buddyInfo);
 					onBuddyRemoved(buddy);
 					delete buddy;
 					buddy = NULL;
 					break;
 				// just send response
 				case Swift::Presence::Unsubscribed:
 					response->setType(Swift::Presence::Unsubscribe);
 					break;
 				// just send response
 				default:
 					return;
+			}

src/rosterresponder.cpp

➞

Show inline comments

@@ @@ -2,49 +2,48 @@ @@
  * 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/rosterresponder.h"
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "Swiften/Swiften.h"
 #include "transport/user.h"
 #include "transport/usermanager.h"
 #include "transport/rostermanager.h"
 #include "transport/buddy.h"
 #include "transport/logging.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "RosterResponder");
 RosterResponder::RosterResponder(Swift::IQRouter *router, UserManager *userManager) : Swift::Responder<RosterPayload>(router) {
 	m_userManager = userManager;
+}
 RosterResponder::~RosterResponder() {
+}
 bool RosterResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload) {
 	// Get means we're in server mode and user wants to fetch his roster.
 	// For now we send empty reponse, but TODO: Get buddies from database and send proper stored roster.
 	User *user = m_userManager->getUser(from.toBare().toString());

src/rosterstorage.cpp

➞

Show inline comments

@@ @@ -3,48 +3,50 @@ @@
+ *
  * 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/rosterstorage.h"
 #include "transport/buddy.h"
 #include "transport/user.h"
 #include "transport/storagebackend.h"
 #include "transport/logging.h"
 #include "Swiften/Network/NetworkFactories.h"
 DEFINE_LOGGER(logger, "RosterStorage");
 namespace Transport {
 // static void save_settings(gpointer k, gpointer v, gpointer data) {
 // 	PurpleValue *value = (PurpleValue *) v;
 // 	std::string key((char *) k);
 // 	SaveData *s = (SaveData *) data;
 // 	AbstractUser *user = s->user;
 // 	long id = s->id;
 // 	if (purple_value_get_type(value) == PURPLE_TYPE_BOOLEAN) {
 // 		if (purple_value_get_boolean(value))
 // 			Transport::instance()->sql()->addBuddySetting(user->storageId(), id, key, "1", purple_value_get_type(value));
 // 		else
 // 			Transport::instance()->sql()->addBuddySetting(user->storageId(), id, key, "0", purple_value_get_type(value));
 // 	}
 // 	else if (purple_value_get_type(value) == PURPLE_TYPE_STRING) {
 // 		const char *str = purple_value_get_string(value);
 // 		Transport::instance()->sql()->addBuddySetting(user->storageId(), id, key, str ? str : "", purple_value_get_type(value));
 // 	}
 // }
 //
 // static gboolean storeAbstractSpectrumBuddy(gpointer key, gpointer v, gpointer data) {
 // 	AbstractUser *user = (AbstractUser *) data;

src/statsresponder.cpp

➞

Show inline comments

@@ @@ -3,49 +3,48 @@ @@
+ *
  * 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/statsresponder.h"
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "transport/BlockPayload.h"
 #include "Swiften/Swiften.h"
 #include "transport/usermanager.h"
 #include "transport/user.h"
 #include "transport/buddy.h"
 #include "transport/rostermanager.h"
 #include "transport/memoryusage.h"
 #include "transport/conversationmanager.h"
 #include "transport/rostermanager.h"
 #include "transport/usermanager.h"
 #include "transport/networkpluginserver.h"
 #include "transport/logging.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "StatsResponder");
 StatsResponder::StatsResponder(Component *component, UserManager *userManager, NetworkPluginServer *server, StorageBackend *storageBackend) : Swift::Responder<StatsPayload>(component->getIQRouter()) {
 	m_component = component;
 	m_userManager = userManager;
 	m_server = server;
 	m_storageBackend = storageBackend;
 	m_start = time(0);

src/storagebackend.cpp

➞

Show inline comments

 #include "transport/storagebackend.h"
 #include "transport/config.h"
 #include "transport/sqlite3backend.h"
 #include "transport/mysqlbackend.h"
 #include "transport/pqxxbackend.h"
 #include "Swiften/StringCodecs/Base64.h"
 #include "Swiften/Swiften.h"
 namespace Transport {
 StorageBackend *StorageBackend::createBackend(Config *config, std::string &error) {
 	StorageBackend *storageBackend = NULL;
 #ifdef WITH_SQLITE
 	if (CONFIG_STRING(config, "database.type") == "sqlite3") {
 		storageBackend = new SQLite3Backend(config);
+	}
 #else
 	if (CONFIG_STRING(config, "database.type") == "sqlite3") {
 		error = "Libtransport is not compiled with sqlite3 backend support.";
+	}
 #endif
 #ifdef WITH_MYSQL
 	if (CONFIG_STRING(config, "database.type") == "mysql") {
 		storageBackend = new MySQLBackend(config);
+	}
 #else
 	if (CONFIG_STRING(config, "database.type") == "mysql") {
 		error = "Spectrum2 is not compiled with mysql backend support.";
+	}
 #endif

src/storageresponder.cpp

➞

Show inline comments

@@ @@ -3,49 +3,51 @@ @@
+ *
  * 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 "storageresponder.h"
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "Swiften/Elements/RawXMLPayload.h"
 #include "Swiften/Swiften.h"
 #include "Swiften/Elements/Storage.h"
 #include "Swiften/Elements/Storage.h"
 #include "Swiften/Serializer/PayloadSerializers/StorageSerializer.h"
 #include "transport/usermanager.h"
 #include "transport/user.h"
 #include "transport/logging.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "StorageResponder");
 StorageResponder::StorageResponder(Swift::IQRouter *router, StorageBackend *storageBackend, UserManager *userManager) : Swift::Responder<PrivateStorage>(router) {
 	m_storageBackend = storageBackend;
 	m_userManager = userManager;
+}
 StorageResponder::~StorageResponder() {
+}
 bool StorageResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::PrivateStorage> payload) {
 	User *user = m_userManager->getUser(from.toBare().toString());
 	if (!user) {
 		LOG4CXX_WARN(logger, from.toBare().toString() << ": User is not logged in");
 		sendError(from, id, ErrorPayload::NotAcceptable, ErrorPayload::Cancel);

src/storageresponder.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/Responder.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/Elements/PrivateStorage.h"
 namespace Transport {
 class StorageBackend;
 class UserManager;
 class StorageResponder : public Swift::Responder<Swift::PrivateStorage> {
 	public:
 		StorageResponder(Swift::IQRouter *router, StorageBackend *storageBackend, UserManager *userManager);
 		~StorageResponder();
 	private:
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::PrivateStorage> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::PrivateStorage> payload);
 		StorageBackend *m_storageBackend;
 		UserManager *m_userManager;
 };
+}

src/tests/conversationmanager.cpp

➞

Show inline comments

@@ @@ -14,48 +14,50 @@ @@
 #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(handleGroupchatMessagesBouncer);
 	CPPUNIT_TEST(handleGroupchatMessagesBouncerLeave);
 	CPPUNIT_TEST(handleGroupchatMessagesTwoResources);
 	CPPUNIT_TEST(handleChatstateMessages);
 	CPPUNIT_TEST(handleSubjectMessages);
 	CPPUNIT_TEST(handleParticipantChanged);
 	CPPUNIT_TEST(handleParticipantChangedTwoResources);
 	CPPUNIT_TEST(handlePMFromXMPP);
 	CPPUNIT_TEST(handleGroupchatRemoved);
 	CPPUNIT_TEST(handleNicknameConflict);
 	CPPUNIT_TEST(handleNotAuthorized);
 	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) {
 		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");
+		conv->handleParticipantChanged("nickname", Conversation::PARTICIPANT_FLAG_MODERATOR, 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");
 		msg->setBody("hi there!");
 		conv->handleMessage(msg, "anotheruser");
 		boost::shared_ptr<Swift::Message> msg2(new Swift::Message());
 		msg2->setBody("hi there2!");
 		conv->handleMessage(msg2, "anotheruser");
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource"), serverFromClientSession.get(), Swift::createSafeByteArray("password"));
 		userRegistry->onPasswordValid(Swift::JID("user@localhost/resource"));
 		loop->processEvents();
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("#room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(4, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(3, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[1])));
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there!"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getBody());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/anotheruser"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getFrom().toString());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[2])));
-		CPPUNIT_ASSERT_EQUAL(std::string("hi there!"), dynamic_cast<Swift::Message *>(getStanza(received[2]))->getBody());
+		CPPUNIT_ASSERT_EQUAL(std::string("hi there2!"), dynamic_cast<Swift::Message *>(getStanza(received[2]))->getBody());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Message *>(getStanza(received[2]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/anotheruser"), dynamic_cast<Swift::Message *>(getStanza(received[2]))->getFrom().toString());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[3])));
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there2!"), dynamic_cast<Swift::Message *>(getStanza(received[3]))->getBody());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Message *>(getStanza(received[3]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/anotheruser"), dynamic_cast<Swift::Message *>(getStanza(received[3]))->getFrom().toString());
+	}
 	void handleGroupchatMessagesBouncerLeave() {
 		User *user = userManager->getUser("user@localhost");
 		user->addUserSetting("stay_connected", "1");
 		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");
 		CPPUNIT_ASSERT(!user->shouldCacheMessages());
 		Swift::Presence::ref response3 = Swift::Presence::create();
 		response3->setType(Swift::Presence::Unavailable);
 		response3->setTo("#room@localhost/hanzz");
 		response3->setFrom("user@localhost/resource");
 		Swift::MUCPayload *payload3 = new Swift::MUCPayload();
 		payload3->setPassword("password");
 		response3->addPayload(boost::shared_ptr<Swift::Payload>(payload3));
 		injectPresence(response3);
 		loop->processEvents();
 		msg->setBody("hi there!");
 		conv->handleMessage(msg, "anotheruser");
 		boost::shared_ptr<Swift::Message> msg2(new Swift::Message());
 		msg2->setBody("hi there2!");
 		conv->handleMessage(msg2, "anotheruser");
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource"), serverFromClientSession.get(), Swift::createSafeByteArray("password"));
 		userRegistry->onPasswordValid(Swift::JID("user@localhost/resource"));
 		loop->processEvents();
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("#room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(4, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(3, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[1])));
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there!"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getBody());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/anotheruser"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getFrom().toString());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[2])));
-		CPPUNIT_ASSERT_EQUAL(std::string("hi there!"), dynamic_cast<Swift::Message *>(getStanza(received[2]))->getBody());
+		CPPUNIT_ASSERT_EQUAL(std::string("hi there2!"), dynamic_cast<Swift::Message *>(getStanza(received[2]))->getBody());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Message *>(getStanza(received[2]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/anotheruser"), dynamic_cast<Swift::Message *>(getStanza(received[2]))->getFrom().toString());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[3])));
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there2!"), dynamic_cast<Swift::Message *>(getStanza(received[3]))->getBody());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Message *>(getStanza(received[3]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/anotheruser"), dynamic_cast<Swift::Message *>(getStanza(received[3]))->getFrom().toString());
+	}
 	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());
 		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");
+		conv->handleParticipantChanged("anotheruser", Conversation::PARTICIPANT_FLAG_NONE, 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");
+		conv->handleParticipantChanged("nickname", Conversation::PARTICIPANT_FLAG_MODERATOR, 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");
+		conv->handleParticipantChanged("anotheruser", Conversation::PARTICIPANT_FLAG_MODERATOR, 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");
+		conv->handleParticipantChanged("anotheruser", Conversation::PARTICIPANT_FLAG_NONE, 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");
+		conv->handleParticipantChanged("anotheruser", Conversation::PARTICIPANT_FLAG_NONE, 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);
+	}
 	void handleNicknameConflict() {
 		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("nickname", Conversation::PARTICIPANT_FLAG_CONFLICT, 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::Presence::Error, dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getType());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::ErrorPayload>());
 		CPPUNIT_ASSERT_EQUAL(Swift::ErrorPayload::Conflict, getStanza(received[0])->getPayload<Swift::ErrorPayload>()->getCondition());
+	}
 	void handleNotAuthorized() {
 		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("nickname", Conversation::PARTICIPANT_FLAG_NOT_AUTHORIZED, 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::Presence::Error, dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getType());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::ErrorPayload>());
 		CPPUNIT_ASSERT_EQUAL(Swift::ErrorPayload::NotAuthorized, getStanza(received[0])->getPayload<Swift::ErrorPayload>()->getCondition());
+	}
 };
 CPPUNIT_TEST_SUITE_REGISTRATION (ConversationManagerTest);

src/tests/rostermanager.cpp

➞

Show inline comments

@@ @@ -2,48 +2,49 @@ @@
 #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 <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 RosterManagerTest : public CPPUNIT_NS :: TestFixture, public BasicTest {
 	CPPUNIT_TEST_SUITE(RosterManagerTest);
 	CPPUNIT_TEST(setBuddy);
 	CPPUNIT_TEST(setBuddyNoAlias);
 	CPPUNIT_TEST(sendCurrentPresences);
 	CPPUNIT_TEST(sendUnavailablePresences);
 	CPPUNIT_TEST(sendCurrentPresence);
 	CPPUNIT_TEST(sendBuddySubscribePresence);
 	CPPUNIT_TEST(removeBuddy);
 	CPPUNIT_TEST(subscribeExistingBuddy);
 	CPPUNIT_TEST(subscribeNewBuddy);
 	CPPUNIT_TEST(unsubscribeExistingBuddy);
 	CPPUNIT_TEST(unsubscribeNewBuddy);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		std::string m_buddy;
 		void setUp (void) {
 			m_buddy.clear();
 			setMeUp();
 			connectUser();
 			User *user = userManager->getUser("user@localhost");
 			user->getRosterManager()->onBuddyAdded.connect(boost::bind(&RosterManagerTest::handleBuddyAdded, this, _1));
 			user->getRosterManager()->onBuddyRemoved.connect(boost::bind(&RosterManagerTest::handleBuddyRemoved, this, _1));
 			received.clear();
+		}
 			received.clear();
 			disconnectUser();
 			tearMeDown();
+		}
 	void handleBuddyAdded(Buddy *buddy) {
 		m_buddy = buddy->getName();
+	}
 	void handleBuddyRemoved(Buddy *buddy) {
 		m_buddy = buddy->getName();
+	}
 	void sendBuddySubscribePresence() {
 		add2Buddies();
 		received.clear();
 		User *user = userManager->getUser("user@localhost");
 		user->getRosterManager()->sendBuddySubscribePresence(user->getRosterManager()->getBuddy("buddy1"));
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Nickname>());
 		CPPUNIT_ASSERT_EQUAL(std::string("Buddy 1"), getStanza(received[0])->getPayload<Swift::Nickname>()->getNickname());
+	}
 	void setBuddyNoAlias() {
 		User *user = userManager->getUser("user@localhost");
 		CPPUNIT_ASSERT(user);
 		std::vector<std::string> grp;
 		grp.push_back("group1");
 		LocalBuddy *buddy = new LocalBuddy(user->getRosterManager(), -1, "buddy1", "", grp, BUDDY_JID_ESCAPING);
 		user->getRosterManager()->setBuddy(buddy);
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		Swift::RosterPayload::ref payload1 = getStanza(received[0])->getPayload<Swift::RosterPayload>();
 		CPPUNIT_ASSERT(payload1);
 		CPPUNIT_ASSERT_EQUAL(1, (int) payload1->getItems().size());
 		Swift::RosterItemPayload item = payload1->getItems()[0];
 		CPPUNIT_ASSERT_EQUAL(std::string("buddy1"), Buddy::JIDToLegacyName(item.getJID()));
 		CPPUNIT_ASSERT_EQUAL(std::string(""), item.getName());
+	}
 	void setBuddy() {
 		add2Buddies();
 		CPPUNIT_ASSERT_EQUAL(4, (int) received.size());
 		Swift::RosterPayload::ref payload1 = getStanza(received[0])->getPayload<Swift::RosterPayload>();
 		CPPUNIT_ASSERT(payload1);
 		CPPUNIT_ASSERT_EQUAL(1, (int) payload1->getItems().size());
 		Swift::RosterItemPayload item = payload1->getItems()[0];
 		CPPUNIT_ASSERT_EQUAL(std::string("buddy1"), Buddy::JIDToLegacyName(item.getJID()));
 		CPPUNIT_ASSERT_EQUAL(std::string("Buddy 1"), item.getName());
 		Swift::RosterPayload::ref payload2 = getStanza(received[2])->getPayload<Swift::RosterPayload>();
 		CPPUNIT_ASSERT(payload2);
 		CPPUNIT_ASSERT_EQUAL(1, (int) payload2->getItems().size());
 		item = payload2->getItems()[0];
 		CPPUNIT_ASSERT_EQUAL(std::string("buddy2"), Buddy::JIDToLegacyName(item.getJID()));
 		CPPUNIT_ASSERT_EQUAL(std::string("Buddy 2"), item.getName());
 		// send responses back
 		injectIQ(Swift::IQ::createResult(getStanza(received[0])->getFrom(), getStanza(received[0])->getTo(), getStanza(received[0])->getID()));
 		injectIQ(Swift::IQ::createResult(getStanza(received[2])->getFrom(), getStanza(received[2])->getTo(), getStanza(received[2])->getID()));
 		// we should get presences
 		CPPUNIT_ASSERT_EQUAL(6, (int) received.size());

src/tests/user.cpp

➞

Show inline comments

 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
+	}
 	void handlePresence() {
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("localhost");
 		response->setFrom("user@localhost/resource");
 		response->setShow(Swift::StatusShow::Away);
 		injectPresence(response);
 		loop->processEvents();
 		// no presence received in server mode, just disco#info
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 		CPPUNIT_ASSERT(changedPresence);
 		CPPUNIT_ASSERT_EQUAL(Swift::StatusShow::Away, changedPresence->getShow());
+	}
 	void handlePresenceJoinRoom() {
 		User *user = userManager->getUser("user@localhost");
 		Swift::Presence::ref response = Swift::Presence::create();
-		response->setTo("#room@localhost/hanzz");
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		// no presence received in server mode, just disco#info
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room"), room);
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string("room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string("hanzz"), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string("password"), roomPassword);
 		room = "";
 		roomNickname = "";
 		roomPassword = "";
 		// simulate that backend joined the room
-		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "#room", true);
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "room", true);
 		conv->addJID("user@localhost/resource");
 		user->getConversationManager()->addConversation(conv);
 		received.clear();
 		injectPresence(response);
 		loop->processEvents();
 		// no presence received in server mode, just disco#info
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
+	}
 	void handlePresenceJoinRoomTwoResources() {
 		handlePresenceJoinRoom();
 		User *user = userManager->getUser("user@localhost");
 		// Add 1 participant
 		Conversation *conv = user->getConversationManager()->getConversation("#room");
 		conv->handleParticipantChanged("anotheruser", 0, Swift::StatusShow::Away, "my status message");
 		Conversation *conv = user->getConversationManager()->getConversation("room");
 		conv->handleParticipantChanged("anotheruser", Conversation::PARTICIPANT_FLAG_NONE, Swift::StatusShow::Away, "my status message");
 		// Connect 2nd resource
 		connectSecondResource();
 		received2.clear();
 		Swift::Presence::ref response = Swift::Presence::create();
-		response->setTo("#room@localhost/hanzz");
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource2");
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		CPPUNIT_ASSERT_EQUAL(2, (int) received2.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received2[1])));
 		CPPUNIT_ASSERT_EQUAL(Swift::StatusShow::Away, dynamic_cast<Swift::Presence *>(getStanza(received2[1]))->getShow());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource2"), dynamic_cast<Swift::Presence *>(getStanza(received2[1]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost/anotheruser"), dynamic_cast<Swift::Presence *>(getStanza(received2[1]))->getFrom().toString());
 		CPPUNIT_ASSERT(getStanza(received2[1])->getPayload<Swift::MUCUserPayload>());
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Member, *getStanza(received2[1])->getPayload<Swift::MUCUserPayload>()->getItems()[0].affiliation);
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Participant, *getStanza(received2[1])->getPayload<Swift::MUCUserPayload>()->getItems()[0].role);
 		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 handlePresenceLeaveRoom() {
 		received.clear();
 		Swift::Presence::ref response = Swift::Presence::create();
-		response->setTo("#room@localhost/hanzz");
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 // 		CPPUNIT_ASSERT_EQUAL(std::string("room"), room);
 // 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 // 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
+	}
 	void handlePresenceLeaveRoomTwoResources() {
 		handlePresenceJoinRoomTwoResources();
 		received.clear();
 		// User is still connected from resource2, so he should not leave the room
 		Swift::Presence::ref response = Swift::Presence::create();
-		response->setTo("#room@localhost/hanzz");
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		// disconnect also from resource
 		// User is still connected from resource2, so he should not leave the room
 		response = Swift::Presence::create();
-		response->setTo("#room@localhost/hanzz");
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource2");
 		response->setType(Swift::Presence::Unavailable);
 		payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
-		CPPUNIT_ASSERT_EQUAL(std::string("#room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string("room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
+	}
 	void handlePresenceLeaveRoomTwoResourcesOneDisconnects() {
 		handlePresenceJoinRoomTwoResources();
 		received.clear();
 		User *user = userManager->getUser("user@localhost");
 		// User is still connected from resource2, so he should not leave the room
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
-		Conversation *conv = user->getConversationManager()->getConversation("#room");
 		Conversation *conv = user->getConversationManager()->getConversation("room");
 		CPPUNIT_ASSERT_EQUAL(1, (int) conv->getJIDs().size());
 		CPPUNIT_ASSERT_EQUAL(Swift::JID("user@localhost/resource2"), conv->getJIDs().front());
+	}
 	void handlePresenceLeaveRoomBouncer() {
 		User *user = userManager->getUser("user@localhost");
 		user->addUserSetting("stay_connected", "1");
 		Swift::Presence::ref response = Swift::Presence::create();
-		response->setTo("#room@localhost/hanzz");
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
+	}
 	void handlePresenceLeaveRoomTwoResourcesBouncer() {
 		User *user = userManager->getUser("user@localhost");
 		user->addUserSetting("stay_connected", "1");
 		handlePresenceJoinRoomTwoResources();
 		received.clear();
 		// User is still connected from resource2, so he should not leave the room
 		Swift::Presence::ref response = Swift::Presence::create();
-		response->setTo("#room@localhost/hanzz");
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		room = "something";
 		// disconnect also from resource
 		// User is still connected from resource2, so he should not leave the room
 		response = Swift::Presence::create();
-		response->setTo("#room@localhost/hanzz");
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource2");
 		response->setType(Swift::Presence::Unavailable);
 		payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string("something"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
+	}
 	void handlePresenceLeaveRoomTwoResourcesOneDisconnectsBouncer() {
 		room = "something";
 		handlePresenceJoinRoomTwoResources();
 		received.clear();
 		User *user = userManager->getUser("user@localhost");
 		// User is still connected from resource2, so he should not leave the room
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
-		Conversation *conv = user->getConversationManager()->getConversation("#room");
 		Conversation *conv = user->getConversationManager()->getConversation("room");
 		CPPUNIT_ASSERT_EQUAL(1, (int) conv->getJIDs().size());
 		CPPUNIT_ASSERT_EQUAL(Swift::JID("user@localhost/resource2"), conv->getJIDs().front());
+	}
 	void leaveJoinedRoom() {
 		User *user = userManager->getUser("user@localhost");
 		handlePresenceJoinRoom();
-		CPPUNIT_ASSERT(user->getConversationManager()->getConversation("#room"));
 		CPPUNIT_ASSERT(user->getConversationManager()->getConversation("room"));
 		received.clear();
 		handlePresenceLeaveRoom();
-		CPPUNIT_ASSERT(!user->getConversationManager()->getConversation("#room"));
 		CPPUNIT_ASSERT(!user->getConversationManager()->getConversation("room"));
+	}
 	void handleDisconnected() {
 		User *user = userManager->getUser("user@localhost");
 		user->handleDisconnected("Connection error", Swift::SpectrumErrorPayload::CONNECTION_ERROR_AUTHENTICATION_FAILED);
 		loop->processEvents();
 		CPPUNIT_ASSERT(streamEnded);
 		user = userManager->getUser("user@localhost");
 		CPPUNIT_ASSERT(!user);
 		CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 		Swift::Message *m = dynamic_cast<Swift::Message *>(getStanza(received[0]));
 		CPPUNIT_ASSERT_EQUAL(std::string("Connection error"), m->getBody());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::StreamError *>(received[1].get()));
 		CPPUNIT_ASSERT_EQUAL(std::string("Connection error"), dynamic_cast<Swift::StreamError *>(received[1].get())->getText());
 		disconnected = true;
+	}
 	void handleDisconnectedReconnect() {
 		readyToConnect = false;
 		User *user = userManager->getUser("user@localhost");
 		user->handleDisconnected("Connection error");
 		loop->processEvents();
 		CPPUNIT_ASSERT(!streamEnded);
 		user = userManager->getUser("user@localhost");
 		CPPUNIT_ASSERT(user);
 		CPPUNIT_ASSERT(readyToConnect);
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("localhost");
 		response->setFrom("user@localhost/resource");
 		injectPresence(response);
 		loop->processEvents();
+	}
 	void joinRoomBeforeConnected() {
 		User *user = userManager->getUser("user@localhost");
 		user->setConnected(false);
 		Swift::Presence::ref response = Swift::Presence::create();
-		response->setTo("#room@localhost/hanzz");
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		// no presence received in server mode, just disco#info
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		user->setConnected(true);
-		CPPUNIT_ASSERT_EQUAL(std::string("#room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string("room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string("hanzz"), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string("password"), roomPassword);
+	}
 	void joinRoomHandleDisconnectedRejoin() {
 		User *user = userManager->getUser("user@localhost");
 		handlePresenceJoinRoom();
 		handleDisconnectedReconnect();
 		room = "";
 		roomNickname = "";
 		roomPassword = "";
 		received.clear();
 		user->setConnected(true);
-		CPPUNIT_ASSERT_EQUAL(std::string("#room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string("room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string("hanzz"), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string("password"), roomPassword);
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
+	}
 };
 CPPUNIT_TEST_SUITE_REGISTRATION (UserTest);

src/tests/userregistry.cpp

➞

Show inline comments

 #include "transport/userregistry.h"
 #include "transport/config.h"
 #include <cppunit/TestFixture.h>
 #include <cppunit/extensions/HelperMacros.h>
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/Server/Server.h>
 #include <Swiften/Network/DummyNetworkFactories.h>
 #include <Swiften/Network/DummyConnectionServer.h>
 #include <Swiften/Network/ConnectionFactory.h>
 #include <Swiften/Network/DummyTimerFactory.h>
 using namespace Transport;
 class UserRegistryTest : public CPPUNIT_NS :: TestFixture {
 	CPPUNIT_TEST_SUITE(UserRegistryTest);
 	CPPUNIT_TEST(login);
 	CPPUNIT_TEST(loginInvalidPassword);
 	CPPUNIT_TEST(loginTwoClientsValidPasswords);
 	CPPUNIT_TEST(loginTwoClientsDifferentPasswords);
 	CPPUNIT_TEST(loginDisconnect);
 	CPPUNIT_TEST(removeLater);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		void setUp (void) {
 			state1 = Init;
 			state2 = Init;
 			std::istringstream ifs;
 			cfg = new Config();
 			cfg->load(ifs);
 			loop = new Swift::DummyEventLoop();
 			factories = new Swift::DummyNetworkFactories(loop);

Changeset was too big and was cut off... Show full diff anyway

0 comments (0 inline, 0 general)