libtransport.git Changeset - 81522828685a

Changeset - 81522828685a

Parent rev.

Child rev.

[Not reviewed]

Merge

4 28 2

Daniel Henninger - 13 years ago 2012-10-04 19:06:33
daniel@vorpalcloud.org

Merge remote branch 'upstream/master'

28 files changed:

CMakeLists.txt

backends/libcommuni/ircnetworkplugin.cpp

131

backends/libcommuni/ircnetworkplugin.h

backends/libcommuni/main.cpp

backends/libcommuni/session.cpp

backends/libcommuni/session.h

backends/libcommuni/singleircnetworkplugin.cpp

138

backends/libcommuni/singleircnetworkplugin.h

backends/libpurple/main.cpp

backends/twitter/userdb.cpp

backends/twitter/userdb.h

include/transport/config.h

include/transport/conversation.h

include/transport/conversationmanager.h

include/transport/networkplugin.h

include/transport/user.h

include/transport/vcardresponder.h

plugin/cpp/networkplugin.cpp

spectrum_manager/src/methods.cpp

src/CMakeLists.txt

src/config.cpp

src/conversation.cpp

src/conversationmanager.cpp

src/networkpluginserver.cpp

src/tests/basictest.cpp

src/tests/basictest.h

src/tests/config.cpp

src/tests/conversationmanager.cpp

105

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

0 comments (0 inline, 0 general)

CMakeLists.txt

➞

