libtransport.git Changeset - 51533ef87b89

Changeset - 51533ef87b89

Parent rev.

Child rev.

[Not reviewed]

Merge

4 69 8

Daniel Henninger - 13 years ago 2012-11-30 16:47:18
daniel@vorpalcloud.org

Merge remote branch 'upstream/master'

79 files changed with 2033 insertions and 1012 deletions:

CMakeLists.txt

256

148

backends/CMakeLists.txt

backends/libcommuni/CMakeLists.txt

backends/libcommuni/ircnetworkplugin.cpp

backends/libcommuni/ircnetworkplugin.h

backends/libcommuni/session.cpp

backends/libcommuni/session.h

backends/libpurple/main.cpp

backends/libpurple/utils.cpp

backends/skype/main.cpp

backends/swiften/main.cpp

backends/twitter/TwitterPlugin.cpp

backends/twitter/TwitterPlugin.h

backends/twitter/TwitterResponseParser.cpp

backends/twitter/main.cpp

docs/guide/debian_ubuntu.textile

docs/guide/libcommuni.textile

docs/guide/logging.textile

include/transport/conversation.h

include/transport/conversationmanager.h

include/transport/discoitemsresponder.h

include/transport/factory.h

include/transport/networkplugin.h

include/transport/networkpluginserver.h

include/transport/protocol.proto

include/transport/storagebackend.h

include/transport/transport.h

include/transport/user.h

include/transport/usermanager.h

include/transport/util.h

plugin/cpp/CMakeLists.txt

plugin/cpp/networkplugin.cpp

spectrum/src/CMakeLists.txt

spectrum/src/main.cpp

184

155

spectrum/src/sample.cfg

spectrum/src/sample2.cfg

spectrum/src/win32/ServiceWrapper.cpp

120

spectrum/src/win32/ServiceWrapper.h

spectrum/src/win32/SpectrumService.cpp

spectrum/src/win32/SpectrumService.h

spectrum/src/win32/WindowsService.cpp

214

spectrum/src/win32/WindowsService.h

spectrum_manager/src/main.cpp

spectrum_manager/src/mongoose.c

spectrum_manager/src/server.cpp

src/CMakeLists.txt

src/buddy.cpp

src/config.cpp

src/conversation.cpp

src/conversationmanager.cpp

src/discoinforesponder.cpp

src/discoinforesponder.h

src/discoitemsresponder.cpp

src/logging.cpp

src/mysqlbackend.cpp

src/networkpluginserver.cpp

src/pqxxbackend.cpp

src/rostermanager.cpp

src/rosterresponder.cpp

src/sqlite3backend.cpp

src/storagebackend.cpp

src/tests/basictest.cpp

src/tests/basictest.h

src/tests/conversationmanager.cpp

src/tests/discoitemsresponder.cpp

src/tests/localbuddy.cpp

src/tests/main.cpp

src/tests/networkpluginserver.cpp

109

src/tests/rosterresponder.cpp

src/tests/settingsadhoccommand.cpp

src/tests/stringtreeparser.cpp

src/tests/user.cpp

src/tests/usermanager.cpp

src/tests/util.cpp

src/transport.cpp

src/user.cpp

src/usermanager.cpp

src/userregistration.cpp

src/util.cpp

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")
 option(ENABLE_SQLITE3 "Build with SQLite3 support" ON)
 option(ENABLE_MYSQL "Build with MySQL support" ON)
 option(ENABLE_PQXX "Build with Postgres supoort" ON)
 option(ENABLE_FROTZ "Build Frotz plugin" ON)
 option(ENABLE_IRC "Build IRC plugin" ON)
 option(ENABLE_PURPLE "Build Libpurple plugin" ON)
 option(ENABLE_SMSTOOLS3 "Build SMSTools3 plugin" ON)
 option(ENABLE_SKYPE "Build Skype plugin" ON)
 option(ENABLE_SWIFTEN "Build Swiften plugin" ON)
 option(ENABLE_TWITTER "Build Twitter plugin" ON)
 option(ENABLE_YAHOO2 "Build Libyahoo2 plugin" ON)
 option(ENABLE_DOCS "Build Docs" ON)
 option(ENABLE_LOG "Build with logging using Log4cxx" ON)
 option(ENABLE_TESTS "Build Tests using CppUnit" OFF)
 MACRO(LIST_CONTAINS var value)
 	SET(${var})
 	FOREACH (value2 ${ARGN})
 		IF (${value} STREQUAL ${value2})
 		SET(${var} TRUE)
 		ENDIF (${value} STREQUAL ${value2})
 	ENDFOREACH (value2)
 ENDMACRO(LIST_CONTAINS)
 if(NOT LIB_INSTALL_DIR)
 	set(LIB_INSTALL_DIR "lib")
 endif()
 set(CMAKE_MODULE_PATH "cmake_modules")
 # FIND CPPUNIT
 set(cppunit_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(cppunit)
 ###### Prerequisites ######
 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()
 # 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)
 	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}")
 # FIND POPT
 if (NOT WIN32)
 	set(popt_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 	find_package(popt REQUIRED)
 endif()
 ###### Database ######
 # 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()
 if (ENABLE_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()
 endif()
 # FIND MYSQL
 set(mysql_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(mysql)
 if(ENABLE_MYSQL)
 	set(mysql_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 	find_package(mysql)
 endif()
 # FIND LIBPURPLE
 set(purple_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(purple)
 # FIND PQXX
 if(ENABLE_PQXX)
 	set(pqxx_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 	find_package(pqxx)
 endif()
 if (WIN32)
 	if (PURPLE_NOT_RUNTIME)
 ###### Plugins ######
 # FIND LIBPURPLE
 if(ENABLE_PURPLE)
 	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)
 	else(PURPLE_NOT_RUNTIME)
 		add_definitions(-DPURPLE_RUNTIME=1)
 	endif(PURPLE_NOT_RUNTIME)
 else()
 	add_definitions(-DPURPLE_RUNTIME=0)
 	endif()
 	# FIND LIBEVENT
 	set(event_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 	find_package(event)
 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()
 if(ENABLE_SKYPE OR ENABLE_PURPLE)
 #	if (GLIB2_INCLUDE_DIR AND GLIB2_LIBRARIES)
 #		set(GLIB2_FOUND TRUE)
 #	else()
 		set(glib_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 		find_package(glib)
 #	endif()
 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 PROTOBUF
 set(Protobuf_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(Protobuf REQUIRED)
 # FIND LIBEVENT
 set(event_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(event)
 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()
 # 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)
 	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)
 if(ENABLE_IRC)
 	set(Communi_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 	find_package(Communi)
 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)
 	INCLUDE(FindQt4)
 	FIND_PACKAGE(Qt4 COMPONENTS QtCore QtNetwork)
 	# ADD_DEFINITIONS(${SWIFTEN_CFLAGS})
 	ADD_DEFINITIONS(-DSUPPORT_LEGACY_CAPS)
 	# ADD_DEFINITIONS(-DBOOST_FILESYSTEM_VERSION=2)
 endif()
 set(event_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(event)
 set(pqxx_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(pqxx)
 if (NOT WIN32)
 if (NOT WIN32 AND ENABLE_SKYPE)
 set(dbus_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(dbus)
 endif()
 set(yahoo2_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(yahoo2)
 if(ENABLE_YAHOO2)
 	set(yahoo2_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 	find_package(yahoo2)
 endif()
-find_package(Doxygen)
+####### Miscallanous ######
 INCLUDE(FindQt4)
 FIND_PACKAGE(Qt4 COMPONENTS QtCore QtNetwork)
 if(ENABLE_DOCS)
 	find_package(Doxygen)
 endif()
 # ADD_DEFINITIONS(${SWIFTEN_CFLAGS})
 ADD_DEFINITIONS(-DSUPPORT_LEGACY_CAPS)
 # ADD_DEFINITIONS(-DBOOST_FILESYSTEM_VERSION=2)
 if(ENABLE_LOG)
 	if(LOG4CXX_INCLUDE_DIR AND LOG4CXX_LIBRARY)
 		set(LOG4CXX_LIBRARIES ${LOG4CXX_LIBRARY})
 		set(LOG4CXX_FOUND 1)
 		message(STATUS "Using log4cxx: ${CPPUNIT_INCLUDE_DIR} ${LOG4CXX_INCLUDE_DIR}")
 	else()
 		set(log4cxx_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 		find_package(log4cxx)
 	endif()
 endif()
 # FIND CPPUNIT
 if(ENABLE_TESTS)
 	set(cppunit_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 	find_package(cppunit)
 	if(NOT CPPUNIT_FOUND AND CPPUNIT_INCLUDE_DIR AND CPPUNIT_LIBRARY)
 		set(CCPUNIT_LIBRARIES ${CPPUNIT_LIBRARY})
 		set(CPPUNIT_FOUND 1)
 		message(STATUS "Using cppunit: ${CPPUNIT_INCLUDE_DIR} ${CPPUNIT_LIBRARIES}")
 	endif()
 endif()
 message("  Supported features")
 message("-----------------------")
 if (SPECTRUM_VERSION)
 	ADD_DEFINITIONS(-DSPECTRUM_VERSION="${SPECTRUM_VERSION}")
 else (SPECTRUM_VERSION)
 	if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
 		if (NOT GIT_EXECUTABLE)
 		set (GIT_EXECUTABLE git)
 		endif()
 		execute_process(COMMAND ${GIT_EXECUTABLE} "--git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git" rev-parse --short HEAD
 						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()
 	if (WIN32)
 		ADD_DEFINITIONS(-DWITH_SQLITE)
 		include_directories(msvc-deps/sqlite3)
 		message("SQLite3           : bundled")
 	else()
 		set(SQLITE3_LIBRARIES "")
 		if(ENABLE_SQLITE3)
 			message("SQLite3           : no (install sqlite3)")
 		else(ENABLE_SQLITE3)
 			message("SQLite3           : no (user disabled)")
 		endif()
 	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)")
 	if(ENABLE_MYSQL)
 		message("MySQL             : no (install mysql-devel)")
 	else(ENABLE_MYSQL)
 		message("MySQL             : no (user disabled)")
 	endif()
 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)")
 	if(ENABLE_PQXX)
 		message("PostgreSQL        : no (install libpqxx-devel)")
 	else(ENABLE_PQXX)
 		message("PostgreSQL        : no (user disabled)")
 	endif()
 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)")
 		if(ENABLE_PURPLE)
 			message("Libpurple plugin  : no (install libpurple)")
 		else(ENABLE_PURPLE)
 			message("Libpurple plugin  : no (user disabled)")
 		endif()
 	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)")
 		if(ENABLE_PURPLE)
 			message("  libev eventloop : no (install libev-devel)")
 		endif()
 	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)")
 		if(ENABLE_IRC)
 			message("IRC plugin        : no (install libCommuni and libprotobuf-dev)")
 		else(ENABLE_IRC)
 			message("IRC plugin        : no (user disabled)")
 		endif()
 	endif()
 if (NOT WIN32)
 	message("Frotz plugin      : yes")
 	message("SMSTools3 plugin  : yes")
 	if(${LIBDBUSGLIB_FOUND})
 		message("Skype plugin      : yes")
 		include_directories(${LIBDBUSGLIB_INCLUDE_DIRS})
 	if (NOT WIN32)
 		if(ENABLE_FROTZ)
 			message("Frotz plugin      : yes")
 		else()
 			message("Frotz plugin      : no (user disabled)")
 		endif()
 		if(ENABLE_SMSTOOLS3)
 			message("SMSTools3 plugin  : yes")
 		else()
 			message("SMSTools3 plugin  : no (user disabled)")
 		endif()
 		if(${LIBDBUSGLIB_FOUND})
 			message("Skype plugin      : yes")
 			include_directories(${LIBDBUSGLIB_INCLUDE_DIRS})
 		else()
 			if(ENABLE_SKYPE)
 				message("Skype plugin      : no (install dbus-glib-devel)")
 			else(ENABLE_SKYPE)
 				message("Skype plugin      : no (user disabled)")
 			endif()
 		endif()
 		if(ENABLE_TWITTER)
 			message("Twitter plugin    : yes")
 		else(ENABLE_TWITTER)
 			message("Twitter plugin    : no (user disabled)")
 		endif()
 	else()
 		message("Skype plugin      : no (install dbus-glib-devel)")
 		message("Frotz plugin      : no (does not run on Win32)")
 		message("SMSTools3 plugin  : no (does not run on Win32)")
 		message("Skype plugin      : no (does not run on Win32)")
 		message("Twitter plugin    : no (does not run on Win32)")
 	endif()
 else()
 	message("Frotz plugin      : no")
 	message("SMSTools3 plugin  : no")
 	message("Skype plugin      : no")
 endif()
 #	We have our own copy now...
 # 	if(YAHOO2_FOUND)
  	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")
  		include_directories(${YAHOO2_INCLUDE_DIR})
 	else()
 		if(ENABLE_YAHOO2)
 			message("Libyahoo2 plugin  : no (install libyahoo2-devel)")
 		else(ENABLE_YAHOO2)
 			message("Libyahoo2 plugin  : no (user disabled)")
 		endif()
  	endif()
 	if(ENABLE_SWIFTEN)
 		message("Swiften plugin    : yes")
 	else()
 		message("Swiften plugin    : no (user disabled)")
 	endif()
 else()
 	message("Network plugins   : no (install libprotobuf-dev)")
 	message("Libpurple plugin  : no (install libpurple and libprotobuf-dev)")
 	message("IRC plugin        : no (install libircclient-qt and libprotobuf-dev)")
 	message("Frotz plugin      : no (install libprotobuf-dev)")
 	message("SMSTools3 plugin  : no (install libprotobuf-dev)")
 	message("Swiften plugin    : no (install libprotobuf-dev)")
     message("Twitter plugin    : no (install libprotobuf-dev)")
 endif()
 if (LOG4CXX_FOUND)
 	message("Log4cxx           : yes")
 	include_directories(${LOG4CXX_INCLUDE_DIR})
 	ADD_DEFINITIONS(-DWITH_LOG4CXX)
 else()
 	set(LOG4CXX_LIBRARIES "")
 	message("Log4cxx           : no (install log4cxx-devel)")
 	if(ENABLE_LOG)
 		message("Log4cxx           : no (install log4cxx-devel)")
 	else(ENABLE_LOG)
 		message("Log4cxx           : no (user disabled)")
 	endif()
 endif()
 if (WIN32)
 ADD_DEFINITIONS(-DLOG4CXX_STATIC)
 ADD_DEFINITIONS(-D_WIN32_WINNT=0x501)
 ADD_DEFINITIONS(-DWIN32_LEAN_AND_MEAN)
 ADD_DEFINITIONS(-DBOOST_USE_WINDOWS_H)
 ADD_DEFINITIONS(-DBOOST_THREAD_USE_LIB)
 	ADD_DEFINITIONS(-DLOG4CXX_STATIC)
 	ADD_DEFINITIONS(-D_WIN32_WINNT=0x501)
 	ADD_DEFINITIONS(-DWIN32_LEAN_AND_MEAN)
 	ADD_DEFINITIONS(-DBOOST_USE_WINDOWS_H)
 	ADD_DEFINITIONS(-DBOOST_THREAD_USE_LIB)
 endif()
 if(CMAKE_BUILD_TYPE MATCHES Debug)
 if (CMAKE_COMPILER_IS_GNUCXX)
 	ADD_DEFINITIONS(-O0)
 	ADD_DEFINITIONS(-ggdb)
 endif()
 	if (CMAKE_COMPILER_IS_GNUCXX)
 		ADD_DEFINITIONS(-O0)
 		ADD_DEFINITIONS(-ggdb)
 	endif()
 	ADD_DEFINITIONS(-DDEBUG)
 	message("Debug             : yes")
 else(CMAKE_BUILD_TYPE MATCHES Debug)
 	message("Debug             : no (run \"cmake . -DCMAKE_BUILD_TYPE=Debug\")")
 endif(CMAKE_BUILD_TYPE MATCHES Debug)
 SET(TRANSPORT_VERSION 2.0)
 SET(PROJECT_VERSION 2.0)
 include_directories(include)
 include_directories(${EVENT_INCLUDE_DIRS})
 include_directories(${SWIFTEN_INCLUDE_DIR})
 include_directories(${Boost_INCLUDE_DIRS})
 if (CMAKE_COMPILER_IS_GNUCXX)
 include_directories(${OPENSSL_INCLUDE_DIR})
 endif()
 ADD_SUBDIRECTORY(src)
 ADD_SUBDIRECTORY(plugin)
 ADD_SUBDIRECTORY(include)
 ADD_SUBDIRECTORY(spectrum)
 ADD_SUBDIRECTORY(backends)
 if (NOT WIN32)
 	ADD_SUBDIRECTORY(spectrum_manager)
 #	ADD_SUBDIRECTORY(spectrum2_send_message)
 endif()
 if (CPPUNIT_FOUND)
 	message("tests             : yes")
 	include_directories(${CPPUNIT_INCLUDE_DIR})
 else()
 	message("tests             : no (install CPPUnit)")
 	if(ENABLE_TESTS)
 		message("tests             : no (install CPPUnit)")
 	else(ENABLE_TESTS)
 		message("tests             : no (user disabled)")
 	endif()
 endif()
 if(DOXYGEN_FOUND)
 	message("Docs              : yes")
 	ADD_SUBDIRECTORY(docs)
 else(DOXYGEN_FOUND)
 	message("Docs              : no (install doxygen)")
 	if(ENABLE_DOCS)
 		message("Docs              : no (install doxygen)")
 	else(ENABLE_DOCS)
 		message("Docs              : no (user disabled)")
 	endif()
 endif(DOXYGEN_FOUND)
 message("----------------------")
 if(NOT SQLITE3_FOUND AND NOT MYSQL_FOUND AND NOT PQXX_FOUND)
 	if(ENABLE_SQLITE3 OR ENABLE_MYSQL OR ENABLE_PQXX)
 		message("Could not find any database - Please install at least one of sqlite3-devel, mysql-devel or pqxx-devel if you want to use transport mode.")
 	else(ENABLE_SQLITE3 OR ENABLE_MYSQL OR ENABLE_PQXX)
 		message("Please enable at least one of SQLITE3, MYSQL, PQXX databases to use transport mode.")
 	endif()
 endif()

backends/CMakeLists.txt

➞

Show inline comments

 if (PROTOBUF_FOUND)
 	if (PURPLE_FOUND)
 		ADD_SUBDIRECTORY(libpurple)
 	endif()
 	if (IRC_FOUND)
 		ADD_SUBDIRECTORY(libcommuni)
 	endif()
 	ADD_SUBDIRECTORY(swiften)
 	if (ENABLE_SWIFTEN)
 		ADD_SUBDIRECTORY(swiften)
 	endif()
 	ADD_SUBDIRECTORY(template)
 if (NOT WIN32)
 	ADD_SUBDIRECTORY(smstools3)
 	ADD_SUBDIRECTORY(frotz)
 # 	if(YAHOO2_FOUND)
 		ADD_SUBDIRECTORY(libyahoo2)
 # 	endif()
 	ADD_SUBDIRECTORY(twitter)
 	if (${LIBDBUSGLIB_FOUND})
 		ADD_SUBDIRECTORY(skype)
 	if (NOT WIN32)
 		if(ENABLE_SMSTOOLS3)
 			ADD_SUBDIRECTORY(smstools3)
 		endif()
 		if(ENABLE_FROTZ)
 			ADD_SUBDIRECTORY(frotz)
 		endif()
  		if(YAHOO2_FOUND)
 			ADD_SUBDIRECTORY(libyahoo2)
 	 	endif()
 		if(ENABLE_TWITTER)
 			ADD_SUBDIRECTORY(twitter)
 		endif()
 		if (${LIBDBUSGLIB_FOUND})
 			ADD_SUBDIRECTORY(skype)
 		endif()
 	endif()
 endif()
 endif()

backends/libcommuni/CMakeLists.txt

➞

Show inline comments

 cmake_minimum_required(VERSION 2.6)
 FILE(GLOB SRC *.cpp)
 FILE(GLOB HEADERS *.h)
 QT4_WRAP_CPP(SRC ${HEADERS})
+QT4_WRAP_CPP(SRC ${HEADERS} OPTIONS -DBOOST_TT_HAS_OPERATOR_HPP_INCLUDED)
 ADD_EXECUTABLE(spectrum2_libcommuni_backend ${SRC})
 target_link_libraries(spectrum2_libcommuni_backend ${IRC_LIBRARY} ${QT_LIBRARIES} transport pthread)
 if (NOT WIN32)
 	target_link_libraries(spectrum2_libcommuni_backend ${IRC_LIBRARY} ${QT_LIBRARIES} transport pthread)
 else ()
 	target_link_libraries(spectrum2_libcommuni_backend ${IRC_LIBRARY} ${QT_LIBRARIES} transport)
 endif()
 INSTALL(TARGETS spectrum2_libcommuni_backend RUNTIME DESTINATION bin)

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_firstPing = true;
 	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;
 	if (m_firstPing) {
 		m_firstPing = false;
 		// Users can join the network without registering if we allow
 		// one user to connect multiple IRC networks.
 		if (m_servers.empty()) {
 			NetworkPlugin::PluginConfig cfg;
 			cfg.setNeedRegistration(false);
 			sendConfig(cfg);
+		}
+	}
 	std::string d = std::string(m_socket->readAll().data(), availableBytes);
 	handleDataRead(d);
+}
 void IRCNetworkPlugin::sendData(const std::string &string) {
 	m_socket->write(string.c_str(), string.size());
+}
 MyIrcSession *IRCNetworkPlugin::createSession(const std::string &user, const std::string &hostname, const std::string &nickname, const std::string &password, const std::string &suffix) {
 	MyIrcSession *session = new MyIrcSession(user, this, suffix);
 	session->setUserName(FROM_UTF8(nickname));
 	session->setNickName(FROM_UTF8(nickname));
 	session->setRealName(FROM_UTF8(nickname));
 	session->setHost(FROM_UTF8(hostname));
 	session->setPort(6667);
 	session->setEncoding( "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);
+	}
 std::string IRCNetworkPlugin::getTargetName(const std::string &legacyName) {
 	std::string r = legacyName;
 // 	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 (message.find("/me") == 0) {
 		m_sessions[session]->sendCommand(IrcCommand::createCtcpAction(FROM_UTF8(target), FROM_UTF8(message.substr(4))));
+	}
 	else {
 		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()));
+	}
+}
 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;
+	}
 	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()) {

backends/libcommuni/ircnetworkplugin.h

➞

Show inline comments

 		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;
 		bool m_firstPing;
 };
@@ \ No newline at end of file @@

backends/libcommuni/session.cpp

➞

Show inline comments

@@ @@ -2,107 +2,115 @@ @@
  * 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");
 static bool sentList;
 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);
 // 		if (!sentList) {
 // 			sendCommand(IrcCommand::createList("", ""));
 // 			sentList = true;
 // 		}
+	}
 	sendCommand(IrcCommand::createCapability("REQ", QStringList("away-notify")));
 	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()) {
 		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]));
 	np->handleParticipantChanged(user, nickname, TO_UTF8(m->channel()) + suffix, (int) flags, pbnetwork::STATUS_ONLINE);
 	LOG4CXX_INFO(logger, user << ": " << nickname << " joined " << TO_UTF8(m->channel()) + suffix);
+}
 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) {
@@ @@ -137,93 +145,129 @@ void MyIrcSession::on_modeChanged(IrcMessage *message) { @@
+	}
+}
 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;
+		}
+	}
 	QString msg = m->message();
 	if (m->isAction()) {
 		msg = QString("/me ") + msg;
+	}
 	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);
+		np->handleMessage(user, target + suffix, TO_UTF8(msg), nickname);
+	}
 	else {
 		bool flags = 0;
 		std::string nickname = TO_UTF8(m->sender().name());
 		flags = correctNickname(nickname);
 		LOG4CXX_INFO(logger, nickname + suffix);
-		np->handleMessage(user, nickname + suffix, TO_UTF8(m->message()));
+		np->handleMessage(user, nickname + suffix, TO_UTF8(msg));
+	}
+}
 void MyIrcSession::on_numericMessageReceived(IrcMessage *message) {
 	QString channel;
 	QStringList members;
 	std::string nick;
 	IrcNumericMessage *m = (IrcNumericMessage *) message;
 	switch (m->code()) {
 		case 301:
 			break;
 		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)));
 			nick = TO_UTF8(m->parameters().value(2));
 			if (nick.find("!") != std::string::npos) {
 				nick = nick.substr(0, nick.find("!"));
+			}
 			if (nick.find("/") != std::string::npos) {
 				nick = nick.substr(0, nick.find("/"));
+			}
 			np->handleSubject(user, TO_UTF8(m->parameters().value(1)) + suffix, m_topicData, nick);
 			break;
 		case 352:
 			channel = m->parameters().value(1);
 			nick = TO_UTF8(m->parameters().value(5));
 			if (m->parameters().value(6).toUpper().startsWith("G")) {
 				np->handleParticipantChanged(user, nick, TO_UTF8(channel) + suffix, m_modes[TO_UTF8(channel) + nick], pbnetwork::STATUS_AWAY);
+			}
 			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);
+			}
 			// ask /who to get away states
 			sendCommand(IrcCommand::createWho(channel));
 			break;
 		case 432:
 			np->handleDisconnected(user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Erroneous Nickname");
 			break;
 		case 321:
 			m_rooms.clear();
 			m_names.clear();
 			break;
 		case 322:
 			m_rooms.push_back(TO_UTF8(m->parameters().value(1)));
 			m_names.push_back(TO_UTF8(m->parameters().value(1)));
 			break;
 		case 323:
 			np->handleRoomList("", m_rooms, m_names);
 			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);

backends/libcommuni/session.h

➞

Show inline comments

@@ @@ -20,104 +20,74 @@ 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, IRCNetworkPlugin *np, const std::string &suffix = "", QObject* parent = 0);
 	std::map<std::string, bool> m_modes;
 	std::map<std::string, bool> m_away;
 	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:
 	IRCNetworkPlugin *np;
 	std::string user;
 	std::string m_identify;
 	AutoJoinMap m_autoJoin;
 	std::string m_topicData;
 	bool m_connected;
 	std::list<std::string> m_rooms;
 	std::list<std::string> m_names;
 };
 //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/libpurple/main.cpp

➞

Show inline comments

 	char *newline = purple_strdup_withhtml_wrapped(msg);
 	char *strip, *xhtml;
 	purple_markup_html_to_xhtml_wrapped(newline, &xhtml, &strip);
 // 	xhtml_linkified = spectrum_markup_linkify(xhtml);
 	std::string message_(strip);
 	std::string xhtml_(xhtml);
 	g_free(newline);
 	g_free(xhtml);
 // 	g_free(xhtml_linkified);
 	g_free(strip);
 	// AIM and XMPP adds <body>...</body> here...
 	if (xhtml_.find("<body>") == 0) {
 		xhtml_ = xhtml_.substr(6);
 		if (xhtml_.find("</body>") != std::string::npos) {
 			xhtml_ = xhtml_.substr(0, xhtml_.find("</body>"));
+		}
+	}
 	if (xhtml_ == message_) {
 		xhtml_ = "";
+	}
 	std::string timestamp;
 	if (mtime && (unsigned long) time(NULL)-10 > (unsigned long) mtime/* && (unsigned long) time(NULL) - 31536000 < (unsigned long) mtime*/) {
 		char buf[80];
 		strftime(buf, sizeof(buf), "%Y%m%dT%H%M%S", gmtime(&mtime));
 		timestamp = buf;
+	}
 // 	LOG4CXX_INFO(logger, "Received message body='" << message_ << "' xhtml='" << xhtml_ << "'");
 	if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_IM) {
 		np->handleMessage(np->m_accounts[account], w, message_, "", xhtml_);
+		np->handleMessage(np->m_accounts[account], w, message_, "", xhtml_, timestamp);
+	}
 	else {
 		LOG4CXX_INFO(logger, "Received message body='" << message_ << "' name='" << purple_conversation_get_name_wrapped(conv) << "' " << w);
 		np->handleMessage(np->m_accounts[account], purple_conversation_get_name_wrapped(conv), message_, w, xhtml_);
+		np->handleMessage(np->m_accounts[account], purple_conversation_get_name_wrapped(conv), message_, w, xhtml_, timestamp);
+	}
+}
 static void conv_chat_add_users(PurpleConversation *conv, GList *cbuddies, gboolean new_arrivals) {
 	PurpleAccount *account = purple_conversation_get_account_wrapped(conv);
 	GList *l = cbuddies;
 	while (l != NULL) {
 		PurpleConvChatBuddy *cb = (PurpleConvChatBuddy *)l->data;
 		std::string name(cb->name);
 		int flags = GPOINTER_TO_INT(cb->flags);
 		if (flags & PURPLE_CBFLAGS_OP || flags & PURPLE_CBFLAGS_HALFOP) {
 // 			item->addAttribute("affiliation", "admin");
 // 			item->addAttribute("role", "moderator");
 			flags = 1;
+		}
 		else if (flags & PURPLE_CBFLAGS_FOUNDER) {
 // 			item->addAttribute("affiliation", "owner");
 // 			item->addAttribute("role", "moderator");
 			flags = 1;
+		}
 		else {
 			flags = 0;
 // 			item->addAttribute("affiliation", "member");

backends/libpurple/utils.cpp

➞

Show inline comments

@@ @@ -15,56 +15,56 @@ @@
+ *
  * 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
  */
 // 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 "utils.h"
 #include "glib.h"
 #include "purple.h"
 #include <algorithm>
 #include <iostream>
 #include <vector>
 #include "errno.h"
 #include <string.h>
 #ifndef WIN32
 #include "sys/wait.h"
 #include "sys/signal.h"
 #include <netinet/if_ether.h>
 #include <netinet/ip.h>
 #include <netinet/ip6.h>
 #include <netinet/udp.h>
 #include <netinet/tcp.h>
 #include <netinet/ether.h>
 #include "sys/socket.h"
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <netdb.h>
 #include <arpa/inet.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <fcntl.h>
 #else
 #include <process.h>
 #define getpid _getpid
 #define ssize_t SSIZE_T
 #include "win32/win32dep.h"
 #define close closesocket
 #endif
 #include "purple_defs.h"
 #include <boost/numeric/conversion/cast.hpp>
 using std::vector;
 static GHashTable *ui_info = NULL;
 void execute_purple_plugin_action(PurpleConnection *gc, const std::string &name) {
 	PurplePlugin *plugin = gc && PURPLE_CONNECTION_IS_CONNECTED_WRAPPED(gc) ? gc->prpl : NULL;
 	if (plugin && PURPLE_PLUGIN_HAS_ACTIONS(plugin)) {
 		PurplePluginAction *action = NULL;
 		GList *actions, *l;
@@ @@ -116,72 +116,74 @@ GHashTable *spectrum_ui_get_info(void) @@
+	}
 	return ui_info;
+}
 #ifndef WIN32
 void spectrum_sigchld_handler(int sig)
+{
 	int status;
 	pid_t pid;
 	do {
 		pid = waitpid(-1, &status, WNOHANG);
 	} while (pid != 0 && pid != (pid_t)-1);
 	if ((pid == (pid_t) - 1) && (errno != ECHILD)) {
 		char errmsg[BUFSIZ];
 		snprintf(errmsg, BUFSIZ, "Warning: waitpid() returned %d", pid);
 		perror(errmsg);
+	}
+}
 #endif
 int create_socket(const char *host, int portno) {
 	struct sockaddr_in serv_addr;
 	int main_socket = socket(AF_INET, SOCK_STREAM, 0);
 	memset((char *) &serv_addr, 0, sizeof(serv_addr));
 	serv_addr.sin_family = AF_INET;
 	serv_addr.sin_port = htons(portno);
 	hostent *hos;  // Resolve name
 	struct sockaddr_in stSockAddr;
 	int SocketFD = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
 	if (-1 == SocketFD) {
 		return 0;
+	}
 	hostent *hos;
 	if ((hos = gethostbyname(host)) == NULL) {
 		// strerror() will not work for gethostbyname() and hstrerror()
 		// is supposedly obsolete
-		exit(1);
+		return 0;
+	}
 	serv_addr.sin_addr.s_addr = *((unsigned long *) hos->h_addr_list[0]);
 	if (connect(main_socket, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
 		close(main_socket);
 		main_socket = 0;
 	memset(&stSockAddr, 0, sizeof(stSockAddr));
 	stSockAddr.sin_family = AF_INET;
 	stSockAddr.sin_port = htons(portno);
 	memcpy(&(stSockAddr.sin_addr.s_addr), hos->h_addr,  hos->h_length);
 	if (-1 == connect(SocketFD, (struct sockaddr *)&stSockAddr, sizeof(stSockAddr))) {
 		close(SocketFD);
 		return 0;
+	}
 // 	int flags = fcntl(main_socket, F_GETFL);
 // 	flags |= O_NONBLOCK;
 // 	fcntl(main_socket, F_SETFL, flags);
 	return main_socket;
 	return SocketFD;
+}
 #ifdef _WIN32
 std::wstring utf8ToUtf16(const std::string& str)
+{
 	try
+	{
 		if (str.empty())
 			return L"";
 		// First request the size of the required UTF-16 buffer
 		int numRequiredBytes = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), boost::numeric_cast<int>(str.size()), NULL, 0);
 		if (!numRequiredBytes)
 			return L"";
 		// Allocate memory for the UTF-16 string
 		std::vector<wchar_t> utf16Str(numRequiredBytes);
 		int numConverted = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), boost::numeric_cast<int>(str.size()), &utf16Str[0], numRequiredBytes);
 		if (!numConverted)
 			return L"";
 		std::wstring wstr(&utf16Str[0], numConverted);
 		return wstr;

backends/skype/main.cpp

➞

Show inline comments

 #include "glib.h"
 #include <iostream>
 #include "transport/config.h"
 #include "transport/logging.h"
 #include "transport/transport.h"
 #include "transport/usermanager.h"
 #include "transport/memoryusage.h"
 #include "transport/logger.h"
 #include "transport/sqlite3backend.h"
 #include "transport/userregistration.h"
 #include "transport/user.h"
 #include "transport/storagebackend.h"
 #include "transport/rostermanager.h"
 #include "transport/conversation.h"
 #include "transport/networkplugin.h"
 #include "transport/logger.h"
 #include <boost/filesystem.hpp>
 #include "sys/wait.h"
 #include "sys/signal.h"
 // #include "valgrind/memcheck.h"
 #ifndef __FreeBSD__
 #include "malloc.h"
 #endif
 #include <dbus-1.0/dbus/dbus-glib-lowlevel.h>
 DEFINE_LOGGER(logger, "backend");
 using namespace Transport;
 class SpectrumNetworkPlugin;
 #define GET_RESPONSE_DATA(RESP, DATA) ((RESP.find(std::string(DATA) + " ") != std::string::npos) ? RESP.substr(RESP.find(DATA) + strlen(DATA) + 1) : "");
 #define GET_PROPERTY(VAR, OBJ, WHICH, PROP) std::string VAR = sk->send_command(std::string("GET ") + OBJ + " " + WHICH + " " + PROP); \
 					try {\
 						VAR = GET_RESPONSE_DATA(VAR, PROP);\
 					}\
 					catch (std::out_of_range& oor) {\
 						VAR="";\
+					}
 SpectrumNetworkPlugin *np;
 int m_sock;
 static int writeInput;

backends/swiften/main.cpp

➞

Show inline comments

 // Transport includes
 #include "transport/config.h"
 #include "transport/networkplugin.h"
 #include "transport/logging.h"
 // Swiften
 #include "Swiften/Swiften.h"
 #ifndef WIN32
 // for signal handler
 #include "unistd.h"
 #include "signal.h"
 #include "sys/wait.h"
 #include "sys/signal.h"
 #endif
 #ifndef __FreeBSD__
 // malloc_trim
 #include "malloc.h"
 #endif
 // Boost
 #include <boost/algorithm/string.hpp>
 using namespace boost::filesystem;
 using namespace boost::program_options;
 using namespace Transport;
 DEFINE_LOGGER(logger, "Swiften");
 // eventloop
 Swift::SimpleEventLoop *loop_;
 // Plugins
 class SwiftenPlugin;
 SwiftenPlugin *np = NULL;
 class SwiftenPlugin : public NetworkPlugin {
 	public:
 		Swift::BoostNetworkFactories *m_factories;
 		Swift::BoostIOServiceThread m_boostIOServiceThread;
 		boost::shared_ptr<Swift::Connection> m_conn;
 		SwiftenPlugin(Config *config, Swift::SimpleEventLoop *loop, const std::string &host, int port) : NetworkPlugin() {
 			this->config = config;
 			m_factories = new Swift::BoostNetworkFactories(loop);
 			m_conn = m_factories->getConnectionFactory()->createConnection();
 			m_conn->onDataRead.connect(boost::bind(&SwiftenPlugin::_handleDataRead, this, _1));
 			m_conn->connect(Swift::HostAddressPort(Swift::HostAddress(host), port));
 			LOG4CXX_INFO(logger, "Starting the plugin.");
+		}
 		// NetworkPlugin uses this method to send the data to networkplugin server
 		void sendData(const std::string &string) {
 			m_conn->write(Swift::createSafeByteArray(string));
+		}
 		// This method has to call handleDataRead with all received data from network plugin server
 		void _handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data) {
 			std::string d(data->begin(), data->end());
 			handleDataRead(d);
+		}
 		void handleSwiftDisconnected(const std::string &user, const boost::optional<Swift::ClientError> &error) {
 			std::string message = "";
 			bool reconnect = false;
 			if (error) {
 				switch(error->getType()) {
 					case Swift::ClientError::UnknownError: message = ("Unknown Error"); break;
+					case Swift::ClientError::UnknownError: message = ("Unknown Error"); reconnect = true; break;
 					case Swift::ClientError::DomainNameResolveError: message = ("Unable to find server"); break;
 					case Swift::ClientError::ConnectionError: message = ("Error connecting to server"); break;
 					case Swift::ClientError::ConnectionReadError: message = ("Error while receiving server data"); break;
 					case Swift::ClientError::ConnectionWriteError: message = ("Error while sending data to the server"); break;
 					case Swift::ClientError::XMLError: message = ("Error parsing server data"); break;
 					case Swift::ClientError::ConnectionReadError: message = ("Error while receiving server data"); reconnect = true; break;
 					case Swift::ClientError::ConnectionWriteError: message = ("Error while sending data to the server"); reconnect = true; break;
 					case Swift::ClientError::XMLError: message = ("Error parsing server data"); reconnect = true; break;
 					case Swift::ClientError::AuthenticationFailedError: message = ("Login/password invalid"); break;
 					case Swift::ClientError::CompressionFailedError: message = ("Error while compressing stream"); break;
 					case Swift::ClientError::ServerVerificationFailedError: message = ("Server verification failed"); break;
 					case Swift::ClientError::NoSupportedAuthMechanismsError: message = ("Authentication mechanisms not supported"); break;
 					case Swift::ClientError::UnexpectedElementError: message = ("Unexpected response"); break;
 					case Swift::ClientError::ResourceBindError: message = ("Error binding resource"); break;
 					case Swift::ClientError::SessionStartError: message = ("Error starting session"); break;
 					case Swift::ClientError::StreamError: message = ("Stream error"); break;
 					case Swift::ClientError::TLSError: message = ("Encryption error"); break;
 					case Swift::ClientError::ClientCertificateLoadError: message = ("Error loading certificate (Invalid password?)"); break;
 					case Swift::ClientError::ClientCertificateError: message = ("Certificate not authorized"); break;
 					case Swift::ClientError::UnknownCertificateError: message = ("Unknown certificate"); break;
 					case Swift::ClientError::CertificateExpiredError: message = ("Certificate has expired"); break;
 					case Swift::ClientError::CertificateNotYetValidError: message = ("Certificate is not yet valid"); break;
 					case Swift::ClientError::CertificateSelfSignedError: message = ("Certificate is self-signed"); break;
 					case Swift::ClientError::CertificateRejectedError: message = ("Certificate has been rejected"); break;
 					case Swift::ClientError::CertificateUntrustedError: message = ("Certificate is not trusted"); break;
 					case Swift::ClientError::InvalidCertificatePurposeError: message = ("Certificate cannot be used for encrypting your connection"); break;
 					case Swift::ClientError::CertificatePathLengthExceededError: message = ("Certificate path length constraint exceeded"); break;
 					case Swift::ClientError::InvalidCertificateSignatureError: message = ("Invalid certificate signature"); break;
 					case Swift::ClientError::InvalidCAError: message = ("Invalid Certificate Authority"); break;
 					case Swift::ClientError::InvalidServerIdentityError: message = ("Certificate does not match the host identity"); break;
+				}
+			}
 			LOG4CXX_INFO(logger, user << ": Disconnected " << message);
 			handleDisconnected(user, 3, message);
+			handleDisconnected(user, reconnect ? 0 : 3, message);
 			boost::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				client->onConnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftConnected, this, user));
 				client->onDisconnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftDisconnected, this, user, _1));
 				client->onMessageReceived.disconnect(boost::bind(&SwiftenPlugin::handleSwiftMessageReceived, this, user, _1));
 				m_users.erase(user);
