libtransport.git Changeset - 697339dbfa61

Changeset - 697339dbfa61

Parent rev.

Child rev.

[Not reviewed]

Merge

4 18 3

Daniel Henninger - 13 years ago 2012-02-21 16:57:47
daniel@vorpalcloud.org

Merge remote-tracking branch 'upstream/master'

25 files changed with 754 insertions and 491 deletions:

CMakeLists.txt

ChangeLog

backends/CMakeLists.txt

backends/frotz/CMakeLists.txt

backends/libcommuni/CMakeLists.txt

backends/skype/CMakeLists.txt

backends/skype/geventloop.cpp

248

backends/skype/geventloop.h

backends/skype/main.cpp

backends/skype/spectrumeventloop.cpp

backends/skype/spectrumeventloop.h

backends/smstools3/CMakeLists.txt

backends/smstools3/main.cpp

397

cmake_modules/dbusConfig.cmake

include/Swiften/TLS/OpenSSL/OpenSSLServerContext.cpp

spectrum/src/sample.cfg

spectrum/src/sample2.cfg

src/CMakeLists.txt

src/config.cpp

src/mysqlbackend.cpp

src/networkpluginserver.cpp

src/rostermanager.cpp

src/sqlite3backend.cpp

src/usermanager.cpp

src/userregistration.cpp

0 comments (0 inline, 0 general)

CMakeLists.txt

➞

Show inline comments

@@ @@ -29,42 +29,45 @@ find_package(event) @@
 set(Swiften_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(Swiften REQUIRED)
 set(openssl_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(openssl REQUIRED)
 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 thread signals REQUIRED)
 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("-----------------------")
@@ @@ -137,30 +140,39 @@ if (PROTOBUF_FOUND) @@
 	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")
 	include_directories(${LOG4CXX_INCLUDE_DIR})
 else()
 	message(FATAL_ERROR "Logging           : no (install log4cxx-devel)")
 endif()
 if (WIN32)
 ADD_DEFINITIONS(-D_WIN32_WINNT=0x501)
 ADD_DEFINITIONS(-DWIN32_LEAN_AND_MEAN)

ChangeLog

➞

Show inline comments

 Version 2.0.0-beta  (X-X-X):
 	General:
 	* Added PostreSQL support (thanks to Jadestorm).
 	* 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)
 if (NOT WIN32)
 	ADD_SUBDIRECTORY(frotz)
 #	ADD_SUBDIRECTORY(skype)
 	if (${LIBDBUSGLIB_FOUND})
 		ADD_SUBDIRECTORY(skype)
 	endif()
 endif()
 endif()

backends/frotz/CMakeLists.txt

➞

Show inline comments

 cmake_minimum_required(VERSION 2.6)
 ADD_SUBDIRECTORY(dfrotz)
 FILE(GLOB SRC *.c *.cpp)
 ADD_EXECUTABLE(spectrum2_frotz_backend ${SRC})
-target_link_libraries(spectrum2_frotz_backend transport pthread transport-plugin ${Boost_LIBRARIES} ${SWIFTEN_LIBRARY} ${LOG4CXX_LIBRARIES})
 target_link_libraries(spectrum2_frotz_backend transport pthread ${Boost_LIBRARIES} ${SWIFTEN_LIBRARY} ${LOG4CXX_LIBRARIES})
 INSTALL(TARGETS spectrum2_frotz_backend RUNTIME DESTINATION bin)

backends/libcommuni/CMakeLists.txt

➞

Show inline comments

 cmake_minimum_required(VERSION 2.6)
 FILE(GLOB SRC *.cpp)
 FILE(GLOB HEADERS *.h)
 QT4_WRAP_CPP(SRC ${HEADERS})
 ADD_EXECUTABLE(spectrum2_libcommuni_backend ${SRC})
-target_link_libraries(spectrum2_libcommuni_backend ${IRC_LIBRARY} ${QT_LIBRARIES} transport-plugin transport pthread)
 target_link_libraries(spectrum2_libcommuni_backend ${IRC_LIBRARY} ${QT_LIBRARIES} transport pthread)
 INSTALL(TARGETS spectrum2_libcommuni_backend RUNTIME DESTINATION bin)

backends/skype/CMakeLists.txt

➞

Show inline comments

 cmake_minimum_required(VERSION 2.6)
 FILE(GLOB SRC *.cpp)
 include_directories(/usr/include/dbus-1.0/)
 include_directories(/usr/lib/dbus-1.0/include/)
 include_directories(/usr/lib64/dbus-1.0/include/)
 ADD_EXECUTABLE(spectrum2_skype_backend ${SRC})
-target_link_libraries(spectrum2_skype_backend ${GLIB2_LIBRARIES} ${EVENT_LIBRARIES} transport pthread dbus-glib-1 dbus-1 gobject-2.0 transport-plugin)
+target_link_libraries(spectrum2_skype_backend ${GLIB2_LIBRARIES} ${EVENT_LIBRARIES} transport pthread ${LIBDBUSGLIB_LIBRARIES})
 INSTALL(TARGETS spectrum2_skype_backend RUNTIME DESTINATION bin)

backends/skype/geventloop.cpp

➞

Show inline comments

deleted file

backends/skype/geventloop.h

➞

Show inline comments

deleted file

backends/skype/main.cpp

➞

Show inline comments

@@ @@ -3,27 +3,25 @@ @@
 #include "transport/config.h"
 #include "transport/transport.h"
 #include "transport/usermanager.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 "spectrumeventloop.h"
 #include <boost/filesystem.hpp>
 #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 "sys/wait.h"
 #include "sys/signal.h"
 // #include "valgrind/memcheck.h"
 #include "malloc.h"
 #include <dbus-1.0/dbus/dbus-glib-lowlevel.h>
@@ @@ -87,49 +85,56 @@ class Skype { @@
 		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();
 	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);
 			LOG4CXX_INFO(logger,  "Creating account with name '" << name);
+			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 handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 			Skype *skype = m_sessions[user];
 			if (skype) {
 				skype->logout();
@@ @@ -288,31 +293,79 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 		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);
 				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() {
 	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"
@@ @@ -331,113 +384,104 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 									"<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);
 	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;
 			int fd_output;
 	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*/);
 	std::string login_data = std::string(m_username + " " + m_password + "\n");
 	LOG4CXX_INFO(logger,  m_username << ": Login data=" << login_data);
 	write(fd, login_data.c_str(), login_data.size());
 	close(fd);
 	fcntl (fd_output, F_SETFL, O_NONBLOCK);
 	free(db);
 			sleep(2);
 			GError *error = NULL;
 			DBusObjectPathVTable vtable;
 	//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 << ": DBUS Error: " << error->message);
 			g_error_free(error);
 			return;
+		}
+	}
 			if (m_proxy == 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);
 					g_error_free(error);
 	m_timer = g_timeout_add_seconds(1, create_dbus_proxy, this);
+}
 				vtable.message_function = &skype_notify_handler;
 				dbus_connection_register_object_path(dbus_g_connection_get_connection(m_connection), "/com/Skype/Client", &vtable, this);
