libtransport.git Changeset - 9331f56079ad

Changeset - 9331f56079ad

Parent rev.

Child rev.

[Not reviewed]

Merge

! ! !

Daniel Henninger - 14 years ago 2012-05-07 17:18:54
daniel@vorpalcloud.org

Merge remote-tracking branch 'upstream/master'

43 files changed:

CMakeLists.txt

ChangeLog

backends/CMakeLists.txt

backends/libcommuni/ircnetworkplugin.cpp

backends/libcommuni/main.cpp

backends/libcommuni/session.cpp

backends/libcommuni/singleircnetworkplugin.cpp

backends/libpurple/gen_dynamic_purple.py

251

backends/libpurple/geventloop.cpp

backends/libpurple/main.cpp

208

489

backends/libpurple/purple_defs.cpp

backends/libpurple/purple_defs.h

backends/libpurple/utils.cpp

153

backends/libpurple/utils.h

backends/skype/main.cpp

174

backends/smstools3/main.cpp

backends/template/CMakeLists.txt

backends/template/README

backends/template/main.cpp

153

backends/template/template_backend.py

103

cmake_modules/CommuniConfig.cmake

docs/Doxyfile

1510

include/Swiften/Elements/GatewayPayload.cpp

include/Swiften/Elements/GatewayPayload.h

include/Swiften/Elements/PubSubItem.cpp

include/Swiften/Elements/PubSubItem.h

include/Swiften/Elements/PubSubPayload.cpp

include/Swiften/Elements/PubSubPayload.h

include/Swiften/Elements/PubSubPublishPayload.cpp

include/Swiften/Elements/PubSubPublishPayload.h

include/Swiften/Elements/PubSubSubscribePayload.cpp

include/Swiften/Elements/PubSubSubscribePayload.h

include/Swiften/Elements/PubSubSubscriptionPayload.cpp

include/Swiften/Elements/PubSubSubscriptionPayload.h

include/Swiften/Network/DummyNetworkFactories.cpp

include/Swiften/Network/DummyNetworkFactories.h

include/Swiften/Parser/PayloadParsers/GatewayPayloadParser.cpp

include/Swiften/Parser/PayloadParsers/GatewayPayloadParser.h

include/Swiften/Parser/PayloadParsers/MUCPayloadParser.cpp

include/Swiften/Parser/PayloadParsers/MUCPayloadParser.h

include/Swiften/Parser/PayloadParsers/PubSubItemParser.cpp

include/Swiften/Parser/PayloadParsers/PubSubItemParser.h

include/Swiften/Parser/PayloadParsers/PubSubPayloadParser.cpp

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

0 comments (0 inline, 0 general)

CMakeLists.txt

➞