+			}
 #ifndef WIN32
 #ifndef __FreeBSD__
 			// force returning of memory chunks allocated by libxml2 to kernel
 			malloc_trim(0);
 #endif
 #endif
+		}
 		void handleSwiftConnected(const std::string &user) {
 			LOG4CXX_INFO(logger, user << ": Connected to XMPP server.");
 			handleConnected(user);
 			m_users[user]->requestRoster();
 			Swift::Presence::ref response = Swift::Presence::create();
 			response->setFrom(m_users[user]->getJID());
 			m_users[user]->sendPresence(response);
+		}
 		void handleSwiftRosterReceived(const std::string &user) {
 			Swift::PresenceOracle *oracle = m_users[user]->getPresenceOracle();
 			BOOST_FOREACH(const Swift::XMPPRosterItem &item, m_users[user]->getRoster()->getItems()) {
 				Swift::Presence::ref lastPresence = oracle->getLastPresence(item.getJID());
 				pbnetwork::StatusType status = lastPresence ? ((pbnetwork::StatusType) lastPresence->getShow()) : pbnetwork::STATUS_NONE;
 				handleBuddyChanged(user, item.getJID().toBare().toString(),
 								   item.getName(), item.getGroups(), status);
+			}
+		}
 		void handleSwiftPresenceChanged(const std::string &user, Swift::Presence::ref presence) {
 			LOG4CXX_INFO(logger, user << ": " << presence->getFrom().toBare().toString() << " presence changed");

backends/twitter/TwitterPlugin.cpp

➞

Show inline comments

+{
 	if(userdb[user].connectionState != CONNECTED) {
 		LOG4CXX_ERROR(logger, user << " is not connected to twitter!")
 		return;
+	}
 	LOG4CXX_INFO(logger, user << " - VCardRequest for " << legacyName << ", " << userdb[user].buddiesInfo[legacyName].getProfileImgURL())
 	if(getTwitterMode(user) != SINGLECONTACT && userdb[user].buddies.count(legacyName)
 		&& userdb[user].buddiesInfo[legacyName].getProfileImgURL().length()) {
 		if(userdb[user].buddiesImgs.count(legacyName) == 0) {
 			tp->runAsThread(new ProfileImageRequest(config, user, legacyName, userdb[user].buddiesInfo[legacyName].getProfileImgURL(), id,
 													boost::bind(&TwitterPlugin::profileImageResponse, this, _1, _2, _3, _4, _5)));
+		}
 		handleVCard(user, id, legacyName, legacyName, "", userdb[user].buddiesImgs[legacyName]);
+	}
+}
 void TwitterPlugin::pollForTweets()
+{
 	boost::mutex::scoped_lock lock(userlock);
 	std::set<std::string>::iterator it = onlineUsers.begin();
 	while(it != onlineUsers.end()) {
 		std::string user = *it;
-		tp->runAsThread(new TimelineRequest(userdb[user].sessions, user, "", userdb[user].mostRecentTweetID,
+		tp->runAsThread(new TimelineRequest(userdb[user].sessions, user, "", getMostRecentTweetIDUnsafe(user),
 											boost::bind(&TwitterPlugin::displayTweets, this, _1, _2, _3, _4)));
 		it++;
+	}
 	tweet_timer->start();
+}
 void TwitterPlugin::pollForDirectMessages()
+{
 	boost::mutex::scoped_lock lock(userlock);
 	std::set<std::string>::iterator it = onlineUsers.begin();
 	while(it != onlineUsers.end()) {
 		std::string user = *it;
 		tp->runAsThread(new DirectMessageRequest(userdb[user].sessions, user, "", userdb[user].mostRecentDirectMessageID,
 											boost::bind(&TwitterPlugin::directMessageResponse, this, _1, _2, _3, _4)));
 		it++;
+	}
 	message_timer->start();
+}
 bool TwitterPlugin::getUserOAuthKeyAndSecret(const std::string user, std::string &key, std::string &secret)
+{
 	boost::mutex::scoped_lock lock(dblock);
+}
 void TwitterPlugin::pinExchangeComplete(const std::string user, const std::string OAuthAccessTokenKey, const std::string OAuthAccessTokenSecret)
+{
 	boost::mutex::scoped_lock lock(userlock);
 	userdb[user].sessions->getOAuth().setOAuthTokenKey( OAuthAccessTokenKey );
 	userdb[user].sessions->getOAuth().setOAuthTokenSecret( OAuthAccessTokenSecret );
 	userdb[user].connectionState = CONNECTED;
 	userdb[user].twitterMode = (mode)getTwitterMode(user);
 	if(userdb[user].twitterMode == MULTIPLECONTACT) {
 		tp->runAsThread(new FetchFriends(userdb[user].sessions, user, boost::bind(&TwitterPlugin::populateRoster, this, _1, _2, _3, _4)));
+	}
 	onlineUsers.insert(user);
 	userdb[user].mostRecentTweetID = "";
 	userdb[user].mostRecentDirectMessageID = "";
+}
 void TwitterPlugin::updateLastTweetID(const std::string user, const std::string ID)
+{
 	boost::mutex::scoped_lock lock(userlock);
 	userdb[user].mostRecentTweetID = ID;
 	UserInfo info;
 	if(storagebackend->getUser(user, info) == false) {
 		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
 		return;
+	}
 	storagebackend->updateUserSetting((long)info.id, "twitter_last_tweet", ID);
+}
 std::string TwitterPlugin::getMostRecentTweetID(const std::string user)
+{
 	boost::mutex::scoped_lock lock(userlock);
 	std::string ID = "-1";
 	if(onlineUsers.count(user)) ID = userdb[user].mostRecentTweetID;
 std::string TwitterPlugin::getMostRecentTweetIDUnsafe(const std::string user)
+{
 	std::string ID = "";
 	if(onlineUsers.count(user)) {
 		ID = userdb[user].mostRecentTweetID;
 		if (ID.empty()) {
 			int type;
 			UserInfo info;
 			if(storagebackend->getUser(user, info) == false) {
 				LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
+			}
 			else {
 				storagebackend->getUserSetting(info.id, "twitter_last_tweet", type, ID);
+			}
+		}
+	}
 	return ID;
+}
 std::string TwitterPlugin::getMostRecentTweetID(const std::string user)
+{
 	boost::mutex::scoped_lock lock(userlock);
 	return getMostRecentTweetIDUnsafe(user);
+}
 void TwitterPlugin::updateLastDMID(const std::string user, const std::string ID)
+{
 	boost::mutex::scoped_lock lock(userlock);
 	userdb[user].mostRecentDirectMessageID = ID;
+}
 std::string TwitterPlugin::getMostRecentDMID(const std::string user)
+{
 	boost::mutex::scoped_lock lock(userlock);
 	std::string ID = "";
 	if(onlineUsers.count(user)) ID = userdb[user].mostRecentDirectMessageID;
 	return ID;
+}
 /************************************** Twitter response functions **********************************/
 void TwitterPlugin::statusUpdateResponse(std::string &user, Error &errMsg)
+{
 	if(errMsg.getMessage().length()) {
 		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 							errMsg.getMessage(), userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 	} else {
 		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 							"Status Update successful", userdb[user].twitterMode == CHATROOM ? adminNickName : "");
+	}
 void TwitterPlugin::displayFriendlist(std::string &user, std::vector<User> &friends, std::vector<std::string> &friendAvatars, Error &errMsg)
+{
 	if(errMsg.getMessage().length() == 0)
+	{
 		std::string userlist = "\n***************USER LIST****************\n";
 		for(int i=0 ; i < friends.size() ; i++) {
 			userlist += " - " + friends[i].getUserName() + " (" + friends[i].getScreenName() + ")\n";
+		}
 		userlist += "***************************************\n";
 		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 							userlist, userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 	} else handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 							   errMsg.getMessage(), userdb[user].twitterMode == CHATROOM ? adminNickName : "");
+}
 void TwitterPlugin::displayTweets(std::string &user, std::string &userRequested, std::vector<Status> &tweets , Error &errMsg)
+{
 	if(errMsg.getMessage().length() == 0) {
 		std::string timeline = "";
 		std::map<std::string, int> lastTweet;
 		std::map<std::string, int>::iterator it;
-		for(int i=0 ; i<tweets.size() ; i++) {
+		for(int i = tweets.size() - 1 ; i >= 0 ; i--) {
 			if(userdb[user].twitterMode != CHATROOM) {
 				timeline += " - " + tweets[i].getUserData().getScreenName() + ": " + tweets[i].getTweet() + " (MsgId: " + tweets[i].getID() + ")\n";
 				std::string m = " - " + tweets[i].getUserData().getScreenName() + ": " + tweets[i].getTweet() + " (MsgId: " + tweets[i].getID() + ")\n";
 				handleMessage(user, adminLegacyName, m, "", "", tweets[i].getCreationTime());
 				std::string scrname = tweets[i].getUserData().getScreenName();
 				if(lastTweet.count(scrname) == 0 || cmp(tweets[lastTweet[scrname]].getID(), tweets[i].getID()) <= 0) lastTweet[scrname] = i;
 			} else {
 				handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 									tweets[i].getTweet() + " (MsgId: " + tweets[i].getID() + ")", tweets[i].getUserData().getScreenName());
+									tweets[i].getTweet() + " (MsgId: " + tweets[i].getID() + ")", tweets[i].getUserData().getScreenName(), "", tweets[i].getCreationTime());
+			}
+		}
 		if(userdb[user].twitterMode == MULTIPLECONTACT) {
 			//Set as status user's last tweet
 			for(it=lastTweet.begin() ; it!=lastTweet.end() ; it++) {
 				int t =  it->second;
 				handleBuddyChanged(user, tweets[t].getUserData().getScreenName(), tweets[t].getUserData().getUserName(),
 								   std::vector<std::string>(), pbnetwork::STATUS_ONLINE, tweets[t].getTweet());
+			}
+		}
 		if((userRequested == "" || userRequested == user) && tweets.size()) {
 			std::string tweetID = getMostRecentTweetID(user);
 			if(tweetID != tweets[0].getID()) updateLastTweetID(user, tweets[0].getID());
+		}
 		if(timeline.length()) handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 												  timeline, userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 	} else handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 							   errMsg.getMessage(), userdb[user].twitterMode == CHATROOM ? adminNickName : "");
+}
 void TwitterPlugin::directMessageResponse(std::string &user, std::string &username, std::vector<DirectMessage> &messages, Error &errMsg)

backends/twitter/TwitterPlugin.h

➞

Show inline comments

@@ @@ -113,48 +113,50 @@ class TwitterPlugin : public NetworkPlugin { @@
 		/****************** Twitter response handlers **************************************/
 		void statusUpdateResponse(std::string &user, Error &errMsg);
 		void helpMessageResponse(std::string &user, std::string &msg);
 		void populateRoster(std::string &user, std::vector<User> &friends, std::vector<std::string> &friendAvatars, Error &errMsg);
 		void displayFriendlist(std::string &user, std::vector<User> &friends, std::vector<std::string> &friendAvatars, Error &errMsg);
 		void displayTweets(std::string &user, std::string &userRequested, std::vector<Status> &tweets , Error &errMsg);
 		void directMessageResponse(std::string &user, std::string &username, std::vector<DirectMessage> &messages, Error &errMsg);
 		void createFriendResponse(std::string &user, User &frnd, std::string &img, Error &errMsg);
 		void deleteFriendResponse(std::string &user, User &frnd, Error &errMsg);
 		void RetweetResponse(std::string &user, Error &errMsg);
 		void profileImageResponse(std::string &user, std::string &buddy, std::string &img, unsigned int reqID, Error &errMsg);
 		/***********************************************************************************/
 	private:
 		std::string getMostRecentTweetIDUnsafe(const std::string user);
 		enum status {NEW, WAITING_FOR_PIN, CONNECTED, DISCONNECTED};
 		enum mode {SINGLECONTACT, MULTIPLECONTACT, CHATROOM};
 		Config *config;
 		std::string adminLegacyName;
 		std::string adminChatRoom;
 		std::string adminNickName;
 		std::string adminAlias;
 		std::string consumerKey;
 		std::string consumerSecret;
 		std::string OAUTH_KEY;
 		std::string OAUTH_SECRET;
 		std::string MODE;
 		boost::mutex dblock, userlock;
 		ThreadPool *tp;
 		std::set<std::string> onlineUsers;
 		struct UserData
+		{
 			std::string legacyName;
 			bool spectrum1User; //Legacy support
 			User userTwitterObj;

backends/twitter/TwitterResponseParser.cpp

➞

Show inline comments

 #include "TwitterResponseParser.h"
 #include "transport/logging.h"
 #include "boost/algorithm/string.hpp"
 #include <cctype>
 DEFINE_LOGGER(logger, "TwitterResponseParser")
 static std::string tolowercase(std::string inp)
+{
 	std::string out = inp;
 	for(int i=0 ; i<out.size() ; i++) out[i] = tolower(out[i]);
 	return out;
+}
 static std::string unescape(std::string data) {
 	using boost::algorithm::replace_all;
 	replace_all(data, "&amp;",  "&");
 	replace_all(data, "&quot;", "\"");
 	replace_all(data, "&apos;", "\'");
 	replace_all(data, "&lt;",   "<");
 	replace_all(data, "&gt;",   ">");
 	return data;
+}
 static std::string toIsoTime(std::string in) {
 	time_t now = time(0);
 	struct tm *mtime = gmtime(&now);
 	strptime(in.c_str(), "%a %b %d %H:%M:%S %z %Y", mtime);
 	char buf[80];
 	strftime(buf, sizeof(buf), "%Y%m%dT%H%M%S", mtime);
 	return buf;
+}
 EmbeddedStatus getEmbeddedStatus(const Swift::ParserElement::ref &element, const std::string xmlns)
+{
 	EmbeddedStatus status;
 	if(element->getName() != TwitterReponseTypes::status) {
 		LOG4CXX_ERROR(logger, "Not a status element!")
 		return status;
+	}
 	status.setCreationTime( std::string( element->getChild(TwitterReponseTypes::created_at, xmlns)->getText() ) );
 	status.setCreationTime( toIsoTime(std::string( element->getChild(TwitterReponseTypes::created_at, xmlns)->getText() ) ) );
 	status.setID( std::string( element->getChild(TwitterReponseTypes::id, xmlns)->getText() ) );
 	status.setTweet( std::string( element->getChild(TwitterReponseTypes::text, xmlns)->getText() ) );
+	status.setTweet( unescape (std::string( element->getChild(TwitterReponseTypes::text, xmlns)->getText() ) ) );
 	status.setTruncated( std::string( element->getChild(TwitterReponseTypes::truncated, xmlns)->getText() )=="true" );
 	status.setReplyToStatusID( std::string( element->getChild(TwitterReponseTypes::in_reply_to_status_id, xmlns)->getText() ) );
 	status.setReplyToUserID( std::string( element->getChild(TwitterReponseTypes::in_reply_to_user_id, xmlns)->getText() ) );
 	status.setReplyToScreenName( std::string( element->getChild(TwitterReponseTypes::in_reply_to_screen_name, xmlns)->getText() ) );
 	status.setRetweetCount( atoi( element->getChild(TwitterReponseTypes::retweet_count, xmlns)->getText().c_str() ) );
 	status.setFavorited( std::string( element->getChild(TwitterReponseTypes::favorited, xmlns)->getText() )=="true" );
 	status.setRetweeted( std::string( element->getChild(TwitterReponseTypes::retweeted, xmlns)->getText() )=="true" );
 	return status;
+}
 User getUser(const Swift::ParserElement::ref &element, const std::string xmlns)
+{
 	User user;
 	if(element->getName() != TwitterReponseTypes::user
 	   && element->getName() != TwitterReponseTypes::sender
 	   && element->getName() != TwitterReponseTypes::recipient) {
 		LOG4CXX_ERROR(logger, "Not a user element!")
 		return user;
+	}
 	user.setUserID( std::string( element->getChild(TwitterReponseTypes::id, xmlns)->getText() ) );
 	user.setScreenName( tolowercase( std::string( element->getChild(TwitterReponseTypes::screen_name, xmlns)->getText() ) ) );
 	user.setUserName( std::string( element->getChild(TwitterReponseTypes::name, xmlns)->getText() ) );
 	user.setProfileImgURL( std::string( element->getChild(TwitterReponseTypes::profile_image_url, xmlns)->getText() ) );
 	user.setNumberOfTweets( atoi(element->getChild(TwitterReponseTypes::statuses_count, xmlns)->getText().c_str()) );
 	if(element->getChild(TwitterReponseTypes::status, xmlns))
 		user.setLastStatus(getEmbeddedStatus(element->getChild(TwitterReponseTypes::status, xmlns),  xmlns));
 	return user;
+}
 Status getStatus(const Swift::ParserElement::ref &element, const std::string xmlns)
+{
 	Status status;
 	if(element->getName() != "status") {
 		LOG4CXX_ERROR(logger, "Not a status element!")
 		return status;
+	}
 	status.setCreationTime( std::string( element->getChild(TwitterReponseTypes::created_at, xmlns)->getText() ) );
+	status.setCreationTime( toIsoTime ( std::string( element->getChild(TwitterReponseTypes::created_at, xmlns)->getText() ) ) );
 	status.setID( std::string( element->getChild(TwitterReponseTypes::id, xmlns)->getText() ) );
 	status.setTweet( std::string( element->getChild(TwitterReponseTypes::text, xmlns)->getText() ) );
+	status.setTweet( unescape ( std::string( element->getChild(TwitterReponseTypes::text, xmlns)->getText() ) ) );
 	status.setTruncated( std::string( element->getChild(TwitterReponseTypes::truncated, xmlns)->getText() )=="true" );
 	status.setReplyToStatusID( std::string( element->getChild(TwitterReponseTypes::in_reply_to_status_id, xmlns)->getText() ) );
 	status.setReplyToUserID( std::string( element->getChild(TwitterReponseTypes::in_reply_to_user_id, xmlns)->getText() ) );
 	status.setReplyToScreenName( std::string( element->getChild(TwitterReponseTypes::in_reply_to_screen_name, xmlns)->getText() ) );
 	status.setUserData( getUser(element->getChild(TwitterReponseTypes::user, xmlns), xmlns) );
 	status.setRetweetCount( atoi( element->getChild(TwitterReponseTypes::retweet_count, xmlns)->getText().c_str() ) );
 	status.setFavorited( std::string( element->getChild(TwitterReponseTypes::favorited, xmlns)->getText() )=="true" );
 	status.setRetweeted( std::string( element->getChild(TwitterReponseTypes::retweeted, xmlns)->getText() )=="true" );
 	return status;
+}
 DirectMessage getDirectMessage(const Swift::ParserElement::ref &element, const std::string xmlns)
+{
 	DirectMessage DM;
 	if(element->getName() != TwitterReponseTypes::direct_message) {
 		LOG4CXX_ERROR(logger, "Not a direct_message element!")
 		return DM;
+	}
 	DM.setCreationTime( std::string( element->getChild(TwitterReponseTypes::created_at, xmlns)->getText() ) );
+	DM.setCreationTime( toIsoTime ( std::string( element->getChild(TwitterReponseTypes::created_at, xmlns)->getText() ) ) );
 	DM.setID( std::string( element->getChild(TwitterReponseTypes::id, xmlns)->getText() ) );
 	DM.setMessage( std::string( element->getChild(TwitterReponseTypes::text, xmlns)->getText() ) );
+	DM.setMessage( unescape ( std::string( element->getChild(TwitterReponseTypes::text, xmlns)->getText() ) ) );
 	DM.setSenderID( std::string( element->getChild(TwitterReponseTypes::sender_id, xmlns)->getText() ) );
 	DM.setRecipientID( std::string( element->getChild(TwitterReponseTypes::recipient_id, xmlns)->getText() ) );
 	DM.setSenderScreenName( std::string( element->getChild(TwitterReponseTypes::sender_screen_name, xmlns)->getText() ) );
 	DM.setRecipientScreenName( std::string( element->getChild(TwitterReponseTypes::recipient_screen_name, xmlns)->getText() ) );
 	DM.setSenderData( getUser(element->getChild(TwitterReponseTypes::sender, xmlns), xmlns) );
 	DM.setRecipientData( getUser(element->getChild(TwitterReponseTypes::recipient, xmlns), xmlns) );
 	return DM;
+}
 std::vector<Status> getTimeline(std::string &xml)
+{
 	std::vector<Status> statuses;
 	Swift::ParserElement::ref rootElement = Swift::StringTreeParser::parse(xml);
 	if(rootElement == NULL) {
 		LOG4CXX_ERROR(logger, "Error while parsing XML")
 		return statuses;
+	}
 	if(rootElement->getName() != "statuses") {
 		LOG4CXX_ERROR(logger, "XML doesn't correspond to timeline")
 		return statuses;
+	}

backends/twitter/main.cpp

➞

Show inline comments

@@ @@ -6,93 +6,53 @@ static void spectrum_sigchld_handler(int sig) @@
 	int status;
 	pid_t pid;
 	do {
 		pid = waitpid(-1, &status, WNOHANG);
 	} while (pid != 0 && pid != (pid_t)-1);
 	if ((pid == (pid_t) - 1) && (errno != ECHILD)) {
 		char errmsg[BUFSIZ];
 		snprintf(errmsg, BUFSIZ, "Warning: waitpid() returned %d", pid);
 		perror(errmsg);
+	}
+}
 int main (int argc, char* argv[]) {
 	std::string host;
 	int port;
 	if (signal(SIGCHLD, spectrum_sigchld_handler) == SIG_ERR) {
 		std::cout << "SIGCHLD handler can't be set\n";
 		return -1;
+	}
 	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")
 		("config", boost::program_options::value<std::string>(&configFile)->default_value(""), "Config file")
+		;
 	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"))
+		{
 			std::cout << desc << "\n";
 			return 1;
+		}
 		if(vm.count("config") == 0) {
 			std::cout << desc << "\n";
 			return 1;
+		}
+	}
 	catch (std::runtime_error& e)
+	{
 		std::cout << desc << "\n";
 		return 1;
+	}
 	catch (...)
+	{
 		std::cout << desc << "\n";
 	std::string error;
 	Config *cfg = Config::createFromArgs(argc, argv, error, host, port);
 	if (cfg == NULL) {
 		std::cerr << error;
 		return 1;
+	}
 	Config config(argc, argv);
 	if (!config.load(configFile)) {
 		std::cerr << "Can't open " << argv[1] << " configuration file.\n";
 		return 1;
+	}
 	Logging::initBackendLogging(cfg);
 	Logging::initBackendLogging(&config);
 	std::string error;
 	StorageBackend *storagebackend;
 	storagebackend = StorageBackend::createBackend(&config, error);
 	storagebackend = StorageBackend::createBackend(cfg, error);
 	if (storagebackend == NULL) {
 		LOG4CXX_ERROR(logger, "Error creating StorageBackend! " << error)
 		return -2;
 		LOG4CXX_ERROR(logger, "Error creating StorageBackend! " << error);
 		LOG4CXX_ERROR(logger, "Twitter backend needs storage backend configured to work! " << error);
 		return NetworkPlugin::StorageBackendNeeded;
+	}
 	else if (!storagebackend->connect()) {
 		LOG4CXX_ERROR(logger, "Can't connect to database!")
 		return -1;
+	}
 	Swift::SimpleEventLoop eventLoop;
 	loop_ = &eventLoop;
-	np = new TwitterPlugin(&config, &eventLoop, storagebackend, host, port);
+	np = new TwitterPlugin(cfg, &eventLoop, storagebackend, host, port);
 	loop_->run();
 	return 0;
+}

docs/guide/debian_ubuntu.textile

➞

Show inline comments

@@ @@ -12,28 +12,28 @@ h2. Add GPG key @@
 After you have added the repository, you still have to import the GPG key that is used to sign the packages in the repository. You can do this in two ways:
 You can download and add the key manually (apt-key requires root privileges):
 <pre>
  wget -O - http://packages.spectrum.im/keys/apt-repository@fsinf.at | apt-key add -
 </pre>
 You can simply update the repositories and install the fsinf-keyring packages:
 <pre>
  apt-get update
  apt-get install fsinf-keyring
  apt-get update
 </pre>
 Don’t worry about the warnings that the packages can’t be identified, they will be gone after you installed the fsinf-keyring package.
 h2. Install spectrum2 - development version
 After you have done that, simply do:
 <pre>
-apt-get install spectrum2-git spectrum2-backend-libpurple-git
 apt-get install spectrum2 spectrum2-backend-libpurple
 </pre>
 Note that these repositories pull in quite a few dependencies, depending on the distribution you use.

docs/guide/libcommuni.textile

➞

Show inline comments

 backend=/usr/bin/spectrum2_libcommuni_backend
 </pre>
 LibCommuni backend can then work in two modes.
 h3. 2.1. One transport per one IRC network
 This is preferred way if you know that you or your users will need to connect just one IRC network. It's also good mode of you maintain IRC server and want to provide XMPP access to it.
 In this mode users can:
 * connect the IRC network without joining the IRC channel.
 * identify to NickServ (or any other service like that) using username and password from transport registration.
 * have IRC contacts in their rosters. (Not done yet, but it's planned)
 * see channel list in the service discovery. (Not done yet, but it's planned)
 To use this mode, you have to configure irc_server variable like this:
 <pre>
 [service]
 irc_server=irc.freenode.org
 </pre>
 h3. 2.2 One transport for more IRC networks
-In this mode users can connect more IRC networks, but they can't connect the network without being in the room. Currently this mode is not finished yet in Spectrum 2.
+In this mode users can connect more IRC networks, but they can't connect the network without being in the room. To connect the network, user has to join the room in following format: #room%irc.freenode.org@irc.domain.tld. The nickname used in the first join request is used as a nickname for the IRC connection.
 h2. 3. All configuration variables
 |_. Key |_. Type |_. Default |_. Description |
 | irc_server | string | | IRC server hostname for "One transport per one IRC network" mode. |
 | irc_identify | string | NickServ identify $name $password | The fiirst word is nickname of service used for identifying. After the nickname there's a message sent to that service. $name is replaced by the username defined by user in the registration. $password is replaced by password. |

docs/guide/logging.textile

➞

Show inline comments

@@ @@ -74,57 +74,76 @@ log4j.appender.R=org.apache.log4j.RollingFileAppender @@
 log4j.appender.R.File=/var/log/spectrum2/${jid}/spectrum2.log
 # Set MaxFileSize. Log will be rotated automatically when this limit is reached
 log4j.appender.R.MaxFileSize=10000KB
 # Keep one backup file
 log4j.appender.R.MaxBackupIndex=1
 # Define the output pattern. Characters are mentioned here: http://logging.apache.org/log4cxx/apidocs/classlog4cxx_1_1_pattern_layout.html
 log4j.appender.R.layout=org.apache.log4j.PatternLayout
 log4j.appender.R.layout.ConversionPattern=%d %-5p %c: %m%n
 # ---- spectrum2_xml.log
 # Define new logger for category Component.XML:
 #   - "debug" is internal logger used by log4cxx
 #   - "XML" is the name of our RollingFileAppender logger for XML category
 log4j.category.Component.XML = debug, XML
 # Do not add XML category into "R" logger, so XML category will be logged only to spectrum2_xml.log, but not to spectrum2.log.
 # If you want to have XML category also in spectrum2.log, set this value to "true"
 log4j.additivity.Component.XML=false
 # Create new RollingFileAppender logger and set the file name
 log4j.appender.XML=org.apache.log4j.RollingFileAppender
-log4j.appender.XML.File=/var/log/spectrum2/${jid}/spectrum2.log
+log4j.appender.XML.File=/var/log/spectrum2/${jid}/spectrum2_xml.log
 # Set MaxFileSize. Log will be rotated automatically when this limit is reached
 log4j.appender.XML.MaxFileSize=100000KB
 # Keep one backup file
 log4j.appender.XML.MaxBackupIndex=4
 # Define the output pattern. Characters are mentioned here: http://logging.apache.org/log4cxx/apidocs/classlog4cxx_1_1_pattern_layout.html
 log4j.appender.XML.layout=org.apache.log4j.PatternLayout
 log4j.appender.XML.layout.ConversionPattern=%d %-5p %c: %m%n
 </pre>
 h3. Disable XML logging
 <pre>
 # We create two rootLoggers:
 #   - "debug" is internal logger used by log4cxx
 #   - "stdout" is name of our ConsoleAppender logger
 log4j.rootLogger=debug, stdout
 # Create new ConsoleAppender logger with custom PatternLayout
 log4j.appender.stdout=org.apache.log4j.ConsoleAppender
 # Define the output pattern. Characters are mentioned here: http://logging.apache.org/log4cxx/apidocs/classlog4cxx_1_1_pattern_layout.html
 log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
 log4j.appender.stdout.layout.ConversionPattern=%d %-5p %c: %m%n
 # Disable XML category
 log4j.category.Component.XML = OFF
 </pre>
 h3. Disable logging
 To disable logging, you still *must have* one logger created (probably the ConsoleAppender), but you can set log4j.threshold = OFF to not log everything later:
 <pre>
 # We create two rootLoggers:
 #   - "debug" is internal logger used by log4cxx
 #   - "stdout" is name of our ConsoleAppender logger
 log4j.rootLogger=debug, stdout
 # Create new ConsoleAppender logger with custom PatternLayout
 log4j.appender.stdout=org.apache.log4j.ConsoleAppender
 # Define the output pattern. Characters are mentioned here: http://logging.apache.org/log4cxx/apidocs/classlog4cxx_1_1_pattern_layout.html
 log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
 log4j.appender.stdout.layout.ConversionPattern=%d %-5p %c: %m%n
 # Disable logging of everything:
 log4j.threshold = OFF
 </pre>

include/transport/conversation.h

➞

Show inline comments

@@ @@ -127,27 +127,29 @@ class Conversation { @@
 		/// 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;
 		boost::shared_ptr<Swift::Message> m_subject;
 		bool m_sentInitialPresence;
 };
+}

include/transport/conversationmanager.h

➞

Show inline comments

@@ @@ -48,38 +48,40 @@ class ConversationManager { @@
 		/// \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 deleteAllConversations();
 		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/discoitemsresponder.h

➞

Show inline comments

@@ @@ -7,42 +7,51 @@ @@
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <vector>
 #include "Swiften/Swiften.h"
 #include "Swiften/Queries/GetResponder.h"
 #include "Swiften/Elements/DiscoItems.h"
 namespace Transport {
 class Component;
 class DiscoInfoResponder;
 class DiscoItemsResponder : public Swift::GetResponder<Swift::DiscoItems> {
 	public:
 		DiscoItemsResponder(Component *component);
 		~DiscoItemsResponder();
 		Swift::CapsInfo &getBuddyCapsInfo();
 		void addAdHocCommand(const std::string &node, const std::string &name);
 // 		void removeAdHocCommand(const std::string &node);
 		void addRoom(const std::string &node, const std::string &name);
 		void clearRooms();
 	private:
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::DiscoItems> payload);
 	private:
 		Component *m_component;
 		boost::shared_ptr<Swift::DiscoItems> m_commands;
 		boost::shared_ptr<Swift::DiscoItems> m_rooms;
 		DiscoInfoResponder *m_discoInfoResponder;
 };
+}
@@ \ No newline at end of file @@

include/transport/factory.h

➞

Show inline comments

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

include/transport/networkplugin.h

➞

Show inline comments

@@ @@ -3,58 +3,60 @@ @@
+ *
  * 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 "transport/protocol.pb.h"
 // #include "conversation.h"
 #include <iostream>
 #include <list>
 namespace Transport {
 /// Represents Spectrum2 legacy network plugin.
 /// This class is base class for all C++ legacy network plugins. It provides a way to connect
 /// Spectrum2 NetworkPluginServer and allows to use high-level API for legacy network plugins
 /// development.
 class NetworkPlugin {
 	public:
 		enum ExitCode { StorageBackendNeeded = -2 };
 		class PluginConfig {
 			public:
 				PluginConfig() : m_needPassword(true), m_needRegistration(false) {}
 				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();
@@ @@ -88,49 +90,49 @@ class NetworkPlugin { @@
 		/// \param room Room in which participant changed. (eg. #spectrum)
 		/// \param flags Participant flags.
 		/// \param status Current status of participant. Swift::StatusShow::None if participant left the room.
 		/// \param statusMessage Current status message of participant.
 		/// \param newname New name of participant if he changed the nickname. Otherwise empty.
 		void handleParticipantChanged(const std::string &user, const std::string &nickname, const std::string &room, int flags,
 			pbnetwork::StatusType = pbnetwork::STATUS_NONE, const std::string &statusMessage = "", const std::string &newname = "");
 		/// Call this function when user disconnected the legacy network because of some legacy network error.
 		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")
 		/// \param error Reserved for future use, currently keep it on 0.
 		/// \param message XMPP message which is sent to XMPP user.
 		void handleDisconnected(const std::string &user, int error = 0, const std::string &message = "");
 		/// Call this function when user connected the legacy network and is logged in.
 		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")
 		void handleConnected(const std::string &user);
 		/// Call this function when new message is received from legacy network for user.
 		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")
 		/// \param legacyName Name of legacy network buddy or name of room. (eg. "user2@gmail.com")
 		/// \param message Plain text message.
 		/// \param nickname Nickname of buddy in room. Empty if it's normal chat message.
 		/// \param xhtml XHTML message.
 		void handleMessage(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &nickname = "", const std::string &xhtml = "");
+		void handleMessage(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &nickname = "", const std::string &xhtml = "", const std::string &timestamp = "");
 		/// 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.
@@ @@ -143,48 +145,50 @@ class NetworkPlugin { @@
 		/// \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);
 		void handleRoomList(const std::string &user, const std::list<std::string> &rooms, const std::list<std::string> &names);
 		/// 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.

include/transport/networkpluginserver.h

➞

Show inline comments

@@ @@ -22,138 +22,144 @@ @@
 #include <time.h>
 #include "Swiften/Swiften.h"
 #include "Swiften/Presence/PresenceOracle.h"
 #include "Swiften/Disco/EntityCapsManager.h"
 #include "Swiften/Network/BoostConnectionServer.h"
 #include "Swiften/Network/Connection.h"
 #include "storagebackend.h"
 #include "transport/filetransfermanager.h"
 namespace Transport {
 class UserManager;
 class User;
 class Component;
 class Buddy;
 class LocalBuddy;
 class Config;
 class NetworkConversation;
 class VCardResponder;
 class RosterResponder;
 class BlockResponder;
 class DummyReadBytestream;
 class AdminInterface;
 class DiscoItemsResponder;
 class NetworkPluginServer {
 	public:
 		struct Backend {
 			int pongReceived;
 			std::list<User *> users;
 			Swift::SafeByteArray data;
 			boost::shared_ptr<Swift::Connection> connection;
 			unsigned long res;
 			unsigned long init_res;
 			unsigned long shared;
 			bool acceptUsers;
 			bool longRun;
 			bool willDie;
 			std::string id;
 		};
 		NetworkPluginServer(Component *component, Config *config, UserManager *userManager, FileTransferManager *ftManager);
+		NetworkPluginServer(Component *component, Config *config, UserManager *userManager, FileTransferManager *ftManager, DiscoItemsResponder *discoItemsResponder);
 		virtual ~NetworkPluginServer();
 		void start();
 		void setAdminInterface(AdminInterface *adminInterface) {
 			m_adminInterface = adminInterface;
+		}
 		int getBackendCount() {
 			return m_clients.size();
+		}
 		const std::list<Backend *> &getBackends() {
 			return m_clients;
+		}
 		const std::vector<std::string> &getCrashedBackends() {
 			return m_crashedBackends;
+		}
 		void collectBackend();
 		bool moveToLongRunBackend(User *user);
 		void handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &message);
-	private:
+	public:
 		void handleNewClientConnection(boost::shared_ptr<Swift::Connection> c);
 		void handleSessionFinished(Backend *c);
 		void handlePongReceived(Backend *c);
 		void handleDataRead(Backend *c, boost::shared_ptr<Swift::SafeByteArray> data);
 		void handleConnectedPayload(const std::string &payload);
 		void handleDisconnectedPayload(const std::string &payload);
 		void handleBuddyChangedPayload(const std::string &payload);
 		void handleBuddyRemovedPayload(const std::string &payload);
 		void handleConvMessagePayload(const std::string &payload, bool subject = false);
 		void handleParticipantChangedPayload(const std::string &payload);
 		void handleRoomChangedPayload(const std::string &payload);
 		void handleVCardPayload(const std::string &payload);
 		void handleChatStatePayload(const std::string &payload, Swift::ChatState::ChatStateType type);
 		void handleAuthorizationPayload(const std::string &payload);
 		void handleAttentionPayload(const std::string &payload);
 		void handleStatsPayload(Backend *c, const std::string &payload);
 		void handleFTStartPayload(const std::string &payload);
 		void handleFTFinishPayload(const std::string &payload);
 		void handleFTDataPayload(Backend *b, const std::string &payload);
 		void handleQueryPayload(Backend *b, const std::string &payload);
 		void handleBackendConfigPayload(const std::string &payload);
 		void handleRoomListPayload(const std::string &payload);
 		void handleUserCreated(User *user);
 		void handleRoomJoined(User *user, const Swift::JID &who, const std::string &room, const std::string &nickname, const std::string &password);
 		void handleRoomLeft(User *user, const std::string &room);
 		void handleUserReadyToConnect(User *user);
 		void handleUserPresenceChanged(User *user, Swift::Presence::ref presence);
 		void handleUserDestroyed(User *user);
 		void handleBuddyUpdated(Buddy *buddy, const Swift::RosterItemPayload &item);
 		void handleBuddyRemoved(Buddy *buddy);
 		void handleBuddyAdded(Buddy *buddy, const Swift::RosterItemPayload &item);
 		void handleBlockToggled(Buddy *buddy);
 		void handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> vcard);
 		void handleVCardRequired(User *user, const std::string &name, unsigned int id);
 		void handleFTStateChanged(Swift::FileTransfer::State state, const std::string &userName, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long id);
 		void handleFTAccepted(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID);
 		void handleFTRejected(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size);
 		void handleFTDataNeeded(Backend *b, unsigned long ftid);
 	private:
 		void send(boost::shared_ptr<Swift::Connection> &, const std::string &data);
 		void pingTimeout();
 		void sendPing(Backend *c);
 		Backend *getFreeClient(bool acceptUsers = true, bool longRun = false);
 		UserManager *m_userManager;
 		VCardResponder *m_vcardResponder;
 		RosterResponder *m_rosterResponder;
 		BlockResponder *m_blockResponder;
 		Config *m_config;
 		boost::shared_ptr<Swift::ConnectionServer> m_server;
 		std::list<Backend *>  m_clients;
 		Swift::Timer::ref m_pingTimer;
 		Swift::Timer::ref m_collectTimer;
 		Component *m_component;
 		std::list<User *> m_waitingUsers;
 		bool m_isNextLongRun;
 		std::map<unsigned long, FileTransferManager::Transfer> m_filetransfers;
 		FileTransferManager *m_ftManager;
 		std::vector<std::string> m_crashedBackends;
 		AdminInterface *m_adminInterface;
 		bool m_startingBackend;
 		DiscoItemsResponder *m_discoItemsResponder;
 };
+}

include/transport/protocol.proto

➞

Show inline comments

@@ @@ -48,57 +48,63 @@ message Login { @@
+}
 message Logout {
 	required string user = 1;
 	required string legacyName = 2;
+}
 message Buddy {
 	required string userName = 1;
 	required string buddyName = 2;
 	optional string alias = 3;
 	repeated string group = 4;
 	optional StatusType status = 5;
 	optional string statusMessage = 6;
 	optional string iconHash = 7;
 	optional bool blocked = 8;
+}
 message ConversationMessage {
 	required string userName = 1;
 	required string buddyName = 2;
 	required string message = 3;
 	optional string nickname = 4;
 	optional string xhtml = 5;
 	optional string timestamp = 6;
+}
 message Room {
 	required string userName = 1;
 	required string nickname = 2;
 	required string room = 3;
 	optional string password = 4;
+}
 message RoomList {
 	repeated string room = 1;
 	repeated string name = 2;
+}
 message Participant {
 	required string userName = 1;
 	required string room = 2;
 	required string nickname = 3;
 	required int32 flag = 4;
 	required StatusType status = 5;
 	optional string statusMessage = 6;
 	optional string newname = 7;
+}
 message VCard {
 	required string userName = 1;
 	required string buddyName = 2;
 	required int32 id = 3;
 	optional string fullname = 4;
 	optional string nickname = 5;
 	optional bytes photo = 6;
+}
 message Status {
 	required string userName = 1;
 	required StatusType status = 3;
 	optional string statusMessage = 4;
+}
@@ @@ -138,29 +144,30 @@ message WrapperMessage { @@
 		TYPE_CONV_MESSAGE			= 8;
 		TYPE_PING					= 9;
 		TYPE_PONG					= 10;
 		TYPE_JOIN_ROOM				= 11;
 		TYPE_LEAVE_ROOM				= 12;
 		TYPE_PARTICIPANT_CHANGED	= 13;
 		TYPE_ROOM_NICKNAME_CHANGED	= 14;
 		TYPE_ROOM_SUBJECT_CHANGED	= 15;
 		TYPE_VCARD					= 16;
 		TYPE_STATUS_CHANGED			= 17;
 		TYPE_BUDDY_TYPING			= 18;
 		TYPE_BUDDY_STOPPED_TYPING	= 19;
 		TYPE_BUDDY_TYPED			= 20;
 		TYPE_AUTH_REQUEST			= 21;
 		TYPE_ATTENTION				= 22;
 		TYPE_STATS					= 23;
 		TYPE_FT_START				= 24;
 		TYPE_FT_FINISH				= 25;
 		TYPE_FT_DATA				= 26;
 		TYPE_FT_PAUSE				= 27;
 		TYPE_FT_CONTINUE			= 28;
 		TYPE_EXIT					= 29;
 		TYPE_BACKEND_CONFIG			= 30;
 		TYPE_QUERY					= 31;
 		TYPE_ROOM_LIST				= 32;
+	}
 	required Type type = 1;
 	optional bytes payload = 2;
+}
+;

include/transport/storagebackend.h

➞

Show inline comments

@@ @@ -65,48 +65,56 @@ typedef enum @@
 struct SettingVariableInfo {
 	int type;
 	std::string s;
 	int i;
 	bool b;
 };
 struct BuddyInfo {
 	long id;
 	std::string alias;
 	std::string legacyName;
 	std::string subscription;
 	std::vector<std::string> groups;
 	std::map<std::string, SettingVariableInfo> settings;
 	int flags;
 };
 class Config;
 /// Abstract class defining storage backends.
 class StorageBackend
+{
 	public:
 		static std::string encryptPassword(const std::string &password, const std::string &key);
 		static std::string decryptPassword(std::string &encrypted, const std::string &key);
 		static std::string serializeGroups(const std::vector<std::string> &groups);
 		static std::vector<std::string> deserializeGroups(std::string &groups);
 		/// Virtual desctructor.
 		virtual ~StorageBackend() {}
 		static StorageBackend *createBackend(Config *config, std::string &error);
 		/// connect
 		virtual bool connect() = 0;
 		/// createDatabase
 		virtual bool createDatabase() = 0;
 		/// setUser
 		virtual void setUser(const UserInfo &user) = 0;
 		/// getuser
 		virtual bool getUser(const std::string &barejid, UserInfo &user) = 0;
 		/// setUserOnline
 		virtual void setUserOnline(long id, bool online) = 0;
 		/// removeUser
 		virtual bool removeUser(long id) = 0;
 		/// getBuddies

include/transport/transport.h

➞

Show inline comments

@@ @@ -26,117 +26,102 @@ @@
 #include "Swiften/Disco/GetDiscoInfoRequest.h"
 #include "Swiften/Disco/EntityCapsManager.h"
 #include "Swiften/Disco/CapsManager.h"
 #include "Swiften/Disco/CapsMemoryStorage.h"
 #include "Swiften/Network/BoostTimerFactory.h"
 #include "Swiften/Network/BoostIOServiceThread.h"
 #include "Swiften/Server/UserRegistry.h"
 #include "Swiften/Base/SafeByteArray.h"
 #include "Swiften/Jingle/JingleSessionManager.h"
 #include <boost/bind.hpp>
 #include "transport/config.h"
 #include "transport/factory.h"
 #include "transport/presenceoracle.h"
 #include <Swiften/Network/BoostConnectionServer.h>
 namespace Transport {
 	// typedef enum { 	CLIENT_FEATURE_ROSTERX = 2,
 	// 				CLIENT_FEATURE_XHTML_IM = 4,
 	// 				CLIENT_FEATURE_FILETRANSFER = 8,
 	// 				CLIENT_FEATURE_CHATSTATES = 16
 	// 				} SpectrumImportantFeatures;
 	//
 	class StorageBackend;
 	class DiscoInfoResponder;
 	class Factory;
 	class UserRegistry;
 	/// Represents one transport instance.
 	/// It's used to connect the Jabber server and provides transaction layer
 	/// between Jabber server and other classes.
 	///
 	/// In server mode it represents Jabber server to which users can connect and use
 	/// it as transport.
 	class Component {
 		public:
 			/// Creates new Component instance.
 			/// \param loop Main event loop.
 			/// \param config Cofiguration; this class uses following Config values:
 			/// 	- service.jid
 			/// 	- service.password
 			/// 	- service.server
 			/// 	- service.port
 			/// 	- service.server_mode
 			/// \param factory Transport Abstract factory used to create basic transport structures.
 			Component(Swift::EventLoop *loop, Swift::NetworkFactories *factories, Config *config, Factory *factory, Transport::UserRegistry *userRegistry = NULL);
 			/// Component destructor.
 			~Component();
 			/// Returns Swift::StanzaChannel associated with this Transport::Component.
 			/// It can be used to send presences and other stanzas.
 			/// \return Swift::StanzaChannel associated with this Transport::Component.
 			Swift::StanzaChannel *getStanzaChannel();
 			Swift::CapsInfo &getBuddyCapsInfo();
 			/// Returns Swift::IQRouter associated with this Component.
 			/// \return Swift::IQRouter associated with this Component.
 			Swift::IQRouter *getIQRouter() { return m_iqRouter; }
 			/// Returns Swift::PresenceOracle associated with this Transport::Component.
 			/// You can use it to check current resource connected for particular user.
 			/// \return Swift::PresenceOracle associated with this Transport::Component.
 			PresenceOracle *getPresenceOracle();
 			/// Returns True if the component is in server mode.
 			/// \return True if the component is in server mode.
 			bool inServerMode() { return m_server != NULL; }
 			/// Connects the Jabber server.
 			void start();
 			void stop();
 			/// Sets disco#info features which are sent as answer to disco#info IQ-get.
 			/// This sets features of transport contact (For example "j2j.domain.tld").
 			/// \param features list of features as sent in disco#info response
 			void setTransportFeatures(std::list<std::string> &features);
 			/// Sets disco#info features which are sent as answer to disco#info IQ-get.
 			/// This sets features of legacy network buddies (For example "me\40gmail.com@j2j.domain.tld").
 			/// \param features list of features as sent in disco#info response
 			void setBuddyFeatures(std::list<std::string> &features);
 			/// Returns Jabber ID of this transport.
 			/// \return Jabber ID of this transport
 			Swift::JID &getJID() { return m_jid; }
 			/// Returns Swift::NetworkFactories which can be used to create new connections.
 			/// \return Swift::NetworkFactories which can be used to create new connections.
 			Swift::NetworkFactories *getNetworkFactories() { return m_factories; }
 			/// Returns Transport Factory used to create basic Transport components.
 			/// \return Transport Factory used to create basic Transport components.
 			Factory *getFactory() { return m_factory; }
 			/// This signal is emitted when server disconnects the transport because of some error.
 			/// \param error disconnection error
 			boost::signal<void (const Swift::ComponentError &error)> onConnectionError;
 			/// This signal is emitted when transport successfully connects the server.
 			boost::signal<void ()> onConnected;
 			/// This signal is emitted when XML stanza is sent to server.
@@ @@ -165,37 +150,36 @@ namespace Transport { @@
 		private:
 			void handleConnected();
 			void handleConnectionError(const Swift::ComponentError &error);
 			void handleServerStopped(boost::optional<Swift::BoostConnectionServer::Error> e);
 			void handlePresence(Swift::Presence::ref presence);
 			void handleDataRead(const Swift::SafeByteArray &data);
 			void handleDataWritten(const Swift::SafeByteArray &data);
 			void handleDiscoInfoResponse(boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid);
 			void handleCapsChanged(const Swift::JID& jid);
 			Swift::NetworkFactories *m_factories;
 			Swift::Component *m_component;
 			Swift::Server *m_server;
 			Swift::Timer::ref m_reconnectTimer;
 			Swift::EntityCapsManager *m_entityCapsManager;
 			Swift::CapsManager *m_capsManager;
 			Swift::CapsMemoryStorage *m_capsMemoryStorage;
 			PresenceOracle *m_presenceOracle;
 			Swift::StanzaChannel *m_stanzaChannel;
 			Swift::IQRouter *m_iqRouter;
 			Transport::UserRegistry *m_userRegistry;
 			StorageBackend *m_storageBackend;
  			DiscoInfoResponder *m_discoInfoResponder;
 			int m_reconnectCount;
 			Config* m_config;
 			std::string m_protocol;
 			Swift::JID m_jid;
 			Factory *m_factory;
 			Swift::EventLoop *m_loop;
 		friend class User;
 		friend class UserRegistration;
 		friend class NetworkPluginServer;
 	};
+}

include/transport/user.h

➞

Show inline comments

@@ @@ -50,54 +50,56 @@ class User : public Swift::EntityCapsProvider { @@
 		/// Destroyes User.
 		virtual ~User();
 		/// Returns JID of XMPP user who is currently connected using this User class.
 		/// \return full JID
 		const Swift::JID &getJID();
 		/// Returns full JID which supports particular feature or invalid JID.
 		/// \param feature disco#info feature.
 		/// \return full JID which supports particular feature or invalid JID.
 		Swift::JID getJIDWithFeature(const std::string &feature);
 		Swift::DiscoInfo::ref getCaps(const Swift::JID &jid) const;
 		/// Returns UserInfo struct with informations needed to connect the legacy network.
 		/// \return UserInfo struct
 		UserInfo &getUserInfo() { return m_userInfo; }
 		RosterManager *getRosterManager() { return m_rosterManager; }
 		ConversationManager *getConversationManager() { return m_conversationManager; }
 		Component *getComponent() { return m_component; }
 		UserManager *getUserManager() { return m_userManager; }
 		void setData(void *data) { m_data = data; }
 		void *getData() { return m_data; }
 		/// Handles presence from XMPP JID associated with this user.
 		/// \param presence Swift::Presence.
 		void handlePresence(Swift::Presence::ref presence);
+		void handlePresence(Swift::Presence::ref presence, bool forceJoin = false);
 		void handleSubscription(Swift::Presence::ref presence);
 		void handleDiscoInfo(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info);
 		time_t &getLastActivity() {
 			return m_lastActivity;
+		}
 		void updateLastActivity() {
 			m_lastActivity = time(NULL);
+		}
 		/// Returns language.
 		/// \return language
 		const char *getLang() { return "en"; }
 		void handleDisconnected(const std::string &error, Swift::SpectrumErrorPayload::Error e = Swift::SpectrumErrorPayload::CONNECTION_ERROR_OTHER_ERROR);
 		bool isReadyToConnect() {
 			return m_readyForConnect;
+		}
 		void setConnected(bool connected);
@@ @@ -121,27 +123,28 @@ class User : public Swift::EntityCapsProvider { @@
 		boost::signal<void ()> onDisconnected;
 	private:
 		void onConnectingTimeout();
 		Swift::JID m_jid;
 		Component *m_component;
 		RosterManager *m_rosterManager;
 		UserManager *m_userManager;
 		ConversationManager *m_conversationManager;
 		Swift::EntityCapsManager *m_entityCapsManager;
 		PresenceOracle *m_presenceOracle;
 		UserInfo m_userInfo;
 		void *m_data;
 		bool m_connected;
 		bool m_readyForConnect;
 		bool m_ignoreDisconnect;
 		Swift::Timer::ref m_reconnectTimer;
 		boost::shared_ptr<Swift::Connection> connection;
 		time_t m_lastActivity;
 		std::map<Swift::JID, Swift::DiscoInfo::ref> m_legacyCaps;
 		std::vector<boost::shared_ptr<Swift::OutgoingFileTransfer> > m_filetransfers;
 		int m_resources;
 		int m_reconnectCounter;
 		std::list<Swift::Presence::ref> m_joinedRooms;
 };
+}

include/transport/usermanager.h

➞

Show inline comments

@@ @@ -11,139 +11,144 @@ @@
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <string>
 #include <map>
 #include "Swiften/Swiften.h"
 #include "transport/userregistry.h"
 namespace Transport {
 class User;
 class Component;
 class StorageBackend;
 class StorageResponder;
 class RosterResponder;
 class DiscoItemsResponder;
 /// Manages online XMPP Users.
 /// This class handles presences and creates User classes when new user connects.
 /// It also removes the User class once the last user's resource disconnected.
 /// Basic user creation process:
 /**
 	\msc
 	Component,UserManager,User,StorageBackend,Slot;
 	---  [ label = "Available presence received"];
 	Component->UserManager [label="handlePresence(...)", URL="\ref UserManager::handlePresence()"];
 	UserManager->StorageBackend [label="getUser(...)", URL="\ref StorageBackend::getUser()"];
 	UserManager->User [label="User::User(...)", URL="\ref User"];
 	UserManager->Slot [label="onUserCreated(...)", URL="\ref UserManager::onUserCreated()"];
 	UserManager->User [label="handlePresence(...)", URL="\ref User::handlePresence()"];
 	\endmsc
 */
 class UserManager : public Swift::EntityCapsProvider {
 	public:
 		/// Creates new UserManager.
 		/// \param component Component which's presence will be handled
 		/// \param storageBackend Storage backend used to fetch UserInfos
 		UserManager(Component *component, UserRegistry *userRegistry, StorageBackend *storageBackend = NULL);
+		UserManager(Component *component, UserRegistry *userRegistry, DiscoItemsResponder *discoItemsResponder, StorageBackend *storageBackend = NULL);
 		/// Destroys UserManager.
 		~UserManager();
 		/// Returns user according to his bare JID.
 		/// \param barejid bare JID of user
 		/// \return User class associated with this user
 		User *getUser(const std::string &barejid);
 		/// Returns map with all connected users.
 		/// \return All connected users.
 		const std::map<std::string, User *> &getUsers() {
 			return m_users;
+		}
 		/// Returns number of online users.
 		/// \return number of online users
 		int getUserCount();
 		/// Removes user. This function disconnects user and safely removes
 		/// User class. This does *not* remove user from StorageBackend.
 		/// \param user User class to remove
 		void removeUser(User *user, bool onUserBehalf = true);
 		void removeAllUsers(bool onUserBehalf = true);
 		Swift::DiscoInfo::ref getCaps(const Swift::JID&) const;
 		DiscoItemsResponder *getDiscoResponder() { return m_discoItemsResponder; }
 		/// Called when new User class is created.
 		/// \param user newly created User class
 		boost::signal<void (User *user)> onUserCreated;
 		/// Called when User class is going to be removed
 		/// \param user removed User class
 		boost::signal<void (User *user)> onUserDestroyed;
 		/// Returns true if user is connected.
 		/// \return True if user is connected.
 		bool isUserConnected(const std::string &barejid) const {
 			return m_users.find(barejid) != m_users.end();
+		}
 		/// Returns pointer to UserRegistry.
 		/// \return Pointer to UserRegistry.
 		UserRegistry *getUserRegistry() {
 			return m_userRegistry;
+		}
 		Component *getComponent() {
 			return m_component;
+		}
 		/// Connects user manually.
 		/// \param user JID of user.
 		void connectUser(const Swift::JID &user);
 		/// Disconnects user manually.
 		/// \param user JID of user.
 		void disconnectUser(const Swift::JID &user);
 		void messageToXMPPSent() { m_sentToXMPP++; }
 		void messageToBackendSent() { m_sentToBackend++; }
 		unsigned long getMessagesToXMPP() { return m_sentToXMPP; }
 		unsigned long getMessagesToBackend() { return m_sentToBackend; }
 	private:
 		void handlePresence(Swift::Presence::ref presence);
 		void handleMessageReceived(Swift::Message::ref message);
 		void handleGeneralPresenceReceived(Swift::Presence::ref presence);
 		void handleProbePresence(Swift::Presence::ref presence);
 		void handleErrorPresence(Swift::Presence::ref presence);
 		void handleSubscription(Swift::Presence::ref presence);
 		void handleRemoveTimeout(const std::string jid, User *user, bool reconnect);
 		void handleDiscoInfo(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info);
 		void addUser(User *user);
 		long m_onlineBuddies;
 		User *m_cachedUser;
 		std::map<std::string, User *> m_users;
 		Component *m_component;
 		StorageBackend *m_storageBackend;
 		StorageResponder *m_storageResponder;
 		UserRegistry *m_userRegistry;
 		Swift::Timer::ref m_removeTimer;
 		unsigned long m_sentToXMPP;
 		unsigned long m_sentToBackend;
 		DiscoItemsResponder *m_discoItemsResponder;
 		friend class RosterResponder;
 };
+}

include/transport/util.h

➞

Show inline comments

@@ @@ -5,47 +5,44 @@ @@
+ *
  * 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 <stdio.h>
 #include <stdlib.h>
 #include <vector>
 #include <string>
 #include "Swiften/StringCodecs/Base64.h"
 #include <boost/filesystem.hpp>
 #include "transport/config.h"
 namespace Transport {
 namespace Util {
 void removeEverythingOlderThan(const std::vector<std::string> &dirs, time_t t);
 std::string encryptPassword(const std::string &password, const std::string &key);
 void createDirectories(Transport::Config *config, const boost::filesystem::path& ph);
 std::string decryptPassword(std::string &encrypted, const std::string &key);
 std::string serializeGroups(const std::vector<std::string> &groups);
 std::vector<std::string> deserializeGroups(std::string &groups);
 void removeEverythingOlderThan(const std::vector<std::string> &dirs, time_t t);
 int getRandomPort(const std::string &s);
 #ifdef _WIN32
 	std::wstring utf8ToUtf16(const std::string& str);
 #endif
+}
+}

plugin/cpp/CMakeLists.txt

➞

Show inline comments

 cmake_minimum_required(VERSION 2.6)
 FILE(GLOB SRC *.cpp *.h)
 FILE(GLOB HEADERS ../include/transport/*.h)
 set(EXTRA_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/../../src/memoryusage.cpp)
 set(EXTRA_SOURCES ${EXTRA_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/../../src/logging.cpp)
 set(EXTRA_SOURCES ${EXTRA_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/../../src/config.cpp)
 set(EXTRA_SOURCES ${EXTRA_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/../../src/util.cpp)
 set(EXTRA_SOURCES ${EXTRA_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/../../include/transport/protocol.pb.cc)
 if (NOT WIN32)
 	ADD_LIBRARY(transport-plugin SHARED ${HEADERS} ${SRC} ${PROTOBUF_SRC} ${PROTOBUF_HDRS} ${EXTRA_SOURCES})
 else()
 	ADD_LIBRARY(transport-plugin STATIC ${HEADERS} ${SRC} ${EXTRA_SOURCES} )
 endif()
 ADD_DEPENDENCIES(transport-plugin pb)
 SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_SOURCE_DIR}/../../include/transport/protocol.pb.cc PROPERTIES GENERATED 1)
 if (CMAKE_COMPILER_IS_GNUCXX)
 	if (NOT WIN32)
 	ADD_DEFINITIONS(-fPIC)
 	endif()
 endif()
 if (NOT WIN32)
 	TARGET_LINK_LIBRARIES(transport-plugin ${PROTOBUF_LIBRARY} ${LOG4CXX_LIBRARIES} ${Boost_LIBRARIES})
 else()
 	TARGET_LINK_LIBRARIES(transport-plugin ${PROTOBUF_LIBRARY} ${LOG4CXX_LIBRARIES} ${Boost_LIBRARIES} ws2_32.lib)
 endif()
 SET_TARGET_PROPERTIES(transport-plugin PROPERTIES
       VERSION ${TRANSPORT_VERSION} SOVERSION ${TRANSPORT_VERSION}

plugin/cpp/networkplugin.cpp

➞

Show inline comments

@@ @@ -42,74 +42,75 @@ namespace Transport { @@
 #define WRAP(MESSAGE, TYPE) 	pbnetwork::WrapperMessage wrap; \
 	wrap.set_type(TYPE); \
 	wrap.set_payload(MESSAGE); \
 	wrap.SerializeToString(&MESSAGE);
 template <class T> std::string stringOf(T object) {
 	std::ostringstream os;
 	os << object;
 	return (os.str());
+}
 NetworkPlugin::NetworkPlugin() {
 	m_pingReceived = false;
 	double shared;
 #ifndef WIN32
 	process_mem_usage(shared, m_init_res);
 #endif
+}
 NetworkPlugin::~NetworkPlugin() {
+}
 void NetworkPlugin::sendConfig(const PluginConfig &cfg) {
 	std::string data = "[registration]";
+	std::string data = "[registration]\n";
 	data += std::string("needPassword=") + (cfg.m_needPassword ? "1" : "0") + "\n";
 	data += std::string("needRegistration=") + (cfg.m_needRegistration ? "1" : "0") + "\n";
 	for (std::vector<std::string>::const_iterator it = cfg.m_extraFields.begin(); it != cfg.m_extraFields.end(); it++) {
 		data += std::string("extraField=") + (*it) + "\n";
+	}
 	pbnetwork::BackendConfig m;
 	m.set_config(data);
 	std::string message;
 	m.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BACKEND_CONFIG);
 	send(message);
+}
 void NetworkPlugin::handleMessage(const std::string &user, const std::string &legacyName, const std::string &msg, const std::string &nickname, const std::string &xhtml) {
+void NetworkPlugin::handleMessage(const std::string &user, const std::string &legacyName, const std::string &msg, const std::string &nickname, const std::string &xhtml, const std::string &timestamp) {
 	pbnetwork::ConversationMessage m;
 	m.set_username(user);
 	m.set_buddyname(legacyName);
 	m.set_message(msg);
 	m.set_nickname(nickname);
 	m.set_xhtml(xhtml);
 	m.set_timestamp(timestamp);
 	std::string message;
 	m.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE);
 	send(message);
+}
 void NetworkPlugin::handleAttention(const std::string &user, const std::string &buddyName, const std::string &msg) {
 	pbnetwork::ConversationMessage m;
 	m.set_username(user);
 	m.set_buddyname(buddyName);
 	m.set_message(msg);
 	std::string message;
 	m.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_ATTENTION);
 	send(message);
+}
 void NetworkPlugin::handleVCard(const std::string &user, unsigned int id, const std::string &legacyName, const std::string &fullName, const std::string &nickname, const std::string &photo) {
 		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::handleRoomList(const std::string &user, const std::list<std::string> &rooms, const std::list<std::string> &names) {
 	pbnetwork::RoomList d;
 	for (std::list<std::string>::const_iterator it = rooms.begin(); it != rooms.end(); it++) {
 		d.add_room(*it);
+	}
 	for (std::list<std::string>::const_iterator it = names.begin(); it != names.end(); it++) {
 		d.add_name(*it);
+	}
 	std::string message;
 	d.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_ROOM_LIST);
 	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;
+	}

spectrum/src/CMakeLists.txt

➞

Show inline comments

 cmake_minimum_required(VERSION 2.6)
 FILE(GLOB SRC *.cpp)
 # if (WIN32)
 # FILE(GLOB WIN_SRC win32/*.cpp)
 # include_directories(win32)
 # ADD_EXECUTABLE(spectrum2 ${SRC} ${WIN_SRC})
 # else()
 if (WIN32)
 FILE(GLOB WIN_SRC win32/*.cpp)
 include_directories(win32)
 ADD_EXECUTABLE(spectrum2 ${SRC} ${WIN_SRC})
 else()
 ADD_EXECUTABLE(spectrum2 ${SRC})
-# endif()
 endif()
 ADD_DEPENDENCIES(spectrum2 spectrum2_libpurple_backend)
 ADD_DEPENDENCIES(spectrum2 spectrum2_libircclient-qt_backend)
 target_link_libraries(spectrum2 transport ${SWIFTEN_LIBRARY} ${LOG4CXX_LIBRARIES} ${PROTOBUF_LIBRARY})
 INSTALL(TARGETS spectrum2 RUNTIME DESTINATION bin)
 INSTALL(FILES
 	sample2.cfg
 	RENAME spectrum.cfg.example
 	DESTINATION /etc/spectrum2/transports
+	)
 INSTALL(FILES
 	backend-logging.cfg
 	DESTINATION /etc/spectrum2
+	)
 INSTALL(FILES
 	logging.cfg
 	DESTINATION /etc/spectrum2

spectrum/src/main.cpp

➞

Show inline comments

 #include "transport/config.h"
 #include "transport/transport.h"
 #include "transport/filetransfermanager.h"
 #include "transport/usermanager.h"
 #include "transport/logger.h"
 #include "transport/sqlite3backend.h"
 #include "transport/mysqlbackend.h"
 #include "transport/pqxxbackend.h"
 #include "transport/userregistration.h"
 #include "transport/networkpluginserver.h"
 #include "transport/admininterface.h"
 #include "transport/statsresponder.h"
 #include "transport/usersreconnecter.h"
 #include "transport/util.h"
 #include "transport/gatewayresponder.h"
 #include "transport/logging.h"
 #include "transport/discoitemsresponder.h"
 #include "transport/adhocmanager.h"
 #include "transport/settingsadhoccommand.h"
 #include "Swiften/EventLoop/SimpleEventLoop.h"
 #include <boost/filesystem.hpp>
 #include <boost/algorithm/string.hpp>
 #ifndef WIN32
 #include "sys/signal.h"
 #include "sys/stat.h"
 #include <pwd.h>
 #include <grp.h>
 #include <sys/resource.h>
 #include "libgen.h"
 #ifndef __FreeBSD__
 #include <malloc.h>
 #endif
 #else
 #include <process.h>
 #define getpid _getpid
-// #include "win32/SpectrumService.h"
+#include "win32/ServiceWrapper.h"
 #endif
 #include <sys/stat.h>
 using namespace Transport;
 using namespace Transport::Util;
 DEFINE_LOGGER(logger, "Spectrum");
 Swift::SimpleEventLoop *eventLoop_ = NULL;
 Component *component_ = NULL;
 UserManager *userManager_ = NULL;
 Config *config_ = NULL;
 void stop() {
 	userManager_->removeAllUsers(false);
 	component_->stop();
 	eventLoop_->stop();
+}
 static void stop_spectrum() {
 	userManager_->removeAllUsers(false);
 	component_->stop();
 	eventLoop_->stop();
+}
 static void spectrum_sigint_handler(int sig) {
 	eventLoop_->postEvent(&stop_spectrum);
+}
 static void spectrum_sigterm_handler(int sig) {
 	eventLoop_->postEvent(&stop_spectrum);
+}
 static void removeOldIcons(std::string iconDir) {
 	std::vector<std::string> dirs;
 	dirs.push_back(iconDir);
 	boost::thread thread(boost::bind(Util::removeEverythingOlderThan, dirs, time(NULL) - 3600*24*14));
+}
 #ifndef WIN32
 static void daemonize(const char *cwd, const char *lock_file) {
 	/* Change the file mode mask */
 	umask(0);
 	/* Create a new SID for the child process */
 	sid = setsid();
 	if (sid < 0) {
 		exit(1);
+	}
 	/* Change the current working directory.  This prevents the current
 		directory from being locked; hence not being able to remove it. */
 	if ((chdir(cwd)) < 0) {
 		exit(1);
+	}
 	if (freopen( "/dev/null", "r", stdin) == NULL) {
 		std::cout << "EE cannot open /dev/null. Exiting\n";
 		exit(1);
+	}
+}
 #endif
 int mainloop() {
 #ifndef WIN32
 	mode_t old_cmask = umask(0007);
 #endif
 	Logging::initMainLogging(config_);
 #ifndef WIN32
 	if (!CONFIG_STRING(config_, "service.group").empty() ||!CONFIG_STRING(config_, "service.user").empty() ) {
 		struct rlimit limit;
 		getrlimit(RLIMIT_CORE, &limit);
 		if (!CONFIG_STRING(config_, "service.group").empty()) {
 			struct group *gr;
 			if ((gr = getgrnam(CONFIG_STRING(config_, "service.group").c_str())) == NULL) {
 				std::cerr << "Invalid service.group name " << CONFIG_STRING(config_, "service.group") << "\n";
 				return 1;
+			}
 			if (((setgid(gr->gr_gid)) != 0) || (initgroups(CONFIG_STRING(config_, "service.user").c_str(), gr->gr_gid) != 0)) {
 				std::cerr << "Failed to set service.group name " << CONFIG_STRING(config_, "service.group") << " - " << gr->gr_gid << ":" << strerror(errno) << "\n";
 				return 1;
+			}
+		}
 		if (!CONFIG_STRING(config_, "service.user").empty()) {
 			struct passwd *pw;
 			if ((pw = getpwnam(CONFIG_STRING(config_, "service.user").c_str())) == NULL) {
 				std::cerr << "Invalid service.user name " << CONFIG_STRING(config_, "service.user") << "\n";
 				return 1;
+			}
 			if ((setuid(pw->pw_uid)) != 0) {
 				std::cerr << "Failed to set service.user name " << CONFIG_STRING(config_, "service.user") << " - " << pw->pw_uid << ":" << strerror(errno) << "\n";
 				return 1;
+			}
+		}
 		setrlimit(RLIMIT_CORE, &limit);
+	}
 	struct rlimit limit;
 	limit.rlim_max = RLIM_INFINITY;
 	limit.rlim_cur = RLIM_INFINITY;
 	setrlimit(RLIMIT_CORE, &limit);
 #endif
 	Swift::SimpleEventLoop eventLoop;
 	Swift::BoostNetworkFactories *factories = new Swift::BoostNetworkFactories(&eventLoop);
 	UserRegistry userRegistry(config_, factories);
 	Component transport(&eventLoop, factories, config_, NULL, &userRegistry);
 	component_ = &transport;
 // 	Logger logger(&transport);
 	std::string error;
 	StorageBackend *storageBackend = StorageBackend::createBackend(config_, error);
 	if (storageBackend == NULL) {
 		if (!error.empty()) {
 			std::cerr << error << "\n";
 			return -2;
+		}
+	}
 	else if (!storageBackend->connect()) {
 		std::cerr << "Can't connect to database. Check the log to find out the reason.\n";
 		return -1;
+	}
 	Logging::redirect_stderr();
 	DiscoItemsResponder discoItemsResponder(&transport);
 	discoItemsResponder.start();
 	UserManager userManager(&transport, &userRegistry, &discoItemsResponder, storageBackend);
 	userManager_ = &userManager;
 	UserRegistration *userRegistration = NULL;
 	UsersReconnecter *usersReconnecter = NULL;
 	if (storageBackend) {
 		userRegistration = new UserRegistration(&transport, &userManager, storageBackend);
 		userRegistration->start();
 		usersReconnecter = new UsersReconnecter(&transport, storageBackend);
+	}
 	FileTransferManager ftManager(&transport, &userManager);
 	NetworkPluginServer plugin(&transport, config_, &userManager, &ftManager, &discoItemsResponder);
 	plugin.start();
 	AdminInterface adminInterface(&transport, &userManager, &plugin, storageBackend, userRegistration);
 	plugin.setAdminInterface(&adminInterface);
 	StatsResponder statsResponder(&transport, &userManager, &plugin, storageBackend);
 	statsResponder.start();
 	GatewayResponder gatewayResponder(transport.getIQRouter(), &userManager);
 	gatewayResponder.start();
 	AdHocManager adhocmanager(&transport, &discoItemsResponder, &userManager, storageBackend);
 	adhocmanager.start();
 	SettingsAdHocCommandFactory settings;
 	adhocmanager.addAdHocCommand(&settings);
 	eventLoop_ = &eventLoop;
 	eventLoop.run();
 #ifndef WIN32
 	umask(old_cmask);
 #endif
 	if (userRegistration) {
 		userRegistration->stop();
 		delete userRegistration;
+	}
 	if (usersReconnecter) {
 		delete usersReconnecter;
+	}
 	delete storageBackend;
 	delete factories;
 	return 0;
+}
 int main(int argc, char **argv)
+{
 	Config config(argc, argv);
+	config_ = &config;
 	boost::program_options::variables_map vm;
 	bool no_daemon = false;
 	std::string config_file;
 	std::string jid;
 #ifdef WIN32
 	std::string install_service_name, uninstall_service_name, run_service_name;
 	// determine the name of the currently executing file
 	char szFilePath[MAX_PATH];
 	GetModuleFileNameA(NULL, szFilePath, sizeof(szFilePath));
 	std::string exe_file(szFilePath);
 #endif
 	setlocale(LC_ALL, "");
 #ifndef WIN32
 #ifndef __FreeBSD__
 	mallopt(M_CHECK_ACTION, 2);
 	mallopt(M_PERTURB, 0xb);
 #endif
 #endif
 #ifndef WIN32
 	if (signal(SIGINT, spectrum_sigint_handler) == SIG_ERR) {
 		std::cout << "SIGINT handler can't be set\n";
 		return -1;
+	}
 	if (signal(SIGTERM, spectrum_sigterm_handler) == SIG_ERR) {
 		std::cout << "SIGTERM handler can't be set\n";
 		return -1;
+	}
 #endif
 	boost::program_options::options_description desc(std::string("Spectrum version: ") + SPECTRUM_VERSION + "\nUsage: spectrum [OPTIONS] <config_file.cfg>\nAllowed options");
 	desc.add_options()
 		("help,h", "help")
 		("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>(&config_file)->default_value(""), "Config file")
 		("version,v", "Shows Spectrum version")
+		;
 #ifdef WIN32
 // 	desc.add_options()
 // 		("install-service,i", "Install spectrum as Windows service")
 // 		("uninstall-service,u", "Uninstall Windows service");
  	desc.add_options()
 		("install-service,i", boost::program_options::value<std::string>(&install_service_name)->default_value(""), "Install spectrum as Windows service")
  		("uninstall-service,u", boost::program_options::value<std::string>(&uninstall_service_name)->default_value(""), "Uninstall Windows service")
 		("run-as-service,r", boost::program_options::value<std::string>(&run_service_name)->default_value(""), "stub for Windows Service Manager");
 #endif
 	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("version")) {
 			std::cout << SPECTRUM_VERSION << "\n";
 			return 0;
+		}
 		if(vm.count("help"))
+		{
 			std::cout << desc << "\n";
 			return 1;
+		}
 		if(vm.count("config") == 0) {
 			std::cout << desc << "\n";
 			return 1;
+		}
 		if(vm.count("no-daemonize")) {
 			no_daemon = true;
+		}
 #ifdef WIN32
 #if 0
 		if (vm.count("install-service")) {
 			SpectrumService ntservice;
 #ifdef WIN32
 		if (!install_service_name.empty()) {
 			// build command line for Service Manager
 			std::string service_path = exe_file + std::string(" --config ") + vm["config"].as<std::string>()
 						+ std::string(" --run-as-service ") + install_service_name;
 			ServiceWrapper ntservice((char *)install_service_name.c_str());
 			if (!ntservice.IsInstalled()) {
 					// determine the name of the currently executing file
 				char szFilePath[MAX_PATH];
 				GetModuleFileName(NULL, szFilePath, sizeof(szFilePath));
 				std::string exe_file(szFilePath);
 				std::string config_file = exe_file.replace(exe_file.end() - 4, exe_file.end(), ".cfg");
 				std::string service_path = std::string(szFilePath) + std::string(" --config ") + config_file;
 				if (ntservice.Install(service_path.c_str())) {
 					std::cout << "Successfully installed" << std::endl;
 				if (ntservice.Install((char *)service_path.c_str())) {
 					std::cout << "Successfully installed " << install_service_name << std::endl;
 					return 0;
 				} else {
 					std::cout << "Error installing service, are you an Administrator?" << std::endl;
 					return 1;
+				}
 			} else {
 				std::cout << "Already installed" << std::endl;
+				std::cout << "Already installed " << install_service_name << std::endl;
 				return 1;
+			}
+		}
 		if (vm.count("uninstall-service")) {
 			SpectrumService ntservice;
 		if (!uninstall_service_name.empty()) {
 			ServiceWrapper ntservice((char *)uninstall_service_name.c_str());
 			if (ntservice.IsInstalled()) {
 				if (ntservice.Remove()) {
 					std::cout << "Successfully removed" << std::endl;
 				if (ntservice.UnInstall()) {
 					std::cout << "Successfully removed " << uninstall_service_name << std::endl;
 					return 0;
 				} else {
 					std::cout << "Error removing service, are you an Administrator?" << std::endl;
 					return 1;
+				}
 			} else {
 				std::cout << "Service not installed" << std::endl;
+				std::cout << "Service not installed: " << uninstall_service_name << std::endl;
 				return 1;
+			}
+		}
 #endif
+		}
 #endif
+	}
 	catch (std::runtime_error& e)
+	{
 		std::cout << desc << "\n";
 		return 1;
+	}
 	catch (...)
+	{
 		std::cout << desc << "\n";
 		return 1;
+	}
 	if (!config.load(vm["config"].as<std::string>(), jid)) {
 		std::cerr << "Can't load configuration file.\n";
 		return 1;
+	}
 	// create directories
 	try {
 		boost::filesystem::create_directories(CONFIG_STRING(&config, "service.working_dir"));
 		Transport::Util::createDirectories(&config, CONFIG_STRING(&config, "service.working_dir"));
+	}
 	catch (...) {
 		std::cerr << "Can't create service.working_dir directory " << CONFIG_STRING(&config, "service.working_dir") << ".\n";
 		return 1;
+	}
 #ifndef WIN32
 	// create directories
 	try {
 		boost::filesystem::create_directories(
 			boost::filesystem::path(CONFIG_STRING(&config, "service.pidfile")).parent_path().string()
 		);
+	}
 	catch (...) {
 		std::cerr << "Can't create service.pidfile directory " << boost::filesystem::path(CONFIG_STRING(&config, "service.pidfile")).parent_path().string() << ".\n";
 		return 1;
+	}
 	// create directories
 	try {
 		boost::filesystem::create_directories(
 			boost::filesystem::path(CONFIG_STRING(&config, "service.portfile")).parent_path().string()
 		);
+	}
 	catch (...) {
 		std::cerr << "Can't create service.portfile directory " << CONFIG_STRING(&config, "service.portfile") << ".\n";
 		return 1;
+	}
 #endif
 #ifdef WIN32
 	SetCurrentDirectory( utf8ToUtf16(CONFIG_STRING(&config, "service.working_dir")).c_str() );
 #endif
 #ifndef WIN32
 	if (!CONFIG_STRING(&config, "service.group").empty() ||!CONFIG_STRING(&config, "service.user").empty() ) {
 		struct group *gr;
 		if ((gr = getgrnam(CONFIG_STRING(&config, "service.group").c_str())) == NULL) {
 			std::cerr << "Invalid service.group name " << CONFIG_STRING(&config, "service.group") << "\n";
 			return 1;
+		}
 		struct passwd *pw;
 		if ((pw = getpwnam(CONFIG_STRING(&config, "service.user").c_str())) == NULL) {
 			std::cerr << "Invalid service.user name " << CONFIG_STRING(&config, "service.user") << "\n";
 			return 1;
+		}
 		chown(CONFIG_STRING(&config, "service.working_dir").c_str(), pw->pw_uid, gr->gr_gid);
+	}
 	char backendport[20];
 	FILE* port_file_f;
 	port_file_f = fopen(CONFIG_STRING(&config, "service.portfile").c_str(), "w+");
 	if (port_file_f == NULL) {
 		std::cerr << "Cannot create port_file file " << CONFIG_STRING(&config, "service.portfile").c_str() << ". Exiting\n";
 		exit(1);
+	}
 	sprintf(backendport,"%s\n",CONFIG_STRING(&config, "service.backend_port").c_str());
 	if (fwrite(backendport,1,strlen(backendport),port_file_f) < strlen(backendport)) {
 		std::cerr << "Cannot write to port file " << CONFIG_STRING(&config, "service.portfile") << ". Exiting\n";
 		exit(1);
+	}
 	fclose(port_file_f);
 	if (!no_daemon) {
 		// daemonize
 		daemonize(CONFIG_STRING(&config, "service.working_dir").c_str(), CONFIG_STRING(&config, "service.pidfile").c_str());
 // 		removeOldIcons(CONFIG_STRING(&config, "service.working_dir") + "/icons");
+    }
 #endif
 	Logging::initMainLogging(&config);
 #ifndef WIN32
 	if (!CONFIG_STRING(&config, "service.group").empty() ||!CONFIG_STRING(&config, "service.user").empty() ) {
 		struct rlimit limit;
 		getrlimit(RLIMIT_CORE, &limit);
 		if (!CONFIG_STRING(&config, "service.group").empty()) {
 			struct group *gr;
 			if ((gr = getgrnam(CONFIG_STRING(&config, "service.group").c_str())) == NULL) {
 				std::cerr << "Invalid service.group name " << CONFIG_STRING(&config, "service.group") << "\n";
 				return 1;
+			}
 			if (((setgid(gr->gr_gid)) != 0) || (initgroups(CONFIG_STRING(&config, "service.user").c_str(), gr->gr_gid) != 0)) {
 				std::cerr << "Failed to set service.group name " << CONFIG_STRING(&config, "service.group") << " - " << gr->gr_gid << ":" << strerror(errno) << "\n";
 				return 1;
+			}
+		}
 		if (!CONFIG_STRING(&config, "service.user").empty()) {
 			struct passwd *pw;
 			if ((pw = getpwnam(CONFIG_STRING(&config, "service.user").c_str())) == NULL) {
 				std::cerr << "Invalid service.user name " << CONFIG_STRING(&config, "service.user") << "\n";
 				return 1;
+			}
 			if ((setuid(pw->pw_uid)) != 0) {
 				std::cerr << "Failed to set service.user name " << CONFIG_STRING(&config, "service.user") << " - " << pw->pw_uid << ":" << strerror(errno) << "\n";
 				return 1;
+			}
 #ifdef WIN32
 	if (!run_service_name.empty()) {
 		ServiceWrapper ntservice((char *)run_service_name.c_str());
 		if (ntservice.IsInstalled()) {
 			ntservice.RunService();
 		} else {
 			std::cerr << "Service not installed: " << run_service_name << std::endl;
 			return 1;
+		}
 		setrlimit(RLIMIT_CORE, &limit);
 	} else {
 		mainloop();
+	}
 	struct rlimit limit;
 	limit.rlim_max = RLIM_INFINITY;
 	limit.rlim_cur = RLIM_INFINITY;
 	setrlimit(RLIMIT_CORE, &limit);
 #else
 	mainloop();
 #endif
 	Swift::SimpleEventLoop eventLoop;
 	Swift::BoostNetworkFactories *factories = new Swift::BoostNetworkFactories(&eventLoop);
 	UserRegistry userRegistry(&config, factories);
 	Component transport(&eventLoop, factories, &config, NULL, &userRegistry);
 	component_ = &transport;
 // 	Logger logger(&transport);
 	std::string error;
 	StorageBackend *storageBackend = StorageBackend::createBackend(&config, error);
 	if (storageBackend == NULL) {
 		if (!error.empty()) {
 			std::cerr << error << "\n";
 			return -2;
+		}
+	}
 	else if (!storageBackend->connect()) {
 		std::cerr << "Can't connect to database. Check the log to find out the reason.\n";
 		return -1;
+	}
 	Logging::redirect_stderr();
 	UserManager userManager(&transport, &userRegistry, storageBackend);
 	userManager_ = &userManager;
 	UserRegistration *userRegistration = NULL;
 	UsersReconnecter *usersReconnecter = NULL;
 	if (storageBackend) {
 		userRegistration = new UserRegistration(&transport, &userManager, storageBackend);
 		userRegistration->start();
 		usersReconnecter = new UsersReconnecter(&transport, storageBackend);
+	}
 	FileTransferManager ftManager(&transport, &userManager);
 	NetworkPluginServer plugin(&transport, &config, &userManager, &ftManager);
 	AdminInterface adminInterface(&transport, &userManager, &plugin, storageBackend, userRegistration);
 	plugin.setAdminInterface(&adminInterface);
 	StatsResponder statsResponder(&transport, &userManager, &plugin, storageBackend);
 	statsResponder.start();
 	GatewayResponder gatewayResponder(transport.getIQRouter(), &userManager);
 	gatewayResponder.start();
 	DiscoItemsResponder discoItemsResponder(&transport);
 	discoItemsResponder.start();
 	AdHocManager adhocmanager(&transport, &discoItemsResponder, &userManager, storageBackend);
 	adhocmanager.start();
 	SettingsAdHocCommandFactory settings;
 	adhocmanager.addAdHocCommand(&settings);
 	eventLoop_ = &eventLoop;
 	eventLoop.run();
 	if (userRegistration) {
 		userRegistration->stop();
 		delete userRegistration;
+	}
 	if (usersReconnecter) {
 		delete usersReconnecter;
+	}
 	delete storageBackend;
 	delete factories;
 	return 0;
+}

spectrum/src/sample.cfg

➞

Show inline comments

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

spectrum/src/sample2.cfg

➞

Show inline comments

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

spectrum/src/win32/ServiceWrapper.cpp

➞

Show inline comments

@@ new file 100644 @@
 #include "ServiceWrapper.h"
 LPSTR ServiceName;
 SERVICE_STATUS ServiceStatus;
 SERVICE_STATUS_HANDLE ServiceStatusHandle;
 bool doAction (int action, int desiredAccess, LPSTR path = NULL);
 enum actions {
 	DO_INSTALL, DO_DELETE, DO_CHECK
 };
 ServiceWrapper::ServiceWrapper(LPSTR serviceName)
+{
 	ServiceName = serviceName;
 	ServiceStatusHandle = 0;
+}
 ServiceWrapper::~ServiceWrapper(void)
+{
+}
 bool ServiceWrapper::Install(LPSTR commandLine) {
 	return doAction(DO_INSTALL, SC_MANAGER_ALL_ACCESS, commandLine);
+}
 bool ServiceWrapper::UnInstall() {
 	return doAction(DO_DELETE, SC_MANAGER_ALL_ACCESS);
+}
 bool ServiceWrapper::IsInstalled() {
 	return doAction(DO_CHECK, SC_MANAGER_CONNECT);
+}
 bool doAction(int action, int desiredAccess, LPSTR path) {
 	SC_HANDLE scm = OpenSCManager(NULL, NULL, desiredAccess);
 	SC_HANDLE service = NULL;
 	if (!scm) return FALSE;
 	switch(action) {
 	case DO_INSTALL:
 		service = CreateServiceA(
 			scm,
 			ServiceName,
 			ServiceName,
 			SERVICE_ALL_ACCESS,
 			SERVICE_WIN32_OWN_PROCESS,
 			SERVICE_DEMAND_START,
 			SERVICE_ERROR_NORMAL,
 			path,
 			NULL,
 			NULL,
 			NULL,
 			NULL,
 			NULL
 			);
 		return (service != NULL);
 		break;
 	case DO_DELETE:
 		service = OpenServiceA(scm, ServiceName, DELETE);
 		if (service == NULL)
 			return FALSE;
 		if (DeleteService(service))
 			return TRUE;
 		break;
 	case DO_CHECK:
 		service = OpenServiceA(scm, ServiceName, SERVICE_QUERY_STATUS);
 		return (service != NULL);
 	default:
 		return FALSE;
+	}
 	CloseServiceHandle(service);
 	CloseServiceHandle(scm);
 	return FALSE;
+}
 void WINAPI ServiceControlHandler(DWORD controlCode) {
 	switch (controlCode) {
 	case SERVICE_CONTROL_INTERROGATE:
 		break;
 	case SERVICE_CONTROL_STOP:
 		ServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;
 		break;
 	default:
 		break;
+	}
 	SetServiceStatus(ServiceStatusHandle, &ServiceStatus);
 	stop();
+}
 void WINAPI ServiceMain(DWORD argc, LPSTR *argv) {
 	ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
 	ServiceStatus.dwServiceSpecificExitCode = NO_ERROR;
 	ServiceStatusHandle = RegisterServiceCtrlHandlerA(ServiceName, ServiceControlHandler);
 	if (ServiceStatusHandle) {
 		ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
 		SetServiceStatus(ServiceStatusHandle, &ServiceStatus);
 		ServiceStatus.dwControlsAccepted |= (SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);
 		ServiceStatus.dwCurrentState = SERVICE_RUNNING;
 		SetServiceStatus(ServiceStatusHandle, &ServiceStatus);
 		mainloop();
 		ServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;
 		SetServiceStatus(ServiceStatusHandle, &ServiceStatus);
 		ServiceStatus.dwControlsAccepted &= ~(SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);
 		ServiceStatus.dwCurrentState = SERVICE_STOPPED;
 		SetServiceStatus(ServiceStatusHandle, &ServiceStatus);
+	}
+}
 void ServiceWrapper::RunService() {
 	SERVICE_TABLE_ENTRYA serviceTable[] = {
 		{ ServiceName, ServiceMain },
 		{ NULL, NULL}
 	};
 	StartServiceCtrlDispatcherA(serviceTable);
+}
@@ \ No newline at end of file @@

spectrum/src/win32/ServiceWrapper.h

➞

Show inline comments

@@ new file 100644 @@
 #pragma once
 #include "transport/config.h"
 #include <windows.h>
 #include <tchar.h>
 class ServiceWrapper
+{
 public:
 	ServiceWrapper(LPSTR serviceName);
 	~ServiceWrapper(void);
 	bool Install(LPSTR commandLine);
 	bool UnInstall();
 	bool IsInstalled();
 	void RunService();
 };
 int mainloop();
 void stop();

spectrum/src/win32/SpectrumService.cpp

➞

Show inline comments

deleted file

spectrum/src/win32/SpectrumService.h

➞

Show inline comments

deleted file

spectrum/src/win32/WindowsService.cpp

➞

Show inline comments

deleted file

spectrum/src/win32/WindowsService.h

➞

Show inline comments

deleted file

spectrum_manager/src/main.cpp

➞

Show inline comments

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

spectrum_manager/src/mongoose.c

➞

Show inline comments

 // Copyright (c) 2004-2012 Sergey Lyubka
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in
 // all copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 #include <netinet/in.h>
 #if defined(_WIN32)
 #define _CRT_SECURE_NO_WARNINGS // Disable deprecation warning in VS2005
 #else
 #define _XOPEN_SOURCE 600     // For flockfile() on Linux
 #define _LARGEFILE_SOURCE     // Enable 64-bit file offsets
 #define __STDC_FORMAT_MACROS  // <inttypes.h> wants this for C++
 #define __STDC_LIMIT_MACROS   // C++ wants that for INT64_MAX
 #endif
 #if defined(__SYMBIAN32__)
 #define NO_SSL // SSL is not supported
 #define NO_CGI // CGI is not supported
 #define PATH_MAX FILENAME_MAX
 #endif // __SYMBIAN32__
 #ifndef _WIN32_WCE // Some ANSI #includes are not available on Windows CE
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <errno.h>
 #include <signal.h>
 #include <fcntl.h>
 #endif // !_WIN32_WCE
 #include <time.h>

spectrum_manager/src/server.cpp

➞

Show inline comments

   mg_get_var(qs, strlen(qs == NULL ? "" : qs), name, dst, dst_len);
+}
 static void my_strlcpy(char *dst, const char *src, size_t len) {
   strncpy(dst, src, len);
   dst[len - 1] = '\0';
+}
 // Generate session ID. buf must be 33 bytes in size.
 // Note that it is easy to steal session cookies by sniffing traffic.
 // This is why all communication must be SSL-ed.
 static void generate_session_id(char *buf, const char *random,
                                 const char *user) {
   mg_md5(buf, random, user, NULL);
+}
 Server::Server(ManagerConfig *config) {
 	srand((unsigned) time(0));
 	m_config = config;
 	m_user = CONFIG_STRING(m_config, "service.admin_username");
 	m_password = CONFIG_STRING(m_config, "service.admin_password");
+}
 Server::~Server() {
 	mg_stop(ctx);
 	if (ctx) {
 		mg_stop(ctx);
+	}
+}
 static void *_event_handler(enum mg_event event, struct mg_connection *conn) {
 	const struct mg_request_info *request_info = mg_get_request_info(conn);
 	return static_cast<Server *>(request_info->user_data)->event_handler(event, conn);
+}
 bool Server::start() {
 	const char *options[] = {
 		"listening_ports", boost::lexical_cast<std::string>(CONFIG_INT(m_config, "service.port")).c_str(),
 		"num_threads", "1",
 		NULL
 	};
 	// Setup and start Mongoose
 	if ((ctx = mg_start(&_event_handler, this, options)) == NULL) {
 		return false;
+	}
 	return true;
+}
 bool Server::check_password(const char *user, const char *password) {
 	void *processed = (void *) 0x1;
 	if (event == MG_NEW_REQUEST) {
 		if (!is_authorized(conn, request_info)) {
 			redirect_to(conn, request_info, "/login");
 		} else if (strcmp(request_info->uri, "/authorize") == 0) {
 			authorize(conn, request_info);
 		} else if (strcmp(request_info->uri, "/login") == 0) {
 			serve_login(conn, request_info);
 		} else if (strcmp(request_info->uri, "/") == 0) {
 			serve_root(conn, request_info);
 		} else if (strcmp(request_info->uri, "/onlineusers") == 0) {
 			serve_onlineusers(conn, request_info);
 		} else if (strcmp(request_info->uri, "/cmd") == 0) {
 			serve_cmd(conn, request_info);
 		} else if (strcmp(request_info->uri, "/start") == 0) {
 			serve_start(conn, request_info);
 		} else if (strcmp(request_info->uri, "/stop") == 0) {
 			serve_stop(conn, request_info);
 		} else {
 			// No suitable handler found, mark as not processed. Mongoose will
 			// try to serve the request.
 			processed = NULL;
+		}
 	} else {
+	}
 	else if (event == MG_EVENT_LOG) {
 		// Called by Mongoose's cry()
 		std::cerr << "Mongoose error: " << request_info->log_message << "\n";
+	}
 	else {
 		processed = NULL;
+	}
 	return processed;
+}

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})
 	set_target_properties(libtransport_test PROPERTIES COMPILE_DEFINITIONS LIBTRANSPORT_TEST=1)
 	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)

src/buddy.cpp

➞

Show inline comments

@@ @@ -2,48 +2,50 @@ @@
  * XMPP - libpurple transport
+ *
  * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/buddy.h"
 #include "transport/rostermanager.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/BlockPayload.h"
 #include "transport/usermanager.h"
 #include "transport/discoitemsresponder.h"
 namespace Transport {
 Buddy::Buddy(RosterManager *rosterManager, long id, BuddyFlag flags) : m_id(id), m_flags(flags), m_rosterManager(rosterManager),
 	m_subscription(Ask) {
 // 	m_rosterManager->setBuddy(this);
+}
 Buddy::~Buddy() {
 // 	m_rosterManager->unsetBuddy(this);
+}
 void Buddy::generateJID() {
 	m_jid = Swift::JID();
 	m_jid = Swift::JID(getSafeName(), m_rosterManager->getUser()->getComponent()->getJID().toString(), "bot");
+}
 void Buddy::setID(long id) {
 	m_id = id;
+}
 long Buddy::getID() {
 	return m_id;
+}
 	Swift::StatusShow s;
 	std::string statusMessage;
 	if (!getStatus(s, statusMessage))
 		return Swift::Presence::ref();
 	if (m_jid.getNode().empty()) {
 		generateJID();
+	}
 	Swift::Presence::ref presence = Swift::Presence::create();
  	presence->setFrom(m_jid);
 	presence->setTo(m_rosterManager->getUser()->getJID().toBare());
 	presence->setType(Swift::Presence::Available);
 	if (!statusMessage.empty())
 		presence->setStatus(statusMessage);
 	if (s.getType() == Swift::StatusShow::None)
 		presence->setType(Swift::Presence::Unavailable);
 	presence->setShow(s.getType());
 	if (presence->getType() != Swift::Presence::Unavailable) {
 		// caps
-		presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::CapsInfo(m_rosterManager->getUser()->getComponent()->getBuddyCapsInfo())));
+		presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::CapsInfo(m_rosterManager->getUser()->getUserManager()->getDiscoResponder()->getBuddyCapsInfo())));
 // 		if (features & 0/*TRANSPORT_FEATURE_AVATARS*/) {
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::VCardUpdate (getIconHash())));
 // 		}
 		if (isBlocked()) {
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Transport::BlockPayload ()));
+		}
+	}
 // 	if (only_new) {
 // 		if (m_lastPresence)
 // 			m_lastPresence->setTo(Swift::JID(""));
 // 		if (m_lastPresence == presence) {
 // 			return Swift::Presence::ref();
 // 		}
 // 		m_lastPresence = presence;
 // 	}
 	return presence;
+}
 std::string Buddy::getSafeName() {
 	if (m_jid.isValid()) {
 		return m_jid.getNode();

src/config.cpp

➞

Show inline comments

 		("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), "")
 		("service.max_room_list_size", value<int>()->default_value(100), "")
 		("service.jid_escaping", value<bool>()->default_value(true), "")
 		("service.vip_only", value<bool>()->default_value(false), "")
 		("service.vip_message", value<std::string>()->default_value(""), "")
 		("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.")
 		("database.vip_statement", 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.")
+	;
 	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];

src/conversation.cpp

➞

Show inline comments

@@ @@ -12,48 +12,49 @@ @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include <iostream>
 #include "transport/conversation.h"
 #include "transport/conversationmanager.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/buddy.h"
 #include "transport/rostermanager.h"
 namespace Transport {
 Conversation::Conversation(ConversationManager *conversationManager, const std::string &legacyName, bool isMUC) : m_conversationManager(conversationManager) {
 	m_legacyName = legacyName;
 // 	m_conversationManager->addConversation(this);
 	m_muc = isMUC;
 	m_jid = m_conversationManager->getUser()->getJID().toBare();
 	m_sentInitialPresence = false;
+}
 Conversation::~Conversation() {
+}
 void Conversation::destroyRoom() {
 	if (m_muc) {
 		Swift::Presence::ref presence = Swift::Presence::create();
 		std::string legacyName = m_legacyName;
 		if (legacyName.find_last_of("@") != std::string::npos) {
 			legacyName.replace(legacyName.find_last_of("@"), 1, "%"); // OK
+		}
 		presence->setFrom(Swift::JID(legacyName, m_conversationManager->getComponent()->getJID().toBare(), m_nickname));
 		presence->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;
@@ @@ -70,143 +71,164 @@ void Conversation::setRoom(const std::string &room) { @@
+}
 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()));
 				std::string name = m_legacyName;
 				if (CONFIG_BOOL_DEFAULTED(m_conversationManager->getComponent()->getConfig(), "service.jid_escaping", true)) {
 					name = Swift::JID::getEscapedNode(m_legacyName);
+				}
 				else {
 					if (name.find_last_of("@") != std::string::npos) {
 						name.replace(name.find_last_of("@"), 1, "%");
+					}
+				}
 				message->setFrom(Swift::JID(name, m_conversationManager->getComponent()->getJID().toBare(), "bot"));
+			}
+		}
 		// PM message
 		else {
 			if (m_room.empty()) {
 				message->setFrom(Swift::JID(n, m_conversationManager->getComponent()->getJID().toBare(), "user"));
+			}
 			else {
 				message->setFrom(Swift::JID(m_room, m_conversationManager->getComponent()->getJID().toBare(), n));
+			}
+		}
 		m_conversationManager->getComponent()->getStanzaChannel()->sendMessage(message);
+	}
 	else {
 		std::string legacyName = m_legacyName;
 		if (legacyName.find_last_of("@") != std::string::npos) {
 			legacyName.replace(legacyName.find_last_of("@"), 1, "%"); // OK
+		}
 		std::string n = nickname;
 		if (n.empty()) {
 			n = " ";
+		}
 		BOOST_FOREACH(const Swift::JID &jid, m_jids) {
 			message->setTo(jid);
 			message->setFrom(Swift::JID(legacyName, m_conversationManager->getComponent()->getJID().toBare(), n));
 			// Subject has to be sent after our own presence (the one with code 110)
 			if (!message->getSubject().empty() && m_sentInitialPresence == false) {
 				m_subject = message;
 				return;
+			}
 			m_conversationManager->getComponent()->getStanzaChannel()->sendMessage(message);
+		}
+	}
+}
 void Conversation::sendParticipants(const Swift::JID &to) {
 	for (std::map<std::string, Participant>::iterator it = m_participants.begin(); it != m_participants.end(); it++) {
 		Swift::Presence::ref presence = generatePresence(it->first, it->second.flag, it->second.status, it->second.statusMessage, "");
 		presence->setTo(to);
 		m_conversationManager->getComponent()->getStanzaChannel()->sendPresence(presence);
+	}
+}
 Swift::Presence::ref Conversation::generatePresence(const std::string &nick, int flag, int status, const std::string &statusMessage, const std::string &newname) {
 	std::string nickname = nick;
 	Swift::Presence::ref presence = Swift::Presence::create();
 	std::string legacyName = m_legacyName;
 	if (m_muc) {
 		if (legacyName.find_last_of("@") != std::string::npos) {
 			legacyName.replace(legacyName.find_last_of("@"), 1, "%"); // OK
+		}
+	}
 	presence->setFrom(Swift::JID(legacyName, m_conversationManager->getComponent()->getJID().toBare(), nickname));
 	presence->setType(Swift::Presence::Available);
 	if (!statusMessage.empty())
 		presence->setStatus(statusMessage);
 	Swift::StatusShow s((Swift::StatusShow::Type) status);
 	if (s.getType() == Swift::StatusShow::None) {
 		presence->setType(Swift::Presence::Unavailable);
+	}
 	presence->setShow(s.getType());
 	Swift::MUCUserPayload *p = new Swift::MUCUserPayload ();
 	if (m_nickname == nickname) {
 		Swift::MUCUserPayload::StatusCode c;
 		c.code = 110;
 		p->addStatusCode(c);
 		m_sentInitialPresence = true;
+	}
 	Swift::MUCItem item;
 	item.affiliation = Swift::MUCOccupant::Member;
 	item.role = Swift::MUCOccupant::Participant;
 	if (flag & Moderator) {
 		item.affiliation = Swift::MUCOccupant::Admin;
 		item.role = Swift::MUCOccupant::Moderator;
+	}
 	if (!newname.empty()) {
 		item.nick = newname;
 		Swift::MUCUserPayload::StatusCode c;
 		c.code = 303;
 		p->addStatusCode(c);
 		presence->setType(Swift::Presence::Unavailable);
+	}
 	p->addItem(item);
 	presence->addPayload(boost::shared_ptr<Swift::Payload>(p));
 	return presence;
+}
 void Conversation::handleParticipantChanged(const std::string &nick, int flag, int status, const std::string &statusMessage, const std::string &newname) {
 	Swift::Presence::ref presence = generatePresence(nick, flag, status, statusMessage, newname);
 	if (presence->getType() == Swift::Presence::Unavailable) {
 		m_participants.erase(nick);
+	}
 	else {
 		Participant p;
 		p.flag = flag;
 		p.status = status;
 		p.statusMessage = statusMessage;
 		m_participants[nick] = p;
+	}
 	BOOST_FOREACH(const Swift::JID &jid, m_jids) {
 		presence->setTo(jid);
 		m_conversationManager->getComponent()->getStanzaChannel()->sendPresence(presence);
+	}
 	if (!newname.empty()) {
 		handleParticipantChanged(newname, flag, status, statusMessage);
+	}
 	if (m_sentInitialPresence && m_subject) {
 		m_conversationManager->getComponent()->getStanzaChannel()->sendMessage(m_subject);
 		m_subject.reset();
+	}
+}
+}

