libtransport.git Changeset - fa9b9847088e

Changeset - fa9b9847088e

Parent rev.

Child rev.

[Not reviewed]

Merge

0 39 0

Jan Kaluza - 13 years ago 2012-03-22 07:40:56
hanzz.k@gmail.com

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

39 files changed with 128 insertions and 244 deletions:

CMakeLists.txt

ChangeLog

backends/libcommuni/main.cpp

backends/libcommuni/session.cpp

backends/libcommuni/singleircnetworkplugin.cpp

backends/libpurple/geventloop.cpp

backends/libpurple/main.cpp

backends/skype/main.cpp

backends/smstools3/main.cpp

backends/template/main.cpp

include/Swiften/TLS/OpenSSL/OpenSSLServerContext.cpp

include/transport/logging.h

plugin/cpp/CMakeLists.txt

plugin/cpp/networkplugin.cpp

spectrum/src/main.cpp

src/admininterface.cpp

src/blockresponder.cpp

src/config.cpp

src/conversation.cpp

src/conversationmanager.cpp

src/filetransfermanager.cpp

src/gatewayresponder.cpp

src/logging.cpp

src/memoryreadbytestream.cpp

src/mysqlbackend.cpp

src/networkpluginserver.cpp

src/rostermanager.cpp

src/rosterresponder.cpp

src/sqlite3backend.cpp

src/statsresponder.cpp

src/storageresponder.cpp

src/tests/main.cpp

src/transport.cpp

src/user.cpp

src/usermanager.cpp

src/userregistration.cpp

src/userregistry.cpp

src/usersreconnecter.cpp

src/vcardresponder.cpp

0 comments (0 inline, 0 general)

CMakeLists.txt

➞

Show inline comments

@@ @@ -146,52 +146,54 @@ if (PROTOBUF_FOUND) @@
 		include(${QT_USE_FILE})
 	else()
 		message("IRC plugin        : no (install libCommuni and libprotobuf-dev)")
 	endif()
 	message("Frotz plugin      : yes")
 	message("SMSTools3 plugin  : yes")
 	if(${LIBDBUSGLIB_FOUND})
 		message("Skype plugin      : yes")
 		include_directories(${LIBDBUSGLIB_INCLUDE_DIRS})
 	else()
 		message("Skype plugin      : no (install dbus-glib-devel)")
 	endif()
 else()
 	message("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)")
 endif()
 if (LOG4CXX_FOUND)
-	message("Logging           : yes")
+	message("Log4cxx           : yes")
 	include_directories(${LOG4CXX_INCLUDE_DIR})
 	ADD_DEFINITIONS(-DWITH_LOG4CXX)
 else()
 	message(FATAL_ERROR "Logging           : no (install log4cxx-devel)")
 	set(LOG4CXX_LIBRARIES "")
 	message("Log4cxx           : no (install log4cxx-devel)")
 endif()
 if (WIN32)
 ADD_DEFINITIONS(-D_WIN32_WINNT=0x501)
 ADD_DEFINITIONS(-DWIN32_LEAN_AND_MEAN)
 endif()
 if(CMAKE_BUILD_TYPE MATCHES Debug)
 if (CMAKE_COMPILER_IS_GNUCXX)
 	ADD_DEFINITIONS(-O3)
 	ADD_DEFINITIONS(-ggdb)
 	ADD_DEFINITIONS(-Wall)
 	ADD_DEFINITIONS(-W)
 	ADD_DEFINITIONS(-Wcast-align)
 	ADD_DEFINITIONS(-Wextra -Wno-sign-compare -Wno-unused-parameter)
 	ADD_DEFINITIONS(-Winit-self)
 	ADD_DEFINITIONS(-Wmissing-declarations)
 	ADD_DEFINITIONS(-Wpointer-arith)
 	ADD_DEFINITIONS(-Wreorder)
 	ADD_DEFINITIONS(-Woverloaded-virtual)
 	ADD_DEFINITIONS(-Wsign-promo)
 	ADD_DEFINITIONS(-Wundef -Wunused)
 endif()
 	ADD_DEFINITIONS(-DDEBUG)

ChangeLog

➞

Show inline comments

 Version 2.0.0-beta2 (2012-XX-XX):
 	General:
 	* Fixed bug when Roster Item Exchange and subscribe stanzas were sent
 	  repeatedly.
 	* Backends related logs now contain the backend PID.
 	* Fixed username_mask setting.
 	* Added new fields into statistics (backends_crashed, messages related
 	  stats).
 	* Log4cxx is now optional dependency. Without Log4cxx, Spectrum 2 logs
 	  to standard output.
 	* Fixed crash when Log4cxx configuration file didn't exist.
 	* Admin can now see "Admin" contact in server-mode.
 	libpurple:
 	* Added support for MUC for prpl-jabber protocol.
 	Skype:
 	* Memory usage statistic now includes the Skype client.
 	* Fixed logging issue when the logs were not stored in the proper instance
 	  directory.
 	* Skype backend includes also Skype client memory usage into the account.
 	* Working buddies adding/removing.
 	* Information about missed call is now forwarded to XMPP user.
 Version 2.0.0-beta (2012-02-28):
 	General:
 	* Added PostreSQL support (thanks to Jadestorm).
 	* Added XEP-0100 (Gateway interaction) support.
 	* Send presences only "from" bare JID (fixed bug with buddies appearing
 	  twice in the roster and potential unregistering issues).
 	* Fixed potential MySQL/SQLite3 deadlocks.
 	* Fixed disconnecting in server-mode when client does not send unavailable
 	  presence before disconnection.
 	* Fixed crash in server-mode when client send its custom jabber:iq:storage
 	  payload.
 	* Fixed registration from Pidgin.

backends/libcommuni/main.cpp

➞