Show inline comments

 cmake_minimum_required(VERSION 2.6)
 project(libtransport)
 message(STATUS "Variables to override default places where to find libraries:")
 message(STATUS "|- cppunit : -DCPPUNIT_INCLUDE_DIR,  -DCPPUNIT_LIBRARY")
 message(STATUS "|- swiften : -DSWIFTEN_INCLUDE_DIR,  -DSWIFTEN_LIBRARY")
 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")
 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")
 # FIND CPPUNIT
 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}")
 else()
 endif()
 # FIND SQLITE3
 if (NOT CMAKE_COMPILER_IS_GNUCXX)
 ADD_SUBDIRECTORY(msvc-deps)
 else()
 if (WIN32)
 ADD_SUBDIRECTORY(msvc-deps/sqlite3)
 else()
 set(sqlite3_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(sqlite3)
 endif()
 endif()
 # FIND MYSQL
 set(mysql_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(mysql)
 # FIND LIBPURPLE
 set(purple_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(purple)
 if (WIN32)
 	if (PURPLE_NOT_RUNTIME)
 		add_definitions(-DPURPLE_RUNTIME=0)
 	else(PURPLE_NOT_RUNTIME)
 		add_definitions(-DPURPLE_RUNTIME=1)
 	endif(PURPLE_NOT_RUNTIME)
 else()
 	add_definitions(-DPURPLE_RUNTIME=0)
 endif()
 # FIND GLIB
 # if (GLIB2_INCLUDE_DIR AND GLIB2_LIBRARIES)
 # 	set(GLIB2_FOUND TRUE)
 # else()
 	set(glib_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 	find_package(glib)
 # endif()
 # FIND LIBXML2
 # set(libxml2_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 # find_package(libxml2)
 # FIND POPT
 if (NOT WIN32)
 	set(popt_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 	find_package(popt)
 endif()
 # FIND LIBEVENT
 set(event_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(event)
 # FIND SWIFTEN
 set(Swiften_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(Swiften)
 if(NOT SWIFTEN_FOUND)
 	if (ZLIB_LIBRARY)
 		set(SWIFTEN_LIBRARY ${SWIFTEN_LIBRARY} ${ZLIB_LIBRARY})
 	endif()
 	if (EXPAT_LIBRARY)
 		set(SWIFTEN_LIBRARY ${SWIFTEN_LIBRARY} ${EXPAT_LIBRARY})
 	endif()
 	if (LIBIDN_LIBRARY)
 		set(SWIFTEN_LIBRARY ${SWIFTEN_LIBRARY} ${LIBIDN_LIBRARY})
 	endif()
 	if (LIBXML_LIBRARY)
 		set(SWIFTEN_LIBRARY ${SWIFTEN_LIBRARY} ${LIBXML_LIBRARY})
 	endif()
 	set(SWIFTEN_LIBRARY ${SWIFTEN_LIBRARY} "Dnsapi")
 	set(SWIFTEN_LIBRARY ${SWIFTEN_LIBRARY} "Crypt32")
 	set(SWIFTEN_LIBRARY ${SWIFTEN_LIBRARY} "Secur32")
 	set(SWIFTEN_LIBRARY ${SWIFTEN_LIBRARY} "Iphlpapi")
 	set(SWIFTEN_LIBRARY ${SWIFTEN_LIBRARY} "Winscard")
 	message(STATUS "Using swiften: ${SWIFTEN_INCLUDE_DIR} ${SWIFTEN_LIBRARY}")
 endif()
 if (WIN32)
 	add_definitions(-DSWIFTEN_STATIC=1)
 	ADD_DEFINITIONS(-D_UNICODE)
 	ADD_DEFINITIONS(-DUNICODE)
 endif()
 if (CMAKE_COMPILER_IS_GNUCXX)
 set(openssl_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(openssl)
 endif()
 # FIND BOOST
 set(Boost_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 if (WIN32)
 	set(Boost_USE_STATIC_LIBS      ON)
 	set(Boost_USE_MULTITHREADED      ON)
 	set(Boost_USE_STATIC_RUNTIME    OFF)
 	find_package(Boost COMPONENTS program_options date_time system filesystem regex thread signals REQUIRED)
 else(WIN32)
 	LIST_CONTAINS(contains -lboost_program_options ${SWIFTEN_LIBRARY})
 	if(contains)
 		message(STATUS "Using non-multithreaded boost")
 		set(Boost_USE_MULTITHREADED 0)
 	endif(contains)
 	find_package(Boost COMPONENTS program_options date_time system filesystem regex thread-mt signals REQUIRED)
 	set(Boost_FIND_QUIETLY ON)
 	find_package(Boost COMPONENTS program_options date_time system filesystem regex thread-mt signals)
 	if (NOT Boost_FOUND)
 		set(Boost_FIND_QUIETLY OFF)
 		find_package(Boost COMPONENTS program_options date_time system filesystem regex thread signals REQUIRED)
 	endif()
 endif(WIN32)
 message( STATUS "Found Boost: ${Boost_LIBRARIES}, ${Boost_INCLUDE_DIR}")
 set(Protobuf_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(Protobuf)
 # FIND PROTOBUF
 if (NOT PROTOBUF_FOUND AND PROTOBUF_INCLUDE_DIR AND PROTOBUF_LIBRARY)
 	set(PROTOBUF_FOUND 1)
 	set(PROTOBUF_INCLUDE_DIRS ${PROTOBUF_INCLUDE_DIR})
 	if (PROTOBUF_PROTOC_EXECUTABLE)
 	else()
 		set(PROTOBUF_PROTOC_EXECUTABLE protoc)
 	endif()
 	message(STATUS "Using protobuf: ${PROTOBUF_INCLUDE_DIRS} ${PROTOBUF_LIBRARY}")
 endif()
 set(Communi_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(Communi)
 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()
 set(event_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(event)
 set(pqxx_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(pqxx)
 if (NOT WIN32)
 set(dbus_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(dbus)
 endif()
 set(yahoo2_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(yahoo2)
 find_package(Doxygen)
 INCLUDE(FindQt4)
 FIND_PACKAGE(Qt4 COMPONENTS QtCore QtNetwork)
 # ADD_DEFINITIONS(${SWIFTEN_CFLAGS})
 ADD_DEFINITIONS(-DSUPPORT_LEGACY_CAPS)
 # ADD_DEFINITIONS(-DBOOST_FILESYSTEM_VERSION=2)
 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
 						OUTPUT_VARIABLE GIT_REVISION
 						OUTPUT_STRIP_TRAILING_WHITESPACE
+		)
 		set(SPECTRUM_VERSION 2.0.0-beta-git-${GIT_REVISION})
 		ADD_DEFINITIONS(-DSPECTRUM_VERSION="${SPECTRUM_VERSION}")
 	else (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
 		set(SPECTRUM_VERSION 2.0.0-alpha)
 		ADD_DEFINITIONS(-DSPECTRUM_VERSION="${SPECTRUM_VERSION}")
 	endif (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
 endif (SPECTRUM_VERSION)
 message("Version           : " ${SPECTRUM_VERSION})
 if (SQLITE3_FOUND)
 	ADD_DEFINITIONS(-DWITH_SQLITE)
 	include_directories(${SQLITE3_INCLUDE_DIR})
 	message("SQLite3           : yes")
 else (SQLITE3_FOUND)
 if (WIN32)
 	ADD_DEFINITIONS(-DWITH_SQLITE)
 	include_directories(msvc-deps/sqlite3)
 	message("SQLite3           : bundled")
 else()
 	set(SQLITE3_LIBRARIES "")
 	message("SQLite3           : no")
 endif()
 endif (SQLITE3_FOUND)
 if (MYSQL_FOUND)
 	ADD_DEFINITIONS(-DWITH_MYSQL)
 	include_directories(${MYSQL_INCLUDE_DIR})
 	message("MySQL             : yes")
 else (MYSQL_FOUND)
 	set(MYSQL_LIBRARIES "")
 	message("MySQL             : no (install mysql-devel)")
 endif (MYSQL_FOUND)
 if (PQXX_FOUND)
 	ADD_DEFINITIONS(-DWITH_PQXX)
 	include_directories(${PQXX_INCLUDE_DIR})
 	message("PostgreSQL        : yes")
 else (PQXX_FOUND)
 	set(PQXX_LIBRARY "")
 	set(PQ_LIBRARY "")
 	message("PostgreSQL        : no (install libpqxx-devel)")
 endif (PQXX_FOUND)
 if (PROTOBUF_FOUND)
 	ADD_DEFINITIONS(-DWITH_PROTOBUF)
 	include_directories(${PROTOBUF_INCLUDE_DIRS})
 	message("Network plugins   : yes")
 	if(PURPLE_FOUND)
 		message("Libpurple plugin  : yes")
 		include_directories(${PURPLE_INCLUDE_DIR})
 		include_directories(${GLIB2_INCLUDE_DIR})
 	else()
 		message("Libpurple plugin  : no (install libpurple)")
 	endif()
 	if (HAVE_EVENT)
 		ADD_DEFINITIONS(-DWITH_LIBEVENT)
 		include_directories(${EVENT_INCLUDE_DIRS})
 		message("  libev eventloop : yes")
 	else()
 		message("  libev eventloop : no (install libev-devel)")
 	endif()
 	if(IRC_FOUND)
 		ADD_DEFINITIONS(-DCOMMUNI_SHARED)
 		message("IRC plugin        : yes")
 		include_directories(${QT_QTNETWORK_INCLUDE_DIR})
 		include_directories(${IRC_INCLUDE_DIR})
 		include(${QT_USE_FILE})
 	else()
 		message("IRC plugin        : no (install libCommuni and libprotobuf-dev)")
 	endif()
 if (NOT WIN32)
 	message("Frotz plugin      : yes")
 	message("SMSTools3 plugin  : yes")
 	if(${LIBDBUSGLIB_FOUND})
 		message("Skype plugin      : yes")
 		include_directories(${LIBDBUSGLIB_INCLUDE_DIRS})
 	else()
 		message("Skype plugin      : no (install dbus-glib-devel)")
 	endif()
 else()
 	message("Frotz plugin      : no")
 	message("SMSTools3 plugin  : no")
 	message("Skype plugin      : no")
 endif()
 #	We have our own copy now...
 # 	if(YAHOO2_FOUND)
 		message("Libyahoo2 plugin  : yes")
 # 		include_directories(${YAHOO2_INCLUDE_DIR})
 # 	else()
 # 		message("Libyahoo2 plugin  : no (install libyahoo2-devel)")
 # 	endif()
 	message("Swiften plugin    : yes")
     message("Twitter plugin    : yes")
 else()
 	message("Network plugins   : no (install libprotobuf-dev)")
 	message("Libpurple plugin  : no (install libpurple and libprotobuf-dev)")
 	message("IRC plugin        : no (install libircclient-qt and libprotobuf-dev)")
 	message("Frotz plugin      : no (install libprotobuf-dev)")
 	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 "")
 	message("Log4cxx           : no (install log4cxx-devel)")
 endif()
 if (WIN32)
 ADD_DEFINITIONS(-DLOG4CXX_STATIC)
 ADD_DEFINITIONS(-D_WIN32_WINNT=0x501)
 ADD_DEFINITIONS(-DWIN32_LEAN_AND_MEAN)

backends/libcommuni/ircnetworkplugin.cpp

➞

Show inline comments

 #include "ircnetworkplugin.h"
 #include <IrcCommand>
 #include <IrcMessage>
 #include "transport/logging.h"
 DEFINE_LOGGER(logger, "IRCNetworkPlugin");
 #define FROM_UTF8(WHAT) QString::fromUtf8((WHAT).c_str(), (WHAT).size())
 #define TO_UTF8(WHAT) std::string((WHAT).toUtf8().data(), (WHAT).toUtf8().size())
 IRCNetworkPlugin::IRCNetworkPlugin(Config *config, Swift::QtEventLoop *loop, const std::string &host, int port) {
 	this->config = config;
 	m_currentServer = 0;
 	m_socket = new QTcpSocket();
 	m_socket->connectToHost(FROM_UTF8(host), port);
 	connect(m_socket, SIGNAL(readyRead()), this, SLOT(readData()));
 	std::string server = CONFIG_STRING_DEFAULTED(config, "service.irc_server", "");
 	if (!server.empty()) {
 		m_servers.push_back(server);
+	}
 	else {
 		std::list<std::string> list;
 		list = CONFIG_LIST_DEFAULTED(config, "service.irc_server", list);
 		m_servers.insert(m_servers.begin(), list.begin(), list.end());
+	}
 	if (CONFIG_HAS_KEY(config, "service.irc_identify")) {
 		m_identify = CONFIG_STRING(config, "service.irc_identify");
+	}
 	else {
 		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;
 	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( "utf-8" );
 	if (!password.empty()) {
 		std::string identify = m_identify;
 		boost::replace_all(identify, "$password", password);
 		boost::replace_all(identify, "$name", nickname);
 		session->setIdentify(identify);
+	}
 	LOG4CXX_INFO(logger, user << ": Connecting " << hostname << " as " << nickname << ", suffix=" << suffix);
 	session->open();
 	return session;
+}
 void IRCNetworkPlugin::handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 	// In server mode, hostname of the server we want to connect to is stored in "user" JID.
 	// In component mode we will connect user to the IRC network once he joins the room.
 	if (CONFIG_BOOL(config, "service.server_mode")) {
 		MyIrcSession *session = new MyIrcSession(user, this);
 		std::string h = user.substr(0, user.find("@"));
 		session->setNickName(FROM_UTF8(h.substr(0, h.find("%"))));
 		session->setHost(FROM_UTF8(h.substr(h.find("%") + 1)));
 		session->setPort(6667);
 		session->open();
 		LOG4CXX_INFO(logger, user << ": Connecting IRC network " << h.substr(h.find("%") + 1));
 		m_sessions[user] = session;
 	if (!m_servers.empty()) {
 		// legacy name is users nickname
 		if (m_sessions[user] != NULL) {
 			LOG4CXX_WARN(logger, user << ": Already logged in.");
 			return;
+		}
 		m_sessions[user] = createSession(user, m_servers[m_currentServer], legacyName, password, "");
+	}
 	else {
 		// We are waiting for first room join to connect user to IRC network, because we don't know which
 		// network he choose...
 		LOG4CXX_INFO(logger, user << ": Ready for connections");
 		handleConnected(user);
+	}
+}
 void IRCNetworkPlugin::handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 	if (m_sessions[user] == NULL)
 	if (m_sessions[user] == NULL) {
 		LOG4CXX_WARN(logger, user << ": Already disconnected.");
 		return;
+	}
 	LOG4CXX_INFO(logger, user << ": Disconnecting.");
 	m_sessions[user]->close();
 	m_sessions[user]->deleteLater();
 	m_sessions.erase(user);
+}
-void IRCNetworkPlugin::handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &/*xhtml*/) {
+std::string IRCNetworkPlugin::getSessionName(const std::string &user, const std::string &legacyName) {
 	std::string u = user;
 	if (!CONFIG_BOOL(config, "service.server_mode")) {
+	if (!CONFIG_BOOL(config, "service.server_mode") && m_servers.empty()) {
 		u = user + legacyName.substr(legacyName.find("@") + 1);
 		if (u.find("/") != std::string::npos) {
 			u = u.substr(0, u.find("/"));
+		}
+	}
 	if (m_sessions[u] == NULL) {
 		LOG4CXX_WARN(logger, user << ": Session name: " << u << ", No session for user");
 		return;
+	}
 	return u;
+}
 std::string IRCNetworkPlugin::getTargetName(const std::string &legacyName) {
 	std::string r = legacyName;
 	if (!CONFIG_BOOL(config, "service.server_mode")) {
+// 	if (!CONFIG_BOOL(config, "service.server_mode")) {
 		if (legacyName.find("/") == std::string::npos) {
 			r = legacyName.substr(0, r.find("@"));
+		}
 		else {
 			r = legacyName.substr(legacyName.find("/") + 1);
+		}
 // 	}
 	return r;
+}
 void IRCNetworkPlugin::handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &/*xhtml*/) {
 	std::string session = getSessionName(user, legacyName);
 	if (m_sessions[session] == NULL) {
 		LOG4CXX_WARN(logger, user << ": Session name: " << session << ", No session for user");
 		return;
+	}
 	std::string target = getTargetName(legacyName);
 	LOG4CXX_INFO(logger, user << ": Session name: " << session << ", message to " << target);
 	m_sessions[session]->sendCommand(IrcCommand::createMessage(FROM_UTF8(target), FROM_UTF8(message)));
 	if (target.find("#") == 0) {
 		handleMessage(user, legacyName, message, TO_UTF8(m_sessions[session]->nickName()));
+	}
 	LOG4CXX_INFO(logger, user << ": Session name: " << u << ", message to " << r);
 	m_sessions[u]->sendCommand(IrcCommand::createMessage(FROM_UTF8(r), FROM_UTF8(message)));
+}
 void IRCNetworkPlugin::handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &password) {
 	std::string r = room;
 	std::string u = user;
 	if (!CONFIG_BOOL(config, "service.server_mode")) {
 		u = user + room.substr(room.find("@") + 1);
 		r = room.substr(0, room.find("@"));
 void IRCNetworkPlugin::handleRoomSubjectChangedRequest(const std::string &user, const std::string &room, const std::string &message) {
 	std::string session = getSessionName(user, room);
 	if (m_sessions[session] == NULL) {
 		LOG4CXX_WARN(logger, user << ": Session name: " << session << ", No session for user");
 		return;
+	}
 	LOG4CXX_INFO(logger, user << ": Session name: " << u << ", Joining room " << r);
 	if (m_sessions[u] == NULL) {
 		// in gateway mode we want to login this user to network according to legacyName
 		if (room.find("@") != std::string::npos) {
 			// suffix is %irc.freenode.net to let MyIrcSession return #room%irc.freenode.net
 			MyIrcSession *session = new MyIrcSession(user, this, room.substr(room.find("@")));
 			session->setNickName(FROM_UTF8(nickname));
 			session->setHost(FROM_UTF8(room.substr(room.find("@") + 1)));
 			session->setPort(6667);
 			session->open();
 			LOG4CXX_INFO(logger, user << ": Connecting IRC network " << room.substr(room.find("@") + 1));
 			m_sessions[u] = session;
 	std::string target = getTargetName(room);
 	m_sessions[session]->sendCommand(IrcCommand::createTopic(FROM_UTF8(target), FROM_UTF8(message)));
+}
 void IRCNetworkPlugin::handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &password) {
 	std::string session = getSessionName(user, room);
 	std::string target = getTargetName(room);
 	LOG4CXX_INFO(logger, user << ": Session name: " << session << ", Joining room " << target);
 	if (m_sessions[session] == NULL) {
 		if (m_servers.empty()) {
 			// in gateway mode we want to login this user to network according to legacyName
 			if (room.find("@") != std::string::npos) {
 				// suffix is %irc.freenode.net to let MyIrcSession return #room%irc.freenode.net
 				m_sessions[session] = createSession(user, room.substr(room.find("@") + 1), nickname, "", room.substr(room.find("@")));
+			}
 			else {
 				LOG4CXX_WARN(logger, user << ": There's no proper server defined in room to which this user wants to join: " << room);
 				return;
+			}
+		}
 		else {
-			LOG4CXX_WARN(logger, user << ": There's no proper server defined in room to which this user wants to join: " << room);
+			LOG4CXX_WARN(logger, user << ": Join room requested for unconnected user");
 			return;
+		}
+	}
 	m_sessions[u]->addAutoJoinChannel(r, password);
 	m_sessions[u]->sendCommand(IrcCommand::createJoin(FROM_UTF8(r), FROM_UTF8(password)));
 	m_sessions[u]->rooms += 1;
 	m_sessions[session]->addAutoJoinChannel(target, password);
 	m_sessions[session]->sendCommand(IrcCommand::createJoin(FROM_UTF8(target), FROM_UTF8(password)));
 	m_sessions[session]->rooms += 1;
 	// update nickname, because we have nickname per session, no nickname per room.
-	handleRoomNicknameChanged(user, r, TO_UTF8(m_sessions[u]->nickName()));
+	handleRoomNicknameChanged(user, target, TO_UTF8(m_sessions[session]->nickName()));
+}
 void IRCNetworkPlugin::handleLeaveRoomRequest(const std::string &user, const std::string &room) {
 	std::string r = room;
 	std::string u = user;
 	if (!CONFIG_BOOL(config, "service.server_mode")) {
 		r = room.substr(0, room.find("@"));
 		u = user + room.substr(room.find("@") + 1);
+	}
 	std::string session = getSessionName(user, room);
 	std::string target = getTargetName(room);
 	if (m_sessions[u] == NULL)
 	LOG4CXX_INFO(logger, user << ": Session name: " << session << ", Leaving room " << target);
 	if (m_sessions[session] == NULL)
 		return;
 	LOG4CXX_INFO(logger, user << ": Session name: " << u << ", Leaving room " << r);
 	m_sessions[u]->sendCommand(IrcCommand::createPart(FROM_UTF8(r)));
 	m_sessions[u]->removeAutoJoinChannel(r);
 	m_sessions[u]->rooms -= 1;
 	m_sessions[session]->sendCommand(IrcCommand::createPart(FROM_UTF8(target)));
 	m_sessions[session]->removeAutoJoinChannel(target);
 	m_sessions[session]->rooms -= 1;
 	if (m_sessions[u]->rooms <= 0) {
 		LOG4CXX_INFO(logger, user << ": Session name: " << u << ", User is not in room, disconnecting from network");
 		m_sessions[u]->close();
 		m_sessions[u]->deleteLater();
 		m_sessions.erase(u);
 	if (m_sessions[session]->rooms <= 0 && m_servers.empty()) {
 		LOG4CXX_INFO(logger, user << ": Session name: " << session << ", User is not in any room, disconnecting from network");
 		m_sessions[session]->close();
 		m_sessions[session]->deleteLater();
 		m_sessions.erase(session);
+	}
+}

backends/libcommuni/ircnetworkplugin.h

➞

Show inline comments

 #pragma once
 #include "transport/config.h"
 #include "transport/networkplugin.h"
 #include "session.h"
 #include <QtCore>
 #include <QtNetwork>
 #include "Swiften/EventLoop/Qt/QtEventLoop.h"
 #include "ircnetworkplugin.h"
 class IRCNetworkPlugin : public QObject, public NetworkPlugin {
 	Q_OBJECT
 	public:
 		IRCNetworkPlugin(Config *config, Swift::QtEventLoop *loop, const std::string &host, int port);
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password);
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName);
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &/*xhtml*/);
 		void handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &password);
 		void handleLeaveRoomRequest(const std::string &user, const std::string &room);
 		void handleRoomSubjectChangedRequest(const std::string &user, const std::string &room, const std::string &message);
 		void tryNextServer();
 	public slots:
 		void readData();
 		void sendData(const std::string &string);
 	private:
 		MyIrcSession *createSession(const std::string &user, const std::string &hostname, const std::string &nickname, const std::string &password, const std::string &suffix = "");
 		std::string getSessionName(const std::string &user, const std::string &legacyName);
 		std::string getTargetName(const std::string &legacyName);
 	private:
 		Config *config;
 		QTcpSocket *m_socket;
 		std::map<std::string, MyIrcSession *> m_sessions;
 		std::vector<std::string> m_servers;
 		int m_currentServer;
 		std::string m_identify;
 };
@@ \ No newline at end of file @@

backends/libcommuni/main.cpp

➞

Show inline comments

 /*
  * Copyright (C) 2008-2009 J-P Nurmi jpnurmi@gmail.com
+ *
  * This example is free, and not covered by LGPL license. There is no
  * restriction applied to their modification, redistribution, using and so on.
  * You can study them, modify them, use them in your own program - either
  * completely or partially. By using it you may give me some credits in your
  * program, but you don't have to.
  */
 #include "transport/config.h"
 #include "transport/networkplugin.h"
 #include "transport/logging.h"
 #include "session.h"
 #include <QtCore>
 #include <QtNetwork>
 #include "Swiften/EventLoop/Qt/QtEventLoop.h"
 #include "ircnetworkplugin.h"
 #include "singleircnetworkplugin.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);
 	Swift::QtEventLoop eventLoop;
 	if (!CONFIG_HAS_KEY(cfg, "service.irc_server")) {
 		np = new IRCNetworkPlugin(cfg, &eventLoop, host, port);
+	}
 	else {
 		np = new SingleIRCNetworkPlugin(cfg, &eventLoop, host, port);
+	}
 	np = new IRCNetworkPlugin(cfg, &eventLoop, host, port);
 	return app.exec();
+}

backends/libcommuni/session.cpp

➞

Show inline comments

 /*
  * Copyright (C) 2008-2009 J-P Nurmi jpnurmi@gmail.com
+ *
  * This example is free, and not covered by LGPL license. There is no
  * restriction applied to their modification, redistribution, using and so on.
  * You can study them, modify them, use them in your own program - either
  * completely or partially. By using it you may give me some credits in your
  * program, but you don't have to.
  */
 #include "session.h"
 #include <QtCore>
 #include <iostream>
 #include <IrcCommand>
 #include <IrcMessage>
 #include "ircnetworkplugin.h"
 #define FROM_UTF8(WHAT) QString::fromUtf8((WHAT).c_str(), (WHAT).size())
 #define TO_UTF8(WHAT) std::string((WHAT).toUtf8().data(), (WHAT).toUtf8().size())
 #include "transport/logging.h"
 DEFINE_LOGGER(logger, "IRCSession");
-MyIrcSession::MyIrcSession(const std::string &user, NetworkPlugin *np, const std::string &suffix, QObject* parent) : IrcSession(parent)
+MyIrcSession::MyIrcSession(const std::string &user, IRCNetworkPlugin *np, const std::string &suffix, QObject* parent) : IrcSession(parent)
+{
 	this->np = np;
 	this->user = user;
 	this->suffix = suffix;
 	m_connected = false;
 	rooms = 0;
 	connect(this, SIGNAL(disconnected()), SLOT(on_disconnected()));
 	connect(this, SIGNAL(socketError(QAbstractSocket::SocketError)), SLOT(on_socketError(QAbstractSocket::SocketError)));
 	connect(this, SIGNAL(connected()), SLOT(on_connected()));
 	connect(this, SIGNAL(messageReceived(IrcMessage*)), this, SLOT(onMessageReceived(IrcMessage*)));
+}
 void MyIrcSession::on_connected() {
 	m_connected = true;
 	if (suffix.empty()) {
 		np->handleConnected(user);
+	}
 	for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
 		sendCommand(IrcCommand::createJoin(FROM_UTF8(it->second->getChannel()), FROM_UTF8(it->second->getPassword())));
+	}
 	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())
+	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;
 		default: break;
+	}
 	return flags;
+}
 void MyIrcSession::on_joined(IrcMessage *message) {
 	IrcJoinMessage *m = (IrcJoinMessage *) message;
 	bool flags = 0;
 	std::string nickname = TO_UTF8(m->sender().name());
 	flags = correctNickname(nickname);
 	np->handleParticipantChanged(user, nickname, TO_UTF8(m->channel()), (int) flags, pbnetwork::STATUS_ONLINE);
 	LOG4CXX_INFO(logger, user << ": Joined " << TO_UTF8(m->parameters()[0]));
+}
 void MyIrcSession::on_parted(IrcMessage *message) {
 	IrcPartMessage *m = (IrcPartMessage *) message;
 	bool flags = 0;
 	std::string nickname = TO_UTF8(m->sender().name());
 	flags = correctNickname(nickname);
 	LOG4CXX_INFO(logger, user << ": " << nickname << " parted " << TO_UTF8(m->channel()) + suffix);
 	np->handleParticipantChanged(user, nickname, TO_UTF8(m->channel()) + suffix,(int) flags, 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 flags = 0;
 		std::string nickname = TO_UTF8(m->sender().name());
 		flags = correctNickname(nickname);
 		LOG4CXX_INFO(logger, user << ": " << nickname << " quit " << it->second->getChannel() + suffix);
 		np->handleParticipantChanged(user, nickname, it->second->getChannel() + suffix,(int) flags, 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());
 		bool flags = m_modes[it->second->getChannel() + nickname];
 		LOG4CXX_INFO(logger, user << ": " << nickname << " changed nickname to " << TO_UTF8(m->nick()));
 		np->handleParticipantChanged(user, nickname, it->second->getChannel() + suffix,(int) flags, pbnetwork::STATUS_ONLINE, "", TO_UTF8(m->nick()));
+	}
+}
 void MyIrcSession::on_modeChanged(IrcMessage *message) {
 	IrcModeMessage *m = (IrcModeMessage *) message;
 	// mode changed: "#testik" "HanzZ" "+o" "hanzz_k"
 	std::string nickname = TO_UTF8(m->argument());
 	std::string mode = TO_UTF8(m->mode());
 	if (nickname.empty())
 		return;
 	LOG4CXX_INFO(logger, user << ": " << nickname << " changed mode to " << mode);
 	for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
 		if (mode == "+o") {
 			m_modes[it->second->getChannel() + nickname] = 1;
+		}
 		else {
 			m_modes[it->second->getChannel() + nickname] = 0;
+		}
 		bool flags = m_modes[it->second->getChannel() + nickname];
 		np->handleParticipantChanged(user, nickname, it->second->getChannel() + suffix,(int) flags, pbnetwork::STATUS_ONLINE, "");
+	}
+}
 void MyIrcSession::on_topicChanged(IrcMessage *message) {
 	IrcTopicMessage *m = (IrcTopicMessage *) message;
 	bool flags = 0;
 	std::string nickname = TO_UTF8(m->sender().name());
 	flags = 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);
+}
 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;
+		}
+	}
 	std::string target = TO_UTF8(m->target());
 	LOG4CXX_INFO(logger, user << ": Message from " << target);
 	if (target.find("#") == 0) {
 		bool flags = 0;
 		std::string nickname = TO_UTF8(m->sender().name());
 		flags = correctNickname(nickname);
 		np->handleMessage(user, target + suffix, TO_UTF8(m->message()), nickname);
+	}
 	else {
 		bool flags = 0;
 		std::string nickname = TO_UTF8(m->sender().name());
 		flags = correctNickname(nickname);
 		np->handleMessage(user, nickname, TO_UTF8(m->message()));
 		LOG4CXX_INFO(logger, nickname + suffix);
 		np->handleMessage(user, nickname + suffix, TO_UTF8(m->message()));
+	}
+}
 void MyIrcSession::on_numericMessageReceived(IrcMessage *message) {
 	QString channel;
 	QStringList members;
 	IrcNumericMessage *m = (IrcNumericMessage *) message;
 	switch (m->code()) {
 		case 332:
 			m_topicData = TO_UTF8(m->parameters().value(2));
 			break;
 		case 333:
 			 np->handleSubject(user, TO_UTF8(m->parameters().value(1)) + suffix, m_topicData, TO_UTF8(m->parameters().value(2)));
 			break;
 		case 353:
 			channel = m->parameters().value(2);
 			members = m->parameters().value(3).split(" ");
 			LOG4CXX_INFO(logger, user << ": Received members for " << TO_UTF8(channel) << suffix);
 			for (int i = 0; i < members.size(); i++) {
 				bool flags = 0;
 				std::string nickname = TO_UTF8(members.at(i));
 				flags = correctNickname(nickname);
 				m_modes[TO_UTF8(channel) + nickname] = flags;
 				np->handleParticipantChanged(user, nickname, TO_UTF8(channel) + suffix,(int) flags, pbnetwork::STATUS_ONLINE);
+			}
 			break;
 		case 432:
 			if (m_connected) {
 				np->handleDisconnected(user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Erroneous Nickname");
+			}
 			np->handleDisconnected(user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Erroneous Nickname");
 			break;
 		default:
 			break;
+	}
 	//qDebug() << "numeric message received:" << receiver() << origin << code << params;
+}
 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;
 		case IrcMessage::Nick:
 			on_nickChanged(message);
 			break;
 		case IrcMessage::Mode:
 			on_modeChanged(message);
 			break;
 		case IrcMessage::Topic:
 			on_topicChanged(message);
 			break;
 		case IrcMessage::Private:
 			on_messageReceived(message);
 			break;
 		case IrcMessage::Numeric:
 			on_numericMessageReceived(message);
 			break;
 		default:break;
+	}
+}

backends/libcommuni/session.h

➞

Show inline comments

 /*
  * Copyright (C) 2008-2009 J-P Nurmi jpnurmi@gmail.com
+ *
  * This example is free, and not covered by LGPL license. There is no
  * restriction applied to their modification, redistribution, using and so on.
  * You can study them, modify them, use them in your own program - either
  * completely or partially. By using it you may give me some credits in your
  * program, but you don't have to.
  */
 #ifndef SESSION_H
 #define SESSION_H
 #include <IrcSession>
 #include <transport/networkplugin.h>
 #include "Swiften/Swiften.h"
 #include <boost/smart_ptr/make_shared.hpp>
 using namespace Transport;
 class IRCNetworkPlugin;
 class MyIrcSession : public IrcSession
+{
     Q_OBJECT
 public:
 	class AutoJoinChannel {
 		public:
 			AutoJoinChannel(const std::string &channel = "", const std::string &password = "") : m_channel(channel), m_password(password) {}
 			virtual ~AutoJoinChannel() {}
 			const std::string &getChannel() { return m_channel; }
 			const std::string &getPassword() { return m_password; }
 		private:
 			std::string m_channel;
 			std::string m_password;
 	};
 	typedef std::map<std::string, boost::shared_ptr<AutoJoinChannel> > AutoJoinMap;
-	MyIrcSession(const std::string &user, NetworkPlugin *np, const std::string &suffix = "", QObject* parent = 0);
+	MyIrcSession(const std::string &user, IRCNetworkPlugin *np, const std::string &suffix = "", QObject* parent = 0);
 	std::map<std::string, bool> m_modes;
 	std::string suffix;
 	int rooms;
 	void addAutoJoinChannel(const std::string &channel, const std::string &password) {
 		m_autoJoin[channel] = boost::make_shared<AutoJoinChannel>(channel, password);
+	}
 	void removeAutoJoinChannel(const std::string &channel) {
 		m_autoJoin.erase(channel);
+	}
 	void setIdentify(const std::string &identify) {
 		m_identify = identify;
+	}
 	const std::string  &getIdentify() {
 		return m_identify;
+	}
 	bool correctNickname(std::string &nickname);
 	void on_joined(IrcMessage *message);
 	void on_parted(IrcMessage *message);
 	void on_quit(IrcMessage *message);
 	void on_nickChanged(IrcMessage *message);
 	void on_modeChanged(IrcMessage *message);
 	void on_topicChanged(IrcMessage *message);
 	void on_messageReceived(IrcMessage *message);
 	void on_numericMessageReceived(IrcMessage *message);
 protected Q_SLOTS:
 	void on_connected();
 	void on_disconnected();
 	void on_socketError(QAbstractSocket::SocketError error);
 	void onMessageReceived(IrcMessage* message);
 protected:
-	NetworkPlugin *np;
+	IRCNetworkPlugin *np;
 	std::string user;
 	std::string m_identify;
 	AutoJoinMap m_autoJoin;
 	std::string m_topicData;
 	bool m_connected;
 };
 //class MyIrcBuffer : public Irc::Buffer
 //{
 //    Q_OBJECT
 //public:
 //	MyIrcBuffer(const QString& receiver, const std::string &user, NetworkPlugin *np, const std::string &suffix, Irc::Session* parent);
 //	NetworkPlugin *np;
 //	std::string user;
 //	MyIrcSession *p;
 //	std::string m_topicData;
 //		std::string suffix;
 //protected Q_SLOTS:
 //    void on_receiverChanged(const QString& receiver);
 //    void on_joined(const QString& origin);
 //    void on_parted(const QString& origin, const QString& message);
 //    void on_quit(const QString& origin, const QString& message);
 //    void on_nickChanged(const QString& origin, const QString& nick);
 //    void on_modeChanged(const QString& origin, const QString& mode, const QString& args);
 //    void on_topicChanged(const QString& origin, const QString& topic);
 //    void on_invited(const QString& origin, const QString& receiver, const QString& channel);
 //    void on_kicked(const QString& origin, const QString& nick, const QString& message);
 //    void on_messageReceived(const QString& origin, const QString& message, Irc::Buffer::MessageFlags flags);
 //    void on_noticeReceived(const QString& origin, const QString& notice, Irc::Buffer::MessageFlags flags);
 //    void on_ctcpRequestReceived(const QString& origin, const QString& request, Irc::Buffer::MessageFlags flags);
 //    void on_ctcpReplyReceived(const QString& origin, const QString& reply, Irc::Buffer::MessageFlags flags);
 //    void on_ctcpActionReceived(const QString& origin, const QString& action, Irc::Buffer::MessageFlags flags);
 //    void on_numericMessageReceived(const QString& origin, uint code, const QStringList& params);
 //    void on_unknownMessageReceived(const QString& origin, const QStringList& params);
 //	bool correctNickname(std::string &nickname);
 //};
 #endif // SESSION_H

backends/libcommuni/singleircnetworkplugin.cpp

➞

Show inline comments

deleted file

backends/libcommuni/singleircnetworkplugin.h

➞

Show inline comments

deleted file

backends/libpurple/main.cpp

➞

Show inline comments

 #include "utils.h"
 #include "glib.h"
 // win32/libc_interface.h defines its own socket(), read() and so on.
 // We don't want to use it here.
 #define _LIBC_INTERFACE_H_ 1
 #include "purple.h"
 #include <algorithm>
 #include <iostream>
 #include "transport/networkplugin.h"
 #include "transport/logging.h"
 #include "transport/config.h"
 #include "transport/logging.h"
 #include "geventloop.h"
 // #include "valgrind/memcheck.h"
 #ifndef __FreeBSD__
 #include "malloc.h"
 #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;
 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;
+}
 static std::vector<std::string> split(const std::string &s, char delim) {
     std::vector<std::string> elems;
     return split(s, delim, elems);
+}
 static void transportDataReceived(gpointer data, gint source, PurpleInputCondition cond);
 class SpectrumNetworkPlugin;
 boost::shared_ptr<Config> config;
 SpectrumNetworkPlugin *np;
 static std::string host;
 static int port = 10000;
 struct FTData {
 	unsigned long id;
 	unsigned long timer;
 	bool paused;
 };
 static void *notify_user_info(PurpleConnection *gc, const char *who, PurpleNotifyUserInfo *user_info);
 static gboolean ft_ui_ready(void *data) {
 	PurpleXfer *xfer = (PurpleXfer *) data;
 	FTData *ftdata = (FTData *) xfer->ui_data;
 	ftdata->timer = 0;
 	purple_xfer_ui_ready_wrapped((PurpleXfer *) data);
 	return FALSE;
+}
 struct authRequest {
 	PurpleAccountRequestAuthorizationCb authorize_cb;
 	PurpleAccountRequestAuthorizationCb deny_cb;
 	void *user_data;
 	std::string who;
 	PurpleAccount *account;
 	std::string mainJID;	// JID of user connected with this request
 };
 static void * requestInput(const char *title, const char *primary,const char *secondary, const char *default_value, gboolean multiline, gboolean masked, gchar *hint,const char *ok_text, GCallback ok_cb,const char *cancel_text, GCallback cancel_cb, PurpleAccount *account, const char *who,PurpleConversation *conv, void *user_data) {
 	if (primary) {
 		std::string primaryString(primary);
 		if (primaryString == "Authorization Request Message:") {
 			LOG4CXX_INFO(logger, "Authorization Request Message: calling ok_cb(...)");
 			((PurpleRequestInputCb) ok_cb)(user_data, "Please authorize me.");
 			return NULL;
+		}
 		else if (primaryString == "Authorization Request Message:") {
 			LOG4CXX_INFO(logger, "Authorization Request Message: calling ok_cb(...)");
 			((PurpleRequestInputCb) ok_cb)(user_data, "Please authorize me.");
 			return NULL;
+		}
 		else if (primaryString == "Authorization Denied Message:") {
 			LOG4CXX_INFO(logger, "Authorization Deined Message: calling ok_cb(...)");
 			((PurpleRequestInputCb) ok_cb)(user_data, "Authorization denied.");
 			return NULL;
+		}
 		else {
 			LOG4CXX_WARN(logger, "Unhandled request input. primary=" << primaryString);
+		}
+	}
 	else if (title) {
 		std::string titleString(title);
 		if (titleString == "Xfire Invitation Message") {
 			LOG4CXX_INFO(logger, "Authorization Request Message: calling ok_cb(...)");
 			((PurpleRequestInputCb) ok_cb)(user_data, "Please authorize me.");
 			return NULL;
+		}
 		else {
 			LOG4CXX_WARN(logger, "Unhandled request input. title=" << titleString);
+		}
+	}
 	else {
 		LOG4CXX_WARN(logger, "Request input without primary string");
+	}
 	return NULL;
+}
 static void *requestAction(const char *title, const char *primary, const char *secondary, int default_action, PurpleAccount *account, const char *who,PurpleConversation *conv, void *user_data, size_t action_count, va_list actions){
 	std::string t(title ? title : "NULL");
 	if (t == "SSL Certificate Verification") {
 		LOG4CXX_INFO(logger,  "accepting SSL certificate");
 		va_arg(actions, char *);
 		((PurpleRequestActionCb) va_arg(actions, GCallback)) (user_data, 2);
+	}
 	else {
 		if (title) {
 			std::string headerString(title);
 			LOG4CXX_INFO(logger,  "header string: " << headerString);
 			if (headerString == "SSL Certificate Verification") {
 				va_arg(actions, char *);
 				((PurpleRequestActionCb) va_arg(actions, GCallback)) (user_data, 2);
+			}
+		}
+	}
 	return NULL;
+}
 static std::string getAlias(PurpleBuddy *m_buddy) {
 	std::string alias;
 	PurpleContact *contact = PURPLE_CONTACT(PURPLE_BLIST_NODE(m_buddy)->parent);
 	if (contact && contact->alias) {
 		alias = contact->alias;
+	}
 	else if (purple_buddy_get_alias_wrapped(m_buddy)) {
 		alias = (std::string) purple_buddy_get_alias_wrapped(m_buddy);
+	}
 	else {
 		alias = (std::string) purple_buddy_get_server_alias_wrapped(m_buddy);
+	}
 	return alias;
+}
 class SpectrumNetworkPlugin : public NetworkPlugin {
 	public:
 		SpectrumNetworkPlugin() : NetworkPlugin() {
+		}
 		void handleExitRequest() {
 			LOG4CXX_INFO(logger, "Exiting...");
 			exit(0);
+		}
 		void getProtocolAndName(const std::string &legacyName, std::string &name, std::string &protocol) {
 			name = legacyName;
 			protocol = CONFIG_STRING(config, "service.protocol");
 			if (protocol == "any") {
 				protocol = name.substr(0, name.find("."));
 				name = name.substr(name.find(".") + 1);
+			}
+		}
 		void setDefaultAvatar(PurpleAccount *account, const std::string &legacyName) {
 			char* contents;
 			gsize length;
 			gboolean ret = false;
 			if (!CONFIG_STRING(config, "backend.avatars_directory").empty()) {
 				std::string f = CONFIG_STRING(config, "backend.avatars_directory") + "/" + legacyName;
 				ret = g_file_get_contents (f.c_str(), &contents, &length, NULL);
+			}
 			if (!CONFIG_STRING(config, "backend.default_avatar").empty() && !ret) {
 				ret = g_file_get_contents (CONFIG_STRING(config, "backend.default_avatar").c_str(),
 											&contents, &length, NULL);
+			}
 			if (ret) {
 				purple_buddy_icons_set_account_icon_wrapped(account, (guchar *) contents, length);
+			}
+		}
 		void setDefaultAccountOptions(PurpleAccount *account) {
 			int i = 0;
 			Config::SectionValuesCont purpleConfigValues = config->getSectionValues("purple");
 			BOOST_FOREACH ( const Config::SectionValuesCont::value_type & keyItem, purpleConfigValues )
+			{
 				std::string key = keyItem.first;
 				std::string strippedKey = boost::erase_first_copy(key, "purple.");
 				if (strippedKey == "fb_api_key" || strippedKey == "fb_api_secret") {
 					purple_account_set_bool_wrapped(account, "auth_fb", TRUE);
+ 				}
 				PurplePlugin *plugin = purple_find_prpl_wrapped(purple_account_get_protocol_id_wrapped(account));
 				PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(plugin);
 				bool found = false;
 				for (GList *l = prpl_info->protocol_options; l != NULL; l = l->next) {
 					PurpleAccountOption *option = (PurpleAccountOption *) l->data;
 					PurplePrefType type = purple_account_option_get_type_wrapped(option);
 					std::string key2(purple_account_option_get_setting_wrapped(option));
 					if (strippedKey != key2) {
 						continue;
+					}
 					found = true;
 					switch (type) {
 						case PURPLE_PREF_BOOLEAN:
 							purple_account_set_bool_wrapped(account, strippedKey.c_str(), fromString<bool>(keyItem.second.as<std::string>()));
 							break;
 						case PURPLE_PREF_INT:
 							purple_account_set_int_wrapped(account, strippedKey.c_str(), fromString<int>(keyItem.second.as<std::string>()));
 							break;
 						case PURPLE_PREF_STRING:
 						case PURPLE_PREF_STRING_LIST:
 							purple_account_set_string_wrapped(account, strippedKey.c_str(), keyItem.second.as<std::string>().c_str());
 							break;
 						default:
 							continue;
+					}
 					break;
+				}
 				if (!found) {
 					purple_account_set_string_wrapped(account, strippedKey.c_str(), keyItem.second.as<std::string>().c_str());
+				}
 				i++;
+			}
 			char* contents;
 			gsize length;
 			gboolean ret = g_file_get_contents ("gfire.cfg", &contents, &length, NULL);
 			if (ret) {
 				purple_account_set_int_wrapped(account, "version", fromString<int>(std::string(contents, length)));
+			}
 			if (CONFIG_STRING(config, "service.protocol") == "prpl-novell") {
 				std::string username(purple_account_get_username_wrapped(account));
 				std::vector <std::string> u = split(username, '@');
 				purple_account_set_username_wrapped(account, (const char*) u.front().c_str());
 				std::vector <std::string> s = split(u.back(), ':');
 				purple_account_set_string_wrapped(account, "server", s.front().c_str());
 				purple_account_set_int_wrapped(account, "port", atoi(s.back().c_str()));
+			}
+		}
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 			PurpleAccount *account = NULL;
 			std::string name;
 			std::string protocol;
 			getProtocolAndName(legacyName, name, protocol);
 			if (password.empty()) {
 				LOG4CXX_INFO(logger,  name.c_str() << ": Empty password");
 				np->handleDisconnected(user, 0, "Empty password.");
 				return;
+			}
 			if (!purple_find_prpl_wrapped(protocol.c_str())) {
 				LOG4CXX_INFO(logger,  name.c_str() << ": Invalid protocol '" << protocol << "'");
 				np->handleDisconnected(user, 0, "Invalid protocol " + protocol);
 				return;
+			}
 			if (purple_accounts_find_wrapped(name.c_str(), protocol.c_str()) != NULL) {
 				account = purple_accounts_find_wrapped(name.c_str(), protocol.c_str());
 				if (m_accounts.find(account) != m_accounts.end() && m_accounts[account] != user) {
 					LOG4CXX_INFO(logger, "Account '" << name << "' is already used by '" << m_accounts[account] << "'");
 					np->handleDisconnected(user, 0, "Account '" + name + "' is already used by '" + m_accounts[account] + "'");
 					return;
+				}
 				LOG4CXX_INFO(logger, "Using previously created account with name '" << name.c_str() << "' and protocol '" << protocol << "'");
+			}
 			else {
 				LOG4CXX_INFO(logger, "Creating account with name '" << name.c_str() << "' and protocol '" << protocol << "'");
 				account = purple_account_new_wrapped(name.c_str(), protocol.c_str());
 				purple_accounts_add_wrapped(account);
+			}
 			m_sessions[user] = account;
 			m_accounts[account] = user;
 			// Default avatar
 			setDefaultAvatar(account, legacyName);
 			purple_account_set_password_wrapped(account, password.c_str());
 			purple_account_set_bool_wrapped(account, "custom_smileys", FALSE);
 			purple_account_set_bool_wrapped(account, "direct_connect", FALSE);
 			setDefaultAccountOptions(account);
 			// Enable account + privacy lists
 			purple_account_set_enabled_wrapped(account, "spectrum", TRUE);
 			if (CONFIG_BOOL(config, "service.enable_privacy_lists")) {
 				purple_account_set_privacy_type_wrapped(account, PURPLE_PRIVACY_DENY_USERS);
+			}
 			// Set the status
 			const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive_wrapped(account, PURPLE_STATUS_AVAILABLE);
 			if (status_type != NULL) {
 				purple_account_set_status_wrapped(account, purple_status_type_get_id_wrapped(status_type), TRUE, NULL);
+			}
+		}
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				if (purple_account_get_int_wrapped(account, "version", 0) != 0) {
 					std::string data = stringOf(purple_account_get_int_wrapped(account, "version", 0));
 					g_file_set_contents ("gfire.cfg", data.c_str(), data.size(), NULL);
+				}
 // 				VALGRIND_DO_LEAK_CHECK;
 				m_sessions.erase(user);
 				purple_account_disconnect_wrapped(account);
 				purple_account_set_enabled_wrapped(account, "spectrum", FALSE);
 				m_accounts.erase(account);
 				purple_accounts_delete_wrapped(account);
 #ifndef WIN32
 #ifndef __FreeBSD__
 				malloc_trim(0);
 #endif
 #endif
 // 				VALGRIND_DO_LEAK_CHECK;
+			}
+		}
 		void handleStatusChangeRequest(const std::string &user, int status, const std::string &statusMessage) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				int st;
 				switch(status) {
 					case pbnetwork::STATUS_AWAY: {
 						st = PURPLE_STATUS_AWAY;
 						if (!purple_account_get_status_type_with_primitive_wrapped(account, PURPLE_STATUS_AWAY))
 							st = PURPLE_STATUS_EXTENDED_AWAY;
 						else
 							st = PURPLE_STATUS_AWAY;
 						break;
+					}
 					case pbnetwork::STATUS_DND: {
 						st = PURPLE_STATUS_UNAVAILABLE;
 						break;
+					}
 					case pbnetwork::STATUS_XA: {
 						if (!purple_account_get_status_type_with_primitive_wrapped(account, PURPLE_STATUS_EXTENDED_AWAY))
 							st = PURPLE_STATUS_AWAY;
 						else
 							st = PURPLE_STATUS_EXTENDED_AWAY;
 						break;
+					}
 					case pbnetwork::STATUS_NONE: {
 						st = PURPLE_STATUS_OFFLINE;
 						break;
+					}
 					case pbnetwork::STATUS_INVISIBLE:
 						st = PURPLE_STATUS_INVISIBLE;
 						break;
 					default:
 						st = PURPLE_STATUS_AVAILABLE;
 						break;
+				}
 				gchar *_markup = purple_markup_escape_text_wrapped(statusMessage.c_str(), -1);
 				std::string markup(_markup);
 				g_free(_markup);
 				// we are already connected so we have to change status
 				const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive_wrapped(account, (PurpleStatusPrimitive) st);
 				if (status_type != NULL) {
 					// send presence to legacy network
 					if (!markup.empty()) {
 						purple_account_set_status_wrapped(account, purple_status_type_get_id_wrapped(status_type), TRUE, "message", markup.c_str(), NULL);
+					}
 					else {
 						purple_account_set_status_wrapped(account, purple_status_type_get_id_wrapped(status_type), TRUE, NULL);
+					}
+				}
+			}
+		}
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				PurpleConversation *conv = purple_find_conversation_with_account_wrapped(PURPLE_CONV_TYPE_CHAT, legacyName.c_str(), account);
 				if (!conv) {
 					conv = purple_find_conversation_with_account_wrapped(PURPLE_CONV_TYPE_IM, legacyName.c_str(), account);
 					if (!conv) {
 						conv = purple_conversation_new_wrapped(PURPLE_CONV_TYPE_IM, account, legacyName.c_str());
+					}
+				}
 				if (xhtml.empty()) {
 					gchar *_markup = purple_markup_escape_text_wrapped(message.c_str(), -1);
 					if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_IM) {
 						purple_conv_im_send_wrapped(PURPLE_CONV_IM_WRAPPED(conv), _markup);
+					}
 					else if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_CHAT) {
 						purple_conv_chat_send_wrapped(PURPLE_CONV_CHAT_WRAPPED(conv), _markup);
+					}
 					g_free(_markup);