src/conversationmanager.cpp

➞

Show inline comments

@@ @@ -26,48 +26,57 @@ @@
 #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());
+	}
+}
 void ConversationManager::deleteAllConversations() {
 	while(!m_convs.empty()) {
 		LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Removing conversation " << (*m_convs.begin()).first);
 		(*m_convs.begin()).second->destroyRoom();
 		delete (*m_convs.begin()).second;
 		m_convs.erase(m_convs.begin());
+	}
+}
 Conversation *ConversationManager::getConversation(const std::string &name) {
 	if (m_convs.find(name) != m_convs.end())
 		return m_convs[name];
 	if (name.find("/") == std::string::npos) {
 		return NULL;
+	}
 	// handle PMs
 	std::string room = name.substr(0, name.find("/"));
 	std::string nick = name.substr(name.find("/") + 1);
 	if (getConversation(room) == NULL) {
 		return NULL;
+	}
 	return getConversation(nick);
+}
 void ConversationManager::addConversation(Conversation *conv) {
 	m_convs[conv->getLegacyName()] = conv;
 	LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Adding conversation " << conv->getLegacyName());
+}

src/discoinforesponder.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 "discoinforesponder.h"
 #include <iostream>
 #include <boost/bind.hpp>
 #include <boost/algorithm/string.hpp>
 #include "Swiften/Disco/DiscoInfoResponder.h"
 #include "Swiften/Queries/IQRouter.h"
 #include "Swiften/Elements/DiscoInfo.h"
 #include "Swiften/Swiften.h"
 #include "transport/config.h"
 #include "transport/logging.h"
 using namespace Swift;
 using namespace boost;
 DEFINE_LOGGER(logger, "DiscoInfoResponder");
 namespace Transport {
 DiscoInfoResponder::DiscoInfoResponder(Swift::IQRouter *router, Config *config) : Swift::GetResponder<DiscoInfo>(router) {
 	m_config = config;
 	m_transportInfo.addIdentity(DiscoInfo::Identity(CONFIG_STRING(m_config, "identity.name"),
 													CONFIG_STRING(m_config, "identity.category"),
 													CONFIG_STRING(m_config, "identity.type")));
 	m_buddyInfo.addIdentity(DiscoInfo::Identity(CONFIG_STRING(m_config, "identity.name"), "client", "pc"));
 	std::list<std::string> features;
 	features.push_back("jabber:iq:register");
 	features.push_back("jabber:iq:gateway");
 	features.push_back("jabber:iq:private");
 	features.push_back("http://jabber.org/protocol/disco#info");
 	features.push_back("http://jabber.org/protocol/commands");
 	setTransportFeatures(features);
 	features.clear();
 	features.push_back("http://jabber.org/protocol/disco#items");
 	features.push_back("http://jabber.org/protocol/disco#info");
 	features.push_back("http://jabber.org/protocol/chatstates");
 	features.push_back("http://jabber.org/protocol/xhtml-im");
 	setBuddyFeatures(features);
+}
 DiscoInfoResponder::~DiscoInfoResponder() {
+}
 void DiscoInfoResponder::setTransportFeatures(std::list<std::string> &features) {
 	for (std::list<std::string>::iterator it = features.begin(); it != features.end(); it++) {
 		if (!m_transportInfo.hasFeature(*it)) {
 			m_transportInfo.addFeature(*it);
+		}
+	}
+}
 void DiscoInfoResponder::setBuddyFeatures(std::list<std::string> &f) {
 	for (std::list<std::string>::iterator it = f.begin(); it != f.end(); it++) {
 		if (!m_buddyInfo.hasFeature(*it)) {
 			m_buddyInfo.addFeature(*it);
+		}
+	}
 	CapsInfoGenerator caps("spectrum");
 	m_capsInfo = caps.generateCapsInfo(m_buddyInfo);
 	onBuddyCapsInfoChanged(m_capsInfo);
+}
 bool DiscoInfoResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::DiscoInfo> info) {
 	if (!info->getNode().empty()) {
 		sendError(from, id, ErrorPayload::ItemNotFound, ErrorPayload::Cancel);
 		return true;
+	}
 void DiscoInfoResponder::addRoom(const std::string &jid, const std::string &name) {
 	std::string j = jid;
 	boost::algorithm::to_lower(j);
 	m_rooms[j] = name;
+}
 void DiscoInfoResponder::clearRooms() {
 	m_rooms.clear();
+}
 void DiscoInfoResponder::addAdHocCommand(const std::string &node, const std::string &name) {
 	m_commands[node] = node;
+}
 	// presence for transport
 bool DiscoInfoResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::DiscoInfo> info) {
 	// disco#info for transport
 	if (to.getNode().empty()) {
 		boost::shared_ptr<DiscoInfo> res(new DiscoInfo(m_transportInfo));
 		// Adhoc command
 		if (m_commands.find(info->getNode()) != m_commands.end()) {
 			boost::shared_ptr<DiscoInfo> res(new DiscoInfo());
 			res->addFeature("http://jabber.org/protocol/commands");
 			res->addFeature("jabber:x:data");
 			res->addIdentity(DiscoInfo::Identity(m_commands[info->getNode()], "automation", "command-node"));
 			res->setNode(info->getNode());
 			sendResponse(from, to, id, res);
+		}
 		else {
 			if (!info->getNode().empty()) {
 				sendError(from, id, ErrorPayload::ItemNotFound, ErrorPayload::Cancel);
 				return true;
+			}
 			boost::shared_ptr<DiscoInfo> res(new DiscoInfo(m_transportInfo));
 			res->setNode(info->getNode());
 			sendResponse(from, id, res);
+		}
+	}
 	// disco#info for room
 	else if (m_rooms.find(to.toBare().toString()) != m_rooms.end()) {
 		boost::shared_ptr<DiscoInfo> res(new DiscoInfo());
 		res->addIdentity(DiscoInfo::Identity(m_rooms[to.toBare().toString()], "conference", "text"));
 		res->setNode(info->getNode());
 		sendResponse(from, id, res);
+		sendResponse(from, to, id, res);
+	}
-	// presence for buddy
+	// disco#info for buddy
 	else {
 		boost::shared_ptr<DiscoInfo> res(new DiscoInfo(m_buddyInfo));
 		res->setNode(info->getNode());
 		sendResponse(from, to, id, res);
+	}
 	return true;
+}
+}

