libtransport.git Changeset - 79673211dd9c

Changeset - 79673211dd9c

Parent rev.

Child rev.

[Not reviewed]

Merge

0 12 0

Vitaly Takmazov - 13 years ago 2013-02-06 21:55:48
vitalyster@gmail.com

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

11 files changed with 90 insertions and 556 deletions:

CMakeLists.txt

backends/skype/main.cpp

534

backends/swiften/main.cpp

include/transport/memoryusage.h

include/transport/protocol.proto

spectrum/src/main.cpp

spectrum_manager/src/CMakeLists.txt

src/CMakeLists.txt

src/admininterface.cpp

src/memoryusage.cpp

src/usermanager.cpp

0 comments (0 inline, 0 general)

CMakeLists.txt

➞

Show inline comments

@@ @@ -88,49 +88,49 @@ else(WIN32) @@
 	if(contains)
 		message(STATUS "Using non-multithreaded boost")
 		set(Boost_USE_MULTITHREADED 0)
 	endif(contains)
 	set(Boost_FIND_QUIETLY ON)
 	find_package(Boost COMPONENTS program_options date_time system filesystem regex thread-mt signals)
 	if (NOT Boost_FOUND)
 		set(Boost_FIND_QUIETLY OFF)
 		find_package(Boost COMPONENTS program_options date_time system filesystem regex thread signals REQUIRED)
 	endif()
 endif(WIN32)
 message( STATUS "Found Boost: ${Boost_LIBRARIES}, ${Boost_INCLUDE_DIR}")
 # FIND POPT
 if (NOT WIN32)
 	set(popt_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 	find_package(popt REQUIRED)
 endif()
 ###### Database ######
 # FIND SQLITE3
 if (ENABLE_SQLITE3)
-	if (NOT CMAKE_COMPILER_IS_GNUCXX)
+	if (MSVC)
 		ADD_SUBDIRECTORY(${CMAKE_SOURCE_DIR}/msvc-deps)
 	else()
 		if (WIN32)
 			ADD_SUBDIRECTORY(${CMAKE_SOURCE_DIR}/msvc-deps/sqlite3)
 		else()
 			set(sqlite3_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 			find_package(sqlite3)
 		endif()
 	endif()
 endif()
 # FIND MYSQL
 if(ENABLE_MYSQL)
 	set(mysql_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 	find_package(mysql)
 endif()
 # FIND PQXX
 if(ENABLE_PQXX)
 	set(pqxx_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 	find_package(pqxx)
 endif()
 ###### Plugins ######
@@ @@ -227,48 +227,58 @@ endif() @@
 # if(ENABLE_LOG)
 	if(LOG4CXX_INCLUDE_DIR AND LOG4CXX_LIBRARY)
 		set(LOG4CXX_LIBRARIES ${LOG4CXX_LIBRARY})
 		set(LOG4CXX_FOUND 1)
 		message(STATUS "Using log4cxx: ${CPPUNIT_INCLUDE_DIR} ${LOG4CXX_INCLUDE_DIR}")
 	else()
 		set(log4cxx_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 		find_package(log4cxx)
 	endif()
 # endif()
 # FIND CPPUNIT
 if(ENABLE_TESTS)
 	set(cppunit_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 	find_package(cppunit)
 	if(NOT CPPUNIT_FOUND AND CPPUNIT_INCLUDE_DIR AND CPPUNIT_LIBRARY)
 		set(CCPUNIT_LIBRARIES ${CPPUNIT_LIBRARY})
 		set(CPPUNIT_FOUND 1)
 		message(STATUS "Using cppunit: ${CPPUNIT_INCLUDE_DIR} ${CPPUNIT_LIBRARIES}")
 	endif()
 endif()
 if (APPLE)
         FIND_LIBRARY(IOKIT_FRAMEWORK IOKit)
         FIND_LIBRARY(SECURITY_FRAMEWORK Security)
         FIND_LIBRARY(APPKIT_FRAMEWORK AppKit)
         FIND_LIBRARY(SYSTEMCONFIGURATION_FRAMEWORK SystemConfiguration)
         FIND_LIBRARY(SECURITYINTERFACE_FRAMEWORK SecurityInterface)
         MARK_AS_ADVANCED(IOKIT_FRAMEWORK APPKIT_FRAMEWORK SYSTEMCONFIGURATION_FRAMEWORK SECURITY_FRAMEWORK SECURITYINTERFACE_FRAMEWORK)
         SET (APPLE_FRAMEWORKS ${IOKIT_FRAMEWORK} ${APPKIT_FRAMEWORK} ${SYSTEMCONFIGURATION_FRAMEWORK} ${SECURITY_FRAMEWORK} ${SECURITYINTERFACE_FRAMEWORK})
 endif()
 message("  Supported features")
 message("-----------------------")
 if (SPECTRUM_VERSION)
 	ADD_DEFINITIONS(-DSPECTRUM_VERSION="${SPECTRUM_VERSION}")
 else (SPECTRUM_VERSION)
 	if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
 		if (NOT GIT_EXECUTABLE)
 		set (GIT_EXECUTABLE git)
 		endif()
 		execute_process(COMMAND ${GIT_EXECUTABLE} "--git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git" rev-parse --short HEAD
 						OUTPUT_VARIABLE GIT_REVISION
 						OUTPUT_STRIP_TRAILING_WHITESPACE
+		)
 		set(SPECTRUM_VERSION 2.0.0-beta-git-${GIT_REVISION})
 		ADD_DEFINITIONS(-DSPECTRUM_VERSION="${SPECTRUM_VERSION}")
 	else (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
 		set(SPECTRUM_VERSION 2.0.0-alpha)
 		ADD_DEFINITIONS(-DSPECTRUM_VERSION="${SPECTRUM_VERSION}")
 	endif (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
 endif (SPECTRUM_VERSION)
 message("Version           : " ${SPECTRUM_VERSION})

backends/skype/main.cpp

➞

Show inline comments

 #include "glib.h"
 #include <dbus-1.0/dbus/dbus-glib-lowlevel.h>
 #include "sqlite3.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/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 <boost/filesystem.hpp>
 #include "sys/wait.h"
 #include "sys/signal.h"
 // #include "valgrind/memcheck.h"
 #ifndef __FreeBSD__
 #include "malloc.h"
 #endif
 #include <dbus-1.0/dbus/dbus-glib-lowlevel.h>
-#include "sqlite3.h"
+#include "skype.h"
 DEFINE_LOGGER(logger, "backend");
 using namespace Transport;
-class SpectrumNetworkPlugin;
+class SkypePlugin;
 #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="";\
+					}
 // Prepare the SQL statement
 #define PREP_STMT(sql, str) \
 	if(sqlite3_prepare_v2(db, std::string(str).c_str(), -1, &sql, NULL)) { \
 		LOG4CXX_ERROR(logger, str<< (sqlite3_errmsg(db) == NULL ? "" : sqlite3_errmsg(db))); \
 		sql = NULL; \
+	}
 // Finalize the prepared statement
 #define FINALIZE_STMT(prep) \
 	if(prep != NULL) { \
 		sqlite3_finalize(prep); \
+	}
 #define BEGIN(STATEMENT) 	sqlite3_reset(STATEMENT);\
 							int STATEMENT##_id = 1;\
 							int STATEMENT##_id_get = 0;\
 							(void)STATEMENT##_id_get;
 #define BIND_INT(STATEMENT, VARIABLE) sqlite3_bind_int(STATEMENT, STATEMENT##_id++, VARIABLE)
 #define BIND_STR(STATEMENT, VARIABLE) sqlite3_bind_text(STATEMENT, STATEMENT##_id++, VARIABLE.c_str(), -1, SQLITE_STATIC)
 #define RESET_GET_COUNTER(STATEMENT)	STATEMENT##_id_get = 0;
 #define GET_INT(STATEMENT)	sqlite3_column_int(STATEMENT, STATEMENT##_id_get++)
 #define GET_STR(STATEMENT)	(const char *) sqlite3_column_text(STATEMENT, STATEMENT##_id_get++)
 #define GET_BLOB(STATEMENT)	(const void *) sqlite3_column_blob(STATEMENT, STATEMENT##_id_get++)
 #define EXECUTE_STATEMENT(STATEMENT, NAME) 	if(sqlite3_step(STATEMENT) != SQLITE_DONE) {\
 		LOG4CXX_ERROR(logger, NAME<< (sqlite3_errmsg(db) == NULL ? "" : sqlite3_errmsg(db)));\
+			}
-SpectrumNetworkPlugin *np;
+SkypePlugin *np;
 int m_sock;
 static int writeInput;
 static std::string host;
 static int port = 10000;
 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() { 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;
 		std::map<std::string, std::string> m_groups;
 };
 class SpectrumNetworkPlugin : public NetworkPlugin {
 class SkypePlugin : public NetworkPlugin {
 	public:
-		SpectrumNetworkPlugin(Config *config, const std::string &host, int port) : NetworkPlugin() {
+		SkypePlugin(Config *config, const std::string &host, int port) : NetworkPlugin() {
 			this->config = config;
 			LOG4CXX_INFO(logger, "Starting the backend.");
+		}
-		~SpectrumNetworkPlugin() {
+		~SkypePlugin() {
 			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;
 			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);
+			Skype *skype = new Skype(this, 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) {
@@ @@ -370,537 +335,48 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 		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) {
 				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;
 	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,
 		&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=" << 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.");
 		GError *error = NULL;
 		m_connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
 		if (m_connection == NULL && error != NULL)
+		{
 			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;
 		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) {
 		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" || re == "ERROR 68") {
 		return TRUE;
+	}
 	close(fd_output);
 	if (send_command("PROTOCOL 7") != "PROTOCOL 7") {
 		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");
 	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+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) {
 		if (m_proxy) {
 			send_command("SET USERSTATUS INVISIBLE");
 			send_command("SET USERSTATUS OFFLINE");
 			sleep(2);
 			g_object_unref(m_proxy);
+		}
 		LOG4CXX_INFO(logger,  m_username << ": Terminating Skype instance (SIGTERM)");
 		kill((int) m_pid, SIGTERM);
 		// Give skype a chance
 		sleep(2);
 		LOG4CXX_INFO(logger,  m_username << ": Killing Skype instance (SIGKILL)");
 		kill((int) m_pid, SIGKILL);
 		m_pid = 0;
+	}
+}
 std::string Skype::send_command(const std::string &message) {
 	GError *error = NULL;
 	gchar *str = NULL;
 // 			int message_num;
 // 			gchar error_return[30];
 	LOG4CXX_INFO(logger, "Sending: '" << message << "'");
 	if (!dbus_g_proxy_call (m_proxy, "Invoke", &error, G_TYPE_STRING, message.c_str(), G_TYPE_INVALID,
 						G_TYPE_STRING, &str, G_TYPE_INVALID))
+	{
 			if (error && error->message)
+			{
 			LOG4CXX_INFO(logger,  m_username << ": DBUS Error: " << error->message);
 			g_error_free(error);
 			return "";
 		} else {
 			LOG4CXX_INFO(logger,  m_username << ": DBUS no response");
 			return "";
+		}
+	}
 	if (str != NULL)
+	{
 		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]);
 				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") {
 			GET_PROPERTY(st, "USER", cmd[1], "ONLINESTATUS");
 			pbnetwork::StatusType status = getStatus(st);
 			std::string mood_text = GET_RESPONSE_DATA(message, "MOOD_TEXT");
 			std::vector<std::string> groups;
 			np->handleBuddyChanged(sk->getUser(), cmd[1], "", groups, status, mood_text);
+		}
 		else if (cmd[2] == "BUDDYSTATUS" && cmd[3] == "3") {
 			GET_PROPERTY(mood_text, "USER", cmd[1], "MOOD_TEXT");
 			GET_PROPERTY(st, "USER", cmd[1], "ONLINESTATUS");
 			pbnetwork::StatusType status = getStatus(st);
 			std::vector<std::string> groups;
 			np->handleBuddyChanged(sk->getUser(), cmd[1], "", groups, status, mood_text);
+		}
 		else if (cmd[2] == "FULLNAME") {
 			GET_PROPERTY(alias, "USER", cmd[1], "FULLNAME");
 			GET_PROPERTY(mood_text, "USER", cmd[1], "MOOD_TEXT");
 			GET_PROPERTY(st, "USER", cmd[1], "ONLINESTATUS");
 			pbnetwork::StatusType status = getStatus(st);
 			std::vector<std::string> groups;
 			np->handleBuddyChanged(sk->getUser(), cmd[1], alias, groups, status, mood_text);
+		}
 		else if(cmd[2] == "RECEIVEDAUTHREQUEST") {
 			np->handleAuthorization(sk->getUser(), cmd[1]);
+		}
+	}
 	else if (cmd[0] == "GROUP") {
 // 		if (cmd[2] == "DISPLAYNAME") {
 // 			//GROUP 810 DISPLAYNAME My Friends
 // 			std::string grp = GET_RESPONSE_DATA(message, "DISPLAYNAME");
 // 			std::string users = sk->send_command("GET GROUP " + cmd[1] + " USERS");
 // 			try {
 // 				users = GET_RESPONSE_DATA(users, "USERS");
 // 			}
 // 			catch (std::out_of_range& oor) {
 // 				return;
 // 			}
 //
 // 			std::vector<std::string> data;
 // 			boost::split(data, users, boost::is_any_of(","));
 // 			BOOST_FOREACH(std::string u, data) {
 // 				GET_PROPERTY(alias, "USER", u, "FULLNAME");
 // 				GET_PROPERTY(mood_text, "USER", u, "MOOD_TEXT");
 // 				GET_PROPERTY(st, "USER", u, "ONLINESTATUS");
 // 				pbnetwork::StatusType status = getStatus(st);
 //
 // 				std::vector<std::string> groups;
 // 				groups.push_back(grp);
 // 				np->handleBuddyChanged(sk->getUser(), u, alias, groups, status, mood_text);
 // 			}
 // 		}
 		if (cmd[2] == "NROFUSERS" && cmd[3] != "0") {
 			GET_PROPERTY(grp, "GROUP", cmd[1], "DISPLAYNAME");
 			std::string users = sk->send_command("GET GROUP " + cmd[1] + " USERS");
 			try {
 				users = GET_RESPONSE_DATA(users, "USERS");
+			}
 			catch (std::out_of_range& oor) {
 				return;
+			}
 			std::vector<std::string> data;
 			boost::split(data, users, boost::is_any_of(","));
 			BOOST_FOREACH(std::string u, data) {
 				GET_PROPERTY(alias, "USER", u, "FULLNAME");
 				GET_PROPERTY(mood_text, "USER", u, "MOOD_TEXT");
 				GET_PROPERTY(st, "USER", u, "ONLINESTATUS");
 				pbnetwork::StatusType status = getStatus(st);
 				std::vector<std::string> groups;
 				groups.push_back(grp);
 				np->handleBuddyChanged(sk->getUser(), u, alias, groups, status, mood_text);
+			}
+		}
+	}
 	else if (cmd[0] == "CHATMESSAGE") {
 		if (cmd[3] == "RECEIVED") {
 			GET_PROPERTY(body, "CHATMESSAGE", cmd[1], "BODY");
 			GET_PROPERTY(from_handle, "CHATMESSAGE", cmd[1], "FROM_HANDLE");
 			if (from_handle == sk->getUsername())
 				return;
 			np->handleMessage(sk->getUser(), from_handle, body);
 			sk->send_command("SET CHATMESSAGE " + cmd[1] + " SEEN");
+		}
+	}
 	else if (cmd[0] == "CALL") {
 		// CALL 884 STATUS RINGING
 		if (cmd[2] == "STATUS") {
 			if (cmd[3] == "RINGING" || cmd[3] == "MISSED") {
 				// handle only incoming calls
 				GET_PROPERTY(type, "CALL", cmd[1], "TYPE");
 				if (type.find("INCOMING") != 0) {
 					return;
+				}
 				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(const 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);
@@ @@ -948,43 +424,46 @@ static void log_glib_error(const gchar *string) { @@
 	LOG4CXX_ERROR(logger, "GLIB ERROR:" << string);
+}
 int main(int argc, char **argv) {
 #ifndef WIN32
 		signal(SIGPIPE, SIG_IGN);
 		if (signal(SIGCHLD, spectrum_sigchld_handler) == SIG_ERR) {
 			std::cout << "SIGCHLD handler can't be set\n";
 			return -1;
+		}
 #endif
 	std::string error;
 	Config *cfg = Config::createFromArgs(argc, argv, error, host, port);
 	if (cfg == NULL) {
 		std::cerr << error;
 		return 1;
+	}
 	Logging::initBackendLogging(cfg);
 	g_type_init();
 	m_sock = create_socket(host.c_str(), 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(cfg, host, port);
 	dbus_threads_init_default();
 	np = new SkypePlugin(cfg, host, port);
 	GMainLoop *m_loop;
 	m_loop = g_main_loop_new(NULL, FALSE);
 	if (m_loop) {
 		g_main_loop_run(m_loop);
+	}
+}

backends/swiften/main.cpp

➞

Show inline comments

 // Transport includes
 #include "transport/config.h"
 #include "transport/networkplugin.h"
 #include "transport/logging.h"
 #include "boost/date_time/posix_time/posix_time.hpp"
 // Swiften
 #include "Swiften/Swiften.h"
 #ifndef WIN32
 // for signal handler
 #include "unistd.h"
 #include "signal.h"
 #include "sys/wait.h"
 #include "sys/signal.h"
 #endif
 #ifndef __FreeBSD__
 #ifndef __MACH__
 // malloc_trim
 #include "malloc.h"
 #endif
 #endif
 // Boost
 #include <boost/algorithm/string.hpp>
 using namespace boost::filesystem;
 using namespace boost::program_options;
 using namespace Transport;
 DEFINE_LOGGER(logger, "Swiften");
 // eventloop
 Swift::SimpleEventLoop *loop_;
 // Plugins
 class SwiftenPlugin;
 NetworkPlugin *np = NULL;
 class MUCController {
 	public:
 		MUCController(const std::string &user, boost::shared_ptr<Swift::Client> client, const std::string &room, const std::string &nickname, const std::string &password) {
 			m_user = user;
 			m_room = room;
 			muc = client->getMUCManager()->createMUC(room);
 			if (!password.empty()) {
 				muc->setPassword(password);
@@ @@ -168,79 +170,85 @@ class SwiftenPlugin : public NetworkPlugin { @@
 					case Swift::ClientError::CertificateSelfSignedError: message = ("Certificate is self-signed"); break;
 					case Swift::ClientError::CertificateRejectedError: message = ("Certificate has been rejected"); break;
 					case Swift::ClientError::CertificateUntrustedError: message = ("Certificate is not trusted"); break;
 					case Swift::ClientError::InvalidCertificatePurposeError: message = ("Certificate cannot be used for encrypting your connection"); break;
 					case Swift::ClientError::CertificatePathLengthExceededError: message = ("Certificate path length constraint exceeded"); break;
 					case Swift::ClientError::InvalidCertificateSignatureError: message = ("Invalid certificate signature"); break;
 					case Swift::ClientError::InvalidCAError: message = ("Invalid Certificate Authority"); break;
 					case Swift::ClientError::InvalidServerIdentityError: message = ("Certificate does not match the host identity"); break;
+				}
+			}
 			LOG4CXX_INFO(logger, user << ": Disconnected " << message);
 			handleDisconnected(user, reconnect ? 0 : 3, message);
 			boost::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				client->onConnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftConnected, this, user));
 				client->onDisconnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftDisconnected, this, user, _1));
 				client->onMessageReceived.disconnect(boost::bind(&SwiftenPlugin::handleSwiftMessageReceived, this, user, _1));
 				m_users.erase(user);
 				m_mucs.erase(user);
+			}
 #ifndef WIN32
 #ifndef __FreeBSD__
 #ifndef __MACH__
 			// force returning of memory chunks allocated by libxml2 to kernel
 			malloc_trim(0);
 #endif
 #endif
 #endif
+		}
 		void handleSwiftConnected(const std::string &user) {
 			LOG4CXX_INFO(logger, user << ": Connected to XMPP server.");
 			handleConnected(user);
 			m_users[user]->requestRoster();
 			Swift::Presence::ref response = Swift::Presence::create();
 			response->setFrom(m_users[user]->getJID());
 			m_users[user]->sendPresence(response);
+		}
 		void handleSwiftRosterReceived(const std::string &user) {
 			Swift::PresenceOracle *oracle = m_users[user]->getPresenceOracle();
 			BOOST_FOREACH(const Swift::XMPPRosterItem &item, m_users[user]->getRoster()->getItems()) {
 				Swift::Presence::ref lastPresence = oracle->getLastPresence(item.getJID());
 				pbnetwork::StatusType status = lastPresence ? ((pbnetwork::StatusType) lastPresence->getShow()) : pbnetwork::STATUS_NONE;
 				handleBuddyChanged(user, item.getJID().toBare().toString(),
 								   item.getName(), item.getGroups(), status);
+			}
+		}
 		void handleSwiftPresenceChanged(const std::string &user, Swift::Presence::ref presence) {
 			boost::shared_ptr<Swift::Client> client = m_users[user];
 			if (client->getMUCRegistry()->isMUC(presence->getFrom().toBare())) {
 				return;
+			}
 			if (presence->getPayload<Swift::MUCUserPayload>() != NULL || presence->getPayload<Swift::MUCPayload>() != NULL) {
 				return;
+			}
 			LOG4CXX_INFO(logger, user << ": " << presence->getFrom().toBare().toString() << " presence changed");
 			std::string message = presence->getStatus();
 			std::string photo = "";
 			boost::shared_ptr<Swift::VCardUpdate> update = presence->getPayload<Swift::VCardUpdate>();
 			if (update) {
 				photo = update->getPhotoHash();
+			}
 			boost::optional<Swift::XMPPRosterItem> item = m_users[user]->getRoster()->getItem(presence->getFrom());
 			if (item) {
 				handleBuddyChanged(user, presence->getFrom().toBare().toString(), item->getName(), item->getGroups(), (pbnetwork::StatusType) presence->getShow(), message, photo);
+			}
 			else {
 				std::vector<std::string> groups;
 				handleBuddyChanged(user, presence->getFrom().toBare().toString(), presence->getFrom().toBare(), groups, (pbnetwork::StatusType) presence->getShow(), message, photo);
+			}
+		}
 		void handleSwiftMessageReceived(const std::string &user, Swift::Message::ref message) {
 			std::string body = message->getBody();
 			boost::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
@@ @@ -278,64 +286,63 @@ class SwiftenPlugin : public NetworkPlugin { @@
 			LOG4CXX_INFO(logger, user << ": connecting as " << legacyName);
 			boost::shared_ptr<Swift::Client> client = boost::make_shared<Swift::Client>(Swift::JID(legacyName), password, m_factories);
 			m_users[user] = client;
 			client->setAlwaysTrustCertificates();
 			client->onConnected.connect(boost::bind(&SwiftenPlugin::handleSwiftConnected, this, user));
 			client->onDisconnected.connect(boost::bind(&SwiftenPlugin::handleSwiftDisconnected, this, user, _1));
 			client->onMessageReceived.connect(boost::bind(&SwiftenPlugin::handleSwiftMessageReceived, this, user, _1));
 			client->getRoster()->onInitialRosterPopulated.connect(boost::bind(&SwiftenPlugin::handleSwiftRosterReceived, this, user));
 			client->getPresenceOracle()->onPresenceChange.connect(boost::bind(&SwiftenPlugin::handleSwiftPresenceChanged, this, user, _1));
 			Swift::ClientOptions opt;
 			opt.allowPLAINWithoutTLS = true;
 			client->connect(opt);
+		}
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 			boost::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				client->onConnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftConnected, this, user));
 // 				client->onDisconnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftDisconnected, this, user, _1));
 				client->onMessageReceived.disconnect(boost::bind(&SwiftenPlugin::handleSwiftMessageReceived, this, user, _1));
 				client->getRoster()->onInitialRosterPopulated.disconnect(boost::bind(&SwiftenPlugin::handleSwiftRosterReceived, this, user));
 				client->getPresenceOracle()->onPresenceChange.disconnect(boost::bind(&SwiftenPlugin::handleSwiftPresenceChanged, this, user, _1));
 				client->disconnect();
 				m_mucs.erase(user);
 				m_users.erase(user);
+			}
+		}
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &msg, const std::string &xhtml = "", const std::string &id = "") {
 			LOG4CXX_INFO(logger, "Sending message from " << user << " to " << legacyName << ".");
 			boost::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				boost::shared_ptr<Swift::Message> message(new Swift::Message());
 				message->setTo(Swift::JID(legacyName));
 				message->setFrom(client->getJID());
 				message->setBody(msg);
 				if (client->getMUCRegistry()->isMUC(legacyName)) {
 					message->setType(Swift::Message::Groupchat);
 					boost::shared_ptr<MUCController> muc = m_mucs[user][legacyName];
 					handleMessage(user, legacyName, msg, muc->getNickname(), xhtml);
+// 					handleMessage(user, legacyName, msg, muc->getNickname(), xhtml);
+				}
 				client->sendMessage(message);
+			}
+		}
 		void handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id) {
 			boost::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				LOG4CXX_INFO(logger, user << ": fetching VCard of " << legacyName << " id=" << id);
 				Swift::GetVCardRequest::ref request = Swift::GetVCardRequest::create(Swift::JID(legacyName), client->getIQRouter());
 				request->onResponse.connect(boost::bind(&SwiftenPlugin::handleSwiftVCardReceived, this, user, id, _1, _2));
 				request->send();
+			}
+		}
 		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups) {
 			boost::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				LOG4CXX_INFO(logger, user << ": Added/Updated buddy " << buddyName << ".");
 				if (!client->getRoster()->containsJID(buddyName)) {
 					Swift::RosterItemPayload item;
 					item.setName(alias);
 					item.setJID(buddyName);

include/transport/memoryusage.h

➞

Show inline comments

@@ @@ -3,33 +3,31 @@ @@
+ *
  * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <vector>
 #ifndef WIN32
 #include "signal.h"
 #else
 #define pid_t void*
 #endif
 namespace Transport {
 #ifndef WIN32
 	void process_mem_usage(double& shared, double& resident_set, pid_t pid = 0);
 #endif
+}

include/transport/protocol.proto

➞

Show inline comments

@@ @@ -74,48 +74,52 @@ message ConversationMessage { @@
 	optional string id = 8;
 	optional bool pm = 9;
+}
 message Room {
 	required string userName = 1;
 	required string nickname = 2;
 	required string room = 3;
 	optional string password = 4;
+}
 message RoomList {
 	repeated string room = 1;
 	repeated string name = 2;
+}
 enum ParticipantFlag {
 	PARTICIPANT_FLAG_NONE = 0;
 	PARTICIPANT_FLAG_MODERATOR = 1;
 	PARTICIPANT_FLAG_CONFLICT = 2;
 	PARTICIPANT_FLAG_BANNED = 4;
 	PARTICIPANT_FLAG_NOT_AUTHORIZED = 8;
 	PARTICIPANT_FLAG_ME = 16;
 	PARTICIPANT_FLAG_KICKED = 32;
 	PARTICIPANT_FLAG_VISITOR = 64;
 	PARTICIPANT_FLAG_MEMBER = 128;
 	PARTICIPANT_FLAG_ADMIN = 256;
 	PARTICIPANT_FLAG_OWNER = 512;
+}
 message Participant {
 	required string userName = 1;
 	required string room = 2;
 	required string nickname = 3;
 	required int32 flag = 4;
 	required StatusType status = 5;
 	optional string statusMessage = 6;
 	optional string newname = 7;
+}
 message VCard {
 	required string userName = 1;
 	required string buddyName = 2;
 	required int32 id = 3;
 	optional string fullname = 4;
 	optional string nickname = 5;
 	optional bytes photo = 6;
+}
 message Status {
 	required string userName = 1;
 	required StatusType status = 3;

spectrum/src/main.cpp

➞

Show inline comments

@@ @@ -7,50 +7,52 @@ @@
 #include "transport/pqxxbackend.h"
 #include "transport/userregistration.h"
 #include "transport/networkpluginserver.h"
 #include "transport/admininterface.h"
 #include "transport/statsresponder.h"
 #include "transport/usersreconnecter.h"
 #include "transport/util.h"
 #include "transport/gatewayresponder.h"
 #include "transport/logging.h"
 #include "transport/discoitemsresponder.h"
 #include "transport/adhocmanager.h"
 #include "transport/settingsadhoccommand.h"
 #include "Swiften/EventLoop/SimpleEventLoop.h"
 #include "Swiften/Network/BoostNetworkFactories.h"
 #include <boost/filesystem.hpp>
 #include <boost/algorithm/string.hpp>
 #ifndef WIN32
 #include "sys/signal.h"
 #include "sys/stat.h"
 #include <pwd.h>
 #include <grp.h>
 #include <sys/resource.h>
 #include "libgen.h"
 #ifndef __FreeBSD__
 #ifndef __MACH__
 #include <malloc.h>
 #endif
 #endif
 #else
 #include <process.h>
 #define getpid _getpid
 #include "win32/ServiceWrapper.h"
 #endif
 #include <sys/stat.h>
 using namespace Transport;
 using namespace Transport::Util;
 DEFINE_LOGGER(logger, "Spectrum");
 Swift::SimpleEventLoop *eventLoop_ = NULL;
 Component *component_ = NULL;
 UserManager *userManager_ = NULL;
 Config *config_ = NULL;
 static void stop_spectrum() {
 	userManager_->removeAllUsers(false);
 	component_->stop();
 	eventLoop_->stop();
+}
 static void spectrum_sigint_handler(int sig) {
@@ @@ -287,52 +289,54 @@ int mainloop() { @@
 	delete storageBackend;
 	delete factories;
 	return 0;
+}
 int main(int argc, char **argv)
+{
 	Config config(argc, argv);
 	config_ = &config;
 	boost::program_options::variables_map vm;
 	bool no_daemon = false;
 	std::string config_file;
 	std::string jid;
 #ifdef WIN32
 	std::string install_service_name, uninstall_service_name, run_service_name;
 	// determine the name of the currently executing file
 	char szFilePath[MAX_PATH];
 	GetModuleFileNameA(NULL, szFilePath, sizeof(szFilePath));
 	std::string exe_file(szFilePath);
 #endif
 	setlocale(LC_ALL, "");
 #ifndef WIN32
 #ifndef __FreeBSD__
 #ifndef __MACH__
 	mallopt(M_CHECK_ACTION, 2);
 	mallopt(M_PERTURB, 0xb);
 #endif
 #endif
 #endif
 #ifndef WIN32
 	if (signal(SIGINT, spectrum_sigint_handler) == SIG_ERR) {
 		std::cout << "SIGINT handler can't be set\n";
 		return -1;
+	}
 	if (signal(SIGTERM, spectrum_sigterm_handler) == SIG_ERR) {
 		std::cout << "SIGTERM handler can't be set\n";
 		return -1;
+	}
 #else
 	if( !SetConsoleCtrlHandler( (PHANDLER_ROUTINE) spectrum_control_handler, TRUE ) )
+	{
 		std::cout << "control handler can't be set\n";
 		return -1;
+	}
 #endif
 	boost::program_options::options_description desc(std::string("Spectrum version: ") + SPECTRUM_VERSION + "\nUsage: spectrum [OPTIONS] <config_file.cfg>\nAllowed options");
 	desc.add_options()
 		("help,h", "help")
 		("no-daemonize,n", "Do not run spectrum as daemon")
 		("no-debug,d", "Create coredumps on crash")
 		("jid,j", boost::program_options::value<std::string>(&jid)->default_value(""), "Specify JID of transport manually")

spectrum_manager/src/CMakeLists.txt

➞

Show inline comments

 cmake_minimum_required(VERSION 2.6)
 FILE(GLOB SRC *.cpp *.c)
 ADD_EXECUTABLE(spectrum2_manager ${SRC} ../../src/config.cpp ../../src/util.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../include/transport/protocol.pb.cc)
 ADD_DEPENDENCIES(spectrum2_manager pb)
 SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_SOURCE_DIR}/../../include/transport/protocol.pb.cc PROPERTIES GENERATED 1)
 target_link_libraries(spectrum2_manager ${SWIFTEN_LIBRARY} ${PROTOBUF_LIBRARIES})
 if(APPLE)
 target_link_libraries(spectrum2_manager ${APPLE_FRAMEWORKS})
 endif()
 INSTALL(TARGETS spectrum2_manager RUNTIME DESTINATION bin)
 INSTALL(FILES
 	spectrum_manager.cfg
 	DESTINATION /etc/spectrum2
+	)

src/CMakeLists.txt

➞

Show inline comments

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

src/admininterface.cpp

➞

Show inline comments

 				for (std::list<User *>::const_iterator u = backend->users.begin(); u != backend->users.end(); u++) {
 					User *user = *u;
 					lst += "   " + user->getJID().toBare().toString();
 					lst += " - non-active for " + boost::lexical_cast<std::string>(now - user->getLastActivity()) + " seconds";
 					lst += "\n";
+				}
+			}
 			id++;
+		}
 		message->setBody(lst);
+	}
 	else if (message->getBody().find("has_online_user") == 0) {
 		User *user = m_userManager->getUser(getArg(message->getBody()));
 		std::cout << getArg(message->getBody()) << "\n";
 		message->setBody(boost::lexical_cast<std::string>(user != NULL));
+	}
 	else if (message->getBody() == "backends_count") {
 		int backends = m_server->getBackendCount();
 		message->setBody(boost::lexical_cast<std::string>(backends));
+	}
 	else if (message->getBody() == "res_memory") {
 		double shared = 0;
 		double rss = 0;
 #ifndef WIN32
 		process_mem_usage(shared, rss);
 #endif
 		const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();
 		BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {
 			rss += backend->res;
+		}
 		message->setBody(boost::lexical_cast<std::string>(rss));
+	}
 	else if (message->getBody() == "shr_memory") {
 		double shared = 0;
 		double rss = 0;
 #ifndef WIN32
 		process_mem_usage(shared, rss);
 #endif
 		const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();
 		BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {
 			shared += backend->shared;
+		}
 		message->setBody(boost::lexical_cast<std::string>(shared));
+	}
 	else if (message->getBody() == "used_memory") {
 		double shared = 0;
 		double rss = 0;
 #ifndef WIN32
 		process_mem_usage(shared, rss);
 #endif
 		rss -= shared;
 		const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();
 		BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {
 			rss += backend->res - backend->shared;
+		}
 		message->setBody(boost::lexical_cast<std::string>(rss));
+	}
 	else if (message->getBody() == "average_memory_per_user") {
 		if (m_userManager->getUserCount() == 0) {
 			message->setBody(boost::lexical_cast<std::string>(0));
+		}
 		else {
 			unsigned long per_user = 0;
 			const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();
 			BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {
 				per_user += (backend->res - backend->init_res);
+			}
 			message->setBody(boost::lexical_cast<std::string>(per_user / m_userManager->getUserCount()));
+		}
+	}
 	else if (message->getBody() == "res_memory_per_backend") {

src/memoryusage.cpp

➞

Show inline comments

@@ @@ -7,62 +7,83 @@ @@
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/memoryusage.h"
 #include <iostream>
 #include <cstring>
 #include <sstream>
 #include <fstream>
 #include <algorithm>
 #include <boost/lexical_cast.hpp>
 #ifndef WIN32
 #include <sys/param.h>
 #else
 #include <windows.h>
 #include <psapi.h>
 #endif
 #ifdef BSD
 #ifdef __MACH__
 #include <mach/mach.h>
 #elif BSD
 #include <sys/types.h>
 #include <sys/sysctl.h>
 #include <sys/param.h>
 #include <sys/sysctl.h>
 #include <sys/user.h>
 #endif
 namespace Transport {
 #ifndef WIN32
 #ifdef BSD
 #ifdef __MACH__
 void process_mem_usage(double& vm_usage, double& resident_set, pid_t pid) {
 	struct task_basic_info t_info;
 	mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;
 	if (KERN_SUCCESS != task_info(mach_task_self(),
                               TASK_BASIC_INFO, (task_info_t)&t_info,
                               &t_info_count)) {
 		vm_usage = 0;
 		resident_set = 0;
     		return;
+	}
 	vm_usage = t_info.virtual_size;
 	resident_set = t_info.resident_size;
+}
 #elif BSD
 void process_mem_usage(double& vm_usage, double& resident_set, pid_t pid) {
 	int mib[4];
 	size_t size;
 	mib[0] = CTL_KERN;
 	mib[1] = KERN_PROC;
 	mib[2] = KERN_PROC_PID;
 	if (pid == 0) {
 		mib[3] = getpid();
+	}
 	else {
 		mib[3] = pid;
+	}
 	struct kinfo_proc proc;
 	size = sizeof(struct kinfo_proc);
 	if (sysctl((int*)mib, 4, &proc, &size, NULL, 0) == -1) {
 		vm_usage = 0;
 		resident_set = 0;
 		return;
+	}
 	// sysctl stores 0 in the size if we can't find the process information.
 	// Set errno to ESRCH which will be translated in NoSuchProcess later on.
 		shared = 0;
 		resident_set = 0;
 		return;
+	}
 	// dummy vars for leading entries in stat that we don't care about
 	//
 	string pid1, comm, state, ppid, pgrp, session, tty_nr;
 	string tpgid, flags, minflt, cminflt, majflt, cmajflt;
 	string utime, stime, cutime, cstime, priority, nice;
 	string O, itrealvalue, starttime;
 	// the two fields we want
 	//
 	unsigned long shared_;
 	long rss;
 	stat_stream >> O >> rss >> shared_; // don't care about the rest
 	long page_size_kb = sysconf(_SC_PAGE_SIZE) / 1024; // in case x86-64 is configured to use 2MB pages
 	shared     = shared_ * page_size_kb;
 	resident_set = rss * page_size_kb;
+}
 #endif /* else BSD */
 #else
 #define PSAPI_VERSION 1
 #define pid_t void*
 	void process_mem_usage(double& shared, double& resident_set, pid_t pid) {
 		PROCESS_MEMORY_COUNTERS_EX pmc;
 		GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc));
 		shared =  (double)pmc.PrivateUsage;
 		resident_set = (double)pmc.WorkingSetSize;