Show inline comments

 cmake_minimum_required(VERSION 2.6)
 project(libtransport)
 if(NOT LIB_INSTALL_DIR)
 	set(LIB_INSTALL_DIR "lib")
 endif()
 set(CMAKE_MODULE_PATH "cmake_modules")
 set(cppunit_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(cppunit)
 set(sqlite3_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(sqlite3)
 set(mysql_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(mysql)
 set(purple_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(purple)
 set(glib_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(glib)
 if (NOT WIN32)
 	set(popt_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 	find_package(popt)
 endif()
 set(event_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(event)
 set(Swiften_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
-find_package(Swiften REQUIRED)
 find_package(Swiften)
 set(openssl_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
-find_package(openssl REQUIRED)
 find_package(openssl)
 set(Boost_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 if (WIN32)
 set(Boost_USE_STATIC_LIBS        ON)
 set(Boost_USE_MULTITHREADED      ON)
 set(Boost_USE_STATIC_RUNTIME    OFF)
 endif()
 find_package(Boost COMPONENTS program_options date_time system filesystem regex  signals REQUIRED)
 message( STATUS "Found Boost: ${Boost_LIBRARIES}, ${Boost_INCLUDE_DIR}")
 set(Protobuf_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(Protobuf REQUIRED)
 set(Communi_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(Communi)
 set(log4cxx_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(log4cxx)
 set(event_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(event)
 set(pqxx_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(pqxx)
 set(dbus_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(dbus)
 find_package(Doxygen)
 INCLUDE(FindQt4)
 FIND_PACKAGE(Qt4 COMPONENTS QtCore QtNetwork)
 # ADD_DEFINITIONS(${SWIFTEN_CFLAGS})
 ADD_DEFINITIONS(-DSUPPORT_LEGACY_CAPS)
 ADD_DEFINITIONS(-DBOOST_FILESYSTEM_VERSION=2)
 message("  Supported features")
 message("-----------------------")
 if (SPECTRUM_VERSION)
 	ADD_DEFINITIONS(-DSPECTRUM_VERSION="${SPECTRUM_VERSION}")
 else (SPECTRUM_VERSION)
 	if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
 		execute_process(COMMAND git "--git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git" rev-parse --short HEAD
 						OUTPUT_VARIABLE GIT_REVISION
 						OUTPUT_STRIP_TRAILING_WHITESPACE
+		)
@@ @@ -122,116 +126,119 @@ if (PROTOBUF_FOUND) @@
 	include_directories(${PROTOBUF_INCLUDE_DIRS})
 	message("Network plugins   : yes")
 	if(PURPLE_LIBRARY AND PURPLE_INCLUDE_DIR)
 		message("Libpurple plugin  : yes")
 		include_directories(${PURPLE_INCLUDE_DIR})
 		include_directories(${GLIB2_INCLUDE_DIR})
 	else()
 		message("Libpurple plugin  : no (install libpurple)")
 	endif()
 	if (HAVE_EVENT)
 		ADD_DEFINITIONS(-DWITH_LIBEVENT)
 		include_directories(${EVENT_INCLUDE_DIRS})
 		message("  libev eventloop : yes")
 	else()
 		message("  libev eventloop : no (install libev-devel)")
 	endif()
 	if(IRC_FOUND)
 		ADD_DEFINITIONS(-DCOMMUNI_SHARED)
 		message("IRC plugin        : yes")
 		include_directories(${QT_QTNETWORK_INCLUDE_DIR})
 		include_directories(${IRC_INCLUDE_DIR})
 		include(${QT_USE_FILE})
 	else()
 		message("IRC plugin        : no (install libCommuni and libprotobuf-dev)")
 	endif()
 	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)
 	message("Debug             : yes")
 else(CMAKE_BUILD_TYPE MATCHES Debug)
 	message("Debug             : no (run \"cmake . -DCMAKE_BUILD_TYPE=Debug\")")
 endif(CMAKE_BUILD_TYPE MATCHES Debug)
 SET(TRANSPORT_VERSION 2.0)
 SET(PROJECT_VERSION 2.0)
 include_directories(include)
 include_directories(${EVENT_INCLUDE_DIRS})
 include_directories(${SWIFTEN_INCLUDE_DIR})
 include_directories(${Boost_INCLUDE_DIRS})
 include_directories(${OPENSSL_INCLUDE_DIR})
 ADD_SUBDIRECTORY(src)
 ADD_SUBDIRECTORY(plugin)
 ADD_SUBDIRECTORY(include)
 ADD_SUBDIRECTORY(spectrum)
 ADD_SUBDIRECTORY(backends)
 if (NOT WIN32)
 	ADD_SUBDIRECTORY(spectrum_manager)
 #	ADD_SUBDIRECTORY(spectrum2_send_message)
 endif()
 if (CPPUNIT_FOUND)
 	message("tests             : yes")
 	include_directories(${CPPUNIT_INCLUDE_DIR})
 else()
 	message("tests             : no (install CPPUnit)")
 endif()
 if(DOXYGEN_FOUND)
 	message("Docs              : yes")
 	ADD_SUBDIRECTORY(docs)
 else(DOXYGEN_FOUND)
 	message("Docs              : no (install doxygen)")
 endif(DOXYGEN_FOUND)
 message("----------------------")

ChangeLog

➞

Show inline comments

 Version 2.0.0-beta  (X-X-X):
 Version 2.0.0-beta3 (2012-XX-XX):
 	General:
 	* Log errors related to backend spawning (Show proper log message for
 	  example when path to backend binary is not found).
 	* Update buddies in database only when it's needed and do not execute
 	  useless database statements.
 	* Send roster changes also when buddy's group change.
 	* Fixed bug when transport contact we in all groups.
 	* Answer to disco#info IQ with proper node (#206).
 	* Set SQLite3 as default database backend.
 	* Fixed disconnecting from server caused by sending VCard response
 	  with bad "from" attribute.
 	* Added Munin plugin (Thanks to Askovpen).
 	* Added support for more admin_jid JIDs (Thanks to Askovpen).
 	* Fixed allowed_servers option.
 	Libpurple:
 	* prpl-gg: Fetch the contact list properly (#252).
 	Skype:
 	* Log more errors.
 	Backend API:
 	* Added Python NetworkPlugin class, so it is now easier to write backends
 	  in Python (Thanks to Sarang).
 Version 2.0.0-beta2 (2012-03-28):
 	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).
 	* Chatstates are now not counted as incoming messages in 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 initial support for MUC for prpl-jabber protocol.
 	LibCommuni IRC backend:
 	* Fixed sending/receiving UTF8 messages.
 	* Using the [registration] auto_register=1 config option, users don't
 	  have to register manually when connecting IRC network.
 	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.
 	* Fixed bug when Skype client instance wasn't killed by backend.
 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.
 	* Unsubscribe presence sent to some buddy doesn't disconnect the account.
 	* Remote Roster requests are not sent to resources, but to bare JID.
 	* Added automatic reconnection in case of non-fatal error.
 	* Added more error messages.
 	Skype:
 	* Initial support for Skype added, read more on
 	  http://spectrum.im/projects/spectrum/wiki/Spectrum_2_Admin_-_Skype_backend
 	SMSTools3:
 	* Initial support for SMSTools3, read more on
 	http://spectrum.im/projects/spectrum/wiki/Spectrum_2_Admin_-_SMSTools3_backend
 version 2.0.0 alpha (2011-12-06):
 	General:
 	* First Spectrum 2.0.0 alpha release, check more on
 	  http://spectrum.im/projects/spectrum/wiki/Spectrum_200_alpha

backends/CMakeLists.txt

➞

Show inline comments

 if (PROTOBUF_FOUND)
 	if ( PURPLE_LIBRARY AND PURPLE_INCLUDE_DIR )
 		ADD_SUBDIRECTORY(libpurple)
 	endif()
 	if (IRC_FOUND)
 		ADD_SUBDIRECTORY(libcommuni)
 	endif()
 	ADD_SUBDIRECTORY(smstools3)
 	ADD_SUBDIRECTORY(template)
 if (NOT WIN32)
 	ADD_SUBDIRECTORY(frotz)
 	if (${LIBDBUSGLIB_FOUND})
 		ADD_SUBDIRECTORY(skype)
 	endif()
 endif()
 endif()

backends/libcommuni/ircnetworkplugin.cpp

➞

Show inline comments

 #include "ircnetworkplugin.h"
 #include <IrcCommand>
 #include <IrcMessage>
 #define FROM_UTF8(WHAT) QString::fromUtf8((WHAT).c_str(), (WHAT).size())
 #define TO_UTF8(WHAT) std::string((WHAT).toUtf8().data(), (WHAT).toUtf8().size())
 IRCNetworkPlugin::IRCNetworkPlugin(Config *config, Swift::QtEventLoop *loop, const std::string &host, int port) {
 	this->config = config;
 	m_socket = new QTcpSocket();
-	m_socket->connectToHost(QString::fromStdString(host), port);
+	m_socket->connectToHost(FROM_UTF8(host), port);
 	connect(m_socket, SIGNAL(readyRead()), this, SLOT(readData()));
+}
 void IRCNetworkPlugin::readData() {
 	size_t availableBytes = m_socket->bytesAvailable();
 	if (availableBytes == 0)
 		return;
 	std::cout << "READ\n";
 	std::string d = std::string(m_socket->readAll().data(), availableBytes);
 	handleDataRead(d);
+}
 void IRCNetworkPlugin::sendData(const std::string &string) {
 	m_socket->write(string.c_str(), string.size());
+}
 void IRCNetworkPlugin::handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 	// Server is in server-mode, so user is JID of server when we want to connect
 	if (CONFIG_BOOL(config, "service.server_mode")) {
 		MyIrcSession *session = new MyIrcSession(user, this);
 		std::string h = user.substr(0, user.find("@"));
 		session->setNickName(QString::fromStdString(h.substr(0, h.find("%"))));
 		session->setHost(QString::fromStdString(h.substr(h.find("%") + 1)));
 		session->setNickName(FROM_UTF8(h.substr(0, h.find("%"))));
 		session->setHost(FROM_UTF8(h.substr(h.find("%") + 1)));
 		session->setPort(6667);
 		session->open();
 		std::cout << "CONNECTING IRC NETWORK " << h.substr(h.find("%") + 1) << "\n";
 		m_sessions[user] = session;
+	}
 	else {
 		handleConnected(user);
+	}
+}
 void IRCNetworkPlugin::handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 	if (m_sessions[user] == NULL)
 		return;
 	m_sessions[user]->close();
 	m_sessions[user]->deleteLater();
 	m_sessions.erase(user);
+}
 void IRCNetworkPlugin::handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &/*xhtml*/) {
 	std::string u = user;
 	std::cout << "AAAAA " << legacyName << "\n";
 	if (!CONFIG_BOOL(config, "service.server_mode")) {
 		u = user + legacyName.substr(legacyName.find("@") + 1);
 		if (u.find("/") != std::string::npos) {
 			u = u.substr(0, u.find("/"));
+		}
+	}
 	if (m_sessions[u] == NULL) {
 		std::cout << "No session for " << u << "\n";
 		return;
+	}
 	std::string r = legacyName;
 	if (!CONFIG_BOOL(config, "service.server_mode")) {
 		if (legacyName.find("/") == std::string::npos) {
 			r = legacyName.substr(0, r.find("@"));
+		}
 		else {
 			r = legacyName.substr(legacyName.find("/") + 1);
+		}
+	}
 	std::cout << "MESSAGE " << u << " " << r << "\n";
-	m_sessions[u]->sendCommand(IrcCommand::createMessage(QString::fromStdString(r), QString::fromStdString(message)));
+	m_sessions[u]->sendCommand(IrcCommand::createMessage(FROM_UTF8(r), FROM_UTF8(message)));
 	std::cout << "SENT\n";
+}
 void IRCNetworkPlugin::handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &password) {
 	std::cout << "JOIN\n";
 	std::string r = room;
 	std::string u = user;
 	if (!CONFIG_BOOL(config, "service.server_mode")) {
 		u = user + room.substr(room.find("@") + 1);
 		r = room.substr(0, room.find("@"));
+	}
 	if (m_sessions[u] == NULL) {
 		// in gateway mode we want to login this user to network according to legacyName
 		if (room.find("@") != std::string::npos) {
 			// suffix is %irc.freenode.net to let MyIrcSession return #room%irc.freenode.net
 			MyIrcSession *session = new MyIrcSession(user, this, room.substr(room.find("@")));
 			session->setNickName(QString::fromStdString(nickname));
 			session->setHost(QString::fromStdString(room.substr(room.find("@") + 1)));
 			session->setNickName(FROM_UTF8(nickname));
 			session->setHost(FROM_UTF8(room.substr(room.find("@") + 1)));
 			session->setPort(6667);
 			session->open();
 			std::cout << "CONNECTING IRC NETWORK " << room.substr(room.find("@") + 1) << "\n";
 			std::cout << "SUFFIX " << room.substr(room.find("@")) << "\n";
 			m_sessions[u] = session;
+		}
 		else {
 			return;
+		}
+	}
 	std::cout << "JOINING " << r << "\n";
 	m_sessions[u]->addAutoJoinChannel(r);
-	m_sessions[u]->sendCommand(IrcCommand::createJoin(QString::fromStdString(r), QString::fromStdString(password)));
+	m_sessions[u]->sendCommand(IrcCommand::createJoin(FROM_UTF8(r), FROM_UTF8(password)));
 	m_sessions[u]->rooms += 1;
 	// update nickname, because we have nickname per session, no nickname per room.
-	handleRoomNicknameChanged(user, r, m_sessions[u]->nickName().toStdString());
+	handleRoomNicknameChanged(user, r, TO_UTF8(m_sessions[u]->nickName()));
+}
 void IRCNetworkPlugin::handleLeaveRoomRequest(const std::string &user, const std::string &room) {
 	std::string r = room;
 	std::string u = user;
 	if (!CONFIG_BOOL(config, "service.server_mode")) {
 		r = room.substr(0, room.find("@"));
 		u = user + room.substr(room.find("@") + 1);
+	}
 	if (m_sessions[u] == NULL)
 		return;
-	m_sessions[u]->sendCommand(IrcCommand::createPart(QString::fromStdString(r)));
+	m_sessions[u]->sendCommand(IrcCommand::createPart(FROM_UTF8(r)));
 	m_sessions[u]->removeAutoJoinChannel(r);
 	m_sessions[u]->rooms -= 1;
 	if (m_sessions[u]->rooms <= 0) {
 		m_sessions[u]->close();
 		m_sessions[u]->deleteLater();
 		m_sessions.erase(u);
+	}
+}

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 (...)
+	{
 		std::cout << desc << "\n";
 		exit(1);
+	}
 	if (argc < 5) {
 		qDebug("Usage: %s <config>", argv[0]);
 		return 1;
+	}
 // 	QStringList channels;
 // 	for (int i = 3; i < argc; ++i)
 // 	{
 // 		channels.append(argv[i]);
 // 	}
 //
 // 	MyIrcSession session;
 // 	session.setNick(argv[2]);
 // 	session.setAutoJoinChannels(channels);
 // 	session.connectToServer(argv[1], 6667);
 	Config config;
 	if (!config.load(argv[5])) {
 		std::cerr << "Can't open " << argv[1] << " configuration file.\n";
 		return 1;
+	}
 	QCoreApplication app(argc, argv);
 	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::QtEventLoop eventLoop;
 	if (config.getUnregistered().find("service.irc_server") == config.getUnregistered().end()) {
 		np = new IRCNetworkPlugin(&config, &eventLoop, host, port);
+	}
 	else {
 		np = new SingleIRCNetworkPlugin(&config, &eventLoop, host, port);
+	}
 	return app.exec();
+}

backends/libcommuni/session.cpp

➞

Show inline comments

 /*
  * Copyright (C) 2008-2009 J-P Nurmi jpnurmi@gmail.com
+ *
  * This example is free, and not covered by LGPL license. There is no
  * restriction applied to their modification, redistribution, using and so on.
  * You can study them, modify them, use them in your own program - either
  * completely or partially. By using it you may give me some credits in your
  * program, but you don't have to.
  */
 #include "session.h"
 #include <QtCore>
 #include <iostream>
 #include "Swiften/Elements/StatusShow.h"
 #include <IrcCommand>
 #include <IrcMessage>
 #include "log4cxx/logger.h"
 #define FROM_UTF8(WHAT) QString::fromUtf8((WHAT).c_str(), (WHAT).size())
 #define TO_UTF8(WHAT) std::string((WHAT).toUtf8().data(), (WHAT).toUtf8().size())
-using namespace log4cxx;
+#include "transport/logging.h"
-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)));
+		sendCommand(IrcCommand::createJoin(FROM_UTF8(*it)));
+	}
 	if (getIdentify().find(" ") != std::string::npos) {
 		std::string to = getIdentify().substr(0, getIdentify().find(" "));
 		std::string what = getIdentify().substr(getIdentify().find(" ") + 1);
-		sendCommand(IrcCommand::createMessage(QString::fromStdString(to), QString::fromStdString(what)));
+		sendCommand(IrcCommand::createMessage(FROM_UTF8(to), FROM_UTF8(what)));
+	}
+}
 void MyIrcSession::on_disconnected() {
 	if (suffix.empty())
 		np->handleDisconnected(user, 0, "");
 	m_connected = false;
+}
 bool MyIrcSession::correctNickname(std::string &nickname) {
 	bool flags = 0;
 	switch(nickname.at(0)) {
 		case '@': nickname = nickname.substr(1); flags = 1; break;
 		case '+': nickname = nickname.substr(1); break;
 		default: break;
+	}
 	return flags;
+}
 void MyIrcSession::on_joined(IrcMessage *message) {
 	IrcJoinMessage *m = (IrcJoinMessage *) message;
 	bool flags = 0;
-	std::string nickname = m->sender().name().toStdString();
+	std::string nickname = TO_UTF8(m->sender().name());
 	flags = correctNickname(nickname);
 	np->handleParticipantChanged(user, nickname, m->channel().toStdString() + suffix, (int) flags, pbnetwork::STATUS_ONLINE);
 	LOG4CXX_INFO(logger, user << ": Joined " << m->parameters()[0].toStdString());
 	np->handleParticipantChanged(user, nickname, TO_UTF8(m->channel()), (int) flags, pbnetwork::STATUS_ONLINE);
 	LOG4CXX_INFO(logger, user << ": Joined " << TO_UTF8(m->parameters()[0]));
+}
 void MyIrcSession::on_parted(IrcMessage *message) {
 	IrcPartMessage *m = (IrcPartMessage *) message;
 	bool flags = 0;
-	std::string nickname = m->sender().name().toStdString();
+	std::string nickname = TO_UTF8(m->sender().name());
 	flags = correctNickname(nickname);
 	LOG4CXX_INFO(logger, user << ": " << nickname << " parted " << m->channel().toStdString() + suffix);
 	np->handleParticipantChanged(user, nickname, m->channel().toStdString() + suffix,(int) flags, pbnetwork::STATUS_NONE, m->reason().toStdString());
 	LOG4CXX_INFO(logger, user << ": " << nickname << " parted " << TO_UTF8(m->channel()) + suffix);
 	np->handleParticipantChanged(user, nickname, TO_UTF8(m->channel()) + suffix,(int) flags, pbnetwork::STATUS_NONE, TO_UTF8(m->reason()));
+}
 void MyIrcSession::on_quit(IrcMessage *message) {
 	IrcQuitMessage *m = (IrcQuitMessage *) message;
 	for(std::list<std::string>::const_iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
 		bool flags = 0;
-		std::string nickname = m->sender().name().toStdString();
+		std::string nickname = TO_UTF8(m->sender().name());
 		flags = correctNickname(nickname);
 		LOG4CXX_INFO(logger, user << ": " << nickname << " quit " << (*it) + suffix);
-		np->handleParticipantChanged(user, nickname, (*it) + suffix,(int) flags, pbnetwork::STATUS_NONE, m->reason().toStdString());
+		np->handleParticipantChanged(user, nickname, (*it) + suffix,(int) flags, pbnetwork::STATUS_NONE, TO_UTF8(m->reason()));
+	}
+}
 void MyIrcSession::on_nickChanged(IrcMessage *message) {
 	IrcNickMessage *m = (IrcNickMessage *) message;
 	for(std::list<std::string>::const_iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
-		std::string nickname = m->sender().name().toStdString();
+		std::string nickname = TO_UTF8(m->sender().name());
 		bool flags = m_modes[(*it) + nickname];
 		LOG4CXX_INFO(logger, user << ": " << nickname << " changed nickname to " << m->nick().toStdString());
 		np->handleParticipantChanged(user, nickname, (*it) + suffix,(int) flags, pbnetwork::STATUS_ONLINE, "", m->nick().toStdString());
 		LOG4CXX_INFO(logger, user << ": " << nickname << " changed nickname to " << TO_UTF8(m->nick()));
 		np->handleParticipantChanged(user, nickname, (*it) + suffix,(int) flags, pbnetwork::STATUS_ONLINE, "", TO_UTF8(m->nick()));
+	}
+}
 void MyIrcSession::on_modeChanged(IrcMessage *message) {
 	IrcModeMessage *m = (IrcModeMessage *) message;
 	// mode changed: "#testik" "HanzZ" "+o" "hanzz_k"
 	std::string nickname = m->argument().toStdString();
 	std::string mode = m->mode().toStdString();
 	std::string nickname = TO_UTF8(m->argument());
 	std::string mode = TO_UTF8(m->mode());
 	if (nickname.empty())
 		return;
 	LOG4CXX_INFO(logger, user << ": " << nickname << " changed mode to " << mode);
 	for(std::list<std::string>::const_iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
 		if (mode == "+o") {
 			m_modes[(*it) + nickname] = 1;
+		}
 		else {
 			m_modes[(*it) + nickname] = 0;
+		}
 		bool flags = m_modes[(*it) + nickname];
 		np->handleParticipantChanged(user, nickname, (*it) + suffix,(int) flags, pbnetwork::STATUS_ONLINE, "");
+	}
+}
 void MyIrcSession::on_topicChanged(IrcMessage *message) {
 	IrcTopicMessage *m = (IrcTopicMessage *) message;
 	bool flags = 0;
-	std::string nickname = m->sender().name().toStdString();
+	std::string nickname = TO_UTF8(m->sender().name());
 	flags = correctNickname(nickname);
 	LOG4CXX_INFO(logger, user << ": " << nickname << " topic changed to " << m->topic().toStdString());
 	np->handleSubject(user, m->channel().toStdString() + suffix, m->topic().toStdString(), nickname);
 	LOG4CXX_INFO(logger, user << ": " << nickname << " topic changed to " << TO_UTF8(m->topic()));
 	np->handleSubject(user, TO_UTF8(m->channel()) + suffix, TO_UTF8(m->topic()), nickname);
+}
 void MyIrcSession::on_messageReceived(IrcMessage *message) {
 	IrcPrivateMessage *m = (IrcPrivateMessage *) message;
-	std::string target = m->target().toStdString();
+	std::string target = TO_UTF8(m->target());
 	LOG4CXX_INFO(logger, user << ": Message from " << target);
 	if (target.find("#") == 0) {
 		bool flags = 0;
-		std::string nickname = m->sender().name().toStdString();
+		std::string nickname = TO_UTF8(m->sender().name());
 		flags = correctNickname(nickname);
-		np->handleMessage(user, target + suffix, m->message().toStdString(), nickname);
+		np->handleMessage(user, target + suffix, TO_UTF8(m->message()), nickname);
+	}
 	else {
 		bool flags = 0;
-		std::string nickname = m->sender().name().toStdString();
+		std::string nickname = TO_UTF8(m->sender().name());
 		flags = correctNickname(nickname);
-		np->handleMessage(user, nickname, m->message().toStdString());
+		np->handleMessage(user, nickname, TO_UTF8(m->message()));
+	}
+}
 void MyIrcSession::on_numericMessageReceived(IrcMessage *message) {
 	QString channel;
 	QStringList members;
 	IrcNumericMessage *m = (IrcNumericMessage *) message;
 	switch (m->code()) {
 		case 332:
-			m_topicData = m->parameters().value(2).toStdString();
+			m_topicData = TO_UTF8(m->parameters().value(2));
 			break;
 		case 333:
-			 np->handleSubject(user, m->parameters().value(1).toStdString() + suffix, m_topicData, m->parameters().value(2).toStdString());
+			 np->handleSubject(user, TO_UTF8(m->parameters().value(1)) + suffix, m_topicData, TO_UTF8(m->parameters().value(2)));
 			break;
 		case 353:
 			channel = m->parameters().value(2);
 			members = m->parameters().value(3).split(" ");
 			for (int i = 0; i < members.size(); i++) {
 				bool flags = 0;
-				std::string nickname = members.at(i).toStdString();
+				std::string nickname = TO_UTF8(members.at(i));
 				flags = correctNickname(nickname);
 				m_modes[channel.toStdString() + nickname] = flags;
 				np->handleParticipantChanged(user, nickname, channel.toStdString() + suffix,(int) flags, pbnetwork::STATUS_ONLINE);
 				m_modes[TO_UTF8(channel) + nickname] = flags;
 				np->handleParticipantChanged(user, nickname, TO_UTF8(channel) + suffix,(int) flags, pbnetwork::STATUS_ONLINE);
+			}
 			break;
 		case 432:
 			if (m_connected) {
 				np->handleDisconnected(user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Erroneous Nickname");
+			}
 			break;
 		default:
 			break;
+	}
 	//qDebug() << "numeric message received:" << receiver() << origin << code << params;
+}
 void MyIrcSession::onMessageReceived(IrcMessage *message) {
-	LOG4CXX_INFO(logger, user << ": " << message->toString().toStdString());
+	LOG4CXX_INFO(logger, user << ": " << TO_UTF8(message->toString()));
 	switch (message->type()) {
 		case IrcMessage::Join:
 			on_joined(message);
 			break;
 		case IrcMessage::Part:
 			on_parted(message);
 			break;
 		case IrcMessage::Quit:
 			on_quit(message);
 			break;
 		case IrcMessage::Nick:
 			on_nickChanged(message);
 			break;
 		case IrcMessage::Mode:
 			on_modeChanged(message);
 			break;
 		case IrcMessage::Topic:
 			on_topicChanged(message);
 			break;
 		case IrcMessage::Private:
 			on_messageReceived(message);
 			break;
 		case IrcMessage::Numeric:
 			on_numericMessageReceived(message);
 			break;
 		default:break;
+	}
+}

backends/libcommuni/singleircnetworkplugin.cpp

➞

Show inline comments

 #include "singleircnetworkplugin.h"
-#include "log4cxx/logger.h"
+#include "transport/logging.h"
 #include <IrcCommand>
 #include <IrcMessage>
 using namespace log4cxx;
 #define FROM_UTF8(WHAT) QString::fromUtf8((WHAT).c_str(), (WHAT).size())
 #define TO_UTF8(WHAT) std::string((WHAT).toUtf8().data(), (WHAT).toUtf8().size())
-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);
+	m_socket->connectToHost(FROM_UTF8(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);
 	handleDataRead(d);
+}
 void SingleIRCNetworkPlugin::sendData(const std::string &string) {
 	m_socket->write(string.c_str(), string.size());
+}
 void SingleIRCNetworkPlugin::handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 	// legacy name is users nickname
 	if (m_sessions[user] != NULL) {
 		LOG4CXX_WARN(logger, user << ": Already logged in.");
 		return;
+	}
 	LOG4CXX_INFO(logger, user << ": Connecting " << m_server << " as " << legacyName);
 	MyIrcSession *session = new MyIrcSession(user, this);
 	session->setUserName(QString::fromStdString(legacyName));
 	session->setNickName(QString::fromStdString(legacyName));
 	session->setRealName(QString::fromStdString(legacyName));
 	session->setHost(QString::fromStdString(m_server));
 	session->setUserName(FROM_UTF8(legacyName));
 	session->setNickName(FROM_UTF8(legacyName));
 	session->setRealName(FROM_UTF8(legacyName));
 	session->setHost(FROM_UTF8(m_server));
 	session->setPort(6667);
 	std::string identify = m_identify;
 	boost::replace_all(identify, "$password", password);
 	boost::replace_all(identify, "$name", legacyName);
 	session->setIdentify(identify);
 	if (!password.empty()) {
 		std::string identify = m_identify;
 		boost::replace_all(identify, "$password", password);
 		boost::replace_all(identify, "$name", legacyName);
 		session->setIdentify(identify);
+	}
 	session->open();
 	m_sessions[user] = session;
+}
 void SingleIRCNetworkPlugin::handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 	if (m_sessions[user] == NULL) {
 		LOG4CXX_WARN(logger, user << ": Already disconnected.");
 		return;
+	}
 	LOG4CXX_INFO(logger, user << ": Disconnecting.");
 	m_sessions[user]->close();
 	m_sessions[user]->deleteLater();
 	m_sessions.erase(user);
+}
 void SingleIRCNetworkPlugin::handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &/*xhtml*/) {
 	if (m_sessions[user] == NULL) {
 		LOG4CXX_WARN(logger, user << ": Message received for unconnected user");
 		return;
+	}
 	// handle PMs
 	std::string r = legacyName;
 	if (legacyName.find("/") == std::string::npos) {
 		r = legacyName.substr(0, r.find("@"));
+	}
 	else {
 		r = legacyName.substr(legacyName.find("/") + 1);
+	}
 	LOG4CXX_INFO(logger, user << ": Forwarding message to " << r);
-	m_sessions[user]->sendCommand(IrcCommand::createMessage(QString::fromStdString(r), QString::fromStdString(message)));
+	m_sessions[user]->sendCommand(IrcCommand::createMessage(FROM_UTF8(r), FROM_UTF8(message)));
 	if (r.find("#") == 0) {
-		handleMessage(user, legacyName, message, m_sessions[user]->nickName().toStdString());
+		handleMessage(user, legacyName, message, TO_UTF8(m_sessions[user]->nickName()));
+	}
+}
 void SingleIRCNetworkPlugin::handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &password) {
 	if (m_sessions[user] == NULL) {
 		LOG4CXX_WARN(logger, user << ": Join room requested for unconnected user");
 		return;
+	}
 	LOG4CXX_INFO(logger, user << ": Joining " << room);
 	m_sessions[user]->addAutoJoinChannel(room);
-	m_sessions[user]->sendCommand(IrcCommand::createJoin(QString::fromStdString(room), QString::fromStdString(password)));
+	m_sessions[user]->sendCommand(IrcCommand::createJoin(FROM_UTF8(room), FROM_UTF8(password)));
 	m_sessions[user]->rooms += 1;
 	// update nickname, because we have nickname per session, no nickname per room.
-	handleRoomNicknameChanged(user, room, m_sessions[user]->userName().toStdString());
+	handleRoomNicknameChanged(user, room, TO_UTF8(m_sessions[user]->userName()));
+}
 void SingleIRCNetworkPlugin::handleLeaveRoomRequest(const std::string &user, const std::string &room) {
 	std::string r = room;
 	std::string u = user;
 	if (m_sessions[u] == NULL) {
 		LOG4CXX_WARN(logger, user << ": Leave room requested for unconnected user");
 		return;
+	}
 	LOG4CXX_INFO(logger, user << ": Leaving " << room);
-	m_sessions[u]->sendCommand(IrcCommand::createPart(QString::fromStdString(r)));
+	m_sessions[u]->sendCommand(IrcCommand::createPart(FROM_UTF8(r)));
 	m_sessions[u]->removeAutoJoinChannel(r);
 	m_sessions[u]->rooms -= 1;
+}

backends/libpurple/gen_dynamic_purple.py

➞

Show inline comments

@@ new file 100644 @@
 import sys
 import os
 # intialize for methods used in libpurple macros
 methods = ["purple_connection_get_state(", "purple_conversation_get_im_data(",
 			"purple_conversation_get_chat_data(", "purple_blist_node_get_type("]
 macros = ["PURPLE_CONV_IM", "PURPLE_CONV_CHAT", "PURPLE_BLIST_NODE_IS_BUDDY", "PURPLE_CONNECTION_IS_CONNECTED"]
 definitions = []
 if len(sys.argv) != 2:
 	print "Usage:", sys.argv[0], "<path_to_libpurple_dir_containing_libpurple_headers>"
 	sys.exit(1)
 def handle_file(cpp):
 	global methods
 	global macros
 	sys.stdout.write("getting used methods in " + cpp + ": ")
 	sys.stdout.flush()
 	counter = 0
 	new_file = ""
 	f = open(cpp, "r")
 	for line in f.readlines():
 		new_line = ""
 		index = 0
 		while index < len(line):
 			new_line += line[index]
 			if line[index:].startswith("purple_") or line[index:].startswith("wpurple_") or line[index:].startswith("serv_"):
 				if line[index:].find("=") != -1 and line[index:].find("=") < line[index:].find("("):
 					index += 1
 					continue
 				if line[index-1] == "_" or line[index:].find("(") == -1 or line[index:].startswith("purple_commands_init") or line[index:].startswith("serv_addr"):
 					index += 1
 					continue
 				m = line[index:line[index:].find("(")+index]
 				index += len(m)
 				if m.find("_wrapped") != -1:
 					new_line += m[1:] + "("
 					m = m.replace("_wrapped", "")
 				else:
 					new_line += m[1:] + "_wrapped("
 				if not m + "(" in methods and len(m) != 0:
 					methods += [m + "("]
 					counter += 1
 			index += 1
 		for x in macros:
 			if new_line.find(x + "_WRAPPED") == -1:
 				new_line = new_line.replace(x, x + "_WRAPPED")
 		new_file += new_line
 	f.close()
 	print counter, "new methods found"
 	return new_file
 def handle_header(header, method):
 	global definitions
 	f = open(os.path.join(sys.argv[1], header), "r")
 	lines = f.readlines()
 	for i in range(len(lines)):
 		line = lines[i]
 		if line.find(method) != -1:
 			if line.startswith(method):
 				line = lines[i-1][:-1] + line
 			m = line[:-1]
 			l = unicode(m).strip()
 			if l.endswith(")"):
 				continue
 			if m.find("/*") > m.find(";"):
 				m = m[:m.find("/*")]
 				m.rstrip()
 				if len(m) != 0:
 					while m[-1] == " ":
 						m = m[:-1]
 			index = i;
 			while not m.endswith(";"):
 				index += 1
 				m += " " + lines[index][:-1].lstrip()
 			l = unicode(m).strip()
 			if (l.startswith("#") or l.startswith("*") or l.startswith("/*") or l.count("***") != 0 or l.count("&&") != 0
 				or l.endswith(")")):
 				continue;
 			m = m.replace("G_GNUC_NULL_TERMINATE", "")
 			if not m in definitions:
 				print "found", method[:-1], "in", header
 				definitions += [m]
 			break
 	f.close()
 def get_raw_args(d):
 	return d[d.find("(")+1:-2]
 def get_args(d):
 	x = d[d.find("(")+1:-2]
 	x = x.split(",")
 	args = []
 	for arg in x:
 		y = arg.split(" ")
 		if len(y) == 1:
 			continue
 		args += [y[-1].replace("*", "")]
 	return args
 def get_name(d):
 	x = d[:d.find("(")+1].lstrip()
 	if x.find("wpurple_") != -1:
 		return x[x.find("wpurple_"):]
 	if x.find("serv_") != -1:
 		return x[x.find("serv_"):]
 	return x[x.find("purple_"):]
 def get_rtype(d):
 	if d.find("wpurple_") != -1:
 		return d[:d.find("wpurple_")].lstrip()
 	if d.find("serv_") != -1:
 		return d[:d.find("serv_")].lstrip()
 	return d[:d.find("purple_")].lstrip()
 def output():
 	global definitions
 	header = open("purple_defs.h", "w")
 	print >> header, "#pragma once"
 	print >> header, "#ifdef WIN32"
 	print >> header, """
 #include <Windows.h>
 #include <purple.h>
 #define PURPLE_BLIST_NODE_IS_CHAT_WRAPPED(n)    (purple_blist_node_get_type_wrapped(n) == PURPLE_BLIST_CHAT_NODE)
 #define PURPLE_BLIST_NODE_IS_BUDDY_WRAPPED(n)   (purple_blist_node_get_type_wrapped(n) == PURPLE_BLIST_BUDDY_NODE)
 #define PURPLE_BLIST_NODE_IS_CONTACT_WRAPPED(n) (purple_blist_node_get_type_wrapped(n) == PURPLE_BLIST_CONTACT_NODE)
 #define PURPLE_BLIST_NODE_IS_GROUP_WRAPPED(n)   (purple_blist_node_get_type_wrapped(n) == PURPLE_BLIST_GROUP_NODE)
 #define PURPLE_CONV_IM_WRAPPED(c) (purple_conversation_get_im_data_wrapped(c))
 #define PURPLE_CONV_CHAT_WRAPPED(c) (purple_conversation_get_chat_data_wrapped(c))
 #define PURPLE_CONNECTION_IS_CONNECTED_WRAPPED(gc) \
 	(purple_connection_get_state_wrapped(gc) == PURPLE_CONNECTED)
 """
 	for d in definitions:
 		#typedef void (_cdecl * purple_util_set_user_wrapped_func)(const char *dir);
 		print >> header, "typedef", get_rtype(d), "(_cdecl *", get_name(d)[:-1] + "_wrapped_fnc)(" + get_raw_args(d) + ");"
 		#extern purple_util_set_user_wrapped_func purple_util_set_user_wrapped;
 		print >> header, "extern", get_name(d)[:-1] + "_wrapped_fnc", get_name(d)[:-1] + "_wrapped;"
 		print >> header, ""
 	print >> header, ""
 	print >> header, "#else"
 	print >> header, ""
 	print >> header, """
 #define PURPLE_BLIST_NODE_IS_CHAT_WRAPPED PURPLE_BLIST_NODE_IS_CHAT
 #define PURPLE_BLIST_NODE_IS_BUDDY_WRAPPED PURPLE_BLIST_NODE_IS_BUDDY
 #define PURPLE_BLIST_NODE_IS_CONTACT_WRAPPED PURPLE_BLIST_NODE_IS_CONTACT
 #define PURPLE_BLIST_NODE_IS_GROUP_WRAPPED PURPLE_BLIST_NODE_IS_GROUP
 #define PURPLE_CONV_IM_WRAPPED PURPLE_CONV_IM
 #define PURPLE_CONV_CHAT_WRAPPED PURPLE_CONV_CHAT
 #define PURPLE_CONNECTION_IS_CONNECTED_WRAPPED PURPLE_CONNECTION_IS_CONNECTED
 """
 	for d in definitions:
 		#define purple_util_set_user_wrapped purple_util_set_user
 		print >> header, "#define", get_name(d)[:-1] + "_wrapped", get_name(d)[:-1]
 	print >> header, "#endif"
 	print >> header, ""
 	print >> header, "bool resolvePurpleFunctions();"
 	print >> header, ""
 	cpp = open("purple_defs.cpp", "w")
 	print >> cpp, "#include \"purple_defs.h\""
 	print >> cpp, ""
 	print >> cpp, "#ifdef WIN32"
 	print >> cpp, "static HMODULE f_hPurple = NULL;"
 	for d in definitions:
 		#purple_util_set_user_wrapped_fnc purple_util_set_user_wrapped = NULL;
 		print >> cpp, get_name(d)[:-1] + "_wrapped_fnc", get_name(d)[:-1] + "_wrapped = NULL;"
 	print >> cpp, "#endif"
 	print >> cpp, "bool resolvePurpleFunctions() {"
 	print >> cpp, "#ifdef WIN32"
 	print >> cpp, "\tf_hPurple = LoadLibrary(\"libpurple.dll\");"
 	print >> cpp, "\tif (!f_hPurple)"
 	print >> cpp, "\t\t\treturn false;"
 	for d in definitions:
 		#purple_util_set_user_wrapped = (purple_util_set_user_wrapped_func)GetProcAddress(f_hPurple, "purple_util_set_user_dir");
 		print >> cpp, "\t" + get_name(d)[:-1] + "_wrapped = (" + get_name(d)[:-1] + "_wrapped_fnc)GetProcAddress(f_hPurple, \"" + get_name(d)[:-1] + "\");"
 		#if (!purple_util_set_user_wrapped)
 		print >> cpp, "\tif (!" + get_name(d)[:-1] + "_wrapped)"
 		print >> cpp, "\t\treturn false;"
 		print >> cpp, ""
 	print >> cpp, "#endif"
 	print >> cpp, "\treturn true;"
 	print >> cpp, "}"
 	print >> cpp, ""
 	cpp.close()
 	header.close()
 for f in os.listdir("."):
 	if not f.endswith(".cpp") or f.startswith("purple_defs"):
 		continue
 	new_file = handle_file(f)
 	print "updating", f
 	fd = open(f, "w")
 	fd.write(new_file)
 	fd.close()
 for f in os.listdir(sys.argv[1]):
 	if not f.endswith(".h"):
 		continue
 	for m in methods:
 		handle_header(f, m)
 sys.argv[1] = sys.argv[1] + "/win32"
 for f in os.listdir(sys.argv[1]):
 	if not f.endswith(".h"):
 		continue
 	for m in methods:
 		handle_header(f, m)
 for m in methods:
 	found = False
 	for d in definitions:
 		if d.find(m[:-1]) != -1:
 			found = True
 			break
 	if not found:
 		print "NOT FOUND:", m
 output()

backends/libpurple/geventloop.cpp

➞

Show inline comments

 /**
  * XMPP - libpurple transport
+ *
  * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "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 "purple_defs.h"
-using namespace log4cxx;
+#include "transport/logging.h"
-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;
+	}
 	if (condition & WRITE_COND)
+	{
 		tmp |= PURPLE_INPUT_WRITE;
 		purple_cond = (PurpleInputCondition)tmp;
+	}
 	closure->function(closure->data, g_io_channel_unix_get_fd(source), purple_cond);
 	return TRUE;
+}
 static void io_destroy(gpointer data)
+{
 	g_free(data);
+}
 static guint input_add(gint fd,
 								PurpleInputCondition condition,
 								PurpleInputFunction function,
 								gpointer data)
+{
 	PurpleIOClosure *closure = g_new0(PurpleIOClosure, 1);
 	GIOChannel *channel;

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"
 #ifndef WIN32
 #include "sys/wait.h"
 #include "sys/signal.h"
 #include <netinet/if_ether.h>
 #include <netinet/ip.h>
 #include <netinet/ip6.h>
 #include <netinet/udp.h>
 #include <netinet/tcp.h>
 #include <netinet/ether.h>
 #include "sys/socket.h"
 #include <netdb.h>
 #include <unistd.h>
 #include <fcntl.h>
 #else
 #include <process.h>
 #define getpid _getpid
 #define ssize_t SSIZE_T
 #include "win32/win32dep.h"
 #endif
 // #include "valgrind/memcheck.h"
 #include "malloc.h"
 #include <algorithm>
 #include "errno.h"
 #ifdef WITH_LIBEVENT
 #include <event.h>
 #endif
 using namespace log4cxx;
 #ifdef WIN32
 #include "win32/win32dep.h"
 #define ssize_t SSIZE_T
 #include <process.h>
 #define getpid _getpid
 #endif
 #include "purple_defs.h"
 DEFINE_LOGGER(logger_libpurple, "libpurple");
 DEFINE_LOGGER(logger, "backend");
 static LoggerPtr logger_libpurple = log4cxx::Logger::getLogger("libpurple");
 static LoggerPtr logger = log4cxx::Logger::getLogger("backend");
 int m_sock;
 int main_socket;
 static int writeInput;
 using namespace Transport;
 template <class T> T fromString(const std::string &str) {
 	T i;
 	std::istringstream os(str);
 	os >> i;
 	return i;
+}
 template <class T> std::string stringOf(T object) {
 	std::ostringstream os;
 	os << object;
 	return (os.str());
+}
 static std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
     std::stringstream ss(s);
     std::string item;
     while(std::getline(ss, item, delim)) {
         elems.push_back(item);
+    }
     return elems;
+}
 static std::vector<std::string> split(const std::string &s, char delim) {
     std::vector<std::string> elems;
     return split(s, delim, elems);
+}
 static void transportDataReceived(gpointer data, gint source, PurpleInputCondition cond);
 class SpectrumNetworkPlugin;
 GKeyFile *keyfile;
 SpectrumNetworkPlugin *np;
 static std::string replaceAll(
   std::string result,
   const std::string& replaceWhat,
   const std::string& replaceWithWhat)
+{
   while(1)
+  {
 	const int pos = result.find(replaceWhat);
 	if (pos==-1) break;
 	result.replace(pos,replaceWhat.size(),replaceWithWhat);
+  }
   return result;
+}
 static std::string KEYFILE_STRING(const std::string &cat, const std::string &key, const std::string &def = "") {
 	gchar *str = g_key_file_get_string(keyfile, cat.c_str(), key.c_str(), 0);
 	if (!str) {
 		return def;
+	}
 	std::string ret(str);
-	free(str);
+	g_free(str);
 	if (ret.find("#") != std::string::npos) {
 		ret = ret.substr(0, ret.find("#"));
 		while(*(ret.end() - 1) == ' ') {
 			ret.erase(ret.end() - 1);
+		}
+	}
 	if (ret.find("$jid") != std::string::npos) {
 		std::string jid = KEYFILE_STRING("service", "jid");
 		ret = replaceAll(ret, "$jid", jid);
+	}
 	return ret;
+}
 #define KEYFILE_BOOL(CAT, KEY) g_key_file_get_boolean(keyfile, CAT, KEY, 0)
 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;
 static gboolean list_purple_settings = FALSE;
 struct FTData {
 	unsigned long id;
 	unsigned long timer;
 	bool paused;
 };
 static GOptionEntry options_entries[] = {
 	{ "nodaemon", 'n', 0, G_OPTION_ARG_NONE, &nodaemon, "Disable background daemon mode", NULL },
 	{ "logfile", 'l', 0, G_OPTION_ARG_STRING, &logfile, "Set file to log", NULL },
 	{ "pidfile", 'p', 0, G_OPTION_ARG_STRING, &lock_file, "File where to write transport PID", NULL },
 	{ "version", 'v', 0, G_OPTION_ARG_NONE, &ver, "Shows Spectrum version", NULL },
 	{ "list-purple-settings", 's', 0, G_OPTION_ARG_NONE, &list_purple_settings, "Lists purple settings which can be used in config file", NULL },
 	{ "host", 'h', 0, G_OPTION_ARG_STRING, &host, "Host to connect to", NULL },
 	{ "port", 'p', 0, G_OPTION_ARG_INT, &port, "Port to connect to", NULL },
 	{ NULL, 0, 0, G_OPTION_ARG_NONE, NULL, "", NULL }
 };
 static void *notify_user_info(PurpleConnection *gc, const char *who, PurpleNotifyUserInfo *user_info);
 static GHashTable *ui_info = NULL;
 static GHashTable *spectrum_ui_get_info(void)
+{
 	if(NULL == ui_info) {
 		ui_info = g_hash_table_new(g_str_hash, g_str_equal);
 		g_hash_table_insert(ui_info, g_strdup("name"), g_strdup("Spectrum"));
 		g_hash_table_insert(ui_info, g_strdup("version"), g_strdup("0.5"));
 		g_hash_table_insert(ui_info, g_strdup("website"), g_strdup("http://spectrum.im"));
 		g_hash_table_insert(ui_info, g_strdup("dev_website"), g_strdup("http://spectrum.im"));
 		g_hash_table_insert(ui_info, g_strdup("client_type"), g_strdup("pc"));
 		/*
 		 * This is the client key for "Pidgin."  It is owned by the AIM
 		 * account "markdoliner."  Please don't use this key for other
 		 * applications.  You can either not specify a client key, in
 		 * which case the default "libpurple" key will be used, or you
 		 * can register for your own client key at
 		 * http://developer.aim.com/manageKeys.jsp
 		 */
 		g_hash_table_insert(ui_info, g_strdup("prpl-aim-clientkey"), g_strdup("ma1cSASNCKFtrdv9"));
 		g_hash_table_insert(ui_info, g_strdup("prpl-icq-clientkey"), g_strdup("ma1cSASNCKFtrdv9"));
 		/*
 		 * This is the distid for Pidgin, given to us by AOL.  Please
 		 * don't use this for other applications.  You can just not
 		 * specify a distid and libpurple will use a default.
 		 */
 		g_hash_table_insert(ui_info, g_strdup("prpl-aim-distid"), GINT_TO_POINTER(1550));
 		g_hash_table_insert(ui_info, g_strdup("prpl-icq-distid"), GINT_TO_POINTER(1550));
+	}
 	return ui_info;