src/discoinforesponder.h

➞

Show inline comments

@@ @@ -17,40 +17,47 @@ @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <vector>
 #include "Swiften/Swiften.h"
 #include "Swiften/Queries/GetResponder.h"
 #include "Swiften/Elements/DiscoInfo.h"
 #include "Swiften/Elements/CapsInfo.h"
 namespace Transport {
 class Config;
 class DiscoInfoResponder : public Swift::GetResponder<Swift::DiscoInfo> {
 	public:
 		DiscoInfoResponder(Swift::IQRouter *router, Config *config);
 		~DiscoInfoResponder();
 		void setTransportFeatures(std::list<std::string> &features);
 		void setBuddyFeatures(std::list<std::string> &features);
 		void addRoom(const std::string &jid, const std::string &name);
 		void clearRooms();
 		void addAdHocCommand(const std::string &node, const std::string &name);
 		boost::signal<void (const Swift::CapsInfo &capsInfo)> onBuddyCapsInfoChanged;
 		Swift::CapsInfo &getBuddyCapsInfo() {
 				return m_capsInfo;
+		}
 	private:
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::DiscoInfo> payload);
 		Swift::DiscoInfo m_transportInfo;
 		Swift::DiscoInfo m_buddyInfo;
 		Config *m_config;
 		Swift::CapsInfo m_capsInfo;
 		std::map<std::string, std::string> m_rooms;
 		std::map<std::string, std::string> m_commands;
 };