+				}
 				else {
 					if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_IM) {
 						purple_conv_im_send_wrapped(PURPLE_CONV_IM_WRAPPED(conv), xhtml.c_str());
+					}
 					else if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_CHAT) {
 						purple_conv_chat_send_wrapped(PURPLE_CONV_CHAT_WRAPPED(conv), xhtml.c_str());
+					}
+				}
+			}
+		}
 		void handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				std::string name = legacyName;
 				if (CONFIG_STRING(config, "service.protocol") == "any" && legacyName.find("prpl-") == 0) {
 					name = name.substr(name.find(".") + 1);
+				}
 				m_vcards[user + name] = id;
 				if (CONFIG_BOOL(config, "backend.no_vcard_fetch") && name != purple_account_get_username_wrapped(account)) {
 					PurpleNotifyUserInfo *user_info = purple_notify_user_info_new_wrapped();
 					notify_user_info(purple_account_get_connection_wrapped(account), name.c_str(), user_info);
 					purple_notify_user_info_destroy_wrapped(user_info);
+				}
 				else {
 					serv_get_info_wrapped(purple_account_get_connection_wrapped(account), name.c_str());
+				}
+			}
+		}
 		void handleVCardUpdatedRequest(const std::string &user, const std::string &image, const std::string &nickname) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				purple_account_set_alias_wrapped(account, nickname.c_str());
 				purple_account_set_public_alias_wrapped(account, nickname.c_str(), NULL, NULL);
 				gssize size = image.size();
 				// this will be freed by libpurple
 				guchar *photo = (guchar *) g_malloc(size * sizeof(guchar));
 				memcpy(photo, image.c_str(), size);
 				if (!photo)
 					return;
 				purple_buddy_icons_set_account_icon_wrapped(account, photo, size);
+			}
+		}
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				if (m_authRequests.find(user + buddyName) != m_authRequests.end()) {
 					m_authRequests[user + buddyName]->deny_cb(m_authRequests[user + buddyName]->user_data);
 					m_authRequests.erase(user + buddyName);
+				}
 				PurpleBuddy *buddy = purple_find_buddy_wrapped(account, buddyName.c_str());
 				if (buddy) {
 					purple_account_remove_buddy_wrapped(account, buddy, purple_buddy_get_group_wrapped(buddy));
 					purple_blist_remove_buddy_wrapped(buddy);
+				}
+			}
+		}
 		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups_) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				std::string groups = groups_.empty() ? "" : groups_[0];
 				if (m_authRequests.find(user + buddyName) != m_authRequests.end()) {
 					m_authRequests[user + buddyName]->authorize_cb(m_authRequests[user + buddyName]->user_data);
 					m_authRequests.erase(user + buddyName);
+				}
 				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);
+				}
+			}
+		}
 		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);
+					}
+				}
+			}
+		}
@@ @@ -1270,432 +1274,436 @@ static void fileRecvStart(PurpleXfer *xfer) { @@
 // 	FiletransferRepeater *repeater = (FiletransferRepeater *) xfer->ui_data;
 // 	repeater->fileRecvStart();
 	FTData *ftData = (FTData *) xfer->ui_data;
 	if (ftData->timer == 0) {
 		ftData->timer = purple_timeout_add_wrapped(1, ft_ui_ready, xfer);
+	}
+}
 static void newXfer(PurpleXfer *xfer) {
 	PurpleAccount *account = purple_xfer_get_account_wrapped(xfer);
 	std::string filename(xfer ? purple_xfer_get_filename_wrapped(xfer) : "");
 	purple_xfer_ref_wrapped(xfer);
 	std::string w = xfer->who;
 	size_t pos = w.find("/");
 	if (pos != std::string::npos)
 		w.erase((int) pos, w.length() - (int) pos);
 	FTData *ftdata = new FTData;
 	ftdata->paused = false;
 	ftdata->id = 0;
 	ftdata->timer = 0;
 	xfer->ui_data = (void *) ftdata;
 	np->m_unhandledXfers[np->m_accounts[account] + filename + w] = xfer;
 	np->handleFTStart(np->m_accounts[account], w, filename, purple_xfer_get_size_wrapped(xfer));
+}
 static void XferReceiveComplete(PurpleXfer *xfer) {
 // 	FiletransferRepeater *repeater = (FiletransferRepeater *) xfer->ui_data;
 // 	repeater->_tryToDeleteMe();
 // 	GlooxMessageHandler::instance()->ftManager->handleXferFileReceiveComplete(xfer);
 	std::remove(np->m_waitingXfers.begin(), np->m_waitingXfers.end(), xfer);
 	FTData *ftdata = (FTData *) xfer->ui_data;
 	if (ftdata && ftdata->timer) {
 		purple_timeout_remove_wrapped(ftdata->timer);
+	}
 	purple_xfer_unref_wrapped(xfer);
+}
 static void XferSendComplete(PurpleXfer *xfer) {
 // 	FiletransferRepeater *repeater = (FiletransferRepeater *) xfer->ui_data;
 // 	repeater->_tryToDeleteMe();
 	std::remove(np->m_waitingXfers.begin(), np->m_waitingXfers.end(), xfer);
 	FTData *ftdata = (FTData *) xfer->ui_data;
 	if (ftdata && ftdata->timer) {
 		purple_timeout_remove_wrapped(ftdata->timer);
+	}
 	purple_xfer_unref_wrapped(xfer);
+}
 static gssize XferWrite(PurpleXfer *xfer, const guchar *buffer, gssize size) {
 	FTData *ftData = (FTData *) xfer->ui_data;
 	std::string data((const char *) buffer, (size_t) size);
 // 	std::cout << "xferwrite\n";
 	if (!ftData->paused) {
 // 		std::cout << "adding xfer to waitingXfers queue\n";
 		np->m_waitingXfers.push_back(xfer);
+	}
 	np->handleFTData(ftData->id, data);
 	return size;
+}
 static void XferNotSent(PurpleXfer *xfer, const guchar *buffer, gsize size) {
 // 	FiletransferRepeater *repeater = (FiletransferRepeater *) xfer->ui_data;
 // 	repeater->handleDataNotSent(buffer, size);
+}
 static gssize XferRead(PurpleXfer *xfer, guchar **buffer, gssize size) {
 // 	FiletransferRepeater *repeater = (FiletransferRepeater *) xfer->ui_data;
 // 	int data_size = repeater->getDataToSend(buffer, size);
 // 	if (data_size == 0)
 // 		return 0;
 //
 // 	return data_size;
 	return 0;
+}
 static PurpleXferUiOps xferUiOps =
+{
 	XferCreated,
 	XferDestroyed,
 	NULL,
 	NULL,
 	xferCanceled,
 	xferCanceled,
 	XferWrite,
 	XferRead,
 	XferNotSent,
 	NULL
 };
 static void transport_core_ui_init(void)
+{
 	purple_blist_set_ui_ops_wrapped(&blistUiOps);
 	purple_accounts_set_ui_ops_wrapped(&accountUiOps);
 	purple_notify_set_ui_ops_wrapped(&notifyUiOps);
 	purple_request_set_ui_ops_wrapped(&requestUiOps);
 	purple_xfers_set_ui_ops_wrapped(&xferUiOps);
 	purple_connections_set_ui_ops_wrapped(&conn_ui_ops);
 	purple_conversations_set_ui_ops_wrapped(&conversation_ui_ops);
 // #ifndef WIN32
 // 	purple_dnsquery_set_ui_ops_wrapped(getDNSUiOps());
 // #endif
+}
 /***** Core Ui Ops *****/
 static void
 spectrum_glib_log_handler(const gchar *domain,
 						  GLogLevelFlags flags,
 						  const gchar *message,
 						  gpointer user_data)
+{
 	const char *level;
 	char *new_msg = NULL;
 	char *new_domain = NULL;
 	if ((flags & G_LOG_LEVEL_ERROR) == G_LOG_LEVEL_ERROR)
 		level = "ERROR";
 	else if ((flags & G_LOG_LEVEL_CRITICAL) == G_LOG_LEVEL_CRITICAL)
 		level = "CRITICAL";
 	else if ((flags & G_LOG_LEVEL_WARNING) == G_LOG_LEVEL_WARNING)
 		level = "WARNING";
 	else if ((flags & G_LOG_LEVEL_MESSAGE) == G_LOG_LEVEL_MESSAGE)
 		level = "MESSAGE";
 	else if ((flags & G_LOG_LEVEL_INFO) == G_LOG_LEVEL_INFO)
 		level = "INFO";
 	else if ((flags & G_LOG_LEVEL_DEBUG) == G_LOG_LEVEL_DEBUG)
 		level = "DEBUG";
 	else {
 		LOG4CXX_ERROR(logger, "Unknown glib logging level in " << (guint)flags);
 		level = "UNKNOWN"; /* This will never happen. */
+	}
 	if (message != NULL)
 		new_msg = purple_utf8_try_convert_wrapped(message);
 	if (domain != NULL)
 		new_domain = purple_utf8_try_convert_wrapped(domain);
 	if (new_msg != NULL) {
 		std::string area("glib");
 		area.push_back('/');
 		area.append(level);
 		std::string message(new_domain ? new_domain : "g_log");
 		message.push_back(' ');
 		message.append(new_msg);
 		LOG4CXX_ERROR(logger, message);
 		g_free(new_msg);
+	}
 	g_free(new_domain);
+}
 static void
 debug_init(void)
+{
 #define REGISTER_G_LOG_HANDLER(name) \
 	g_log_set_handler((name), \
 		(GLogLevelFlags)(G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL \
 										  | G_LOG_FLAG_RECURSION), \
 					  spectrum_glib_log_handler, NULL)
 	REGISTER_G_LOG_HANDLER(NULL);
 	REGISTER_G_LOG_HANDLER("GLib");
 	REGISTER_G_LOG_HANDLER("GModule");
 	REGISTER_G_LOG_HANDLER("GLib-GObject");
 	REGISTER_G_LOG_HANDLER("GThread");
 	REGISTER_G_LOG_HANDLER("GConf");
 #undef REGISTER_G_LOD_HANDLER
+}
 static PurpleCoreUiOps coreUiOps =
+{
 	NULL,
 	debug_init,
 	transport_core_ui_init,
 	NULL,
 	spectrum_ui_get_info,
 	NULL,
 	NULL,
 	NULL
 };
 static void signed_on(PurpleConnection *gc, gpointer unused) {
 	PurpleAccount *account = purple_connection_get_account_wrapped(gc);
 	np->handleConnected(np->m_accounts[account]);
 #ifndef WIN32
 #ifndef __FreeBSD__
 	// force returning of memory chunks allocated by libxml2 to kernel
 	malloc_trim(0);
 #endif
 #endif
 	// For prpl-gg
 	execute_purple_plugin_action(gc, "Download buddylist from Server");
+}
 static void printDebug(PurpleDebugLevel level, const char *category, const char *arg_s) {
 	std::string c("");
 	std::string args(arg_s);
 	args.erase(args.size() - 1);
 	if (category) {
 		c.append(category);
+	}
 	c.push_back(':');
 	LOG4CXX_INFO(logger_libpurple, c << args);
+}
 /*
  * Ops....
  */
 static PurpleDebugUiOps debugUiOps =
+{
 	printDebug,
 	NULL,
 	NULL,
 	NULL,
 	NULL,
 	NULL
 };
 static void buddyTyping(PurpleAccount *account, const char *who, gpointer null) {
 	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->handleBuddyTyping(np->m_accounts[account], w);
+}
 static void buddyTyped(PurpleAccount *account, const char *who, gpointer null) {
 	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->handleBuddyTyped(np->m_accounts[account], w);
+}
 static void buddyTypingStopped(PurpleAccount *account, const char *who, gpointer null){
 	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->handleBuddyStoppedTyping(np->m_accounts[account], w);
+}
 static void gotAttention(PurpleAccount *account, const char *who, PurpleConversation *conv, guint type) {
 	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->handleAttention(np->m_accounts[account], w, "");
+}
 static bool initPurple() {
 	bool ret;
 	std::string libPurpleDllPath = CONFIG_STRING_DEFAULTED(config, "purple.libpurple_dll_path", "");
 	if (!resolvePurpleFunctions(libPurpleDllPath)) {
 		LOG4CXX_ERROR(logger, "Unable to load libpurple.dll or some of the needed methods");
 		return false;
+	}
 	std::string pluginsDir = CONFIG_STRING_DEFAULTED(config, "purple.plugins_dir", "./plugins");
 	LOG4CXX_INFO(logger, "Setting libpurple plugins directory to: " << pluginsDir);
 	purple_plugins_add_search_path_wrapped(pluginsDir.c_str());
 	std::string cacertsDir = CONFIG_STRING_DEFAULTED(config, "purple.cacerts_dir", "./ca-certs");
 	LOG4CXX_INFO(logger, "Setting libpurple cacerts directory to: " << cacertsDir);
 	purple_certificate_add_ca_search_path_wrapped(cacertsDir.c_str());
 	std::string userDir = CONFIG_STRING_DEFAULTED(config, "service.working_dir", "./");
 	LOG4CXX_INFO(logger, "Setting libpurple user directory to: " << userDir);
 	purple_util_set_user_dir_wrapped(userDir.c_str());
 	remove("./accounts.xml");
 	remove("./blist.xml");
 	purple_debug_set_ui_ops_wrapped(&debugUiOps);
 	purple_debug_set_verbose_wrapped(true);
 	purple_core_set_ui_ops_wrapped(&coreUiOps);
 	if (CONFIG_STRING_DEFAULTED(config, "service.eventloop", "") == "libev") {
 		LOG4CXX_INFO(logger, "Will use libev based event loop");
+	}
 	else {
 		LOG4CXX_INFO(logger, "Will use glib based event loop");
+	}
 	purple_eventloop_set_ui_ops_wrapped(getEventLoopUiOps(CONFIG_STRING_DEFAULTED(config, "service.eventloop", "") == "libev"));
 	ret = purple_core_init_wrapped("spectrum");
 	if (ret) {
 		static int blist_handle;
 		static int conversation_handle;
 		purple_set_blist_wrapped(purple_blist_new_wrapped());
 		purple_blist_load_wrapped();
 		purple_prefs_load_wrapped();
 		/* Good default preferences */
 		/* The combination of these two settings mean that libpurple will never
 		 * (of its own accord) set all the user accounts idle.
 		 */
 		purple_prefs_set_bool_wrapped("/purple/away/away_when_idle", false);
 		/*
 		 * This must be set to something not "none" for idle reporting to work
 		 * for, e.g., the OSCAR prpl. We don't implement the UI ops, so this is
 		 * okay for now.
 		 */
 		purple_prefs_set_string_wrapped("/purple/away/idle_reporting", "system");
 		/* Disable all logging */
 		purple_prefs_set_bool_wrapped("/purple/logging/log_ims", false);
 		purple_prefs_set_bool_wrapped("/purple/logging/log_chats", false);
 		purple_prefs_set_bool_wrapped("/purple/logging/log_system", false);
 // 		purple_signal_connect_wrapped(purple_conversations_get_handle_wrapped(), "received-im-msg", &conversation_handle, PURPLE_CALLBACK(newMessageReceived), NULL);
 		purple_signal_connect_wrapped(purple_conversations_get_handle_wrapped(), "buddy-typing", &conversation_handle, PURPLE_CALLBACK(buddyTyping), NULL);
 		purple_signal_connect_wrapped(purple_conversations_get_handle_wrapped(), "buddy-typed", &conversation_handle, PURPLE_CALLBACK(buddyTyped), NULL);
 		purple_signal_connect_wrapped(purple_conversations_get_handle_wrapped(), "buddy-typing-stopped", &conversation_handle, PURPLE_CALLBACK(buddyTypingStopped), NULL);
 		purple_signal_connect_wrapped(purple_blist_get_handle_wrapped(), "buddy-privacy-changed", &conversation_handle, PURPLE_CALLBACK(buddyPrivacyChanged), NULL);
 		purple_signal_connect_wrapped(purple_conversations_get_handle_wrapped(), "got-attention", &conversation_handle, PURPLE_CALLBACK(gotAttention), NULL);
 		purple_signal_connect_wrapped(purple_connections_get_handle_wrapped(), "signed-on", &blist_handle,PURPLE_CALLBACK(signed_on), NULL);
 // 		purple_signal_connect_wrapped(purple_blist_get_handle_wrapped(), "buddy-removed", &blist_handle,PURPLE_CALLBACK(buddyRemoved), NULL);
 // 		purple_signal_connect_wrapped(purple_blist_get_handle_wrapped(), "buddy-signed-on", &blist_handle,PURPLE_CALLBACK(buddySignedOn), NULL);
 // 		purple_signal_connect_wrapped(purple_blist_get_handle_wrapped(), "buddy-signed-off", &blist_handle,PURPLE_CALLBACK(buddySignedOff), NULL);
 // 		purple_signal_connect_wrapped(purple_blist_get_handle_wrapped(), "buddy-status-changed", &blist_handle,PURPLE_CALLBACK(buddyStatusChanged), NULL);
 		purple_signal_connect_wrapped(purple_blist_get_handle_wrapped(), "blist-node-removed", &blist_handle,PURPLE_CALLBACK(NodeRemoved), NULL);
 // 		purple_signal_connect_wrapped(purple_conversations_get_handle_wrapped(), "chat-topic-changed", &conversation_handle, PURPLE_CALLBACK(conv_chat_topic_changed), NULL);
 		static int xfer_handle;
 		purple_signal_connect_wrapped(purple_xfers_get_handle_wrapped(), "file-send-start", &xfer_handle, PURPLE_CALLBACK(fileSendStart), NULL);
 		purple_signal_connect_wrapped(purple_xfers_get_handle_wrapped(), "file-recv-start", &xfer_handle, PURPLE_CALLBACK(fileRecvStart), NULL);
 		purple_signal_connect_wrapped(purple_xfers_get_handle_wrapped(), "file-recv-request", &xfer_handle, PURPLE_CALLBACK(newXfer), NULL);
 		purple_signal_connect_wrapped(purple_xfers_get_handle_wrapped(), "file-recv-complete", &xfer_handle, PURPLE_CALLBACK(XferReceiveComplete), NULL);
 		purple_signal_connect_wrapped(purple_xfers_get_handle_wrapped(), "file-send-complete", &xfer_handle, PURPLE_CALLBACK(XferSendComplete), NULL);
 //
 // 		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);
 		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;
+		}
 #endif
 	std::string error;
 	Config *cfg = Config::createFromArgs(argc, argv, error, host, port);
 	if (cfg == NULL) {
 		std::cerr << error;
 		return 1;
+	}
 	config = boost::shared_ptr<Config>(cfg);
 	Logging::initBackendLogging(config.get());
 	initPurple();
 	main_socket = create_socket(host.c_str(), port);
 	purple_input_add_wrapped(main_socket, PURPLE_INPUT_READ, &transportDataReceived, NULL);
 	purple_timeout_add_seconds_wrapped(30, pingTimeout, NULL);
 	np = new SpectrumNetworkPlugin();
 	bool libev = CONFIG_STRING_DEFAULTED(config, "service.eventloop", "") == "libev";
 	GMainLoop *m_loop;
 #ifdef WITH_LIBEVENT
 	if (!libev) {
 		m_loop = g_main_loop_new(NULL, FALSE);
+	}
 	else {
 		event_init();
+	}
 #endif
 	m_loop = g_main_loop_new(NULL, FALSE);
 	if (m_loop) {
 		g_main_loop_run(m_loop);
+	}
 #ifdef WITH_LIBEVENT
 	else {
 		event_loop(0);
+	}
 #endif
 	return 0;
+}