+}
 static gboolean
 badchar(char c)
+{
 	switch (c) {
 	case ' ':
 	case ',':
 	case '\0':
 	case '\n':
 	case '\r':
 	case '<':
 	case '>':
 	case '"':
 		return TRUE;
 	default:
 		return FALSE;
+	}
+}
 static gboolean
 badentity(const char *c)
+{
 	if (!g_ascii_strncasecmp(c, "&lt;", 4) ||
 		!g_ascii_strncasecmp(c, "&gt;", 4) ||
 		!g_ascii_strncasecmp(c, "&quot;", 6)) {
 		return TRUE;
+	}
 	return FALSE;
+}
 static const char *
 process_link(GString *ret,
 		const char *start, const char *c,
 		int matchlen,
 		const char *urlprefix,
 		int inside_paren)
+{
 	char *url_buf;
 	const char *t;
 	for (t = c;; t++) {
 		if (!badchar(*t) && !badentity(t))
 			continue;
 		if (t - c == matchlen)
 			break;
 		if (*t == ',' && *(t + 1) != ' ') {
 			continue;
+		}
 		if (t > start && *(t - 1) == '.')
 			t--;
 		if (t > start && *(t - 1) == ')' && inside_paren > 0)
 			t--;
 		url_buf = g_strndup(c, t - c);
 // 		tmpurlbuf = purple_unescape_html(url_buf);
 // 		std::cout << url_buf << "\n";
 		g_string_append_printf(ret, "<A HREF=\"%s%s\">%s</A>",
 				urlprefix,
 				url_buf, url_buf);
 // 		g_free(tmpurlbuf);
 		g_free(url_buf);
 		return t;
+	}
 	return c;
+}
 static gboolean ft_ui_ready(void *data) {
 	PurpleXfer *xfer = (PurpleXfer *) data;
 	FTData *ftdata = (FTData *) xfer->ui_data;
 	ftdata->timer = 0;
 	purple_xfer_ui_ready((PurpleXfer *) data);
 	return FALSE;
+}
 static char *
 spectrum_markup_linkify(const char *text)
+{
 	const char *c, *t, *q = NULL;
 	char *tmpurlbuf, *url_buf;
 	gunichar g;
 	gboolean inside_html = FALSE;
 	int inside_paren = 0;
 	GString *ret;
 	if (text == NULL)
 		return NULL;
 	ret = g_string_new("");
 	c = text;
 	while (*c) {
 		if(*c == '(' && !inside_html) {
 			inside_paren++;
 			ret = g_string_append_c(ret, *c);
 			c++;
+		}
 		if(inside_html) {
 			if(*c == '>') {
 				inside_html = FALSE;
 			} else if(!q && (*c == '\"' || *c == '\'')) {
 				q = c;
 			} else if(q) {
 				if(*c == *q)
 					q = NULL;
+			}
 		} else if(*c == '<') {
 			inside_html = TRUE;
 			if (!g_ascii_strncasecmp(c, "<A", 2)) {
 				while (1) {
 					if (!g_ascii_strncasecmp(c, "/A>", 3)) {
 						inside_html = FALSE;
 						break;
+					}
 					ret = g_string_append_c(ret, *c);
 					c++;
 					if (!(*c))
 						break;
+				}
+			}
 		} else if (!g_ascii_strncasecmp(c, "http://", 7)) {
 			c = process_link(ret, text, c, 7, "", inside_paren);
 		} else if (!g_ascii_strncasecmp(c, "https://", 8)) {
 			c = process_link(ret, text, c, 8, "", inside_paren);
 		} else if (!g_ascii_strncasecmp(c, "ftp://", 6)) {
 			c = process_link(ret, text, c, 6, "", inside_paren);
 		} else if (!g_ascii_strncasecmp(c, "sftp://", 7)) {
 			c = process_link(ret, text, c, 7, "", inside_paren);
 		} else if (!g_ascii_strncasecmp(c, "file://", 7)) {
 			c = process_link(ret, text, c, 7, "", inside_paren);
 		} else if (!g_ascii_strncasecmp(c, "www.", 4) && c[4] != '.' && (c == text || badchar(c[-1]) || badentity(c-1))) {
 			c = process_link(ret, text, c, 4, "http://", inside_paren);
 		} else if (!g_ascii_strncasecmp(c, "ftp.", 4) && c[4] != '.' && (c == text || badchar(c[-1]) || badentity(c-1))) {
 			c = process_link(ret, text, c, 4, "ftp://", inside_paren);
 		} else if (!g_ascii_strncasecmp(c, "xmpp:", 5) && (c == text || badchar(c[-1]) || badentity(c-1))) {
 			c = process_link(ret, text, c, 5, "", inside_paren);
 		} else if (!g_ascii_strncasecmp(c, "mailto:", 7)) {
 			t = c;
 			while (1) {
 				if (badchar(*t) || badentity(t)) {
 					const char *d;
 					if (t - c == 7) {
 						break;
+					}
 					if (t > text && *(t - 1) == '.')
 						t--;
 					if ((d = strstr(c + 7, "?")) != NULL && d < t)
 						url_buf = g_strndup(c + 7, d - c - 7);
 					else
 						url_buf = g_strndup(c + 7, t - c - 7);
 					if (!purple_email_is_valid(url_buf)) {
 						g_free(url_buf);
 						break;
+					}
 					g_free(url_buf);
 					url_buf = g_strndup(c, t - c);
 // 					tmpurlbuf = purple_unescape_html(url_buf);
 					g_string_append_printf(ret, "<A HREF=\"%s\">%s</A>",
 							  url_buf, url_buf);
 					g_free(url_buf);
 // 					g_free(tmpurlbuf);
 					c = t;
 					break;
+				}
 				t++;
+			}
 		} else if (c != text && (*c == '@')) {
 			int flag;
 			GString *gurl_buf = NULL;
 			const char illegal_chars[] = "!@#$%^&*()[]{}/|\\<>\":;\r\n \0";
 			if (strchr(illegal_chars,*(c - 1)) || strchr(illegal_chars, *(c + 1)))
 				flag = 0;
 			else {
 				flag = 1;
 				gurl_buf = g_string_new("");
+			}
 			t = c;
 			while (flag) {
 				/* iterate backwards grabbing the local part of an email address */
 				g = g_utf8_get_char(t);
 				if (badchar(*t) || (g >= 127) || (*t == '(') ||
 					((*t == ';') && ((t > (text+2) && (!g_ascii_strncasecmp(t - 3, "&lt;", 4) ||
 				                                       !g_ascii_strncasecmp(t - 3, "&gt;", 4))) ||
 				                     (t > (text+4) && (!g_ascii_strncasecmp(t - 5, "&quot;", 6)))))) {
 					/* local part will already be part of ret, strip it out */
 					ret = g_string_truncate(ret, ret->len - (c - t));
 					ret = g_string_append_unichar(ret, g);
 					break;
 				} else {
 					g_string_prepend_unichar(gurl_buf, g);
 					t = g_utf8_find_prev_char(text, t);
 					if (t < text) {
 						ret = g_string_assign(ret, "");
 						break;
+					}
+				}
+			}
 			t = g_utf8_find_next_char(c, NULL);
 			while (flag) {
 				/* iterate forwards grabbing the domain part of an email address */
 				g = g_utf8_get_char(t);
 				if (badchar(*t) || (g >= 127) || (*t == ')') || badentity(t)) {
 					char *d;
 					url_buf = g_string_free(gurl_buf, FALSE);
 					/* strip off trailing periods */
 					if (strlen(url_buf) > 0) {
 						for (d = url_buf + strlen(url_buf) - 1; *d == '.'; d--, t--)
 							*d = '\0';
+					}
 					tmpurlbuf = purple_unescape_html(url_buf);
 					if (purple_email_is_valid(tmpurlbuf)) {
 						g_string_append_printf(ret, "<A HREF=\"mailto:%s\">%s</A>",
 								url_buf, url_buf);
 					} else {
 						g_string_append(ret, url_buf);
+					}
 					g_free(url_buf);
 					g_free(tmpurlbuf);
 					c = t;
 					break;
 				} else {
 					g_string_append_unichar(gurl_buf, g);
 					t = g_utf8_find_next_char(t, NULL);
+				}
+			}
+		}
 		if(*c == ')' && !inside_html) {
 			inside_paren--;
 			ret = g_string_append_c(ret, *c);
 			c++;
+		}
 		if (*c == 0)
 			break;
 		ret = g_string_append_c(ret, *c);
 		c++;
+	}
 	return g_string_free(ret, FALSE);
+}
 struct authRequest {
 	PurpleAccountRequestAuthorizationCb authorize_cb;
 	PurpleAccountRequestAuthorizationCb deny_cb;
 	void *user_data;
 	std::string who;
 	PurpleAccount *account;
 	std::string mainJID;	// JID of user connected with this request
 };
 static void * requestInput(const char *title, const char *primary,const char *secondary, const char *default_value, gboolean multiline, gboolean masked, gchar *hint,const char *ok_text, GCallback ok_cb,const char *cancel_text, GCallback cancel_cb, PurpleAccount *account, const char *who,PurpleConversation *conv, void *user_data) {
 	if (primary) {
 		std::string primaryString(primary);
 		if (primaryString == "Authorization Request Message:") {
 			LOG4CXX_INFO(logger, "Authorization Request Message: calling ok_cb(...)");
 			((PurpleRequestInputCb) ok_cb)(user_data, "Please authorize me.");
 			return NULL;
+		}
 		else if (primaryString == "Authorization Request Message:") {
 			LOG4CXX_INFO(logger, "Authorization Request Message: calling ok_cb(...)");
 			((PurpleRequestInputCb) ok_cb)(user_data, "Please authorize me.");
 			return NULL;
+		}
 		else if (primaryString == "Authorization Denied Message:") {
 			LOG4CXX_INFO(logger, "Authorization Deined Message: calling ok_cb(...)");
 			((PurpleRequestInputCb) ok_cb)(user_data, "Authorization denied.");
 			return NULL;
+		}
 		else {
 			LOG4CXX_WARN(logger, "Unhandled request input. primary=" << primaryString);
+		}
+	}
 	else if (title) {
 		std::string titleString(title);
 		if (titleString == "Xfire Invitation Message") {
 			LOG4CXX_INFO(logger, "Authorization Request Message: calling ok_cb(...)");
 			((PurpleRequestInputCb) ok_cb)(user_data, "Please authorize me.");
 			return NULL;
+		}
 		else {
 			LOG4CXX_WARN(logger, "Unhandled request input. title=" << titleString);
+		}
+	}
 	else {
 		LOG4CXX_WARN(logger, "Request input without primary string");
+	}
 	return NULL;
+}
 static void *requestAction(const char *title, const char *primary, const char *secondary, int default_action, PurpleAccount *account, const char *who,PurpleConversation *conv, void *user_data, size_t action_count, va_list actions){
 	std::string t(title ? title : "NULL");
 	if (t == "SSL Certificate Verification") {
 		LOG4CXX_INFO(logger,  "accepting SSL certificate");
 		va_arg(actions, char *);
 		((PurpleRequestActionCb) va_arg(actions, GCallback)) (user_data, 2);
+	}
 	else {
 		if (title) {
 			std::string headerString(title);
 			LOG4CXX_INFO(logger,  "header string: " << headerString);
 			if (headerString == "SSL Certificate Verification") {
 				va_arg(actions, char *);
 				((PurpleRequestActionCb) va_arg(actions, GCallback)) (user_data, 2);
+			}
+		}
+	}
 	return NULL;
+}
 static std::string getAlias(PurpleBuddy *m_buddy) {
 	std::string alias;
 	PurpleContact *contact = PURPLE_CONTACT(PURPLE_BLIST_NODE(m_buddy)->parent);
 	if (contact && contact->alias) {
 		alias = contact->alias;
+	}
 	else if (purple_buddy_get_alias(m_buddy)) {
 		alias = (std::string) purple_buddy_get_alias(m_buddy);
+	}
 	else {
 		alias = (std::string) purple_buddy_get_server_alias(m_buddy);
+	}
 	return alias;
+}
 class SpectrumNetworkPlugin : public NetworkPlugin {
 	public:
-		SpectrumNetworkPlugin(const std::string &host, int port) : NetworkPlugin() {
 		SpectrumNetworkPlugin() : NetworkPlugin() {
+		}
 		void handleExitRequest() {
 			LOG4CXX_INFO(logger, "Exiting...");
-			exit(1);
+			exit(0);
+		}
 		void getProtocolAndName(const std::string &legacyName, std::string &name, std::string &protocol) {
 			name = legacyName;
 			protocol = KEYFILE_STRING("service", "protocol");
 			if (protocol == "any") {
 				protocol = name.substr(0, name.find("."));
 				name = name.substr(name.find(".") + 1);
+			}
+		}
 		void setDefaultAvatar(PurpleAccount *account, const std::string &legacyName) {
 			char* contents;
 			gsize length;
 			gboolean ret = false;
 			if (!KEYFILE_STRING("backend", "avatars_directory").empty()) {
 				std::string f = KEYFILE_STRING("backend", "avatars_directory") + "/" + legacyName;
 				ret = g_file_get_contents (f.c_str(), &contents, &length, NULL);
+			}
 			if (!KEYFILE_STRING("backend", "default_avatar").empty() && !ret) {
 				ret = g_file_get_contents (KEYFILE_STRING("backend", "default_avatar").c_str(),
 											&contents, &length, NULL);
+			}
 			if (ret) {
 				purple_buddy_icons_set_account_icon(account, (guchar *) contents, length);
+			}
+		}
 		void setDefaultAccountOptions(PurpleAccount *account) {
 			int i = 0;
 			gchar **keys = g_key_file_get_keys (keyfile, "purple", NULL, NULL);
 			while (keys && keys[i] != NULL) {
 				std::string key = keys[i];
 				if (key == "fb_api_key" || key == "fb_api_secret") {
 					purple_account_set_bool(account, "auth_fb", TRUE);
+				}
 				PurplePlugin *plugin = purple_find_prpl(purple_account_get_protocol_id(account));
 				PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(plugin);
 				bool found = false;
 				for (GList *l = prpl_info->protocol_options; l != NULL; l = l->next) {
 					PurpleAccountOption *option = (PurpleAccountOption *) l->data;
 					PurplePrefType type = purple_account_option_get_type(option);
 					std::string key2(purple_account_option_get_setting(option));
 					if (key != key2) {
 						continue;
+					}
 					found = true;
 					switch (type) {
 						case PURPLE_PREF_BOOLEAN:
 							purple_account_set_bool(account, key.c_str(), fromString<bool>(KEYFILE_STRING("purple", key)));
 							break;
 						case PURPLE_PREF_INT:
 							purple_account_set_int(account, key.c_str(), fromString<int>(KEYFILE_STRING("purple", key)));
 							break;
 						case PURPLE_PREF_STRING:
 						case PURPLE_PREF_STRING_LIST:
 							purple_account_set_string(account, key.c_str(), KEYFILE_STRING("purple", key).c_str());
 							break;
 						default:
 							continue;
+					}
 					break;
+				}
 				if (!found) {
 					purple_account_set_string(account, key.c_str(), KEYFILE_STRING("purple", key).c_str());
+				}
 				i++;
+			}
 			g_strfreev (keys);
 			char* contents;
 			gsize length;
 			gboolean ret = g_file_get_contents ("gfire.cfg", &contents, &length, NULL);
 			if (ret) {
 				purple_account_set_int(account, "version", fromString<int>(std::string(contents, length)));
+			}
 			if (KEYFILE_STRING("service", "protocol") == "prpl-novell") {
 				std::string username(purple_account_get_username(account));
 				std::vector <std::string> u = split(username, '@');
 				purple_account_set_username(account, (const char*) u.front().c_str());
 				std::vector <std::string> s = split(u.back(), ':');
 				purple_account_set_string(account, "server", s.front().c_str());
 				purple_account_set_int(account, "port", atoi(s.back().c_str()));
+			}
+		}
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 			PurpleAccount *account = NULL;
 			std::string name;
 			std::string protocol;
 			getProtocolAndName(legacyName, name, protocol);
 			if (password.empty()) {
 				LOG4CXX_INFO(logger,  name.c_str() << ": Empty password");
 				np->handleDisconnected(user, 0, "Empty password.");
 				return;
+			}
 			if (!purple_find_prpl(protocol.c_str())) {
 				LOG4CXX_INFO(logger,  name.c_str() << ": Invalid protocol '" << protocol << "'");
 				np->handleDisconnected(user, 0, "Invalid protocol " + protocol);
 				return;
+			}
 			if (purple_accounts_find(name.c_str(), protocol.c_str()) != NULL) {
 				LOG4CXX_INFO(logger, "Using previously created account with name '" << name.c_str() << "' and protocol '" << protocol << "'");
 				account = purple_accounts_find(name.c_str(), protocol.c_str());
+			}
 			else {
 				LOG4CXX_INFO(logger, "Creating account with name '" << name.c_str() << "' and protocol '" << protocol << "'");
 				account = purple_account_new(name.c_str(), protocol.c_str());
 				purple_accounts_add(account);
+			}
 			m_sessions[user] = account;
 			m_accounts[account] = user;
 			// Default avatar
 			setDefaultAvatar(account, legacyName);
 			purple_account_set_password(account, password.c_str());
 			purple_account_set_bool(account, "custom_smileys", FALSE);
 			purple_account_set_bool(account, "direct_connect", FALSE);
 			setDefaultAccountOptions(account);
 			// Enable account + privacy lists
 			purple_account_set_enabled(account, "spectrum", TRUE);
 			if (KEYFILE_BOOL("service", "enable_privacy_lists")) {
 				purple_account_set_privacy_type(account, PURPLE_PRIVACY_DENY_USERS);
+			}
 			// Set the status
 			const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AVAILABLE);
 			if (status_type != NULL) {
 				purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, NULL);
+			}
+		}
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				if (purple_account_get_int(account, "version", 0) != 0) {
 					std::string data = stringOf(purple_account_get_int(account, "version", 0));
 					g_file_set_contents ("gfire.cfg", data.c_str(), data.size(), NULL);
+				}
 // 				VALGRIND_DO_LEAK_CHECK;
 				m_sessions.erase(user);
 				purple_account_disconnect(account);
 				purple_account_set_enabled(account, "spectrum", FALSE);
 				g_free(account->ui_data);
 				account->ui_data = NULL;
 				m_accounts.erase(account);
 				purple_accounts_delete(account);
 //
 // 				// Remove conversations.
 // 				// This has to be called before m_account->ui_data = NULL;, because it uses
 // 				// ui_data to call SpectrumMessageHandler::purpleConversationDestroyed() callback.
 // 				GList *iter;
 // 				for (iter = purple_get_conversations(); iter; ) {
 // 					PurpleConversation *conv = (PurpleConversation*) iter->data;
 // 					iter = iter->next;
 // 					if (purple_conversation_get_account(conv) == account)
 // 						purple_conversation_destroy(conv);
 // 				}
 //
 // 				g_free(account->ui_data);
 // 				account->ui_data = NULL;
 // 				m_accounts.erase(account);
 //
 // 				purple_notify_close_with_handle(account);
 // 				purple_request_close_with_handle(account);
 //
 // 				purple_accounts_remove(account);
 //
 // 				GSList *buddies = purple_find_buddies(account, NULL);
 // 				while(buddies) {
 // 					PurpleBuddy *b = (PurpleBuddy *) buddies->data;
 // 					purple_blist_remove_buddy(b);
 // 					buddies = g_slist_delete_link(buddies, buddies);
 // 				}
 //
 // 				/* Remove any open conversation for this account */
 // 				for (GList *it = purple_get_conversations(); it; ) {
 // 					PurpleConversation *conv = (PurpleConversation *) it->data;
 // 					it = it->next;
 // 					if (purple_conversation_get_account(conv) == account)
 // 						purple_conversation_destroy(conv);
 // 				}
 //
 // 				/* Remove this account's pounces */
 // 					// purple_pounce_destroy_all_by_account(account);
 //
 // 				/* This will cause the deletion of an old buddy icon. */
 // 				purple_buddy_icons_set_account_icon(account, NULL, 0);
 //
 // 				purple_account_destroy(account);
 				// force returning of memory chunks allocated by libxml2 to kernel
 #ifndef WIN32
 				malloc_trim(0);
 #endif
 // 				VALGRIND_DO_LEAK_CHECK;