+			}
 bool Skype::loadSkypeBuddies() {
 //	std::string re = "CONNSTATUS OFFLINE";
 //	while (re == "CONNSTATUS OFFLINE" || re.empty()) {
 //		sleep(1);
 			int counter = 0;
 			std::string re = "CONNSTATUS OFFLINE";
 			while (re == "CONNSTATUS OFFLINE" || re.empty()) {
 				sleep(1);
 	gchar buffer[1024];
 				int bytes_read;
 				bytes_read = read (fd_output, buffer, 1023);
 	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;
+		return FALSE;
+	}
 				re = send_command("NAME Spectrum");
 				if (counter++ > 15)
 					break;
 	std::string re = send_command("NAME Spectrum");
 	if (m_counter++ > 15) {
 		np->handleDisconnected(m_user, 0, "");
 		close(fd_output);
 		logout();
 		return FALSE;
+	}
 	if (re.empty() || re == "CONNSTATUS OFFLINE") {
 		return TRUE;
+	}
 	close(fd_output);
 	if (send_command("PROTOCOL 7") != "PROTOCOL 7") {
 		np->handleDisconnected(m_user, 0, "Skype is not ready");
 		logout();
-				return;
+		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");
@@ @@ -459,45 +503,57 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
+	{
 		//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)
+		{
 			std::string buddy = full_friends_list[i];
 			if (buddy[0] == ',') {
 				buddy.erase(buddy.begin());
+			}
 					std::cout << "BUDDY '" << buddy << "'\n";
 			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];
 						i++;
+			}
 			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");
 		kill((int) m_pid, SIGTERM);
 		m_pid = 0;
+	}
 		LOG4CXX_INFO(logger, "Diconnecting from spectrum2 server");
 		exit(errno);
+	}
 	std::string d = std::string(buffer, n);
 	np->handleDataRead(d);
 	return TRUE;
+}
 static void io_destroy(gpointer data) {
 	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";
@@ @@ -762,27 +822,28 @@ int main(int argc, char **argv) { @@
 			p.load(istream);
 			p.setProperty("pid", boost::lexical_cast<std::string>(getpid()));
 			log4cxx::PropertyConfigurator::configure(p);
+		}
 // 		initPurple(config);
 		g_type_init();
 		m_sock = create_socket(host, port);
 		g_set_printerr_handler(log_glib_error);
 	GIOChannel *channel;
-	GIOCondition cond = (GIOCondition) READ_COND;
+	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);
+		}
+	}

backends/skype/spectrumeventloop.cpp

➞

Show inline comments

deleted file

backends/skype/spectrumeventloop.h

➞

Show inline comments

deleted file

backends/smstools3/CMakeLists.txt

➞

Show inline comments

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

backends/smstools3/main.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
  * 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/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 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;
 			t.seekg(0, std::ios::end);
 			str.reserve(t.tellg());
 			t.seekg(0, std::ios::beg);
 			str.assign((std::istreambuf_iterator<char>(t)), std::istreambuf_iterator<char>());
 			std::string from = "";
 			std::string msg = "";
 			while(str.find("\n") != std::string::npos) {
 				std::string line = str.substr(0, str.find("\n"));
 				if (line.find("From: ") == 0) {
 					from = line.substr(strlen("From: "));
+				}
 				else if (line.empty()) {
 					msg = str.substr(1);
 					break;
+				}
 				str = str.substr(str.find("\n") + 1);
+			}
 			std::list<BuddyInfo> roster;
 			storageBackend->getBuddies(m_internalUser, roster);
 			std::string to;
 			BOOST_FOREACH(BuddyInfo &b, roster) {
 				if (b.legacyName == from) {
 					to = b.alias;
+				}
+			}
 			if (to.empty()) {
 				LOG4CXX_WARN(logger, "Received SMS from " << from << ", but this number is not associated with any XMPP user.");
+			}
 			LOG4CXX_INFO(logger, "Forwarding SMS from " << from << " to " << to << ".");
 			handleMessage(to, from, msg);
+		}
 		void handleSMSDir() {
 			std::string dir = "/var/spool/sms/incoming/";
 			if (config->getUnregistered().find("backend.incoming_dir") != config->getUnregistered().end()) {
 				dir = config->getUnregistered().find("backend.incoming_dir")->second;
+			}
 			LOG4CXX_INFO(logger, "Checking directory " << dir << " for incoming SMS.");
 			path p(dir);
 			directory_iterator end_itr;
 			for (directory_iterator itr(p); itr != end_itr; ++itr) {
 				try {
 					if (is_regular(itr->path())) {
 						handleSMS(itr->path().string());
 						remove(itr->path());
+					}
+				}
 				catch (const filesystem_error& ex) {
 					LOG4CXX_ERROR(logger, "Error when removing the SMS: " << ex.what() << ".");
+				}
+			}
 			m_timer->start();
+		}
 		void sendSMS(const std::string &to, const std::string &msg) {
 			// TODO: Probably
 			std::string data = "To: " + to + "\n";
 			data += "\n";
 			data += msg;
 			// generate random string here...
 			std::string bucket = "abcdefghijklmnopqrstuvwxyz";
 			std::string uuid;
 			for (int i = 0; i < 10; i++) {
 				uuid += bucket[rand() % bucket.size()];
+			}
 			std::ofstream myfile;
 			myfile.open (std::string("/var/spool/sms/outgoing/spectrum." + uuid).c_str());
 			myfile << data;
 			myfile.close();
+		}
 		void sendData(const std::string &string) {
 			m_conn->write(Swift::createSafeByteArray(string));
+		}
 		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) {
 			UserInfo info;
 			if (!storageBackend->getUser(user, info)) {
 				handleDisconnected(user, 0, "Not registered user.");
 				return;
+			}
 			std::list<BuddyInfo> roster;
 			storageBackend->getBuddies(info.id, roster);
 			// Send available presence to every number in the roster.
 			BOOST_FOREACH(BuddyInfo &b, roster) {
 				handleBuddyChanged(user, b.legacyName, b.alias, b.groups, pbnetwork::STATUS_ONLINE);
+			}
 			np->handleConnected(user);
+		}
 		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 = "") {
 			// Remove trailing +, because smstools doesn't use it in "From: " field for received messages.
 			std::string n = legacyName;
 			if (n.find("+") == 0) {
 				n = n.substr(1);
+			}
 			// Create GSM Number - XMPP user pair to match the potential response and send it to the proper JID.
 			BuddyInfo info;
 			info.legacyName = n;
 			info.alias = user;
 			info.id = -1;
 			info.subscription = "both";
 			info.flags = 0;
 			storageBackend->addBuddy(m_internalUser, info);
 			LOG4CXX_INFO(logger, "Sending SMS from " << user << " to " << n << ".");
 			sendSMS(n, message);
+		}
 		void handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &password) {
+		}
 		void handleLeaveRoomRequest(const std::string &user, const std::string &room) {
+		}
 		void 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;
+	}
 // 	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);
+	}
 #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;
+		}
+	}
 #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;
+	}
 	Swift::SimpleEventLoop eventLoop;
 	loop_ = &eventLoop;
 	np = new SMSNetworkPlugin(&config, &eventLoop, host, port);
 	loop_->run();
 	return 0;
+}

cmake_modules/dbusConfig.cmake

➞

Show inline comments

@@ new file 100644 @@
 # - Try to find LIBDBUS GLIB Bindings
 # Find LIBDBUSGLIB headers, libraries and the answer to all questions.