+}
@@ \ No newline at end of file @@

src/discoitemsresponder.cpp

➞

Show inline comments

@@ @@ -5,62 +5,85 @@ @@
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/discoitemsresponder.h"
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "Swiften/Swiften.h"
 #include "transport/transport.h"
 #include "transport/logging.h"
 #include "discoinforesponder.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
 DEFINE_LOGGER(logger, "DiscoItemsResponder");
 DiscoItemsResponder::DiscoItemsResponder(Component *component) : Swift::GetResponder<DiscoItems>(component->getIQRouter()) {
 	m_component = component;
 	m_commands = boost::shared_ptr<DiscoItems>(new DiscoItems());
 	m_commands->setNode("http://jabber.org/protocol/commands");
 	m_rooms = boost::shared_ptr<DiscoItems>(new DiscoItems());
 	m_discoInfoResponder = new DiscoInfoResponder(component->getIQRouter(), component->getConfig());
 	m_discoInfoResponder->start();
+}
 DiscoItemsResponder::~DiscoItemsResponder() {
+	>
+	delete m_discoInfoResponder;
+}
 void DiscoItemsResponder::addAdHocCommand(const std::string &node, const std::string &name) {
 	m_commands->addItem(DiscoItems::Item(name, m_component->getJID(), node));
 	m_discoInfoResponder->addAdHocCommand(node, name);
+}
 void DiscoItemsResponder::addRoom(const std::string &node, const std::string &name) {
 	if (m_rooms->getItems().size() > CONFIG_INT(m_component->getConfig(), "service.max_room_list_size")) {
 		return;
+	}
 	m_rooms->addItem(DiscoItems::Item(name, node));
 	m_discoInfoResponder->addRoom(node, name);
+}
 void DiscoItemsResponder::clearRooms() {
 	m_rooms = boost::shared_ptr<DiscoItems>(new DiscoItems());
 	m_discoInfoResponder->clearRooms();
+}
 Swift::CapsInfo &DiscoItemsResponder::getBuddyCapsInfo() {
 	return m_discoInfoResponder->getBuddyCapsInfo();
+}
 bool DiscoItemsResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::DiscoItems> info) {
 	LOG4CXX_INFO(logger, "get request received with node " << info->getNode());
 	if (info->getNode() == "http://jabber.org/protocol/commands") {
 		sendResponse(from, id, m_commands);
+	}
 	else if (to.getNode().empty()) {
-		sendResponse(from, id, boost::shared_ptr<DiscoItems>(new DiscoItems()));
+		sendResponse(from, id, m_rooms);
+	}
 	else {
 		sendResponse(from, id, boost::shared_ptr<DiscoItems>(new DiscoItems()));
+	}
 	return true;
+}
+}

src/logging.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/logging.h"
 #include "transport/config.h"
 #include "transport/util.h"
 #include <boost/foreach.hpp>
 #include <iostream>
 #include <iterator>
 #include <algorithm>
 #include <boost/filesystem.hpp>
 #include <boost/algorithm/string.hpp>
 #ifndef WIN32
 #include "sys/signal.h"
 #include <sys/stat.h>
 #include <pwd.h>
 #include <grp.h>
 #include <sys/resource.h>
 #include "libgen.h"
 #else
 #include <windows.h>
 #include <process.h>
 #define getpid _getpid
 #endif
 using namespace boost::filesystem;
 namespace Transport {
 namespace Logging {
 #ifdef WITH_LOG4CXX
 using namespace log4cxx;
 static LoggerPtr root;
 class intercept_stream : public std::streambuf{
 public:
 		if (!istream) {
 			return;
+		}
 		p.load(istream);
 		LogString pid, jid;
 		log4cxx::helpers::Transcoder::decode(boost::lexical_cast<std::string>(getpid()), pid);
 		log4cxx::helpers::Transcoder::decode(CONFIG_STRING(config, "service.jid"), jid);
 #ifdef _MSC_VER
 		p.setProperty(L"pid", pid);
 		p.setProperty(L"jid", jid);
 #else
 		p.setProperty("pid", pid);
 		p.setProperty("jid", jid);
 #endif
 		std::string dir;
 		BOOST_FOREACH(const log4cxx::LogString &prop, p.propertyNames()) {
 			if (boost::ends_with(prop, ".File")) {
 				log4cxx::helpers::Transcoder::encode(p.get(prop), dir);
 				boost::replace_all(dir, "${jid}", jid);
 				break;
+			}
+		}
+		mode_t old_cmask;
 		if (!dir.empty()) {
 			// create directories
 #ifndef WIN32
 			old_cmask = umask(0007);
 #endif
 			try {
 				boost::filesystem::create_directories(
 					boost::filesystem::path(dir).parent_path().string()
 				);
 				Transport::Util::createDirectories(config, boost::filesystem::path(dir).parent_path());
+			}
 			catch (...) {
 				std::cerr << "Can't create logging directory directory " << boost::filesystem::path(dir).parent_path().string() << ".\n";
 			catch (const boost::filesystem::filesystem_error &e) {
 				std::cerr << "Can't create logging directory directory " << boost::filesystem::path(dir).parent_path().string() << ": " << e.what() << ".\n";
+			}
+		}
 #ifndef WIN32
 			if (!CONFIG_STRING(config, "service.group").empty() && !CONFIG_STRING(config, "service.user").empty()) {
 				struct group *gr;
 				if ((gr = getgrnam(CONFIG_STRING(config, "service.group").c_str())) == NULL) {
 					std::cerr << "Invalid service.group name " << CONFIG_STRING(config, "service.group") << "\n";
+				}
 				struct passwd *pw;
 				if ((pw = getpwnam(CONFIG_STRING(config, "service.user").c_str())) == NULL) {
 					std::cerr << "Invalid service.user name " << CONFIG_STRING(config, "service.user") << "\n";
+				}
 				chown(dir.c_str(), pw->pw_uid, gr->gr_gid);
+			}
 		log4cxx::PropertyConfigurator::configure(p);
 #endif
 		// Change owner of main log file
 #ifndef WIN32
 	if (!CONFIG_STRING(config, "service.group").empty() && !CONFIG_STRING(config, "service.user").empty()) {
 		struct group *gr;
 		if ((gr = getgrnam(CONFIG_STRING(config, "service.group").c_str())) == NULL) {
 			std::cerr << "Invalid service.group name " << CONFIG_STRING(config, "service.group") << "\n";
+		}
 		struct passwd *pw;
 		if ((pw = getpwnam(CONFIG_STRING(config, "service.user").c_str())) == NULL) {
 			std::cerr << "Invalid service.user name " << CONFIG_STRING(config, "service.user") << "\n";
+		}
 		chown(dir.c_str(), pw->pw_uid, gr->gr_gid);
+	}
 #endif
 		log4cxx::PropertyConfigurator::configure(p);
 #ifndef WIN32
 		if (!dir.empty()) {
 			umask(old_cmask);
+		}
 #endif
+	}
+}
 void initBackendLogging(Config *config) {
 	initLogging(config, "logging.backend_config");
 	redirect_stderr();
+}
 void initMainLogging(Config *config) {
 	initLogging(config, "logging.config");
+}
 void redirect_stderr() {
 	 intercepter_cerr = new intercept_stream(std::cerr, "cerr");
 	 intercepter_cout = new intercept_stream(std::cout, "cout");
+}
 void shutdownLogging() {
 	delete intercepter_cerr;
 	delete intercepter_cout;
 	log4cxx::LogManager::shutdown();
+}

src/mysqlbackend.cpp

➞

Show inline comments

@@ @@ -400,95 +400,112 @@ bool MySQLBackend::createDatabase() { @@
 			") ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;");
 		exec("CREATE TABLE IF NOT EXISTS `" + m_prefix + "db_version` ("
 				"`ver` int(10) unsigned NOT NULL default '1',"
 				"UNIQUE KEY `ver` (`ver`)"
 			") ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;");
 		exec("INSERT IGNORE INTO db_version (ver) VALUES ('2');");
+	}
 	return true;
+}
 bool MySQLBackend::exec(const std::string &query) {
 	if (mysql_query(&m_conn, query.c_str())) {
 		LOG4CXX_ERROR(logger, query << " " << mysql_error(&m_conn));
 		return false;
+	}
 	return true;
+}
 void MySQLBackend::setUser(const UserInfo &user) {
 	std::string encrypted = user.password;
 	if (!CONFIG_STRING(m_config, "database.encryption_key").empty()) {
-		encrypted = Util::encryptPassword(encrypted, CONFIG_STRING(m_config, "database.encryption_key"));
+		encrypted = StorageBackend::encryptPassword(encrypted, CONFIG_STRING(m_config, "database.encryption_key"));
+	}
 	*m_setUser << user.jid << user.uin << encrypted << user.language << user.encoding << user.vip << user.uin << encrypted;
 	EXEC(m_setUser, setUser(user));
+}
 bool MySQLBackend::getUser(const std::string &barejid, UserInfo &user) {
 	*m_getUser << barejid;
 	EXEC(m_getUser, getUser(barejid, user));
 	if (!exec_ok)
 		return false;
 	int ret = false;
 	while (m_getUser->fetch() == 0) {
 		ret = true;
 		*m_getUser >> user.id >> user.jid >> user.uin >> user.password >> user.encoding >> user.language >> user.vip;
 		if (!CONFIG_STRING(m_config, "database.encryption_key").empty()) {
 			user.password = Util::decryptPassword(user.password, CONFIG_STRING(m_config, "database.encryption_key"));
 			user.password = StorageBackend::decryptPassword(user.password, CONFIG_STRING(m_config, "database.encryption_key"));
+		}
+	}
 	if (!CONFIG_STRING(m_config, "database.vip_statement").empty()) {
 		std::string query = CONFIG_STRING(m_config, "database.vip_statement");
 		boost::replace_all(query, "$barejid", barejid);
 		LOG4CXX_INFO(logger, "Executing '" << query << "' to find out if user " << barejid << " is VIP");
 		if (exec(query)) {
 			MYSQL_RES *result = mysql_store_result(&m_conn);
 			if (result && mysql_num_rows(result) > 0) {
 				LOG4CXX_INFO(logger, "User " << barejid << " is VIP");
 				user.vip = 1;
+			}
 			else {
 				LOG4CXX_INFO(logger, "User " << barejid << " is not VIP");
 				user.vip = 0;
+			}
+		}
+	}
 	return ret;
+}
 void MySQLBackend::setUserOnline(long id, bool online) {
 	*m_setUserOnline << online << id;
 	EXEC(m_setUserOnline, setUserOnline(id, online));
+}
 bool MySQLBackend::getOnlineUsers(std::vector<std::string> &users) {
 	EXEC(m_getOnlineUsers, getOnlineUsers(users));
 	if (!exec_ok)
 		return false;
 	std::string jid;
 	while (m_getOnlineUsers->fetch() == 0) {
 		*m_getOnlineUsers >> jid;
 		users.push_back(jid);
+	}
 	return true;
+}
 long MySQLBackend::addBuddy(long userId, const BuddyInfo &buddyInfo) {
 // 	"INSERT INTO " + m_prefix + "buddies (user_id, uin, subscription, groups, nickname, flags) VALUES (?, ?, ?, ?, ?, ?)"
-	std::string groups = Util::serializeGroups(buddyInfo.groups);
+	std::string groups = StorageBackend::serializeGroups(buddyInfo.groups);
 	*m_addBuddy << userId << buddyInfo.legacyName << buddyInfo.subscription;
 	*m_addBuddy << groups;
 	*m_addBuddy << buddyInfo.alias << buddyInfo.flags;
 	EXEC(m_addBuddy, addBuddy(userId, buddyInfo));
 	long id = (long) mysql_insert_id(&m_conn);
 // 	INSERT OR REPLACE INTO " + m_prefix + "buddies_settings (user_id, buddy_id, var, type, value) VALUES (?, ?, ?, ?, ?)
 	if (buddyInfo.settings.find("icon_hash") != buddyInfo.settings.end() && !buddyInfo.settings.find("icon_hash")->second.s.empty()) {
 		*m_updateBuddySetting << userId << id << buddyInfo.settings.find("icon_hash")->first << (int) TYPE_STRING << buddyInfo.settings.find("icon_hash")->second.s << buddyInfo.settings.find("icon_hash")->second.s;
 		EXEC(m_updateBuddySetting, addBuddy(userId, buddyInfo));
+	}
 	return id;
+}
 void MySQLBackend::updateBuddySetting(long userId, long buddyId, const std::string &variable, int type, const std::string &value) {
 	*m_updateBuddySetting << userId << buddyId << variable << type << value << value;
 	EXEC(m_updateBuddySetting, updateBuddySetting(userId, buddyId, variable, type, value));
+}
 void MySQLBackend::getBuddySetting(long userId, long buddyId, const std::string &variable, int &type, std::string &value) {
 // 	"SELECT type, value FROM " + m_prefix + "users_settings WHERE user_id=? AND var=?"
 	EXEC(m_getBuddySetting, getBuddySetting(userId, buddyId, variable, type, value));
 	if (m_getBuddySetting->fetch() == 0) {
 		*m_getBuddySetting >> type >> value;
+	}
 	while (m_getBuddySetting->fetch() == 0) {
+	}
+}
 void MySQLBackend::removeBuddy(long id) {
 	*m_removeBuddy << (int) id;
 	EXEC(m_removeBuddy, removeBuddy(id));
 	if (!exec_ok)
 		return;
 	*m_removeBuddySettings << (int) id;
 	EXEC(m_removeBuddySettings, removeBuddy(id));
 	if (!exec_ok)
 		return;
+}
 void MySQLBackend::updateBuddy(long userId, const BuddyInfo &buddyInfo) {
 // 	"UPDATE " + m_prefix + "buddies SET groups=?, nickname=?, flags=?, subscription=? WHERE user_id=? AND uin=?"
-	std::string groups = Util::serializeGroups(buddyInfo.groups);
+	std::string groups = StorageBackend::serializeGroups(buddyInfo.groups);
 	*m_updateBuddy << groups;
 	*m_updateBuddy << buddyInfo.alias << buddyInfo.flags << buddyInfo.subscription;
 	*m_updateBuddy << userId << buddyInfo.legacyName;
 	EXEC(m_updateBuddy, updateBuddy(userId, buddyInfo));
+}
 bool MySQLBackend::getBuddies(long id, std::list<BuddyInfo> &roster) {
 //	SELECT id, uin, subscription, nickname, groups, flags FROM " + m_prefix + "buddies WHERE user_id=? ORDER BY id ASC
 	*m_getBuddies << id;
 // 	"SELECT buddy_id, type, var, value FROM " + m_prefix + "buddies_settings WHERE user_id=? ORDER BY buddy_id ASC"
 	*m_getBuddiesSettings << id;
 	SettingVariableInfo var;
 	long buddy_id = -1;
 	std::string key;
 	EXEC(m_getBuddies, getBuddies(id, roster));
 	if (!exec_ok)
 		return false;
 	while (m_getBuddies->fetch() == 0) {
 		BuddyInfo b;
 		std::string group;
 		*m_getBuddies >> b.id >> b.legacyName >> b.subscription >> b.alias >> group >> b.flags;
 		if (!group.empty()) {
-			b.groups = Util::deserializeGroups(group);
+			b.groups = StorageBackend::deserializeGroups(group);
+		}
 		roster.push_back(b);
+	}
 	EXEC(m_getBuddiesSettings, getBuddies(id, roster));
 	if (!exec_ok)
 		return false;
 	BOOST_FOREACH(BuddyInfo &b, roster) {
 		if (buddy_id == b.id) {
 // 			std::cout << "Adding buddy info setting " << key << "\n";
 			b.settings[key] = var;
 			buddy_id = -1;
+		}
 		while(buddy_id == -1 && m_getBuddiesSettings->fetch() == 0) {
 			std::string val;
 			*m_getBuddiesSettings >> buddy_id >> var.type >> key >> val;
 			switch (var.type) {
 				case TYPE_BOOLEAN:
 					var.b = atoi(val.c_str());
 					break;

src/networkpluginserver.cpp

➞

Show inline comments

@@ @@ -23,98 +23,99 @@ @@
 #include "transport/transport.h"
 #include "transport/storagebackend.h"
 #include "transport/rostermanager.h"
 #include "transport/usermanager.h"
 #include "transport/conversationmanager.h"
 #include "transport/localbuddy.h"
 #include "transport/config.h"
 #include "transport/conversation.h"
 #include "transport/vcardresponder.h"
 #include "transport/rosterresponder.h"
 #include "transport/memoryreadbytestream.h"
 #include "transport/logging.h"
 #include "transport/admininterface.h"
 #include "blockresponder.h"
 #include "Swiften/Swiften.h"
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Elements/StreamError.h"
 #include "Swiften/Network/BoostConnectionServer.h"
 #include "Swiften/Elements/AttentionPayload.h"
 #include "Swiften/Elements/XHTMLIMPayload.h"
 #include "Swiften/Elements/InvisiblePayload.h"
 #include "Swiften/Elements/SpectrumErrorPayload.h"
 #include "transport/protocol.pb.h"
 #include "transport/util.h"
 #include "transport/discoitemsresponder.h"
 #include "utf8.h"
 #include <Swiften/FileTransfer/ReadBytestream.h>
 #include <Swiften/Elements/StreamInitiationFileInfo.h>
 #ifdef _WIN32
 #include "windows.h"
 #include <stdint.h>
 #else
 #include "sys/wait.h"
 #include "sys/signal.h"
 #include <sys/types.h>
 #include <signal.h>
 #include "popt.h"
 #endif
 using namespace Transport::Util;
 namespace Transport {
 static unsigned long backend_id;
 static unsigned long bytestream_id;
 DEFINE_LOGGER(logger, "NetworkPluginServer");
 class NetworkConversation : public Conversation {
 	public:
 		NetworkConversation(ConversationManager *conversationManager, const std::string &legacyName, bool muc = false) : Conversation(conversationManager, legacyName, muc) {
+		}
 		// Called when there's new message to legacy network from XMPP network
 		void sendMessage(boost::shared_ptr<Swift::Message> &message) {
 			onMessageToSend(this, message);
+		}
 		boost::signal<void (NetworkConversation *, boost::shared_ptr<Swift::Message> &)> onMessageToSend;
 };
 class NetworkFactory : public Factory {
 	public:
 		NetworkFactory(NetworkPluginServer *nps) {
 			m_nps = nps;
+		}
 		virtual ~NetworkFactory() {}
 		// Creates new conversation (NetworkConversation in this case)
 		Conversation *createConversation(ConversationManager *conversationManager, const std::string &legacyName) {
 			NetworkConversation *nc = new NetworkConversation(conversationManager, legacyName);
 		Conversation *createConversation(ConversationManager *conversationManager, const std::string &legacyName, bool isMuc) {
 			NetworkConversation *nc = new NetworkConversation(conversationManager, legacyName, isMuc);
 			nc->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, m_nps, _1, _2));
 			return nc;
+		}
 		// Creates new LocalBuddy
 		Buddy *createBuddy(RosterManager *rosterManager, const BuddyInfo &buddyInfo) {
 			LocalBuddy *buddy = new LocalBuddy(rosterManager, buddyInfo.id, buddyInfo.legacyName, buddyInfo.alias, buddyInfo.groups, (BuddyFlag) buddyInfo.flags);
 			if (!buddy->isValid()) {
 				delete buddy;
 				return NULL;
+			}
 			if (buddyInfo.subscription == "both") {
 				buddy->setSubscription(Buddy::Both);
+			}
 			else {
 				buddy->setSubscription(Buddy::Ask);
+			}
 			if (buddyInfo.settings.find("icon_hash") != buddyInfo.settings.end())
 				buddy->setIconHash(buddyInfo.settings.find("icon_hash")->second.s);
 			return buddy;
+		}
 	private:
 		NetworkPluginServer *m_nps;
 		&si,
 		&pi
+		)
 	)  {
 		LOG4CXX_ERROR(logger, "Could not start process");
+	}
 	return 0;
 #else
 	// Add host and port.
 	finalExePath += std::string(" --host ") + host + " --port " + port + " " + cmdlineArgs;
 	LOG4CXX_INFO(logger, "Starting new backend " << finalExePath);
 	// Create array of char * from string using -lpopt library
 	char *p = (char *) malloc(finalExePath.size() + 1);
 	strcpy(p, finalExePath.c_str());
 	int argc;
 	char **argv;
 	poptParseArgvString(p, &argc, (const char ***) &argv);
 	// fork and exec
 	pid_t pid = fork();
 	if ( pid == 0 ) {
 		setsid();
 		// close all files
 		int maxfd=sysconf(_SC_OPEN_MAX);
 		for(int fd=3; fd<maxfd; fd++) {
 			close(fd);
+		}
 		// child process
 		errno = 0;
 		int ret = execv(argv[0], argv);
 		if (ret == -1) {
 			exit(errno);
+		}
 		exit(0);
 	} else if ( pid < 0 ) {
 		LOG4CXX_ERROR(logger, "Fork failed");
+	}
 	free(p);
 	return (unsigned long) pid;
 #endif
+}
 #ifndef _WIN32
 static void SigCatcher(int n) {
 	pid_t result;
 	int status;
 	// Read exit code from all children to not have zombies arround
 	// WARNING: Do not put LOG4CXX_ here, because it can lead to deadlock
 	while ((result = waitpid(-1, &status, WNOHANG)) > 0) {
 		if (result != 0) {
 			if (WIFEXITED(status)) {
 				if (WEXITSTATUS(status) != 0) {
 // 					LOG4CXX_ERROR(logger, "Backend can not be started, exit_code=" << WEXITSTATUS(status));
+				}
+			}
 			else {
 // 				LOG4CXX_ERROR(logger, "Backend can not be started");
+			}
+		}
+	}
+}
 #endif
 static void handleBuddyPayload(LocalBuddy *buddy, const pbnetwork::Buddy &payload) {
 	// Set alias only if it's not empty. Backends are allowed to send empty alias if it has
 	// not changed.
 	if (!payload.alias().empty()) {
 		buddy->setAlias(payload.alias());
+	}
 	// Change groups if it's not empty. The same as above...
 	std::vector<std::string> groups;
 	for (int i = 0; i < payload.group_size(); i++) {
 		groups.push_back(payload.group(i));
 		std::string group = payload.group(i);
 		utf8::replace_invalid(payload.group(i).begin(), payload.group(i).end(), group.begin(), '_');
 		groups.push_back(group);
+	}
 	if (!groups.empty()) {
 		buddy->setGroups(groups);
+	}
 	buddy->setStatus(Swift::StatusShow((Swift::StatusShow::Type) payload.status()), payload.statusmessage());
 	buddy->setIconHash(payload.iconhash());
 	buddy->setBlocked(payload.blocked());
+}
 NetworkPluginServer::NetworkPluginServer(Component *component, Config *config, UserManager *userManager, FileTransferManager *ftManager) {
+NetworkPluginServer::NetworkPluginServer(Component *component, Config *config, UserManager *userManager, FileTransferManager *ftManager, DiscoItemsResponder *discoItemsResponder) {
 	m_ftManager = ftManager;
 	m_userManager = userManager;
 	m_config = config;
 	m_component = component;
 	m_isNextLongRun = false;
 	m_adminInterface = NULL;
 	m_startingBackend = false;
 	m_discoItemsResponder = discoItemsResponder;
 	m_component->m_factory = new NetworkFactory(this);
 	m_userManager->onUserCreated.connect(boost::bind(&NetworkPluginServer::handleUserCreated, this, _1));
 	m_userManager->onUserDestroyed.connect(boost::bind(&NetworkPluginServer::handleUserDestroyed, this, _1));
 	m_pingTimer = component->getNetworkFactories()->getTimerFactory()->createTimer(20000);
 	m_pingTimer->onTick.connect(boost::bind(&NetworkPluginServer::pingTimeout, this));
 	m_pingTimer->start();
 	if (CONFIG_INT(m_config, "service.memory_collector_time") != 0) {
 		m_collectTimer = component->getNetworkFactories()->getTimerFactory()->createTimer(CONFIG_INT(m_config, "service.memory_collector_time"));
 		m_collectTimer->onTick.connect(boost::bind(&NetworkPluginServer::collectBackend, this));
 		m_collectTimer->start();
+	}
 	m_vcardResponder = new VCardResponder(component->getIQRouter(), component->getNetworkFactories(), userManager);
 	m_vcardResponder->onVCardRequired.connect(boost::bind(&NetworkPluginServer::handleVCardRequired, this, _1, _2, _3));
 	m_vcardResponder->onVCardUpdated.connect(boost::bind(&NetworkPluginServer::handleVCardUpdated, this, _1, _2));
 	m_vcardResponder->start();
 	m_rosterResponder = new RosterResponder(component->getIQRouter(), userManager);
 	m_rosterResponder->onBuddyAdded.connect(boost::bind(&NetworkPluginServer::handleBuddyAdded, this, _1, _2));
 	m_rosterResponder->onBuddyRemoved.connect(boost::bind(&NetworkPluginServer::handleBuddyRemoved, this, _1));
 	m_rosterResponder->onBuddyUpdated.connect(boost::bind(&NetworkPluginServer::handleBuddyUpdated, this, _1, _2));
 	m_rosterResponder->start();
 	m_blockResponder = new BlockResponder(component->getIQRouter(), userManager);
 	m_blockResponder->onBlockToggled.connect(boost::bind(&NetworkPluginServer::handleBlockToggled, this, _1));
 	m_blockResponder->start();
 	m_server = component->getNetworkFactories()->getConnectionServerFactory()->createConnectionServer(Swift::HostAddress(CONFIG_STRING(m_config, "service.backend_host")), boost::lexical_cast<int>(CONFIG_STRING(m_config, "service.backend_port")));
 	m_server->onNewConnection.connect(boost::bind(&NetworkPluginServer::handleNewClientConnection, this, _1));
+}
 NetworkPluginServer::~NetworkPluginServer() {
 	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {
 		LOG4CXX_INFO(logger, "Stopping backend " << *it);
 		std::string message;
 		pbnetwork::WrapperMessage wrap;
 		wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_EXIT);
 		wrap.SerializeToString(&message);
 		Backend *c = (Backend *) *it;
 		send(c->connection, message);
+	}
 	m_pingTimer->stop();
 	m_server->stop();
 	m_server.reset();
 	delete m_component->m_factory;
 	delete m_vcardResponder;
 	delete m_rosterResponder;
 	delete m_blockResponder;
+}
 void NetworkPluginServer::start() {
 	m_server->start();
 	LOG4CXX_INFO(logger, "Listening on host " << CONFIG_STRING(m_config, "service.backend_host") << " port " << CONFIG_STRING(m_config, "service.backend_port"));
 	while (true) {
 		unsigned long pid = exec_(CONFIG_STRING(m_config, "service.backend"), CONFIG_STRING(m_config, "service.backend_host").c_str(), CONFIG_STRING(m_config, "service.backend_port").c_str(), m_config->getCommandLineArgs().c_str());
 		LOG4CXX_INFO(logger, "Tried to spawn first backend with pid " << pid);
 		LOG4CXX_INFO(logger, "Backend should now connect to Spectrum2 instance. Spectrum2 won't accept any connection before backend connects");
 #ifndef _WIN32
 		// wait if the backend process will still be alive after 1 second
 		sleep(1);
 		pid_t result;
 		int status;
 		result = waitpid(-1, &status, WNOHANG);
 		if (result != 0) {
 			if (WIFEXITED(status)) {
 				if (WEXITSTATUS(status) != 0) {
 					LOG4CXX_ERROR(logger, "Backend can not be started, exit_code=" << WEXITSTATUS(status) << ", possible error: " << strerror(WEXITSTATUS(status)));
 					if (status == 254) {
 						LOG4CXX_ERROR(logger, "Backend can not be started, because it needs database to store data, but the database backend is not configured.");
+					}
 					else {
 						LOG4CXX_ERROR(logger, "Backend can not be started, exit_code=" << WEXITSTATUS(status) << ", possible error: " << strerror(WEXITSTATUS(status)));
+					}
 					LOG4CXX_ERROR(logger, "Check backend log for more details");
 					continue;
+				}
+			}
 			else {
 				LOG4CXX_ERROR(logger, "Backend can not be started");
 				continue;
+			}
+		}
 		signal(SIGCHLD, SigCatcher);
 #endif
 		// quit the while loop
 		break;
+	}
+}
 NetworkPluginServer::~NetworkPluginServer() {
 	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {
 		LOG4CXX_INFO(logger, "Stopping backend " << *it);
 		std::string message;
 		pbnetwork::WrapperMessage wrap;
 		wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_EXIT);
 		wrap.SerializeToString(&message);
 		Backend *c = (Backend *) *it;
 		send(c->connection, message);
+	}
 	m_pingTimer->stop();
 	m_server->stop();
 	m_server.reset();
 	delete m_component->m_factory;
 	delete m_vcardResponder;
 	delete m_rosterResponder;
 	delete m_blockResponder;
+}
 void NetworkPluginServer::handleNewClientConnection(boost::shared_ptr<Swift::Connection> c) {
 	// Create new Backend instance
 	Backend *client = new Backend;
 	client->pongReceived = -1;
 	client->connection = c;
 	client->res = 0;
 	client->init_res = 0;
 	client->shared = 0;
 	// Until we receive first PONG from backend, backend is in willDie state.
 	client->willDie = true;
 	// Backend does not accept new clients automatically if it's long-running
 	client->acceptUsers = !m_isNextLongRun;
 	client->longRun = m_isNextLongRun;
 	m_startingBackend = false;
 	LOG4CXX_INFO(logger, "New" + (client->longRun ? std::string(" long-running") : "") +  " backend " << client << " connected. Current backend count=" << (m_clients.size() + 1));
 	m_clients.push_front(client);
 	c->onDisconnected.connect(boost::bind(&NetworkPluginServer::handleSessionFinished, this, client));
 	c->onDataRead.connect(boost::bind(&NetworkPluginServer::handleDataRead, this, client, _1));
 	utf8::replace_invalid(payload.nickname().begin(), payload.nickname().end(), field.begin(), '_');
 	vcard->setNickname(field);
 	vcard->setPhoto(Swift::createByteArray(payload.photo()));
 	m_vcardResponder->sendVCard(payload.id(), vcard);
+}
 void NetworkPluginServer::handleAuthorizationPayload(const std::string &data) {
 	pbnetwork::Buddy payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	User *user = m_userManager->getUser(payload.username());
 	if (!user)
 		return;
 	// Create subscribe presence and forward it to XMPP side
 	Swift::Presence::ref response = Swift::Presence::create();
 	response->setTo(user->getJID());
 	std::string name = payload.buddyname();
 	name = Swift::JID::getEscapedNode(name);
 // 	if (name.find_last_of("@") != std::string::npos) { // OK when commented
 // 		name.replace(name.find_last_of("@"), 1, "%"); // OK when commented
 // 	}
 	if (CONFIG_BOOL_DEFAULTED(m_config, "service.jid_escaping", true)) {
 		name = Swift::JID::getEscapedNode(name);
+	}
 	else {
 		if (name.find_last_of("@") != std::string::npos) {
 			name.replace(name.find_last_of("@"), 1, "%");
+		}
+	}
 	response->setFrom(Swift::JID(name, m_component->getJID().toString()));
 	response->setType(Swift::Presence::Subscribe);
 	m_component->getStanzaChannel()->sendPresence(response);
+}
 void NetworkPluginServer::handleChatStatePayload(const std::string &data, Swift::ChatState::ChatStateType type) {
 	pbnetwork::Buddy payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	User *user = m_userManager->getUser(payload.username());
 	if (!user)
 		return;
 	// We're not creating new Conversation just because of chatstates.
 	// Some networks/clients spams with chatstates a lot and it leads to bigger memory usage.
 	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(payload.buddyname());
 	if (!conv) {
 		return;
+	}
 	// Forward chatstate
 	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 	msg->addPayload(boost::make_shared<Swift::ChatState>(type));
 	conv->handleMessage(msg);
+}
 void NetworkPluginServer::handleBuddyChangedPayload(const std::string &data) {
 	pbnetwork::Buddy payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	User *user = m_userManager->getUser(payload.username());
 	if (!user)
 		return;
 	LocalBuddy *buddy = (LocalBuddy *) user->getRosterManager()->getBuddy(payload.buddyname());
 	if (buddy) {
 		handleBuddyPayload(buddy, payload);
 		buddy->handleBuddyChanged();
+	}
 	else {
 		if (payload.buddyname() == user->getUserInfo().uin) {
 			return;
+		}
 		std::vector<std::string> groups;
 		for (int i = 0; i < payload.group_size(); i++) {
 			groups.push_back(payload.group(i));
+		}
 		buddy = new LocalBuddy(user->getRosterManager(), -1, payload.buddyname(), payload.alias(), groups, BUDDY_JID_ESCAPING);
 		if (CONFIG_BOOL_DEFAULTED(m_config, "service.jid_escaping", true)) {
 			buddy = new LocalBuddy(user->getRosterManager(), -1, payload.buddyname(), payload.alias(), groups, BUDDY_JID_ESCAPING);
+		}
 		else {
 			buddy = new LocalBuddy(user->getRosterManager(), -1, payload.buddyname(), payload.alias(), groups, BUDDY_NO_FLAG);
+		}
 		if (!buddy->isValid()) {
 			delete buddy;
 			return;
+		}
 		buddy->setStatus(Swift::StatusShow((Swift::StatusShow::Type) payload.status()), payload.statusmessage());
 		buddy->setIconHash(payload.iconhash());
 		buddy->setBlocked(payload.blocked());
 		user->getRosterManager()->setBuddy(buddy);
+	}
+}
 void NetworkPluginServer::handleBuddyRemovedPayload(const std::string &data) {
 	pbnetwork::Buddy payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	User *user = m_userManager->getUser(payload.username());
 	if (!user)
 		return;
 	user->getRosterManager()->removeBuddy(payload.buddyname());
+}
 void NetworkPluginServer::handleParticipantChangedPayload(const std::string &data) {
 	pbnetwork::Participant payload;
 	if (payload.ParseFromString(data) == false) {
 		return;
+	}
 	User *user = m_userManager->getUser(payload.username());
 	if (!user)
 		return;
 	// Message from legacy network triggers network acticity
 	user->updateLastActivity();
 	// Set proper body.
 	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 	if (subject) {
 		msg->setSubject(payload.message());
+	}
 	else {
 		msg->setBody(payload.message());
+	}
 	// Add xhtml-im payload.
 	if (CONFIG_BOOL(m_config, "service.enable_xhtml") && !payload.xhtml().empty()) {
 		msg->addPayload(boost::make_shared<Swift::XHTMLIMPayload>(payload.xhtml()));
+	}
 	// Create new Conversation if it does not exist
 	if (!payload.timestamp().empty()) {
 		boost::posix_time::ptime timestamp = boost::posix_time::from_iso_string(payload.timestamp());
 		msg->addPayload(boost::make_shared<Swift::Delay>(timestamp));
+	}
 	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(payload.buddyname());
 	// We can't create Conversation for payload with nickname, because this means the message is from room,
 	// but this user is not in any room, so it's OK to just reject this message
 	if (!conv && !payload.nickname().empty()) {
 		return;
+	}
 	// Create new Conversation if it does not exist
 	if (!conv) {
 		conv = new NetworkConversation(user->getConversationManager(), payload.buddyname());
 		user->getConversationManager()->addConversation(conv);
 		conv->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, this, _1, _2));
+	}
 	// Forward it
 	conv->handleMessage(msg, payload.nickname());
 	m_userManager->messageToXMPPSent();