+			}
+		}
 		void handleStatusChangeRequest(const std::string &user, int status, const std::string &statusMessage) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				int st;
 				switch(status) {
 					case pbnetwork::STATUS_AWAY: {
 						st = PURPLE_STATUS_AWAY;
 						if (!purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AWAY))
 							st = PURPLE_STATUS_EXTENDED_AWAY;
 						else
 							st = PURPLE_STATUS_AWAY;
 						break;
+					}
 					case pbnetwork::STATUS_DND: {
 						st = PURPLE_STATUS_UNAVAILABLE;
 						break;
+					}
 					case pbnetwork::STATUS_XA: {
 						if (!purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_EXTENDED_AWAY))
 							st = PURPLE_STATUS_AWAY;
 						else
 							st = PURPLE_STATUS_EXTENDED_AWAY;
 						break;
+					}
 					case pbnetwork::STATUS_NONE: {
 						st = PURPLE_STATUS_OFFLINE;
 						break;
+					}
 					case pbnetwork::STATUS_INVISIBLE:
 						st = PURPLE_STATUS_INVISIBLE;
 						break;
 					default:
 						st = PURPLE_STATUS_AVAILABLE;
 						break;
+				}
 				gchar *_markup = purple_markup_escape_text(statusMessage.c_str(), -1);
 				std::string markup(_markup);
 				g_free(_markup);
 				// we are already connected so we have to change status
 				const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive(account, (PurpleStatusPrimitive) st);
 				if (status_type != NULL) {
 					// send presence to legacy network
 					if (!markup.empty()) {
 						purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, "message", markup.c_str(), NULL);
+					}
 					else {
 						purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, NULL);
+					}
+				}
+			}
+		}
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
-				PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, legacyName.c_str(), account);
+				PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, legacyName.c_str(), account);
 				if (!conv) {
 					conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, legacyName.c_str());
 					conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, legacyName.c_str(), account);
 					if (!conv) {
 						conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, legacyName.c_str());
+					}
+				}
 				if (xhtml.empty()) {
 					gchar *_markup = purple_markup_escape_text(message.c_str(), -1);
 					purple_conv_im_send(PURPLE_CONV_IM(conv), _markup);
 					if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) {
 						purple_conv_im_send(PURPLE_CONV_IM(conv), _markup);
+					}
 					else if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) {
 						purple_conv_chat_send(PURPLE_CONV_CHAT(conv), _markup);
+					}
 					g_free(_markup);
+				}
 				else {
 					purple_conv_im_send(PURPLE_CONV_IM(conv), xhtml.c_str());
 					if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) {
 						purple_conv_im_send(PURPLE_CONV_IM(conv), xhtml.c_str());
+					}
 					else if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) {
 						purple_conv_chat_send(PURPLE_CONV_CHAT(conv), xhtml.c_str());
+					}
+				}
+			}
+		}
 		void handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				std::string name = legacyName;
 				if (KEYFILE_STRING("service", "protocol") == "any" && legacyName.find("prpl-") == 0) {
 					name = name.substr(name.find(".") + 1);
+				}
 				m_vcards[user + name] = id;
 				if (KEYFILE_BOOL("backend", "no_vcard_fetch") && name != purple_account_get_username(account)) {
 					PurpleNotifyUserInfo *user_info = purple_notify_user_info_new();
 					notify_user_info(purple_account_get_connection(account), name.c_str(), user_info);
 					purple_notify_user_info_destroy(user_info);
+				}
 				else {
 					serv_get_info(purple_account_get_connection(account), name.c_str());
+				}
+			}
+		}
 		void handleVCardUpdatedRequest(const std::string &user, const std::string &image, const std::string &nickname) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				purple_account_set_alias(account, nickname.c_str());
 				purple_account_set_public_alias(account, nickname.c_str(), NULL, NULL);
 				gssize size = image.size();
 				// this will be freed by libpurple
 				guchar *photo = (guchar *) g_malloc(size * sizeof(guchar));
 				memcpy(photo, image.c_str(), size);
 				if (!photo)
 					return;
 				purple_buddy_icons_set_account_icon(account, photo, size);
+			}
+		}
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				if (m_authRequests.find(user + buddyName) != m_authRequests.end()) {
 					m_authRequests[user + buddyName]->deny_cb(m_authRequests[user + buddyName]->user_data);
 					m_authRequests.erase(user + buddyName);
+				}
@@ @@ -870,138 +573,177 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 					purple_blist_add_buddy(buddy, NULL, group ,NULL);
 					purple_account_add_buddy(account, buddy);
+				}
+			}
+		}
 		void handleBuddyBlockToggled(const std::string &user, const std::string &buddyName, bool blocked) {
 			if (KEYFILE_BOOL("service", "enable_privacy_lists")) {
 				PurpleAccount *account = m_sessions[user];
 				if (account) {
 					if (blocked) {
 						purple_privacy_deny(account, buddyName.c_str(), FALSE, FALSE);
+					}
 					else {
 						purple_privacy_allow(account, buddyName.c_str(), FALSE, FALSE);
+					}
+				}
+			}
+		}
 		void handleTypingRequest(const std::string &user, const std::string &buddyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				serv_send_typing(purple_account_get_connection(account), buddyName.c_str(), PURPLE_TYPING);
+			}
+		}
 		void handleTypedRequest(const std::string &user, const std::string &buddyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				serv_send_typing(purple_account_get_connection(account), buddyName.c_str(), PURPLE_TYPED);
+			}
+		}
 		void handleStoppedTypingRequest(const std::string &user, const std::string &buddyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				serv_send_typing(purple_account_get_connection(account), buddyName.c_str(), PURPLE_NOT_TYPING);
+			}
+		}
 		void handleAttentionRequest(const std::string &user, const std::string &buddyName, const std::string &message) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				purple_prpl_send_attention(purple_account_get_connection(account), buddyName.c_str(), 0);
+			}
+		}
 		void handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &pasword) {
 			PurpleAccount *account = m_sessions[user];
 			if (!account) {
 				return;
+			}
 			PurpleConnection *gc = purple_account_get_connection(account);
 			GHashTable *comps = NULL;
 			// Check if the PurpleChat is not stored in buddy list
 			PurpleChat *chat = purple_blist_find_chat(account, room.c_str());
 			if (chat) {
 				comps = purple_chat_get_components(chat);
+			}
 			else if (PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info_defaults != NULL) {
 				comps = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info_defaults(gc, room.c_str());
+			}
 			LOG4CXX_INFO(logger, user << ": Joining the room " << room);
 			if (comps) {
 				serv_join_chat(gc, comps);
 				g_hash_table_destroy(comps);
+			}
+		}
 		void handleLeaveRoomRequest(const std::string &user, const std::string &room) {
 			PurpleAccount *account = m_sessions[user];
 			if (!account) {
 				return;
+			}
 			PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, room.c_str(), account);
 			purple_conversation_destroy(conv);
+		}
 		void handleFTStartRequest(const std::string &user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID) {
 			PurpleXfer *xfer = m_unhandledXfers[user + fileName + buddyName];
 			if (xfer) {
 				m_unhandledXfers.erase(user + fileName + buddyName);
 				FTData *ftData = (FTData *) xfer->ui_data;
 				ftData->id = ftID;
 				m_xfers[ftID] = xfer;
 				purple_xfer_request_accepted(xfer, fileName.c_str());
 				purple_xfer_ui_ready(xfer);
+			}
+		}
 		void handleFTFinishRequest(const std::string &user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID) {
 			PurpleXfer *xfer = m_unhandledXfers[user + fileName + buddyName];
 			if (xfer) {
 				m_unhandledXfers.erase(user + fileName + buddyName);
 				purple_xfer_request_denied(xfer);
+			}
+		}
 		void handleFTPauseRequest(unsigned long ftID) {
 			PurpleXfer *xfer = m_xfers[ftID];
 			if (!xfer)
 				return;
 			FTData *ftData = (FTData *) xfer->ui_data;
 			ftData->paused = true;
+		}
 		void handleFTContinueRequest(unsigned long ftID) {
 			PurpleXfer *xfer = m_xfers[ftID];
 			if (!xfer)
 				return;
 			FTData *ftData = (FTData *) xfer->ui_data;
 			ftData->paused = false;
 			purple_xfer_ui_ready(xfer);
+		}
 		void sendData(const std::string &string) {
 			write(m_sock, string.c_str(), string.size());
 #ifdef WIN32
 			::send(main_socket, string.c_str(), string.size(), 0);
 #else
 			write(main_socket, string.c_str(), string.size());
 #endif
 			if (writeInput == 0)
-				writeInput = purple_input_add(m_sock, PURPLE_INPUT_WRITE, &transportDataReceived, NULL);
+				writeInput = purple_input_add(main_socket, PURPLE_INPUT_WRITE, &transportDataReceived, NULL);
+		}
 		void readyForData() {
 			if (m_waitingXfers.empty())
 				return;
 			std::vector<PurpleXfer *> tmp;
 			tmp.swap(m_waitingXfers);
 			for (std::vector<PurpleXfer *>::const_iterator it = tmp.begin(); it != tmp.end(); it++) {
 				FTData *ftData = (FTData *) (*it)->ui_data;
 				if (ftData->timer == 0) {
 					ftData->timer = purple_timeout_add(1, ft_ui_ready, *it);
+				}
 // 				purple_xfer_ui_ready(xfer);
+			}
+		}
 		std::map<std::string, PurpleAccount *> m_sessions;
 		std::map<PurpleAccount *, std::string> m_accounts;
 		std::map<std::string, unsigned int> m_vcards;
 		std::map<std::string, authRequest *> m_authRequests;
 		std::map<unsigned long, PurpleXfer *> m_xfers;
 		std::map<std::string, PurpleXfer *> m_unhandledXfers;
 		std::vector<PurpleXfer *> m_waitingXfers;
 };
 static bool getStatus(PurpleBuddy *m_buddy, pbnetwork::StatusType &status, std::string &statusMessage) {
 	PurplePresence *pres = purple_buddy_get_presence(m_buddy);
 	if (pres == NULL)
 		return false;
 	PurpleStatus *stat = purple_presence_get_active_status(pres);
 	if (stat == NULL)
 		return false;
 	int st = purple_status_type_get_primitive(purple_status_get_type(stat));
 	switch(st) {
 		case PURPLE_STATUS_AVAILABLE: {
 			status = pbnetwork::STATUS_ONLINE;
 			break;
+		}
 		case PURPLE_STATUS_AWAY: {
 			status = pbnetwork::STATUS_AWAY;
 			break;
+		}
 		case PURPLE_STATUS_UNAVAILABLE: {
 			status = pbnetwork::STATUS_DND;
 			break;
+		}
@@ @@ -1045,237 +787,287 @@ static std::string getIconHash(PurpleBuddy *m_buddy) { @@
 		if (hash) {
 			char *dot;
 			hash++;
 			dot = strchr(hash, '.');
 			if (dot)
 				*dot = '\0';
 			std::string ret(hash);
 			g_free(avatarHash);
 			return ret;
+		}
 		else {
 			std::string ret(avatarHash);
 			g_free(avatarHash);
 			return ret;
+		}
+	}
 	return "";
+}
 static std::vector<std::string> getGroups(PurpleBuddy *m_buddy) {
 	std::vector<std::string> groups;
 	if (purple_buddy_get_name(m_buddy)) {
 		GSList *buddies = purple_find_buddies(purple_buddy_get_account(m_buddy), purple_buddy_get_name(m_buddy));
 		while(buddies) {
 			PurpleGroup *g = purple_buddy_get_group((PurpleBuddy *) buddies->data);
 			buddies = g_slist_delete_link(buddies, buddies);
 			if(g && purple_group_get_name(g)) {
 				groups.push_back(purple_group_get_name(g));
+			}
+		}
+	}
 	if (groups.empty()) {
 		groups.push_back("Buddies");
+	}
 	return groups;
+}
 static void buddyListNewNode(PurpleBlistNode *node) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 	PurpleBuddy *buddy = (PurpleBuddy *) node;
 	PurpleAccount *account = purple_buddy_get_account(buddy);
 	LOG4CXX_INFO(logger, "Buddy updated " << np->m_accounts[account] << " " << purple_buddy_get_name(buddy) << " " << getAlias(buddy));
 	std::vector<std::string> groups = getGroups(buddy);
 	LOG4CXX_INFO(logger, "Buddy updated " << np->m_accounts[account] << " " << purple_buddy_get_name(buddy) << " " << getAlias(buddy) << " group (" << groups.size() << ")=" << groups[0]);
 	// Status
 	pbnetwork::StatusType status = pbnetwork::STATUS_NONE;
 	std::string message;
 	getStatus(buddy, status, message);
 	// Tooltip
 	PurplePlugin *prpl = purple_find_prpl(purple_account_get_protocol_id(account));
 	PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
 	bool blocked = false;
 	if (KEYFILE_BOOL("service", "enable_privacy_lists")) {
 		if (prpl_info && prpl_info->tooltip_text) {
 			PurpleNotifyUserInfo *user_info = purple_notify_user_info_new();
 			prpl_info->tooltip_text(buddy, user_info, true);
 			GList *entries = purple_notify_user_info_get_entries(user_info);
 			while (entries) {
 				PurpleNotifyUserInfoEntry *entry = (PurpleNotifyUserInfoEntry *)(entries->data);
 				if (purple_notify_user_info_entry_get_label(entry) && purple_notify_user_info_entry_get_value(entry)) {
 					std::string label = purple_notify_user_info_entry_get_label(entry);
 					if (label == "Blocked" ) {
 						if (std::string(purple_notify_user_info_entry_get_value(entry)) == "Yes") {
 							blocked = true;
 							break;
+						}
+					}
+				}
 				entries = entries->next;
+			}
 			purple_notify_user_info_destroy(user_info);
+		}
 		if (!blocked) {
 			blocked = purple_privacy_check(account, purple_buddy_get_name(buddy)) == false;
+		}
 		else {
 			bool purpleBlocked = purple_privacy_check(account, purple_buddy_get_name(buddy)) == false;
 			if (blocked != purpleBlocked) {
 				purple_privacy_deny(account, purple_buddy_get_name(buddy), FALSE, FALSE);
+			}
+		}
+	}
 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy), status, message, getIconHash(buddy),
 		blocked
 	);
+}
 static void buddyListUpdate(PurpleBuddyList *list, PurpleBlistNode *node) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 	buddyListNewNode(node);
+}
 static void buddyPrivacyChanged(PurpleBlistNode *node, void *data) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 	buddyListUpdate(NULL, node);
+}
 static void NodeRemoved(PurpleBlistNode *node, void *data) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 // 	PurpleBuddy *buddy = (PurpleBuddy *) node;
+}
 static PurpleBlistUiOps blistUiOps =
+{
 	NULL,
 	buddyListNewNode,
 	NULL,
 	buddyListUpdate,
 	NULL, //NodeRemoved,
 	NULL,
 	NULL,
 	NULL, // buddyListAddBuddy,
 	NULL,
 	NULL,
 	NULL, //buddyListSaveNode,
 	NULL, //buddyListRemoveNode,
 	NULL, //buddyListSaveAccount,
 	NULL
 };
 static void conv_write_im(PurpleConversation *conv, const char *who, const char *msg, PurpleMessageFlags flags, time_t mtime) {
 	// Don't forwards our own messages.
 	if (flags & PURPLE_MESSAGE_SEND || flags & PURPLE_MESSAGE_SYSTEM)
+	if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM && (flags & PURPLE_MESSAGE_SEND || flags & PURPLE_MESSAGE_SYSTEM)) {
 		return;
+	}
 	PurpleAccount *account = purple_conversation_get_account(conv);
 // 	char *striped = purple_markup_strip_html(message);
 // 	std::string msg = striped;
 // 	g_free(striped);
 	std::string w = purple_normalize(account, who);
 	size_t pos = w.find("/");
 	if (pos != std::string::npos)
 		w.erase((int) pos, w.length() - (int) pos);
 	// Escape HTML characters.
 	char *newline = purple_strdup_withhtml(msg);
 	char *strip, *xhtml;
 	purple_markup_html_to_xhtml(newline, &xhtml, &strip);
 // 	xhtml_linkified = spectrum_markup_linkify(xhtml);
 	std::string message_(strip);
 	std::string xhtml_(xhtml);
 	g_free(newline);
 	g_free(xhtml);
 // 	g_free(xhtml_linkified);
 	g_free(strip);
 	// AIM and XMPP adds <body>...</body> here...
 	if (xhtml_.find("<body>") == 0) {
 		xhtml_ = xhtml_.substr(6);
 		if (xhtml_.find("</body>") != std::string::npos) {
 			xhtml_ = xhtml_.substr(0, xhtml_.find("</body>"));
+		}
+	}
 	if (xhtml_ == message_) {
 		xhtml_ = "";
+	}
 // 	LOG4CXX_INFO(logger, "Received message body='" << message_ << "' xhtml='" << xhtml_ << "'");
 	np->handleMessage(np->m_accounts[account], w, message_, "", xhtml_);
 	if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) {
 		np->handleMessage(np->m_accounts[account], w, message_, "", xhtml_);
+	}
 	else {
 		LOG4CXX_INFO(logger, "Received message body='" << message_ << "' name='" << purple_conversation_get_name(conv) << "' " << w);
 		np->handleMessage(np->m_accounts[account], purple_conversation_get_name(conv), message_, w, xhtml_);
+	}
+}
 static void conv_chat_add_users(PurpleConversation *conv, GList *cbuddies, gboolean new_arrivals) {
 	PurpleAccount *account = purple_conversation_get_account(conv);
 	GList *l = cbuddies;
 	while (l != NULL) {
 		PurpleConvChatBuddy *cb = (PurpleConvChatBuddy *)l->data;
 		std::string name(cb->name);
 		int flags = GPOINTER_TO_INT(cb->flags);
 		if (flags & PURPLE_CBFLAGS_OP || flags & PURPLE_CBFLAGS_HALFOP) {
 // 			item->addAttribute("affiliation", "admin");
 // 			item->addAttribute("role", "moderator");
 			flags = 1;
+		}
 		else if (flags & PURPLE_CBFLAGS_FOUNDER) {
 // 			item->addAttribute("affiliation", "owner");
 // 			item->addAttribute("role", "moderator");
 			flags = 1;
+		}
 		else {
 			flags = 0;
 // 			item->addAttribute("affiliation", "member");
 // 			item->addAttribute("role", "participant");
+		}
 		np->handleParticipantChanged(np->m_accounts[account], name, purple_conversation_get_name(conv), (int) flags, pbnetwork::STATUS_ONLINE);
 		l = l->next;
+	}
+}
 static void conv_chat_remove_users(PurpleConversation *conv, GList *users) {
 	PurpleAccount *account = purple_conversation_get_account(conv);
 	GList *l = users;
 	while (l != NULL) {
 		std::string name((char *) l->data);
 		np->handleParticipantChanged(np->m_accounts[account], name, purple_conversation_get_name(conv), 0, pbnetwork::STATUS_NONE);
 		l = l->next;
+	}
+}
 static PurpleConversationUiOps conversation_ui_ops =