backends/twitter/userdb.cpp

➞

Show inline comments

deleted file

backends/twitter/userdb.h

➞

Show inline comments

deleted file

include/transport/config.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 <boost/program_options.hpp>
 #include <boost/foreach.hpp>
 #include <boost/format.hpp>
 #include <boost/algorithm/string.hpp>
 #include <boost/assign.hpp>
 #include <boost/bind.hpp>
 #include <boost/signal.hpp>
 namespace Transport {
 template <class myType>
 const myType &safeAs(const boost::program_options::variable_value &var, const myType &def) {
 	try  {
 		return var.as<myType>();
+	}
 	catch(...) {
 		return def;
+	}
+}
+}
 #define CONFIG_HAS_KEY(PTR, KEY) (*PTR).hasKey(KEY)
 #define CONFIG_STRING(PTR, KEY) (*PTR)[KEY].as<std::string>()
 #define CONFIG_INT(PTR, KEY) (*PTR)[KEY].as<int>()
 #define CONFIG_BOOL(PTR, KEY) (*PTR)[KEY].as<bool>()
 #define CONFIG_LIST(PTR, KEY) (*PTR)[KEY].as<std::list<std::string> >()
 #define CONFIG_VECTOR(PTR, KEY) ((*PTR).hasKey(KEY) ? (*PTR)[KEY].as<std::vector<std::string> >() : std::vector<std::string>())
 #define CONFIG_STRING_DEFAULTED(PTR, KEY, DEF) ((*PTR).hasKey(KEY) ? (*PTR)[KEY].as<std::string>() : DEF)
 #define CONFIG_BOOL_DEFAULTED(PTR, KEY, DEF) ((*PTR).hasKey(KEY) ? (*PTR)[KEY].as<bool>() : DEF)
 #define CONFIG_STRING_DEFAULTED(PTR, KEY, DEF) ((*PTR).hasKey(KEY) ? Transport::safeAs<std::string>((*PTR)[KEY], DEF) : DEF)
 #define CONFIG_BOOL_DEFAULTED(PTR, KEY, DEF) ((*PTR).hasKey(KEY) ? Transport::safeAs<bool>((*PTR)[KEY], DEF) : DEF)
 #define CONFIG_LIST_DEFAULTED(PTR, KEY, DEF) ((*PTR).hasKey(KEY) ? Transport::safeAs<std::list<std::string> >((*PTR)[KEY], DEF) : DEF)
 namespace Transport {
 /// Represents variable:value pairs.
 typedef boost::program_options::variables_map Variables;
 /// Represents config file.
 /// It's used to load config file and allows others parts of libtransport to be configured
 /// properly. Config files are text files which use "ini" format. Variables are divided into multiple
 /// sections. Every class is configurable with some variables which change its behavior. Check particular
 /// class documentation to get a list of all relevant variables for that class.
 class Config {
 	public:
 		typedef std::map<std::string, boost::program_options::variable_value> SectionValuesCont;
 		typedef std::map<std::string, boost::program_options::variable_value> UnregisteredCont;
 		/// Constructor.
 		Config(int argc = 0, char **argv = NULL) : m_argc(argc), m_argv(argv) {}
 		/// Destructor
 		virtual ~Config() {}
 		/// Loads data from config file.
 		/// You can pass your extra options which will be recognized by
 		/// the parser using opts parameter.
 		/// \param configfile path to config file
 		/// \param opts extra options which will be recognized by a parser
 		bool load(const std::string &configfile, boost::program_options::options_description &opts, const std::string &jid = "");
 		bool load(std::istream &ifs, boost::program_options::options_description &opts, const std::string &jid = "");
 		bool load(std::istream &ifs);
 		/// Loads data from config file.
 		/// This function loads only config variables needed by libtransport.
 		/// \see load(const std::string &, boost::program_options::options_description &)
 		/// \param configfile path to config file
 		bool load(const std::string &configfile, const std::string &jid = "");
 		bool reload();
 		bool hasKey(const std::string &key) {
 			return (m_variables.find(key) != m_variables.end() || m_unregistered.find(key) != m_unregistered.end()
 					|| m_backendConfig.find(key) != m_backendConfig.end());
+		}
 		/// Returns value of variable defined by key.
 		/// For variables in sections you can use "section.variable" key format.
 		/// \param key config variable name
 		const boost::program_options::variable_value &operator[] (const std::string &key) {
 			if (m_variables.find(key) != m_variables.end()) {
 				return m_variables[key];
+			}
 			if (m_backendConfig.find(key) != m_backendConfig.end()) {
 				return m_backendConfig[key];
+			}
 			return m_unregistered[key];
+		}
 		SectionValuesCont getSectionValues(const std::string& sectionName);
 		std::string getCommandLineArgs() const;
 		/// Returns path to config file from which data were loaded.
 		const std::string &getConfigFile() { return m_file; }
 		/// This signal is emitted when config is loaded/reloaded.
 		boost::signal<void ()> onConfigReloaded;
 		void updateBackendConfig(const std::string &backendConfig);
 		static Config *createFromArgs(int argc, char **argv, std::string &error, std::string &host, int &port);
 	private:
 		int m_argc;
 		char **m_argv;
 		Variables m_variables;
 		Variables m_backendConfig;
 		std::map<std::string, boost::program_options::variable_value> m_unregistered;
 		std::string m_file;
 		std::string m_jid;
 };
+}

include/transport/conversation.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 "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 struct _Participant {
 			int 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 = "");
 		/// 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 removeJID(const Swift::JID &jid) {
 			m_jids.remove(jid);
+		}
 		const std::list<Swift::JID> &getJIDs() {
 			return m_jids;
+		}
 		/// Sends message to Legacy network.
 		/// \param message Message.
 		virtual void sendMessage(boost::shared_ptr<Swift::Message> &message) = 0;
 		/// Returns ConversationManager associated with this Conversation.
 		/// \return  ConversationManager associated with this Conversation.
 		ConversationManager *getConversationManager() {
 			return m_conversationManager;
+		}
 		/// Returns True if this conversation is MUC room.
 		/// \return  True if this conversation is MUC room.
 		bool isMUC() {
 			return m_muc;
+		}
 		/// Sets room name associated with this Conversation.
 		/// This is used to detect Private messages associated with particular room.
 		/// \param room room name associated with this Conversation.
 		void setRoom(const std::string &room);
 		/// Returns room name associated with this Conversation.
 		/// \return room name associated with this Conversation.
 		const std::string &getRoom() {
 			return m_room;
+		}
 		void destroyRoom();
 		void sendParticipants(const Swift::JID &to);
 	private:
 		Swift::Presence::ref generatePresence(const std::string &nick, int flag, int status, const std::string &statusMessage, const std::string &newname = "");
 	private:
 		ConversationManager *m_conversationManager;
 		std::string m_legacyName;
 		std::string m_nickname;
 		std::string m_room;
 		bool m_muc;
 		Swift::JID m_jid;
 		std::list<Swift::JID> m_jids;
 		std::map<std::string, Participant> m_participants;
 };
+}

include/transport/conversationmanager.h

➞

Show inline comments

 /**
  * XMPP - libpurple transport
+ *
  * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <string>
 #include <algorithm>
 #include <map>
 #include "Swiften/Swiften.h"
 namespace Transport {
 class Conversation;
 class User;
 class Component;
 /// 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; }
 		/// Returns component associated with this ConversationManager.
 		/// \return component associated with this ConversationManager.
 		Component *getComponent() { return m_component; }
 		/// Returns Conversation by its legacy network name (for example by UIN in case of ICQ).
 		/// \param name legacy network name.
 		/// \return Conversation or NULL.
 		Conversation *getConversation(const std::string &name);
 		/// Adds new Conversation to the manager.
 		/// \param conv Conversation.
 		void addConversation(Conversation *conv);
 		/// Removes Conversation from the manager.
 		/// \param conv Conversation.
 		void removeConversation(Conversation *conv);
 		void resetResources();
 		void removeJID(const Swift::JID &jid);
 	private:
 		void handleMessageReceived(Swift::Message::ref message);
 		Component *m_component;
 		User *m_user;
 		std::map<std::string, Conversation *> m_convs;
 		friend class UserManager;
 };
+}

include/transport/networkplugin.h

➞

Show inline comments

@@ @@ -29,246 +29,248 @@ 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:
 		class PluginConfig {
 			public:
 				PluginConfig() : m_needPassword(true), m_needRegistration(false) {}
 				virtual ~PluginConfig() {}
 				void setNeedRegistration(bool needRegistration = false) { m_needRegistration = needRegistration; }
 				void setNeedPassword(bool needPassword = true) { m_needPassword = needPassword; }
 				void setExtraFields(const std::vector<std::string> &fields) { m_extraFields = fields; }
 			private:
 				bool m_needPassword;
 				bool m_needRegistration;
 				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.
 		/// \param blocked True if this buddy is blocked in privacy lists in legacy network.
 		void handleBuddyChanged(const std::string &user, const std::string &buddyName, const std::string &alias,
 			const std::vector<std::string> &groups, pbnetwork::StatusType status, const std::string &statusMessage = "", const std::string &iconHash = "",
 			bool blocked = false
 		);
 		/// Call this method when buddy is removed from legacy network contact list.
 		/// \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")
 		void handleBuddyRemoved(const std::string &user, const std::string &buddyName);
 		/// Call this function when participant in room changed.
 		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")
 		/// \param nickname Nickname of participant. If participant renamed, this is old name of participant. (eg. "HanzZ")
 		/// \param room Room in which participant changed. (eg. #spectrum)
 		/// \param flags Participant flags.
 		/// \param status Current status of participant. Swift::StatusShow::None if participant left the room.
 		/// \param statusMessage Current status message of participant.
 		/// \param newname New name of participant if he changed the nickname. Otherwise empty.
 		void handleParticipantChanged(const std::string &user, const std::string &nickname, const std::string &room, int flags,
 			pbnetwork::StatusType = pbnetwork::STATUS_NONE, const std::string &statusMessage = "", const std::string &newname = "");
 		/// Call this function when user disconnected the legacy network because of some legacy network error.
 		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")
 		/// \param error Reserved for future use, currently keep it on 0.
 		/// \param message XMPP message which is sent to XMPP user.
 		void handleDisconnected(const std::string &user, int error = 0, const std::string &message = "");
 		/// Call this function when user connected the legacy network and is logged in.
 		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")
 		void handleConnected(const std::string &user);
 		/// Call this function when new message is received from legacy network for user.
 		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")
 		/// \param legacyName Name of legacy network buddy or name of room. (eg. "user2@gmail.com")
 		/// \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 = "");
 		/// 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);
 		/// Call this function when buddy started typing.
 		/// \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")
 		void handleBuddyTyping(const std::string &user, const std::string &buddyName);
 		/// Call this function when buddy typed, but is not typing anymore.
 		/// \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")
 		void handleBuddyTyped(const std::string &user, const std::string &buddyName);
 		/// Call this function when buddy has been typing, but paused for a while.
 		/// \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")
 		void handleBuddyStoppedTyping(const std::string &user, const std::string &buddyName);
 		/// Call this function when new authorization request arrived form legacy network
 		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")
 		/// \param buddyName Name of legacy network buddy. (eg. "user2@gmail.com")
 		void handleAuthorization(const std::string &user, const std::string &buddyName);
 		/// Call this function when attention request arrived from legacy network.
 		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")
 		/// \param buddyName Name of legacy network buddy. (eg. "user2@gmail.com")
 		/// \param message Message.
 		void handleAttention(const std::string &user, const std::string &buddyName, const std::string &message);
 		void handleFTStart(const std::string &user, const std::string &buddyName, const std::string fileName, unsigned long size);
 		void handleFTFinish(const std::string &user, const std::string &buddyName, const std::string fileName, unsigned long size, unsigned long ftid);
 		void handleFTData(unsigned long ftID, const std::string &data);
 		/// Called when XMPP user wants to connect legacy network.
 		/// You should connect him to legacy network and call handleConnected or handleDisconnected function later.
 		/// \param user XMPP JID of user for which this event occurs.
 		/// \param legacyName Legacy network name of this user used for login.
 		/// \param password Legacy network password of this user.
 		/**
 			\msc
 			NetworkPlugin,YourNetworkPlugin,LegacyNetwork;
 			NetworkPlugin->YourNetworkPlugin [label="handleLoginRequest(...)", URL="\ref NetworkPlugin::handleLoginRequest()"];
 			YourNetworkPlugin->LegacyNetwork [label="connect the legacy network"];
 			--- [label="If password was valid and user is connected and logged in"];
 			YourNetworkPlugin<-LegacyNetwork [label="connected"];
 			YourNetworkPlugin->NetworkPlugin [label="handleConnected()", URL="\ref NetworkPlugin::handleConnected()"];
 			--- [label="else"];
 			YourNetworkPlugin<-LegacyNetwork [label="disconnected"];
 			YourNetworkPlugin->NetworkPlugin [label="handleDisconnected()", URL="\ref NetworkPlugin::handleDisconnected()"];
 			\endmsc
 		*/
 		virtual void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) = 0;
 		/// Called when XMPP user wants to disconnect legacy network.
 		/// You should disconnect him from legacy network.
 		/// \param user XMPP JID of user for which this event occurs.
 		/// \param legacyName Legacy network name of this user used for login.
 		virtual void handleLogoutRequest(const std::string &user, const std::string &legacyName) = 0;
 		/// Called when XMPP user sends message to legacy network.
 		/// \param user XMPP JID of user for which this event occurs.
 		/// \param legacyName Legacy network name of buddy or room.
 		/// \param message Plain text message.
 		/// \param xhtml XHTML message.
 		virtual void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml = "") = 0;
 		/// Called when XMPP user requests VCard of buddy.
 		/// \param user XMPP JID of user for which this event occurs.
 		/// \param legacyName Legacy network name of buddy whose VCard is requested.
 		/// \param id ID which is associated with this request. You have to pass it to handleVCard function when you receive VCard.
 		/**
 			\msc
 			NetworkPlugin,YourNetworkPlugin,LegacyNetwork;
 			NetworkPlugin->YourNetworkPlugin [label="handleVCardRequest(...)", URL="\ref NetworkPlugin::handleVCardRequest()"];
 			YourNetworkPlugin->LegacyNetwork [label="start VCard fetching"];
 			YourNetworkPlugin<-LegacyNetwork [label="VCard fetched"];
 			YourNetworkPlugin->NetworkPlugin [label="handleVCard()", URL="\ref NetworkPlugin::handleVCard()"];
 			\endmsc
 		*/
 		virtual void handleVCardRequest(const std::string &/*user*/, const std::string &/*legacyName*/, unsigned int /*id*/) {}
 		/// Called when XMPP user updates his own VCard.
 		/// You should update the VCard in legacy network too.
 		/// \param user XMPP JID of user for which this event occurs.
 		/// \param photo Raw photo data.
 		virtual void handleVCardUpdatedRequest(const std::string &/*user*/, const std::string &/*photo*/, const std::string &nickname) {}
 		virtual void handleRoomSubjectChangedRequest(const std::string &/*user*/, const std::string &/*room*/, const std::string &/*message*/) {}
 		virtual void handleJoinRoomRequest(const std::string &/*user*/, const std::string &/*room*/, const std::string &/*nickname*/, const std::string &/*pasword*/) {}
 		virtual void handleLeaveRoomRequest(const std::string &/*user*/, const std::string &/*room*/) {}
 		virtual void handleStatusChangeRequest(const std::string &/*user*/, int status, const std::string &statusMessage) {}
 		virtual void handleBuddyUpdatedRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::string &/*alias*/, const std::vector<std::string> &/*groups*/) {}
 		virtual void handleBuddyRemovedRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::vector<std::string> &/*groups*/) {}
 		virtual void handleBuddyBlockToggled(const std::string &/*user*/, const std::string &/*buddyName*/, bool /*blocked*/) {}
 		virtual void handleTypingRequest(const std::string &/*user*/, const std::string &/*buddyName*/) {}
 		virtual void handleTypedRequest(const std::string &/*user*/, const std::string &/*buddyName*/) {}
 		virtual void handleStoppedTypingRequest(const std::string &/*user*/, const std::string &/*buddyName*/) {}
 		virtual void handleAttentionRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::string &/*message*/) {}
 		virtual void handleFTStartRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::string &/*fileName*/, unsigned long size, unsigned long ftID) {}
 		virtual void handleFTFinishRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::string &/*fileName*/, unsigned long size, unsigned long ftID) {}
 		virtual void handleFTPauseRequest(unsigned long ftID) {}
 		virtual void handleFTContinueRequest(unsigned long ftID) {}
 		virtual void handleMemoryUsage(double &res, double &shared) {res = 0; shared = 0;}
 		virtual void handleExitRequest() { exit(1); }
 		void handleDataRead(std::string &data);
 		virtual void sendData(const std::string &string) {}
 		void checkPing();
 	private:
 		void handleLoginPayload(const std::string &payload);
 		void handleLogoutPayload(const std::string &payload);
 		void handleStatusChangedPayload(const std::string &payload);
 		void handleConvMessagePayload(const std::string &payload);
 		void handleJoinRoomPayload(const std::string &payload);
 		void handleLeaveRoomPayload(const std::string &payload);
 		void handleVCardPayload(const std::string &payload);
 		void handleBuddyChangedPayload(const std::string &payload);
 		void handleBuddyRemovedPayload(const std::string &payload);
 		void handleChatStatePayload(const std::string &payload, int type);
 		void handleAttentionPayload(const std::string &payload);
 		void handleFTStartPayload(const std::string &payload);
 		void handleFTFinishPayload(const std::string &payload);
 		void handleFTPausePayload(const std::string &payload);
 		void handleFTContinuePayload(const std::string &payload);
 		void handleRoomSubjectChangedPayload(const std::string &payload);
 		void send(const std::string &data);
 		void sendPong();
 		void sendMemoryUsage();
 		std::string m_data;
 		bool m_pingReceived;
 		double m_init_res;
 };
+}

include/transport/user.h

➞