+}
 void NetworkPluginServer::handleAttentionPayload(const std::string &data) {
 	pbnetwork::ConversationMessage payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	User *user = m_userManager->getUser(payload.username());
 	if (!user)
 		return;
 	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 	msg->setBody(payload.message());
 	if (payload.has_ftid()) {
 		if (m_filetransfers.find(payload.ftid()) != m_filetransfers.end()) {
 			FileTransferManager::Transfer &transfer = m_filetransfers[payload.ftid()];
 			transfer.ft->cancel();
+		}
 		else {
 			LOG4CXX_ERROR(logger, "FTFinishPayload for unknown ftid=" << payload.ftid());
+		}
+	}
+}
 void NetworkPluginServer::handleFTDataPayload(Backend *b, const std::string &data) {
 	pbnetwork::FileTransferData payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 // 	User *user = m_userManager->getUser(payload.username());
 // 	if (!user)
 // 		return;
 	if (m_filetransfers.find(payload.ftid()) == m_filetransfers.end()) {
 		LOG4CXX_ERROR(logger, "Uknown filetransfer with id " << payload.ftid());
 		return;
+	}
 	FileTransferManager::Transfer &transfer = m_filetransfers[payload.ftid()];
 	MemoryReadBytestream *bytestream = (MemoryReadBytestream *) transfer.readByteStream.get();
 	if (bytestream->appendData(payload.data()) > 5000000) {
 		pbnetwork::FileTransferData f;
 		f.set_ftid(payload.ftid());
 		f.set_data("");
 		std::string message;
 		f.SerializeToString(&message);
 		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_PAUSE);
 		send(b->connection, message);
+	}
+}
 void NetworkPluginServer::handleFTDataNeeded(Backend *b, unsigned long ftid) {
 	pbnetwork::FileTransferData f;
 	f.set_ftid(ftid);
 	f.set_data("");
 	std::string message;
 	f.SerializeToString(&message);
 	msg->setBody(payload.config());
 	m_adminInterface->handleQuery(msg);
 	pbnetwork::BackendConfig response;
 	response.set_config(msg->getBody());
 	std::string message;
 	response.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_QUERY);
 	send(b->connection, message);