+{
 	NULL,
 	NULL,
-	NULL,//conv_write_chat,                              /* write_chat           */
+	conv_write_im,//conv_write_chat,                              /* write_chat           */
 	conv_write_im,             /* write_im             */
 	NULL,//conv_write_conv,           /* write_conv           */
-	NULL,//conv_chat_add_users,       /* chat_add_users       */
 	conv_chat_add_users,       /* chat_add_users       */
 	NULL,//conv_chat_rename_user,     /* chat_rename_user     */
-	NULL,//conv_chat_remove_users,    /* chat_remove_users    */
 	conv_chat_remove_users,    /* chat_remove_users    */
 	NULL,//pidgin_conv_chat_update_user,     /* chat_update_user     */
 	NULL,//pidgin_conv_present_conversation, /* present              */
 	NULL,//pidgin_conv_has_focus,            /* has_focus            */
 	NULL,//pidgin_conv_custom_smiley_add,    /* custom_smiley_add    */
 	NULL,//pidgin_conv_custom_smiley_write,  /* custom_smiley_write  */
 	NULL,//pidgin_conv_custom_smiley_close,  /* custom_smiley_close  */
 	NULL,//pidgin_conv_send_confirm,         /* send_confirm         */
 	NULL,
 	NULL,
 	NULL,
 	NULL
 };
 struct Dis {
 	std::string name;
 	std::string protocol;
 };
 static gboolean disconnectMe(void *data) {
 	Dis *d = (Dis *) data;
 	PurpleAccount *account = purple_accounts_find(d->name.c_str(), d->protocol.c_str());
 	delete d;
 	if (account) {
 		np->handleLogoutRequest(np->m_accounts[account], purple_account_get_username(account));
+	}
 	return FALSE;
+}
 static gboolean pingTimeout(void *data) {
 	np->checkPing();
 	return TRUE;
+}
 static void connection_report_disconnect(PurpleConnection *gc, PurpleConnectionError reason, const char *text){
 	PurpleAccount *account = purple_connection_get_account(gc);
 	np->handleDisconnected(np->m_accounts[account], (int) reason, text ? text : "");
 	Dis *d = new Dis;
 	d->name = purple_account_get_username(account);
 	d->protocol = purple_account_get_protocol_id(account);
 	purple_timeout_add_seconds(10, disconnectMe, d);
+}
 static PurpleConnectionUiOps conn_ui_ops =
+{
 	NULL,
 	NULL,
 	NULL,//connection_disconnected,
+			}
 			else {
 				LOG4CXX_WARN(logger, "Unhandled VCard Label '" << purple_notify_user_info_entry_get_label(vcardEntry) << "' " << purple_notify_user_info_entry_get_value(vcardEntry));
+			}
+		}
 		vcardEntries = vcardEntries->next;
+	}
 	if ((!firstName.empty() || !lastName.empty()) && fullName.empty())
 		fullName = firstName + " " + lastName;
 	if (nickname.empty() && !fullName.empty()) {
 		nickname = fullName;
+	}
 	bool ownInfo = name == purple_account_get_username(account);
 	if (ownInfo) {
 		const gchar *displayname = purple_connection_get_display_name(gc);
 		if (!displayname) {
 			displayname = purple_account_get_name_for_display(account);
+		}
 		if (displayname && nickname.empty()) {
 			nickname = displayname;
+		}
 		// avatar
 		PurpleStoredImage *avatar = purple_buddy_icons_find_account_icon(account);
 		if (avatar) {
 			const gchar * data = (const gchar *) purple_imgstore_get_data(avatar);
 			size_t len = purple_imgstore_get_size(avatar);
 			if (len < 300000 && data) {
 				photo = std::string(data, len);
+			}
 			purple_imgstore_unref(avatar);
+		}
+	}
 	PurpleBuddy *buddy = purple_find_buddy(purple_connection_get_account(gc), who);
 	if (buddy && photo.size() == 0) {
 		gsize len;
 		PurpleBuddyIcon *icon = NULL;
 		icon = purple_buddy_icons_find(purple_connection_get_account(gc), name.c_str());
 		if (icon) {
 			if (true) {
 				gchar *data;
 				gchar *path = purple_buddy_icon_get_full_path(icon);
 				if (g_file_get_contents (path, &data, &len, NULL)) {
 					photo = std::string(data, len);
 					free(data);
 				if (path) {
 					if (g_file_get_contents(path, &data, &len, NULL)) {
 						photo = std::string(data, len);
 						g_free(data);
+					}
 					g_free(path);
+				}
 				free(path);
+			}
 			else {
 				const gchar * data = (gchar*)purple_buddy_icon_get_data(icon, &len);
 				if (len < 300000 && data) {
 					photo = std::string(data, len);
+				}
+			}
 			purple_buddy_icon_unref(icon);
+		}
+	}
 	np->handleVCard(np->m_accounts[account], np->m_vcards[np->m_accounts[account] + name], name, fullName, nickname, photo);
 	np->m_vcards.erase(np->m_accounts[account] + name);
 	return NULL;
+}
 static PurpleNotifyUiOps notifyUiOps =
+{
 		NULL,
 		NULL,
 		NULL,
 		NULL,
 		NULL,
 		NULL,
 		notify_user_info,
 		NULL,
 		NULL,
 		NULL,
 		NULL,
 		NULL,
 		NULL
 };
 static PurpleRequestUiOps requestUiOps =
+{
 	requestInput,
 	NULL,
 	requestAction,
 	NULL,
 	NULL,
 	NULL, //requestClose,
 	NULL,
 	NULL,
 	NULL,
 	NULL,
 	NULL
 };
@@ @@ -1629,398 +1423,323 @@ spectrum_glib_log_handler(const gchar *domain, @@
 		level = "WARNING";
 	else if ((flags & G_LOG_LEVEL_MESSAGE) == G_LOG_LEVEL_MESSAGE)
 		level = "MESSAGE";
 	else if ((flags & G_LOG_LEVEL_INFO) == G_LOG_LEVEL_INFO)
 		level = "INFO";
 	else if ((flags & G_LOG_LEVEL_DEBUG) == G_LOG_LEVEL_DEBUG)
 		level = "DEBUG";
 	else {
 		LOG4CXX_ERROR(logger, "Unknown glib logging level in " << (guint)flags);
 		level = "UNKNOWN"; /* This will never happen. */
+	}
 	if (message != NULL)
 		new_msg = purple_utf8_try_convert(message);
 	if (domain != NULL)
 		new_domain = purple_utf8_try_convert(domain);
 	if (new_msg != NULL) {
 		std::string area("glib");
 		area.push_back('/');
 		area.append(level);
 		std::string message(new_domain ? new_domain : "g_log");
 		message.push_back(' ');
 		message.append(new_msg);
 		LOG4CXX_ERROR(logger, message);
 		g_free(new_msg);
+	}
 	g_free(new_domain);
+}
 static void
 debug_init(void)
+{
 #define REGISTER_G_LOG_HANDLER(name) \
 	g_log_set_handler((name), \
 		(GLogLevelFlags)(G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL \
 										  | G_LOG_FLAG_RECURSION), \
 					  spectrum_glib_log_handler, NULL)
 	REGISTER_G_LOG_HANDLER(NULL);
 	REGISTER_G_LOG_HANDLER("GLib");
 	REGISTER_G_LOG_HANDLER("GModule");
 	REGISTER_G_LOG_HANDLER("GLib-GObject");
 	REGISTER_G_LOG_HANDLER("GThread");
 	REGISTER_G_LOG_HANDLER("GConf");
 #undef REGISTER_G_LOD_HANDLER
+}
 static PurpleCoreUiOps coreUiOps =
+{
 	NULL,
 	debug_init,
 	transport_core_ui_init,
 	NULL,
 	spectrum_ui_get_info,
 	NULL,
 	NULL,
 	NULL
 };
 static void signed_on(PurpleConnection *gc, gpointer unused) {
 	PurpleAccount *account = purple_connection_get_account(gc);
 	np->handleConnected(np->m_accounts[account]);
 #ifndef WIN32
 	// force returning of memory chunks allocated by libxml2 to kernel
 	malloc_trim(0);
 #endif
 	// For prpl-gg
 	execute_purple_plugin_action(gc, "Download buddylist from Server");
+}
 static void printDebug(PurpleDebugLevel level, const char *category, const char *arg_s) {
 	std::string c("");
 	std::string args(arg_s);
 	args.erase(args.size() - 1);
 	if (category) {
 		c.append(category);
+	}
 	c.push_back(':');
 	LOG4CXX_INFO(logger_libpurple, c << args);
+}
 /*
  * Ops....
  */
 static PurpleDebugUiOps debugUiOps =
+{
 	printDebug,
 	NULL,
 	NULL,
 	NULL,
 	NULL,
 	NULL
 };
 static void buddyTyping(PurpleAccount *account, const char *who, gpointer null) {
 	std::string w = purple_normalize(account, who);
 	size_t pos = w.find("/");
 	if (pos != std::string::npos)
 		w.erase((int) pos, w.length() - (int) pos);
 	np->handleBuddyTyping(np->m_accounts[account], w);
+}
 static void buddyTyped(PurpleAccount *account, const char *who, gpointer null) {
 	std::string w = purple_normalize(account, who);
 	size_t pos = w.find("/");
 	if (pos != std::string::npos)
 		w.erase((int) pos, w.length() - (int) pos);
 	np->handleBuddyTyped(np->m_accounts[account], w);
+}
 static void buddyTypingStopped(PurpleAccount *account, const char *who, gpointer null){
 	std::string w = purple_normalize(account, who);
 	size_t pos = w.find("/");
 	if (pos != std::string::npos)
 		w.erase((int) pos, w.length() - (int) pos);
 	np->handleBuddyStoppedTyping(np->m_accounts[account], w);
+}
 static void gotAttention(PurpleAccount *account, const char *who, PurpleConversation *conv, guint type) {
 	std::string w = purple_normalize(account, who);
 	size_t pos = w.find("/");
 	if (pos != std::string::npos)
 		w.erase((int) pos, w.length() - (int) pos);
 	np->handleAttention(np->m_accounts[account], w, "");
+}
 static bool initPurple() {
 	bool ret;
 	if (!resolvePurpleFunctions()) {
 		LOG4CXX_ERROR(logger, "Unable to load libpurple.dll or some of the needed methods");
 		return false;
+	}
 	purple_plugins_add_search_path("./plugins");
 	purple_util_set_user_dir("./");
 	remove("./accounts.xml");
 	remove("./blist.xml");
 // 	if (m_configuration.logAreas & LOG_AREA_PURPLE)
 		purple_debug_set_ui_ops(&debugUiOps);
 		purple_debug_set_verbose(true);
 	purple_debug_set_ui_ops(&debugUiOps);
 	purple_debug_set_verbose(true);
 	purple_core_set_ui_ops(&coreUiOps);
 	if (KEYFILE_STRING("service", "eventloop") == "libev") {
 		LOG4CXX_INFO(logger, "Will use libev based event loop");
+	}
 	else {
 		LOG4CXX_INFO(logger, "Will use glib based event loop");
+	}
 	purple_eventloop_set_ui_ops(getEventLoopUiOps(KEYFILE_STRING("service", "eventloop") == "libev"));
 	ret = purple_core_init("spectrum");
 	if (ret) {
 		static int blist_handle;
 		static int conversation_handle;
 		purple_set_blist(purple_blist_new());
 		purple_blist_load();
 		purple_prefs_load();
 		/* Good default preferences */
 		/* The combination of these two settings mean that libpurple will never
 		 * (of its own accord) set all the user accounts idle.
 		 */
 		purple_prefs_set_bool("/purple/away/away_when_idle", false);
 		/*
 		 * This must be set to something not "none" for idle reporting to work
 		 * for, e.g., the OSCAR prpl. We don't implement the UI ops, so this is
 		 * okay for now.
 		 */
 		purple_prefs_set_string("/purple/away/idle_reporting", "system");
 		/* Disable all logging */
 		purple_prefs_set_bool("/purple/logging/log_ims", false);
 		purple_prefs_set_bool("/purple/logging/log_chats", false);
 		purple_prefs_set_bool("/purple/logging/log_system", false);
 // 		purple_signal_connect(purple_conversations_get_handle(), "received-im-msg", &conversation_handle, PURPLE_CALLBACK(newMessageReceived), NULL);
 		purple_signal_connect(purple_conversations_get_handle(), "buddy-typing", &conversation_handle, PURPLE_CALLBACK(buddyTyping), NULL);
 		purple_signal_connect(purple_conversations_get_handle(), "buddy-typed", &conversation_handle, PURPLE_CALLBACK(buddyTyped), NULL);
 		purple_signal_connect(purple_conversations_get_handle(), "buddy-typing-stopped", &conversation_handle, PURPLE_CALLBACK(buddyTypingStopped), NULL);
 		purple_signal_connect(purple_blist_get_handle(), "buddy-privacy-changed", &conversation_handle, PURPLE_CALLBACK(buddyPrivacyChanged), NULL);
 		purple_signal_connect(purple_conversations_get_handle(), "got-attention", &conversation_handle, PURPLE_CALLBACK(gotAttention), NULL);
 		purple_signal_connect(purple_connections_get_handle(), "signed-on", &blist_handle,PURPLE_CALLBACK(signed_on), NULL);
 // 		purple_signal_connect(purple_blist_get_handle(), "buddy-removed", &blist_handle,PURPLE_CALLBACK(buddyRemoved), NULL);
 // 		purple_signal_connect(purple_blist_get_handle(), "buddy-signed-on", &blist_handle,PURPLE_CALLBACK(buddySignedOn), NULL);
 // 		purple_signal_connect(purple_blist_get_handle(), "buddy-signed-off", &blist_handle,PURPLE_CALLBACK(buddySignedOff), NULL);
 // 		purple_signal_connect(purple_blist_get_handle(), "buddy-status-changed", &blist_handle,PURPLE_CALLBACK(buddyStatusChanged), NULL);
 		purple_signal_connect(purple_blist_get_handle(), "blist-node-removed", &blist_handle,PURPLE_CALLBACK(NodeRemoved), NULL);
 // 		purple_signal_connect(purple_conversations_get_handle(), "chat-topic-changed", &conversation_handle, PURPLE_CALLBACK(conv_chat_topic_changed), NULL);
 		static int xfer_handle;
 		purple_signal_connect(purple_xfers_get_handle(), "file-send-start", &xfer_handle, PURPLE_CALLBACK(fileSendStart), NULL);
 		purple_signal_connect(purple_xfers_get_handle(), "file-recv-start", &xfer_handle, PURPLE_CALLBACK(fileRecvStart), NULL);
 		purple_signal_connect(purple_xfers_get_handle(), "file-recv-request", &xfer_handle, PURPLE_CALLBACK(newXfer), NULL);
 		purple_signal_connect(purple_xfers_get_handle(), "file-recv-complete", &xfer_handle, PURPLE_CALLBACK(XferReceiveComplete), NULL);
 		purple_signal_connect(purple_xfers_get_handle(), "file-send-complete", &xfer_handle, PURPLE_CALLBACK(XferSendComplete), NULL);
 //
 // 		purple_commands_init();
+	}
 	return ret;
+}
 #ifndef WIN32
 static void spectrum_sigchld_handler(int sig)
+{
 	int status;
 	pid_t pid;
 	do {
 		pid = waitpid(-1, &status, WNOHANG);
 	} while (pid != 0 && pid != (pid_t)-1);
 	if ((pid == (pid_t) - 1) && (errno != ECHILD)) {
 		char errmsg[BUFSIZ];
 		snprintf(errmsg, BUFSIZ, "Warning: waitpid() returned %d", pid);
 		perror(errmsg);
+	}
+}
 #endif
 static int create_socket(char *host, int portno) {
 	struct sockaddr_in serv_addr;
 	int m_sock = socket(AF_INET, SOCK_STREAM, 0);
 	memset((char *) &serv_addr, 0, sizeof(serv_addr));
 	serv_addr.sin_family = AF_INET;
 	serv_addr.sin_port = htons(portno);
 	hostent *hos;  // Resolve name
 	if ((hos = gethostbyname(host)) == NULL) {
 		// strerror() will not work for gethostbyname() and hstrerror()
 		// is supposedly obsolete
 		exit(1);
+	}
 	serv_addr.sin_addr.s_addr = *((unsigned long *) hos->h_addr_list[0]);
 	if (connect(m_sock, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
 		close(m_sock);
 		m_sock = 0;
+	}
 	int flags = fcntl(m_sock, F_GETFL);
 	flags |= O_NONBLOCK;
 	fcntl(m_sock, F_SETFL, flags);
 	return m_sock;
+}
 static void transportDataReceived(gpointer data, gint source, PurpleInputCondition cond) {
 	if (cond & PURPLE_INPUT_READ) {
 		char buffer[65535];
 		char *ptr = buffer;
 #ifdef WIN32
 		ssize_t n = recv(source, ptr, sizeof(buffer), 0);
 #else
 		ssize_t n = read(source, ptr, sizeof(buffer));
 #endif
 		if (n <= 0) {
 			LOG4CXX_INFO(logger, "Diconnecting from spectrum2 server");
 			exit(errno);
+		}
 		std::string d = std::string(buffer, n);
 		np->handleDataRead(d);
+	}
 	else {
 		if (writeInput != 0) {
 			purple_input_remove(writeInput);
 			writeInput = 0;
+		}
 		np->readyForData();
+	}
+}
 int main(int argc, char **argv) {
 	GError *error = NULL;
 	GOptionContext *context;
 	context = g_option_context_new("config_file_name or profile name");
 	g_option_context_add_main_entries(context, options_entries, "");
 	if (!g_option_context_parse (context, &argc, &argv, &error)) {
-		std::cout << "option parsing failed: " << error->message << "\n";
+		std::cerr << "option parsing failed: " << error->message << "\n";
 		return -1;
+	}
 	if (ver) {
 // 		std::cout << VERSION << "\n";
 		std::cout << "verze\n";
 		g_option_context_free(context);
 		return 0;
+	}
 	if (argc != 2) {
 #ifdef WIN32
 		std::cout << "Usage: spectrum.exe <configuration_file.cfg>\n";
 #else
 #if GLIB_CHECK_VERSION(2,14,0)
 	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;
+		}
 //
 // 		if (signal(SIGINT, spectrum_sigint_handler) == SIG_ERR) {
 // 			std::cout << "SIGINT handler can't be set\n";
 // 			g_option_context_free(context);
 // 			return -1;
 // 		}
 //
 // 		if (signal(SIGTERM, spectrum_sigterm_handler) == SIG_ERR) {
 // 			std::cout << "SIGTERM handler can't be set\n";
 // 			g_option_context_free(context);
 // 			return -1;
 // 		}
 //
 // 		struct sigaction sa;
 // 		memset(&sa, 0, sizeof(sa));
 // 		sa.sa_handler = spectrum_sighup_handler;
 // 		if (sigaction(SIGHUP, &sa, NULL)) {
 // 			std::cout << "SIGHUP 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 = new log4cxx::helpers::FileInputStream(KEYFILE_STRING("logging", "backend_config"));
 			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);
 		Config config;
 		if (!config.load(argv[1])) {
 			std::cerr << "Can't open " << argv[1] << " configuration file.\n";
 			return 1;
+		}
 		Logging::initBackendLogging(&config);
 		initPurple();
 		m_sock = create_socket(host, port);
 		purple_input_add(m_sock, PURPLE_INPUT_READ, &transportDataReceived, NULL);
 		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(host, port);
 		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);
+		}
 #ifdef WITH_LIBEVENT
 		else {
 			event_loop(0);
+		}
 #endif
+	}
 	g_option_context_free(context);
 	return 0;
+}

backends/libpurple/purple_defs.cpp

➞

Show inline comments

@@ new file 100644 @@
 #include "purple_defs.h"
 bool resolvePurpleFunctions() {
 	return true;
+}

backends/libpurple/purple_defs.h

➞

Show inline comments

		new file 100644
		#pragma once

		bool resolvePurpleFunctions();

backends/libpurple/utils.cpp

➞

Show inline comments