+#
 #  LIBDBUSGLIB_FOUND               True if libdbus-glib got found
 #  LIBDBUSGLIB_INCLUDE_DIRS        Location of libdbus-glib headers
 #  LIBDBUSGLIB_LIBRARIES           List of libraries to use libdbus-glib
+#
 # Copyright (c) 2008 Bjoern Ricks <bjoern.ricks@googlemail.com>
+#
 #  Redistribution and use is allowed according to the terms of the New
 #  BSD license.
 #  For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+#
 INCLUDE( FindPkgConfig )
 IF ( LibDbusGlib_FIND_REQUIRED )
 	SET( _pkgconfig_REQUIRED "REQUIRED" )
 ELSE( LibDbusGlib_FIND_REQUIRED )
 	SET( _pkgconfig_REQUIRED "" )
 ENDIF ( LibDbusGlib_FIND_REQUIRED )
 IF ( LIBDBUSGLIB_MIN_VERSION )
 	PKG_SEARCH_MODULE( LIBDBUSGLIB ${_pkgconfig_REQUIRED} dbus-glib-1>=${LIBDBUSGLIB_MIN_VERSION} )
 ELSE ( LIBDBUSGLIB_MIN_VERSION )
 	PKG_SEARCH_MODULE( LIBDBUSGLIB ${_pkgconfig_REQUIRED} dbus-glib-1 )
 ENDIF ( LIBDBUSGLIB_MIN_VERSION )
 IF( NOT LIBDBUSGLIB_FOUND AND NOT PKG_CONFIG_FOUND )
 	FIND_PATH( LIBDBUSGLIB_INCLUDE_DIRS dbus/dbus-glib.h PATH_SUFFIXES dbus-1.0 dbus )
 	FIND_LIBRARY( LIBDBUSGLIB_LIBRARIES dbus-glib dbus-glib-1)
 	# Report results
 	IF ( LIBDBUSGLIB_LIBRARIES AND LIBDBUSGLIB_INCLUDE_DIRS )
 		SET( LIBDBUSGLIB_FOUND 1 )
 		IF ( NOT LIBDBUSGLIB_FIND_QUIETLY )
 			MESSAGE( STATUS "Found libdbus-glib: ${LIBDBUSGLIB_LIBRARIES} ${LIBDBUSGLIB_INCLUDE_DIRS}" )
 		ENDIF ( NOT LIBDBUSGLIB_FIND_QUIETLY )
 	ELSE ( LIBDBUSGLIB_LIBRARIES AND LIBDBUSGLIB_INCLUDE_DIRS )
 		IF ( LIBDBUSGLIB_FIND_REQUIRED )
 			MESSAGE( SEND_ERROR "Could NOT find libdbus-glib" )
 		ELSE ( LIBDBUSGLIB_FIND_REQUIRED )
 			IF ( NOT LIBDBUSGLIB_FIND_QUIETLY )
 				MESSAGE( STATUS "Could NOT find libdbus-glib" )
 			ENDIF ( NOT LIBDBUSGLIB_FIND_QUIETLY )
 		ENDIF ( LIBDBUSGLIB_FIND_REQUIRED )
 	ENDIF ( LIBDBUSGLIB_LIBRARIES AND LIBDBUSGLIB_INCLUDE_DIRS )
 else()
 	MESSAGE( STATUS "Found libdbus-glib: ${LIBDBUSGLIB_LIBRARIES} ${LIBDBUSGLIB_INCLUDE_DIRS}" )
 ENDIF()
 MARK_AS_ADVANCED( LIBDBUSGLIB_LIBRARIES LIBDBUSGLIB_INCLUDE_DIRS )
@@ \ No newline at end of file @@

include/Swiften/TLS/OpenSSL/OpenSSLServerContext.cpp

➞

Show inline comments