+}
 void NetworkPluginServer::handleBackendConfigPayload(const std::string &data) {
 	pbnetwork::BackendConfig payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	m_config->updateBackendConfig(payload.config());
+}
 void NetworkPluginServer::handleRoomListPayload(const std::string &data) {
 	pbnetwork::RoomList payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	m_discoItemsResponder->clearRooms();
 	for (int i = 0; i < payload.room_size() && i < payload.name_size(); i++) {
 		m_discoItemsResponder->addRoom(Swift::JID::getEscapedNode(payload.room(i)) + "@" + m_component->getJID().toString(), payload.name(i));
+	}
+}
 void NetworkPluginServer::handleDataRead(Backend *c, boost::shared_ptr<Swift::SafeByteArray> data) {
 	// Append data to buffer
 	c->data.insert(c->data.end(), data->begin(), data->end());
 	// Parse data while there are some
 	while (c->data.size() != 0) {
 		// expected_size of wrapper message
 		unsigned int expected_size;
 		// if data is >= 4, we have whole header and we can
 		// read expected_size.
 		if (c->data.size() >= 4) {
 			expected_size = *((unsigned int*) &c->data[0]);
 			expected_size = ntohl(expected_size);
 			// If we don't have whole wrapper message, wait for next
 			// handleDataRead call.
 			if (c->data.size() - 4 < expected_size)
 				return;
+		}
 		else {
 			return;
+		}
 		// Parse wrapper message and erase it from buffer.
 			case pbnetwork::WrapperMessage_Type_TYPE_ATTENTION:
 				handleAttentionPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_STATS:
 				handleStatsPayload(c, wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_FT_START:
 				handleFTStartPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_FT_FINISH:
 				handleFTFinishPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_FT_DATA:
 				handleFTDataPayload(c, wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_REMOVED:
 				handleBuddyRemovedPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_QUERY:
 				handleQueryPayload(c, wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_BACKEND_CONFIG:
 				handleBackendConfigPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_ROOM_LIST:
 				handleRoomListPayload(wrapper.payload());
 				break;
 			default:
 				return;
+		}
+	}
+}
 void NetworkPluginServer::send(boost::shared_ptr<Swift::Connection> &c, const std::string &data) {
 	// generate header - size of wrapper message
 	uint32_t size = htonl(data.size());
 	char *header = (char *) &size;
 	// send header together with wrapper message
 	c->write(Swift::createSafeByteArray(std::string(header, 4) + data));
+}
 void NetworkPluginServer::pingTimeout() {
 	// TODO: move to separate timer, those 2 loops could be expensive
 	// Some users are connected for weeks and they are blocking backend to be destroyed and its memory
 	// to be freed. We are finding users who are inactive for more than "idle_reconnect_time" seconds and
 	// reconnect them to long-running backend, where they can idle hapilly till the end of ages.
 	time_t now = time(NULL);
 	std::vector<User *> usersToMove;
 	unsigned long diff = CONFIG_INT(m_config, "service.idle_reconnect_time");
 	if (diff != 0) {
 		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->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) {

src/pqxxbackend.cpp

➞

Show inline comments

 	return "'" + txn.esc(pqxx::to_string(t)) + "'";
+}
 bool PQXXBackend::exec(const std::string &query, bool show_error) {
 	pqxx::nontransaction txn(*m_conn);
 	return exec(txn, query, show_error);
+}
 bool PQXXBackend::exec(pqxx::nontransaction &txn, const std::string &query, bool show_error) {
 	try {
 		txn.exec(query);
 		txn.commit();
+	}
 	catch (std::exception& e) {
 		if (show_error)
 			LOG4CXX_ERROR(logger, e.what());
 		return false;
+	}
 	return true;
+}
 void PQXXBackend::setUser(const UserInfo &user) {
 	std::string encrypted = user.password;
 	if (!CONFIG_STRING(m_config, "database.encryption_key").empty()) {
-		encrypted = Util::encryptPassword(encrypted, CONFIG_STRING(m_config, "database.encryption_key"));
+		encrypted = StorageBackend::encryptPassword(encrypted, CONFIG_STRING(m_config, "database.encryption_key"));
+	}
 	try {
 		pqxx::nontransaction txn(*m_conn);
 		txn.exec("INSERT INTO " + m_prefix + "users (jid, uin, password, language, encoding, last_login, vip) VALUES "
 			+ "(" + quote(txn, user.jid) + ","
 			+ quote(txn, user.uin) + ","
 			+ quote(txn, encrypted) + ","
 			+ quote(txn, user.language) + ","
 			+ quote(txn, user.encoding) + ","
 			+ "NOW(),"
 			+ (user.vip ? "'true'" : "'false'") +")");
+	}
 	catch (std::exception& e) {
 		LOG4CXX_ERROR(logger, e.what());
+	}
+}
 bool PQXXBackend::getUser(const std::string &barejid, UserInfo &user) {
 	try {
 		pqxx::nontransaction txn(*m_conn);
 		pqxx::result r = txn.exec("SELECT id, jid, uin, password, encoding, language, vip FROM " + m_prefix + "users WHERE jid="
 			+ quote(txn, barejid));
@@ @@ -215,100 +215,100 @@ void PQXXBackend::setUserOnline(long id, bool online) { @@
 bool PQXXBackend::getOnlineUsers(std::vector<std::string> &users) {
 	try {
 		pqxx::nontransaction txn(*m_conn);
 		pqxx::result r = txn.exec("SELECT jid FROM " + m_prefix + "users WHERE online='true'");
 		for (pqxx::result::const_iterator it = r.begin(); it != r.end(); it++)  {
 			users.push_back((*it)[0].as<std::string>());
+		}
+	}
 	catch (std::exception& e) {
 		LOG4CXX_ERROR(logger, e.what());
 		return false;
+	}
 	return true;
+}
 long PQXXBackend::addBuddy(long userId, const BuddyInfo &buddyInfo) {
 	try {
 		pqxx::nontransaction txn(*m_conn);
 		pqxx::result r = txn.exec("INSERT INTO " + m_prefix + "buddies (user_id, uin, subscription, groups, nickname, flags) VALUES "
 			+ "(" + pqxx::to_string(userId) + ","
 			+ quote(txn, buddyInfo.legacyName) + ","
 			+ quote(txn, buddyInfo.subscription) + ","
-			+ quote(txn, Util::serializeGroups(buddyInfo.groups)) + ","
+			+ quote(txn, StorageBackend::serializeGroups(buddyInfo.groups)) + ","
 			+ quote(txn, buddyInfo.alias) + ","
 			+ pqxx::to_string(buddyInfo.flags) + ") RETURNING id");
 		long id = r[0][0].as<long>();
 		r = txn.exec("UPDATE " + m_prefix + "buddies_settings SET var = " + quote(txn, buddyInfo.settings.find("icon_hash")->first) + ", type = " + pqxx::to_string((int)TYPE_STRING) + ", value = " + quote(txn, buddyInfo.settings.find("icon_hash")->second.s) + " WHERE user_id = " + pqxx::to_string(userId) + " AND buddy_id = " + pqxx::to_string(id));
 		if (r.affected_rows() == 0) {
 			txn.exec("INSERT INTO " + m_prefix + "buddies_settings (user_id, buddy_id, var, type, value) VALUES "
 				+ "(" + pqxx::to_string(userId) + ","
 				+ pqxx::to_string(id) + ","
 				+ quote(txn, buddyInfo.settings.find("icon_hash")->first) + ","
 				+ pqxx::to_string((int)TYPE_STRING) + ","
 				+ quote(txn,  buddyInfo.settings.find("icon_hash")->second.s) + ")");
+		}
 		return id;
+	}
 	catch (std::exception& e) {
 		LOG4CXX_ERROR(logger, e.what());
 		return -1;
+	}
+}
 void PQXXBackend::updateBuddy(long userId, const BuddyInfo &buddyInfo) {
 	try {
 		pqxx::nontransaction txn(*m_conn);
-		txn.exec("UPDATE " + m_prefix + "buddies SET groups=" + quote(txn, Util::serializeGroups(buddyInfo.groups)) + ", nickname=" + quote(txn, buddyInfo.alias) + ", flags=" + pqxx::to_string(buddyInfo.flags) + ", subscription=" + quote(txn, buddyInfo.subscription) + " WHERE user_id=" + pqxx::to_string(userId) + " AND uin=" + quote(txn, buddyInfo.legacyName));
+		txn.exec("UPDATE " + m_prefix + "buddies SET groups=" + quote(txn, StorageBackend::serializeGroups(buddyInfo.groups)) + ", nickname=" + quote(txn, buddyInfo.alias) + ", flags=" + pqxx::to_string(buddyInfo.flags) + ", subscription=" + quote(txn, buddyInfo.subscription) + " WHERE user_id=" + pqxx::to_string(userId) + " AND uin=" + quote(txn, buddyInfo.legacyName));
+	}
 	catch (std::exception& e) {
 		LOG4CXX_ERROR(logger, e.what());
+	}
+}
 bool PQXXBackend::getBuddies(long id, std::list<BuddyInfo> &roster) {
 	try {
 		pqxx::nontransaction txn(*m_conn);
 		pqxx::result r = txn.exec("SELECT id, uin, subscription, nickname, groups, flags FROM " + m_prefix + "buddies WHERE user_id=" + pqxx::to_string(id) + " ORDER BY id ASC");
 		for (pqxx::result::const_iterator it = r.begin(); it != r.end(); it++)  {
 			BuddyInfo b;
 			std::string group;
 			b.id = r[0][0].as<long>();
 			b.legacyName = r[0][1].as<std::string>();
 			b.subscription = r[0][2].as<std::string>();
 			b.alias = r[0][3].as<std::string>();
 			group = r[0][4].as<std::string>();
 			b.flags = r[0][5].as<long>();
 			if (!group.empty()) {
-				b.groups = Util::deserializeGroups(group);
+				b.groups = StorageBackend::deserializeGroups(group);
+			}
 			roster.push_back(b);
+		}
 		r = txn.exec("SELECT buddy_id, type, var, value FROM " + m_prefix + "buddies_settings WHERE user_id=" + pqxx::to_string(id) + " ORDER BY buddy_id ASC");
 		for (pqxx::result::const_iterator it = r.begin(); it != r.end(); it++)  {
 			SettingVariableInfo var;
 			long buddy_id = -1;
 			std::string key;
 			std::string val;
 			buddy_id = r[0][0].as<long>();
 			var.type = r[0][1].as<long>();
 			key = r[0][2].as<std::string>();
 			val = r[0][3].as<std::string>();
 			switch (var.type) {
 				case TYPE_BOOLEAN:
 					var.b = atoi(val.c_str());
 					break;
 				case TYPE_STRING:
 					var.s = val;
 					break;

src/rostermanager.cpp

➞

Show inline comments

@@ @@ -160,49 +160,49 @@ void RosterManager::sendBuddyRosterPush(Buddy *buddy) { @@
 	item.setGroups(buddy->getGroups());
 	item.setSubscription(Swift::RosterItemPayload::Both);
 	payload->addItem(item);
 	// In server mode we have to send pushes to all resources, but in gateway-mode we send it only to bare JID
 	if (m_component->inServerMode()) {
 		std::vector<Swift::Presence::ref> presences = m_component->getPresenceOracle()->getAllPresence(m_user->getJID().toBare());
 		BOOST_FOREACH(Swift::Presence::ref presence, presences) {
 			Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, presence->getFrom(), m_component->getIQRouter());
 			request->onResponse.connect(boost::bind(&RosterManager::handleBuddyRosterPushResponse, this, _1, request, buddy->getName()));
 			request->send();
 			m_requests.push_back(request);
+		}
+	}
 	else {
 		Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, m_user->getJID().toBare(), m_component->getIQRouter());
 		request->onResponse.connect(boost::bind(&RosterManager::handleBuddyRosterPushResponse, this, _1, request, buddy->getName()));
 		request->send();
 		m_requests.push_back(request);
+	}
 	if (buddy->getSubscription() != Buddy::Both) {
 		buddy->setSubscription(Buddy::Both);
-		handleBuddyChanged(buddy);
+		storeBuddy(buddy);
+	}
+}
 void RosterManager::sendBuddyUnsubscribePresence(Buddy *buddy) {
 	Swift::Presence::ref response = Swift::Presence::create();
 	response->setTo(m_user->getJID());
 	response->setFrom(buddy->getJID());
 	response->setType(Swift::Presence::Unsubscribe);
 	m_component->getStanzaChannel()->sendPresence(response);
 	response = Swift::Presence::create();
 	response->setTo(m_user->getJID());
 	response->setFrom(buddy->getJID());
 	response->setType(Swift::Presence::Unsubscribed);
 	m_component->getStanzaChannel()->sendPresence(response);
+}
 void RosterManager::sendBuddySubscribePresence(Buddy *buddy) {
 	Swift::Presence::ref response = Swift::Presence::create();
 	response->setTo(m_user->getJID());
 	response->setFrom(buddy->getJID());
 	response->setType(Swift::Presence::Subscribe);
 // 	TODO: NICKNAME
 	m_component->getStanzaChannel()->sendPresence(response);
+			}
 			m_component->getStanzaChannel()->sendPresence(response);
+		}
+	}
 	else {
 		Swift::Presence::ref response = Swift::Presence::create();
 		Swift::Presence::ref currentPresence;
 		response->setTo(presence->getFrom().toBare());
 		response->setFrom(presence->getTo().toBare());
 		Buddy *buddy = getBuddy(Buddy::JIDToLegacyName(presence->getTo()));
 		if (buddy) {
 			switch (presence->getType()) {
 				// buddy is already there, so nothing to do, just answer
 				case Swift::Presence::Subscribe:
 					onBuddyAdded(buddy);
 					response->setType(Swift::Presence::Subscribed);
 					currentPresence = buddy->generatePresenceStanza(255);
 					if (currentPresence) {
 						currentPresence->setTo(presence->getFrom());
 						m_component->getStanzaChannel()->sendPresence(currentPresence);
+					}
 					if (buddy->getSubscription() != Buddy::Both) {
 						buddy->setSubscription(Buddy::Both);
-						handleBuddyChanged(buddy);
+						storeBuddy(buddy);
+					}
 					break;
 				// remove buddy
 				case Swift::Presence::Unsubscribe:
 					response->setType(Swift::Presence::Unsubscribed);
 					onBuddyRemoved(buddy);
 					removeBuddy(buddy->getName());
 					buddy = NULL;
 					break;
 				// just send response
 				case Swift::Presence::Unsubscribed:
 					response->setType(Swift::Presence::Unsubscribe);
 					// We set both here, because this Unsubscribed can be response to
 					// subscribe presence and we don't want that unsubscribe presence
 					// to be send later again
 					if (buddy->getSubscription() != Buddy::Both) {
 						buddy->setSubscription(Buddy::Both);
-						handleBuddyChanged(buddy);
+						storeBuddy(buddy);
+					}
 					break;
 				case Swift::Presence::Subscribed:
 					if (buddy->getSubscription() != Buddy::Both) {
 						buddy->setSubscription(Buddy::Both);
-						handleBuddyChanged(buddy);
+						storeBuddy(buddy);
+					}
 					return;
 				default:
 					return;
+			}
+		}
 		else {
 			BuddyInfo buddyInfo;
 			switch (presence->getType()) {
 				// buddy is not in roster, so add him
 				case Swift::Presence::Subscribe:
 					buddyInfo.id = -1;
 					buddyInfo.alias = "";
 					buddyInfo.legacyName = Buddy::JIDToLegacyName(presence->getTo());
 					buddyInfo.subscription = "both";
 					buddyInfo.flags = Buddy::buddyFlagsFromJID(presence->getTo());
 					buddy = m_component->getFactory()->createBuddy(this, buddyInfo);
 					setBuddy(buddy);
 					onBuddyAdded(buddy);
 					response->setType(Swift::Presence::Subscribed);
 					break;
 				// buddy is already there, so nothing to do, just answer
 				case Swift::Presence::Unsubscribe:
 					buddyInfo.id = -1;
 					buddyInfo.alias = "";
 					buddyInfo.legacyName = Buddy::JIDToLegacyName(presence->getTo());
 					buddyInfo.subscription = "both";
 					buddyInfo.flags = Buddy::buddyFlagsFromJID(presence->getTo());
 					response->setType(Swift::Presence::Unsubscribed);
 // 					onBuddyRemoved(buddy);
 					buddy = m_component->getFactory()->createBuddy(this, buddyInfo);
 					onBuddyRemoved(buddy);
 					delete buddy;
 					buddy = NULL;
 					break;
 				// just send response
 				case Swift::Presence::Unsubscribed:
 					response->setType(Swift::Presence::Unsubscribe);
 					break;
 				// just send response
 				default:
 					return;
+			}
+		}
 		m_component->getStanzaChannel()->sendPresence(response);
 		// We have to act as buddy and send its subscribe/unsubscribe just to be sure...
 		switch (response->getType()) {
 			case Swift::Presence::Unsubscribed:
 				response->setType(Swift::Presence::Unsubscribe);
 				m_component->getStanzaChannel()->sendPresence(response);
 				break;
 			case Swift::Presence::Subscribed:
 				response->setType(Swift::Presence::Subscribe);
 				m_component->getStanzaChannel()->sendPresence(response);
 				break;
 			default:

src/rosterresponder.cpp

➞

Show inline comments

 		LOG4CXX_WARN(logger, from.toBare().toString() << ": User is not logged in");
 		return true;
+	}
 	sendResponse(from, id, user->getRosterManager()->generateRosterPayload());
 	user->getRosterManager()->sendCurrentPresences(from);
 	return true;
+}
 bool RosterResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload) {
 	sendResponse(from, id, boost::shared_ptr<RosterPayload>(new RosterPayload()));
 	User *user = m_userManager->getUser(from.toBare().toString());
 	if (!user) {
 		LOG4CXX_WARN(logger, from.toBare().toString() << ": User is not logged in");
 		return true;
+	}
 	if (payload->getItems().size() == 0) {
 		LOG4CXX_WARN(logger, from.toBare().toString() << ": Roster push with no item");
 		return true;
+	}
 	Swift::RosterItemPayload item = payload->getItems()[0];
 	if (item.getJID().getNode().empty()) {
 		return true;
+	}
 	Buddy *buddy = user->getRosterManager()->getBuddy(Buddy::JIDToLegacyName(item.getJID()));
 	if (buddy) {
 		if (item.getSubscription() == Swift::RosterItemPayload::Remove) {
 			LOG4CXX_INFO(logger, from.toBare().toString() << ": Removing buddy " << buddy->getName());
 			onBuddyRemoved(buddy);
 			// send roster push here
 			Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, user->getJID().toBare(), user->getComponent()->getIQRouter());
 			request->send();
+		}
 		else {
 			LOG4CXX_INFO(logger, from.toBare().toString() << ": Updating buddy " << buddy->getName());
 			onBuddyUpdated(buddy, item);
+		}
+	}
 	else if (item.getSubscription() != Swift::RosterItemPayload::Remove) {
 		// Roster push for this new buddy is sent by RosterManager
 		BuddyInfo buddyInfo;
 		buddyInfo.id = -1;
 		buddyInfo.alias = item.getName();
 		buddyInfo.legacyName = Buddy::JIDToLegacyName(item.getJID());
 		buddyInfo.subscription = "both";
 		buddyInfo.flags = Buddy::buddyFlagsFromJID(item.getJID());
 		LOG4CXX_INFO(logger, from.toBare().toString() << ": Adding buddy " << buddyInfo.legacyName);

src/sqlite3backend.cpp

➞

Show inline comments

 bool SQLite3Backend::getOnlineUsers(std::vector<std::string> &users) {
 	sqlite3_reset(m_getOnlineUsers);
 	int ret;
 	while((ret = sqlite3_step(m_getOnlineUsers)) == SQLITE_ROW) {
 		std::string jid = (const char *) sqlite3_column_text(m_getOnlineUsers, 0);
 		users.push_back(jid);
+	}
 	if (ret != SQLITE_DONE) {
 		LOG4CXX_ERROR(logger, "getOnlineUsers query"<< (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));
 		return false;
+	}
 	return true;
+}
 long SQLite3Backend::addBuddy(long userId, const BuddyInfo &buddyInfo) {
 // 	"INSERT INTO " + m_prefix + "buddies (user_id, uin, subscription, groups, nickname, flags) VALUES (?, ?, ?, ?, ?, ?)"
 	BEGIN(m_addBuddy);
 	BIND_INT(m_addBuddy, userId);
 	BIND_STR(m_addBuddy, buddyInfo.legacyName);
 	BIND_STR(m_addBuddy, buddyInfo.subscription);
-	BIND_STR(m_addBuddy, Util::serializeGroups(buddyInfo.groups));
+	BIND_STR(m_addBuddy, StorageBackend::serializeGroups(buddyInfo.groups));
 	BIND_STR(m_addBuddy, buddyInfo.alias);
 	BIND_INT(m_addBuddy, buddyInfo.flags);
 	if(sqlite3_step(m_addBuddy) != SQLITE_DONE) {
 		LOG4CXX_ERROR(logger, "addBuddy query"<< (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));
 		return -1;
+	}
 	long id = (long) sqlite3_last_insert_rowid(m_db);
 // 	INSERT OR REPLACE INTO " + m_prefix + "buddies_settings (user_id, buddy_id, var, type, value) VALUES (?, ?, ?, ?, ?)
 	BEGIN(m_updateBuddySetting);
 	BIND_INT(m_updateBuddySetting, userId);
 	BIND_INT(m_updateBuddySetting, id);
 	BIND_STR(m_updateBuddySetting, buddyInfo.settings.find("icon_hash")->first);
 	BIND_INT(m_updateBuddySetting, TYPE_STRING);
 	BIND_STR(m_updateBuddySetting, buddyInfo.settings.find("icon_hash")->second.s);
 	EXECUTE_STATEMENT(m_updateBuddySetting, "updateBuddySetting query");
 	return id;
+}
 void SQLite3Backend::updateBuddy(long userId, const BuddyInfo &buddyInfo) {
 // 	UPDATE " + m_prefix + "buddies SET groups=?, nickname=?, flags=?, subscription=? WHERE user_id=? AND uin=?
 	BEGIN(m_updateBuddy);
-	BIND_STR(m_updateBuddy, Util::serializeGroups(buddyInfo.groups));
+	BIND_STR(m_updateBuddy, StorageBackend::serializeGroups(buddyInfo.groups));
 	BIND_STR(m_updateBuddy, buddyInfo.alias);
 	BIND_INT(m_updateBuddy, buddyInfo.flags);
 	BIND_STR(m_updateBuddy, buddyInfo.subscription);
 	BIND_INT(m_updateBuddy, userId);
 	BIND_STR(m_updateBuddy, buddyInfo.legacyName);
 	EXECUTE_STATEMENT(m_updateBuddy, "updateBuddy query");
 // 	INSERT OR REPLACE INTO " + m_prefix + "buddies_settings (user_id, buddy_id, var, type, value) VALUES (?, ?, ?, ?, ?)
 	BEGIN(m_updateBuddySetting);
 	BIND_INT(m_updateBuddySetting, userId);
 	BIND_INT(m_updateBuddySetting, buddyInfo.id);
 	BIND_STR(m_updateBuddySetting, buddyInfo.settings.find("icon_hash")->first);
 	BIND_INT(m_updateBuddySetting, TYPE_STRING);
 	BIND_STR(m_updateBuddySetting, buddyInfo.settings.find("icon_hash")->second.s);
 	EXECUTE_STATEMENT(m_updateBuddySetting, "updateBuddySetting query");
+}
 bool SQLite3Backend::getBuddies(long id, std::list<BuddyInfo> &roster) {
 //	SELECT id, uin, subscription, nickname, groups, flags FROM " + m_prefix + "buddies WHERE user_id=? ORDER BY id ASC
 	BEGIN(m_getBuddies);
 	BIND_INT(m_getBuddies, id);
 // 	"SELECT buddy_id, type, var, value FROM " + m_prefix + "buddies_settings WHERE user_id=? ORDER BY buddy_id ASC"
 	BEGIN(m_getBuddiesSettings);
 	BIND_INT(m_getBuddiesSettings, id);
 	SettingVariableInfo var;
 	long buddy_id = -1;
 	std::string key;
 	int ret;
 	while((ret = sqlite3_step(m_getBuddies)) == SQLITE_ROW) {
 		BuddyInfo b;
 		RESET_GET_COUNTER(m_getBuddies);
 		b.id = GET_INT(m_getBuddies);
 		b.legacyName = GET_STR(m_getBuddies);
 		b.subscription = GET_STR(m_getBuddies);
 		b.alias = GET_STR(m_getBuddies);
 		std::string groups = GET_STR(m_getBuddies);
-		b.groups = Util::deserializeGroups(groups);
+		b.groups = StorageBackend::deserializeGroups(groups);
 		b.flags = GET_INT(m_getBuddies);
 		if (buddy_id == b.id) {
 			std::cout << "Adding buddy info " << key << "\n";
 			b.settings[key] = var;
 			buddy_id = -1;
+		}
 		while(buddy_id == -1 && (ret = sqlite3_step(m_getBuddiesSettings)) == SQLITE_ROW) {
 			RESET_GET_COUNTER(m_getBuddiesSettings);
 			buddy_id = GET_INT(m_getBuddiesSettings);
 			var.type = GET_INT(m_getBuddiesSettings);
 			key = GET_STR(m_getBuddiesSettings);
 			std::string val = GET_STR(m_getBuddiesSettings);
 			switch (var.type) {
 				case TYPE_BOOLEAN:
 					var.b = atoi(val.c_str());
 					break;
 				case TYPE_STRING:
 					var.s = val;
 					break;
 				default:

src/storagebackend.cpp

➞

Show inline comments

 #include "transport/storagebackend.h"
 #include "transport/config.h"
 #include "transport/sqlite3backend.h"
 #include "transport/mysqlbackend.h"
 #include "transport/pqxxbackend.h"
 #include "Swiften/Swiften.h"
 namespace Transport {
 StorageBackend *StorageBackend::createBackend(Config *config, std::string &error) {
 	StorageBackend *storageBackend = NULL;
 #ifdef WITH_SQLITE
 	if (CONFIG_STRING(config, "database.type") == "sqlite3" ||
 		(CONFIG_STRING(config, "database.type") == "none" && !CONFIG_BOOL(config, "service.server_mode"))) {
 	if (CONFIG_STRING(config, "database.type") == "sqlite3") {
 		storageBackend = new SQLite3Backend(config);
+	}
 #else
 	if (CONFIG_STRING(config, "database.type") == "sqlite3") {
 		error = "Libtransport is not compiled with sqlite3 backend support.";
+	}
 #endif
 #ifdef WITH_MYSQL
 	if (CONFIG_STRING(config, "database.type") == "mysql") {
 		storageBackend = new MySQLBackend(config);
+	}
 #else
 	if (CONFIG_STRING(config, "database.type") == "mysql") {
 		error = "Spectrum2 is not compiled with mysql backend support.";
+	}
 #endif
 #ifdef WITH_PQXX
 	if (CONFIG_STRING(config, "database.type") == "pqxx") {
 		storageBackend = new PQXXBackend(config);
+	}
 #else
 	if (CONFIG_STRING(config, "database.type") == "pqxx") {
 		error = "Spectrum2 is not compiled with pqxx backend support.";
+	}
 #endif
 	if (CONFIG_STRING(config, "database.type") != "mysql" && CONFIG_STRING(config, "database.type") != "sqlite3"
 		&& CONFIG_STRING(config, "database.type") != "pqxx" && CONFIG_STRING(config, "database.type") != "none") {
 		error = "Unknown storage backend " + CONFIG_STRING(config, "database.type");
+	}
 	return storageBackend;
+}
 std::string StorageBackend::encryptPassword(const std::string &password, const std::string &key) {
 	std::string encrypted;
 	encrypted.resize(password.size());
 	for (int i = 0; i < password.size(); i++) {
 		char c = password[i];
 		char keychar = key[i % key.size()];
 		c += keychar;
 		encrypted[i] = c;
+	}
 	encrypted = Swift::Base64::encode(Swift::createByteArray(encrypted));
 	return encrypted;
+}
 std::string StorageBackend::decryptPassword(std::string &encrypted, const std::string &key) {
 	encrypted = Swift::byteArrayToString(Swift::Base64::decode(encrypted));
 	std::string password;
 	password.resize(encrypted.size());
 	for (int i = 0; i < encrypted.size(); i++) {
 		char c = encrypted[i];
 		char keychar = key[i % key.size()];
 		c -= keychar;
 		password[i] = c;
+	}
 	return password;
+}
 std::string StorageBackend::serializeGroups(const std::vector<std::string> &groups) {
 	std::string ret;
 	BOOST_FOREACH(const std::string &group, groups) {
 		ret += group + "\n";
+	}
 	if (!ret.empty()) {
 		ret.erase(ret.end() - 1);
+	}
 	return ret;
+}
 std::vector<std::string> StorageBackend::deserializeGroups(std::string &groups) {
 	std::vector<std::string> ret;
 	if (groups.empty()) {
 		return ret;
+	}
 	boost::split(ret, groups, boost::is_any_of("\n"));
 	if (ret.back().empty()) {
 		ret.erase(ret.end() - 1);
+	}
 	return ret;
+}
+}

src/tests/basictest.cpp

➞

Show inline comments

@@ @@ -36,56 +36,56 @@ @@
 #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\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);
 	itemsResponder = new DiscoItemsResponder(component);
 	itemsResponder->start();
 	userManager = new UserManager(component, userRegistry, itemsResponder, 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(),
 	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(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() {
 	received.clear();
 	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

@@ @@ -46,50 +46,50 @@ @@
 #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);
 		Conversation *createConversation(ConversationManager *conversationManager, const std::string &legacyName, bool isMuc = false) {
 			TestingConversation *nc = new TestingConversation(conversationManager, legacyName, isMuc);
 			nc->onMessageToSend.connect(boost::bind(&TestingFactory::handleMessageToSend, this, _1, _2));
 			return nc;
+		}
 		void handleMessageToSend(TestingConversation *_conv, boost::shared_ptr<Swift::Message> &_msg) {
 			onMessageToSend(_conv, _msg);
+		}
 		// Creates new LocalBuddy
 		Buddy *createBuddy(RosterManager *rosterManager, const BuddyInfo &buddyInfo) {
 			LocalBuddy *buddy = new LocalBuddy(rosterManager, buddyInfo.id, buddyInfo.legacyName, buddyInfo.alias, buddyInfo.groups, (BuddyFlag) buddyInfo.flags);
 			if (!buddy->isValid()) {
 				delete buddy;
 				return NULL;
+			}
 			buddy->setSubscription(Buddy::Ask);
 			if (buddyInfo.settings.find("icon_hash") != buddyInfo.settings.end())
 				buddy->setIconHash(buddyInfo.settings.find("icon_hash")->second.s);
 			return buddy;
+		}
 		boost::signal<void (TestingConversation *, boost::shared_ptr<Swift::Message> &)> onMessageToSend;
 };
@@ @@ -204,48 +204,49 @@ class BasicTest : public Swift::XMPPParserClient { @@
 		void tearMeDown (void);
 	void handleDataReceived(const Swift::SafeByteArray &data);
 	void handleDataReceived2(const Swift::SafeByteArray &data);
 	void handleStreamStart(const Swift::ProtocolHeader&);
 	void handleElement(boost::shared_ptr<Swift::Element> element);
 	void handleStreamEnd();
 	void injectPresence(boost::shared_ptr<Swift::Presence> &response);
 	void injectIQ(boost::shared_ptr<Swift::IQ> iq);
 	void injectMessage(boost::shared_ptr<Swift::Message> msg);
 	void dumpReceived();
 	void addUser() {
 		UserInfo user;
 		user.id = 1;
 		user.jid = "user@localhost";
 		user.uin = "legacyname";
 		user.password = "password";
 		user.vip = 0;
 		storage->setUser(user);
+	}
 	void connectUser();
 	void connectSecondResource();
 	void disconnectUser();
 	void add2Buddies();
 	Swift::Stanza *getStanza(boost::shared_ptr<Swift::Element> element);
 	protected:
 		bool streamEnded;
 		UserManager *userManager;
 		boost::shared_ptr<Swift::ServerFromClientSession> serverFromClientSession;
 		boost::shared_ptr<Swift::ServerFromClientSession> serverFromClientSession2;
 		Swift::FullPayloadSerializerCollection* payloadSerializers;
 		Swift::FullPayloadParserFactoryCollection* payloadParserFactories;
 		Swift::XMPPParser *parser;
 		Swift::XMPPParser *parser2;
 		UserRegistry *userRegistry;
 		Config *cfg;
 		Swift::Server *server;
 		Swift::DummyNetworkFactories *factories;
 		Swift::DummyEventLoop *loop;

src/tests/conversationmanager.cpp

➞

Show inline comments

 		// 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);
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "#room", true);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 		conv->setNickname("nickname");
 		conv->addJID("user@localhost/resource");
 		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setSubject("subject");
 		msg->setType(Swift::Message::Groupchat);
 		// Forward it
 		conv->handleMessage(msg);
 		loop->processEvents();
 		// No response, because presence with code 110 has not been sent yet and we must not send
 		// subject before this one.
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		// this user presence - status code 110
 		conv->handleParticipantChanged("nickname", 1, Swift::StatusShow::Away, "my status message");
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(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());
 		CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[1])));
 		CPPUNIT_ASSERT_EQUAL(std::string("subject"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getSubject());
 		received.clear();
 		// send response
 		msg->setFrom("user@localhost/resource");
-		msg->setTo("buddy1@localhost/bot");
+		msg->setTo("#room@localhost");
 		injectMessage(msg);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT(m_msg);
 		CPPUNIT_ASSERT_EQUAL(std::string("subject"), m_msg->getSubject());
 		received.clear();
+	}
 	void handleNormalMessages() {
 		User *user = userManager->getUser("user@localhost");
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "buddy1");
+		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "buddy1@test");
 		user->getConversationManager()->addConversation(conv);
 		conv->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 		boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 		msg->setBody("hi there!");
+		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("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());
+		CPPUNIT_ASSERT_EQUAL(std::string("buddy1\\40test@localhost/bot"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getFrom().toString());
 		received.clear();
 		// send response
 		msg->setFrom("user@localhost/resource");
 		msg->setTo("buddy1@localhost/bot");
 		msg->setBody("response!");
 		msg->setTo("buddy1\\40test@localhost/bot");
 		msg->setBody("response<>!");
 		injectMessage(msg);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT(m_msg);
 		CPPUNIT_ASSERT_EQUAL(std::string("response!"), m_msg->getBody());
+		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());
+		CPPUNIT_ASSERT_EQUAL(std::string("buddy1\\40test@localhost/bot"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getFrom().toString());
 		received.clear();
 		// disable jid_escaping
 		std::istringstream ifs("service.server_mode = 1\nservice.jid_escaping=0\nservice.jid=localhost\nservice.more_resources=1\n");
 		cfg->load(ifs);
 		// and now to bare JID again...
 		user->getConversationManager()->resetResources();
 		conv->handleMessage(msg2);
 		loop->processEvents();
 		// enable jid_escaping again
 		std::istringstream ifs2("service.server_mode = 1\nservice.jid_escaping=1\nservice.jid=localhost\nservice.more_resources=1\n");
 		cfg->load(ifs2);
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(std::string("hi there!"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getBody());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("buddy1@localhost/bot"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getFrom().toString());
+		CPPUNIT_ASSERT_EQUAL(std::string("buddy1%test@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->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])));

src/tests/discoitemsresponder.cpp

➞

Show inline comments

@@ new file 100644 @@
 #include "transport/userregistry.h"
 #include "transport/userregistration.h"
 #include "transport/config.h"
 #include "transport/storagebackend.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/conversation.h"
 #include "transport/usermanager.h"
 #include "transport/localbuddy.h"
 #include "transport/settingsadhoccommand.h"
 #include "transport/adhocmanager.h"
 #include <cppunit/TestFixture.h>
 #include <cppunit/extensions/HelperMacros.h>
 #include <Swiften/Swiften.h>
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/Server/Server.h>
 #include <Swiften/Network/DummyNetworkFactories.h>
 #include <Swiften/Network/DummyConnectionServer.h>
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Server/ServerFromClientSession.h"
 #include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"
 #include "basictest.h"
 using namespace Transport;
 class DiscoItemsResponderTest : public CPPUNIT_NS :: TestFixture, public BasicTest {
 	CPPUNIT_TEST_SUITE(DiscoItemsResponderTest);
 	CPPUNIT_TEST(roomList);
 	CPPUNIT_TEST(roomInfo);
 	CPPUNIT_TEST(clearRooms);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		void setUp (void) {
 			setMeUp();
+		}
 		void tearDown (void) {
 			received.clear();
 			tearMeDown();
+		}
 	void roomList() {
 		itemsResponder->addRoom("#room@localhost", "#room");
 		boost::shared_ptr<Swift::DiscoItems> payload(new Swift::DiscoItems());
 		boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		iq->setFrom("user@localhost");
 		injectIQ(iq);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoItems>());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room@localhost"), getStanza(received[0])->getPayload<Swift::DiscoItems>()->getItems()[0].getJID().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room"), getStanza(received[0])->getPayload<Swift::DiscoItems>()->getItems()[0].getName());
+	}
 	void roomInfo() {
 		itemsResponder->addRoom("#room@localhost", "#room");
 		boost::shared_ptr<Swift::DiscoInfo> payload(new Swift::DiscoInfo());
 		boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		iq->setFrom("user@localhost");
 		iq->setTo("#room@localhost");
 		injectIQ(iq);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 		CPPUNIT_ASSERT_EQUAL(std::string("#room"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getName());
 		CPPUNIT_ASSERT_EQUAL(std::string("conference"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getCategory());
 		CPPUNIT_ASSERT_EQUAL(std::string("text"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getType());
+	}
 	void clearRooms() {
 		itemsResponder->addRoom("#room@localhost", "#room");
 		itemsResponder->clearRooms();
 		boost::shared_ptr<Swift::DiscoItems> payload(new Swift::DiscoItems());
 		boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 		iq->setFrom("user@localhost");
 		injectIQ(iq);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoItems>());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoItems>()->getItems().empty());
+	}
 };
 CPPUNIT_TEST_SUITE_REGISTRATION (DiscoItemsResponderTest);

src/tests/localbuddy.cpp

➞

Show inline comments

@@ @@ -4,93 +4,108 @@ @@
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/conversation.h"
 #include "transport/usermanager.h"
 #include "transport/localbuddy.h"
 #include <cppunit/TestFixture.h>
 #include <cppunit/extensions/HelperMacros.h>
 #include <Swiften/Swiften.h>
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/Server/Server.h>
 #include <Swiften/Network/DummyNetworkFactories.h>
 #include <Swiften/Network/DummyConnectionServer.h>
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Server/ServerFromClientSession.h"
 #include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"
 #include "basictest.h"
 using namespace Transport;
 class LocalBuddyTest : public CPPUNIT_NS :: TestFixture, public BasicTest {
 	CPPUNIT_TEST_SUITE(LocalBuddyTest);
 	CPPUNIT_TEST(createWithInvalidName);
 	CPPUNIT_TEST(buddyFlagsFromJID);
 	CPPUNIT_TEST(JIDToLegacyName);
 	CPPUNIT_TEST(getSafeName);
 	CPPUNIT_TEST(handleBuddyChanged);
 	CPPUNIT_TEST(setAlias);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		void setUp (void) {
 			setMeUp();
 			connectUser();
 			received.clear();
+		}
 		void tearDown (void) {
 			received.clear();
 			disconnectUser();
 			tearMeDown();
+		}
 	void createWithInvalidName() {
 		User *user = userManager->getUser("user@localhost");
 		CPPUNIT_ASSERT(user);
 		std::vector<std::string> grp;
 		grp.push_back("group");
 		// with BUDDY_JID_ESCAPING it escapes /
 		LocalBuddy *buddy = new LocalBuddy(user->getRosterManager(), -1, "msn/something", "Buddy 1", grp, BUDDY_JID_ESCAPING);
 		CPPUNIT_ASSERT(buddy->isValid());
 		CPPUNIT_ASSERT_EQUAL(std::string("msn\\2fsomething@localhost/bot"), buddy->getJID().toString());
 		delete buddy;
 		// without BUDDY_JID_ESCAPING it shoudl fail
 		buddy = new LocalBuddy(user->getRosterManager(), -1, "msn/something", "Buddy 1", grp);
 		CPPUNIT_ASSERT(!buddy->isValid());
 		delete buddy;
 		buddy = new LocalBuddy(user->getRosterManager(), -1, "\xd7\x92\xd7\x9c\xd7\x99\xd7\x9d@nimbuzz.com", "Buddy 1", grp);
 		CPPUNIT_ASSERT(!buddy->isValid());
 		delete buddy;
+	}
 	void JIDToLegacyName() {
 		CPPUNIT_ASSERT_EQUAL(std::string("hanzz@test"), Buddy::JIDToLegacyName("hanzz\\40test@localhost/bot"));
 		CPPUNIT_ASSERT_EQUAL(std::string("hanzz@test"), Buddy::JIDToLegacyName("hanzz%test@localhost/bot"));
+	}
 	void getSafeName() {
 		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@test", "Buddy 1", grp, BUDDY_JID_ESCAPING);
 		CPPUNIT_ASSERT_EQUAL(std::string("buddy1\\40test"), buddy->getSafeName());
 		buddy->setFlags(BUDDY_NO_FLAG);
 		CPPUNIT_ASSERT_EQUAL(std::string("buddy1%test"), buddy->getSafeName());
+	}
 	void buddyFlagsFromJID() {
 		CPPUNIT_ASSERT_EQUAL(BUDDY_JID_ESCAPING, Buddy::buddyFlagsFromJID("hanzz\\40test@localhost/bot"));
 		CPPUNIT_ASSERT_EQUAL(BUDDY_NO_FLAG, Buddy::buddyFlagsFromJID("hanzz%test@localhost/bot"));
+	}
 	void handleBuddyChanged() {
 		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);
 		received.clear();
 		buddy->handleBuddyChanged();
 		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("status1"), dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getStatus());
+	}
 	void setAlias() {

src/tests/main.cpp

➞

Show inline comments

 #include "main.h"
 #include <cppunit/CompilerOutputter.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 #include <cppunit/TestResult.h>
 #include <cppunit/TestResultCollector.h>
 #include <cppunit/TestRunner.h>
 #include <cppunit/BriefTestProgressListener.h>
 #ifdef WITH_LOG4CXX
 #include "log4cxx/logger.h"
 #include "log4cxx/fileappender.h"
 #include "log4cxx/patternlayout.h"
 #include "log4cxx/propertyconfigurator.h"
 using namespace log4cxx;
 #endif
 int main (int argc, char* argv[])
+{
 #ifdef WITH_LOG4CXX
 	LoggerPtr root = Logger::getRootLogger();
 	root->addAppender(new FileAppender(new PatternLayout("%d %-5p %c: %m%n"), "libtransport_test.log", false));
 #endif
 	std::vector<std::string> testsToRun;
 	for (int i = 1; i < argc; ++i) {
 		std::string param(argv[i]);
 		testsToRun.push_back(param);
+	}
 	if (testsToRun.empty()) {
 		testsToRun.push_back("");
+	}
 	// informs test-listener about testresults
 	CPPUNIT_NS :: TestResult testresult;
 	// register listener for collecting the test-results
 	CPPUNIT_NS :: TestResultCollector collectedresults;
 	testresult.addListener (&collectedresults);
 	// register listener for per-test progress output
 	CPPUNIT_NS :: BriefTestProgressListener progress;
 	testresult.addListener (&progress);
 	// insert test-suite at test-runner by registry
 	CPPUNIT_NS :: TestRunner testrunner;
 	testrunner.addTest (CPPUNIT_NS :: TestFactoryRegistry :: getRegistry ().makeTest ());
 	testrunner.run (testresult);
 	for (std::vector<std::string>::const_iterator i = testsToRun.begin(); i != testsToRun.end(); ++i) {
 		try {
 			testrunner.run(testresult, *i);
+		}
 		catch (const std::exception& e) {
 			std::cerr << "Error: " << e.what() << std::endl;
 			return -1;
+		}
+	}
 	// output results in compiler-format
 	CPPUNIT_NS :: CompilerOutputter compileroutputter (&collectedresults, std::cerr);
 	compileroutputter.write ();
 	// return 0 if tests were successful
 	return collectedresults.wasSuccessful () ? 0 : 1;
+}

src/tests/networkpluginserver.cpp

➞

Show inline comments

@@ new file 100644 @@
 #include "transport/userregistry.h"
 #include "transport/userregistration.h"
 #include "transport/config.h"
 #include "transport/storagebackend.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/conversation.h"
 #include "transport/usermanager.h"
 #include "transport/localbuddy.h"
 #include "transport/settingsadhoccommand.h"
 #include "transport/adhocmanager.h"
 #include "transport/protocol.pb.h"
 #include "transport/networkpluginserver.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 NetworkPluginServerTest : public CPPUNIT_NS :: TestFixture, public BasicTest {
 	CPPUNIT_TEST_SUITE(NetworkPluginServerTest);
 	CPPUNIT_TEST(handleBuddyChangedPayload);
 	CPPUNIT_TEST(handleBuddyChangedPayloadNoEscaping);
 	CPPUNIT_TEST(handleBuddyChangedPayloadUserContactInRoster);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		NetworkPluginServer *serv;
 		void setUp (void) {
 			setMeUp();
 			serv = new NetworkPluginServer(component, cfg, userManager, NULL, NULL);
 			connectUser();
 			received.clear();
+		}
 		void tearDown (void) {
 			received.clear();
 			disconnectUser();
 			delete serv;
 			tearMeDown();
+		}
 		void handleBuddyChangedPayload() {
 			User *user = userManager->getUser("user@localhost");
 			pbnetwork::Buddy buddy;
 			buddy.set_username("user@localhost");
 			buddy.set_buddyname("buddy1@test");
 			std::string message;
 			buddy.SerializeToString(&message);
 			serv->handleBuddyChangedPayload(message);
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			Swift::RosterPayload::ref payload1 = getStanza(received[0])->getPayload<Swift::RosterPayload>();
 			CPPUNIT_ASSERT_EQUAL(1, (int) payload1->getItems().size());
 			Swift::RosterItemPayload item = payload1->getItems()[0];
 			CPPUNIT_ASSERT_EQUAL(std::string("buddy1\\40test@localhost"), item.getJID().toString());
+		}
 		void handleBuddyChangedPayloadNoEscaping() {
 			std::istringstream ifs("service.server_mode = 1\nservice.jid_escaping=0\nservice.jid=localhost\nservice.more_resources=1\n");
 			cfg->load(ifs);
 			User *user = userManager->getUser("user@localhost");
 			pbnetwork::Buddy buddy;
 			buddy.set_username("user@localhost");
 			buddy.set_buddyname("buddy1@test");
 			std::string message;
 			buddy.SerializeToString(&message);
 			serv->handleBuddyChangedPayload(message);
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			Swift::RosterPayload::ref payload1 = getStanza(received[0])->getPayload<Swift::RosterPayload>();
 			CPPUNIT_ASSERT_EQUAL(1, (int) payload1->getItems().size());
 			Swift::RosterItemPayload item = payload1->getItems()[0];
 			CPPUNIT_ASSERT_EQUAL(std::string("buddy1%test@localhost"), item.getJID().toString());
 			std::istringstream ifs2("service.server_mode = 1\nservice.jid_escaping=1\nservice.jid=localhost\nservice.more_resources=1\n");
 			cfg->load(ifs2);
+		}
 		void handleBuddyChangedPayloadUserContactInRoster() {
 			User *user = userManager->getUser("user@localhost");
 			pbnetwork::Buddy buddy;
 			buddy.set_username("user@localhost");
 			buddy.set_buddyname("user");
 			std::string message;
 			buddy.SerializeToString(&message);
 			serv->handleBuddyChangedPayload(message);
 			CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
+		}
 };
 CPPUNIT_TEST_SUITE_REGISTRATION (NetworkPluginServerTest);

src/tests/rosterresponder.cpp

➞

Show inline comments

@@ new file 100644 @@
 #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/rosterresponder.h"
 #include "transport/usermanager.h"
 #include "transport/localbuddy.h"
 #include <cppunit/TestFixture.h>
 #include <cppunit/extensions/HelperMacros.h>
 #include <Swiften/Swiften.h>
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/Server/Server.h>
 #include <Swiften/Network/DummyNetworkFactories.h>
 #include <Swiften/Network/DummyConnectionServer.h>
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Server/ServerFromClientSession.h"
 #include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"
 #include "basictest.h"
 using namespace Transport;
 class RosterResponderTest : public CPPUNIT_NS :: TestFixture, public BasicTest {
 	CPPUNIT_TEST_SUITE(RosterResponderTest);
 	CPPUNIT_TEST(addEmptyBuddy);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		RosterResponder *m_rosterResponder;
 		std::string m_buddy;
 		void setUp (void) {
 			m_buddy = "none";
 			setMeUp();
 			connectUser();
 			m_rosterResponder = new RosterResponder(component->getIQRouter(), userManager);
 			m_rosterResponder->onBuddyAdded.connect(boost::bind(&RosterResponderTest::handleBuddyAdded, this, _1, _2));
 			m_rosterResponder->onBuddyRemoved.connect(boost::bind(&RosterResponderTest::handleBuddyRemoved, this, _1));
 			m_rosterResponder->onBuddyUpdated.connect(boost::bind(&RosterResponderTest::handleBuddyUpdated, this, _1, _2));
 			m_rosterResponder->start();
 			received.clear();
+		}
 		void tearDown (void) {
 			received.clear();
 			disconnectUser();
 			tearMeDown();
+		}
 	void handleBuddyAdded(Buddy *buddy, const Swift::RosterItemPayload &item) {
 		m_buddy = buddy->getName();
+	}
 	void handleBuddyRemoved(Buddy *buddy) {
 		m_buddy = buddy->getName();
+	}
 	void handleBuddyUpdated(Buddy *buddy, const Swift::RosterItemPayload &item) {
 		m_buddy = buddy->getName();
+	}
 	void addEmptyBuddy() {
 		Swift::RosterPayload::ref p = Swift::RosterPayload::ref(new Swift::RosterPayload());
 		Swift::RosterItemPayload item;
 		item.setJID("icq.localhost");
 		item.setSubscription(Swift::RosterItemPayload::Both);
 		p->addItem(item);
 		Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(p, "user@localhost", component->getIQRouter());
 		boost::shared_ptr<Swift::IQ> iq(new Swift::IQ(Swift::IQ::Set));
 		iq->setTo("icq.localhost");
 		iq->setFrom("user@localhost");
 		iq->addPayload(p);
 		iq->setID("123");
 		injectIQ(iq);
 		CPPUNIT_ASSERT_EQUAL(std::string("none"), m_buddy);
+	}
 };
 CPPUNIT_TEST_SUITE_REGISTRATION (RosterResponderTest);

src/tests/settingsadhoccommand.cpp

➞

Show inline comments

@@ @@ -5,92 +5,109 @@ @@
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/conversation.h"
 #include "transport/usermanager.h"
 #include "transport/localbuddy.h"
 #include "transport/settingsadhoccommand.h"
 #include "transport/adhocmanager.h"
 #include <cppunit/TestFixture.h>
 #include <cppunit/extensions/HelperMacros.h>
 #include <Swiften/Swiften.h>
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/Server/Server.h>
 #include <Swiften/Network/DummyNetworkFactories.h>
 #include <Swiften/Network/DummyConnectionServer.h>
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Server/ServerFromClientSession.h"
 #include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"
 #include "basictest.h"
 using namespace Transport;
 class SettingsAdHocCommandTest : public CPPUNIT_NS :: TestFixture, public BasicTest {
 	CPPUNIT_TEST_SUITE(SettingsAdHocCommandTest);
 	CPPUNIT_TEST(getItems);
 	CPPUNIT_TEST(getInfo);
 	CPPUNIT_TEST(execute);
 	CPPUNIT_TEST(executeBadSessionID);
 	CPPUNIT_TEST(executeNotRegistered);
 	CPPUNIT_TEST(cancel);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		AdHocManager *adhoc;
 		SettingsAdHocCommandFactory *settings;
 		void setUp (void) {
 			setMeUp();
 			adhoc = new AdHocManager(component, itemsResponder, userManager, storage);
 			adhoc->start();
 			settings = new SettingsAdHocCommandFactory();
 			adhoc->addAdHocCommand(settings);
 			received.clear();
+		}
 		void tearDown (void) {
 			received.clear();
 			delete adhoc;
 			delete settings;
 			tearMeDown();
+		}
 		void getItems() {
 			boost::shared_ptr<Swift::DiscoItems> payload(new Swift::DiscoItems());
 			payload->setNode("http://jabber.org/protocol/commands");
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoItems>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::DiscoItems>()->getItems()[0].getNode());
+		}
 		void getInfo() {
 			boost::shared_ptr<Swift::DiscoInfo> payload(new Swift::DiscoInfo());
 			payload->setNode("settings");
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 			CPPUNIT_ASSERT_EQUAL(std::string("automation"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getCategory());
 			CPPUNIT_ASSERT_EQUAL(std::string("command-node"), getStanza(received[0])->getPayload<Swift::DiscoInfo>()->getIdentities()[0].getType());
+		}
 		void executeNotRegistered() {
 			boost::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::Command>());
 			CPPUNIT_ASSERT_EQUAL(std::string("settings"), getStanza(received[0])->getPayload<Swift::Command>()->getNode());
 			CPPUNIT_ASSERT_EQUAL(Swift::Command::Completed, getStanza(received[0])->getPayload<Swift::Command>()->getStatus());
+		}
 		void execute() {
 			addUser();
 			boost::shared_ptr<Swift::Command> payload(new Swift::Command("settings"));
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", payload);
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();

src/tests/stringtreeparser.cpp

➞

Show inline comments

@@ new file 100644 @@
 #include "transport/userregistry.h"
 #include "transport/config.h"
 #include "transport/storagebackend.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/storagebackend.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/Parser/StringTreeParser.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 StringTreeParserTest : public CPPUNIT_NS :: TestFixture{
 	CPPUNIT_TEST_SUITE(StringTreeParserTest);
 	CPPUNIT_TEST(parseEscapedCharacters);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		void setUp (void) {
+		}
 		void tearDown (void) {
+		}
 	void parseEscapedCharacters() {
 		Swift::ParserElement::ref root = Swift::StringTreeParser::parse("<body>&lt;test&gt;</body>");
 		CPPUNIT_ASSERT_EQUAL(std::string("<test>"), root->getText());
+	}
 };
 CPPUNIT_TEST_SUITE_REGISTRATION (StringTreeParserTest);

src/tests/user.cpp

➞

Show inline comments

@@ @@ -9,50 +9,52 @@ @@
 #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 UserTest : public CPPUNIT_NS :: TestFixture, public BasicTest {
 	CPPUNIT_TEST_SUITE(UserTest);
 	CPPUNIT_TEST(sendCurrentPresence);
     CPPUNIT_TEST(handlePresence);
 	CPPUNIT_TEST(handlePresenceJoinRoom);
 	CPPUNIT_TEST(handlePresenceJoinRoomTwoResources);
 	CPPUNIT_TEST(handlePresenceLeaveRoom);
 	CPPUNIT_TEST(handlePresenceLeaveRoomTwoResources);
 	CPPUNIT_TEST(handlePresenceLeaveRoomTwoResourcesOneDisconnects);
 	CPPUNIT_TEST(leaveJoinedRoom);
 	CPPUNIT_TEST(joinRoomBeforeConnected);
 	CPPUNIT_TEST(handleDisconnected);
 	CPPUNIT_TEST(handleDisconnectedReconnect);
 	CPPUNIT_TEST(joinRoomHandleDisconnectedRejoin);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		std::string room;
 		std::string roomNickname;
 		std::string roomPassword;
 		bool readyToConnect;
 		bool disconnected;
 		Swift::Presence::ref changedPresence;
 		void setUp (void) {
 			disconnected = false;
 			readyToConnect = false;
 			changedPresence = Swift::Presence::ref();
 			room = "";
 			roomNickname = "";
 			roomPassword = "";
 			setMeUp();
 			userManager->onUserCreated.connect(boost::bind(&UserTest::handleUserCreated, this, _1));
 			connectUser();
 			received.clear();
+		}
 		CPPUNIT_ASSERT(streamEnded);
 		user = userManager->getUser("user@localhost");
 		CPPUNIT_ASSERT(!user);
 		CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 		Swift::Message *m = dynamic_cast<Swift::Message *>(getStanza(received[0]));
 		CPPUNIT_ASSERT_EQUAL(std::string("Connection error"), m->getBody());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::StreamError *>(received[1].get()));
 		CPPUNIT_ASSERT_EQUAL(std::string("Connection error"), dynamic_cast<Swift::StreamError *>(received[1].get())->getText());
 		disconnected = true;
+	}
 	void handleDisconnectedReconnect() {
 		readyToConnect = false;
 		User *user = userManager->getUser("user@localhost");
 		user->handleDisconnected("Connection error");
 		loop->processEvents();
 		CPPUNIT_ASSERT(!streamEnded);
 		user = userManager->getUser("user@localhost");
 		CPPUNIT_ASSERT(user);
 		CPPUNIT_ASSERT(readyToConnect);
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("localhost");
 		response->setFrom("user@localhost/resource");
 		injectPresence(response);
 		loop->processEvents();
+	}
 	void joinRoomBeforeConnected() {
 		User *user = userManager->getUser("user@localhost");
 		user->setConnected(false);
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("#room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		// no presence received in server mode, just disco#info
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		user->setConnected(true);
 		CPPUNIT_ASSERT_EQUAL(std::string("#room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string("hanzz"), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string("password"), roomPassword);
+	}
 	void joinRoomHandleDisconnectedRejoin() {
 		User *user = userManager->getUser("user@localhost");
 		handlePresenceJoinRoom();
 		handleDisconnectedReconnect();
 		room = "";
 		roomNickname = "";
 		roomPassword = "";
 		received.clear();
 		user->setConnected(true);
 		CPPUNIT_ASSERT_EQUAL(std::string("#room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string("hanzz"), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string("password"), roomPassword);
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
+	}
 };
 CPPUNIT_TEST_SUITE_REGISTRATION (UserTest);

src/tests/usermanager.cpp

➞

Show inline comments

@@ @@ -6,103 +6,180 @@ @@
 #include "transport/conversation.h"
 #include "transport/usermanager.h"
 #include "transport/localbuddy.h"
 #include <cppunit/TestFixture.h>
 #include <cppunit/extensions/HelperMacros.h>
 #include <Swiften/Swiften.h>
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/Server/Server.h>
 #include <Swiften/Network/DummyNetworkFactories.h>
 #include <Swiften/Network/DummyConnectionServer.h>
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Server/ServerFromClientSession.h"
 #include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"
 #include "basictest.h"
 using namespace Transport;
 class UserManagerTest : public CPPUNIT_NS :: TestFixture, public BasicTest {
 	CPPUNIT_TEST_SUITE(UserManagerTest);
 	CPPUNIT_TEST(connectUser);
 	CPPUNIT_TEST(connectTwoResources);
 	CPPUNIT_TEST(connectUserTransportDisabled);
 	CPPUNIT_TEST(connectUserRegistrationNeeded);
 	CPPUNIT_TEST(connectUserRegistrationNeededRegistered);
 	CPPUNIT_TEST(connectUserVipOnlyNonVip);
 	CPPUNIT_TEST(handleProbePresence);
 	CPPUNIT_TEST(disconnectUser);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		void setUp (void) {
 			setMeUp();
+		}
 		void tearDown (void) {
 			tearMeDown();
+		}
 	void connectUserTransportDisabled() {
 		addUser();
 		storage->updateUserSetting(1, "enable_transport", "0");
 		CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());
 		userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource"), serverFromClientSession.get(), Swift::createSafeByteArray("password"));
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());
 		User *user = userManager->getUser("user@localhost");
 		CPPUNIT_ASSERT(!user);
+	}
 	void connectUserRegistrationNeeded() {
 		cfg->updateBackendConfig("[registration]\nneedRegistration=1\n");
 		CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());
 		userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource"), serverFromClientSession.get(), Swift::createSafeByteArray("password"));
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());
 		CPPUNIT_ASSERT(streamEnded);
+	}
 	void connectUserRegistrationNeededRegistered() {
 		addUser();
 		cfg->updateBackendConfig("[registration]\nneedRegistration=1\n");
 		CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());
 		userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource"), serverFromClientSession.get(), Swift::createSafeByteArray("password"));
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, userManager->getUserCount());
 		CPPUNIT_ASSERT(!streamEnded);
+	}
 	void connectUserVipOnlyNonVip() {
 		addUser();
 		std::istringstream ifs("service.server_mode = 1\nservice.jid_escaping=0\nservice.jid=localhost\nservice.vip_only=1\nservice.vip_message=Ahoj\n");
 		cfg->load(ifs);
 		CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());
 		userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource"), serverFromClientSession.get(), Swift::createSafeByteArray("password"));
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(3, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[1])));
 		CPPUNIT_ASSERT_EQUAL(std::string("Ahoj"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getBody());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("localhost"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getFrom().toString());
 		CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());
 		CPPUNIT_ASSERT(streamEnded);
 		std::istringstream ifs2("service.server_mode = 1\nservice.jid_escaping=1\nservice.jid=localhost\nservice.more_resources=1\n");
 		cfg->load(ifs2);
+	}
 	void handleProbePresence() {
 		UserInfo info;
 		info.id = 1;
 		info.jid = "user@localhost";
 		storage->setUser(info);
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("localhost");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Probe);
 		dynamic_cast<Swift::ServerStanzaChannel *>(component->getStanzaChannel())->onPresenceReceived(response);
 		loop->processEvents();
-		CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
+		CPPUNIT_ASSERT_EQUAL(3, (int) received.size());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 		Swift::Presence *presence = dynamic_cast<Swift::Presence *>(getStanza(received[1]));
 		CPPUNIT_ASSERT(presence);
 		CPPUNIT_ASSERT_EQUAL(Swift::Presence::Unavailable, presence->getType());
 		presence = dynamic_cast<Swift::Presence *>(getStanza(received[2]));
 		CPPUNIT_ASSERT(presence);
 		CPPUNIT_ASSERT_EQUAL(Swift::Presence::Probe, presence->getType());
 		received.clear();
 		response = Swift::Presence::create();
 		response->setTo("localhost");
 		response->setFrom("user@localhost");
 		response->setType(Swift::Presence::Unsubscribed);
 		dynamic_cast<Swift::ServerStanzaChannel *>(component->getStanzaChannel())->onPresenceReceived(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 		presence = dynamic_cast<Swift::Presence *>(getStanza(received[1]));
 		CPPUNIT_ASSERT(presence);
 		CPPUNIT_ASSERT_EQUAL(Swift::Presence::Subscribe, presence->getType());
 		received.clear();
 		response = Swift::Presence::create();
 		response->setTo("localhost");
 		response->setFrom("user@localhost");
 		response->setType(Swift::Presence::Error);
 		dynamic_cast<Swift::ServerStanzaChannel *>(component->getStanzaChannel())->onPresenceReceived(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		response = Swift::Presence::create();
 		response->setTo("localhost");
 		response->setFrom("user@localhost");
 		response->setType(Swift::Presence::Error);
 		response->addPayload(boost::shared_ptr<Swift::ErrorPayload>(new Swift::ErrorPayload(Swift::ErrorPayload::SubscriptionRequired)));
 		dynamic_cast<Swift::ServerStanzaChannel *>(component->getStanzaChannel())->onPresenceReceived(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		presence = dynamic_cast<Swift::Presence *>(getStanza(received[0]));
 		CPPUNIT_ASSERT(presence);
 		CPPUNIT_ASSERT_EQUAL(Swift::Presence::Subscribe, presence->getType());
 		storage->removeUser(1);
 		received.clear();
 		response = Swift::Presence::create();
 		response->setTo("localhost");
 		response->setFrom("user@localhost");
 		response->setType(Swift::Presence::Unsubscribed);
 		dynamic_cast<Swift::ServerStanzaChannel *>(component->getStanzaChannel())->onPresenceReceived(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
+	}
 	void connectTwoResources() {
 		connectUser();
 		add2Buddies();
 		connectSecondResource();
 		// we should get presences
 		CPPUNIT_ASSERT_EQUAL(4, (int) received2.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received2[2])));
 		CPPUNIT_ASSERT_EQUAL(Swift::StatusShow::Away, dynamic_cast<Swift::Presence *>(getStanza(received2[2]))->getShow());
 		CPPUNIT_ASSERT_EQUAL(std::string("status1"), dynamic_cast<Swift::Presence *>(getStanza(received2[2]))->getStatus());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received2[3])));
 		CPPUNIT_ASSERT_EQUAL(Swift::StatusShow::Away, dynamic_cast<Swift::Presence *>(getStanza(received2[3]))->getShow());
 		CPPUNIT_ASSERT_EQUAL(std::string("status2"), dynamic_cast<Swift::Presence *>(getStanza(received2[3]))->getStatus());
+	}
 };
 CPPUNIT_TEST_SUITE_REGISTRATION (UserManagerTest);

src/tests/util.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/storagebackend.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 UtilTest : public CPPUNIT_NS :: TestFixture{
 	CPPUNIT_TEST_SUITE(UtilTest);
 	CPPUNIT_TEST(encryptDecryptPassword);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		void setUp (void) {
+		}
 		void tearDown (void) {
+		}
 	void encryptDecryptPassword() {
 		std::string encrypted = Util::encryptPassword("password", "key");
 		CPPUNIT_ASSERT_EQUAL(std::string("password"), Util::decryptPassword(encrypted, "key"));
 		std::string encrypted = StorageBackend::encryptPassword("password", "key");
 		CPPUNIT_ASSERT_EQUAL(std::string("password"), StorageBackend::decryptPassword(encrypted, "key"));
+	}
 };
 CPPUNIT_TEST_SUITE_REGISTRATION (UtilTest);

src/transport.cpp

➞

Show inline comments

@@ @@ -5,49 +5,48 @@ @@
+ *
  * 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/transport.h"
 #include <boost/bind.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 #include <boost/algorithm/string/predicate.hpp>
 #include "transport/storagebackend.h"
 #include "transport/factory.h"
 #include "transport/userregistry.h"
 #include "transport/logging.h"
 #include "discoinforesponder.h"
 #include "storageparser.h"
 #ifdef _WIN32
 #include <Swiften/TLS/CAPICertificate.h>
 #include "Swiften/TLS/Schannel/SchannelServerContext.h"
 #include "Swiften/TLS/Schannel/SchannelServerContextFactory.h"
 #else
 #include "Swiften/TLS/PKCS12Certificate.h"
 #include "Swiften/TLS/CertificateWithKey.h"
 #include "Swiften/TLS/OpenSSL/OpenSSLServerContext.h"
 #include "Swiften/TLS/OpenSSL/OpenSSLServerContextFactory.h"
 #endif
 #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"
 		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::StatsParser>("query", "http://jabber.org/protocol/stats"));
 		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::GatewayPayloadParser>("query", "jabber:iq:gateway"));
 		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::MUCPayloadParser>("x", "http://jabber.org/protocol/muc"));
 		m_component->addPayloadSerializer(new Swift::AttentionSerializer());
 		m_component->addPayloadSerializer(new Swift::XHTMLIMSerializer());
 		m_component->addPayloadSerializer(new Transport::BlockSerializer());
 		m_component->addPayloadSerializer(new Swift::InvisibleSerializer());
 		m_component->addPayloadSerializer(new Swift::StatsSerializer());
 		m_component->addPayloadSerializer(new Swift::SpectrumErrorSerializer());
 		m_component->addPayloadSerializer(new Swift::GatewayPayloadSerializer());
 		m_stanzaChannel = m_component->getStanzaChannel();
 		m_iqRouter = m_component->getIQRouter();