@@ new file 100644 @@
 /**
  * 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 "utils.h"
 #include "glib.h"
 #include "purple.h"
 #include <algorithm>
 #include <iostream>
 #include "errno.h"
 #ifndef WIN32
 #include "sys/wait.h"
 #include "sys/signal.h"
 #include <netinet/if_ether.h>
 #include <netinet/ip.h>
 #include <netinet/ip6.h>
 #include <netinet/udp.h>
 #include <netinet/tcp.h>
 #include <netinet/ether.h>
 #include "sys/socket.h"
 #include <netdb.h>
 #include <unistd.h>
 #include <fcntl.h>
 #else
 #include <process.h>
 #define getpid _getpid
 #define ssize_t SSIZE_T
 #include "win32/win32dep.h"
 #endif
 #include "purple_defs.h"
 static GHashTable *ui_info = NULL;
 void execute_purple_plugin_action(PurpleConnection *gc, const std::string &name) {
 	PurplePlugin *plugin = gc && PURPLE_CONNECTION_IS_CONNECTED(gc) ? gc->prpl : NULL;
 	if (plugin && PURPLE_PLUGIN_HAS_ACTIONS(plugin)) {
 		PurplePluginAction *action = NULL;
 		GList *actions, *l;
 		actions = PURPLE_PLUGIN_ACTIONS(plugin, gc);
 		for (l = actions; l != NULL; l = l->next) {
 			if (l->data) {
 				action = (PurplePluginAction *) l->data;
 				action->plugin = plugin;
 				action->context = gc;
 				if ((std::string) action->label == name) {
 					action->callback(action);
+				}
 				purple_plugin_action_free(action);
+			}
+		}
+	}
+}
 GHashTable *spectrum_ui_get_info(void)
+{
 	if(NULL == ui_info) {
 		ui_info = g_hash_table_new(g_str_hash, g_str_equal);
 		g_hash_table_insert(ui_info, g_strdup("name"), g_strdup("Spectrum"));
 		g_hash_table_insert(ui_info, g_strdup("version"), g_strdup("0.5"));
 		g_hash_table_insert(ui_info, g_strdup("website"), g_strdup("http://spectrum.im"));
 		g_hash_table_insert(ui_info, g_strdup("dev_website"), g_strdup("http://spectrum.im"));
 		g_hash_table_insert(ui_info, g_strdup("client_type"), g_strdup("pc"));
 		/*
 		 * This is the client key for "Pidgin."  It is owned by the AIM
 		 * account "markdoliner."  Please don't use this key for other
 		 * applications.  You can either not specify a client key, in
 		 * which case the default "libpurple" key will be used, or you
 		 * can register for your own client key at
 		 * http://developer.aim.com/manageKeys.jsp
 		 */
 		g_hash_table_insert(ui_info, g_strdup("prpl-aim-clientkey"), g_strdup("ma1cSASNCKFtrdv9"));
 		g_hash_table_insert(ui_info, g_strdup("prpl-icq-clientkey"), g_strdup("ma1cSASNCKFtrdv9"));
 		/*
 		 * This is the distid for Pidgin, given to us by AOL.  Please
 		 * don't use this for other applications.  You can just not
 		 * specify a distid and libpurple will use a default.
 		 */
 		g_hash_table_insert(ui_info, g_strdup("prpl-aim-distid"), GINT_TO_POINTER(1550));
 		g_hash_table_insert(ui_info, g_strdup("prpl-icq-distid"), GINT_TO_POINTER(1550));
+	}
 	return ui_info;
+}
 #ifndef WIN32
 void spectrum_sigchld_handler(int sig)
+{
 	int status;
 	pid_t pid;
 	do {
 		pid = waitpid(-1, &status, WNOHANG);
 	} while (pid != 0 && pid != (pid_t)-1);
 	if ((pid == (pid_t) - 1) && (errno != ECHILD)) {
 		char errmsg[BUFSIZ];
 		snprintf(errmsg, BUFSIZ, "Warning: waitpid() returned %d", pid);
 		perror(errmsg);
+	}
+}
 #endif
 int create_socket(char *host, int portno) {
 	struct sockaddr_in serv_addr;
 	int main_socket = socket(AF_INET, SOCK_STREAM, 0);
 	memset((char *) &serv_addr, 0, sizeof(serv_addr));
 	serv_addr.sin_family = AF_INET;
 	serv_addr.sin_port = htons(portno);
 	hostent *hos;  // Resolve name
 	if ((hos = gethostbyname(host)) == NULL) {
 		// strerror() will not work for gethostbyname() and hstrerror()
 		// is supposedly obsolete
 		exit(1);
+	}
 	serv_addr.sin_addr.s_addr = *((unsigned long *) hos->h_addr_list[0]);
 	if (connect(main_socket, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
 		close(main_socket);
 		main_socket = 0;
+	}
 // 	int flags = fcntl(main_socket, F_GETFL);
 // 	flags |= O_NONBLOCK;
 // 	fcntl(main_socket, F_SETFL, flags);
 	return main_socket;
+}

backends/libpurple/utils.h

➞

Show inline comments

@@ new file 100644 @@
 /**
  * libtransport -- C++ library for easy XMPP Transports development
+ *
  * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include "purple.h"
 #include <string>
 #ifndef WIN32
 void spectrum_sigchld_handler(int sig);
 #endif
 int create_socket(char *host, int portno);
 GHashTable *spectrum_ui_get_info(void);
 void execute_purple_plugin_action(PurpleConnection *gc, const std::string &name);

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;
 static gboolean list_purple_settings = FALSE;
 int m_sock;
 static int writeInput;
 static GOptionEntry options_entries[] = {
 	{ "nodaemon", 'n', 0, G_OPTION_ARG_NONE, &nodaemon, "Disable background daemon mode", NULL },
 	{ "logfile", 'l', 0, G_OPTION_ARG_STRING, &logfile, "Set file to log", NULL },
 	{ "pidfile", 'p', 0, G_OPTION_ARG_STRING, &lock_file, "File where to write transport PID", NULL },
 	{ "version", 'v', 0, G_OPTION_ARG_NONE, &ver, "Shows Spectrum version", NULL },
 	{ "list-purple-settings", 's', 0, G_OPTION_ARG_NONE, &list_purple_settings, "Lists purple settings which can be used in config file", NULL },
 	{ "host", 'h', 0, G_OPTION_ARG_STRING, &host, "Host to connect to", NULL },
 	{ "port", 'p', 0, G_OPTION_ARG_INT, &port, "Port to connect to", NULL },
 	{ NULL, 0, 0, G_OPTION_ARG_NONE, NULL, "", NULL }
 };
 DBusHandlerResult skype_notify_handler(DBusConnection *connection, DBusMessage *message, gpointer user_data);
 static pbnetwork::StatusType getStatus(const std::string &st) {
 	pbnetwork::StatusType status = pbnetwork::STATUS_ONLINE;
 	if (st == "SKYPEOUT" || st == "OFFLINE") {
 		status = pbnetwork::STATUS_NONE;
+	}
 	else if (st == "DND") {
 		status = pbnetwork::STATUS_DND;
+	}
 	else if (st == "NA") {
 		status = pbnetwork::STATUS_XA;
+	}
 	else if (st == "AWAY") {
 		status = pbnetwork::STATUS_AWAY;
+	}
 	return status;
+}
 class Skype {
 	public:
 		Skype(const std::string &user, const std::string &username, const std::string &password);
 		~Skype() { logout(); }
+		~Skype() { LOG4CXX_INFO(logger, "Skype instance desctuctor"); logout(); }
 		void login();
 		void logout();
 		std::string send_command(const std::string &message);
 		const std::string &getUser() {
 			return m_user;
+		}
 		const std::string &getUsername() {
 			return m_username;
+		}
 		bool createDBusProxy();
 		bool loadSkypeBuddies();
 		int getPid() {
 			return (int) m_pid;
+		}
 	private:
 		std::string m_username;
 		std::string m_password;
 		GPid m_pid;
 		DBusGConnection *m_connection;
 		DBusGProxy *m_proxy;
 		std::string m_user;
 		int m_timer;
 		int m_counter;
 		int fd_output;
 };
 class SpectrumNetworkPlugin : public NetworkPlugin {
 	public:
 		SpectrumNetworkPlugin(Config *config, const std::string &host, int port) : NetworkPlugin() {
 			this->config = config;
 			LOG4CXX_INFO(logger, "Starting the backend.");
+		}
 		~SpectrumNetworkPlugin() {
 			for (std::map<Skype *, std::string>::iterator it = m_accounts.begin(); it != m_accounts.end(); it++) {
 				delete (*it).first;
+			}
+		}
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 			std::string name = legacyName;
 			name = name.substr(name.find(".") + 1);
 			if (name.find("skype.") == 0 || name.find("prpl-skype.") == 0) {
 				name = name.substr(name.find(".") + 1);
+			}
 			LOG4CXX_INFO(logger,  "Creating account with name '" << name << "'");
 			Skype *skype = new Skype(user, name, password);
 			m_sessions[user] = skype;
 			m_accounts[skype] = user;
 			skype->login();
+		}
 		void handleMemoryUsage(double &res, double &shared) {
 			res = 0;
 			shared = 0;
 			for(std::map<std::string, Skype *>::const_iterator it = m_sessions.begin(); it != m_sessions.end(); it++) {
 				Skype *skype = it->second;
 				if (skype) {
 					double r;
 					double s;
 					process_mem_usage(s, r, skype->getPid());
 					res += r;
 					shared += s;
+				}
+			}
+		}
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 			Skype *skype = m_sessions[user];
 			if (skype) {
 				LOG4CXX_INFO(logger, "User wants to logout, logging out");
 				skype->logout();
 				Logging::shutdownLogging();
 				exit(1);
+			}
+		}
 		void handleStatusChangeRequest(const std::string &user, int status, const std::string &statusMessage) {
 			Skype *skype = m_sessions[user];
 			if (!skype)
 				return;
 			std::string st;
 			switch(status) {
 				case Swift::StatusShow::Away: {
 					st = "AWAY";
 					break;
+				}
 				case Swift::StatusShow::DND: {
 					st = "DND";
 					break;
+				}
 				case Swift::StatusShow::XA: {
 					st = "NA";
 					break;
+				}
 				case Swift::StatusShow::None: {
 					break;
+				}
 				case pbnetwork::STATUS_INVISIBLE:
 					st = "INVISIBLE";
 					break;
 				default:
 					st = "ONLINE";
 					break;
+			}
 			skype->send_command("SET USERSTATUS " + st);
 			if (!statusMessage.empty()) {
 				skype->send_command("SET PROFILE MOOD_TEXT " + statusMessage);
+			}
+		}
 		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups) {
 			Skype *skype = m_sessions[user];
 			if (skype) {
 				skype->send_command("SET USER " + buddyName + " BUDDYSTATUS 2 Please authorize me");
 				skype->send_command("SET USER " + buddyName + " ISAUTHORIZED TRUE");
+			}
+		}
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups) {
 			Skype *skype = m_sessions[user];
 			if (skype) {
 				skype->send_command("SET USER " + buddyName + " BUDDYSTATUS 1");
+			}
+		}
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml) {
 			Skype *skype = m_sessions[user];
 			if (skype) {
 				skype->send_command("MESSAGE " + legacyName + " " + message);
+			}
+		}
 		void handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id) {
 			Skype *skype = m_sessions[user];
 			if (skype) {
 				std::string name = legacyName;
 				if (name.find("skype.") == 0) {
 					name = name.substr(6);
+				}
 				std::string photo;
 				gchar *filename = NULL;
 				gchar *new_filename = NULL;
 				gchar *image_data = NULL;
 				gsize image_data_len = 0;
 				gchar *ret;
 				int fh;
 				GError *error;
 				const gchar *userfiles[] = {"user256", "user1024", "user4096", "user16384", "user32768", "user65536",
 											"profile256", "profile1024", "profile4096", "profile16384", "profile32768",
 											NULL};
 				char *username = g_strdup_printf("\x03\x10%s", name.c_str());
 				for (fh = 0; userfiles[fh]; fh++) {
 					filename = g_strconcat("/tmp/skype/", skype->getUsername().c_str(), "/", skype->getUsername().c_str(), "/", userfiles[fh], ".dbb", NULL);
 					std::cout << "getting filename:" << filename << "\n";
 					if (g_file_get_contents(filename, &image_data, &image_data_len, NULL))
+					{
 						std::cout << "got\n";
 						char *start = (char *)memmem(image_data, image_data_len, username, strlen(username)+1);
 						if (start != NULL)
+						{
 							char *next = image_data;
 							char *last = next;
 							//find last index of l33l
 							while ((next = (char *)memmem(next+4, start-next-4, "l33l", 4)))
+							{
 								last = next;
+							}
 							start = last;
 							if (start != NULL)
+							{
 								char *img_start;
 								//find end of l33l block
 								char *end = (char *)memmem(start+4, image_data+image_data_len-start-4, "l33l", 4);
 								if (!end) end = image_data+image_data_len;
 								//look for start of JPEG block
 								img_start = (char *)memmem(start, end-start, "\xFF\xD8", 2);
 								if (img_start)
+								{
 									//look for end of JPEG block
 									char *img_end = (char *)memmem(img_start, end-img_start, "\xFF\xD9", 2);
 									if (img_end)
+									{
 										image_data_len = img_end - img_start + 2;
 										photo = std::string(img_start, image_data_len);
+									}
+								}
+							}
+						}
 						g_free(image_data);
+					}
 					g_free(filename);
+				}
 				g_free(username);
 				std::string alias = "";
 				std::cout << skype->getUsername() << " " << name << "\n";
 				if (skype->getUsername() == name) {
 					alias = skype->send_command("GET PROFILE FULLNAME");
-					alias = alias.substr(17);
+					alias = GET_RESPONSE_DATA(alias, "FULLNAME")
+				}
 				handleVCard(user, id, legacyName, "", alias, photo);
+			}
+		}
 		void sendData(const std::string &string) {
 			write(m_sock, string.c_str(), string.size());
 // 			if (writeInput == 0)
 // 				writeInput = purple_input_add(m_sock, PURPLE_INPUT_WRITE, &transportDataReceived, NULL);
+		}
 		void handleVCardUpdatedRequest(const std::string &user, const std::string &p, const std::string &nickname) {
+		}
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups) {
+		}
 		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups) {
+		}
 		void handleBuddyBlockToggled(const std::string &user, const std::string &buddyName, bool blocked) {
+		}
 		void handleTypingRequest(const std::string &user, const std::string &buddyName) {
+		}
 		void handleTypedRequest(const std::string &user, const std::string &buddyName) {
+		}
 		void handleStoppedTypingRequest(const std::string &user, const std::string &buddyName) {
+		}
 		void handleAttentionRequest(const std::string &user, const std::string &buddyName, const std::string &message) {
+		}
 		std::map<std::string, Skype *> m_sessions;
 		std::map<Skype *, std::string> m_accounts;
 		std::map<std::string, unsigned int> m_vcards;
 		Config *config;
 };
 Skype::Skype(const std::string &user, const std::string &username, const std::string &password) {
 	m_username = username;
 	m_user = user;
 	m_password = password;
 	m_pid = 0;
 	m_connection = 0;
 	m_proxy = 0;
 	m_timer = -1;
 	m_counter = 0;
+}
 static gboolean load_skype_buddies(gpointer data) {
 	Skype *skype = (Skype *) data;
 	return skype->loadSkypeBuddies();
+}
 bool Skype::createDBusProxy() {
 	if (m_proxy == NULL) {
 		LOG4CXX_INFO(logger, "Creating DBus proxy for com.Skype.Api.");
 		m_counter++;
 		GError *error = NULL;
 		m_proxy = dbus_g_proxy_new_for_name_owner (m_connection, "com.Skype.API", "/com/Skype", "com.Skype.API", &error);
 		if (m_proxy == NULL && error != NULL) {
 			LOG4CXX_INFO(logger,  m_username << ":" << error->message);
 			if (m_counter == 15) {
 				np->handleDisconnected(m_user, 0, error->message);
 				LOG4CXX_ERROR(logger, "Logging out, proxy couldn't be created: " << error->message);
 				np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE, error->message);
 				logout();
 				g_error_free(error);
 				return FALSE;
+			}
 			g_error_free(error);
+		}
 		if (m_proxy) {
 			LOG4CXX_INFO(logger, "Proxy created.");
 			DBusObjectPathVTable vtable;
 			vtable.message_function = &skype_notify_handler;
 			dbus_connection_register_object_path(dbus_g_connection_get_connection(m_connection), "/com/Skype/Client", &vtable, this);
 			m_counter = 0;
 			m_timer = g_timeout_add_seconds(1, load_skype_buddies, this);
 			return FALSE;
+		}
 		return TRUE;
+	}
 	return FALSE;
+}
 static gboolean create_dbus_proxy(gpointer data) {
 	Skype *skype = (Skype *) data;
 	return skype->createDBusProxy();
+}
 void Skype::login() {
 	if (m_username.find("..") == 0 || m_username.find("/") != std::string::npos) {
 		np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE, "Invalid username");
 		return;
+	}
 	boost::filesystem::remove_all(std::string("/tmp/skype/") + m_username);
 	boost::filesystem::path	path(std::string("/tmp/skype/") + m_username);
 	if (!boost::filesystem::exists(path)) {
 		boost::filesystem::create_directories(path);
 		boost::filesystem::path	path2(std::string("/tmp/skype/") + m_username + "/" + m_username );
 		boost::filesystem::create_directories(path2);
+	}
 	std::string shared_xml = "<?xml version=\"1.0\"?>\n"
 							"<config version=\"1.0\" serial=\"28\" timestamp=\"" + boost::lexical_cast<std::string>(time(NULL)) + ".0\">\n"
 							"<UI>\n"
 								"<Installed>2</Installed>\n"
 								"<Language>en</Language>\n"
 							"</UI>\n"
 							"</config>\n";
 	g_file_set_contents(std::string(std::string("/tmp/skype/") + m_username + "/shared.xml").c_str(), shared_xml.c_str(), -1, NULL);
 	std::string config_xml = "<?xml version=\"1.0\"?>\n"
 							"<config version=\"1.0\" serial=\"7\" timestamp=\"" + boost::lexical_cast<std::string>(time(NULL)) + ".0\">\n"
 								"<Lib>\n"
 									"<Account>\n"
 									"<IdleTimeForAway>30000000</IdleTimeForAway>\n"
 									"<IdleTimeForNA>300000000</IdleTimeForNA>\n"
 									"<LastUsed>" + boost::lexical_cast<std::string>(time(NULL)) + "</LastUsed>\n"
 									"</Account>\n"
 								"</Lib>\n"
 								"<UI>\n"
 									"<API>\n"
 									"<Authorizations>Spectrum</Authorizations>\n"
 									"<BlockedPrograms></BlockedPrograms>\n"
 									"</API>\n"
 								"</UI>\n"
 							"</config>\n";
 	g_file_set_contents(std::string(std::string("/tmp/skype/") + m_username + "/" + m_username +"/config.xml").c_str(), config_xml.c_str(), -1, NULL);
 	sleep(1);
 	std::string db_path = std::string("/tmp/skype/") + m_username;
 	char *db = (char *) malloc(db_path.size() + 1);
 	strcpy(db, db_path.c_str());
 	LOG4CXX_INFO(logger,  m_username << ": Spawning new Skype instance dbpath=" << db);
 	gchar* argv[6] = {"skype", "--disable-cleanlooks", "--pipelogin", "--dbpath", db, 0};
 	int fd;
 	g_spawn_async_with_pipes(NULL,
 	GError *error = NULL;
 	bool spawned = g_spawn_async_with_pipes(NULL,
 		argv,
 		NULL /*envp*/,
 		G_SPAWN_SEARCH_PATH,
 		NULL /*child_setup*/,
 		NULL /*user_data*/,
 		&m_pid /*child_pid*/,
 		&fd,
 		NULL,
 		&fd_output,
 		NULL /*error*/);
 		&error);
 	if (!spawned) {
 		LOG4CXX_ERROR(logger, "Error spawning the Skype instance: " << error->message)
 		np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE, "Error spawning the Skype instance.");
 		return;
+	}
 	std::string login_data = std::string(m_username + " " + m_password + "\n");
-	LOG4CXX_INFO(logger,  m_username << ": Login data=" << login_data);
+	LOG4CXX_INFO(logger,  m_username << ": Login data=" << m_username);
 	write(fd, login_data.c_str(), login_data.size());
 	close(fd);
 	fcntl (fd_output, F_SETFL, O_NONBLOCK);
 	free(db);
 	//Initialise threading
 	dbus_threads_init_default();
 	if (m_connection == NULL)
+	{
-		LOG4CXX_INFO(logger, "Creating DBus connection.");
+		LOG4CXX_INFO(logger, "Creating DBUS connection.");
 		GError *error = NULL;
 		m_connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
 		if (m_connection == NULL && error != NULL)
+		{
-			LOG4CXX_INFO(logger,  m_username << ": DBUS Error: " << error->message);
+			LOG4CXX_INFO(logger,  m_username << ": Creating DBUS Connection error: " << error->message);
 			g_error_free(error);
 			return;
+		}
+	}
 	sleep(1);
 	m_timer = g_timeout_add_seconds(1, create_dbus_proxy, this);
+}
 bool Skype::loadSkypeBuddies() {
 //	std::string re = "CONNSTATUS OFFLINE";
 //	while (re == "CONNSTATUS OFFLINE" || re.empty()) {
 //		sleep(1);
 	gchar buffer[1024];
 	int bytes_read = read(fd_output, buffer, 1023);
 	if (bytes_read > 0) {
 		buffer[bytes_read] = 0;
 		np->handleDisconnected(m_user, 0, buffer);
 		close(fd_output);
 		logout();
 		return FALSE;
 		std::string b(buffer);
 		LOG4CXX_WARN(logger, "Skype wrote this on stdout '" << b << "'");
 		if (b.find("Incorrect Password") != std::string::npos) {
 			LOG4CXX_INFO(logger, "Incorrect password, logging out")
 			np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_FAILED, "Incorrect password");
 			close(fd_output);
 			logout();
 			return FALSE;
+		}
+	}
 	std::string re = send_command("NAME Spectrum");
 	if (m_counter++ > 15) {
 		np->handleDisconnected(m_user, 0, "");
 		LOG4CXX_ERROR(logger, "Logging out, because we tried to connect the Skype over DBUS 15 times without success");
 		np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE, "Skype is not ready. This issue have been logged and admins will check it and try to fix it soon.");
 		close(fd_output);
 		logout();
 		return FALSE;