+	}
 #endif /* WIN32 */
+}

src/usermanager.cpp

➞

Show inline comments

@@ @@ -13,50 +13,52 @@ @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/usermanager.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/storagebackend.h"
 #include "transport/conversationmanager.h"
 #include "transport/rostermanager.h"
 #include "transport/userregistry.h"
 #include "transport/logging.h"
 #include "transport/discoitemsresponder.h"
 #include "storageresponder.h"
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Elements/StreamError.h"
 #include "Swiften/Elements/MUCPayload.h"
 #include "Swiften/Elements/ChatState.h"
 #ifndef __FreeBSD__
 #ifndef __MACH__
 #include "malloc.h"
 #endif
 #endif
 // #include "valgrind/memcheck.h"
 namespace Transport {
 DEFINE_LOGGER(logger, "UserManager");
 UserManager::UserManager(Component *component, UserRegistry *userRegistry, DiscoItemsResponder *discoItemsResponder, StorageBackend *storageBackend) {
 	m_cachedUser = NULL;
 	m_onlineBuddies = 0;
 	m_sentToXMPP = 0;
 	m_sentToBackend = 0;
 	m_component = component;
 	m_storageBackend = storageBackend;
 	m_storageResponder = NULL;
 	m_userRegistry = userRegistry;
 	m_discoItemsResponder = discoItemsResponder;
 	if (m_storageBackend) {
 		m_storageResponder = new StorageResponder(component->getIQRouter(), m_storageBackend, this);
 		m_storageResponder->start();
+	}
 	component->onUserPresenceReceived.connect(bind(&UserManager::handlePresence, this, _1));
 	component->onUserDiscoInfoReceived.connect(bind(&UserManager::handleDiscoInfo, this, _1, _2));
 void UserManager::removeUser(User *user, bool onUserBehalf) {
 	m_users.erase(user->getJID().toBare().toString());
 	if (m_cachedUser == user)
 		m_cachedUser = NULL;
 	if (m_component->inServerMode()) {
 		disconnectUser(user->getJID());
+	}
 	else {
 		// User could be disconnected by User::handleDisconnect() method, but
 		// Transport::PresenceOracle could still contain his last presence.
 		// We have to clear all received presences for this user in PresenceOracle.
 		m_component->getPresenceOracle()->clearPresences(user->getJID().toBare());
+	}
 	if (m_storageBackend && onUserBehalf) {
 		m_storageBackend->setUserOnline(user->getUserInfo().id, false);
+	}
 	onUserDestroyed(user);
 	delete user;
 #ifndef WIN32
 #ifndef __FreeBSD__
 #ifndef __MACH__
 	malloc_trim(0);
 #endif
 #endif
 #endif
 // 	VALGRIND_DO_LEAK_CHECK;
+}
 void UserManager::removeAllUsers(bool onUserBehalf) {
 	while(m_users.begin() != m_users.end()) {
 		removeUser((*m_users.begin()).second, onUserBehalf);
+	}
+}
 int UserManager::getUserCount() {
 	return m_users.size();
+}
 void UserManager::handleDiscoInfo(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info) {
 	User *user = getUser(jid.toBare().toString());
 	if (!user) {
 		return;
+	}
 	user->handleDiscoInfo(jid, info);
+}
 void UserManager::handlePresence(Swift::Presence::ref presence) {
 	std::string barejid = presence->getTo().toBare().toString();
 					m_userRegistry->onPasswordInvalid(presence->getFrom());
 					return;
+				}
 				res.password = "";
 				res.uin = presence->getFrom().getNode();
 				res.jid = userkey;
 				while (res.uin.find_last_of("%") != std::string::npos) { // OK
 					res.uin.replace(res.uin.find_last_of("%"), 1, "@"); // OK
+				}
 				if (m_storageBackend) {
 					// store user and getUser again to get user ID.
 					m_storageBackend->setUser(res);
 					registered = m_storageBackend->getUser(userkey, res);
+				}
 				else {
 					registered = true;
+				}
+			}
 			res.password = m_userRegistry->getUserPassword(userkey);
+		}
 		// We allow auto_register feature in gateway-mode. This allows IRC user to register
 		// the transport just by joining the room.
 		if (!m_component->inServerMode()) {
 			if (!registered && (CONFIG_BOOL(m_component->getConfig(), "registration.auto_register") ||
 				!CONFIG_BOOL_DEFAULTED(m_component->getConfig(), "registration.needRegistration", true))) {
 			if (!registered && (CONFIG_BOOL(m_component->getConfig(), "registration.auto_register")
 				/*!CONFIG_BOOL_DEFAULTED(m_component->getConfig(), "registration.needRegistration", true)*/)) {
 				res.password = "";
 				res.jid = userkey;
 				bool isMUC = presence->getPayload<Swift::MUCPayload>() != NULL || *presence->getTo().getNode().c_str() == '#';
 				if (isMUC) {
 					res.uin = presence->getTo().getResource();
+				}
 				else {
 					res.uin = presence->getFrom().toString();
+				}
 				LOG4CXX_INFO(logger, "Auto-registering user " << userkey << " with uin=" << res.uin);
 				if (m_storageBackend) {
 					// store user and getUser again to get user ID.
 					m_storageBackend->setUser(res);
 					registered = m_storageBackend->getUser(userkey, res);
+				}
 				else {
 					registered = true;
+				}
+			}
+		}
 		// Unregistered users are not able to login

0 comments (0 inline, 0 general)