Show inline comments

 /*
  * Copyright (C) 2008-2009 J-P Nurmi jpnurmi@gmail.com
+ *
  * This example is free, and not covered by LGPL license. There is no
  * restriction applied to their modification, redistribution, using and so on.
  * You can study them, modify them, use them in your own program - either
  * completely or partially. By using it you may give me some credits in your
  * program, but you don't have to.
  */
 #include "transport/config.h"
 #include "transport/networkplugin.h"
 #include "transport/logging.h"
 #include "session.h"
 #include <QtCore>
 #include <QtNetwork>
 #include "Swiften/EventLoop/Qt/QtEventLoop.h"
 #include "ircnetworkplugin.h"
 #include "singleircnetworkplugin.h"
 #include "log4cxx/logger.h"
 #include "log4cxx/consoleappender.h"
 #include "log4cxx/patternlayout.h"
 #include "log4cxx/propertyconfigurator.h"
 #include "log4cxx/helpers/properties.h"
 #include "log4cxx/helpers/fileinputstream.h"
 #include "log4cxx/helpers/transcoder.h"
 using namespace boost::program_options;
 using namespace Transport;
 using namespace log4cxx;
 NetworkPlugin * np = NULL;
 int main (int argc, char* argv[]) {
 	std::string host;
 	int port;
 	boost::program_options::options_description desc("Usage: spectrum [OPTIONS] <config_file.cfg>\nAllowed options");
 	desc.add_options()
 		("host,h", value<std::string>(&host), "host")
 		("port,p", value<int>(&port), "port")
+		;
 	try
+	{
 		boost::program_options::variables_map vm;
 		boost::program_options::store(boost::program_options::parse_command_line(argc, argv, desc), vm);
 		boost::program_options::notify(vm);
+	}
 	catch (std::runtime_error& e)
+	{
 		std::cout << desc << "\n";
 		exit(1);
+	}
 	catch (...)

backends/libcommuni/session.cpp

➞

Show inline comments

 /*
  * Copyright (C) 2008-2009 J-P Nurmi jpnurmi@gmail.com
+ *
  * This example is free, and not covered by LGPL license. There is no
  * restriction applied to their modification, redistribution, using and so on.
  * You can study them, modify them, use them in your own program - either
  * completely or partially. By using it you may give me some credits in your
  * program, but you don't have to.
  */
 #include "session.h"
 #include <QtCore>
 #include <iostream>
 #include "Swiften/Elements/StatusShow.h"
 #include <IrcCommand>
 #include <IrcMessage>
-#include "log4cxx/logger.h"
+#include "transport/logging.h"
 using namespace log4cxx;
 static LoggerPtr logger = log4cxx::Logger::getLogger("IRCSession");
 DEFINE_LOGGER(logger, "IRCSession");
 MyIrcSession::MyIrcSession(const std::string &user, NetworkPlugin *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(connected()), SLOT(on_connected()));
 	connect(this, SIGNAL(messageReceived(IrcMessage*)), this, SLOT(onMessageReceived(IrcMessage*)));
+}
 void MyIrcSession::on_connected() {
 	m_connected = true;
 	if (suffix.empty()) {
 		np->handleConnected(user);
+	}
 	for(std::list<std::string>::const_iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
 		sendCommand(IrcCommand::createJoin(QString::fromStdString(*it)));
+	}
 	if (getIdentify().find(" ") != std::string::npos) {

backends/libcommuni/singleircnetworkplugin.cpp

➞

Show inline comments

 #include "singleircnetworkplugin.h"
-#include "log4cxx/logger.h"
+#include "transport/logging.h"
 #include <IrcCommand>
 #include <IrcMessage>
 using namespace log4cxx;
 static LoggerPtr logger = log4cxx::Logger::getLogger("SingleIRCNetworkPlugin");
 DEFINE_LOGGER(logger, "SingleIRCNetworkPlugin");
 SingleIRCNetworkPlugin::SingleIRCNetworkPlugin(Config *config, Swift::QtEventLoop *loop, const std::string &host, int port) {
 	this->config = config;
 	m_server = config->getUnregistered().find("service.irc_server")->second;
 	m_socket = new QTcpSocket();
 	m_socket->connectToHost(QString::fromStdString(host), port);
 	connect(m_socket, SIGNAL(readyRead()), this, SLOT(readData()));
 	if (config->getUnregistered().find("service.irc_identify") != config->getUnregistered().end()) {
 		m_identify = config->getUnregistered().find("service.irc_identify")->second;
+	}
 	else {
 		m_identify = "NickServ identify $name $password";
+	}
 	LOG4CXX_INFO(logger, "SingleIRCNetworkPlugin for server " << m_server << " initialized.");
+}
 void SingleIRCNetworkPlugin::readData() {
 	size_t availableBytes = m_socket->bytesAvailable();
 	if (availableBytes == 0)
 		return;
 	std::string d = std::string(m_socket->readAll().data(), availableBytes);

backends/libpurple/geventloop.cpp

➞

Show inline comments

@@ @@ -7,53 +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
  */
 #include "geventloop.h"
 #ifdef _WIN32
 #include "win32/win32dep.h"
 #undef read
 #undef write
 #endif
 #ifdef WITH_LIBEVENT
 #include "event.h"
 #endif
-#include "log4cxx/logger.h"
+#include "transport/logging.h"
 using namespace log4cxx;
 static LoggerPtr logger = Logger::getLogger("EventLoop");
 DEFINE_LOGGER(logger, "EventLoop");
 typedef struct _PurpleIOClosure {
 	PurpleInputFunction function;
 	guint result;
 	gpointer data;
 #ifdef WITH_LIBEVENT
 	GSourceFunc function2;
 	struct timeval timeout;
 	struct event evfifo;
 #endif
 } PurpleIOClosure;
 static gboolean io_invoke(GIOChannel *source,
 										GIOCondition condition,
 										gpointer data)
+{
 	PurpleIOClosure *closure = (PurpleIOClosure* )data;
 	PurpleInputCondition purple_cond = (PurpleInputCondition)0;
 	int tmp = 0;
 	if (condition & READ_COND)
+	{
 		tmp |= PURPLE_INPUT_READ;
 		purple_cond = (PurpleInputCondition)tmp;

backends/libpurple/main.cpp

➞

Show inline comments

 #include "utils.h"
 #include "glib.h"
 #include "purple.h"
 #include <algorithm>
 #include <iostream>
 #include "transport/networkplugin.h"
 #include "transport/logging.h"
 #include "transport/config.h"
 #include "transport/logging.h"
 #include "geventloop.h"
 #include "log4cxx/logger.h"
 #include "log4cxx/consoleappender.h"
 #include "log4cxx/patternlayout.h"
 #include "log4cxx/propertyconfigurator.h"
 #include "log4cxx/helpers/properties.h"
 #include "log4cxx/helpers/fileinputstream.h"
 #include "log4cxx/helpers/transcoder.h"
 // #include "valgrind/memcheck.h"
 #include "malloc.h"
 #include <algorithm>
 #include "errno.h"
 #ifdef WITH_LIBEVENT
 #include <event.h>
 #endif
 #ifdef WIN32
 #include "win32/win32dep.h"
 #define ssize_t SSIZE_T
 #include <process.h>
 #define getpid _getpid
 #endif
 using namespace log4cxx;
 DEFINE_LOGGER(logger_libpurple, "libpurple");
 DEFINE_LOGGER(logger, "backend");
 static LoggerPtr logger_libpurple = log4cxx::Logger::getLogger("libpurple");
 static LoggerPtr logger = log4cxx::Logger::getLogger("backend");
 int main_socket;
 static int writeInput;
 using namespace Transport;
 template <class T> T fromString(const std::string &str) {
 	T i;
 	std::istringstream os(str);
 	os >> i;
 	return i;
+}
 template <class T> std::string stringOf(T object) {
 	std::ostringstream os;
 	os << object;
 	return (os.str());
+}
 static void transportDataReceived(gpointer data, gint source, PurpleInputCondition cond);
 class SpectrumNetworkPlugin;
 GKeyFile *keyfile;
 SpectrumNetworkPlugin *np;
@@ @@ -1627,86 +1622,54 @@ int main(int argc, char **argv) { @@
 	std::cout << g_option_context_get_help(context, FALSE, NULL);
 #else
 	std::cout << "Usage: spectrum <configuration_file.cfg>\n";
 	std::cout << "See \"man spectrum\" for more info.\n";
 #endif
 #endif
+	}
 	else {
 #ifndef WIN32
 		signal(SIGPIPE, SIG_IGN);
 		if (signal(SIGCHLD, spectrum_sigchld_handler) == SIG_ERR) {
 			std::cout << "SIGCHLD handler can't be set\n";
 			g_option_context_free(context);
 			return -1;
+		}
 #endif
 		keyfile = g_key_file_new ();
 		if (!g_key_file_load_from_file (keyfile, argv[1], (GKeyFileFlags) 0, 0)) {
 			std::cout << "Can't open " << argv[1] << " configuration file.\n";
 			return 1;
+		}
 		if (KEYFILE_STRING("logging", "backend_config").empty()) {
 			LoggerPtr root = log4cxx::Logger::getRootLogger();
 #ifndef _MSC_VER
 			root->addAppender(new ConsoleAppender(new PatternLayout("%d %-5p %c: %m%n")));
 #else
 			root->addAppender(new ConsoleAppender(new PatternLayout(L"%d %-5p %c: %m%n")));
 #endif
+		}
 		else {
 			log4cxx::helpers::Properties p;
 			log4cxx::helpers::FileInputStream *istream = NULL;
 			try {
 				istream = new log4cxx::helpers::FileInputStream(KEYFILE_STRING("logging", "backend_config"));
+			}
 			catch(log4cxx::helpers::IOException &ex) {
 				std::cerr << "Can't create FileInputStream logger instance: " << ex.what() << "\n";
+			}
 			catch (...) {
 				std::cerr << "Can't create FileInputStream logger instance\n";
+			}
 			if (!istream) {
 		Config config;
 		if (!config.load(argv[1])) {
 			std::cerr << "Can't open " << argv[1] << " configuration file.\n";
 			return 1;
+		}
 			p.load(istream);
 			LogString pid, jid;
 			log4cxx::helpers::Transcoder::decode(stringOf(getpid()), pid);
 			log4cxx::helpers::Transcoder::decode(KEYFILE_STRING("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
 			log4cxx::PropertyConfigurator::configure(p);
+		}
 		Logging::initBackendLogging(&config);
 		initPurple();
 		main_socket = create_socket(host, port);
 		purple_input_add(main_socket, PURPLE_INPUT_READ, &transportDataReceived, NULL);
 		purple_timeout_add_seconds(30, pingTimeout, NULL);
 		np = new SpectrumNetworkPlugin();
 		bool libev = KEYFILE_STRING("service", "eventloop") == "libev";
 		GMainLoop *m_loop;
 #ifdef WITH_LIBEVENT
 		if (!libev) {
 			m_loop = g_main_loop_new(NULL, FALSE);
+		}
 		else {
 			event_init();
+		}
 #endif
 		m_loop = g_main_loop_new(NULL, FALSE);
 		if (m_loop) {
 			g_main_loop_run(m_loop);
+		}

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 "log4cxx/logger.h"
 #include "log4cxx/consoleappender.h"
 #include "log4cxx/patternlayout.h"
 #include "log4cxx/propertyconfigurator.h"
 #include "log4cxx/helpers/properties.h"
 #include "log4cxx/helpers/fileinputstream.h"
 #include "sys/wait.h"
 #include "sys/signal.h"
 // #include "valgrind/memcheck.h"
 #include "malloc.h"
 #include <dbus-1.0/dbus/dbus-glib-lowlevel.h>
 using namespace log4cxx;
 static LoggerPtr logger = Logger::getLogger("backend");
 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;
 static gboolean nodaemon = FALSE;
 static gchar *logfile = NULL;
 static gchar *lock_file = NULL;
 static gchar *host = NULL;
 static int port = 10000;
 static gboolean ver = FALSE;

backends/smstools3/main.cpp

➞

Show inline comments

@@ @@ -5,66 +5,57 @@ @@
  * restriction applied to their modification, redistribution, using and so on.
  * You can study them, modify them, use them in your own program - either
  * completely or partially. By using it you may give me some credits in your
  * program, but you don't have to.
  */
 #include "transport/config.h"
 #include "transport/logging.h"
 #include "transport/networkplugin.h"
 #include "transport/sqlite3backend.h"
 #include "transport/mysqlbackend.h"
 #include "transport/pqxxbackend.h"
 #include "transport/storagebackend.h"
 #include "Swiften/Swiften.h"
 #include <boost/filesystem.hpp>
 #include "unistd.h"
 #include "signal.h"
 #include "sys/wait.h"
 #include "sys/signal.h"
 #include <fstream>
 #include <streambuf>
 Swift::SimpleEventLoop *loop_;
 #include "log4cxx/logger.h"
 #include "log4cxx/consoleappender.h"
 #include "log4cxx/patternlayout.h"
 #include "log4cxx/propertyconfigurator.h"
 #include "log4cxx/helpers/properties.h"
 #include "log4cxx/helpers/fileinputstream.h"
 #include "log4cxx/helpers/transcoder.h"
 #include <boost/filesystem.hpp>
 #include <boost/algorithm/string.hpp>
 using namespace boost::filesystem;
 using namespace boost::program_options;
 using namespace Transport;
 using namespace log4cxx;
 static LoggerPtr logger = log4cxx::Logger::getLogger("SMSNetworkPlugin");
 DEFINE_LOGGER(logger, "SMSNetworkPlugin");
 #define INTERNAL_USER "/sms@backend@internal@user"
 class SMSNetworkPlugin;
 SMSNetworkPlugin * np = NULL;
 StorageBackend *storageBackend;
 class SMSNetworkPlugin : public NetworkPlugin {
 	public:
 		Swift::BoostNetworkFactories *m_factories;
 		Swift::BoostIOServiceThread m_boostIOServiceThread;
 		boost::shared_ptr<Swift::Connection> m_conn;
 		Swift::Timer::ref m_timer;
 		int m_internalUser;
 		SMSNetworkPlugin(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(&SMSNetworkPlugin::_handleDataRead, this, _1));
 			m_conn->connect(Swift::HostAddressPort(Swift::HostAddress(host), port));
 // 			m_conn->onConnectFinished.connect(boost::bind(&FrotzNetworkPlugin::_handleConnected, this, _1));
 // 			m_conn->onDisconnected.connect(boost::bind(&FrotzNetworkPlugin::handleDisconnected, this));

backends/template/main.cpp

➞

Show inline comments

 // Transport includes
 #include "transport/config.h"
 #include "transport/networkplugin.h"
 #include "transport/logging.h"
 // Swiften
 #include "Swiften/Swiften.h"
 // for signal handler
 #include "unistd.h"
 #include "signal.h"
 #include "sys/wait.h"
 #include "sys/signal.h"
 // Log4cxx
 #include "log4cxx/logger.h"
 #include "log4cxx/consoleappender.h"
 #include "log4cxx/patternlayout.h"
 #include "log4cxx/propertyconfigurator.h"
 #include "log4cxx/helpers/properties.h"
 #include "log4cxx/helpers/fileinputstream.h"
 #include "log4cxx/helpers/transcoder.h"
 // Boost
 #include <boost/algorithm/string.hpp>
 using namespace boost::filesystem;
 using namespace boost::program_options;
 using namespace Transport;
 // log4cxx main logger
 using namespace log4cxx;
 static LoggerPtr logger = log4cxx::Logger::getLogger("Backend Template");
 DEFINE_LOGGER(logger, "Backend Template");
 // eventloop
 Swift::SimpleEventLoop *loop_;
 // Plugin
 class TemplatePlugin;
 TemplatePlugin * np = NULL;
 class TemplatePlugin : public NetworkPlugin {
 	public:
 		Swift::BoostNetworkFactories *m_factories;
 		Swift::BoostIOServiceThread m_boostIOServiceThread;
 		boost::shared_ptr<Swift::Connection> m_conn;
 		TemplatePlugin(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(&TemplatePlugin::_handleDataRead, this, _1));
 			m_conn->connect(Swift::HostAddressPort(Swift::HostAddress(host), port));
 			LOG4CXX_INFO(logger, "Starting the plugin.");
+		}
@@ @@ -126,56 +116,33 @@ int main (int argc, char* argv[]) { @@
 		boost::program_options::notify(vm);
+	}
 	catch (std::runtime_error& e)
+	{
 		std::cout << desc << "\n";
 		exit(1);
+	}
 	catch (...)
+	{
 		std::cout << desc << "\n";
 		exit(1);
+	}
 	if (argc < 5) {
 		return 1;
+	}
 	Config config;
 	if (!config.load(argv[5])) {
 		std::cerr << "Can't open " << argv[1] << " configuration file.\n";
 		return 1;
+	}
 	if (CONFIG_STRING(&config, "logging.backend_config").empty()) {
 		LoggerPtr root = log4cxx::Logger::getRootLogger();
 #ifndef _MSC_VER
 		root->addAppender(new ConsoleAppender(new PatternLayout("%d %-5p %c: %m%n")));
 #else
 		root->addAppender(new ConsoleAppender(new PatternLayout(L"%d %-5p %c: %m%n")));
 #endif
+	}
 	else {
 		log4cxx::helpers::Properties p;
 		log4cxx::helpers::FileInputStream *istream = new log4cxx::helpers::FileInputStream(CONFIG_STRING(&config, "logging.backend_config"));
 		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
 		log4cxx::PropertyConfigurator::configure(p);
+	}
 	Logging::initBackendLogging(&config);
 	Swift::SimpleEventLoop eventLoop;
 	loop_ = &eventLoop;
 	np = new TemplatePlugin(&config, &eventLoop, host, port);
 	loop_->run();
 	return 0;
+}

include/Swiften/TLS/OpenSSL/OpenSSLServerContext.cpp

➞

Show inline comments

 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 #include "Swiften/Base/Platform.h"
 #ifdef SWIFTEN_PLATFORM_WINDOWS
 #include <windows.h>
 #include <wincrypt.h>
 #endif
 #include <vector>
 #include <openssl/err.h>
 #include <openssl/pkcs12.h>
 #include "log4cxx/logger.h"
 #include "log4cxx/consoleappender.h"
 #include "log4cxx/patternlayout.h"
 #include "log4cxx/propertyconfigurator.h"
 using namespace log4cxx;
 static LoggerPtr logger = Logger::getLogger("OpenSSLServerContext");
 #include "transport/logging.h"
 DEFINE_LOGGER(logger, "OpenSSLServerContext");
 #include "Swiften/TLS/OpenSSL/OpenSSLServerContext.h"
 #include "Swiften/TLS/OpenSSL/OpenSSLCertificate.h"
 #include "Swiften/TLS/PKCS12Certificate.h"
 #ifndef _MSC_VER
 #pragma GCC diagnostic ignored "-Wold-style-cast"
 #endif
 namespace Swift {
 static const int MAX_FINISHED_SIZE = 4096;
 static const int SSL_READ_BUFFERSIZE = 8192;
 static void freeX509Stack(STACK_OF(X509)* stack) {
 	sk_X509_free(stack);
 }
 // static int _sx_ssl_verify_callback(int preverify_ok, X509_STORE_CTX *ctx) {
 // 	return 1;
 // }
 OpenSSLServerContext::OpenSSLServerContext() : state_(Start), context_(0), handle_(0), readBIO_(0), writeBIO_(0) {
 	ensureLibraryInitialized();
 	context_ = SSL_CTX_new(SSLv23_server_method());

include/transport/logging.h

➞

Show inline comments

@@ @@ -3,37 +3,59 @@ @@
+ *
  * 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 <stdio.h>
 #include <stdlib.h>
 #include <vector>
 #include <string>
 #include <iostream>
 #ifdef WITH_LOG4CXX
 #include "log4cxx/logger.h"
 #include "log4cxx/consoleappender.h"
 #include "log4cxx/patternlayout.h"
 #include "log4cxx/propertyconfigurator.h"
 #include "log4cxx/helpers/properties.h"
 #include "log4cxx/helpers/fileinputstream.h"
 #include "log4cxx/helpers/transcoder.h"
 #include "log4cxx/logger.h"
 #define DEFINE_LOGGER(VAR, NAME) static log4cxx::LoggerPtr VAR = log4cxx::Logger::getLogger(NAME);
 using namespace log4cxx;
 #else
 #define DEFINE_LOGGER(VARIABLE, NAME) static const char *VARIABLE = NAME;
 #define LOG4CXX_ERROR(LOGGER, DATA) std::cerr << "E: <" << LOGGER << "> " << DATA << "\n";
 #define LOG4CXX_WARN(LOGGER, DATA) std::cout << "W: <" << LOGGER << "> " << DATA << "\n";
 #define LOG4CXX_INFO(LOGGER, DATA) std::cout << "I: <" << LOGGER << "> " << DATA << "\n";
 #endif
 namespace Transport {
 class Config;
 namespace Logging {
 void initBackendLogging(Config *config);
 void initMainLogging(Config *config);
+}
+}

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_BINARY_DIR}/../../src/memoryusage.cpp)
 set(EXTRA_SOURCES ${EXTRA_SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/../../src/logging.cpp)
 set(EXTRA_SOURCES ${EXTRA_SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/../../src/config.cpp)
 set(EXTRA_SOURCES ${EXTRA_SOURCES} ${CMAKE_CURRENT_BINARY_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} ${PROTOBUF_SRC} ${PROTOBUF_HDRS} ${EXTRA_SOURCES})
 endif()
 ADD_DEPENDENCIES(transport-plugin pb)
 SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/../../include/transport/protocol.pb.cc PROPERTIES GENERATED 1)
 if (CMAKE_COMPILER_IS_GNUCXX)
 	ADD_DEFINITIONS(-fPIC)
 endif()
 if (NOT WIN32)
 	TARGET_LINK_LIBRARIES(transport-plugin ${PROTOBUF_LIBRARIES} ${LOG4CXX_LIBRARIES})
+	TARGET_LINK_LIBRARIES(transport-plugin ${PROTOBUF_LIBRARIES} ${LOG4CXX_LIBRARIES} ${Boost_LIBRARIES})
 else()
 	TARGET_LINK_LIBRARIES(transport-plugin ${PROTOBUF_LIBRARIES} ${LOG4CXX_LIBRARIES} ws2_32.lib)
+	TARGET_LINK_LIBRARIES(transport-plugin ${PROTOBUF_LIBRARIES} ${LOG4CXX_LIBRARIES} ${Boost_LIBRARIES} ws2_32.lib)
 endif()
 SET_TARGET_PROPERTIES(transport-plugin PROPERTIES
       VERSION ${TRANSPORT_VERSION} SOVERSION ${TRANSPORT_VERSION}
+)
 INSTALL(TARGETS transport-plugin LIBRARY DESTINATION lib ARCHIVE DESTINATION lib COMPONENT libraries)
 #CONFIGURE_FILE(transport.pc.in "${CMAKE_CURRENT_BINARY_DIR}/transport.pc")
 #INSTALL(FILES "${CMAKE_CURRENT_BINARY_DIR}/transport.pc" DESTINATION lib/pkgconfig)

plugin/cpp/networkplugin.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/networkplugin.h"
 #include "log4cxx/logger.h"
 #include "log4cxx/basicconfigurator.h"
 #include "transport/memoryusage.h"
 #include "transport/logging.h"
 #include <sstream>
 #ifndef WIN32
 #include <arpa/inet.h>
 #else
 #include <winsock2.h>
 #include <stdint.h>
 #include <process.h>
 #define getpid _getpid
 #endif
 using namespace log4cxx;
 static LoggerPtr logger = Logger::getLogger("NetworkPlugin");
 DEFINE_LOGGER(logger, "NetworkPlugin");
 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() {

spectrum/src/main.cpp

➞

Show inline comments

@@ @@ -5,62 +5,53 @@ @@
 #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 "Swiften/EventLoop/SimpleEventLoop.h"
 #include <boost/filesystem.hpp>
 #include <boost/algorithm/string.hpp>
 #ifndef WIN32
 #include "sys/signal.h"
 #include <pwd.h>
 #include <grp.h>
 #include <sys/resource.h>
 #include "libgen.h"
 #else
 #include <windows.h>
 #endif
 #include "log4cxx/logger.h"
 #include "log4cxx/consoleappender.h"
 #include "log4cxx/patternlayout.h"
 #include "log4cxx/propertyconfigurator.h"
 #include "log4cxx/helpers/properties.h"
 #include "log4cxx/helpers/transcoder.h"
 #include "log4cxx/helpers/fileinputstream.h"
 #include <sys/stat.h>
 using namespace log4cxx;
 using namespace Transport;
-static LoggerPtr logger = log4cxx::Logger::getLogger("Spectrum");
+DEFINE_LOGGER(logger, "Spectrum");
 Swift::SimpleEventLoop *eventLoop_ = NULL;
 Component *component_ = NULL;
 UserManager *userManager_ = NULL;
 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));

src/admininterface.cpp

➞

Show inline comments

@@ @@ -5,58 +5,56 @@ @@
+ *
  * 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/admininterface.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/storagebackend.h"
 #include "transport/conversationmanager.h"
 #include "transport/rostermanager.h"
 #include "transport/usermanager.h"
 #include "transport/networkpluginserver.h"
 #include "transport/logging.h"
 #include "storageresponder.h"
 #include "log4cxx/logger.h"
 #include "transport/memoryusage.h"
 #include <boost/foreach.hpp>
 using namespace log4cxx;
 namespace Transport {
-static LoggerPtr logger = Logger::getLogger("AdminInterface");
+DEFINE_LOGGER(logger, "AdminInterface");
 static std::string getArg(const std::string &body) {
 	std::string ret;
 	if (body.find(" ") == std::string::npos)
 		return ret;
 	return body.substr(body.find(" ") + 1);
+}
 AdminInterface::AdminInterface(Component *component, UserManager *userManager, NetworkPluginServer *server, StorageBackend *storageBackend) {
 	m_component = component;
 	m_storageBackend = storageBackend;
 	m_userManager = userManager;
 	m_server = server;
 	m_component->getStanzaChannel()->onMessageReceived.connect(bind(&AdminInterface::handleMessageReceived, this, _1));
+}
 AdminInterface::~AdminInterface() {
+}
 void AdminInterface::handleMessageReceived(Swift::Message::ref message) {
 	if (!message->getTo().getNode().empty())
 		return;

src/blockresponder.cpp

➞

Show inline comments

@@ @@ -8,58 +8,56 @@ @@
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "blockresponder.h"
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "transport/BlockPayload.h"
 #include "Swiften/Swiften.h"
 #include "transport/usermanager.h"
 #include "transport/user.h"
 #include "transport/buddy.h"
 #include "transport/rostermanager.h"
 #include "log4cxx/logger.h"
 using namespace log4cxx;
 #include "transport/logging.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
-static LoggerPtr logger = Logger::getLogger("BlockResponder");
+DEFINE_LOGGER(logger, "BlockResponder");
 BlockResponder::BlockResponder(Swift::IQRouter *router, UserManager *userManager) : Swift::SetResponder<BlockPayload>(router) {
 	m_userManager = userManager;
+}
 BlockResponder::~BlockResponder() {
+}
 bool BlockResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Transport::BlockPayload> info) {
 	User *user = m_userManager->getUser(from.toBare().toString());
 	if (!user) {
 		LOG4CXX_WARN(logger, from.toBare().toString() << ": User is not logged in");
 		return true;
+	}
 	Buddy *buddy = user->getRosterManager()->getBuddy(Buddy::JIDToLegacyName(to));
 	if (!buddy) {
 		LOG4CXX_WARN(logger, from.toBare().toString() << ": Buddy " << Buddy::JIDToLegacyName(to) << " does not exist");
 		return true;
+	}
 	if (buddy->isBlocked()) {
 		LOG4CXX_INFO(logger, from.toBare().toString() << ": Unblocking buddy " << Buddy::JIDToLegacyName(to));

src/config.cpp

➞

Show inline comments

 /**
  * libtransport -- C++ library for easy XMPP Transports development
+ *
  * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/config.h"
 #include "transport/util.h"
 #include <fstream>
 #ifdef _MSC_VER
 #include <direct.h>
 #define getcwd _getcwd
 #include <windows.h>
 #define PATH_MAX MAX_PATH
 #endif
 using namespace boost::program_options;
 namespace Transport {
 int getRandomPort(const std::string &s) {
 	unsigned long r = 0;
 	BOOST_FOREACH(char c, s) {
 		r += (int) c;
+	}
 	srand(time(NULL) + r);
 	return 30000 + rand() % 10000;
+}
 bool Config::load(const std::string &configfile, boost::program_options::options_description &opts, const std::string &jid) {
 	std::ifstream ifs(configfile.c_str());
 	if (!ifs.is_open())
 		return false;
 	m_file = configfile;
 	bool ret = load(ifs, opts, jid);
 	ifs.close();
 	char path[PATH_MAX] = "";
 	if (m_file.find_first_of("/") != 0) {
 		getcwd(path, PATH_MAX);
 		m_file = std::string(path) + "/" + m_file;
+	}
 	return ret;
+}
 bool Config::load(std::istream &ifs, boost::program_options::options_description &opts, const std::string &_jid) {
 	m_unregistered.clear();
 	opts.add_options()
 		("service.jid", value<std::string>()->default_value(""), "Transport Jabber ID")
 		("service.server", value<std::string>()->default_value(""), "Server to connect to")
 		("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.")
+	;
 	parsed_options parsed = parse_config_file(ifs, opts, true);
 	bool found_working = false;
 	bool found_pidfile = false;
 	bool found_backend_port = false;
 	bool found_database = false;
 	std::string jid = "";
 	BOOST_FOREACH(option &opt, parsed.options) {
 		if (opt.string_key == "service.jid") {
 			if (_jid.empty()) {
 				jid = opt.value[0];
+			}
 			else {
 				opt.value[0] = _jid;
 				jid = _jid;
+			}
+		}
 		else if (opt.string_key == "service.backend_port") {
 			found_backend_port = true;
 			if (opt.value[0] == "0") {
-				opt.value[0] = boost::lexical_cast<std::string>(Util::getRandomPort(_jid.empty() ? jid : _jid));
 				opt.value[0] = boost::lexical_cast<std::string>(getRandomPort(_jid.empty() ? jid : _jid));
+			}
+		}
 		else if (opt.string_key == "service.working_dir") {
 			found_working = true;
+		}
 		else if (opt.string_key == "service.pidfile") {
 			found_pidfile = true;
+		}
 		else if (opt.string_key == "database.database") {
 			found_database = true;
+		}
+	}
 	if (!found_working) {
 		std::vector<std::string> value;
 		value.push_back("/var/lib/spectrum2/$jid");
 		parsed.options.push_back(boost::program_options::basic_option<char>("service.working_dir", value));
+	}
 	if (!found_pidfile) {
 		std::vector<std::string> value;
 		value.push_back("/var/run/spectrum2/$jid.pid");
 		parsed.options.push_back(boost::program_options::basic_option<char>("service.pidfile", value));
+	}
 	if (!found_backend_port) {
 		std::vector<std::string> value;
-		std::string p = boost::lexical_cast<std::string>(Util::getRandomPort(_jid.empty() ? jid : _jid));
 		std::string p = boost::lexical_cast<std::string>(getRandomPort(_jid.empty() ? jid : _jid));
 		value.push_back(p);
 		parsed.options.push_back(boost::program_options::basic_option<char>("service.backend_port", value));
+	}
 	if (!found_database) {
 		std::vector<std::string> value;
 		value.push_back("/var/lib/spectrum2/$jid/database.sql");
 		parsed.options.push_back(boost::program_options::basic_option<char>("database.database", value));
+	}
 	BOOST_FOREACH(option &opt, parsed.options) {
 		if (opt.unregistered) {
 			m_unregistered[opt.string_key] = opt.value[0];
+		}
 		else if (opt.value[0].find("$jid") != std::string::npos) {
 			boost::replace_all(opt.value[0], "$jid", jid);
+		}
+	}
 	store(parsed, m_variables);
 	notify(m_variables);
 	onConfigReloaded();
 	return true;

src/conversation.cpp

➞

Show inline comments

@@ @@ -4,56 +4,51 @@ @@
  * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include <iostream>
 #include "transport/conversation.h"
 #include "transport/conversationmanager.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/buddy.h"
 #include "transport/rostermanager.h"
 #include "log4cxx/logger.h"
 using namespace log4cxx;
 namespace Transport {
 // static LoggerPtr logger = Logger::getLogger("Conversation");
 Conversation::Conversation(ConversationManager *conversationManager, const std::string &legacyName, bool isMUC) : m_conversationManager(conversationManager) {
 	m_legacyName = legacyName;
 	m_conversationManager->addConversation(this);
 	m_muc = isMUC;
 	m_jid = m_conversationManager->getUser()->getJID().toBare();
+}
 Conversation::~Conversation() {
+}
 void Conversation::setRoom(const std::string &room) {
 	m_room = room;
 	m_legacyName = m_room + "/" + m_legacyName;
+}
 void Conversation::handleMessage(boost::shared_ptr<Swift::Message> &message, const std::string &nickname) {
 	if (m_muc) {
 		message->setType(Swift::Message::Groupchat);
+	}
 	else {
 		message->setType(Swift::Message::Chat);
+	}
 	std::string n = nickname;

src/conversationmanager.cpp

➞

Show inline comments

@@ @@ -3,58 +3,56 @@ @@
+ *
  * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/conversationmanager.h"
 #include "transport/conversation.h"
 #include "transport/usermanager.h"
 #include "transport/buddy.h"
 #include "transport/factory.h"
 #include "transport/user.h"
 #include "transport/logging.h"
 #include "Swiften/Roster/SetRosterRequest.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/Elements/RosterItemPayload.h"
 #include "log4cxx/logger.h"
 using namespace log4cxx;
 namespace Transport {
-static LoggerPtr logger = Logger::getLogger("ConversationManager");
+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);
 		delete (*m_convs.begin()).second;
 		m_convs.erase(m_convs.begin());
+	}
+}
 void ConversationManager::addConversation(Conversation *conv) {
 	m_convs[conv->getLegacyName()] = conv;
 	LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Adding conversation " << conv->getLegacyName());
+}
 void ConversationManager::removeConversation(Conversation *conv) {
 	for (std::map<std::string, Conversation *>::const_iterator it = m_convs.begin(); it != m_convs.end(); it++) {
 		if ((*it).second->getRoom() == conv->getLegacyName()) {
 			(*it).second->setRoom("");
+		}

src/filetransfermanager.cpp

➞

Show inline comments

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

src/gatewayresponder.cpp

➞

Show inline comments

@@ @@ -7,57 +7,55 @@ @@
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/gatewayresponder.h"
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "Swiften/Elements/RawXMLPayload.h"
 #include "Swiften/Swiften.h"
 #include "transport/usermanager.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "log4cxx/logger.h"
 using namespace log4cxx;
 #include "transport/logging.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
-static LoggerPtr logger = Logger::getLogger("GatewayResponder");
+DEFINE_LOGGER(logger, "GatewayResponder");
 GatewayResponder::GatewayResponder(Swift::IQRouter *router, UserManager *userManager) : Swift::Responder<GatewayPayload>(router) {
 	m_userManager = userManager;
+}
 GatewayResponder::~GatewayResponder() {
+}
 bool GatewayResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::GatewayPayload> payload) {
 	sendResponse(from, id, boost::shared_ptr<GatewayPayload>(new GatewayPayload(Swift::JID(), "Enter legacy network contact ID.", "Contact ID")));
 	return true;
+}
 bool GatewayResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::GatewayPayload> payload) {
 	std::string prompt = payload->getPrompt();
 	std::string escaped = Swift::JID::getEscapedNode(prompt);
 	std::string jid = escaped + "@" + m_userManager->getComponent()->getJID().toBare().toString();
 	sendResponse(from, id, boost::shared_ptr<GatewayPayload>(new GatewayPayload(jid)));
 	return true;
+}
+}

src/logging.cpp

➞

Show inline comments

@@ @@ -4,77 +4,73 @@ @@
  * 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 <boost/foreach.hpp>
 #include <iostream>
 #include <iterator>
 #include <algorithm>
 #include "log4cxx/logger.h"
 #include "log4cxx/consoleappender.h"
 #include "log4cxx/patternlayout.h"
 #include "log4cxx/propertyconfigurator.h"
 #include "log4cxx/helpers/properties.h"
 #include "log4cxx/helpers/fileinputstream.h"
 #include "log4cxx/helpers/transcoder.h"
 #include <boost/filesystem.hpp>
 #include <boost/algorithm/string.hpp>
 #ifndef WIN32
 #include "sys/signal.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 log4cxx;
 namespace Transport {
 namespace Logging {
 #ifdef WITH_LOG4CXX
 using namespace log4cxx;
 static LoggerPtr root;
 static void initLogging(Config *config, std::string key) {
 	if (CONFIG_STRING(config, key).empty()) {
 		root = log4cxx::Logger::getRootLogger();
 #ifdef WIN32
 		root->addAppender(new ConsoleAppender(new PatternLayout(L"%d %-5p %c: %m%n")));
 #else
 		root->addAppender(new ConsoleAppender(new PatternLayout("%d %-5p %c: %m%n")));
 #endif
+	}
 	else {
 		log4cxx::helpers::Properties p;
 		log4cxx::helpers::FileInputStream *istream = NULL;
 		try {
 			istream = new log4cxx::helpers::FileInputStream(CONFIG_STRING(config, key));
+		}
 		catch(log4cxx::helpers::IOException &ex) {
 			std::cerr << "Can't create FileInputStream logger instance: " << ex.what() << "\n";
+		}
 		catch (...) {
 			std::cerr << "Can't create FileInputStream logger instance\n";
+		}
 					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);
+	}
+}
 void initBackendLogging(Config *config) {
 	initLogging(config, "logging.backend_config");
+}
 void initMainLogging(Config *config) {
 	initLogging(config, "logging.config");
+}
 #else /* WITH_LOG4CXX */
 void initBackendLogging(Config */*config*/) {
+}
 void initMainLogging(Config */*config*/) {
+}
 #endif /* WITH_LOG4CXX */
+}
+}

src/memoryreadbytestream.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/memoryreadbytestream.h"
 #include "log4cxx/logger.h"
 #include <boost/foreach.hpp>
 using namespace log4cxx;
 namespace Transport {
 MemoryReadBytestream::MemoryReadBytestream(unsigned long size) {
 	neededData = false;
 	m_finished = false;
 	m_sent = 0;
 	m_size = size;
+}
 MemoryReadBytestream::~MemoryReadBytestream() {
+}
 unsigned long MemoryReadBytestream::appendData(const std::string &data) {
 	m_data += data;
 	onDataAvailable();
 	neededData = false;
 	return m_data.size();
+}
 boost::shared_ptr<std::vector<unsigned char> > MemoryReadBytestream::read(size_t size) {
 	if (m_data.empty()) {
 		onDataNeeded();
 		return boost::shared_ptr<std::vector<unsigned char> >(new std::vector<unsigned char>());

src/mysqlbackend.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
  */
 #ifdef WITH_MYSQL
 #include "transport/mysqlbackend.h"
 #include "transport/util.h"
 #include "transport/logging.h"
 #include <boost/bind.hpp>
 #include "log4cxx/logger.h"
 using namespace log4cxx;
 #define MYSQL_DB_VERSION 2
 #define CHECK_DB_RESPONSE(stmt) \
 	if(stmt) { \
 		sqlite3_EXEC(m_db, "ROLLBACK;", NULL, NULL, NULL); \
 		return 0; \
+	}
 // Prepare the SQL statement
 #define PREP_STMT(sql, str) \
 	sql = mysql_stmt_init(&m_conn);\
 	if (mysql_stmt_prepare(sql, std::string(str).c_str(), std::string(str).size())) {\
 		LOG4CXX_ERROR(logger, str << " " << mysql_error(&m_conn)); \
 		return false; \
+	}
 // Finalize the prepared statement
 #define FINALIZE_STMT(prep) \
 	if(prep != NULL) { \
 		mysql_stmt_close(prep); \
+	}
 #define BEGIN(STATEMENT, SIZE) 	MYSQL_BIND STATEMENT##_bind[SIZE]; \
 							memset(STATEMENT##_bind, 0, sizeof(STATEMENT##_bind)); \
@@ @@ -71,49 +69,49 @@ using namespace log4cxx; @@
 	} \
 	if (mysql_stmt_execute(STATEMENT)) { \
 		LOG4CXX_ERROR(logger, NAME << " " << mysql_error(&m_conn)); \
+	}
 #define EXEC(STMT, METHOD) \
 	{\
 	int ret = STMT->execute(); \
 	if (ret == 0) \
 		exec_ok = true; \
 	else if (ret == 2013) { \
 		LOG4CXX_INFO(logger, "MySQL connection lost. Reconnecting...");\
 		disconnect(); \
 		connect(); \
 		return METHOD; \
 	} \
 	else \
 		exec_ok = false; \
+	}
 using namespace boost;
 namespace Transport {
-static LoggerPtr logger = Logger::getLogger("MySQLBackend");
+DEFINE_LOGGER(logger, "MySQLBackend");
 static bool exec_ok;
 MySQLBackend::Statement::Statement(MYSQL *conn, const std::string &format, const std::string &statement) {
 	m_resultOffset = -1;
 	m_conn = conn;
 	m_offset = 0;
 	m_string = statement;
 	m_stmt = mysql_stmt_init(conn);
 	if (mysql_stmt_prepare(m_stmt, statement.c_str(), statement.size())) {
 		LOG4CXX_ERROR(logger, statement << " " << mysql_error(conn));
 		return;
+	}
 	for (int i = 0; i < format.length() && m_resultOffset == -1; i++) {
 		switch (format.at(i)) {
 			case 's':
 				m_params.resize(m_params.size() + 1);
 				memset(&m_params.back(), 0, sizeof(MYSQL_BIND));
 				m_params.back().buffer_type= MYSQL_TYPE_STRING;
 				m_params.back().buffer= (char *) malloc(sizeof(char) * 4096);
 				m_params.back().buffer_length= 4096;
 				m_params.back().is_null= 0;
 				m_params.back().length= (unsigned long *) malloc(sizeof(unsigned long));

src/networkpluginserver.cpp

➞

Show inline comments

@@ @@ -10,80 +10,78 @@ @@
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/networkpluginserver.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/storagebackend.h"
 #include "transport/rostermanager.h"
 #include "transport/usermanager.h"
 #include "transport/conversationmanager.h"
 #include "transport/localbuddy.h"
 #include "transport/config.h"
 #include "transport/conversation.h"
 #include "transport/vcardresponder.h"
 #include "transport/rosterresponder.h"
 #include "transport/memoryreadbytestream.h"
 #include "transport/logging.h"
 #include "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 "log4cxx/logger.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 "popt.h"
 #endif
 using namespace log4cxx;
 namespace Transport {
 static unsigned long backend_id;
 static unsigned long bytestream_id;
-static LoggerPtr logger = Logger::getLogger("NetworkPluginServer");
+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;
+		}
 		// Creates new conversation (NetworkConversation in this case)
 		Conversation *createConversation(ConversationManager *conversationManager, const std::string &legacyName) {
 			NetworkConversation *nc = new NetworkConversation(conversationManager, legacyName);
 			nc->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, m_nps, _1, _2));

src/rostermanager.cpp

➞

Show inline comments

@@ @@ -4,63 +4,61 @@ @@
  * 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/rostermanager.h"
 #include "transport/rosterstorage.h"
 #include "transport/storagebackend.h"
 #include "transport/buddy.h"
 #include "transport/usermanager.h"
 #include "transport/buddy.h"
 #include "transport/user.h"
 #include "transport/logging.h"
 #include "Swiften/Roster/SetRosterRequest.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/Elements/RosterItemPayload.h"
 #include "Swiften/Elements/RosterItemExchangePayload.h"
 #include "log4cxx/logger.h"
 #include <boost/foreach.hpp>
 #include <map>
 #include <iterator>
 using namespace log4cxx;
 namespace Transport {
-static LoggerPtr logger = Logger::getLogger("RosterManager");
+DEFINE_LOGGER(logger, "RosterManager");
 RosterManager::RosterManager(User *user, Component *component){
 	m_rosterStorage = NULL;
 	m_user = user;
 	m_component = component;
 	m_setBuddyTimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(1000);
 	m_RIETimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(5000);
 	m_RIETimer->onTick.connect(boost::bind(&RosterManager::sendRIE, this));
 	m_supportRemoteRoster = false;
 	if (!m_component->inServerMode()) {
 		m_remoteRosterRequest = AddressedRosterRequest::ref(new AddressedRosterRequest(m_component->getIQRouter(), m_user->getJID().toBare()));
 		m_remoteRosterRequest->onResponse.connect(boost::bind(&RosterManager::handleRemoteRosterResponse, this, _1, _2));
 		m_remoteRosterRequest->send();
+	}
+}
 RosterManager::~RosterManager() {
 	m_setBuddyTimer->stop();
 	m_RIETimer->stop();
 	if (m_rosterStorage) {
 		m_rosterStorage->storeBuddies();
+	}

src/rosterresponder.cpp

➞

Show inline comments

@@ @@ -7,58 +7,56 @@ @@
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/rosterresponder.h"
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "Swiften/Swiften.h"
 #include "transport/user.h"
 #include "transport/usermanager.h"
 #include "transport/rostermanager.h"
 #include "transport/buddy.h"
 #include "log4cxx/logger.h"
 using namespace log4cxx;
 #include "transport/logging.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
-static LoggerPtr logger = Logger::getLogger("RosterResponder");
+DEFINE_LOGGER(logger, "RosterResponder");
 RosterResponder::RosterResponder(Swift::IQRouter *router, UserManager *userManager) : Swift::Responder<RosterPayload>(router) {
 	m_userManager = userManager;
+}
 RosterResponder::~RosterResponder() {
+}
 bool RosterResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload) {
 	// Get means we're in server mode and user wants to fetch his roster.
 	// For now we send empty reponse, but TODO: Get buddies from database and send proper stored roster.
 	User *user = m_userManager->getUser(from.toBare().toString());
 	if (!user) {
 		sendResponse(from, id, boost::shared_ptr<RosterPayload>(new RosterPayload()));
 		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()));

src/sqlite3backend.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
  */
 #ifdef WITH_SQLITE
 #include "transport/sqlite3backend.h"
 #include "transport/util.h"
 #include "transport/logging.h"
 #include <boost/bind.hpp>
 #include "log4cxx/logger.h"
 using namespace log4cxx;
 #define SQLITE_DB_VERSION 3
 #define CHECK_DB_RESPONSE(stmt) \
 	if(stmt) { \
 		sqlite3_exec(m_db, "ROLLBACK;", NULL, NULL, NULL); \
 		return 0; \
+	}
 // Prepare the SQL statement
 #define PREP_STMT(sql, str) \
 	if(sqlite3_prepare_v2(m_db, std::string(str).c_str(), -1, &sql, NULL)) { \
 		LOG4CXX_ERROR(logger, str<< (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db))); \
 		return false; \
+	}
 // Finalize the prepared statement
 #define FINALIZE_STMT(prep) \
 	if(prep != NULL) { \
 		sqlite3_finalize(prep); \
+	}
 #define BEGIN(STATEMENT) 	sqlite3_reset(STATEMENT);\
 							int STATEMENT##_id = 1;\
 							int STATEMENT##_id_get = 0;\
 							(void)STATEMENT##_id_get;
 #define BIND_INT(STATEMENT, VARIABLE) sqlite3_bind_int(STATEMENT, STATEMENT##_id++, VARIABLE)
 #define BIND_STR(STATEMENT, VARIABLE) sqlite3_bind_text(STATEMENT, STATEMENT##_id++, VARIABLE.c_str(), -1, SQLITE_STATIC)
 #define RESET_GET_COUNTER(STATEMENT)	STATEMENT##_id_get = 0;
 #define GET_INT(STATEMENT)	sqlite3_column_int(STATEMENT, STATEMENT##_id_get++)
 #define GET_STR(STATEMENT)	(const char *) sqlite3_column_text(STATEMENT, STATEMENT##_id_get++)
 #define EXECUTE_STATEMENT(STATEMENT, NAME) 	if(sqlite3_step(STATEMENT) != SQLITE_DONE) {\
 		LOG4CXX_ERROR(logger, NAME<< (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));\
+			}
 using namespace boost;
 namespace Transport {
-static LoggerPtr logger = Logger::getLogger("SQLite3Backend");
+DEFINE_LOGGER(logger, "SQLite3Backend");
 SQLite3Backend::SQLite3Backend(Config *config) {
 	m_config = config;
 	m_db = NULL;
 	m_prefix = CONFIG_STRING(m_config, "database.prefix");
+}
 SQLite3Backend::~SQLite3Backend(){
 	if (m_db) {
 		// Would be nice to use this:
 		//
 		//   sqlite3_stmt *pStmt;
 		//   while((pStmt = sqlite3_next_stmt(db, 0)) != 0 ) {
 		//    sqlite3_finalize(pStmt);
 		//   }
 		//
 		// But requires SQLite3 >= 3.6.0 beta
 		FINALIZE_STMT(m_setUser);
 		FINALIZE_STMT(m_getUser);
 		FINALIZE_STMT(m_removeUser);
 		FINALIZE_STMT(m_removeUserBuddies);
 		FINALIZE_STMT(m_removeUserSettings);
 		FINALIZE_STMT(m_removeUserBuddiesSettings);

src/statsresponder.cpp

➞

Show inline comments

@@ @@ -13,58 +13,56 @@ @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/statsresponder.h"
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "transport/BlockPayload.h"
 #include "Swiften/Swiften.h"
 #include "transport/usermanager.h"
 #include "transport/user.h"
 #include "transport/buddy.h"
 #include "transport/rostermanager.h"
 #include "transport/memoryusage.h"
 #include "transport/conversationmanager.h"
 #include "transport/rostermanager.h"
 #include "transport/usermanager.h"
 #include "transport/networkpluginserver.h"
 #include "log4cxx/logger.h"
 using namespace log4cxx;
 #include "transport/logging.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
-static LoggerPtr logger = Logger::getLogger("StatsResponder");
+DEFINE_LOGGER(logger, "StatsResponder");
 StatsResponder::StatsResponder(Component *component, UserManager *userManager, NetworkPluginServer *server, StorageBackend *storageBackend) : Swift::Responder<StatsPayload>(component->getIQRouter()) {
 	m_component = component;
 	m_userManager = userManager;
 	m_server = server;
 	m_storageBackend = storageBackend;
 	m_start = time(0);
+}
 StatsResponder::~StatsResponder() {
+}
 unsigned long StatsResponder::usedMemory() {
 	double shared = 0;
 	double rss = 0;
 #ifndef WIN32
 	process_mem_usage(shared, rss);
 #endif
 	rss -= shared;
 	const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();
 	BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {
 		rss += backend->res - backend->shared;

src/storageresponder.cpp

➞

Show inline comments

@@ @@ -6,58 +6,56 @@ @@
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "storageresponder.h"
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "Swiften/Elements/RawXMLPayload.h"
 #include "Swiften/Swiften.h"
 #include "transport/usermanager.h"
 #include "transport/user.h"
 #include "log4cxx/logger.h"
 using namespace log4cxx;
 #include "transport/logging.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
-static LoggerPtr logger = Logger::getLogger("StorageResponder");
+DEFINE_LOGGER(logger, "StorageResponder");
 StorageResponder::StorageResponder(Swift::IQRouter *router, StorageBackend *storageBackend, UserManager *userManager) : Swift::Responder<PrivateStorage>(router) {
 	m_storageBackend = storageBackend;
 	m_userManager = userManager;
+}
 StorageResponder::~StorageResponder() {
+}
 bool StorageResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::PrivateStorage> payload) {
 	User *user = m_userManager->getUser(from.toBare().toString());
 	if (!user) {
 		LOG4CXX_WARN(logger, from.toBare().toString() << ": User is not logged in");
 		sendError(from, id, ErrorPayload::NotAcceptable, ErrorPayload::Cancel);
 		return true;
+	}
 	int type = 0;
 	std::string value = "";
 	m_storageBackend->getUserSetting(user->getUserInfo().id, "storage", type, value);
 	LOG4CXX_INFO(logger, from.toBare().toString() << ": Sending jabber:iq:storage");
 	sendResponse(from, id, boost::shared_ptr<PrivateStorage>(new PrivateStorage(boost::shared_ptr<RawXMLPayload>(new RawXMLPayload(value)))));
 	return true;

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
 	// 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);
 	// 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/transport.cpp

➞

Show inline comments

@@ @@ -3,81 +3,77 @@ @@
+ *
  * 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/transport.h"
 #include <boost/bind.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 "discoitemsresponder.h"
 #include "storageparser.h"
 #include "Swiften/TLS/OpenSSL/OpenSSLServerContext.h"
 #include "Swiften/TLS/PKCS12Certificate.h"
 #include "Swiften/TLS/OpenSSL/OpenSSLServerContextFactory.h"
 #include "Swiften/Parser/PayloadParsers/AttentionParser.h"
 #include "Swiften/Serializer/PayloadSerializers/AttentionSerializer.h"
 #include "Swiften/Parser/PayloadParsers/XHTMLIMParser.h"
 #include "Swiften/Serializer/PayloadSerializers/XHTMLIMSerializer.h"
 #include "Swiften/Parser/PayloadParsers/StatsParser.h"
 #include "Swiften/Serializer/PayloadSerializers/StatsSerializer.h"
 #include "Swiften/Parser/PayloadParsers/GatewayPayloadParser.h"
 #include "Swiften/Serializer/PayloadSerializers/GatewayPayloadSerializer.h"
 #include "Swiften/Serializer/PayloadSerializers/SpectrumErrorSerializer.h"
 #include "transport/BlockParser.h"
 #include "transport/BlockSerializer.h"
 #include "Swiften/Parser/PayloadParsers/InvisibleParser.h"
 #include "Swiften/Serializer/PayloadSerializers/InvisibleSerializer.h"
 #include "log4cxx/logger.h"
 #include "log4cxx/consoleappender.h"
 #include "log4cxx/patternlayout.h"
 #include "log4cxx/propertyconfigurator.h"
 #include "Swiften/Swiften.h"
 using namespace Swift;
 using namespace boost;
 using namespace log4cxx;
 namespace Transport {
 static LoggerPtr logger = Logger::getLogger("Component");
 static LoggerPtr logger_xml = Logger::getLogger("Component.XML");
 DEFINE_LOGGER(logger, "Component");
 DEFINE_LOGGER(logger_xml, "Component.XML");
 Component::Component(Swift::EventLoop *loop, Swift::NetworkFactories *factories, Config *config, Factory *factory, Transport::UserRegistry *userRegistry) {
 	m_component = NULL;
 	m_userRegistry = NULL;
 	m_server = NULL;
 	m_reconnectCount = 0;
 	m_config = config;
 	m_factory = factory;
 	m_loop = loop;
 	m_userRegistry = userRegistry;
 	m_jid = Swift::JID(CONFIG_STRING(m_config, "service.jid"));
 	m_factories = factories;
 	m_reconnectTimer = m_factories->getTimerFactory()->createTimer(3000);
 	m_reconnectTimer->onTick.connect(bind(&Component::start, this));
 	if (CONFIG_BOOL(m_config, "service.server_mode")) {
 		LOG4CXX_INFO(logger, "Creating component in server mode on port " << CONFIG_INT(m_config, "service.port"));
 		m_server = new Swift::Server(loop, m_factories, m_userRegistry, m_jid, CONFIG_INT(m_config, "service.port"));
 		if (!CONFIG_STRING(m_config, "service.cert").empty()) {
 			LOG4CXX_INFO(logger, "Using PKCS#12 certificate " << CONFIG_STRING(m_config, "service.cert"));
 			LOG4CXX_INFO(logger, "SSLv23_server_method used.");

src/user.cpp

➞

Show inline comments

@@ @@ -4,66 +4,65 @@ @@
  * 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/user.h"
 #include "transport/transport.h"
 #include "transport/storagebackend.h"
 #include "transport/rostermanager.h"
 #include "transport/usermanager.h"
 #include "transport/conversationmanager.h"
 #include "transport/presenceoracle.h"
 #include "transport/logging.h"
 #include "Swiften/Swiften.h"
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Elements/StreamError.h"
 #include "Swiften/Elements/MUCPayload.h"
 #include "Swiften/Elements/SpectrumErrorPayload.h"
 #include "log4cxx/logger.h"
 #include <boost/foreach.hpp>
 #include <stdio.h>
 #include <stdlib.h>
 using namespace log4cxx;
 using namespace boost;
 #define foreach         BOOST_FOREACH
 namespace Transport {
-static LoggerPtr logger = Logger::getLogger("User");
+DEFINE_LOGGER(logger, "User");
 User::User(const Swift::JID &jid, UserInfo &userInfo, Component *component, UserManager *userManager) {
 	m_jid = jid.toBare();
 	m_data = NULL;
 	m_component = component;
 	m_presenceOracle = component->m_presenceOracle;
 	m_entityCapsManager = component->m_entityCapsManager;
 	m_userManager = userManager;
 	m_userInfo = userInfo;
 	m_connected = false;
 	m_readyForConnect = false;
 	m_ignoreDisconnect = false;
 	m_resources = 0;
 	m_reconnectCounter = 0;
 	m_reconnectTimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(10000);
 	m_reconnectTimer->onTick.connect(boost::bind(&User::onConnectingTimeout, this));
 	m_rosterManager = new RosterManager(this, m_component);
 	m_conversationManager = new ConversationManager(this, m_component);
 	LOG4CXX_INFO(logger, m_jid.toString() << ": Created");
 	updateLastActivity();
+}

src/usermanager.cpp

➞

Show inline comments

@@ @@ -4,61 +4,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
  */
 #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 "storageresponder.h"
-#include "log4cxx/logger.h"
 #include "Swiften/Swiften.h"
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Elements/StreamError.h"
 #include "malloc.h"
 // #include "valgrind/memcheck.h"
 using namespace log4cxx;
 namespace Transport {
-static LoggerPtr logger = Logger::getLogger("UserManager");
+DEFINE_LOGGER(logger, "UserManager");
 UserManager::UserManager(Component *component, UserRegistry *userRegistry, 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;
 	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));

src/userregistration.cpp

➞

Show inline comments

@@ @@ -3,60 +3,59 @@ @@
+ *
  * 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/userregistration.h"
 #include "transport/usermanager.h"
 #include "transport/storagebackend.h"
 #include "transport/transport.h"
 #include "transport/rostermanager.h"
 #include "transport/user.h"
 #include "transport/logging.h"
 #include "Swiften/Elements/ErrorPayload.h"
 #include <boost/shared_ptr.hpp>
 #include <boost/thread.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
 #include "log4cxx/logger.h"
 using namespace Swift;
 using namespace log4cxx;
 namespace Transport {
-static LoggerPtr logger = Logger::getLogger("UserRegistration");
+DEFINE_LOGGER(logger, "UserRegistration");
 UserRegistration::UserRegistration(Component *component, UserManager *userManager, StorageBackend *storageBackend) : Swift::Responder<Swift::InBandRegistrationPayload>(component->m_iqRouter) {
 	m_component = component;
 	m_config = m_component->m_config;
 	m_storageBackend = storageBackend;
 	m_userManager = userManager;
+}
 UserRegistration::~UserRegistration(){
+}
 bool UserRegistration::registerUser(const UserInfo &row) {
 	UserInfo user;
 	bool registered = m_storageBackend->getUser(row.jid, user);
 	// This user is already registered
 	if (registered)
 		return false;
 	m_storageBackend->setUser(row);
 	Swift::Presence::ref response = Swift::Presence::create();
 	response->setFrom(m_component->getJID());
 	response->setTo(Swift::JID(row.jid));
 	response->setType(Swift::Presence::Subscribe);

src/userregistry.cpp

➞

Show inline comments

@@ @@ -2,55 +2,53 @@ @@
  * 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 <string>
 #include <map>
 #include "Swiften/Swiften.h"
 #include "Swiften/Server/UserRegistry.h"
 #include "transport/userregistry.h"
 #include "log4cxx/logger.h"
 using namespace log4cxx;
 #include "transport/logging.h"
 namespace Transport {
-static LoggerPtr logger = Logger::getLogger("UserRegistry");
+DEFINE_LOGGER(logger, "UserRegistry");
 UserRegistry::UserRegistry(Config *cfg, Swift::NetworkFactories *factories) {
 	config = cfg;
 	m_removeTimer = factories->getTimerFactory()->createTimer(1);
 	m_inRemoveLater = false;
+}
 UserRegistry::~UserRegistry() { m_removeTimer->stop(); }
 void UserRegistry::isValidUserPassword(const Swift::JID& user, Swift::ServerFromClientSession *session, const Swift::SafeByteArray& password) {
 	if (!CONFIG_STRING(config, "service.admin_jid").empty() && user.toBare().toString() == CONFIG_STRING(config, "service.admin_jid")) {
 		if (Swift::safeByteArrayToString(password) == CONFIG_STRING(config, "service.admin_password")) {
 			session->handlePasswordValid();
+		}
 		else {
 			session->handlePasswordInvalid();
+		}
 		return;
+	}
 	std::string key = user.toBare().toString();
 	// Users try to connect twice
 	if (users.find(key) != users.end()) {

src/usersreconnecter.cpp

➞

Show inline comments

@@ @@ -5,58 +5,56 @@ @@
+ *
  * 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/usersreconnecter.h"
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "Swiften/Swiften.h"
 #include "transport/storagebackend.h"
 #include "transport/transport.h"
 #include "log4cxx/logger.h"
 using namespace log4cxx;
 #include "transport/logging.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
-static LoggerPtr logger = Logger::getLogger("UserReconnecter");
+DEFINE_LOGGER(logger, "UserReconnecter");
 UsersReconnecter::UsersReconnecter(Component *component, StorageBackend *storageBackend) {
 	m_component = component;
 	m_storageBackend = storageBackend;
 	m_started = false;
 	m_nextUserTimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(1000);
 	m_nextUserTimer->onTick.connect(boost::bind(&UsersReconnecter::reconnectNextUser, this));
 	m_component->onConnected.connect(bind(&UsersReconnecter::handleConnected, this));
+}
 UsersReconnecter::~UsersReconnecter() {
 	m_component->onConnected.disconnect(bind(&UsersReconnecter::handleConnected, this));
 	m_nextUserTimer->stop();
 	m_nextUserTimer->onTick.disconnect(boost::bind(&UsersReconnecter::reconnectNextUser, this));
+}
 void UsersReconnecter::reconnectNextUser() {
 	if (m_users.empty()) {
 		LOG4CXX_INFO(logger, "All users reconnected, stopping UserReconnecter.");
 		return;
+	}

src/vcardresponder.cpp

➞

Show inline comments

@@ @@ -7,58 +7,56 @@ @@
  * 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/vcardresponder.h"
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "Swiften/Swiften.h"
 #include "transport/user.h"
 #include "transport/usermanager.h"
 #include "transport/rostermanager.h"
 #include "transport/transport.h"
 #include "log4cxx/logger.h"
 using namespace log4cxx;
 #include "transport/logging.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
-static LoggerPtr logger = Logger::getLogger("VCardResponder");
+DEFINE_LOGGER(logger, "VCardResponder");
 VCardResponder::VCardResponder(Swift::IQRouter *router, Swift::NetworkFactories *factories, UserManager *userManager) : Swift::Responder<VCard>(router) {
 	m_id = 0;
 	m_userManager = userManager;
 	m_collectTimer = factories->getTimerFactory()->createTimer(20000);
 	m_collectTimer->onTick.connect(boost::bind(&VCardResponder::collectTimeouted, this));
 	m_collectTimer->start();
+}
 VCardResponder::~VCardResponder() {
+}
 void VCardResponder::sendVCard(unsigned int id, boost::shared_ptr<Swift::VCard> vcard) {
 	if (m_queries.find(id) == m_queries.end()) {
 		LOG4CXX_WARN(logger, "Unexpected VCard from legacy network with id " << id);
 		return;
+	}
 	LOG4CXX_INFO(logger, m_queries[id].from.toString() << ": Forwarding VCard of " << m_queries[id].to.toString() << " from legacy network");
 	sendResponse(m_queries[id].from, m_queries[id].to, m_queries[id].id, vcard);
 	m_queries.erase(id);
+}

0 comments (0 inline, 0 general)