+	}
 	m_capsMemoryStorage = new CapsMemoryStorage();
 	m_capsManager = new CapsManager(m_capsMemoryStorage, m_stanzaChannel, m_iqRouter);
 	m_entityCapsManager = new EntityCapsManager(m_capsManager, m_stanzaChannel);
  	m_entityCapsManager->onCapsChanged.connect(boost::bind(&Component::handleCapsChanged, this, _1));
 	m_presenceOracle = new Transport::PresenceOracle(m_stanzaChannel);
 	m_presenceOracle->onPresenceChange.connect(bind(&Component::handlePresence, this, _1));
 	m_discoInfoResponder = new DiscoInfoResponder(m_iqRouter, m_config);
 	m_discoInfoResponder->start();
 //
 // 	m_registerHandler = new SpectrumRegisterHandler(m_component);
 // 	m_registerHandler->start();
+}
 Component::~Component() {
 	delete m_presenceOracle;
 	delete m_entityCapsManager;
 	delete m_capsManager;
 	delete m_capsMemoryStorage;
 	delete m_discoInfoResponder;
 	if (m_component)
 		delete m_component;
 	if (m_server) {
 		m_server->stop();
 		delete m_server;
+	}
+}
 Swift::StanzaChannel *Component::getStanzaChannel() {
 	return m_stanzaChannel;
+}
 Transport::PresenceOracle *Component::getPresenceOracle() {
 	return m_presenceOracle;
+}
 void Component::setTransportFeatures(std::list<std::string> &features) {
 	m_discoInfoResponder->setTransportFeatures(features);
+}
 Swift::CapsInfo &Component::getBuddyCapsInfo() {
 		return m_discoInfoResponder->getBuddyCapsInfo();
+}
 void Component::setBuddyFeatures(std::list<std::string> &features) {
 	// TODO: handle caps change
 	m_discoInfoResponder->setBuddyFeatures(features);
+}
 void Component::start() {
 	if (m_component && !m_component->isAvailable()) {
 		LOG4CXX_INFO(logger, "Connecting XMPP server " << CONFIG_STRING(m_config, "service.server") << " port " << CONFIG_INT(m_config, "service.port"));
 		if (CONFIG_INT(m_config, "service.port") == 5222) {
 			LOG4CXX_WARN(logger, "Port 5222 is usually used for client connections, not for component connections! Are you sure you are using right port?");
+		}
 		m_reconnectCount++;
 		m_component->connect(CONFIG_STRING(m_config, "service.server"), CONFIG_INT(m_config, "service.port"));
 		m_reconnectTimer->stop();
+	}
 	else if (m_server) {
 		LOG4CXX_INFO(logger, "Starting component in server mode on port " << CONFIG_INT(m_config, "service.port"));
 		m_server->start();
 		//Type casting to BoostConnectionServer since onStopped signal is not defined in ConnectionServer
 		//Ideally, onStopped must be defined in ConnectionServer
 		if (boost::dynamic_pointer_cast<Swift::BoostConnectionServer>(m_server->getConnectionServer())) {
 			boost::dynamic_pointer_cast<Swift::BoostConnectionServer>(m_server->getConnectionServer())->onStopped.connect(boost::bind(&Component::handleServerStopped, this, _1));
+		}
 		// We're connected right here, because we're in server mode...
 		handleConnected();
+	}
+}
+}
 void Component::handleDataRead(const Swift::SafeByteArray &data) {
 	std::string d = safeByteArrayToString(data);
 	if (!boost::starts_with(d, "<auth")) {
 		LOG4CXX_INFO(logger_xml, "XML IN " << d);
+	}
+}
 void Component::handleDataWritten(const Swift::SafeByteArray &data) {
 	LOG4CXX_INFO(logger_xml, "XML OUT " << safeByteArrayToString(data));
+}
 void Component::handlePresence(Swift::Presence::ref presence) {
 	bool isMUC = presence->getPayload<MUCPayload>() != NULL || *presence->getTo().getNode().c_str() == '#';
 	// filter out login/logout presence spam
 	if (!presence->getTo().getNode().empty() && isMUC == false)
 		return;
 	// filter out bad presences
 	if (!presence->getFrom().isValid()) {
 		return;
+	}
 	if (presence->getType() == Presence::Error) {
 		return;
+	}
 	switch (presence->getType()) {
 		case Presence::Error:
 		case Presence::Subscribe:
 		case Presence::Subscribed:
 		case Presence::Unsubscribe:
 		case Presence::Unsubscribed:
 			return;
 		default:
 			break;
 	};
 	// check if we have this client's capabilities and ask for them
 	if (presence->getType() != Swift::Presence::Unavailable) {
 		boost::shared_ptr<CapsInfo> capsInfo = presence->getPayload<CapsInfo>();
 		if (capsInfo && capsInfo->getHash() == "sha-1") {
 			/*haveFeatures = */m_entityCapsManager->getCaps(presence->getFrom()) != DiscoInfo::ref();
+		}
 #ifdef SUPPORT_LEGACY_CAPS
 		else {
 			GetDiscoInfoRequest::ref discoInfoRequest = GetDiscoInfoRequest::create(presence->getFrom(), m_iqRouter);
 			discoInfoRequest->onResponse.connect(boost::bind(&Component::handleDiscoInfoResponse, this, _1, _2, presence->getFrom()));
 			discoInfoRequest->send();
+		}
 #endif
+	}
 	onUserPresenceReceived(presence);
+}
 void Component::handleDiscoInfoResponse(boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid) {
 #ifdef SUPPORT_LEGACY_CAPS
 	onUserDiscoInfoReceived(jid, info);
 #endif
+}

src/user.cpp

➞

Show inline comments

@@ @@ -155,131 +155,172 @@ void User::sendCurrentPresence() { @@
 				response->setTo(presence->getFrom());
 				response->setFrom(m_component->getJID());
 				response->setType(Swift::Presence::Unavailable);
 				m_component->getStanzaChannel()->sendPresence(response);
+			}
+		}
 		else {
 			Swift::Presence::ref response = Swift::Presence::create();
 			response->setTo(presence->getFrom());
 			response->setFrom(m_component->getJID());
 			response->setType(Swift::Presence::Unavailable);
 			response->setStatus("Connecting");
 			m_component->getStanzaChannel()->sendPresence(response);
+		}
+	}
+}
 void User::setConnected(bool connected) {
 	m_connected = connected;
 	m_reconnectCounter = 0;
 	setIgnoreDisconnect(false);
 	updateLastActivity();
 	sendCurrentPresence();
 	if (m_connected) {
 		BOOST_FOREACH(Swift::Presence::ref &presence, m_joinedRooms) {
 			handlePresence(presence, true);
+		}
+	}
+}
 void User::handlePresence(Swift::Presence::ref presence) {
+void User::handlePresence(Swift::Presence::ref presence, bool forceJoin) {
 	int currentResourcesCount = m_presenceOracle->getAllPresence(m_jid).size();
 	m_conversationManager->resetResources();
 	LOG4CXX_INFO(logger, "PRESENCE " << presence->getFrom().toString() << " " << presence->getTo().toString());
 	if (!m_connected) {
 		// we are not connected to legacy network, so we should do it when disco#info arrive :)
 		if (m_readyForConnect == false) {
 			// Forward status message to legacy network, but only if it's sent from active resource
 // 					if (m_activeResource == presence->getFrom().getResource().getUTF8String()) {
 // 						forwardStatus(presenceShow, stanzaStatus);
 // 					}
 			boost::shared_ptr<Swift::CapsInfo> capsInfo = presence->getPayload<Swift::CapsInfo>();
 			if (capsInfo && capsInfo->getHash() == "sha-1") {
 				if (m_entityCapsManager->getCaps(presence->getFrom()) != Swift::DiscoInfo::ref()) {
 					LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");
 					m_readyForConnect = true;
 					onReadyToConnect();
+				}
 				else {
 					m_reconnectTimer->start();
+				}
+			}
 			else if (m_component->inServerMode()) {
 				LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");
 				m_readyForConnect = true;
 				onReadyToConnect();
+			}
 			else {
 				m_reconnectTimer->start();
+			}
+		}
+	}
 	bool isMUC = presence->getPayload<Swift::MUCPayload>() != NULL || *presence->getTo().getNode().c_str() == '#';
 	if (isMUC) {
 		if (presence->getType() == Swift::Presence::Unavailable) {
 			std::string room = Buddy::JIDToLegacyName(presence->getTo());
 			Conversation *conv = m_conversationManager->getConversation(room);
 			if (conv) {
 				conv->removeJID(presence->getFrom());
 				if (!conv->getJIDs().empty()) {
 					return;
+				}
+			}
 			LOG4CXX_INFO(logger, m_jid.toString() << ": Going to left room " << room);
 			onRoomLeft(room);
 			BOOST_FOREACH(Swift::Presence::ref &p, m_joinedRooms) {
 				if (p->getTo() == presence->getTo()) {
 					m_joinedRooms.remove(p);
 					break;
+				}
+			}
 			if (conv) {
 				m_conversationManager->removeConversation(conv);
 				delete conv;
+			}
+		}
 		else {
 			// force connection to legacy network to let backend to handle auto-join on connect.
 			if (!m_readyForConnect) {
 				LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");
 				m_readyForConnect = true;
 				onReadyToConnect();
+			}
 			std::string room = Buddy::JIDToLegacyName(presence->getTo());
 			std::string password = "";
 			if (presence->getPayload<Swift::MUCPayload>() != NULL) {
 				password = presence->getPayload<Swift::MUCPayload>()->getPassword() ? *presence->getPayload<Swift::MUCPayload>()->getPassword() : "";
+			}
 			Conversation *conv = m_conversationManager->getConversation(room);
 			if (conv != NULL) {
 				if (std::find(conv->getJIDs().begin(), conv->getJIDs().end(), presence->getFrom()) != conv->getJIDs().end()) {
 					LOG4CXX_INFO(logger, m_jid.toString() << ": User has already tried to join room " << room << " as " << presence->getTo().getResource());
+				}
 				else {
 					conv->addJID(presence->getFrom());
 					conv->sendParticipants(presence->getFrom());
+				}
 				if (forceJoin) {
 					onRoomJoined(presence->getFrom(), room, presence->getTo().getResource(), password);
+				}
 				return;
+			}
 			LOG4CXX_INFO(logger, m_jid.toString() << ": Going to join room " << room << " as " << presence->getTo().getResource());
 			std::string password = "";
 			if (presence->getPayload<Swift::MUCPayload>() != NULL) {
 				password = presence->getPayload<Swift::MUCPayload>()->getPassword() ? *presence->getPayload<Swift::MUCPayload>()->getPassword() : "";
 			bool isInJoined = false;
 			BOOST_FOREACH(Swift::Presence::ref &p, m_joinedRooms) {
 				if (p->getTo() == presence->getTo()) {
 					isInJoined = true;
+				}
+			}
 			if (!isInJoined) {
 				m_joinedRooms.push_back(presence);
+			}
 			if (!m_connected) {
 				LOG4CXX_INFO(logger, m_jid.toString() << ": Joining room " << room << " postponed, because use is not connected to legacy network yet.");
 				return;
+			}
 			LOG4CXX_INFO(logger, m_jid.toString() << ": Going to join room " << room << " as " << presence->getTo().getResource());
 			conv = m_component->getFactory()->createConversation(m_conversationManager, room, true);
 			m_conversationManager->addConversation(conv);
 			conv->setNickname(presence->getTo().getResource());
 			conv->addJID(presence->getFrom());
 			onRoomJoined(presence->getFrom(), room, presence->getTo().getResource(), password);
+		}
 		return;
+	}
 	if (presence->getType() == Swift::Presence::Unavailable) {
 		m_conversationManager->removeJID(presence->getFrom());
+	}
 	// User wants to disconnect this resource
 	if (!m_component->inServerMode()) {
 		if (presence->getType() == Swift::Presence::Unavailable) {
 				// Send unavailable presences for online contacts
 				m_rosterManager->sendUnavailablePresences(presence->getFrom());
 				// Send unavailable presence for transport contact itself
 				Swift::Presence::ref response = Swift::Presence::create();
 				response->setTo(presence->getFrom());
 				response->setFrom(m_component->getJID());
 				response->setType(Swift::Presence::Unavailable);
 				m_component->getStanzaChannel()->sendPresence(response);
+		}
 		else {

src/usermanager.cpp

➞

Show inline comments

@@ @@ -5,71 +5,73 @@ @@
+ *
  * 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/usermanager.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/storagebackend.h"
 #include "transport/conversationmanager.h"
 #include "transport/rostermanager.h"
 #include "transport/userregistry.h"
 #include "transport/logging.h"
 #include "transport/discoitemsresponder.h"
 #include "storageresponder.h"
 #include "Swiften/Swiften.h"
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Elements/StreamError.h"
 #ifndef __FreeBSD__
 #include "malloc.h"
 #endif
 // #include "valgrind/memcheck.h"
 namespace Transport {
 DEFINE_LOGGER(logger, "UserManager");
 UserManager::UserManager(Component *component, UserRegistry *userRegistry, StorageBackend *storageBackend) {
+UserManager::UserManager(Component *component, UserRegistry *userRegistry, DiscoItemsResponder *discoItemsResponder, StorageBackend *storageBackend) {
 	m_cachedUser = NULL;
 	m_onlineBuddies = 0;
 	m_sentToXMPP = 0;
 	m_sentToBackend = 0;
 	m_component = component;
 	m_storageBackend = storageBackend;
 	m_storageResponder = NULL;
 	m_userRegistry = userRegistry;
 	m_discoItemsResponder = discoItemsResponder;
 	if (m_storageBackend) {
 		m_storageResponder = new StorageResponder(component->getIQRouter(), m_storageBackend, this);
 		m_storageResponder->start();
+	}
 	component->onUserPresenceReceived.connect(bind(&UserManager::handlePresence, this, _1));
 	component->onUserDiscoInfoReceived.connect(bind(&UserManager::handleDiscoInfo, this, _1, _2));
 	m_component->getStanzaChannel()->onMessageReceived.connect(bind(&UserManager::handleMessageReceived, this, _1));
 	m_component->getStanzaChannel()->onPresenceReceived.connect(bind(&UserManager::handleGeneralPresenceReceived, this, _1));
 	m_userRegistry->onConnectUser.connect(bind(&UserManager::connectUser, this, _1));
 	m_userRegistry->onDisconnectUser.connect(bind(&UserManager::disconnectUser, this, _1));
 	m_removeTimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(1);
+}
 UserManager::~UserManager(){
 	if (m_storageResponder) {
 		m_storageResponder->stop();
 		delete m_storageResponder;
+	}
+}
 	if (!user) {
 		// Admin user is not legacy network user, so do not create User class instance for him
 		if (m_component->inServerMode()) {
 			std::vector<std::string> const &x = CONFIG_VECTOR(m_component->getConfig(),"service.admin_jid");
 			if (std::find(x.begin(), x.end(), presence->getFrom().toBare().toString()) != x.end()) {
 				// Send admin contact to the user.
 				Swift::RosterPayload::ref payload = Swift::RosterPayload::ref(new Swift::RosterPayload());
 				Swift::RosterItemPayload item;
 				item.setJID(m_component->getJID());
 				item.setName("Admin");
 				item.setSubscription(Swift::RosterItemPayload::Both);
 				payload->addItem(item);
 				Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, presence->getFrom(), m_component->getIQRouter());
 				request->send();
 				Swift::Presence::ref response = Swift::Presence::create();
 				response->setTo(presence->getFrom());
 				response->setFrom(m_component->getJID());
 				m_component->getStanzaChannel()->sendPresence(response);
 				return;
+		    }
+		}
 		UserInfo res;
 		bool registered = m_storageBackend ? m_storageBackend->getUser(userkey, res) : false;
 		// No user and unavailable presence -> answer with unavailable
 		if (presence->getType() == Swift::Presence::Unavailable) {
+		if (presence->getType() == Swift::Presence::Unavailable || presence->getType() == Swift::Presence::Probe) {
 			Swift::Presence::ref response = Swift::Presence::create();
 			response->setTo(presence->getFrom());
 			response->setFrom(presence->getTo());
 			response->setType(Swift::Presence::Unavailable);
 			m_component->getStanzaChannel()->sendPresence(response);
 			// bother him with probe presence, just to be
 			// sure he is subscribed to us.
 			if (/*registered && */presence->getType() == Swift::Presence::Probe) {
 				Swift::Presence::ref response = Swift::Presence::create();
 				response->setTo(presence->getFrom());
 				response->setFrom(presence->getTo());
 				response->setType(Swift::Presence::Probe);
 				m_component->getStanzaChannel()->sendPresence(response);
+			}
 			// Set user offline in database
 			if (m_storageBackend) {
 				UserInfo res;
 				bool registered = m_storageBackend->getUser(userkey, res);
 				if (registered) {
 					m_storageBackend->setUserOnline(res.id, false);
+				}
+			}
 			return;
+		}
 		UserInfo res;
 		bool registered = m_storageBackend ? m_storageBackend->getUser(userkey, res) : false;
 		// In server mode, we don't need registration normally, but for networks like IRC
 		// or Twitter where there's no real authorization using password, we have to force
 		// registration otherwise some data (like bookmarked rooms) could leak.
 		if (m_component->inServerMode()) {
 			if (!registered) {
 				// If we need registration, stop login process because user is not registered
 				if (CONFIG_BOOL_DEFAULTED(m_component->getConfig(), "registration.needRegistration", false)) {
 					m_userRegistry->onPasswordInvalid(presence->getFrom());
 					return;
+				}
 				res.password = "";
 				res.uin = presence->getFrom().getNode();
 				res.jid = userkey;
 				if (res.uin.find_last_of("%") != std::string::npos) { // OK
 					res.uin.replace(res.uin.find_last_of("%"), 1, "@"); // OK
+				}
 				if (m_storageBackend) {
 					// store user and getUser again to get user ID.
 					m_storageBackend->setUser(res);
 					registered = m_storageBackend->getUser(userkey, res);
+				}
 				else {
 					registered = true;
+				}
+			}
 			res.password = m_userRegistry->getUserPassword(userkey);
+		}
 		// We allow auto_register feature in gateway-mode. This allows IRC user to register
 		// the transport just by joining the room.
 		if (!m_component->inServerMode()) {
 			if (!registered && CONFIG_BOOL(m_component->getConfig(), "registration.auto_register")) {
 			if (!registered && (CONFIG_BOOL(m_component->getConfig(), "registration.auto_register") ||
 				!CONFIG_BOOL_DEFAULTED(m_component->getConfig(), "registration.needRegistration", true))) {
 				res.password = "";
 				res.jid = userkey;
 				bool isMUC = presence->getPayload<Swift::MUCPayload>() != NULL || *presence->getTo().getNode().c_str() == '#';
 				if (isMUC) {
 					res.uin = presence->getTo().getResource();
+				}
 				else {
 					res.uin = presence->getFrom().toString();
+				}
 				LOG4CXX_INFO(logger, "Auto-registering user " << userkey << " with uin=" << res.uin);
 				if (m_storageBackend) {
 					// store user and getUser again to get user ID.
 					m_storageBackend->setUser(res);
 					registered = m_storageBackend->getUser(userkey, res);
+				}
 				else {
-					registered = false;
+					registered = true;
+				}
+			}
+		}
 		// Unregistered users are not able to login
 		if (!registered) {
 			LOG4CXX_WARN(logger, "Unregistered user " << userkey << " tried to login");
 			return;
+		}
 		if (CONFIG_BOOL(m_component->getConfig(), "service.vip_only") && res.vip == false) {
 			if (!CONFIG_STRING(m_component->getConfig(), "service.vip_message").empty()) {
 				boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 				msg->setBody(CONFIG_STRING(m_component->getConfig(), "service.vip_message"));
 				msg->setTo(presence->getFrom());
 				msg->setFrom(m_component->getJID());
 				m_component->getStanzaChannel()->sendMessage(msg);
+			}
 			LOG4CXX_WARN(logger, "Non VIP user " << userkey << " tried to login");
 			if (m_component->inServerMode()) {
 				m_userRegistry->onPasswordInvalid(presence->getFrom());
+			}
 			return;
+		}
 		bool transport_enabled = true;
 		if (m_storageBackend) {
 			std::string value = "1";
 			int type = (int) TYPE_BOOLEAN;
 			m_storageBackend->getUserSetting(res.id, "enable_transport", type, value);
 			transport_enabled = value == "1";
+		}
 		// User can disabled the transport using adhoc commands
 		if (!transport_enabled) {
 			LOG4CXX_INFO(logger, "User " << userkey << " has disabled transport, not logging");
 			return;
+		}
 		// Create new user class and set storagebackend
 		user = new User(presence->getFrom(), res, m_component, this);
 		user->getRosterManager()->setStorageBackend(m_storageBackend);
 		addUser(user);
+	}
 	// User can be handleDisconnected in addUser callback, so refresh the pointer
 	user = getUser(userkey);
 	if (!user) {
 		m_userRegistry->onPasswordInvalid(presence->getFrom());
 		return;
+	}
 	User *user = getUser(message->getFrom().toBare().toString());
 	if (!user){
 		return;
+	}
 	user->getConversationManager()->handleMessageReceived(message);
+}
 void UserManager::handleGeneralPresenceReceived(Swift::Presence::ref presence) {
 	switch(presence->getType()) {
 		case Swift::Presence::Subscribe:
 		case Swift::Presence::Subscribed:
 		case Swift::Presence::Unsubscribe:
 		case Swift::Presence::Unsubscribed:
 			handleSubscription(presence);
 			break;
 		case Swift::Presence::Available:
 		case Swift::Presence::Unavailable:
 			break;
 		case Swift::Presence::Probe:
 			handleProbePresence(presence);
 			break;
 		case Swift::Presence::Error:
 			handleErrorPresence(presence);
 			break;
 		default:
 			break;
 	};
+}
 void UserManager::handleProbePresence(Swift::Presence::ref presence) {
 	// Don't let RosterManager to handle presences for us
 	if (presence->getTo().getNode().empty()) {
 		return;
+	}
 	User *user = getUser(presence->getFrom().toBare().toString());
  	if (user) {
  		user->getRosterManager()->sendCurrentPresence(presence->getTo(), presence->getFrom());
+ 	}
  	else {
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setFrom(presence->getTo());
 		response->setTo(presence->getFrom());
 		response->setType(Swift::Presence::Unavailable);
 		m_component->getStanzaChannel()->sendPresence(response);
+	}
+}
 void UserManager::handleErrorPresence(Swift::Presence::ref presence) {
 	// Don't let RosterManager to handle presences for us
 	if (!presence->getTo().getNode().empty()) {
 		return;
+	}
 	if (!presence->getPayload<Swift::ErrorPayload>()) {
 		return;
+	}
 	if (presence->getPayload<Swift::ErrorPayload>()->getCondition() != Swift::ErrorPayload::SubscriptionRequired) {
 		return;
+	}
 	std::string userkey = presence->getFrom().toBare().toString();
 	UserInfo res;
 	bool registered = m_storageBackend ? m_storageBackend->getUser(userkey, res) : false;
 	if (registered) {
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setFrom(presence->getTo().toBare());
 		response->setTo(presence->getFrom().toBare());
 		response->setType(Swift::Presence::Subscribe);
 		m_component->getStanzaChannel()->sendPresence(response);
+	}
+}
 void UserManager::handleSubscription(Swift::Presence::ref presence) {
 	// answer to subscibe for transport itself
 	if (presence->getType() == Swift::Presence::Subscribe && presence->getTo().getNode().empty()) {
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setFrom(presence->getTo().toBare());
 		response->setTo(presence->getFrom().toBare());
 		response->setType(Swift::Presence::Subscribed);
 		m_component->getStanzaChannel()->sendPresence(response);
 // 		response = Swift::Presence::create();
 // 		response->setFrom(presence->getTo());
 // 		response->setTo(presence->getFrom());
 // 		response->setType(Swift::Presence::Subscribe);
 // 		m_component->getStanzaChannel()->sendPresence(response);
 		return;
+	}
 	else if (presence->getType() == Swift::Presence::Unsubscribed && presence->getTo().getNode().empty()) {
 		std::string userkey = presence->getFrom().toBare().toString();
 		UserInfo res;
 		bool registered = m_storageBackend ? m_storageBackend->getUser(userkey, res) : false;
 		if (registered) {
 			Swift::Presence::ref response = Swift::Presence::create();
 			response->setFrom(presence->getTo().toBare());
 			response->setTo(presence->getFrom().toBare());
 			response->setType(Swift::Presence::Subscribe);
 			m_component->getStanzaChannel()->sendPresence(response);
+		}
 		return;
+	}
 	// Don't let RosterManager to handle presences for us
 	if (presence->getTo().getNode().empty()) {
 		return;
+	}
 	User *user = getUser(presence->getFrom().toBare().toString());
  	if (user) {
  		user->handleSubscription(presence);
+ 	}
  	else if (presence->getType() == Swift::Presence::Unsubscribe) {
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setFrom(presence->getTo());
 		response->setTo(presence->getFrom());
 		response->setType(Swift::Presence::Unsubscribed);
 		m_component->getStanzaChannel()->sendPresence(response);
+	}
 // 	else {
 // // 		Log(presence->getFrom().toString().getUTF8String(), "Subscribe presence received, but this user is not logged in");
 // 	}
+}
 void UserManager::connectUser(const Swift::JID &user) {

src/userregistration.cpp

➞

Show inline comments

 	if (!registered)
 		return false;
 	onUserUnregistered(userInfo);
 	// We have to check if server supports remoteroster XEP and use it if it's supported or fallback to unsubscribe otherwise
 	AddressedRosterRequest::ref request = AddressedRosterRequest::ref(new AddressedRosterRequest(m_component->getIQRouter(), barejid));
 	request->onResponse.connect(boost::bind(&UserRegistration::handleUnregisterRemoteRosterResponse, this, _1, _2, barejid));
 	request->send();
 	return true;
+}
 void UserRegistration::handleUnregisterRemoteRosterResponse(boost::shared_ptr<Swift::RosterPayload> payload, Swift::ErrorPayload::ref remoteRosterNotSupported /*error*/, const std::string &barejid) {
 	UserInfo userInfo;
 	bool registered = m_storageBackend->getUser(barejid, userInfo);
 	// This user is not registered
 	if (!registered)
 		return;
 	if (remoteRosterNotSupported || !payload) {
 		std::list <BuddyInfo> roster;
 		m_storageBackend->getBuddies(userInfo.id, roster);
 		for(std::list<BuddyInfo>::iterator u = roster.begin(); u != roster.end() ; u++){
 			std::string name = Swift::JID::getEscapedNode((*u).legacyName);
 			std::string name = (*u).legacyName;
 			if ((*u).flags & BUDDY_JID_ESCAPING) {
 				name = Swift::JID::getEscapedNode((*u).legacyName);
+			}
 			else {
 				if (name.find_last_of("@") != std::string::npos) {
 					name.replace(name.find_last_of("@"), 1, "%");
+				}
+			}
 			Swift::Presence::ref response;
 			response = Swift::Presence::create();
 			response->setTo(Swift::JID(barejid));
 			response->setFrom(Swift::JID(name, m_component->getJID().toString()));
 			response->setType(Swift::Presence::Unsubscribe);
 			m_component->getStanzaChannel()->sendPresence(response);
 			response = Swift::Presence::create();
 			response->setTo(Swift::JID(barejid));
 			response->setFrom(Swift::JID(name, m_component->getJID().toString()));
 			response->setType(Swift::Presence::Unsubscribed);
 			m_component->getStanzaChannel()->sendPresence(response);
+		}
+	}
 	else {
 		BOOST_FOREACH(Swift::RosterItemPayload it, payload->getItems()) {
 			Swift::RosterPayload::ref p = Swift::RosterPayload::ref(new Swift::RosterPayload());
 			Swift::RosterItemPayload item;
 			item.setJID(it.getJID());
 			item.setSubscription(Swift::RosterItemPayload::Remove);
 			p->addItem(item);

src/util.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/util.h"
 #include "transport/config.h"
 #include <boost/foreach.hpp>
 #include <iostream>
 #include <iterator>
 #include <algorithm>
 #include <boost/filesystem.hpp>
 #include <boost/algorithm/string.hpp>
 #include <boost/numeric/conversion/cast.hpp>
 #ifndef WIN32
 #include "sys/signal.h"
 #include <sys/stat.h>
 #include <pwd.h>
 #include <grp.h>
 #include <sys/resource.h>
 #include "libgen.h"
 #else
 #include <windows.h>
 #include <process.h>
 #define getpid _getpid
 #endif
 using namespace boost::filesystem;
 using namespace boost;
 namespace Transport {
 namespace Util {
 void createDirectories(Transport::Config *config, const boost::filesystem::path& ph) {
 	if (ph.empty() || exists(ph)) {
 		return;
+	}
 	// First create branch, by calling ourself recursively
 	createDirectories(config, ph.branch_path());
 	// Now that parent's path exists, create the directory
 	create_directory(ph);
 #ifndef WIN32
 	if (!CONFIG_STRING(config, "service.group").empty() && !CONFIG_STRING(config, "service.user").empty()) {
 		struct group *gr;
 		if ((gr = getgrnam(CONFIG_STRING(config, "service.group").c_str())) == NULL) {
 			std::cerr << "Invalid service.group name " << CONFIG_STRING(config, "service.group") << "\n";
+		}
 		struct passwd *pw;
 		if ((pw = getpwnam(CONFIG_STRING(config, "service.user").c_str())) == NULL) {
 			std::cerr << "Invalid service.user name " << CONFIG_STRING(config, "service.user") << "\n";
+		}
 		chown(ph.string().c_str(), pw->pw_uid, gr->gr_gid);
+	}
 #endif
+}
 void removeEverythingOlderThan(const std::vector<std::string> &dirs, time_t t) {
 	BOOST_FOREACH(const std::string &dir, dirs) {
 		path p(dir);
 		try {
 			if (!exists(p)) {
 				continue;
+			}
 			if (!is_directory(p)) {
 				continue;
+			}
 			directory_iterator end_itr;
 			for (directory_iterator itr(p); itr != end_itr; ++itr) {
 				if (last_write_time(itr->path()) < t) {
 					try {
 						if (is_regular(itr->path())) {
 							remove(itr->path());
+						}
 						else if (is_directory(itr->path())) {
 							std::vector<std::string> nextDirs;
 							nextDirs.push_back(itr->path().string());
 							removeEverythingOlderThan(nextDirs, t);
 							if (is_empty(itr->path())) {
+							if (boost::filesystem::is_empty(itr->path())) {
 								remove_all(itr->path());
+							}
+						}
+					}
 					catch (const filesystem_error& ex) {
+					}
+				}
+			}
+		}
 		catch (const filesystem_error& ex) {
+		}
+	}
+}
 std::string encryptPassword(const std::string &password, const std::string &key) {
 	std::string encrypted;
 	encrypted.resize(password.size());
 	for (int i = 0; i < password.size(); i++) {
 		char c = password[i];
 		char keychar = key[i % key.size()];
 		c += keychar;
 		encrypted[i] = c;
+	}
 	encrypted = Swift::Base64::encode(Swift::createByteArray(encrypted));
 	return encrypted;
+}
 std::string decryptPassword(std::string &encrypted, const std::string &key) {
 	encrypted = Swift::byteArrayToString(Swift::Base64::decode(encrypted));
 	std::string password;
 	password.resize(encrypted.size());
 	for (int i = 0; i < encrypted.size(); i++) {
 		char c = encrypted[i];
 		char keychar = key[i % key.size()];
 		c -= keychar;
 		password[i] = c;
+	}
 	return password;
+}
 std::string serializeGroups(const std::vector<std::string> &groups) {
 	std::string ret;
 	BOOST_FOREACH(const std::string &group, groups) {
 		ret += group + "\n";
+	}
 	if (!ret.empty()) {
 		ret.erase(ret.end() - 1);
+	}
 	return ret;
+}
 std::vector<std::string> deserializeGroups(std::string &groups) {
 	std::vector<std::string> ret;
 	if (groups.empty()) {
 		return ret;
+	}
 	boost::split(ret, groups, boost::is_any_of("\n"));
 	if (ret.back().empty()) {
 		ret.erase(ret.end() - 1);
+	}
 	return ret;
+}
 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;
+}
 #ifdef _WIN32
 std::wstring utf8ToUtf16(const std::string& str)
+{
 	try
+	{
 		if (str.empty())
 			return L"";
 		// First request the size of the required UTF-16 buffer
 		int numRequiredBytes = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), boost::numeric_cast<int>(str.size()), NULL, 0);
 		if (!numRequiredBytes)
 			return L"";
 		// Allocate memory for the UTF-16 string
 		std::vector<wchar_t> utf16Str(numRequiredBytes);

0 comments (0 inline, 0 general)