+	}
 	if (re.empty() || re == "CONNSTATUS OFFLINE") {
+	if (re.empty() || re == "CONNSTATUS OFFLINE" || re == "ERROR 68") {
 		return TRUE;
+	}
 	close(fd_output);
 	if (send_command("PROTOCOL 7") != "PROTOCOL 7") {
 		np->handleDisconnected(m_user, 0, "Skype is not ready");
 		LOG4CXX_ERROR(logger, "PROTOCOL 7 failed, logging out");
 		np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE, "Skype is not ready. This issue have been logged and admins will check it and try to fix it soon.");
 		logout();
 		return FALSE;
+	}
 	np->handleConnected(m_user);
 	std::map<std::string, std::string> group_map;
 	std::string groups = send_command("SEARCH GROUPS CUSTOM");
 	groups = groups.substr(groups.find(' ') + 1);
 	std::vector<std::string> grps;
 	boost::split(grps, groups, boost::is_any_of(","));
 	BOOST_FOREACH(std::string grp, grps) {
 		std::vector<std::string> data;
 		std::string name = send_command("GET GROUP " + grp + " DISPLAYNAME");
 		boost::split(data, name, boost::is_any_of(" "));
 		name = name.substr(name.find("DISPLAYNAME") + 12);
 		std::string users = send_command("GET GROUP " + data[1] + " USERS");
 		users = name.substr(name.find("USERS") + 6);
 		boost::split(data, users, boost::is_any_of(","));
 		BOOST_FOREACH(std::string u, data) {
 			group_map[u] = grp;
 	if (groups.find(' ') != std::string::npos) {
 		groups = groups.substr(groups.find(' ') + 1);
 		std::vector<std::string> grps;
 		boost::split(grps, groups, boost::is_any_of(","));
 		BOOST_FOREACH(std::string grp, grps) {
 			std::vector<std::string> data;
 			std::string name = send_command("GET GROUP " + grp + " DISPLAYNAME");
 			if (name.find("ERROR") == 0) {
 				continue;
+			}
 			boost::split(data, name, boost::is_any_of(" "));
 			name = GET_RESPONSE_DATA(name, "DISPLAYNAME");
 			std::string users = send_command("GET GROUP " + data[1] + " USERS");
 			try {
 				users = GET_RESPONSE_DATA(users, "USERS");
+			}
 			catch (std::out_of_range& oor) {
 				continue;
+			}
 			boost::split(data, users, boost::is_any_of(","));
 			BOOST_FOREACH(std::string u, data) {
 				group_map[u] = grp;
+			}
+		}
+	}
 	std::string friends = send_command("GET AUTH_CONTACTS_PROFILES");
 	char **full_friends_list = g_strsplit((strchr(friends.c_str(), ' ')+1), ";", 0);
 	if (full_friends_list && full_friends_list[0])
+	{
 		//in the format of: username;full name;phone;office phone;mobile phone;
 		//                  online status;friendly name;voicemail;mood
 		// (comma-seperated lines, usernames can have comma's)
 		for (int i=0; full_friends_list[i] && *full_friends_list[i] != '\0'; i+=8)
+		for (int i=0; full_friends_list[i] && full_friends_list[i+1] && *full_friends_list[i] != '\0'; i+=8)
+		{
 			std::string buddy = full_friends_list[i];
 			if (buddy[0] == ',') {
 				buddy.erase(buddy.begin());
+			}
 			if (buddy.rfind(",") != std::string::npos) {
 				buddy = buddy.substr(buddy.rfind(","));
+			}
 			if (buddy[0] == ',') {
 				buddy.erase(buddy.begin());
+			}
 			LOG4CXX_INFO(logger, "Got buddy " << buddy);
 			std::string st = full_friends_list[i + 5];
 			pbnetwork::StatusType status = getStatus(st);
 			std::string alias = full_friends_list[i + 6];
 			std::string mood_text = "";
 			if (full_friends_list[i + 8] && *full_friends_list[i + 8] != '\0' && *full_friends_list[i + 8] != ',') {
 				mood_text = full_friends_list[i + 8];
+			}
 			std::vector<std::string> groups;
 			if (group_map.find(buddy) != group_map.end()) {
 				groups.push_back(group_map[buddy]);
+			}
 			np->handleBuddyChanged(m_user, buddy, alias, groups, status, mood_text);
+		}
+	}
 	g_strfreev(full_friends_list);
 	send_command("SET AUTOAWAY OFF");
 	send_command("SET USERSTATUS ONLINE");
 	return FALSE;
+}
 void Skype::logout() {
 	if (m_pid != 0) {
 		send_command("SET USERSTATUS INVISIBLE");
 		send_command("SET USERSTATUS OFFLINE");
 		sleep(2);
 		g_object_unref(m_proxy);
-		LOG4CXX_INFO(logger,  m_username << ": Killing Skype instance");
+		LOG4CXX_INFO(logger,  m_username << ": Terminating Skype instance (SIGTERM)");
 		kill((int) m_pid, SIGTERM);
 		// Give skype a chance
 		sleep(2);
 		LOG4CXX_INFO(logger,  m_username << ": Killing Skype instance (SIGKILL)");
 		kill((int) m_pid, SIGKILL);
 		m_pid = 0;
+	}
+}
 std::string Skype::send_command(const std::string &message) {
 	GError *error = NULL;
 	gchar *str = NULL;
 // 			int message_num;
 // 			gchar error_return[30];
 	LOG4CXX_INFO(logger, "Sending: '" << message << "'");
 	if (!dbus_g_proxy_call (m_proxy, "Invoke", &error, G_TYPE_STRING, message.c_str(), G_TYPE_INVALID,
 						G_TYPE_STRING, &str, G_TYPE_INVALID))
+	{
 			if (error && error->message)
+			{
 			LOG4CXX_INFO(logger,  m_username << ": DBUS Error: " << error->message);
 			g_error_free(error);
 			return "";
 		} else {
 			LOG4CXX_INFO(logger,  m_username << ": DBUS no response");
 			return "";
+		}
+	}
 	if (str != NULL)
+	{
 		LOG4CXX_INFO(logger,  m_username << ": DBUS:" << str);
+		LOG4CXX_INFO(logger,  m_username << ": DBUS:'" << str << "'");
+	}
 	return str ? std::string(str) : std::string();
+}
 static void handle_skype_message(std::string &message, Skype *sk) {
 	std::vector<std::string> cmd;
 	boost::split(cmd, message, boost::is_any_of(" "));
 	if (cmd[0] == "USER") {
 		if (cmd[1] == sk->getUsername()) {
 			return;
+		}
 		if (cmd[2] == "ONLINESTATUS") {
 			if (cmd[3] == "SKYPEOUT" || cmd[3] == "UNKNOWN") {
 				return;
+			}
 			else {
 				pbnetwork::StatusType status = getStatus(cmd[3]);
 				std::string mood_text = sk->send_command("GET USER " + cmd[1] + " MOOD_TEXT");
 				mood_text = mood_text.substr(mood_text.find("MOOD_TEXT") + 10);
 				std::string alias = sk->send_command("GET USER " + cmd[1] + " FULLNAME");
 				alias = alias.substr(alias.find("FULLNAME") + 9);
 				GET_PROPERTY(mood_text, "USER", cmd[1], "MOOD_TEXT");
 				GET_PROPERTY(alias, "USER", cmd[1], "FULLNAME");
 				std::vector<std::string> groups;
 				np->handleBuddyChanged(sk->getUser(), cmd[1], alias, groups, status, mood_text);
+			}
+		}
 		else if (cmd[2] == "MOOD_TEXT") {
 			std::string st = sk->send_command("GET USER " + cmd[1] + " ONLINESTATUS");
 			st = st.substr(st.find("ONLINESTATUS") + 13);
 			GET_PROPERTY(st, "USER", cmd[1], "ONLINESTATUS");
 			pbnetwork::StatusType status = getStatus(st);
-			std::string mood_text = message.substr(message.find("MOOD_TEXT") + 10);
+			std::string mood_text = GET_RESPONSE_DATA(message, "MOOD_TEXT");
 			std::vector<std::string> groups;
 			np->handleBuddyChanged(sk->getUser(), cmd[1], "", groups, status, mood_text);
+		}
 		else if (cmd[2] == "BUDDYSTATUS" && cmd[3] == "3") {
 			std::string st = sk->send_command("GET USER " + cmd[1] + " ONLINESTATUS");
 			st = st.substr(st.find("ONLINESTATUS") + 13);
 			GET_PROPERTY(mood_text, "USER", cmd[1], "MOOD_TEXT");
 			GET_PROPERTY(st, "USER", cmd[1], "ONLINESTATUS");
 			pbnetwork::StatusType status = getStatus(st);
 			std::string mood_text = message.substr(message.find("MOOD_TEXT") + 10);
 			std::vector<std::string> groups;
 			np->handleBuddyChanged(sk->getUser(), cmd[1], "", groups, status, mood_text);
+		}
 		else if (cmd[2] == "FULLNAME") {
 			GET_PROPERTY(alias, "USER", cmd[1], "FULLNAME");
 			GET_PROPERTY(mood_text, "USER", cmd[1], "MOOD_TEXT");
 			GET_PROPERTY(st, "USER", cmd[1], "ONLINESTATUS");
 			pbnetwork::StatusType status = getStatus(st);
 			std::vector<std::string> groups;
 			np->handleBuddyChanged(sk->getUser(), cmd[1], alias, groups, status, mood_text);
+		}
+	}
 	else if (cmd[0] == "CHATMESSAGE") {
 		if (cmd[3] == "RECEIVED") {
 			std::string body = sk->send_command("GET CHATMESSAGE " + cmd[1] + " BODY");
 			body = body.substr(body.find("BODY") + 5);
 			std::string chatname = sk->send_command("GET CHATMESSAGE " + cmd[1] + " CHATNAME");
 			size_t start = chatname.find("$") + 1;
 			size_t len = chatname.find(";") - start;
 			std::string from = chatname.substr(start, len);
 			std::string from_handle = sk->send_command("GET CHATMESSAGE " + cmd[1] + " FROM_HANDLE");
 			from_handle = from_handle.substr(from_handle.find("FROM_HANDLE") + 12);
 			GET_PROPERTY(body, "CHATMESSAGE", cmd[1], "BODY");
 			GET_PROPERTY(from_handle, "CHATMESSAGE", cmd[1], "FROM_HANDLE");
 // 			if (from_handle != sk->getUsername()) {
 				from = from_handle;
 // 			}
 			if (from_handle == sk->getUsername())
 				return;
 			np->handleMessage(sk->getUser(), from, body);
 			np->handleMessage(sk->getUser(), from_handle, body);
 			sk->send_command("SET CHATMESSAGE " + cmd[1] + " SEEN");
+		}
+	}
 	else if (cmd[0] == "CALL") {
 		// CALL 884 STATUS RINGING
 		if (cmd[2] == "STATUS") {
 			if (cmd[3] == "RINGING" || cmd[3] == "MISSED") {
 				// handle only incoming calls
 				GET_PROPERTY(type, "CALL", cmd[1], "TYPE");
 				if (type.find("INCOMING") != 0) {
 					return;
+				}
 				GET_PROPERTY(from, "CALL", cmd[1], "PARTNER_HANDLE");
 				GET_PROPERTY(dispname, "CALL", cmd[1], "PARTNER_DISPNAME");
 				if (cmd[3] == "RINGING") {
 					np->handleMessage(sk->getUser(), from, "User " + dispname + " is calling you.");
+				}
 				else {
 					np->handleMessage(sk->getUser(), from, "You have missed call from user " + dispname + ".");
+				}
+			}
+		}
+	}
+}
 DBusHandlerResult skype_notify_handler(DBusConnection *connection, DBusMessage *message, gpointer user_data) {
 	DBusMessageIter iterator;
 	gchar *message_temp;
 	DBusMessage *temp_message;
 	temp_message = dbus_message_ref(message);
 	dbus_message_iter_init(temp_message, &iterator);
 	if (dbus_message_iter_get_arg_type(&iterator) != DBUS_TYPE_STRING)
+	{
 		dbus_message_unref(message);
 		return (DBusHandlerResult) FALSE;
+	}
 	do {
 		dbus_message_iter_get_basic(&iterator, &message_temp);
 		std::string m(message_temp);
 		LOG4CXX_INFO(logger,"DBUS message: " << m);
 		handle_skype_message(m, (Skype *) user_data);
 	} while(dbus_message_iter_has_next(&iterator) && dbus_message_iter_next(&iterator));
 	dbus_message_unref(message);
 	return DBUS_HANDLER_RESULT_HANDLED;
+}
 static void spectrum_sigchld_handler(int sig)
+{
 	int status;
 	pid_t pid;
 	do {
 		pid = waitpid(-1, &status, WNOHANG);
 	} while (pid != 0 && pid != (pid_t)-1);
 	if ((pid == (pid_t) - 1) && (errno != ECHILD)) {
 		char errmsg[BUFSIZ];
 		snprintf(errmsg, BUFSIZ, "Warning: waitpid() returned %d", pid);
 		perror(errmsg);
+	}
+}
 static int create_socket(char *host, int portno) {
 	struct sockaddr_in serv_addr;
 	int m_sock = socket(AF_INET, SOCK_STREAM, 0);
 	memset((char *) &serv_addr, 0, sizeof(serv_addr));
 	serv_addr.sin_family = AF_INET;
 	serv_addr.sin_port = htons(portno);
 	hostent *hos;  // Resolve name
 	if ((hos = gethostbyname(host)) == NULL) {
 		// strerror() will not work for gethostbyname() and hstrerror()
 		// is supposedly obsolete
 		Logging::shutdownLogging();
 		exit(1);
+	}
 	serv_addr.sin_addr.s_addr = *((unsigned long *) hos->h_addr_list[0]);
 	if (connect(m_sock, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
 		close(m_sock);
 		m_sock = 0;
+	}
 	int flags = fcntl(m_sock, F_GETFL);
 	flags |= O_NONBLOCK;
 	fcntl(m_sock, F_SETFL, flags);
 	return m_sock;
+}
 static gboolean transportDataReceived(GIOChannel *source, GIOCondition condition, gpointer data) {
 	char buffer[65535];
 	char *ptr = buffer;
 	ssize_t n = read(m_sock, ptr, sizeof(buffer));
 	if (n <= 0) {
 		LOG4CXX_INFO(logger, "Diconnecting from spectrum2 server");
 		Logging::shutdownLogging();
 		exit(errno);
+	}
 	std::string d = std::string(buffer, n);
 	np->handleDataRead(d);
 	return TRUE;
+}
 static void io_destroy(gpointer data) {
 	Logging::shutdownLogging();
 	exit(1);
+}
 static void log_glib_error(const gchar *string) {
 	LOG4CXX_ERROR(logger, "GLIB ERROR:" << string);
+}
 int main(int argc, char **argv) {
 	GError *error = NULL;
 	GOptionContext *context;
 	context = g_option_context_new("config_file_name or profile name");
 	g_option_context_add_main_entries(context, options_entries, "");
 	if (!g_option_context_parse (context, &argc, &argv, &error)) {
 		std::cout << "option parsing failed: " << error->message << "\n";
 		return -1;
+	}
 	if (ver) {
 // 		std::cout << VERSION << "\n";
 		std::cout << "verze\n";
 		g_option_context_free(context);
 		return 0;
+	}
 	if (argc != 2) {
 #ifdef WIN32
 		std::cout << "Usage: spectrum.exe <configuration_file.cfg>\n";
 #else
 #if GLIB_CHECK_VERSION(2,14,0)
 	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;
+		}
 //
 // 		if (signal(SIGINT, spectrum_sigint_handler) == SIG_ERR) {
 // 			std::cout << "SIGINT handler can't be set\n";
 // 			g_option_context_free(context);
 // 			return -1;
 // 		}
 //
 // 		if (signal(SIGTERM, spectrum_sigterm_handler) == SIG_ERR) {
 // 			std::cout << "SIGTERM handler can't be set\n";
 // 			g_option_context_free(context);
 // 			return -1;
 // 		}
 //
 // 		struct sigaction sa;
 // 		memset(&sa, 0, sizeof(sa));
 // 		sa.sa_handler = spectrum_sighup_handler;
 // 		if (sigaction(SIGHUP, &sa, NULL)) {
 // 			std::cout << "SIGHUP handler can't be set\n";
 // 			g_option_context_free(context);
 // 			return -1;
 //		}
 #endif
 		Config config;
 		if (!config.load(argv[1])) {
 			std::cout << "Can't open " << argv[1] << " configuration file.\n";
 			return 1;
+		}
 		if (CONFIG_STRING(&config, "logging.backend_config").empty()) {
 			LoggerPtr root = log4cxx::Logger::getRootLogger();
 			root->addAppender(new ConsoleAppender(new PatternLayout("%d %-5p %c: %m%n")));
+		}
 		else {
 			log4cxx::helpers::Properties p;
 			log4cxx::helpers::FileInputStream *istream = new log4cxx::helpers::FileInputStream(CONFIG_STRING(&config, "logging.backend_config"));
 			p.load(istream);
 			p.setProperty("pid", boost::lexical_cast<std::string>(getpid()));
 			log4cxx::PropertyConfigurator::configure(p);
+		}
 		Logging::initBackendLogging(&config);
 // 		initPurple(config);
 		g_type_init();
 		m_sock = create_socket(host, port);
 		g_set_printerr_handler(log_glib_error);
 	GIOChannel *channel;
 	GIOCondition cond = (GIOCondition) G_IO_IN;
 	channel = g_io_channel_unix_new(m_sock);
 	g_io_add_watch_full(channel, G_PRIORITY_DEFAULT, cond, transportDataReceived, NULL, io_destroy);
 		np = new SpectrumNetworkPlugin(&config, host, port);
 		GMainLoop *m_loop;
 		m_loop = g_main_loop_new(NULL, FALSE);
 		if (m_loop) {
 			g_main_loop_run(m_loop);
+		}
+	}
 	g_option_context_free(context);
+}

backends/smstools3/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/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));
 			LOG4CXX_INFO(logger, "Starting the plugin.");
 			m_timer = m_factories->getTimerFactory()->createTimer(5000);
 			m_timer->onTick.connect(boost::bind(&SMSNetworkPlugin::handleSMSDir, this));
 			m_timer->start();
 			// We're reusing our database model here. Buddies of user with JID INTERNAL_USER are there
 			// to match received GSM messages from number N with the XMPP users who sent message to number N.
 			// BuddyName = GSM number
 			// Alias = XMPP user JID to which the messages from this number is sent to.
 			// TODO: This should be per Modem!!!
 			UserInfo info;
 			info.jid = INTERNAL_USER;
 			info.password = "";
 			storageBackend->setUser(info);
 			storageBackend->getUser(INTERNAL_USER, info);
 			m_internalUser = info.id;
+		}
 		void handleSMS(const std::string &sms) {
 			LOG4CXX_INFO(logger, "Handling SMS " << sms << ".")
 			std::ifstream t(sms.c_str());
 			std::string str;
@@ @@ -267,131 +259,70 @@ int main (int argc, char* argv[]) { @@
 		std::cout << "SIGCHLD handler can't be set\n";
 		return -1;
+	}
 	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 (...)
+	{
 		std::cout << desc << "\n";
 		exit(1);
+	}
 	if (argc < 5) {
 		return 1;
+	}
 // 	QStringList channels;
 // 	for (int i = 3; i < argc; ++i)
 // 	{
 // 		channels.append(argv[i]);
 // 	}
 //
 // 	MyIrcSession session;
 // 	session.setNick(argv[2]);
 // 	session.setAutoJoinChannels(channels);
 // 	session.connectToServer(argv[1], 6667);
 	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);
 #ifdef WITH_SQLITE
 	if (CONFIG_STRING(&config, "database.type") == "sqlite3") {
 		storageBackend = new SQLite3Backend(&config);
 		if (!storageBackend->connect()) {
 			std::cerr << "Can't connect to database. Check the log to find out the reason.\n";
 			return -1;
+		}
+	}
 #else
 	if (CONFIG_STRING(&config, "database.type") == "sqlite3") {
 		std::cerr << "Spectrum2 is not compiled with mysql backend.\n";
 		return -2;
+	}
 #endif
 #ifdef WITH_MYSQL
 	if (CONFIG_STRING(&config, "database.type") == "mysql") {
 		storageBackend = new MySQLBackend(&config);
 		if (!storageBackend->connect()) {
 			std::cerr << "Can't connect to database. Check the log to find out the reason.\n";
 			return -1;
 	std::string error;
 	StorageBackend *storageBackend = StorageBackend::createBackend(&config, error);
 	if (storageBackend == NULL) {
 		if (!error.empty()) {
 			std::cerr << error << "\n";
 			return -2;
+		}
+	}
 #else
 	if (CONFIG_STRING(&config, "database.type") == "mysql") {
 		std::cerr << "Spectrum2 is not compiled with mysql backend.\n";
 		return -2;
+	}
 #endif
 #ifdef WITH_PQXX
 	if (CONFIG_STRING(&config, "database.type") == "pqxx") {
 		storageBackend = new PQXXBackend(&config);
 		if (!storageBackend->connect()) {
 			std::cerr << "Can't connect to database. Check the log to find out the reason.\n";
 			return -1;
+		}
+	}
 #else
 	if (CONFIG_STRING(&config, "database.type") == "pqxx") {
 		std::cerr << "Spectrum2 is not compiled with pqxx backend.\n";
 		return -2;
+	}
 #endif
 	if (CONFIG_STRING(&config, "database.type") != "mysql" && CONFIG_STRING(&config, "database.type") != "sqlite3"
 		&& CONFIG_STRING(&config, "database.type") != "pqxx" && CONFIG_STRING(&config, "database.type") != "none") {
 		std::cerr << "Unknown storage backend " << CONFIG_STRING(&config, "database.type") << "\n";
 		return -2;
 	else if (!storageBackend->connect()) {
 		std::cerr << "Can't connect to database. Check the log to find out the reason.\n";
 		return -1;
+	}
 	Swift::SimpleEventLoop eventLoop;
 	loop_ = &eventLoop;
 	np = new SMSNetworkPlugin(&config, &eventLoop, host, port);
 	loop_->run();
 	return 0;
+}

backends/template/CMakeLists.txt

➞

Show inline comments

@@ new file 100644 @@
 cmake_minimum_required(VERSION 2.6)
 FILE(GLOB SRC *.c *.cpp)
 ADD_EXECUTABLE(spectrum2_template_backend ${SRC})
 target_link_libraries(spectrum2_template_backend transport pthread ${Boost_LIBRARIES} ${SWIFTEN_LIBRARY} ${LOG4CXX_LIBRARIES})
 #INSTALL(TARGETS spectrum2_template_backend RUNTIME DESTINATION bin)

backends/template/README

➞

Show inline comments

		new file 100644
		This is just template for creating new generic spectrum2 backends. It does not do anything!
		\ No newline at end of file

backends/template/main.cpp

➞

Show inline comments

@@ new file 100644 @@
 // 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"
 // Boost
 #include <boost/algorithm/string.hpp>
 using namespace boost::filesystem;
 using namespace boost::program_options;
 using namespace Transport;
 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.");
+		}
 		// NetworkPlugin uses this method to send the data to networkplugin server
 		void sendData(const std::string &string) {
 			m_conn->write(Swift::createSafeByteArray(string));
+		}
 		// This method has to call handleDataRead with all received data from network plugin server
 		void _handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data) {
 			std::string d(data->begin(), data->end());
 			handleDataRead(d);
+		}
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 			handleConnected(user);
 			LOG4CXX_INFO(logger, user << ": Added buddy - Echo.");
 			handleBuddyChanged(user, "echo", "Echo", std::vector<std::string>(), pbnetwork::STATUS_ONLINE);