Show inline comments

 /**
  * libtransport -- C++ library for easy XMPP Transports development
+ *
  * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <time.h>
 #include "Swiften/Swiften.h"
 #include "Swiften/Disco/EntityCapsManager.h"
 #include "Swiften/Disco/EntityCapsProvider.h"
 #include "storagebackend.h"
 #include <Swiften/FileTransfer/OutgoingFileTransfer.h>
 #include "Swiften/Elements/SpectrumErrorPayload.h"
 namespace Transport {
 class Component;
 class RosterManager;
 class ConversationManager;
 class UserManager;
 class PresenceOracle;
 struct UserInfo;
 /// Represents online XMPP user.
 class User : public Swift::EntityCapsProvider {
 	public:
 		/// Creates new User class.
 		/// \param jid XMPP JID associated with this user
 		/// \param userInfo UserInfo struct with informations needed to connect
 		/// this user to legacy network
 		/// \param component Component associated with this user
 		User(const Swift::JID &jid, UserInfo &userInfo, Component * component, UserManager *userManager);
 		/// Destroyes User.
 		virtual ~User();
 		/// Returns JID of XMPP user who is currently connected using this User class.
 		/// \return full JID
 		const Swift::JID &getJID();
 		/// Returns full JID which supports particular feature or invalid JID.
 		/// \param feature disco#info feature.
 		/// \return full JID which supports particular feature or invalid JID.
 		Swift::JID getJIDWithFeature(const std::string &feature);
 		Swift::DiscoInfo::ref getCaps(const Swift::JID &jid) const;
 		/// Returns UserInfo struct with informations needed to connect the legacy network.
 		/// \return UserInfo struct
 		UserInfo &getUserInfo() { return m_userInfo; }
 		RosterManager *getRosterManager() { return m_rosterManager; }
 		ConversationManager *getConversationManager() { return m_conversationManager; }
 		Component *getComponent() { return m_component; }
 		void setData(void *data) { m_data = data; }
 		void *getData() { return m_data; }
 		/// Handles presence from XMPP JID associated with this user.
 		/// \param presence Swift::Presence.
 		void handlePresence(Swift::Presence::ref presence);
 		void handleSubscription(Swift::Presence::ref presence);
 		void handleDiscoInfo(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info);
 		time_t &getLastActivity() {
 			return m_lastActivity;
+		}
 		void updateLastActivity() {
 			m_lastActivity = time(NULL);
+		}
 		/// Returns language.
 		/// \return language
 		const char *getLang() { return "en"; }
 		void handleDisconnected(const std::string &error, Swift::SpectrumErrorPayload::Error e = Swift::SpectrumErrorPayload::CONNECTION_ERROR_OTHER_ERROR);
 		bool isReadyToConnect() {
 			return m_readyForConnect;
+		}
 		void setConnected(bool connected);
 		void sendCurrentPresence();
 		void setIgnoreDisconnect(bool ignoreDisconnect);
 		bool isConnected() {
 			return m_connected;
+		}
 		int getResourceCount() {
 			return m_resources;
+		}
 		boost::signal<void ()> onReadyToConnect;
 		boost::signal<void (Swift::Presence::ref presence)> onPresenceChanged;
 		boost::signal<void (const Swift::JID &who, const std::string &room, const std::string &nickname, const std::string &password)> onRoomJoined;
 		boost::signal<void (const std::string &room)> onRoomLeft;
 		boost::signal<void ()> onDisconnected;
 	private:
 		void onConnectingTimeout();
 		Swift::JID m_jid;
 		Component *m_component;
 		RosterManager *m_rosterManager;
 		UserManager *m_userManager;
 		ConversationManager *m_conversationManager;
 		Swift::EntityCapsManager *m_entityCapsManager;
 		PresenceOracle *m_presenceOracle;
 		UserInfo m_userInfo;
 		void *m_data;
 		bool m_connected;
 		bool m_readyForConnect;
 		bool m_ignoreDisconnect;
 		Swift::Timer::ref m_reconnectTimer;
 		boost::shared_ptr<Swift::Connection> connection;
 		time_t m_lastActivity;
 		std::map<Swift::JID, Swift::DiscoInfo::ref> m_legacyCaps;
 		std::vector<boost::shared_ptr<Swift::OutgoingFileTransfer> > m_filetransfers;
 		int m_resources;
 		int m_reconnectCounter;
 };
+}

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"
 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;
 			time_t received;
 		};
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::VCard> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::VCard> payload);
 		UserManager *m_userManager;
 		std::map<unsigned int, VCardData> m_queries;
 		unsigned int m_id;
 		Swift::Timer::ref m_collectTimer;
 };
+}
@@ \ No newline at end of file @@
+}

plugin/cpp/networkplugin.cpp

➞

Show inline comments

 	buddy.set_buddyname(buddyName);
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING);
 	send(message);
+}
 void NetworkPlugin::handleBuddyTyped(const std::string &user, const std::string &buddyName) {
 	pbnetwork::Buddy buddy;
 	buddy.set_username(user);
 	buddy.set_buddyname(buddyName);
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPED);
 	send(message);
+}
 void NetworkPlugin::handleBuddyStoppedTyping(const std::string &user, const std::string &buddyName) {
 	pbnetwork::Buddy buddy;
 	buddy.set_username(user);
 	buddy.set_buddyname(buddyName);
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_STOPPED_TYPING);
 	send(message);
+}
 void NetworkPlugin::handleAuthorization(const std::string &user, const std::string &buddyName) {
 	pbnetwork::Buddy buddy;
 	buddy.set_username(user);
 	buddy.set_buddyname(buddyName);
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_AUTH_REQUEST);
 	send(message);
+}
 void NetworkPlugin::handleConnected(const std::string &user) {
 	pbnetwork::Connected d;
 	d.set_user(user);
 	std::string message;
 	d.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONNECTED);
 	send(message);
+}
 void NetworkPlugin::handleDisconnected(const std::string &user, int error, const std::string &msg) {
 	pbnetwork::Disconnected d;
 	d.set_user(user);
 	d.set_error(error);
 	d.set_message(msg);
 	std::string message;
 	d.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_DISCONNECTED);
 	send(message);
+}
 void NetworkPlugin::handleParticipantChanged(const std::string &user, const std::string &nickname, const std::string &room, int flags, pbnetwork::StatusType status, const std::string &statusMessage, const std::string &newname) {
 	pbnetwork::Participant d;
 	d.set_username(user);
 	d.set_nickname(nickname);
 	d.set_room(room);
 	d.set_flag(flags);
 	d.set_newname(newname);
 	d.set_status((pbnetwork::StatusType) status);
 	d.set_statusmessage(statusMessage);
 	std::string message;
 	d.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_PARTICIPANT_CHANGED);
 	send(message);
+}
 void NetworkPlugin::handleRoomNicknameChanged(const std::string &user, const std::string &r, const std::string &nickname) {
 	pbnetwork::Room room;
 	room.set_username(user);
 	room.set_nickname(nickname);
 	room.set_room(r);
 	room.set_password("");
 	std::string message;
 	room.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_ROOM_NICKNAME_CHANGED);
 	send(message);
+}
 void NetworkPlugin::handleFTStart(const std::string &user, const std::string &buddyName, const std::string fileName, unsigned long size) {
 	pbnetwork::File room;
 	room.set_username(user);
 	room.set_buddyname(buddyName);
 	room.set_filename(fileName);
 	room.set_size(size);
 	std::string message;
 	room.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_START);
 	send(message);
+}
 void NetworkPlugin::handleFTFinish(const std::string &user, const std::string &buddyName, const std::string fileName, unsigned long size, unsigned long ftid) {
 	pbnetwork::File room;
 	room.set_username(user);
 	room.set_buddyname(buddyName);
 	room.set_filename(fileName);
 	room.set_size(size);
 	if (ftid) {
 		room.set_ftid(ftid);
+	}
 	std::string message;
 	room.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_FINISH);
 	send(message);
+}
 void NetworkPlugin::handleFTData(unsigned long ftID, const std::string &data) {
 	pbnetwork::FileTransferData d;
 	d.set_ftid(ftID);
 	d.set_data(data);
 	std::string message;
 	d.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_DATA);
 	send(message);
+}
 void NetworkPlugin::handleLoginPayload(const std::string &data) {
 	pbnetwork::Login payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	handleLoginRequest(payload.user(), payload.legacyname(), payload.password());
+}
 void NetworkPlugin::handleLogoutPayload(const std::string &data) {
 	pbnetwork::Logout payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	handleLogoutRequest(payload.user(), payload.legacyname());
+}
 void NetworkPlugin::handleStatusChangedPayload(const std::string &data) {
 	pbnetwork::Status payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	handleStatusChangeRequest(payload.username(), payload.status(), payload.statusmessage());
+}
 void NetworkPlugin::handleConvMessagePayload(const std::string &data) {
 	pbnetwork::ConversationMessage payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	handleMessageSendRequest(payload.username(), payload.buddyname(), payload.message(), payload.xhtml());
+}
 void NetworkPlugin::handleRoomSubjectChangedPayload(const std::string &data) {
 	pbnetwork::ConversationMessage payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	handleRoomSubjectChangedRequest(payload.username(), payload.buddyname(), payload.message());
+}
 void NetworkPlugin::handleAttentionPayload(const std::string &data) {
 	pbnetwork::ConversationMessage payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	handleAttentionRequest(payload.username(), payload.buddyname(), payload.message());
+}
 void NetworkPlugin::handleFTStartPayload(const std::string &data) {
 	pbnetwork::File payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	handleFTStartRequest(payload.username(), payload.buddyname(), payload.filename(), payload.size(), payload.ftid());
+}
 void NetworkPlugin::handleFTFinishPayload(const std::string &data) {
 	pbnetwork::File payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	handleFTFinishRequest(payload.username(), payload.buddyname(), payload.filename(), payload.size(), payload.ftid());
+}
 void NetworkPlugin::handleFTPausePayload(const std::string &data) {
 	pbnetwork::FileTransferData payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	handleFTPauseRequest(payload.ftid());
+}
 void NetworkPlugin::handleFTContinuePayload(const std::string &data) {
 	pbnetwork::FileTransferData payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	handleFTContinueRequest(payload.ftid());
+}
 void NetworkPlugin::handleJoinRoomPayload(const std::string &data) {
 	pbnetwork::Room payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	handleJoinRoomRequest(payload.username(), payload.room(), payload.nickname(), payload.password());
+}
 void NetworkPlugin::handleLeaveRoomPayload(const std::string &data) {
 	pbnetwork::Room payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	handleLeaveRoomRequest(payload.username(), payload.room());
+}
 void NetworkPlugin::handleVCardPayload(const std::string &data) {
 	pbnetwork::VCard payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	if (payload.has_photo()) {
 		handleVCardUpdatedRequest(payload.username(), payload.photo(), payload.nickname());
+	}
 	else if (!payload.buddyname().empty()) {
 		handleVCardRequest(payload.username(), payload.buddyname(), payload.id());
+	}
+}
 void NetworkPlugin::handleBuddyChangedPayload(const std::string &data) {
 	pbnetwork::Buddy payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	if (payload.has_blocked()) {
 		handleBuddyBlockToggled(payload.username(), payload.buddyname(), payload.blocked());
+	}
 	else {
 		std::vector<std::string> groups;
 		for (int i = 0; i < payload.group_size(); i++) {
 			groups.push_back(payload.group(i));
+		}
 		handleBuddyUpdatedRequest(payload.username(), payload.buddyname(), payload.alias(), groups);
+	}
+}
 void NetworkPlugin::handleBuddyRemovedPayload(const std::string &data) {
 	pbnetwork::Buddy payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	std::vector<std::string> groups;
 	for (int i = 0; i < payload.group_size(); i++) {
 		groups.push_back(payload.group(i));
+	}
 	handleBuddyRemovedRequest(payload.username(), payload.buddyname(), groups);
+}
 void NetworkPlugin::handleChatStatePayload(const std::string &data, int type) {
 	pbnetwork::Buddy payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	switch(type) {
 		case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING:
 			handleTypingRequest(payload.username(), payload.buddyname());
 			break;
 		case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPED:
 			handleTypedRequest(payload.username(), payload.buddyname());
 			break;
 		case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_STOPPED_TYPING:
 			handleStoppedTypingRequest(payload.username(), payload.buddyname());
 			break;
 		default:
 			break;
+	}
+}
 void NetworkPlugin::handleDataRead(std::string &data) {
 	m_data.insert(m_data.end(), data.begin(), data.end());
 	while (m_data.size() != 0) {
 		unsigned int expected_size;
 		if (m_data.size() >= 4) {
 			expected_size = *((unsigned int*) &m_data[0]);
 			expected_size = ntohl(expected_size);
 			if (m_data.size() - 4 < expected_size)
 				return;
+		}
 		else {
 			return;
+		}
 		pbnetwork::WrapperMessage wrapper;
 		if (wrapper.ParseFromArray(&m_data[4], expected_size) == false) {
 			m_data.erase(m_data.begin(), m_data.begin() + 4 + expected_size);
 			return;
+		}
 		m_data.erase(m_data.begin(), m_data.begin() + 4 + expected_size);
 		switch(wrapper.type()) {
 			case pbnetwork::WrapperMessage_Type_TYPE_LOGIN:
 				handleLoginPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_LOGOUT:
 				handleLogoutPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_PING:
 				sendPong();
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE:
 				handleConvMessagePayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_ROOM_SUBJECT_CHANGED:
 				handleRoomSubjectChangedPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_JOIN_ROOM:
 				handleJoinRoomPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_LEAVE_ROOM:
 				handleLeaveRoomPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_VCARD:
 				handleVCardPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED:
 				handleBuddyChangedPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_REMOVED:
 				handleBuddyRemovedPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_STATUS_CHANGED:
 				handleStatusChangedPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING:
 				handleChatStatePayload(wrapper.payload(), pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING);
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPED:
 				handleChatStatePayload(wrapper.payload(), pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPED);
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_STOPPED_TYPING:
 				handleChatStatePayload(wrapper.payload(), pbnetwork::WrapperMessage_Type_TYPE_BUDDY_STOPPED_TYPING);
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_ATTENTION:
 				handleAttentionPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_FT_START:
 				handleFTStartPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_FT_FINISH:
 				handleFTFinishPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_FT_PAUSE:
 				handleFTPausePayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_FT_CONTINUE:
 				handleFTContinuePayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_EXIT:
 				handleExitRequest();
 				break;
 			default:
 				return;
+		}
+	}
+}
 void NetworkPlugin::send(const std::string &data) {
 	uint32_t size = htonl(data.size());
 	char *header = (char *) &size;
 	sendData(std::string(header, 4) + data);
+}
 void NetworkPlugin::checkPing() {
 	if (m_pingReceived == false) {
 		handleExitRequest();
+	}
 	m_pingReceived = false;
+}
 void NetworkPlugin::sendPong() {
 	m_pingReceived = true;
 	std::string message;
 	pbnetwork::WrapperMessage wrap;
 	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_PONG);
 	wrap.SerializeToString(&message);
 	send(message);
 	sendMemoryUsage();
+}
 void NetworkPlugin::sendMemoryUsage() {
 	pbnetwork::Stats stats;
 	stats.set_init_res(m_init_res);
 	double res = 0;
 	double shared = 0;
 #ifndef WIN32
 	process_mem_usage(shared, res);
 #endif
 	double e_res;
 	double e_shared;
 	handleMemoryUsage(e_res, e_shared);
 	stats.set_res(res + e_res);
 	stats.set_shared(shared + e_shared);
 	stats.set_id(stringOf(getpid()));
 	std::string message;
 	stats.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_STATS);
 	send(message);
+}
+}

spectrum_manager/src/methods.cpp

➞

Show inline comments

@@ @@ -6,504 +6,504 @@ @@
 #include <string.h>
 #include <time.h>
 #include <stdarg.h>
 #include <pthread.h>
 #include <boost/foreach.hpp>
 #include <iostream>
 #include <fstream>
 #include <iterator>
 #include <algorithm>
 #include <boost/filesystem.hpp>
 #include <cstdlib>
 #include "signal.h"
 #include "sys/wait.h"
 #define WRAP(MESSAGE, TYPE) 	pbnetwork::WrapperMessage wrap; \
 	wrap.set_type(TYPE); \
 	wrap.set_payload(MESSAGE); \
 	wrap.SerializeToString(&MESSAGE);
 using namespace Transport;
 using namespace boost::filesystem;
 using namespace boost;
 std::string _data;
 static std::string response;
 std::string get_response() {
 	return response;
+}
 std::string searchForBinary(const std::string &binary) {
 	std::vector<std::string> path_list;
 	char * env_path = getenv("PATH");
 	if (env_path != NULL) {
 		std::string buffer = "";
 		for (int s = 0; s < strlen(env_path); s++) {
 			if (env_path[s] == ':') {
 				path_list.insert(path_list.end(), std::string(buffer));
 				buffer = "";
+			}
 			else {
 				buffer += env_path[s];
+			}
+		}
 		if (buffer != "") {
 			path_list.insert(path_list.end(), std::string(buffer));
 			buffer = "";
+		}
 		for (std::vector<std::string>::iterator dit = path_list.begin(); dit < path_list.end(); dit++) {
 			std::string bpath = *dit;
 			bpath += "/";
 			bpath += binary;
 			path p(bpath);
 			if (exists(p) && !is_directory(p)) {
 				return bpath;
+			}
+		}
+	}
 	return "";
+}
 // Executes new backend
 unsigned long exec_(std::string path, std::string config, std::string jid, int &rc) {
 	// fork and exec
 	pid_t pid = fork();
 	if ( pid == 0 ) {
 		// child process
 		if (jid.empty()) {
 			exit(execl(path.c_str(), path.c_str(), config.c_str(), NULL));
+		}
 		else {
 			exit(execl(path.c_str(), path.c_str(), "-j", jid.c_str(), config.c_str(), NULL));
+		}
 	} else if ( pid < 0 ) {
 		// fork failed
+	}
 	else {
 		waitpid(pid, &rc, 0);
+	}
 	return (unsigned long) pid;
+}
 int getPort(const std::string &portfile) {
 	path p(portfile);
 	if (!exists(p) || is_directory(p)) {
 		return 0;
+	}
 	std::ifstream f(p.string().c_str(), std::ios_base::in);
 	std::string port;
 	f >> port;
 	if (port.empty())
 		return 0;
 	return boost::lexical_cast<int>(port);
+}
 int isRunning(const std::string &pidfile) {
 	path p(pidfile);
 	if (!exists(p) || is_directory(p)) {
 		return 0;
+	}
 	std::ifstream f(p.string().c_str(), std::ios_base::in);
 	std::string pid;
 	f >> pid;
 	if (pid.empty())
 		return 0;
 	if (kill(boost::lexical_cast<int>(pid), 0) != 0)
 		return 0;
 	return boost::lexical_cast<int>(pid);
+}
 int start_instances(ManagerConfig *config, const std::string &_jid) {
 	int rv = 0;
 	response = "";
 	path p(CONFIG_STRING(config, "service.config_directory"));
 	try {
 		if (!exists(p)) {
 			std::cerr << "Config directory " << CONFIG_STRING(config, "service.config_directory") << " does not exist\n";
 			return 6;
+		}
 		if (!is_directory(p)) {
 			std::cerr << "Config directory " << CONFIG_STRING(config, "service.config_directory") << " does not exist\n";
 			return 7;
+		}
 		std::string spectrum2_binary = searchForBinary("spectrum2");
 		if (spectrum2_binary.empty()) {
 			std::cerr << "spectrum2 binary not found in PATH\n";
 			return 8;
+		}
 		directory_iterator end_itr;
 		for (directory_iterator itr(p); itr != end_itr; ++itr) {
 			if (is_regular(itr->path()) && extension(itr->path()) == ".cfg") {
 				Config cfg;
 				if (cfg.load(itr->path().string()) == false) {
 					std::cerr << "Can't load config file " << itr->path().string() << ". Skipping...\n";
 					continue;
+				}
 				std::vector<std::string> vhosts;
 				if (CONFIG_HAS_KEY(&cfg, "vhosts.vhost"))
 					vhosts = CONFIG_VECTOR(&cfg, "vhosts.vhost");
 				vhosts.push_back(CONFIG_STRING(&cfg, "service.jid"));
 				BOOST_FOREACH(std::string &vhost, vhosts) {
 					Config vhostCfg;
 					if (vhostCfg.load(itr->path().string(), vhost) == false) {
 						std::cerr << "Can't load config file " << itr->path().string() << ". Skipping...\n";
 						continue;
+					}
 					if (!_jid.empty() && _jid != vhost) {
 						continue;
+					}
 					int pid = isRunning(CONFIG_STRING(&vhostCfg, "service.pidfile"));
 					if (pid == 0) {
 						int rc;
 						response = "Starting " + itr->path().string() + ": OK\n";
 						std::cout << "Starting " << itr->path() << ": OK\n";
 						exec_(spectrum2_binary, itr->path().string(), vhost, rc);
 						if (rv == 0) {
 							rv = rc;
+						}
+					}
 					else {
 						response = "Starting " + itr->path().string() + ": Already started (PID=" + boost::lexical_cast<std::string>(pid) + ")\n";
 						std::cout << "Starting " << itr->path() << ": Already started (PID=" << pid << ")\n";
+					}
+				}
+			}
+		}
+	}
 	catch (const filesystem_error& ex) {
-		std::cerr << "boost filesystem error\n";
+		std::cerr << "Filesystem error: " << ex.what() << "\n";
 		return 6;
+	}
 	return rv;
+}
 void stop_instances(ManagerConfig *config, const std::string &_jid) {
 	response = "";
 	path p(CONFIG_STRING(config, "service.config_directory"));
 	try {
 		if (!exists(p)) {
 			std::cerr << "Config directory " << CONFIG_STRING(config, "service.config_directory") << " does not exist\n";
 			exit(6);
+		}
 		if (!is_directory(p)) {
 			std::cerr << "Config directory " << CONFIG_STRING(config, "service.config_directory") << " does not exist\n";
 			exit(7);
+		}
 		directory_iterator end_itr;
 		for (directory_iterator itr(p); itr != end_itr; ++itr) {
 			if (is_regular(itr->path()) && extension(itr->path()) == ".cfg") {
 				Config cfg;
 				if (cfg.load(itr->path().string()) == false) {
 					std::cerr << "Can't load config file " << itr->path().string() << ". Skipping...\n";
+				}
 				std::vector<std::string> vhosts;
 				if (CONFIG_HAS_KEY(&cfg, "vhosts.vhost"))
 					vhosts = CONFIG_VECTOR(&cfg, "vhosts.vhost");
 				vhosts.push_back(CONFIG_STRING(&cfg, "service.jid"));
 				BOOST_FOREACH(std::string &vhost, vhosts) {
 					Config vhostCfg;
 					if (vhostCfg.load(itr->path().string(), vhost) == false) {
 						std::cerr << "Can't load config file " << itr->path().string() << ". Skipping...\n";
 						continue;
+					}
 					if (!_jid.empty() && _jid != vhost) {
 						continue;
+					}
 					int pid = isRunning(CONFIG_STRING(&vhostCfg, "service.pidfile"));
 					if (pid) {
 						response ="Stopping " + itr->path().string() + ": ";
 						std::cout << "Stopping " << itr->path() << ": ";
 						kill(pid, SIGTERM);
 						sleep(1);
 						int count = 20;
 						while (kill(pid, 0) == 0 && count != 0) {
 							std::cout << ".";
 							sleep(1);
 							count--;
+						}
 						if (count == 0) {
 							response += "ERROR (timeout)\n";
 							std::cout << " ERROR (timeout)\n";
+						}
 						else {
 							response += "OK\n";
 							std::cout << " OK\n";
+						}
+					}
 					else {
 						response = "Stopping " + itr->path().string() + ": Not running\n";
 						std::cout << "Stopping " << itr->path() << ": Not running\n";
+					}
+				}
+			}
+		}
+	}
 	catch (const filesystem_error& ex) {
-		std::cerr << "boost filesystem error\n";
+		std::cerr << "Filesystem error: " << ex.what() << "\n";
 		exit(5);
+	}
+}
 int show_status(ManagerConfig *config) {
 	int ret = 0;
 	path p(CONFIG_STRING(config, "service.config_directory"));
 	try {
 		if (!exists(p)) {
 			std::cerr << "Config directory " << CONFIG_STRING(config, "service.config_directory") << " does not exist\n";
 			exit(6);
+		}
 		if (!is_directory(p)) {
 			std::cerr << "Config directory " << CONFIG_STRING(config, "service.config_directory") << " does not exist\n";
 			exit(7);
+		}
 		directory_iterator end_itr;
 		for (directory_iterator itr(p); itr != end_itr; ++itr) {
 			if (is_regular(itr->path()) && extension(itr->path()) == ".cfg") {
 				Config cfg;
 				if (cfg.load(itr->path().string()) == false) {
 					std::cerr << "Can't load config file " << itr->path().string() << ". Skipping...\n";
+				}
 				std::vector<std::string> vhosts;
 				if (CONFIG_HAS_KEY(&cfg, "vhosts.vhost"))
 					vhosts = CONFIG_VECTOR(&cfg, "vhosts.vhost");
 				vhosts.push_back(CONFIG_STRING(&cfg, "service.jid"));
 				BOOST_FOREACH(std::string &vhost, vhosts) {
 					Config vhostCfg;
 					if (vhostCfg.load(itr->path().string(), vhost) == false) {
 						std::cerr << "Can't load config file " << itr->path().string() << ". Skipping...\n";
 						continue;
+					}
 					int pid = isRunning(CONFIG_STRING(&vhostCfg, "service.pidfile"));
 					if (pid) {
 						std::cout << itr->path() << ": " << vhost << " Running\n";
+					}
 					else {
 						ret = 3;
 						std::cout << itr->path() << ": " << vhost << " Stopped\n";
+					}
+				}
+			}
+		}
+	}
 	catch (const filesystem_error& ex) {
-		std::cerr << "boost filesystem error\n";
+		std::cerr << "Filesystem error: " << ex.what() << "\n";
 		exit(5);
+	}
 	return ret;
+}
 static void handleDataRead(boost::shared_ptr<Swift::Connection> m_conn, boost::shared_ptr<Swift::SafeByteArray> data) {
 	_data += std::string(data->begin(), data->end());
 	// Parse data while there are some
 	while (_data.size() != 0) {
 		// expected_size of wrapper message
 		unsigned int expected_size;
 		// if data is >= 4, we have whole header and we can
 		// read expected_size.
 		if (_data.size() >= 4) {
 			expected_size = *((unsigned int*) &_data[0]);
 			expected_size = ntohl(expected_size);
 			// If we don't have whole wrapper message, wait for next
 			// handleDataRead call.
 			if (_data.size() - 4 < expected_size)
 				return;
+		}
 		else {
 			return;
+		}
 		// Parse wrapper message and erase it from buffer.
 		pbnetwork::WrapperMessage wrapper;
 		if (wrapper.ParseFromArray(&_data[4], expected_size) == false) {
 			std::cout << "PARSING ERROR " << expected_size << "\n";
 			_data.erase(_data.begin(), _data.begin() + 4 + expected_size);
 			continue;
+		}
 		_data.erase(_data.begin(), _data.begin() + 4 + expected_size);
 		if (wrapper.type() == pbnetwork::WrapperMessage_Type_TYPE_QUERY) {
 			pbnetwork::BackendConfig payload;
 			if (payload.ParseFromString(wrapper.payload()) == false) {
 				std::cout << "PARSING ERROR\n";
 				// TODO: ERROR
 				continue;
+			}
 			m_conn->onDataRead.disconnect(boost::bind(&handleDataRead, m_conn, _1));
 			m_conn->disconnect();
 			response = payload.config();
 			std::cout << payload.config() << "\n";
 // 			exit(0);
+		}
+	}
+}
 static void handleConnected(boost::shared_ptr<Swift::Connection> m_conn, const std::string &msg, bool error) {
 		m_conn->onConnectFinished.disconnect(boost::bind(&handleConnected, m_conn, msg, _1));
 	if (error) {
 		std::cerr << "Can't connect the server\n";
 		response = "Can't connect the server\n";
 		m_conn->onDataRead.disconnect(boost::bind(&handleDataRead, m_conn, _1));
 // 		exit(50);
+	}
 	else {
 		pbnetwork::BackendConfig m;
 		m.set_config(msg);
 		std::string message;
 		m.SerializeToString(&message);
 		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_QUERY);
 		uint32_t size = htonl(message.size());
 		char *header = (char *) &size;
 		// send header together with wrapper message
 		m_conn->write(Swift::createSafeByteArray(std::string(header, 4) + message));
+	}
+}
 void ask_local_server(ManagerConfig *config, Swift::BoostNetworkFactories &networkFactories, const std::string &jid, const std::string &message) {
 	response = "";
 	path p(CONFIG_STRING(config, "service.config_directory"));
 	try {
 		if (!exists(p)) {
 			std::cerr << "Config directory " << CONFIG_STRING(config, "service.config_directory") << " does not exist\n";
 			exit(6);
+		}
 		if (!is_directory(p)) {
 			std::cerr << "Config directory " << CONFIG_STRING(config, "service.config_directory") << " does not exist\n";
 			exit(7);
+		}
 		bool found = false;
 		directory_iterator end_itr;
 		for (directory_iterator itr(p); itr != end_itr; ++itr) {
 			if (is_regular(itr->path()) && extension(itr->path()) == ".cfg") {
 				Config cfg;
 				if (cfg.load(itr->path().string()) == false) {
 					std::cerr << "Can't load config file " << itr->path().string() << ". Skipping...\n";
 					continue;
+				}
 				if (CONFIG_STRING(&cfg, "service.jid") != jid) {
 					continue;
+				}
 				found = true;
 				boost::shared_ptr<Swift::Connection> m_conn;
 				m_conn = networkFactories.getConnectionFactory()->createConnection();
 				m_conn->onDataRead.connect(boost::bind(&handleDataRead, m_conn, _1));
 				m_conn->onConnectFinished.connect(boost::bind(&handleConnected, m_conn, message, _1));
 				m_conn->connect(Swift::HostAddressPort(Swift::HostAddress(CONFIG_STRING(&cfg, "service.backend_host")), getPort(CONFIG_STRING(&cfg, "service.portfile"))));
 // 				finished++;
 // 				Swift::Client *client = new Swift::Client(CONFIG_VECTOR(&cfg, "service.admin_jid")[0], CONFIG_STRING(&cfg, "service.admin_password"), &networkFactories);
 // 				client->setAlwaysTrustCertificates();
 // 				client->onConnected.connect(boost::bind(&handleConnected, client, CONFIG_STRING(&cfg, "service.jid")));
 // 				client->onDisconnected.connect(bind(&handleDisconnected, client, _1, CONFIG_STRING(&cfg, "service.jid")));
 // 				client->onMessageReceived.connect(bind(&handleMessageReceived, client, _1, CONFIG_STRING(&cfg, "service.jid")));
 // 				Swift::ClientOptions opt;
 // 				opt.allowPLAINWithoutTLS = true;
 // 				client->connect(opt);
+			}
+		}
 		if (!found) {
 			response = "Config file for Spectrum instance with this JID was not found\n";
 			std::cerr << "Config file for Spectrum instance with this JID was not found\n";
 // 			exit(20);
+		}
+	}
 	catch (const filesystem_error& ex) {
-		std::cerr << "boost filesystem error\n";
+		std::cerr << "Filesystem error: " << ex.what() << "\n";
 		exit(5);
+	}
+}
 std::vector<std::string> show_list(ManagerConfig *config, bool show) {
 	path p(CONFIG_STRING(config, "service.config_directory"));
 	std::vector<std::string> list;
 	try {
 		if (!exists(p)) {
 			std::cerr << "Config directory " << CONFIG_STRING(config, "service.config_directory") << " does not exist\n";
 			exit(6);
+		}
 		if (!is_directory(p)) {
 			std::cerr << "Config directory " << CONFIG_STRING(config, "service.config_directory") << " does not exist\n";
 			exit(7);
+		}
 		bool found = false;
 		directory_iterator end_itr;
 		for (directory_iterator itr(p); itr != end_itr; ++itr) {
 			if (is_regular(itr->path()) && extension(itr->path()) == ".cfg") {
 				Config cfg;
 				if (cfg.load(itr->path().string()) == false) {
 					std::cerr << "Can't load config file " << itr->path().string() << ". Skipping...\n";
 					continue;
+				}
 				if (show) {
 					std::cout << CONFIG_STRING(&cfg, "service.jid") << "\n";
+				}
 				list.push_back(CONFIG_STRING(&cfg, "service.jid"));
+			}
+		}
+	}
 	catch (const filesystem_error& ex) {
-		std::cerr << "boost filesystem error\n";
+		std::cerr << "Filesystem error: " << ex.what() << "\n";
+	}
 	return list;
+}

src/CMakeLists.txt

➞

Show inline comments

 cmake_minimum_required(VERSION 2.6)
 FILE(GLOB SRC *.cpp *.h)
 FILE(GLOB_RECURSE SWIFTEN_SRC ../include/Swiften/*.cpp)
 # Build without openssl on msvc
 if (CMAKE_COMPILER_IS_GNUCXX)
 	string(REGEX REPLACE "[^;]+;?/Schannel/[^;]+;?" "" SWIFTEN_SRC "${SWIFTEN_SRC}")
 else()
 	string(REGEX REPLACE "[^;]+;?/OpenSSL/[^;]+;?" "" SWIFTEN_SRC "${SWIFTEN_SRC}")
 endif()
 FILE(GLOB HEADERS ../include/transport/*.h)
 if (CPPUNIT_FOUND)
 	FILE(GLOB SRC_TEST tests/*.cpp)
 	ADD_EXECUTABLE(libtransport_test ${SRC_TEST})
 	target_link_libraries(libtransport_test transport ${CPPUNIT_LIBRARY} ${Boost_LIBRARIES})
 endif()
 if (NOT WIN32)
 include_directories(${POPT_INCLUDE_DIR})
 endif()
 # SOURCE_GROUP(headers FILES ${HEADERS})
 if (PROTOBUF_FOUND)
 	if (NOT WIN32)
 		ADD_LIBRARY(transport SHARED ${HEADERS} ${SRC} ${SWIFTEN_SRC})
 	else()
 		ADD_LIBRARY(transport STATIC ${HEADERS} ${SRC} ${SWIFTEN_SRC})
 	endif()
 #	SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/../include/transport/protocol.pb.cc PROPERTIES GENERATED 1)
 	ADD_DEPENDENCIES(transport pb)
 else(PROTOBUF_FOUND)
 	ADD_LIBRARY(transport SHARED ${HEADERS} ${SRC} ${SWIFTEN_SRC})
 endif(PROTOBUF_FOUND)
 if (CMAKE_COMPILER_IS_GNUCXX)
+# if (CMAKE_COMPILER_IS_GNUCXX)
 	if (NOT WIN32)
 		ADD_DEFINITIONS(-fPIC)
 	endif()
 endif()
+# endif()
 if (WIN32)
 	TARGET_LINK_LIBRARIES(transport transport-plugin sqlite3 ${PQXX_LIBRARY} ${PQ_LIBRARY} ${MYSQL_LIBRARIES} ${SWIFTEN_LIBRARY} ${LOG4CXX_LIBRARIES} ${PROTOBUF_LIBRARY})
 else()
 	TARGET_LINK_LIBRARIES(transport transport-plugin ${PQXX_LIBRARY} ${PQ_LIBRARY} ${SQLITE3_LIBRARIES} ${MYSQL_LIBRARIES} ${SWIFTEN_LIBRARY} ${LOG4CXX_LIBRARIES} ${POPT_LIBRARY} ${PROTOBUF_LIBRARY})
 endif()
 SET_TARGET_PROPERTIES(transport PROPERTIES
       VERSION ${TRANSPORT_VERSION} SOVERSION ${TRANSPORT_VERSION}
+)
 INSTALL(TARGETS transport LIBRARY DESTINATION ${LIB_INSTALL_DIR} ARCHIVE DESTINATION ${LIB_INSTALL_DIR} COMPONENT libraries)
 #CONFIGURE_FILE(transport.pc.in "${CMAKE_CURRENT_BINARY_DIR}/transport.pc")
 #INSTALL(FILES "${CMAKE_CURRENT_BINARY_DIR}/transport.pc" DESTINATION lib/pkgconfig)

src/config.cpp

➞

Show inline comments

 /**
  * libtransport -- C++ library for easy XMPP Transports development
+ *
  * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/config.h"
 #include <fstream>
 #ifdef _WIN32
 #include <direct.h>
 #define getcwd _getcwd
 #include <windows.h>
 #ifdef _MSC_VER
 #define PATH_MAX MAX_PATH
 #endif
 #endif
 #include "iostream"
 #include "boost/version.hpp"
 #include "boost/algorithm/string.hpp"
 #define BOOST_MAJOR_VERSION BOOST_VERSION / 100000
 #define BOOST_MINOR_VERSION BOOST_VERSION / 100 % 1000
 using namespace boost::program_options;
 namespace Transport {
 static int getRandomPort(const std::string &s) {
 	unsigned long r = 0;
 	BOOST_FOREACH(char c, s) {
 		r += (int) c;
+	}
 	srand(time(NULL) + r);
 	return 30000 + rand() % 10000;
+}
 bool Config::load(const std::string &configfile, boost::program_options::options_description &opts, const std::string &jid) {
 	std::ifstream ifs(configfile.c_str());
 	if (!ifs.is_open())
 		return false;
 	m_file = configfile;
 	m_jid = jid;
 	bool ret = load(ifs, opts, jid);
 	ifs.close();
 #ifndef WIN32
 	char path[PATH_MAX] = "";
 	if (m_file.find_first_of("/") != 0) {
 		getcwd(path, PATH_MAX);
 		m_file = std::string(path) + "/" + m_file;
+	}
 #endif
 	return ret;
+}
 bool Config::load(std::istream &ifs, boost::program_options::options_description &opts, const std::string &_jid) {
 	m_unregistered.clear();
 	opts.add_options()
 		("service.jid", value<std::string>()->default_value(""), "Transport Jabber ID")
 		("service.server", value<std::string>()->default_value(""), "Server to connect to")
 		("service.password", value<std::string>()->default_value(""), "Password used to auth the server")
 		("service.port", value<int>()->default_value(0), "Port the server is listening on")
 		("service.user", value<std::string>()->default_value(""), "The name of user Spectrum runs as.")
 		("service.group", value<std::string>()->default_value(""), "The name of group Spectrum runs as.")
 		("service.backend", value<std::string>()->default_value("libpurple_backend"), "Backend")
 		("service.protocol", value<std::string>()->default_value(""), "Protocol")
 		("service.pidfile", value<std::string>()->default_value("/var/run/spectrum2/$jid.pid"), "Full path to pid file")
 		("service.portfile", value<std::string>()->default_value("/var/run/spectrum2/$jid.port"), "File to store backend_port to. It's used by spectrum2_manager.")
 		("service.working_dir", value<std::string>()->default_value("/var/lib/spectrum2/$jid"), "Working dir")
 		("service.allowed_servers", value<std::vector<std::string> >()->multitoken(), "Only users from these servers can connect")
 		("service.server_mode", value<bool>()->default_value(false), "True if Spectrum should behave as server")
 		("service.users_per_backend", value<int>()->default_value(100), "Number of users per one legacy network backend")
 		("service.backend_host", value<std::string>()->default_value("localhost"), "Host to bind backend server to")
 		("service.backend_port", value<std::string>()->default_value("0"), "Port to bind backend server to")
 		("service.cert", value<std::string>()->default_value(""), "PKCS#12 Certificate.")
 		("service.cert_password", value<std::string>()->default_value(""), "PKCS#12 Certificate password.")
 		("service.admin_jid", value<std::vector<std::string> >()->multitoken(), "Administrator jid.")
 		("service.admin_password", value<std::string>()->default_value(""), "Administrator password.")
 		("service.reuse_old_backends", value<bool>()->default_value(true), "True if Spectrum should use old backends which were full in the past.")
 		("service.idle_reconnect_time", value<int>()->default_value(0), "Time in seconds after which idle users are reconnected to let their backend die.")
 		("service.memory_collector_time", value<int>()->default_value(0), "Time in seconds after which backend with most memory is set to die.")
 		("service.more_resources", value<bool>()->default_value(false), "Allow more resources to be connected in server mode at the same time.")
 		("service.enable_privacy_lists", value<bool>()->default_value(true), "")
 		("service.enable_xhtml", value<bool>()->default_value(true), "")
 		("vhosts.vhost", value<std::vector<std::string> >()->multitoken(), "")
 		("identity.name", value<std::string>()->default_value("Spectrum 2 Transport"), "Name showed in service discovery.")
 		("identity.category", value<std::string>()->default_value("gateway"), "Disco#info identity category. 'gateway' by default.")
 		("identity.type", value<std::string>()->default_value(""), "Type of transport ('icq','msn','gg','irc', ...)")
 		("registration.enable_public_registration", value<bool>()->default_value(true), "True if users should be able to register.")
 		("registration.language", value<std::string>()->default_value("en"), "Default language for registration form")
 		("registration.instructions", value<std::string>()->default_value("Enter your legacy network username and password."), "Instructions showed to user in registration form")
 		("registration.username_label", value<std::string>()->default_value("Legacy network username:"), "Label for username field")
 		("registration.username_mask", value<std::string>()->default_value(""), "Username mask")
 		("registration.allowed_usernames", value<std::string>()->default_value(""), "Allowed usernames")
 		("registration.auto_register", value<bool>()->default_value(false), "Register new user automatically when the presence arrives.")
 		("registration.encoding", value<std::string>()->default_value("utf8"), "Default encoding in registration form")
 		("registration.require_local_account", value<bool>()->default_value(false), "True if users have to have a local account to register to this transport from remote servers.")
 		("registration.local_username_label", value<std::string>()->default_value("Local username:"), "Label for local usernme field")
 		("registration.local_account_server", value<std::string>()->default_value("localhost"), "The server on which the local accounts will be checked for validity")
 		("registration.local_account_server_timeout", value<int>()->default_value(10000), "Timeout when checking local user on local_account_server (msecs)")
 		("gateway_responder.prompt", value<std::string>()->default_value("Contact ID"), "Value of <prompt> </promt> field")
 		("gateway_responder.label", value<std::string>()->default_value("Enter legacy network contact ID."), "Label for add contact ID field")
 		("database.type", value<std::string>()->default_value("none"), "Database type.")
 		("database.database", value<std::string>()->default_value("/var/lib/spectrum2/$jid/database.sql"), "Database used to store data")
 		("database.server", value<std::string>()->default_value("localhost"), "Database server.")
 		("database.user", value<std::string>()->default_value(""), "Database user.")
 		("database.password", value<std::string>()->default_value(""), "Database Password.")
 		("database.port", value<int>()->default_value(0), "Database port.")
 		("database.prefix", value<std::string>()->default_value(""), "Prefix of tables in database")
 		("database.encryption_key", value<std::string>()->default_value(""), "Encryption key.")
 		("logging.config", value<std::string>()->default_value(""), "Path to log4cxx config file which is used for Spectrum 2 instance")
 		("logging.backend_config", value<std::string>()->default_value(""), "Path to log4cxx config file which is used for backends")
 		("backend.default_avatar", value<std::string>()->default_value(""), "Full path to default avatar")
 		("backend.avatars_directory", value<std::string>()->default_value(""), "Path to directory with avatars")
 		("backend.no_vcard_fetch", value<bool>()->default_value(false), "True if VCards for buddies should not be fetched. Only avatars will be forwarded.")
 		("proxy.server", value<std::string>()->default_value("localhost"), "Proxy IP.")
 		("proxy.user", value<std::string>()->default_value(""), "Proxy user.")
 		("proxy.password", value<std::string>()->default_value(""), "Proxy Password.")
 		("proxy.port", value<int>()->default_value(0), "Proxy port.")
+	;
 	// Load configs passed by command line
 	if (m_argc != 0 && m_argv) {
 		basic_command_line_parser<char> parser = command_line_parser(m_argc, m_argv).options(opts).allow_unregistered();
 		parsed_options parsed = parser.run();
 		BOOST_FOREACH(option &opt, parsed.options) {
 			if (opt.unregistered && !opt.value.empty()) {
 				m_unregistered[opt.string_key] = variable_value(opt.value[0], false);
+			}
+		}
 		store(parsed, m_variables);
+	}
 	parsed_options parsed = parse_config_file(ifs, opts, true);
 	bool found_working = false;
 	bool found_pidfile = false;
 	bool found_portfile = false;
 	bool found_backend_port = false;
 	bool found_database = false;
 	std::string jid = "";
 	BOOST_FOREACH(option &opt, parsed.options) {
 		if (opt.string_key == "service.jid") {
 			if (_jid.empty()) {
 				jid = opt.value[0];
+			}
 			else {
 				opt.value[0] = _jid;
 				jid = _jid;
+			}
+		}
 		else if (opt.string_key == "service.backend_port") {
 			found_backend_port = true;
 			if (opt.value[0] == "0") {
 				opt.value[0] = boost::lexical_cast<std::string>(getRandomPort(_jid.empty() ? jid : _jid));
+			}
+		}
 		else if (opt.string_key == "service.working_dir") {
 			found_working = true;
+		}
 		else if (opt.string_key == "service.pidfile") {
 			found_pidfile = true;
+		}
 		else if (opt.string_key == "service.portfile") {
 			found_portfile = true;
+		}
 		else if (opt.string_key == "database.database") {
 			found_database = true;
+		}
+	}
 	if (!found_working) {
 		std::vector<std::string> value;
 		value.push_back("/var/lib/spectrum2/$jid");
 		parsed.options.push_back(boost::program_options::basic_option<char>("service.working_dir", value));
+	}
 	if (!found_pidfile) {
 		std::vector<std::string> value;
 		value.push_back("/var/run/spectrum2/$jid.pid");
 		parsed.options.push_back(boost::program_options::basic_option<char>("service.pidfile", value));
+	}
 	if (!found_portfile) {
 		std::vector<std::string> value;
 		value.push_back("/var/run/spectrum2/$jid.port");
 		parsed.options.push_back(boost::program_options::basic_option<char>("service.portfile", value));
+	}
 	if (!found_backend_port) {
 		std::vector<std::string> value;
 		std::string p = boost::lexical_cast<std::string>(getRandomPort(_jid.empty() ? jid : _jid));
 		value.push_back(p);
 		parsed.options.push_back(boost::program_options::basic_option<char>("service.backend_port", value));
+	}
 	if (!found_database) {
 		std::vector<std::string> value;
 		value.push_back("/var/lib/spectrum2/$jid/database.sql");
 		parsed.options.push_back(boost::program_options::basic_option<char>("database.database", value));
+	}
 	std::list<std::string> has_key;
 	BOOST_FOREACH(option &opt, parsed.options) {
 		if (opt.unregistered) {
 			m_unregistered[opt.string_key] = variable_value(opt.value[0], false);
 			if (std::find(has_key.begin(), has_key.end(), opt.string_key) == has_key.end()) {
 				has_key.push_back(opt.string_key);
 				m_unregistered[opt.string_key] = variable_value(opt.value[0], false);
+			}
 			else {
 				std::list<std::string> list;
 				try {
 					list = m_unregistered[opt.string_key].as<std::list<std::string> >();
+				}
 				catch(...) {
 					list.push_back(m_unregistered[opt.string_key].as<std::string>());
+				}
 				list.push_back(opt.value[0]);
 				m_unregistered[opt.string_key] = variable_value(list, false);
+			}
+		}
 		else if (opt.value[0].find("$jid") != std::string::npos) {
 			boost::replace_all(opt.value[0], "$jid", jid);
+		}
+	}
 	// Load configs passed by command line
 	if (m_argc != 0 && m_argv) {
 		basic_command_line_parser<char> parser = command_line_parser(m_argc, m_argv).options(opts).allow_unregistered();
 		parsed_options parsed = parser.run();
 		BOOST_FOREACH(option &opt, parsed.options) {
 			if (opt.unregistered && !opt.value.empty()) {
 				m_unregistered[opt.string_key] = variable_value(opt.value[0], false);
+			}
+		}
 		store(parsed, m_variables);
+	}
 	store(parsed, m_variables);
 	notify(m_variables);
 	onConfigReloaded();
 	return true;
+}
 bool Config::load(std::istream &ifs) {
 	options_description opts("Transport options");
 	return load(ifs, opts);
+}
 bool Config::load(const std::string &configfile, const std::string &jid) {
 	try {
 		options_description opts("Transport options");
 		return load(configfile, opts, jid);
 	} catch ( const boost::program_options::multiple_occurrences& e ) {
 #if (BOOST_MAJOR_VERSION >= 1 && BOOST_MINOR_VERSION >= 42)
 		std::cerr << configfile << " parsing error: " << e.what() << " from option: " << e.get_option_name() << std::endl;
 #else
 		std::cerr << configfile << " parsing error: " << e.what() << std::endl;
 #endif
 		return false;
+	}
+}
 bool Config::reload() {
 	if (m_file.empty()) {
 		return false;
+	}
 	return load(m_file, m_jid);
+}
 Config::SectionValuesCont Config::getSectionValues(const std::string& sectionName) {
 	SectionValuesCont sectionValues;
 	std::string sectionSearchString = sectionName + ".";
 	BOOST_FOREACH (const Variables::value_type & varItem, m_variables) {
 		if (boost::istarts_with(varItem.first, sectionSearchString))
 			sectionValues[varItem.first] = varItem.second;
+	}
 	BOOST_FOREACH (const UnregisteredCont::value_type & varItem, m_unregistered) {
 		if (boost::istarts_with(varItem.first, sectionSearchString))
 			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(), "")
+	;
 	std::stringstream ifs(backendConfig);
 	parsed_options parsed = parse_config_file(ifs, opts, true);
 	store(parsed, m_backendConfig);
 	notify(m_backendConfig);
+}
 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")
 		("config", boost::program_options::value<std::string>(&configFile)->default_value(""), "Config file")
+		;
 	os << desc;
 	try
+	{
 		boost::program_options::positional_options_description p;
 		p.add("config", -1);
 		boost::program_options::store(boost::program_options::command_line_parser(argc, argv).
 			options(desc).positional(p).allow_unregistered().run(), vm);
 		boost::program_options::notify(vm);
 		if(vm.count("help"))
+		{
 			error = os.str();
 			return NULL;
+		}
 		if(vm.count("config") == 0) {
 			error = os.str();
 			return NULL;
+		}
+	}
 	catch (std::runtime_error& e)
+	{
 		error = os.str();
 		return NULL;
+	}
 	catch (...)
+	{
 		error = os.str();
 		return NULL;
+	}
 	Config *config = new Config(argc, argv);
 	if (!config->load(configFile)) {
 		error = "Can't open " + configFile + " configuration file.\n";
 		delete config;
 		return NULL;
+	}
 	return config;
+}
+}

src/conversation.cpp

➞

Show inline comments

 /**
  * XMPP - libpurple transport
+ *
  * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include <iostream>
 #include "transport/conversation.h"
 #include "transport/conversationmanager.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/buddy.h"
 #include "transport/rostermanager.h"
 namespace Transport {
 Conversation::Conversation(ConversationManager *conversationManager, const std::string &legacyName, bool isMUC) : m_conversationManager(conversationManager) {
 	m_legacyName = legacyName;
 // 	m_conversationManager->addConversation(this);
 	m_muc = isMUC;
 	m_jid = m_conversationManager->getUser()->getJID().toBare();
+}
 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->setTo(m_jid);
 		presence->setType(Swift::Presence::Unavailable);
 		Swift::MUCItem item;
 		item.affiliation = Swift::MUCOccupant::NoAffiliation;
 		item.role = Swift::MUCOccupant::NoRole;
 		Swift::MUCUserPayload *p = new Swift::MUCUserPayload ();
 		p->addItem(item);
 		Swift::MUCUserPayload::StatusCode c;
 		c.code = 332;
 		p->addStatusCode(c);
 		presence->addPayload(boost::shared_ptr<Swift::Payload>(p));
 		m_conversationManager->getComponent()->getStanzaChannel()->sendPresence(presence);
+	}
+}
 void Conversation::setRoom(const std::string &room) {
 	m_room = room;
 	m_legacyName = m_room + "/" + m_legacyName;
+}
 void Conversation::handleMessage(boost::shared_ptr<Swift::Message> &message, const std::string &nickname) {
 	if (m_muc) {
 		message->setType(Swift::Message::Groupchat);
+	}
 	else {
 		message->setType(Swift::Message::Chat);
+	}
 	std::string n = nickname;
 	if (n.empty() && !m_room.empty() && !m_muc) {
 		n = m_nickname;
+	}
 	if (message->getType() != Swift::Message::Groupchat) {
 		message->setTo(m_jid);
 		// normal message
 		if (n.empty()) {
 			Buddy *buddy = m_conversationManager->getUser()->getRosterManager()->getBuddy(m_legacyName);
 			if (buddy) {
 				message->setFrom(buddy->getJID());
+			}
 			else {
 				message->setFrom(Swift::JID(Swift::JID::getEscapedNode(m_legacyName), m_conversationManager->getComponent()->getJID().toBare()));
+			}
+		}
 		// PM message
 		else {
 			if (m_room.empty()) {
 				message->setFrom(Swift::JID(n, m_conversationManager->getComponent()->getJID().toBare(), "user"));
+			}
 			else {
 				message->setFrom(Swift::JID(m_room, m_conversationManager->getComponent()->getJID().toBare(), n));
+			}
+		}
 		m_conversationManager->getComponent()->getStanzaChannel()->sendMessage(message);
+	}
 	else {
 		std::string legacyName = m_legacyName;
 		if (legacyName.find_last_of("@") != std::string::npos) {
 			legacyName.replace(legacyName.find_last_of("@"), 1, "%"); // OK
+		}
 		std::string n = nickname;
 		if (n.empty()) {
 			n = " ";
+		}
 		message->setTo(m_jid);
 		message->setFrom(Swift::JID(legacyName, m_conversationManager->getComponent()->getJID().toBare(), n));
 		m_conversationManager->getComponent()->getStanzaChannel()->sendMessage(message);
 		BOOST_FOREACH(const Swift::JID &jid, m_jids) {
 			message->setTo(jid);
 			message->setFrom(Swift::JID(legacyName, m_conversationManager->getComponent()->getJID().toBare(), n));
 			m_conversationManager->getComponent()->getStanzaChannel()->sendMessage(message);
+		}
+	}
+}
 void Conversation::handleParticipantChanged(const std::string &nick, int flag, int status, const std::string &statusMessage, const std::string &newname) {
 void Conversation::sendParticipants(const Swift::JID &to) {
 	for (std::map<std::string, Participant>::iterator it = m_participants.begin(); it != m_participants.end(); it++) {
 		Swift::Presence::ref presence = generatePresence(it->first, it->second.flag, it->second.status, it->second.statusMessage, "");
 		presence->setTo(to);
 		m_conversationManager->getComponent()->getStanzaChannel()->sendPresence(presence);
+	}
+}
 Swift::Presence::ref Conversation::generatePresence(const std::string &nick, int flag, int status, const std::string &statusMessage, const std::string &newname) {
 	std::string nickname = nick;
 	Swift::Presence::ref presence = Swift::Presence::create();
 	std::string legacyName = m_legacyName;
 	if (m_muc) {
 		if (legacyName.find_last_of("@") != std::string::npos) {
 			legacyName.replace(legacyName.find_last_of("@"), 1, "%"); // OK
+		}
+	}
 	presence->setFrom(Swift::JID(legacyName, m_conversationManager->getComponent()->getJID().toBare(), nickname));
 	presence->setTo(m_jid);
 	presence->setType(Swift::Presence::Available);
 	if (!statusMessage.empty())
 		presence->setStatus(statusMessage);
 	Swift::StatusShow s((Swift::StatusShow::Type) status);
 	if (s.getType() == Swift::StatusShow::None) {
 		presence->setType(Swift::Presence::Unavailable);
+	}
 	presence->setShow(s.getType());
 	Swift::MUCUserPayload *p = new Swift::MUCUserPayload ();
 	if (m_nickname == nickname) {
 		Swift::MUCUserPayload::StatusCode c;
 		c.code = 110;
 		p->addStatusCode(c);
+	}
 	Swift::MUCItem item;
 	item.affiliation = Swift::MUCOccupant::Member;
 	item.role = Swift::MUCOccupant::Participant;
 	if (flag & Moderator) {
 		item.affiliation = Swift::MUCOccupant::Admin;
 		item.role = Swift::MUCOccupant::Moderator;
+	}
 	if (!newname.empty()) {
 		item.nick = newname;
 		Swift::MUCUserPayload::StatusCode c;
 		c.code = 303;
 		p->addStatusCode(c);
 		presence->setType(Swift::Presence::Unavailable);
+	}
 	p->addItem(item);
 	presence->addPayload(boost::shared_ptr<Swift::Payload>(p));
 	m_conversationManager->getComponent()->getStanzaChannel()->sendPresence(presence);
 	return presence;
+}
 void Conversation::handleParticipantChanged(const std::string &nick, int flag, int status, const std::string &statusMessage, const std::string &newname) {
 	Swift::Presence::ref presence = generatePresence(nick, flag, status, statusMessage, newname);
 	if (presence->getType() == Swift::Presence::Unavailable) {
 		m_participants.erase(nick);
+	}
 	else {
 		Participant p;
 		p.flag = flag;
 		p.status = status;
 		p.statusMessage = statusMessage;
 		m_participants[nick] = p;
+	}
 	BOOST_FOREACH(const Swift::JID &jid, m_jids) {
 		presence->setTo(jid);
 		m_conversationManager->getComponent()->getStanzaChannel()->sendPresence(presence);
+	}
 	if (!newname.empty()) {
 		handleParticipantChanged(newname, flag, status, statusMessage);
+	}
+}
+}

src/conversationmanager.cpp

➞

Show inline comments

 /**
  * XMPP - libpurple transport
+ *
  * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/conversationmanager.h"
 #include "transport/conversation.h"
 #include "transport/usermanager.h"
 #include "transport/buddy.h"
 #include "transport/factory.h"
 #include "transport/user.h"
 #include "transport/logging.h"
 #include "Swiften/Roster/SetRosterRequest.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/Elements/RosterItemPayload.h"
 namespace Transport {
 DEFINE_LOGGER(logger, "ConversationManager");
 ConversationManager::ConversationManager(User *user, Component *component){
 	m_user = user;
 	m_component = component;
+}
 ConversationManager::~ConversationManager() {
 	while(!m_convs.empty()) {
 		LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Removing conversation " << (*m_convs.begin()).first);
 		(*m_convs.begin()).second->destroyRoom();
 		delete (*m_convs.begin()).second;
 		m_convs.erase(m_convs.begin());
+	}
+}
 Conversation *ConversationManager::getConversation(const std::string &name) {
 	if (m_convs.find(name) != m_convs.end())
 		return m_convs[name];
 	if (name.find("/") == std::string::npos) {
 		return NULL;
+	}
 	// handle PMs
 	std::string room = name.substr(0, name.find("/"));
 	std::string nick = name.substr(name.find("/") + 1);
 	if (getConversation(room) == NULL) {
 		return NULL;
+	}
 	return getConversation(nick);
+}
 void ConversationManager::addConversation(Conversation *conv) {
 	m_convs[conv->getLegacyName()] = conv;
 	LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Adding conversation " << conv->getLegacyName());
+}
 void ConversationManager::removeConversation(Conversation *conv) {
 	for (std::map<std::string, Conversation *>::const_iterator it = m_convs.begin(); it != m_convs.end(); it++) {
 		if ((*it).second->getRoom() == conv->getLegacyName()) {
 			(*it).second->setRoom("");
+		}
+	}
 	m_convs.erase(conv->getLegacyName());
+}
 void ConversationManager::resetResources() {
 	for (std::map<std::string, Conversation *>::const_iterator it = m_convs.begin(); it != m_convs.end(); it++) {
 		if ((*it).second->isMUC()) {
 			continue;
+		}
 		(*it).second->setJID(m_user->getJID().toBare());
+	}
+}
 void ConversationManager::removeJID(const Swift::JID &jid) {
 	for (std::map<std::string, Conversation *>::const_iterator it = m_convs.begin(); it != m_convs.end(); it++) {
 		(*it).second->removeJID(jid);
+	}
+}
 void ConversationManager::handleMessageReceived(Swift::Message::ref message) {
 // 	std::string name = message->getTo().getUnescapedNode();
 // 	if (name.find_last_of("%") != std::string::npos) { // OK when commented
 // 		name.replace(name.find_last_of("%"), 1, "@"); // OK when commented
 // 	}
 	std::string name = Buddy::JIDToLegacyName(message->getTo());
 	if (name.empty()) {
 		LOG4CXX_WARN(logger, m_user->getJID().toString() << ": Tried to create empty conversation");
 		return;
+	}
 	// create conversation if it does not exist.
 	if (!m_convs[name]) {
 		Conversation *conv = m_component->getFactory()->createConversation(this, name);
 		addConversation(conv);
+	}
 	// if it exists and it's MUC, but this message is PM, get PM conversation or create new one.
 	else if (m_convs[name]->isMUC() && message->getType() != Swift::Message::Groupchat) {
 		std::string room_name = name;
 		name = room_name + "/" + message->getTo().getResource();
 		if (m_convs.find(name) == m_convs.end()) {
 			Conversation *conv = m_component->getFactory()->createConversation(this, message->getTo().getResource());
 			conv->setRoom(room_name);
 			conv->setNickname(name);
 			addConversation(conv);
+		}
+	}
 	// update resource and send the message
 	m_convs[name]->setJID(message->getFrom());
 	m_convs[name]->sendMessage(message);
+}
+}

src/networkpluginserver.cpp

➞

Show inline comments

 /**
  * libtransport -- C++ library for easy XMPP Transports development
+ *
  * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/networkpluginserver.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/storagebackend.h"
 #include "transport/rostermanager.h"
 #include "transport/usermanager.h"
 #include "transport/conversationmanager.h"
 #include "transport/localbuddy.h"
 #include "transport/config.h"
 #include "transport/conversation.h"
 #include "transport/vcardresponder.h"
 #include "transport/rosterresponder.h"
 #include "transport/memoryreadbytestream.h"
 #include "transport/logging.h"
 #include "transport/admininterface.h"
 #include "blockresponder.h"
 #include "Swiften/Swiften.h"
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Elements/StreamError.h"
 #include "Swiften/Network/BoostConnectionServer.h"
 #include "Swiften/Elements/AttentionPayload.h"
 #include "Swiften/Elements/XHTMLIMPayload.h"
 #include "Swiften/Elements/InvisiblePayload.h"
 #include "Swiften/Elements/SpectrumErrorPayload.h"
 #include "transport/protocol.pb.h"
 #include "transport/util.h"
 #include "utf8.h"
 #include <Swiften/FileTransfer/ReadBytestream.h>
 #include <Swiften/Elements/StreamInitiationFileInfo.h>
 #ifdef _WIN32
 #include "windows.h"
 #include <stdint.h>
 #else
 #include "sys/wait.h"
 #include "sys/signal.h"
 #include <sys/types.h>
 #include <signal.h>
 #include "popt.h"
 #endif
 using namespace Transport::Util;
 namespace Transport {
 static unsigned long backend_id;
 static unsigned long bytestream_id;
 DEFINE_LOGGER(logger, "NetworkPluginServer");
 class NetworkConversation : public Conversation {
 	public:
 		NetworkConversation(ConversationManager *conversationManager, const std::string &legacyName, bool muc = false) : Conversation(conversationManager, legacyName, muc) {
+		}
 		// Called when there's new message to legacy network from XMPP network
 		void sendMessage(boost::shared_ptr<Swift::Message> &message) {
 			onMessageToSend(this, message);
+		}
 		boost::signal<void (NetworkConversation *, boost::shared_ptr<Swift::Message> &)> onMessageToSend;
 };
 class NetworkFactory : public Factory {
 	public:
 		NetworkFactory(NetworkPluginServer *nps) {
 			m_nps = nps;
+		}
 		virtual ~NetworkFactory() {}
 		// Creates new conversation (NetworkConversation in this case)
 		Conversation *createConversation(ConversationManager *conversationManager, const std::string &legacyName) {
 			NetworkConversation *nc = new NetworkConversation(conversationManager, legacyName);
 			nc->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, m_nps, _1, _2));
 			return nc;
+		}
 		// Creates new LocalBuddy
 		Buddy *createBuddy(RosterManager *rosterManager, const BuddyInfo &buddyInfo) {
 			LocalBuddy *buddy = new LocalBuddy(rosterManager, buddyInfo.id, buddyInfo.legacyName, buddyInfo.alias, buddyInfo.groups, (BuddyFlag) buddyInfo.flags);
 			if (!buddy->isValid()) {
 				delete buddy;
 				return NULL;
+			}
 			if (buddyInfo.subscription == "both") {
 				buddy->setSubscription(Buddy::Both);
+			}
 			else {
 				buddy->setSubscription(Buddy::Ask);
+			}
 			if (buddyInfo.settings.find("icon_hash") != buddyInfo.settings.end())
 				buddy->setIconHash(buddyInfo.settings.find("icon_hash")->second.s);
 			return buddy;
+		}
 	private:
 		NetworkPluginServer *m_nps;
 };
 // Wraps google protobuf payload into WrapperMessage and serialize it to string
 #define WRAP(MESSAGE, TYPE) 	pbnetwork::WrapperMessage wrap; \
 	wrap.set_type(TYPE); \
 	wrap.set_payload(MESSAGE); \
 	wrap.SerializeToString(&MESSAGE);
 // Executes new backend
 static unsigned long exec_(const std::string& exePath, const char *host, const char *port, const char *cmdlineArgs) {
 	// BACKEND_ID is replaced with unique ID. The ID is increasing for every backend.
 	std::string finalExePath = boost::replace_all_copy(exePath, "BACKEND_ID", boost::lexical_cast<std::string>(backend_id++));
 #ifdef _WIN32
 	// Add host and port.
 	std::ostringstream fullCmdLine;
 	fullCmdLine << "\"" << finalExePath << "\" --host " << host << " --port " << port;
 	if (cmdlineArgs)
 		fullCmdLine << " " << cmdlineArgs;
 	LOG4CXX_INFO(logger, "Starting new backend " << fullCmdLine.str());
 	// We must provide a non-const buffer to CreateProcess below
 	std::vector<wchar_t> rawCommandLineArgs( fullCmdLine.str().size() + 1 );
 	wcscpy_s(&rawCommandLineArgs[0], rawCommandLineArgs.size(), utf8ToUtf16(fullCmdLine.str()).c_str());
 	STARTUPINFO         si;
 	PROCESS_INFORMATION pi;
 	ZeroMemory (&si, sizeof(si));
 	si.cb=sizeof (si);
 	if (! CreateProcess(
 		utf8ToUtf16(finalExePath).c_str(),
 		&rawCommandLineArgs[0],
 ,                    // process attributes
 ,                    // thread attributes
 ,                    // inherit handles
 ,                    // creation flags
 ,                    // environment
 ,                    // cwd
 		&si,
 		&pi
+		)
 	)  {
 		LOG4CXX_ERROR(logger, "Could not start process");
+	}
 	return 0;
 #else
 	// Add host and port.
 	finalExePath += std::string(" --host ") + host + " --port " + port + " " + cmdlineArgs;
 	LOG4CXX_INFO(logger, "Starting new backend " << finalExePath);
 	// Create array of char * from string using -lpopt library
 	char *p = (char *) malloc(finalExePath.size() + 1);
 	strcpy(p, finalExePath.c_str());
 	int argc;
 	char **argv;
 	poptParseArgvString(p, &argc, (const char ***) &argv);
 	// fork and exec
 	pid_t pid = fork();
 	if ( pid == 0 ) {
 		setsid();
 		// child process
 		errno = 0;
 		int ret = execv(argv[0], argv);
 		if (ret == -1) {
 			exit(errno);
+		}
 		exit(0);
 	} else if ( pid < 0 ) {
 		LOG4CXX_ERROR(logger, "Fork failed");
+	}
 	free(p);
 	return (unsigned long) pid;
 #endif
+}
 #ifndef _WIN32
 static void SigCatcher(int n) {
 	pid_t result;
 	int status;
 	// Read exit code from all children to not have zombies arround
 	// WARNING: Do not put LOG4CXX_ here, because it can lead to deadlock
 	while ((result = waitpid(-1, &status, WNOHANG)) > 0) {
 		if (result != 0) {
 			if (WIFEXITED(status)) {
 				if (WEXITSTATUS(status) != 0) {
 // 					LOG4CXX_ERROR(logger, "Backend can not be started, exit_code=" << WEXITSTATUS(status));
+				}
+			}
 			else {
 // 				LOG4CXX_ERROR(logger, "Backend can not be started");
+			}
+		}
+	}
+}
 #endif
 static void handleBuddyPayload(LocalBuddy *buddy, const pbnetwork::Buddy &payload) {
 	// Set alias only if it's not empty. Backends are allowed to send empty alias if it has
 	// not changed.
 	if (!payload.alias().empty()) {
 		buddy->setAlias(payload.alias());
+	}
 	// Change groups if it's not empty. The same as above...
 	std::vector<std::string> groups;
 	for (int i = 0; i < payload.group_size(); i++) {
 		groups.push_back(payload.group(i));
+	}
 	if (!groups.empty()) {
 		buddy->setGroups(groups);
+	}
 	buddy->setStatus(Swift::StatusShow((Swift::StatusShow::Type) payload.status()), payload.statusmessage());
 	buddy->setIconHash(payload.iconhash());
 	buddy->setBlocked(payload.blocked());
+}
 NetworkPluginServer::NetworkPluginServer(Component *component, Config *config, UserManager *userManager, FileTransferManager *ftManager) {
 	m_ftManager = ftManager;
 	m_userManager = userManager;
 	m_config = config;
 	m_component = component;
 	m_isNextLongRun = false;
 	m_adminInterface = NULL;
 	m_startingBackend = false;
@@ @@ -1003,493 +1005,509 @@ void NetworkPluginServer::pingTimeout() { @@
 			// when registering backend.
 			if ((*it)->pongReceived) {
 				sendPing((*it));
+			}
+		}
 		else {
 			LOG4CXX_INFO(logger, "Disconnecting backend " << (*it) << " (ID=" << (*it)->id << "). PING response not received.");
 			toRemove.push_back(*it);
 #ifndef WIN32
 			// generate coredump for this backend to find out why it wasn't able to respond to PING
 			std::string pid = (*it)->id;
 			if (!pid.empty()) {
 				try {
 					kill(boost::lexical_cast<int>(pid), SIGABRT);
+				}
 				catch (...) { }
+			}
 #endif
+		}
 		if ((*it)->users.size() == 0) {
 			LOG4CXX_INFO(logger, "Disconnecting backend " << (*it) << " (ID=" << (*it)->id << "). There are no users.");
 			toRemove.push_back(*it);
+		}
+	}
 	BOOST_FOREACH(Backend *b, toRemove) {
 		handleSessionFinished(b);
+	}
 	m_pingTimer->start();
+}
 void NetworkPluginServer::collectBackend() {
 	// Stop accepting new users to backend with the biggest memory usage. This prevents backends
 	// which are leaking to eat whole memory by connectin new users to legacy network.
 	LOG4CXX_INFO(logger, "Collect backend called, finding backend which will be set to die");
 	unsigned long max = 0;
 	Backend *backend = NULL;
 	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {
 		if ((*it)->res > max) {
 			max = (*it)->res;
 			backend = (*it);
+		}
+	}
 	if (backend) {
 		if (m_collectTimer) {
 			m_collectTimer->start();
+		}
 		LOG4CXX_INFO(logger, "Backend " << backend << " (ID=" << backend->id << ") is set to die");
 		backend->acceptUsers = false;
+	}
+}
 bool NetworkPluginServer::moveToLongRunBackend(User *user) {
 	// Check if user has already some backend
 	Backend *old = (Backend *) user->getData();
 	if (!old) {
 		LOG4CXX_INFO(logger, "User " << user->getJID().toString() << " does not have old backend. Not moving.");
 		return true;
+	}
 	// if he's already on long run, do nothing
 	if (old->longRun) {
 		LOG4CXX_INFO(logger, "User " << user->getJID().toString() << " is already on long-running backend. Not moving.");
 		return true;
+	}
 	// Get free longrun backend, if there's no longrun backend, create one and wait
 	// for its connection
 	Backend *backend = getFreeClient(false, true);
 	if (!backend) {
 		LOG4CXX_INFO(logger, "No free long-running backend for user " << user->getJID().toString() << ". Will try later");
 		return false;
+	}
 	// old backend will trigger disconnection which has to be ignored to keep user online
 	user->setIgnoreDisconnect(true);
 	// remove user from the old backend
 	// If backend is empty, it will be collected by pingTimeout
 	old->users.remove(user);
 	// switch to new backend and connect
 	user->setData(backend);
 	backend->users.push_back(user);
 	// connect him
 	handleUserReadyToConnect(user);
 	return true;
+}
 void NetworkPluginServer::handleUserCreated(User *user) {
 	// Get free backend to handle this user or spawn new one if there's no free one.
 	Backend *c = getFreeClient();
 	// Add user to queue if there's no free backend to handle him so far.
 	if (!c) {
 		LOG4CXX_INFO(logger, "There is no backend to handle user " << user->getJID().toString() << ". Adding him to queue.");
 		m_waitingUsers.push_back(user);
 		return;
+	}
 	// Associate users with backend
 	user->setData(c);
 	c->users.push_back(user);
 	// Don't forget to disconnect these in handleUserDestroyed!!!
 	user->onReadyToConnect.connect(boost::bind(&NetworkPluginServer::handleUserReadyToConnect, this, user));
 	user->onPresenceChanged.connect(boost::bind(&NetworkPluginServer::handleUserPresenceChanged, this, user, _1));
 	user->onRoomJoined.connect(boost::bind(&NetworkPluginServer::handleRoomJoined, this, user, _1, _2, _3, _4));
 	user->onRoomLeft.connect(boost::bind(&NetworkPluginServer::handleRoomLeft, this, user, _1));
+}
 void NetworkPluginServer::handleUserReadyToConnect(User *user) {
 	UserInfo userInfo = user->getUserInfo();
 	pbnetwork::Login login;
 	login.set_user(user->getJID().toBare());
 	login.set_legacyname(userInfo.uin);
 	login.set_password(userInfo.password);
 	std::string message;
 	login.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_LOGIN);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleUserPresenceChanged(User *user, Swift::Presence::ref presence) {
 	if (presence->getShow() == Swift::StatusShow::None)
 		return;
 	UserInfo userInfo = user->getUserInfo();
 	pbnetwork::Status status;
 	status.set_username(user->getJID().toBare());
 	bool isInvisible = presence->getPayload<Swift::InvisiblePayload>() != NULL;
 	if (isInvisible) {
 		LOG4CXX_INFO(logger, "This presence is invisible");
 		status.set_status((pbnetwork::STATUS_INVISIBLE));
+	}
 	else {
 		status.set_status((pbnetwork::StatusType) presence->getShow());
+	}
 	status.set_statusmessage(presence->getStatus());
 	std::string message;
 	status.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_STATUS_CHANGED);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleRoomJoined(User *user, const Swift::JID &who, const std::string &r, const std::string &nickname, const std::string &password) {
 	UserInfo userInfo = user->getUserInfo();
 	pbnetwork::Room room;
 	room.set_username(user->getJID().toBare());
 	room.set_nickname(nickname);
 	room.set_room(r);
 	room.set_password(password);
 	std::string message;
 	room.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_JOIN_ROOM);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
 	NetworkConversation *conv = new NetworkConversation(user->getConversationManager(), r, true);
 	user->getConversationManager()->addConversation(conv);
 	conv->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, this, _1, _2));
 	conv->setNickname(nickname);
-	conv->setJID(who);
+	conv->addJID(who);
+}
 void NetworkPluginServer::handleRoomLeft(User *user, const std::string &r) {
 	UserInfo userInfo = user->getUserInfo();
 	pbnetwork::Room room;
 	room.set_username(user->getJID().toBare());
 	room.set_nickname("");
 	room.set_room(r);
 	room.set_password("");
 	std::string message;
 	room.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_LEAVE_ROOM);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleUserDestroyed(User *user) {
 	m_waitingUsers.remove(user);
 	UserInfo userInfo = user->getUserInfo();
 	user->onReadyToConnect.disconnect(boost::bind(&NetworkPluginServer::handleUserReadyToConnect, this, user));
 	user->onPresenceChanged.disconnect(boost::bind(&NetworkPluginServer::handleUserPresenceChanged, this, user, _1));
 	user->onRoomJoined.disconnect(boost::bind(&NetworkPluginServer::handleRoomJoined, this, user, _1, _2, _3, _4));
 	user->onRoomLeft.disconnect(boost::bind(&NetworkPluginServer::handleRoomLeft, this, user, _1));
 	pbnetwork::Logout logout;
 	logout.set_user(user->getJID().toBare());
 	logout.set_legacyname(userInfo.uin);
 	std::string message;
 	logout.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_LOGOUT);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
 	c->users.remove(user);
 	// If backend should handle only one user, it must not accept another one before
 	// we kill it, so set up willDie to true
 	if (c->users.size() == 0 && CONFIG_INT(m_config, "service.users_per_backend") == 1) {
 		LOG4CXX_INFO(logger, "Backend " << c->id << " will die, because the last user disconnected");
 		c->willDie = true;
+	}
+}
 void NetworkPluginServer::handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &msg) {
 	conv->getConversationManager()->getUser()->updateLastActivity();
 	boost::shared_ptr<Swift::ChatState> statePayload = msg->getPayload<Swift::ChatState>();
 	if (statePayload) {
 		pbnetwork::WrapperMessage_Type type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED;
 		switch (statePayload->getChatState()) {
 			case Swift::ChatState::Active:
 				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_STOPPED_TYPING;
 				break;
 			case Swift::ChatState::Composing:
 				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING;
 				break;
 			case Swift::ChatState::Paused:
 				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPED;
 				break;
 			default:
 				break;
+		}
 		if (type != pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED) {
 			pbnetwork::Buddy buddy;
 			buddy.set_username(conv->getConversationManager()->getUser()->getJID().toBare());
 			buddy.set_buddyname(conv->getLegacyName());
 			std::string message;
 			buddy.SerializeToString(&message);
 			WRAP(message, type);
 			Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 			if (!c) {
 				return;
+			}
 			send(c->connection, message);
+		}
+	}
 	boost::shared_ptr<Swift::AttentionPayload> attentionPayload = msg->getPayload<Swift::AttentionPayload>();
 	if (attentionPayload) {
 		pbnetwork::ConversationMessage m;
 		m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());
 		m.set_buddyname(conv->getLegacyName());
 		m.set_message(msg->getBody());
 		std::string message;
 		m.SerializeToString(&message);
 		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_ATTENTION);
 		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 		send(c->connection, message);
 		return;
+	}
 	if (!msg->getSubject().empty()) {
 		pbnetwork::ConversationMessage m;
 		m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());
 		m.set_buddyname(conv->getLegacyName());
 		m.set_message(msg->getSubject());
 		std::string message;
 		m.SerializeToString(&message);
 		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_ROOM_SUBJECT_CHANGED);
 		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 		send(c->connection, message);
 		return;
+	}
 	std::string xhtml;
 	boost::shared_ptr<Swift::XHTMLIMPayload> xhtmlPayload = msg->getPayload<Swift::XHTMLIMPayload>();
 	if (xhtmlPayload) {
 		xhtml = xhtmlPayload->getBody();
+	}
 	// Send normal message
 	if (!msg->getBody().empty() || !xhtml.empty()) {
 		pbnetwork::ConversationMessage m;
 		m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());
 		m.set_buddyname(conv->getLegacyName());
 		m.set_message(msg->getBody());
 		m.set_xhtml(xhtml);
 		std::string message;
 		m.SerializeToString(&message);
 		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE);
 		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 		if (!c) {
 			return;
+		}
 		send(c->connection, message);
+	}
+}
 void NetworkPluginServer::handleBuddyRemoved(Buddy *b) {
 	User *user = b->getRosterManager()->getUser();
 	pbnetwork::Buddy buddy;
 	buddy.set_username(user->getJID().toBare());
 	buddy.set_buddyname(b->getName());
 	buddy.set_alias(b->getAlias());
 	BOOST_FOREACH(const std::string &g, b->getGroups()) {
 		buddy.add_group(g);
+	}
 	buddy.set_status(pbnetwork::STATUS_NONE);
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_REMOVED);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleBuddyUpdated(Buddy *b, const Swift::RosterItemPayload &item) {
 	User *user = b->getRosterManager()->getUser();
 	dynamic_cast<LocalBuddy *>(b)->setAlias(item.getName());
 	dynamic_cast<LocalBuddy *>(b)->setGroups(item.getGroups());
 	pbnetwork::Buddy buddy;
 	buddy.set_username(user->getJID().toBare());
 	buddy.set_buddyname(b->getName());
 	buddy.set_alias(b->getAlias());
 	BOOST_FOREACH(const std::string &g, b->getGroups()) {
 		buddy.add_group(g);
+	}
 	buddy.set_status(pbnetwork::STATUS_NONE);
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleBuddyAdded(Buddy *buddy, const Swift::RosterItemPayload &item) {
 	handleBuddyUpdated(buddy, item);
+}
 void NetworkPluginServer::handleBlockToggled(Buddy *b) {
 	User *user = b->getRosterManager()->getUser();
 	pbnetwork::Buddy buddy;
 	buddy.set_username(user->getJID().toBare());
 	buddy.set_buddyname(b->getName());
 	buddy.set_alias(b->getAlias());
 	BOOST_FOREACH(const std::string &g, b->getGroups()) {
 		buddy.add_group(g);
+	}
 	buddy.set_status(pbnetwork::STATUS_NONE);
 	buddy.set_blocked(!b->isBlocked());
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> v) {
 	pbnetwork::VCard vcard;
 	vcard.set_username(user->getJID().toBare());
 	vcard.set_buddyname("");
 	vcard.set_id(0);
 	vcard.set_photo(&v->getPhoto()[0], v->getPhoto().size());
 	vcard.set_nickname(v->getNickname());
 	std::string message;
 	vcard.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_VCARD);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleVCardRequired(User *user, const std::string &name, unsigned int id) {
 	pbnetwork::VCard vcard;
 	vcard.set_username(user->getJID().toBare());
 	vcard.set_buddyname(name);
 	vcard.set_id(id);
 	std::string message;
 	vcard.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_VCARD);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleFTAccepted(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID) {
 	pbnetwork::File f;
 	f.set_username(user->getJID().toBare());
 	f.set_buddyname(buddyName);
 	f.set_filename(fileName);
 	f.set_size(size);
 	f.set_ftid(ftID);
 	std::string message;
 	f.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_START);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleFTRejected(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size) {
 	pbnetwork::File f;
 	f.set_username(user->getJID().toBare());
 	f.set_buddyname(buddyName);
 	f.set_filename(fileName);
 	f.set_size(size);
 	f.set_ftid(0);
 	std::string message;
 	f.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_FINISH);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleFTStateChanged(Swift::FileTransfer::State state, const std::string &userName, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long id) {
 	User *user = m_userManager->getUser(userName);
 	if (!user) {
 		// TODO: FIXME We have to remove filetransfer when use disconnects

src/tests/basictest.cpp

➞

Show inline comments

 #include "basictest.h"
 #include "transport/userregistry.h"
 #include "transport/config.h"
 #include "transport/storagebackend.h"
 #include "transport/userregistration.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 "Swiften/Serializer/GenericPayloadSerializer.h"
 #include "../storageparser.h"
 #include "Swiften/Parser/PayloadParsers/AttentionParser.h"
 #include "Swiften/Serializer/PayloadSerializers/AttentionSerializer.h"
 #include "Swiften/Parser/PayloadParsers/XHTMLIMParser.h"
 #include "Swiften/Serializer/PayloadSerializers/XHTMLIMSerializer.h"
 #include "Swiften/Parser/PayloadParsers/StatsParser.h"
 #include "Swiften/Serializer/PayloadSerializers/StatsSerializer.h"
 #include "Swiften/Parser/PayloadParsers/GatewayPayloadParser.h"
 #include "Swiften/Serializer/PayloadSerializers/GatewayPayloadSerializer.h"
 #include "Swiften/Serializer/PayloadSerializers/SpectrumErrorSerializer.h"
 #include "Swiften/Parser/PayloadParsers/MUCPayloadParser.h"
 #include "transport/BlockParser.h"
 #include "transport/BlockSerializer.h"
 #include "Swiften/Parser/PayloadParsers/InvisibleParser.h"
 #include "Swiften/Serializer/PayloadSerializers/InvisibleSerializer.h"
 using namespace Transport;
 void BasicTest::setMeUp (void) {
 	streamEnded = false;
 	std::istringstream ifs("service.server_mode = 1\nservice.jid=localhost");
+	std::istringstream ifs("service.server_mode = 1\nservice.jid=localhost\nservice.more_resources=1\n");
 	cfg = new Config();
 	cfg->load(ifs);
 	factory = new TestingFactory();
 	storage = new TestingStorageBackend();
 	loop = new Swift::DummyEventLoop();
 	factories = new Swift::DummyNetworkFactories(loop);
 	userRegistry = new UserRegistry(cfg, factories);
 	component = new Component(loop, factories, cfg, factory, userRegistry);
 	component->start();
 	userManager = new UserManager(component, userRegistry, storage);
 	userRegistration = new UserRegistration(component, userManager, storage);
 	userRegistration->start();
 	itemsResponder = new DiscoItemsResponder(component);
 	itemsResponder->start();
 	payloadSerializers = new Swift::FullPayloadSerializerCollection();
 	payloadParserFactories = new Swift::FullPayloadParserFactoryCollection();
 	payloadParserFactories->addFactory(new Swift::GenericPayloadParserFactory<StorageParser>("private", "jabber:iq:private"));
 	payloadParserFactories->addFactory(new Swift::GenericPayloadParserFactory<Swift::AttentionParser>("attention", "urn:xmpp:attention:0"));
 	payloadParserFactories->addFactory(new Swift::GenericPayloadParserFactory<Swift::XHTMLIMParser>("html", "http://jabber.org/protocol/xhtml-im"));
 	payloadParserFactories->addFactory(new Swift::GenericPayloadParserFactory<Transport::BlockParser>("block", "urn:xmpp:block:0"));
 	payloadParserFactories->addFactory(new Swift::GenericPayloadParserFactory<Swift::InvisibleParser>("invisible", "urn:xmpp:invisible:0"));
 	payloadParserFactories->addFactory(new Swift::GenericPayloadParserFactory<Swift::StatsParser>("query", "http://jabber.org/protocol/stats"));
 	payloadParserFactories->addFactory(new Swift::GenericPayloadParserFactory<Swift::GatewayPayloadParser>("query", "jabber:iq:gateway"));
 	payloadParserFactories->addFactory(new Swift::GenericPayloadParserFactory<Swift::MUCPayloadParser>("x", "http://jabber.org/protocol/muc"));
 	payloadSerializers->addSerializer(new Swift::AttentionSerializer());
 	payloadSerializers->addSerializer(new Swift::XHTMLIMSerializer());
 	payloadSerializers->addSerializer(new Transport::BlockSerializer());
 	payloadSerializers->addSerializer(new Swift::InvisibleSerializer());
 	payloadSerializers->addSerializer(new Swift::StatsSerializer());
 	payloadSerializers->addSerializer(new Swift::SpectrumErrorSerializer());
 	payloadSerializers->addSerializer(new Swift::GatewayPayloadSerializer());
 	parser = new Swift::XMPPParser(this, payloadParserFactories, factories->getXMLParserFactory());
 	parser2 = new Swift::XMPPParser(this, payloadParserFactories, factories->getXMLParserFactory());
 	serverFromClientSession = boost::shared_ptr<Swift::ServerFromClientSession>(new Swift::ServerFromClientSession("id", factories->getConnectionFactory()->createConnection(),
 			payloadParserFactories, payloadSerializers, userRegistry, factories->getXMLParserFactory(), Swift::JID("user@localhost/resource")));
 	serverFromClientSession->startSession();
 	serverFromClientSession->onDataWritten.connect(boost::bind(&BasicTest::handleDataReceived, this, _1));
 	dynamic_cast<Swift::ServerStanzaChannel *>(component->getStanzaChannel())->addSession(serverFromClientSession);
 	parser->parse("<stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' to='localhost' version='1.0'>");
 	parser2->parse("<stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' to='localhost' version='1.0'>");
 	received.clear();
 	received2.clear();
 	receivedData.clear();
 	loop->processEvents();
+}
 void BasicTest::tearMeDown (void) {
 	dynamic_cast<Swift::ServerStanzaChannel *>(component->getStanzaChannel())->removeSession(serverFromClientSession);
 	if (serverFromClientSession2) {
 		dynamic_cast<Swift::ServerStanzaChannel *>(component->getStanzaChannel())->removeSession(serverFromClientSession2);
 		serverFromClientSession2.reset();
+	}
 	delete component;
 	delete userRegistry;
 	delete factories;
 	delete factory;
 	delete loop;
 	delete cfg;
 	delete parser;
 	delete parser2;
 	delete storage;
 	delete userRegistration;
 	delete itemsResponder;
 	received.clear();
 	received2.clear();
 	receivedData.clear();
 	receivedData2.clear();
+}
 void BasicTest::handleDataReceived(const Swift::SafeByteArray &data) {
 // 	std::cout << safeByteArrayToString(data) << "\n";
 	stream1_active = true;
 	receivedData += safeByteArrayToString(data) + "\n";
 	parser->parse(safeByteArrayToString(data));
+}
 void BasicTest::handleDataReceived2(const Swift::SafeByteArray &data) {
 // 	std::cout << safeByteArrayToString(data) << "\n";
 	stream1_active = false;
 	receivedData2 += safeByteArrayToString(data) + "\n";
 	parser2->parse(safeByteArrayToString(data));
+}
 void BasicTest::handleStreamStart(const Swift::ProtocolHeader&) {
+}
 void BasicTest::dumpReceived() {
 	std::cout << "\nStream1:\n";
 	std::cout << receivedData << "\n";
 	std::cout << "Stream2:\n";
 	std::cout << receivedData2 << "\n";
+}
 void BasicTest::handleElement(boost::shared_ptr<Swift::Element> element) {
 	received.push_back(element);
 	if (stream1_active) {
 		received.push_back(element);
+	}
 	else {
 		received2.push_back(element);
+	}
+}
 void BasicTest::handleStreamEnd() {
 	streamEnded = true;
+}
 void BasicTest::injectPresence(boost::shared_ptr<Swift::Presence> &response) {
 	dynamic_cast<Swift::ServerStanzaChannel *>(component->getStanzaChannel())->onPresenceReceived(response);
+}
 void BasicTest::injectIQ(boost::shared_ptr<Swift::IQ> iq) {
 	dynamic_cast<Swift::ServerStanzaChannel *>(component->getStanzaChannel())->onIQReceived(iq);
+}
 void BasicTest::injectMessage(boost::shared_ptr<Swift::Message> msg) {
 	dynamic_cast<Swift::ServerStanzaChannel *>(component->getStanzaChannel())->onMessageReceived(msg);
+}
 Swift::Stanza *BasicTest::getStanza(boost::shared_ptr<Swift::Element> element) {
 	Swift::Stanza *stanza = dynamic_cast<Swift::Stanza *>(element.get());
 	CPPUNIT_ASSERT(stanza);
 	return stanza;
+}
 void BasicTest::connectUser() {
 	CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());
 	userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource"), serverFromClientSession.get(), Swift::createSafeByteArray("password"));
 	userRegistry->onPasswordValid(Swift::JID("user@localhost/resource"));
 	loop->processEvents();
 	CPPUNIT_ASSERT_EQUAL(1, userManager->getUserCount());
 	User *user = userManager->getUser("user@localhost");
 	CPPUNIT_ASSERT(user);
 	UserInfo userInfo = user->getUserInfo();
 	CPPUNIT_ASSERT_EQUAL(std::string("password"), userInfo.password);
 	CPPUNIT_ASSERT(user->isReadyToConnect() == true);
 	CPPUNIT_ASSERT(user->isConnected() == false);
 	user->setConnected(true);
 	CPPUNIT_ASSERT(user->isConnected() == true);
-	CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
+	CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 	CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 	received.clear();
 	receivedData.clear();
+}
 void BasicTest::connectSecondResource() {
 	serverFromClientSession2 = boost::shared_ptr<Swift::ServerFromClientSession>(new Swift::ServerFromClientSession("id", factories->getConnectionFactory()->createConnection(),
 			payloadParserFactories, payloadSerializers, userRegistry, factories->getXMLParserFactory(), Swift::JID("user@localhost/resource2")));
 	serverFromClientSession2->startSession();
 	serverFromClientSession2->onDataWritten.connect(boost::bind(&BasicTest::handleDataReceived2, this, _1));
 	dynamic_cast<Swift::ServerStanzaChannel *>(component->getStanzaChannel())->addSession(serverFromClientSession2);
 	userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource2"), serverFromClientSession2.get(), Swift::createSafeByteArray("password"));
 	userRegistry->onPasswordValid(Swift::JID("user@localhost/resource2"));
 	loop->processEvents();
 	Swift::Presence::ref response = Swift::Presence::create();
 	response->setTo("localhost");
 	response->setFrom("user@localhost/resource2");
 	injectPresence(response);
 	loop->processEvents();
 	CPPUNIT_ASSERT_EQUAL(1, userManager->getUserCount());
 	User *user = userManager->getUser("user@localhost");
 	CPPUNIT_ASSERT(user);
 	CPPUNIT_ASSERT_EQUAL(2, user->getResourceCount());
 	CPPUNIT_ASSERT(getStanza(received2[1])->getPayload<Swift::DiscoInfo>());
+}
 void BasicTest::disconnectUser() {
 	userManager->disconnectUser("user@localhost");
 	dynamic_cast<Swift::DummyTimerFactory *>(factories->getTimerFactory())->setTime(10);
 	loop->processEvents();
 	CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());
 	CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 	CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received[0])));
+}
 void BasicTest::add2Buddies() {
 	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", "Buddy 1", grp, BUDDY_JID_ESCAPING);
 	buddy->setStatus(Swift::StatusShow(Swift::StatusShow::Away), "status1");
 	user->getRosterManager()->setBuddy(buddy);
 	std::vector<std::string> grp2;
 	grp2.push_back("group2");
 	buddy = new LocalBuddy(user->getRosterManager(), -1, "buddy2", "Buddy 2", grp2, BUDDY_JID_ESCAPING);
 	buddy->setStatus(Swift::StatusShow(Swift::StatusShow::Away), "status2");
 	user->getRosterManager()->setBuddy(buddy);
+}

src/tests/basictest.h

➞

Show inline comments

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

src/tests/config.cpp

➞

Show inline comments

 #include "transport/userregistry.h"
 #include "transport/config.h"
 #include "transport/storagebackend.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/conversation.h"
 #include "transport/usermanager.h"
 #include "transport/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"
 #include "transport/util.h"
 using namespace Transport;
 class ConfigTest : public CPPUNIT_NS :: TestFixture{
 	CPPUNIT_TEST_SUITE(ConfigTest);
 	CPPUNIT_TEST(setStringTwice);
 	CPPUNIT_TEST(updateBackendConfig);
 	CPPUNIT_TEST(unregisteredList);
 	CPPUNIT_TEST(unregisteredString);
 	CPPUNIT_TEST(unregisteredListAsString);
 	CPPUNIT_TEST(unregisteredStringAsList);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		void setUp (void) {
+		}
 		void tearDown (void) {
+		}
 	void setStringTwice() {
 		char *argv[3] = {"binary", "--service.jids=localhost", NULL};
 		Config cfg(2, argv);
 		std::istringstream ifs("service.jids = irc.freenode.org\n");
 		cfg.load(ifs);
 		CPPUNIT_ASSERT_EQUAL(std::string("localhost"), CONFIG_STRING(&cfg, "service.jids"));
+	}
 	void updateBackendConfig() {
 		Config cfg;
 		CPPUNIT_ASSERT(!cfg.hasKey("registration.needPassword"));
 		cfg.updateBackendConfig("[registration]\nneedPassword=0\n");
 		CPPUNIT_ASSERT(cfg.hasKey("registration.needPassword"));
 		CPPUNIT_ASSERT_EQUAL(false, CONFIG_BOOL(&cfg, "registration.needPassword"));
+	}
 	void unregisteredList() {
 		Config cfg;
 		std::istringstream ifs("service.irc_server = irc.freenode.org\nservice.irc_server=localhost\n");
 		cfg.load(ifs);
 		CPPUNIT_ASSERT_EQUAL(2, (int) CONFIG_LIST(&cfg, "service.irc_server").size());
+	}
 	void unregisteredString() {
 		Config cfg;
 		std::istringstream ifs("service.irc_server = irc.freenode.org");
 		cfg.load(ifs);
 		CPPUNIT_ASSERT_EQUAL(std::string("irc.freenode.org"), CONFIG_STRING(&cfg, "service.irc_server"));
+	}
 	void unregisteredListAsString() {
 		Config cfg;
 		std::istringstream ifs("service.irc_server = irc.freenode.orgn\nservice.irc_server = irc2.freenode.org");
 		cfg.load(ifs);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), CONFIG_STRING_DEFAULTED(&cfg, "service.irc_server", ""));
+	}
 	void unregisteredStringAsList() {
 		Config cfg;
 		std::istringstream ifs("service.irc_server = irc.freenode.org");
 		cfg.load(ifs);
 		std::list<std::string> list;
 		CPPUNIT_ASSERT_EQUAL(0, (int) CONFIG_LIST_DEFAULTED(&cfg, "service.irc_server", list).size());
+	}
 };
 CPPUNIT_TEST_SUITE_REGISTRATION (ConfigTest);

src/tests/conversationmanager.cpp

➞

Show inline comments

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

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

0 comments (0 inline, 0 general)