@@ @@ -5,24 +5,31 @@ @@
  */
 #include "Swiften/Base/Platform.h"
 #ifdef SWIFTEN_PLATFORM_WINDOWS
 #include <windows.h>
 #include <wincrypt.h>
 #endif
 #include <vector>
 #include <openssl/err.h>
 #include <openssl/pkcs12.h>
 #include "log4cxx/logger.h"
 #include "log4cxx/consoleappender.h"
 #include "log4cxx/patternlayout.h"
 #include "log4cxx/propertyconfigurator.h"
 using namespace log4cxx;
 static LoggerPtr logger = Logger::getLogger("OpenSSLServerContext");
 #include "Swiften/TLS/OpenSSL/OpenSSLServerContext.h"
 #include "Swiften/TLS/OpenSSL/OpenSSLCertificate.h"
 #include "Swiften/TLS/PKCS12Certificate.h"
 #ifndef _MSC_VER
 #pragma GCC diagnostic ignored "-Wold-style-cast"
 #endif
 namespace Swift {
 static const int MAX_FINISHED_SIZE = 4096;
 static const int SSL_READ_BUFFERSIZE = 8192;
 		data.resize(SSL_READ_BUFFERSIZE);
 		ret = SSL_read(handle_, vecptr(data), data.size());
 	}
 	if (ret < 0 && SSL_get_error(handle_, ret) != SSL_ERROR_WANT_READ) {
 		state_ = Error;
 // 		std::cout << "AAAAAAAA 3\n";
 		onError();
 	}
 }
 bool OpenSSLServerContext::setServerCertificate(const PKCS12Certificate& certificate) {
 	if (certificate.isNull()) {
-// 		std::cout << "error 1\n";
+		LOG4CXX_ERROR(logger, "TLS WILL NOT WORK: Certificate can't be loaded.");
 		return false;
 	}
 	// Create a PKCS12 structure
 	BIO* bio = BIO_new(BIO_s_mem());
 	BIO_write(bio, vecptr(certificate.getData()), certificate.getData().size());
 	boost::shared_ptr<PKCS12> pkcs12(d2i_PKCS12_bio(bio, NULL), PKCS12_free);
 	BIO_free(bio);
 	if (!pkcs12) {
-// 		std::cout << "error 2\n";
+		LOG4CXX_ERROR(logger, "TLS WILL NOT WORK: Certificate is not in PKCS#12 format.");
 		return false;
 	}
 	// Parse PKCS12
 	X509 *certPtr = 0;
 	EVP_PKEY* privateKeyPtr = 0;
 	STACK_OF(X509)* caCertsPtr = 0;
 	int result = PKCS12_parse(pkcs12.get(), reinterpret_cast<const char*>(vecptr(certificate.getPassword())), &privateKeyPtr, &certPtr, &caCertsPtr);
 	if (result != 1) {
-// 		std::cout << "error 3\n";
+		LOG4CXX_ERROR(logger, "TLS WILL NOT WORK: Certificate is not in PKCS#12 format.");
 		return false;
 	}
 	boost::shared_ptr<X509> cert(certPtr, X509_free);
 	boost::shared_ptr<EVP_PKEY> privateKey(privateKeyPtr, EVP_PKEY_free);
 	boost::shared_ptr<STACK_OF(X509)> caCerts(caCertsPtr, freeX509Stack);
 	// Use the key & certificates
 	if (SSL_CTX_use_certificate(context_, cert.get()) != 1) {
-// 		std::cout << "error 4\n";
+		LOG4CXX_ERROR(logger, "TLS WILL NOT WORK: Can't use this certificate");
 		return false;
 	}
 	if (SSL_CTX_use_PrivateKey(context_, privateKey.get()) != 1) {
-// 		std::cout << "error 5\n";
+		LOG4CXX_ERROR(logger, "TLS WILL NOT WORK: Can't use this private key");
 		return false;
 	}
 	return true;
 }
 Certificate::ref OpenSSLServerContext::getPeerCertificate() const {
 	boost::shared_ptr<X509> x509Cert(SSL_get_peer_certificate(handle_), X509_free);
 	if (x509Cert) {
 		return Certificate::ref(new OpenSSLCertificate(x509Cert));
 	}
 	else {
 		return Certificate::ref();

spectrum/src/sample.cfg

➞

Show inline comments

@@ @@ -4,33 +4,41 @@ password = secret @@
 server = 127.0.0.1
 port = 5222
 server_mode = 1
 backend_host=localhost
 pidfile=./test.pid
 # < this option doesn't work yet
 backend_port=10001
 admin_username=admin
 admin_password=test
 #cert=server.pfx #patch to PKCS#12 certificate
 #cert_password=test #password to that certificate if any
 users_per_backend=10
 backend=/home/hanzz/code/libtransport/backends/libpurple/spectrum2_libpurple_backend
 #backend=/home/hanzz/code/libtransport/backends/libpurple/spectrum2_libpurple_backend
 backend=/home/hanzz/code/libtransport/backends/smstools3/spectrum2_smstools3_backend
 #backend=/usr/bin/mono /home/hanzz/code/networkplugin-csharp/msnp-sharp-backend/bin/Debug/msnp-sharp-backend.exe
 #backend=/home/hanzz/code/libtransport/backends/frotz/spectrum2_frotz_backend
 #backend=/home/hanzz/code/libtransport/backends/libircclient-qt/spectrum2_libircclient-qt_backend
 #protocol=prpl-msn
 protocol=any
 #protocol=prpl-icq
 irc_server=irc.freenode.org
 [backend]
 #default_avatar=catmelonhead.jpg
 #no_vcard_fetch=true
 incoming_dir=/var/spool/sms/incoming
 [logging]
 #config=logging.cfg # log4cxx/log4j logging configuration file
 #backend_config=/home/hanzz/code/libtransport/spectrum/src/backend-logging.cfg # log4cxx/log4j logging configuration file for backends
 [database]
 type = none # or "none" without database backend
 database = test.sql
 prefix=icq
 #type = sqlite3 # or "none" without database backend
 #database = test.sql
 #prefix=icq
 type = mysql # or "none" without database backend.......................................................................................................................
 database = test
 prefix=
 user=root
 password=yourrootsqlpassword
 #encryption_key=hanzzik

spectrum/src/sample2.cfg

➞

Show inline comments

@@ @@ -32,25 +32,25 @@ backend_host = localhost @@
 #cert=
 # Certificate password if any.
 #cert_password=
 # Number of users per one legacy network backend.
 users_per_backend=10
 # Full path to backend binary.
 backend=/usr/bin/spectrum2_libpurple_backend
 #backend=/usr/bin/spectrum2_libircclient-qt_backend
 # For skype:
-#backend=/usr/bin/setsid /usr/bin/xvfb-run -n BACKEND_ID -s "-screen 0 10x10x8" -f /tmp/x-skype-gw /usr/bin/spectrum2_skype_backend
 #backend=/usr/bin/xvfb-run -n BACKEND_ID -s "-screen 0 10x10x8" -f /tmp/x-skype-gw /usr/bin/spectrum2_skype_backend
 # Libpurple protocol-id for spectrum_libpurple_backend
 protocol=prpl-jabber
 #protocol=prpl-msn
 #protocol=prpl-icq
 # prpl-any means that user sets his protocol in his JID which has to be
 # in following format: protocol.username@domain.tld
 # So for example: prpl-jabber.hanzz.k%gmail.com@domain.tld
 #protocol=prpl-any
 [identity]
@@ @@ -86,12 +86,29 @@ type = none @@
 # Port.
 #port = 0
 # User.
 #user = spectrum
 # Paasword.
 #password = secret
 # Prefix used for tables
 #prefix = jabber_
 [registration]
 # Enable public registrations
 enable_public_registration=1
 # Text to display upon user registration form
 #username_label=Jabber JID (e.g. user@server.tld):
 #instructions=Enter your remote jabber JID and password as well as your local username and password
 # If True a local jabber account on <local_account_server> is needed
 # for transport registration, the idea is to enable public registration
 # from other servers, but only for users, who have already local accounts
 #require_local_account=1
 #local_username_label=Local username (without @server.tld):
 #local_account_server=localhost
 #local_account_server_timeout=10000

src/CMakeLists.txt

➞

Show inline comments

@@ @@ -11,40 +11,40 @@ if (CPPUNIT_FOUND) @@
 	target_link_libraries(libtransport_test transport ${CPPUNIT_LIBRARIES} ${Boost_LIBRARIES})
 endif()
 if (NOT WIN32)
 include_directories(${POPT_INCLUDE_DIR})
 endif()
 # SOURCE_GROUP(headers FILES ${HEADERS})
 if (PROTOBUF_FOUND)
 	if (CMAKE_COMPILER_IS_GNUCXX)
-		ADD_LIBRARY(transport SHARED ${HEADERS} ${SRC} ${SWIFTEN_SRC} ${CMAKE_CURRENT_BINARY_DIR}/../include/transport/protocol.pb.cc)
 		ADD_LIBRARY(transport SHARED ${HEADERS} ${SRC} ${SWIFTEN_SRC})
 	else(CMAKE_COMPILER_IS_GNUCXX)
-		ADD_LIBRARY(transport STATIC ${HEADERS} ${SRC} ${SWIFTEN_SRC} ${CMAKE_CURRENT_BINARY_DIR}/../include/transport/protocol.pb.cc)
 		ADD_LIBRARY(transport STATIC ${HEADERS} ${SRC} ${SWIFTEN_SRC})
 	endif(CMAKE_COMPILER_IS_GNUCXX)
 	SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/../include/transport/protocol.pb.cc PROPERTIES GENERATED 1)
+#	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)
 	ADD_DEFINITIONS(-fPIC)
 endif()
 if (WIN32)
 	TARGET_LINK_LIBRARIES(transport ${PQXX_LIBRARY} ${PQ_LIBRARY} ${SQLITE3_LIBRARIES} ${MYSQL_LIBRARIES} ${SWIFTEN_LIBRARY} ${PROTOBUF_LIBRARIES} ${LOG4CXX_LIBRARIES})
+	TARGET_LINK_LIBRARIES(transport transport-plugin ${PQXX_LIBRARY} ${PQ_LIBRARY} ${SQLITE3_LIBRARIES} ${MYSQL_LIBRARIES} ${SWIFTEN_LIBRARY} ${PROTOBUF_LIBRARIES} ${LOG4CXX_LIBRARIES})
 else (WIN32)
 	TARGET_LINK_LIBRARIES(transport ${PQXX_LIBRARY} ${PQ_LIBRARY} ${SQLITE3_LIBRARIES} ${MYSQL_LIBRARIES} ${SWIFTEN_LIBRARY} ${PROTOBUF_LIBRARIES} ${LOG4CXX_LIBRARIES} ${POPT_LIBRARY})
+	TARGET_LINK_LIBRARIES(transport transport-plugin ${PQXX_LIBRARY} ${PQ_LIBRARY} ${SQLITE3_LIBRARIES} ${MYSQL_LIBRARIES} ${SWIFTEN_LIBRARY} ${PROTOBUF_LIBRARIES} ${LOG4CXX_LIBRARIES} ${POPT_LIBRARY})
 endif(WIN32)
 SET_TARGET_PROPERTIES(transport PROPERTIES
       VERSION ${TRANSPORT_VERSION} SOVERSION ${TRANSPORT_VERSION}
+)
 INSTALL(TARGETS transport LIBRARY DESTINATION lib ARCHIVE DESTINATION lib COMPONENT libraries)
 #CONFIGURE_FILE(transport.pc.in "${CMAKE_CURRENT_BINARY_DIR}/transport.pc")
 #INSTALL(FILES "${CMAKE_CURRENT_BINARY_DIR}/transport.pc" DESTINATION lib/pkgconfig)

src/config.cpp

➞

Show inline comments

 		("service.more_resources", value<bool>()->default_value(false), "Allow more resources to be connected in server mode at the same time.")
 		("service.enable_privacy_lists", value<bool>()->default_value(true), "")
 		("vhosts.vhost", value<std::vector<std::string> >()->multitoken(), "")
 		("identity.name", value<std::string>()->default_value("Spectrum 2 Transport"), "Name showed in service discovery.")
 		("identity.category", value<std::string>()->default_value("gateway"), "Disco#info identity category. 'gateway' by default.")
 		("identity.type", value<std::string>()->default_value(""), "Type of transport ('icq','msn','gg','irc', ...)")
 		("registration.enable_public_registration", value<bool>()->default_value(true), "True if users should be able to register.")
 		("registration.language", value<std::string>()->default_value("en"), "Default language for registration form")
 		("registration.instructions", value<std::string>()->default_value("Enter your legacy network username and password."), "Instructions showed to user in registration form")
 		("registration.username_label", value<std::string>()->default_value("Legacy network username:"), "Label for username field")
 		("registration.username_mask", value<std::string>()->default_value(""), "Username mask")
 		("registration.encoding", value<std::string>()->default_value("utf8"), "Default encoding in registration form")
 		("registration.require_local_account", value<bool>()->default_value(false), "True if users have to have a local account to register to this transport from remote servers.")
 		("registration.local_username_label", value<std::string>()->default_value("Local username:"), "Label for local usernme field")
 		("registration.local_account_server", value<std::string>()->default_value("localhost"), "The server on which the local accounts will be checked for validity")
 		("registration.local_account_server_timeout", value<int>()->default_value(10000), "Timeout when checking local user on local_account_server (msecs)")
 		("database.type", value<std::string>()->default_value("none"), "Database type.")
 		("database.database", value<std::string>()->default_value(""), "Database used to store data")
+		("database.database", value<std::string>()->default_value("/var/lib/spectrum2/$jid/database.sql"), "Database used to store data")
 		("database.server", value<std::string>()->default_value("localhost"), "Database server.")
 		("database.user", value<std::string>()->default_value(""), "Database user.")
 		("database.password", value<std::string>()->default_value(""), "Database Password.")
 		("database.port", value<int>()->default_value(0), "Database port.")
 		("database.prefix", value<std::string>()->default_value(""), "Prefix of tables in database")
 		("database.encryption_key", value<std::string>()->default_value(""), "Encryption key.")
 		("logging.config", value<std::string>()->default_value(""), "Path to log4cxx config file which is used for Spectrum 2 instance")
 		("logging.backend_config", value<std::string>()->default_value(""), "Path to log4cxx config file which is used for backends")
 		("backend.default_avatar", value<std::string>()->default_value(""), "Full path to default avatar")
 		("backend.avatars_directory", value<std::string>()->default_value(""), "Path to directory with avatars")
 		("backend.no_vcard_fetch", value<bool>()->default_value(false), "True if VCards for buddies should not be fetched. Only avatars will be forwarded.")
+	;
 	parsed_options parsed = parse_config_file(ifs, opts, true);
 	bool found_working = false;
 	bool found_pidfile = false;
 	bool found_backend_port = false;
 	bool found_database = false;
 	std::string jid = "";
 	BOOST_FOREACH(option &opt, parsed.options) {
 		if (opt.string_key == "service.jid") {
 			if (_jid.empty()) {
 				jid = opt.value[0];
+			}
 			else {
 				opt.value[0] = _jid;
 				jid = _jid;
+			}
+		}
 		else if (opt.string_key == "service.backend_port") {
 			found_backend_port = true;
 			if (opt.value[0] == "0") {
 				opt.value[0] = boost::lexical_cast<std::string>(Util::getRandomPort(_jid.empty() ? jid : _jid));
+			}
+		}
 		else if (opt.string_key == "service.working_dir") {
 			found_working = true;
+		}
 		else if (opt.string_key == "service.pidfile") {
 			found_pidfile = true;
+		}
 		else if (opt.string_key == "database.database") {
 			found_database = true;
+		}
+	}
 	if (!found_working) {
 		std::vector<std::string> value;
 		value.push_back("/var/lib/spectrum2/$jid");
 		parsed.options.push_back(boost::program_options::basic_option<char>("service.working_dir", value));
+	}
 	if (!found_pidfile) {
 		std::vector<std::string> value;
 		value.push_back("/var/run/spectrum2/$jid.pid");
 		parsed.options.push_back(boost::program_options::basic_option<char>("service.pidfile", value));
+	}
 	if (!found_backend_port) {
 		std::vector<std::string> value;
 		std::string p = boost::lexical_cast<std::string>(Util::getRandomPort(_jid.empty() ? jid : _jid));
 		value.push_back(p);
 		parsed.options.push_back(boost::program_options::basic_option<char>("service.backend_port", value));
+	}
 	if (!found_database) {
 		std::vector<std::string> value;
 		value.push_back("/var/lib/spectrum2/$jid/database.sql");
 		parsed.options.push_back(boost::program_options::basic_option<char>("database.database", value));
+	}
 	BOOST_FOREACH(option &opt, parsed.options) {
 		if (opt.unregistered) {
 			m_unregistered[opt.string_key] = opt.value[0];
+		}
 		else if (opt.value[0].find("$jid") != std::string::npos) {
 			boost::replace_all(opt.value[0], "$jid", jid);
+		}
+	}
 	store(parsed, m_variables);
 	notify(m_variables);

src/mysqlbackend.cpp

➞

Show inline comments

 long MySQLBackend::addBuddy(long userId, const BuddyInfo &buddyInfo) {
 // 	"INSERT INTO " + m_prefix + "buddies (user_id, uin, subscription, groups, nickname, flags) VALUES (?, ?, ?, ?, ?, ?)"
 	std::string groups = Util::serializeGroups(buddyInfo.groups);
 	*m_addBuddy << userId << buddyInfo.legacyName << buddyInfo.subscription;
 	*m_addBuddy << groups;
 	*m_addBuddy << buddyInfo.alias << buddyInfo.flags;
 	EXEC(m_addBuddy, addBuddy(userId, buddyInfo));
 	long id = (long) mysql_insert_id(&m_conn);
 // 	INSERT OR REPLACE INTO " + m_prefix + "buddies_settings (user_id, buddy_id, var, type, value) VALUES (?, ?, ?, ?, ?)
 	if (!buddyInfo.settings.find("icon_hash")->second.s.empty()) {
+	if (buddyInfo.settings.find("icon_hash") != buddyInfo.settings.end() && !buddyInfo.settings.find("icon_hash")->second.s.empty()) {
 		*m_updateBuddySetting << userId << id << buddyInfo.settings.find("icon_hash")->first << (int) TYPE_STRING << buddyInfo.settings.find("icon_hash")->second.s << buddyInfo.settings.find("icon_hash")->second.s;
 		EXEC(m_updateBuddySetting, addBuddy(userId, buddyInfo));
+	}
 	return id;
+}
 void MySQLBackend::updateBuddy(long userId, const BuddyInfo &buddyInfo) {
 // 	"UPDATE " + m_prefix + "buddies SET groups=?, nickname=?, flags=?, subscription=? WHERE user_id=? AND uin=?"
 	std::string groups = Util::serializeGroups(buddyInfo.groups);
 	*m_updateBuddy << groups;
 	*m_updateBuddy << buddyInfo.alias << buddyInfo.flags << buddyInfo.subscription;
@@ @@ -588,31 +588,35 @@ bool MySQLBackend::removeUser(long id) { @@
 void MySQLBackend::getUserSetting(long id, const std::string &variable, int &type, std::string &value) {
 // 	"SELECT type, value FROM " + m_prefix + "users_settings WHERE user_id=? AND var=?"
 	*m_getUserSetting << id << variable;
 	EXEC(m_getUserSetting, getUserSetting(id, variable, type, value));
 	if (m_getUserSetting->fetch() != 0) {
 // 		"INSERT INTO " + m_prefix + "users_settings (user_id, var, type, value) VALUES (?,?,?,?)"
 		*m_setUserSetting << id << variable << type << value;
 		EXEC(m_setUserSetting, getUserSetting(id, variable, type, value));
+	}
 	else {
 		*m_getUserSetting >> type >> value;
+	}
 	while (m_getUserSetting->fetch() == 0) {
+	}
+}
 void MySQLBackend::updateUserSetting(long id, const std::string &variable, const std::string &value) {
 // 	"UPDATE " + m_prefix + "users_settings SET value=? WHERE user_id=? AND var=?"
 	*m_updateUserSetting << value << id << variable;
 	EXEC(m_updateUserSetting, updateUserSetting(id, variable, value));
+}
 void MySQLBackend::beginTransaction() {
 	exec("START TRANSACTION;");
+	//exec("START TRANSACTION;");
+}
 void MySQLBackend::commitTransaction() {
 	exec("COMMIT;");
+	//exec("COMMIT;");
+}
+}
 #endif

src/networkpluginserver.cpp

➞

Show inline comments

 	return 0;
 #else
 	// Create array of char * from string using -lpopt library
 	char *p = (char *) malloc(path.size() + 1);
 	strcpy(p, path.c_str());
 	int argc;
 	char **argv;
 	poptParseArgvString(p, &argc, (const char ***) &argv);
 	// fork and exec
 	pid_t pid = fork();
 	if ( pid == 0 ) {
 		setsid();
 		// child process
 		exit(execv(argv[0], argv));
 	} else if ( pid < 0 ) {
 		// fork failed
+	}
 	free(p);
 	return (unsigned long) pid;
 #endif
+}
 #ifndef _WIN32
 static void SigCatcher(int n) {
 	pid_t result;
 	int status;
 	// Read exit code from all children to not have zombies arround
 	// WARNING: Do not put LOG4CXX_ here, because it can lead to deadlock
-	while ((result = waitpid(0, &status, WNOHANG)) > 0) {
+	while ((result = waitpid(-1, &status, WNOHANG)) > 0) {
 		if (result != 0) {
 			if (WIFEXITED(status)) {
 				if (WEXITSTATUS(status) != 0) {
 // 					LOG4CXX_ERROR(logger, "Backend can not be started, exit_code=" << WEXITSTATUS(status));
+				}
+			}
 			else {
 // 				LOG4CXX_ERROR(logger, "Backend can not be started");
+			}
+		}
+	}
+}
 	m_server = component->getNetworkFactories()->getConnectionServerFactory()->createConnectionServer(Swift::HostAddress(CONFIG_STRING(m_config, "service.backend_host")), boost::lexical_cast<int>(CONFIG_STRING(m_config, "service.backend_port")));
 	m_server->onNewConnection.connect(boost::bind(&NetworkPluginServer::handleNewClientConnection, this, _1));
 	m_server->start();
 	LOG4CXX_INFO(logger, "Listening on host " << CONFIG_STRING(m_config, "service.backend_host") << " port " << CONFIG_STRING(m_config, "service.backend_port"));
 #ifndef _WIN32
 	signal(SIGCHLD, SigCatcher);
 #endif
 	exec_(CONFIG_STRING(m_config, "service.backend"), CONFIG_STRING(m_config, "service.backend_host").c_str(), CONFIG_STRING(m_config, "service.backend_port").c_str(), m_config->getConfigFile().c_str());
 	LOG4CXX_INFO(logger, "Backend should now connect to Spectrum2 instance. Spectrum2 won't accept any connection before backend connects");
+}
 NetworkPluginServer::~NetworkPluginServer() {
 	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {
 		LOG4CXX_INFO(logger, "Stopping backend " << *it);
 		std::string message;
 		pbnetwork::WrapperMessage wrap;
 		wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_EXIT);
 		wrap.SerializeToString(&message);
 		Backend *c = (Backend *) *it;
 		send(c->connection, message);

src/rostermanager.cpp

➞

Show inline comments

@@ @@ -276,26 +276,26 @@ void RosterManager::sendRIE() { @@
+	}
 	boost::shared_ptr<Swift::GenericRequest<Swift::RosterItemExchangePayload> > request(new Swift::GenericRequest<Swift::RosterItemExchangePayload>(Swift::IQ::Set, jidWithRIE, payload, m_component->getIQRouter()));
 	request->send();
+}
 void RosterManager::handleSubscription(Swift::Presence::ref presence) {
 	std::string legacyName = Buddy::JIDToLegacyName(presence->getTo());
 	// For server mode the subscription changes are handler in rosterresponder.cpp
 	// using roster pushes.
 	if (m_component->inServerMode()) {
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo(presence->getFrom());
 		response->setFrom(presence->getTo());
 		response->setTo(presence->getFrom().toBare());
 		response->setFrom(presence->getTo().toBare());
 		Buddy *buddy = getBuddy(Buddy::JIDToLegacyName(presence->getTo()));
 		if (buddy) {
 			LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Subscription received and buddy " << Buddy::JIDToLegacyName(presence->getTo()) << " is already there => answering");
 			switch (presence->getType()) {
 				case Swift::Presence::Subscribe:
 					onBuddyAdded(buddy);
 					response->setType(Swift::Presence::Subscribed);
 					break;
 				case Swift::Presence::Unsubscribe:
 					onBuddyRemoved(buddy);
 					response->setType(Swift::Presence::Unsubscribed);
 					break;
 					response->setType(Swift::Presence::Unsubscribed);
 					break;
 				default:
 					return;
+			}
 			m_component->getStanzaChannel()->sendPresence(response);
+		}
+	}
 	else {
 		Swift::Presence::ref response = Swift::Presence::create();
 		Swift::Presence::ref currentPresence;
 		response->setTo(presence->getFrom().toBare());
-		response->setFrom(presence->getTo().toBare().toString() + "/bot");
 		response->setFrom(presence->getTo().toBare());
 		Buddy *buddy = getBuddy(Buddy::JIDToLegacyName(presence->getTo()));
 		if (buddy) {
 			switch (presence->getType()) {
 				// buddy is already there, so nothing to do, just answer
 				case Swift::Presence::Subscribe:
 					onBuddyAdded(buddy);
 					response->setType(Swift::Presence::Subscribed);
 					currentPresence = buddy->generatePresenceStanza(255);
 					if (currentPresence) {
 						currentPresence->setTo(presence->getFrom());
 						m_component->getStanzaChannel()->sendPresence(currentPresence);

src/sqlite3backend.cpp

➞

Show inline comments

@@ @@ -102,24 +102,26 @@ SQLite3Backend::~SQLite3Backend(){ @@
 		FINALIZE_STMT(m_getOnlineUsers);
 		sqlite3_close(m_db);
+	}
+}
 bool SQLite3Backend::connect() {
 	LOG4CXX_INFO(logger, "Opening database " << CONFIG_STRING(m_config, "database.database"));
 	if (sqlite3_open(CONFIG_STRING(m_config, "database.database").c_str(), &m_db)) {
 		sqlite3_close(m_db);
 		return false;
+	}
 	sqlite3_busy_timeout(m_db, 1500);
 	if (createDatabase() == false)
 		return false;
 	PREP_STMT(m_setUser, "INSERT OR REPLACE INTO " + m_prefix + "users (jid, uin, password, language, encoding, last_login, vip) VALUES (?, ?, ?, ?, ?, DATETIME('NOW'), ?)");
 	PREP_STMT(m_getUser, "SELECT id, jid, uin, password, encoding, language, vip FROM " + m_prefix + "users WHERE jid=?");
 	PREP_STMT(m_removeUser, "DELETE FROM " + m_prefix + "users WHERE id=?");
 	PREP_STMT(m_removeUserBuddies, "DELETE FROM " + m_prefix + "buddies WHERE user_id=?");
 	PREP_STMT(m_removeUserSettings, "DELETE FROM " + m_prefix + "users_settings WHERE user_id=?");
 	PREP_STMT(m_removeUserBuddiesSettings, "DELETE FROM " + m_prefix + "buddies_settings WHERE user_id=?");
 	PREP_STMT(m_addBuddy, "INSERT INTO " + m_prefix + "buddies (user_id, uin, subscription, groups, nickname, flags) VALUES (?, ?, ?, ?, ?, ?)");
 	sqlite3_reset(m_getUser);
 	sqlite3_bind_text(m_getUser, 1, barejid.c_str(), -1, SQLITE_TRANSIENT);
 	int ret;
 	while((ret = sqlite3_step(m_getUser)) == SQLITE_ROW) {
 		user.id = sqlite3_column_int(m_getUser, 0);
 		user.jid = (const char *) sqlite3_column_text(m_getUser, 1);
 		user.uin = (const char *) sqlite3_column_text(m_getUser, 2);
 		user.password = (const char *) sqlite3_column_text(m_getUser, 3);
 		user.encoding = (const char *) sqlite3_column_text(m_getUser, 4);
 		user.language = (const char *) sqlite3_column_text(m_getUser, 5);
 		user.vip = sqlite3_column_int(m_getUser, 6) != 0;
 		while((ret = sqlite3_step(m_getUser)) == SQLITE_ROW) {
+		}
 		return true;
+	}
 	if (ret != SQLITE_DONE) {
 		LOG4CXX_ERROR(logger, "getUser query"<< (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));
+	}
 	return false;
+}
 void SQLite3Backend::setUserOnline(long id, bool online) {
 	BEGIN(m_setUserOnline);
 				buddy_id = -1;
+			}
+		}
 // 		if (ret != SQLITE_DONE) {
 // 			LOG4CXX_ERROR(logger, "getBuddiesSettings query"<< (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));
 // 			return false;
 // 		}
 		roster.push_back(b);
+	}
 	while((ret = sqlite3_step(m_getBuddiesSettings)) == SQLITE_ROW) {
+	}
 	if (ret != SQLITE_DONE) {
 		LOG4CXX_ERROR(logger, "getBuddies query"<< (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));
 		return false;
+	}
 	return true;
+}
 bool SQLite3Backend::removeUser(long id) {
 	sqlite3_reset(m_removeUser);
 	sqlite3_bind_int(m_removeUser, 1, id);
 	if(sqlite3_step(m_removeUser) != SQLITE_DONE) {
 	if(sqlite3_step(m_getUserSetting) != SQLITE_ROW) {
 		BEGIN(m_setUserSetting);
 		BIND_INT(m_setUserSetting, id);
 		BIND_STR(m_setUserSetting, variable);
 		BIND_INT(m_setUserSetting, type);
 		BIND_STR(m_setUserSetting, value);
 		EXECUTE_STATEMENT(m_setUserSetting, "m_setUserSetting");
+	}
 	else {
 		type = GET_INT(m_getUserSetting);
 		value = GET_STR(m_getUserSetting);
+	}
 	int ret;
 	while((ret = sqlite3_step(m_getUserSetting)) == SQLITE_ROW) {
+	}
+}
 void SQLite3Backend::updateUserSetting(long id, const std::string &variable, const std::string &value) {
 	BEGIN(m_updateUserSetting);
 	BIND_STR(m_updateUserSetting, value);
 	BIND_INT(m_updateUserSetting, id);
 	BIND_STR(m_updateUserSetting, variable);
 	EXECUTE_STATEMENT(m_updateUserSetting, "m_updateUserSetting");
+}
 void SQLite3Backend::beginTransaction() {
 	exec("BEGIN TRANSACTION;");

src/usermanager.cpp

➞

Show inline comments

 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setFrom(presence->getTo());
 		response->setTo(presence->getFrom());
 		response->setType(Swift::Presence::Unavailable);
 		m_component->getStanzaChannel()->sendPresence(response);
+	}
+}
 void UserManager::handleSubscription(Swift::Presence::ref presence) {
 	// answer to subscibe for transport itself
 	if (presence->getType() == Swift::Presence::Subscribe && presence->getTo().getNode().empty()) {
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setFrom(presence->getTo());
 		response->setTo(presence->getFrom());
 		response->setFrom(presence->getTo().toBare());
 		response->setTo(presence->getFrom().toBare());
 		response->setType(Swift::Presence::Subscribed);
 		m_component->getStanzaChannel()->sendPresence(response);
 // 		response = Swift::Presence::create();
 // 		response->setFrom(presence->getTo());
 // 		response->setTo(presence->getFrom());
 // 		response->setType(Swift::Presence::Subscribe);
 // 		m_component->getStanzaChannel()->sendPresence(response);
 		return;
+	}
 	// Don't let RosterManager to handle presences for us

src/userregistration.cpp

➞

Show inline comments

@@ @@ -17,24 +17,26 @@ @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/userregistration.h"
 #include "transport/usermanager.h"
 #include "transport/storagebackend.h"
 #include "transport/transport.h"
 #include "transport/rostermanager.h"
 #include "transport/user.h"
 #include "Swiften/Elements/ErrorPayload.h"
 #include <boost/shared_ptr.hpp>
 #include <boost/thread.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
 #include "log4cxx/logger.h"
 using namespace Swift;
 using namespace log4cxx;
 namespace Transport {
 static LoggerPtr logger = Logger::getLogger("UserRegistration");
 UserRegistration::UserRegistration(Component *component, UserManager *userManager, StorageBackend *storageBackend) : Swift::Responder<Swift::InBandRegistrationPayload>(component->m_iqRouter) {
 	m_component = component;
 	m_config = m_component->m_config;
 //	if (registered)
 //		encoding->setValue(res.encoding);
 //	else
 //		encoding->setValue(CONFIG_STRING(m_config, "registration.encoding"));
 //	form->addField(encoding);
 	if (registered) {
 		BooleanFormField::ref boolean = BooleanFormField::create();
 		boolean->setName("unregister");
 		boolean->setLabel((("Remove your registration")));
 		boolean->setValue(0);
 		form->addField(boolean);
 	} else {
 		if (CONFIG_BOOL(m_config,"registration.require_local_account")) {
 			std::string localUsernameField = CONFIG_STRING(m_config, "registration.local_username_label");
 			TextSingleFormField::ref local_username = TextSingleFormField::create();
 			local_username->setName("local_username");
 			local_username->setLabel((localUsernameField));
 			local_username->setRequired(true);
 			form->addField(local_username);
 			TextPrivateFormField::ref local_password = TextPrivateFormField::create();
 			local_password->setName("local_password");
 			local_password->setLabel((("Local Password")));
 			local_password->setRequired(true);
 			form->addField(local_password);
+		}
+	}
 	reg->setForm(form);
 	sendResponse(from, id, reg);
 	return true;
+}
 bool UserRegistration::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::InBandRegistrationPayload> payload) {
 	// TODO: backend should say itself if registration is needed or not...
 	if (CONFIG_STRING(m_config, "service.protocol") == "irc") {
 		if (std::find(x.begin(), x.end(), from.getDomain()) == x.end()) {
 			LOG4CXX_INFO(logger, barejid << ": This user has no permissions to register an account")
 			sendError(from, id, ErrorPayload::BadRequest, ErrorPayload::Modify);
 			return true;
+		}
+	}
 	UserInfo res;
 	bool registered = m_storageBackend->getUser(barejid, res);
 	std::string encoding;
 	std::string language;
 	std::string local_username("");
 	std::string local_password("");
 	Form::ref form = payload->getForm();
 	if (form) {
 		const std::vector<FormField::ref> fields = form->getFields();
 		for (std::vector<FormField::ref>::const_iterator it = fields.begin(); it != fields.end(); it++) {
 			TextSingleFormField::ref textSingle = boost::dynamic_pointer_cast<TextSingleFormField>(*it);
 			if (textSingle) {
 				if (textSingle->getName() == "username") {
 					payload->setUsername(textSingle->getValue());
+				}
 				else if (textSingle->getName() == "encoding") {
 					encoding = textSingle->getValue();
+				}
 				// Pidgin sends it as textSingle, not sure why...
 				else if (textSingle->getName() == "password") {
 					payload->setPassword(textSingle->getValue());
+				}
 				else if (textSingle->getName() == "local_username") {
 					local_username = textSingle->getValue();
+				}
 				// Pidgin sends it as textSingle, not sure why...
 				else if (textSingle->getName() == "local_password") {
 					local_password = textSingle->getValue();
+				}
 				continue;
+			}
 			TextPrivateFormField::ref textPrivate = boost::dynamic_pointer_cast<TextPrivateFormField>(*it);
 			if (textPrivate) {
 				if (textPrivate->getName() == "password") {
 					payload->setPassword(textPrivate->getValue());
+				}
 				else if (textPrivate->getName() == "local_password") {
 					local_password = textPrivate->getValue();
+				}
 				continue;
+			}
 			ListSingleFormField::ref listSingle = boost::dynamic_pointer_cast<ListSingleFormField>(*it);
 			if (listSingle) {
 				if (listSingle->getName() == "language") {
 					language = listSingle->getValue();
+				}
 				continue;
+			}
 			BooleanFormField::ref boolean = boost::dynamic_pointer_cast<BooleanFormField>(*it);
+				}
 				continue;
+			}
+		}
+	}
 	if (payload->isRemove()) {
 		unregisterUser(barejid);
 		sendResponse(from, id, InBandRegistrationPayload::ref());
 		return true;
+	}
 	if (CONFIG_BOOL(m_config,"registration.require_local_account")) {
 	/*	if (!local_username || !local_password) {
 			sendResponse(from, id, InBandRegistrationPayload::ref());
 			return true
 		} else */ if (local_username == "" || local_password == "") {
 			sendResponse(from, id, InBandRegistrationPayload::ref());
 			return true;
+		}
 //		Swift::logging = true;
 		bool validLocal = false;
 		std::string localLookupServer = CONFIG_STRING(m_config, "registration.local_account_server");
 		std::string localLookupJID = local_username + std::string("@") + localLookupServer;
 		SimpleEventLoop localLookupEventLoop;
 		BoostNetworkFactories localLookupNetworkFactories(&localLookupEventLoop);
 		Client localLookupClient(localLookupJID, local_password, &localLookupNetworkFactories);
 		// TODO: this is neccessary on my server ... but should maybe omitted
 		localLookupClient.setAlwaysTrustCertificates();
 		localLookupClient.connect();
 		class SimpleLoopRunner {
 			public:
 				SimpleLoopRunner() {};
 				static void run(SimpleEventLoop * loop) {
 					loop->run();
 				};
 		};
 		// TODO: Really ugly and hacky solution, any other ideas more than welcome!
 		boost::thread thread(boost::bind(&(SimpleLoopRunner::run), &localLookupEventLoop));
 		thread.timed_join(boost::posix_time::millisec(CONFIG_INT(m_config, "registration.local_account_server_timeout")));
 		localLookupEventLoop.stop();
 		thread.join();
 		validLocal = localLookupClient.isAvailable();
 		localLookupClient.disconnect();
 		if (!validLocal) {
 			sendError(from, id, ErrorPayload::NotAuthorized, ErrorPayload::Modify);
 			return true;
+		}
+	}
 	printf("here\n");
 	if (!payload->getUsername() || !payload->getPassword()) {
 		sendError(from, id, ErrorPayload::NotAcceptable, ErrorPayload::Modify);
 		return true;
+	}
 	// Register or change password
 	if (payload->getUsername()->empty()) {
 		sendError(from, id, ErrorPayload::NotAcceptable, ErrorPayload::Modify);
 		return true;
+	}
 	// TODO: Move this check to backend somehow

0 comments (0 inline, 0 general)