+		}
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
+		}
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml = "") {
 			LOG4CXX_INFO(logger, "Sending message from " << user << " to " << legacyName << ".");
 			if (legacyName == "echo") {
 				handleMessage(user, legacyName, message);
+			}
+		}
 		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups) {
 			LOG4CXX_INFO(logger, user << ": Added buddy " << buddyName << ".");
 			handleBuddyChanged(user, buddyName, alias, groups, pbnetwork::STATUS_ONLINE);
+		}
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups) {
+		}
 	private:
 		Config *config;
 };
 static void spectrum_sigchld_handler(int sig)
+{
 	int status;
 	pid_t pid;
 	do {
 		pid = waitpid(-1, &status, WNOHANG);
 	} while (pid != 0 && pid != (pid_t)-1);
 	if ((pid == (pid_t) - 1) && (errno != ECHILD)) {
 		char errmsg[BUFSIZ];
 		snprintf(errmsg, BUFSIZ, "Warning: waitpid() returned %d", pid);
 		perror(errmsg);
+	}
+}
 int main (int argc, char* argv[]) {
 	std::string host;
 	int port;
 	if (signal(SIGCHLD, spectrum_sigchld_handler) == SIG_ERR) {
 		std::cout << "SIGCHLD handler can't be set\n";
 		return -1;
+	}
 	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 (...)
+	{
 		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;
+	}
 	Logging::initBackendLogging(&config);
 	Swift::SimpleEventLoop eventLoop;
 	loop_ = &eventLoop;
 	np = new TemplatePlugin(&config, &eventLoop, host, port);
 	loop_->run();
 	return 0;
+}

backends/template/template_backend.py

➞

Show inline comments

@@ new file 100755 @@
 #!/usr/bin/python
 import asyncore, argparse, protocol_pb2, socket, logging
 from NetworkPlugin import NetworkPlugin
 np = None
 logger = logging.getLogger('Template Backend')
 logger.setLevel(logging.DEBUG)
 ch = logging.StreamHandler()
 ch.setLevel(logging.DEBUG)
 formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 ch.setFormatter(formatter)
 logger.addHandler(ch)
 def handleTransportData(data):
 	"""
 	This function is called when data is received from the NetworkPlugin server
 	"""
 	np.handleDataRead(data)
 class SpectrumPlugin(NetworkPlugin):
 	global logger
 	def __init__(self, iochannel):
 		NetworkPlugin.__init__(self)
 		self.iochannel = iochannel
 		logger.info("Starting plugin.")
 	def sendData(self, string):
 		"""
 		NetworkPlugin uses this method to send the data to networkplugin server
 		"""
 		self.iochannel.sendData(string)
 		logger.info("Starting plugin.")
 	def handleLoginRequest(self, user, legacyName, password):
 		self.handleConnected(user)
 		logger.info("Added Echo Buddy")
 		self.handleBuddyChanged(user, "echo", "Echo", [], protocol_pb2.STATUS_ONLINE)
 	def handleLogoutRequest(self, user, legacyName):
 		pass
 	def handleMessageSendRequest(self, user, legacyName, message, xhtml = ""):
 		logger.info("Message sent from "  + user + ' to ' + legacyName)
 		if(legacyName == "echo"):
 			logger.info("Message Echoed: " + message)
 			self.handleMessage(user, legacyName, message)
 	def handleBuddyUpdatedRequest(self, user, buddyName, alias, groups):
 		logger.info("Added Buddy " + buddyName)
 		self.handleBuddyChanged(user, buddyName, alias, groups, protocol_pb2.STATUS_ONLINE)
 	def handleBuddyRemovedRequest(self, user, buddyName, groups):
 		pass
 class IOChannel(asyncore.dispatcher):
 	def __init__(self, host, port, readCallBack):
 		asyncore.dispatcher.__init__(self)
 		self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
 		self.connect((host, port))
 		self.handleReceivedData = readCallBack
 		self.send_buffer = ""
 	def sendData(self, data):
 		self.send_buffer += data
 	def handle_connect(self):
 		pass
 	def handle_close(self):
 		self.close()
 	def handle_read(self):
 		data = self.recv(65536)
 		self.handleReceivedData(data)
 	def handle_write(self):
 		sent = self.send(self.send_buffer)
 		self.send_buffer = self.send_buffer[sent:]
 	def writable(self):
 		return (len(self.send_buffer) > 0)
 	def readable(self):
 		return True
 if __name__ == "__main__":
 	parser = argparse.ArgumentParser()
 	parser.add_argument('--host', type=str, required=True)
 	parser.add_argument('--port', type=int, required=True)
 	parser.add_argument('config_file', type=str)
 	args = parser.parse_args()
 	io = IOChannel(args.host, args.port, handleTransportData)
 	np = SpectrumPlugin(io)
 	asyncore.loop()

cmake_modules/CommuniConfig.cmake

➞

Show inline comments

 FIND_LIBRARY(IRC_LIBRARY NAMES Communi)
 FIND_PATH(IRC_INCLUDE_DIR NAMES "ircglobal.h" PATH_SUFFIXES Communi qt4/Communi )
 find_package(Qt4 REQUIRED)
 include( ${QT_USE_FILE} )
 FIND_LIBRARY(IRC_LIBRARY NAMES Communi PATHS ${QT_LIBRARY_DIR})
 FIND_PATH(IRC_INCLUDE_DIR NAMES "ircglobal.h" PATHS ${QT_INCLUDE_DIR} PATH_SUFFIXES Communi)
 # message( STATUS ${IRC_LIBRARY})
 if( IRC_LIBRARY AND IRC_INCLUDE_DIR )
     message( STATUS "Found libCommuni ${IRC_LIBRARY}, ${IRC_INCLUDE_DIR}")
     set( IRC_FOUND 1 )
 else()
     message( STATUS "Could NOT find libCommuni" )
 endif()

docs/Doxyfile

➞

Show inline comments

deleted file

include/Swiften/Elements/GatewayPayload.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #include <Swiften/Elements/GatewayPayload.h>
 namespace Swift {
 GatewayPayload::GatewayPayload(const JID &jid, const std::string &desc, const std::string &prompt) :
 	jid(jid), desc(desc), prompt(prompt) {
+	}
+}

include/Swiften/Elements/GatewayPayload.h

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <vector>
 #include <string>
 #include <Swiften/Elements/Payload.h>
 #include <Swiften/JID/JID.h>
 namespace Swift {
 	class GatewayPayload : public Payload {
 		public:
 			GatewayPayload(const JID &jid = JID(), const std::string &desc = "", const std::string &prompt = "");
 			void setJID(const JID &jid) {
 				this->jid = jid;
+			}
 			const JID &getJID() const {
 				return jid;
+			}
 			void setDesc(const std::string &desc) {
 				this->desc = desc;
+			}
 			const std::string &getDesc() const {
 				return desc;
+			}
 			void setPrompt(const std::string &prompt) {
 				this->prompt = prompt;
+			}
 			const std::string &getPrompt() const {
 				return prompt;
+			}
 		private:
 			JID jid;
 			std::string desc;
 			std::string prompt;
 	};
+}

include/Swiften/Elements/PubSubItem.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #include <Swiften/Elements/PubSubItem.h>
 namespace Swift {
 PubSubItem::PubSubItem() {
+}
+}

include/Swiften/Elements/PubSubItem.h

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <vector>
 #include <string>
 #include <Swiften/Elements/Payload.h>
 namespace Swift {
 	class PubSubItem : public Payload {
 		public:
 			PubSubItem();
 			void addPayload(boost::shared_ptr<Payload> payload) {
 				payloads.push_back(payload);
+			}
 			const std::vector<boost::shared_ptr<Payload> > getPayloads() const {
 				return payloads;
+			}
 			template<typename T>
 			const std::vector<boost::shared_ptr<T> > getPayloads() const {
 				std::vector<boost::shared_ptr<T> > matched_payloads;
 				for (std::vector<boost::shared_ptr<Payload> >::const_iterator i = payloads.begin(); i != payloads.end(); ++i) {
 					boost::shared_ptr<T> result = boost::dynamic_pointer_cast<T>(*i);
 					if (result) {
 						matched_payloads.push_back(result);
+					}
+				}
 				return matched_payloads;
+			}
 			template<typename T>
 			const boost::shared_ptr<T> getPayload() const {
 				boost::shared_ptr<T> result;
 				for (std::vector<boost::shared_ptr<Payload> >::const_iterator i = payloads.begin(); i != payloads.end(); ++i) {
 					result = boost::dynamic_pointer_cast<T>(*i);
 					if (result) {
 						return result;
+					}
+				}
 				return result;
+			}
 			const std::string& getId() const { return id; }
 			void setId(const std::string& id) {
 				this->id = id;
+			}
 		private:
 			std::vector<boost::shared_ptr<Payload> > payloads;
 			std::string id;
 	};
+}

include/Swiften/Elements/PubSubPayload.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #include <Swiften/Elements/PubSubPayload.h>
 namespace Swift {
 PubSubPayload::PubSubPayload() {
+}
+}

include/Swiften/Elements/PubSubPayload.h

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2012 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <vector>
 #include <string>
 #include <Swiften/Elements/Payload.h>
 namespace Swift {
 	class PubSubPayload : public Payload {
 		public:
 			PubSubPayload();
 			void addPayload(boost::shared_ptr<Payload> payload) {
 				payloads.push_back(payload);
+			}
 			const std::vector<boost::shared_ptr<Payload> > getPayloads() const {
 				return payloads;
+			}
 			template<typename T>
 			const std::vector<boost::shared_ptr<T> > getPayloads() const {
 				std::vector<boost::shared_ptr<T> > matched_payloads;
 				for (std::vector<boost::shared_ptr<Payload> >::const_iterator i = payloads.begin(); i != payloads.end(); ++i) {
 					boost::shared_ptr<T> result = boost::dynamic_pointer_cast<T>(*i);
 					if (result) {
 						matched_payloads.push_back(result);
+					}
+				}
 				return matched_payloads;
+			}
 			template<typename T>
 			const boost::shared_ptr<T> getPayload() const {
 				boost::shared_ptr<T> result;
 				for (std::vector<boost::shared_ptr<Payload> >::const_iterator i = payloads.begin(); i != payloads.end(); ++i) {
 					result = boost::dynamic_pointer_cast<T>(*i);
 					if (result) {
 						return result;
+					}
+				}
 				return result;
+			}
 		private:
 			std::vector<boost::shared_ptr<Payload> > payloads;
 	};
+}

include/Swiften/Elements/PubSubPublishPayload.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #include <Swiften/Elements/PubSubPublishPayload.h>
 namespace Swift {
 PubSubPublishPayload::PubSubPublishPayload(const std::string &node) :
 	node(node) {
+	}
+}

include/Swiften/Elements/PubSubPublishPayload.h

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <vector>
 #include <string>
 #include <Swiften/Elements/Payload.h>
 #include <Swiften/Elements/PubSubItem.h>
 #include <Swiften/JID/JID.h>
 namespace Swift {
 	class PubSubPublishPayload : public Payload {
 		public:
 			enum Type { None, Pending, Subscribed, Unconfigured };
 			PubSubPublishPayload(const std::string &node = "");
 			void setNode(const std::string &node) {
 				this->node = node;
+			}
 			const std::string &getNode() const {
 				return node;
+			}
 			void addItem(const boost::shared_ptr<Payload> &item) {
 				items.push_back(item);
+			}
 			const std::vector<boost::shared_ptr<Payload> > &getItems() const {
 				return items;
+			}
 		private:
 			std::string node;
 			std::vector<boost::shared_ptr<Payload> > items;
 	};
+}

include/Swiften/Elements/PubSubSubscribePayload.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #include <Swiften/Elements/PubSubSubscribePayload.h>
 namespace Swift {
 PubSubSubscribePayload::PubSubSubscribePayload(const JID &jid, const std::string &node) :
 	jid(jid), node(node) {
+	}
+}

include/Swiften/Elements/PubSubSubscribePayload.h

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <vector>
 #include <string>
 #include <Swiften/Elements/Payload.h>
 #include <Swiften/JID/JID.h>
 namespace Swift {
 	class PubSubSubscribePayload : public Payload {
 		public:
 			PubSubSubscribePayload(const JID &jid = JID(), const std::string &node = "");
 			void setJID(const JID &jid) {
 				this->jid = jid;
+			}
 			const JID &getJID() const {
 				return jid;
+			}
 			void setNode(const std::string &node) {
 				this->node = node;
+			}
 			const std::string &getNode() const {
 				return node;
+			}
 		private:
 			JID jid;
 			std::string node;
 	};
+}

include/Swiften/Elements/PubSubSubscriptionPayload.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #include <Swiften/Elements/PubSubSubscriptionPayload.h>
 namespace Swift {
 PubSubSubscriptionPayload::PubSubSubscriptionPayload(const JID &jid, const std::string &node) :
 	jid(jid), node(node), type(None) {
+	}
+}

include/Swiften/Elements/PubSubSubscriptionPayload.h

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2011 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <vector>
 #include <string>
 #include <Swiften/Elements/Payload.h>
 #include <Swiften/JID/JID.h>
 namespace Swift {
 	class PubSubSubscriptionPayload : public Payload {
 		public:
 			enum Type { None, Pending, Subscribed, Unconfigured };
 			PubSubSubscriptionPayload(const JID &jid = JID(), const std::string &node = "");
 			void setJID(const JID &jid) {
 				this->jid = jid;
+			}
 			const JID &getJID() const {
 				return jid;
+			}
 			void setNode(const std::string &node) {
 				this->node = node;
+			}
 			const std::string &getNode() const {
 				return node;
+			}
 			void setId(const std::string &id) {
 				this->id = id;
+			}
 			const std::string &getId() const {
 				return id;
+			}
 			void setType(const Type &type) {
 				this->type = type;
+			}
 			const Type &getType() const {
 				return type;
+			}
 		private:
 			JID jid;
 			std::string node;
 			std::string id;
 			Type type;
 	};
+}

include/Swiften/Network/DummyNetworkFactories.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/Network/DummyNetworkFactories.h>
 #include <Swiften/Network/DummyTimerFactory.h>
 #include <Swiften/Network/DummyConnectionFactory.h>
 #include <Swiften/Network/PlatformDomainNameResolver.h>
 #include <Swiften/Network/DummyConnectionServerFactory.h>
 namespace Swift {
 DummyNetworkFactories::DummyNetworkFactories(EventLoop* eventLoop) {
 	timerFactory = new DummyTimerFactory();
 	connectionFactory = new DummyConnectionFactory(eventLoop);
 	domainNameResolver = new PlatformDomainNameResolver(eventLoop);
 	connectionServerFactory = new DummyConnectionServerFactory(eventLoop);
 	m_platformXMLParserFactory =  new PlatformXMLParserFactory();
 	this->eventLoop = eventLoop;
+}
 DummyNetworkFactories::~DummyNetworkFactories() {
 	delete connectionServerFactory;
 	delete domainNameResolver;
 	delete connectionFactory;
 	delete timerFactory;
 	delete m_platformXMLParserFactory;
+}
+}

include/Swiften/Network/DummyNetworkFactories.h

➞

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.
  */
 #pragma once
 #include <Swiften/Network/NetworkFactories.h>
 #include <Swiften/Parser/PlatformXMLParserFactory.h>
 namespace Swift {
 	class EventLoop;
 	class DummyNetworkFactories : public NetworkFactories {
 		public:
 			DummyNetworkFactories(EventLoop *eventLoop);
 			~DummyNetworkFactories();
 			virtual TimerFactory* getTimerFactory() const {
 				return timerFactory;
+			}
 			virtual ConnectionFactory* getConnectionFactory() const {
 				return connectionFactory;
+			}
 			DomainNameResolver* getDomainNameResolver() const {
 				return domainNameResolver;
+			}
 			ConnectionServerFactory* getConnectionServerFactory() const {
 				return connectionServerFactory;
+			}
 			virtual Swift::NATTraverser* getNATTraverser() const {
 				return 0;
+			}
 			Swift::XMLParserFactory* getXMLParserFactory() const {
 				return m_platformXMLParserFactory;
+			}
 			EventLoop *getEventLoop() const {
 				return eventLoop;
+			}
             Swift::TLSContextFactory* getTLSContextFactory() const {
                 return 0;
+            }
             Swift::ProxyProvider* getProxyProvider() const {
                 return 0;
+            }
 		private:
 			PlatformXMLParserFactory *m_platformXMLParserFactory;
 			TimerFactory* timerFactory;
 			ConnectionFactory* connectionFactory;
 			DomainNameResolver* domainNameResolver;
 			ConnectionServerFactory* connectionServerFactory;
 			EventLoop *eventLoop;
 	};
+}

include/Swiften/Parser/PayloadParsers/GatewayPayloadParser.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2012 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #include <Swiften/Parser/PayloadParsers/GatewayPayloadParser.h>
 #include <boost/lexical_cast.hpp>
 #include <Swiften/Parser/PayloadParserFactoryCollection.h>
 #include <Swiften/Parser/PayloadParserFactory.h>
 #include <Swiften/Base/foreach.h>
 #include <Swiften/Elements/MUCOccupant.h>
 #include <Swiften/Parser/Tree/TreeReparser.h>
 namespace Swift {
 void GatewayPayloadParser::handleTree(ParserElement::ref root) {
 	foreach (ParserElement::ref child, root->getAllChildren()) {
 		if (child->getName() == "desc") {
 			getPayloadInternal()->setDesc(child->getText());
+		}
 		else if (child->getName() == "prompt") {
 			getPayloadInternal()->setPrompt(child->getText());
+		}
 		else if (child->getName() == "jid") {
 			getPayloadInternal()->setJID(child->getText());
+		}
+	}
+}
+}

include/Swiften/Parser/PayloadParsers/GatewayPayloadParser.h

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2012 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <boost/optional.hpp>
 #include <Swiften/Elements/GatewayPayload.h>
 #include <Swiften/Parser/GenericPayloadTreeParser.h>
 #include <Swiften/Parser/PayloadParsers/MUCItemParser.h>
 namespace Swift {
 	class GatewayPayloadParser : public GenericPayloadTreeParser<GatewayPayload> {
 		public:
 			GatewayPayloadParser() {}
 			virtual void handleTree(ParserElement::ref root);
 	};
+}

include/Swiften/Parser/PayloadParsers/MUCPayloadParser.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2010 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 #include <Swiften/Parser/PayloadParsers/MUCPayloadParser.h>
 #include <boost/lexical_cast.hpp>
 #include <Swiften/Parser/PayloadParserFactoryCollection.h>
 #include <Swiften/Parser/PayloadParserFactory.h>
 #include <Swiften/Base/foreach.h>
 #include <Swiften/Elements/MUCOccupant.h>
 #include <Swiften/Parser/Tree/TreeReparser.h>
 namespace Swift {
 void MUCPayloadParser::handleTree(ParserElement::ref root) {
 	foreach (ParserElement::ref child, root->getAllChildren()) {
 		if (child->getName() == "password" && child->getNamespace() == root->getNamespace()) {
 			getPayloadInternal()->setPassword(child->getText());
+		}
+	}
+}
+}

include/Swiften/Parser/PayloadParsers/MUCPayloadParser.h

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2010 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 #pragma once
 #include <boost/optional.hpp>
 #include <Swiften/Elements/MUCPayload.h>
 #include <Swiften/Parser/GenericPayloadTreeParser.h>
 #include <Swiften/Parser/PayloadParsers/MUCItemParser.h>
 namespace Swift {
 	class PayloadParserFactoryCollection;
 	class MUCPayloadParser : public GenericPayloadTreeParser<MUCPayload> {
 		public:
 			MUCPayloadParser(){}
 			virtual void handleTree(ParserElement::ref root);
 	};
+}

include/Swiften/Parser/PayloadParsers/PubSubItemParser.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2012 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #include <Swiften/Parser/PayloadParsers/PubSubItemParser.h>
 #include <boost/lexical_cast.hpp>
 #include <Swiften/Parser/PayloadParserFactoryCollection.h>
 #include <Swiften/Parser/PayloadParserFactory.h>
 #include <Swiften/Base/foreach.h>
 #include <Swiften/Elements/MUCOccupant.h>
 #include <Swiften/Parser/Tree/TreeReparser.h>
 namespace Swift {
 void PubSubItemParser::handleTree(ParserElement::ref root) {
 	std::string id = root->getAttributes().getAttribute("id");
 	if (!id.empty()) {
 		getPayloadInternal()->setId(id);
+	}
 	foreach (ParserElement::ref child, root->getAllChildren()) {
 		getPayloadInternal()->addPayload(TreeReparser::parseTree(child, factories));
+	}
+}
+}

include/Swiften/Parser/PayloadParsers/PubSubItemParser.h

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2012 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #pragma once
 #include <boost/optional.hpp>
 #include <Swiften/Elements/PubSubItem.h>
 #include <Swiften/Parser/GenericPayloadTreeParser.h>
 #include <Swiften/Parser/PayloadParsers/MUCItemParser.h>
 namespace Swift {
 	class PayloadParserFactoryCollection;
 	class PubSubItemParser : public GenericPayloadTreeParser<PubSubItem> {
 		public:
 			PubSubItemParser(PayloadParserFactoryCollection* collection) : factories(collection) {}
 			virtual void handleTree(ParserElement::ref root);
 		private:
 			PayloadParserFactoryCollection* factories;
 	};
+}

include/Swiften/Parser/PayloadParsers/PubSubPayloadParser.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (c) 2012 Jan Kaluza
  * Licensed under the Simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 #include <Swiften/Parser/PayloadParsers/PubSubPayloadParser.h>
 #include <boost/lexical_cast.hpp>
 #include <Swiften/Parser/PayloadParserFactoryCollection.h>
 #include <Swiften/Parser/PayloadParserFactory.h>
 #include <Swiften/Base/foreach.h>
 #include <Swiften/Elements/MUCOccupant.h>
 #include <Swiften/Parser/Tree/TreeReparser.h>
 namespace Swift {
 void PubSubPayloadParser::handleTree(ParserElement::ref root) {
 	foreach (ParserElement::ref child, root->getAllChildren()) {
 		getPayloadInternal()->addPayload(TreeReparser::parseTree(child, factories));
+	}
+}
+}

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

0 comments (0 inline, 0 general)