libtransport.git Changeset - ef5561de00e2

Changeset - ef5561de00e2

Parent rev.

Child rev.

[Not reviewed]

Merge

2 39 19

Vitaly Takmazov - 14 years ago 2012-03-20 21:39:16
vitalyster@gmail.com

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

35 files changed with 844 insertions and 795 deletions:

CMakeLists.txt

ChangeLog

backends/libcommuni/main.cpp

backends/libpurple/main.cpp

455

backends/libpurple/utils.cpp

129

backends/libpurple/utils.h

backends/skype/main.cpp

132

backends/smstools3/main.cpp

include/transport/buddy.h

include/transport/logging.h

include/transport/memoryusage.h

include/transport/networkplugin.h

include/transport/networkpluginserver.h

include/transport/protocol.proto

include/transport/storagebackend.h

include/transport/usermanager.h

plugin/CMakeLists.txt

plugin/cpp/CMakeLists.txt

rename

plugin/cpp/networkplugin.cpp

plugin/python/CMakeLists.txt

spectrum/src/main.cpp

114

spectrum/src/sample.cfg

src/admininterface.cpp

src/buddy.cpp

src/logging.cpp

132

src/memoryusage.cpp

src/networkpluginserver.cpp

src/rostermanager.cpp

src/rosterstorage.cpp

src/statsresponder.cpp

src/storagebackend.cpp

src/tests/basictest.h

src/user.cpp

src/usermanager.cpp

src/userregistration.cpp

0 comments (0 inline, 0 general)

CMakeLists.txt

➞

Show inline comments

@@ @@ -221,41 +221,42 @@ else(CMAKE_BUILD_TYPE MATCHES Debug) @@
 	message("Debug             : no (run \"cmake . -DCMAKE_BUILD_TYPE=Debug\")")
 endif(CMAKE_BUILD_TYPE MATCHES Debug)
 SET(TRANSPORT_VERSION 2.0)
 SET(PROJECT_VERSION 2.0)
 include_directories(include)
 include_directories(${EVENT_INCLUDE_DIRS})
 include_directories(${SWIFTEN_INCLUDE_DIR})
 include_directories(${Boost_INCLUDE_DIRS})
 if (NOT WIN32)
 include_directories(${OPENSSL_INCLUDE_DIR})
 endif()
 ADD_SUBDIRECTORY(src)
 ADD_SUBDIRECTORY(plugin)
 ADD_SUBDIRECTORY(include)
 ADD_SUBDIRECTORY(spectrum)
 ADD_SUBDIRECTORY(backends)
 if (NOT WIN32)
 	ADD_SUBDIRECTORY(spectrum_manager)
 #	ADD_SUBDIRECTORY(spectrum2_send_message)
 endif()
 if (CPPUNIT_FOUND)
 	message("tests             : yes")
 	include_directories(${CPPUNIT_INCLUDE_DIR})
 else()
 	message("tests             : no (install CPPUnit)")
 endif()
 if(DOXYGEN_FOUND)
 	message("Docs              : yes")
 	ADD_SUBDIRECTORY(docs)
 else(DOXYGEN_FOUND)
 	message("Docs              : no (install doxygen)")
 endif(DOXYGEN_FOUND)
 message("----------------------")

ChangeLog

➞

Show inline comments

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

backends/libcommuni/main.cpp

➞

Show inline comments

 /*
  * Copyright (C) 2008-2009 J-P Nurmi jpnurmi@gmail.com
+ *
  * This example is free, and not covered by LGPL license. There is no
  * restriction applied to their modification, redistribution, using and so on.
  * You can study them, modify them, use them in your own program - either
  * completely or partially. By using it you may give me some credits in your
  * program, but you don't have to.
  */
 #include "transport/config.h"
 #include "transport/networkplugin.h"
 #include "transport/logging.h"
 #include "session.h"
 #include <QtCore>
 #include <QtNetwork>
 #include "Swiften/EventLoop/Qt/QtEventLoop.h"
 #include "ircnetworkplugin.h"
 #include "singleircnetworkplugin.h"
 #include "log4cxx/logger.h"
 #include "log4cxx/consoleappender.h"
 #include "log4cxx/patternlayout.h"
 #include "log4cxx/propertyconfigurator.h"
 #include "log4cxx/helpers/properties.h"
 #include "log4cxx/helpers/fileinputstream.h"
 #include "log4cxx/helpers/transcoder.h"
 using namespace boost::program_options;
 using namespace Transport;
 using namespace log4cxx;
 NetworkPlugin * np = NULL;
 int main (int argc, char* argv[]) {
 	std::string host;
@@ @@ -62,60 +63,37 @@ int main (int argc, char* argv[]) { @@
 	if (argc < 5) {
 		qDebug("Usage: %s <config>", argv[0]);
 		return 1;
+	}
 // 	QStringList channels;
 // 	for (int i = 3; i < argc; ++i)
 // 	{
 // 		channels.append(argv[i]);
 // 	}
 //
 // 	MyIrcSession session;
 // 	session.setNick(argv[2]);
 // 	session.setAutoJoinChannels(channels);
 // 	session.connectToServer(argv[1], 6667);
 	Config config;
 	if (!config.load(argv[5])) {
 		std::cerr << "Can't open " << argv[1] << " configuration file.\n";
 		return 1;
+	}
 	QCoreApplication app(argc, argv);
 	if (CONFIG_STRING(&config, "logging.backend_config").empty()) {
 		LoggerPtr root = log4cxx::Logger::getRootLogger();
 #ifndef _MSC_VER
 		root->addAppender(new ConsoleAppender(new PatternLayout("%d %-5p %c: %m%n")));
 #else
 		root->addAppender(new ConsoleAppender(new PatternLayout(L"%d %-5p %c: %m%n")));
 #endif
+	}
 	else {
 		log4cxx::helpers::Properties p;
 		log4cxx::helpers::FileInputStream *istream = new log4cxx::helpers::FileInputStream(CONFIG_STRING(&config, "logging.backend_config"));
 		p.load(istream);
 		LogString pid, jid;
 		log4cxx::helpers::Transcoder::decode(boost::lexical_cast<std::string>(getpid()), pid);
 		log4cxx::helpers::Transcoder::decode(CONFIG_STRING(&config, "service.jid"), jid);
 #ifdef _MSC_VER
 		p.setProperty(L"pid", pid);
 		p.setProperty(L"jid", jid);
 #else
 		p.setProperty("pid", pid);
 		p.setProperty("jid", jid);
 #endif
 		log4cxx::PropertyConfigurator::configure(p);
+	}
 	Logging::initBackendLogging(&config);
 	Swift::QtEventLoop eventLoop;
 	if (config.getUnregistered().find("service.irc_server") == config.getUnregistered().end()) {
 		np = new IRCNetworkPlugin(&config, &eventLoop, host, port);
+	}
 	else {
 		np = new SingleIRCNetworkPlugin(&config, &eventLoop, host, port);
+	}
 	return app.exec();
+}

backends/libpurple/main.cpp

➞

Show inline comments

 #include "utils.h"
 #include "glib.h"
 #include "purple.h"
 #include <algorithm>
 #include <iostream>
 #include "transport/networkplugin.h"
 #include "geventloop.h"
 #include "log4cxx/logger.h"
 #include "log4cxx/consoleappender.h"
 #include "log4cxx/patternlayout.h"
 #include "log4cxx/propertyconfigurator.h"
 #include "log4cxx/helpers/properties.h"
 #include "log4cxx/helpers/fileinputstream.h"
 #include "log4cxx/helpers/transcoder.h"
 #ifndef WIN32
 #include "sys/wait.h"
 #include "sys/signal.h"
 #include <netinet/if_ether.h>
 #include <netinet/ip.h>
 #include <netinet/ip6.h>
 #include <netinet/udp.h>
 #include <netinet/tcp.h>
 #include <netinet/ether.h>
 #include "sys/socket.h"
 #include <netdb.h>
 #include <unistd.h>
 #include <fcntl.h>
 #else
 #include <process.h>
 #define getpid _getpid
 #define ssize_t SSIZE_T
 #include "win32/win32dep.h"
 #endif
 // #include "valgrind/memcheck.h"
 #include "malloc.h"
 #include <algorithm>
 #include "errno.h"
 #ifdef WITH_LIBEVENT
 #include <event.h>
 #endif
 using namespace log4cxx;
 static LoggerPtr logger_libpurple = log4cxx::Logger::getLogger("libpurple");
 static LoggerPtr logger = log4cxx::Logger::getLogger("backend");
-int m_sock;
+int main_socket;
 static int writeInput;
 using namespace Transport;
 template <class T> T fromString(const std::string &str) {
 	T i;
 	std::istringstream os(str);
 	os >> i;
 	return i;
+}
 template <class T> std::string stringOf(T object) {
 	std::ostringstream os;
 	os << object;
 	return (os.str());
+}
 static void transportDataReceived(gpointer data, gint source, PurpleInputCondition cond);
 class SpectrumNetworkPlugin;
 GKeyFile *keyfile;
 SpectrumNetworkPlugin *np;
 static std::string replaceAll(
   std::string result,
   const std::string& replaceWhat,
   const std::string& replaceWithWhat)
+{
   while(1)
+  {
 	const int pos = result.find(replaceWhat);
 	if (pos==-1) break;
 	result.replace(pos,replaceWhat.size(),replaceWithWhat);
+  }
   return result;
+}
 static std::string KEYFILE_STRING(const std::string &cat, const std::string &key, const std::string &def = "") {
 	gchar *str = g_key_file_get_string(keyfile, cat.c_str(), key.c_str(), 0);
 	if (!str) {
 		return def;
+	}
 	std::string ret(str);
-	free(str);
+	g_free(str);
 	if (ret.find("#") != std::string::npos) {
 		ret = ret.substr(0, ret.find("#"));
 		while(*(ret.end() - 1) == ' ') {
 			ret.erase(ret.end() - 1);
+		}
+	}
 	if (ret.find("$jid") != std::string::npos) {
 		std::string jid = KEYFILE_STRING("service", "jid");
 		ret = replaceAll(ret, "$jid", jid);
+	}
 	return ret;
+}
 #define KEYFILE_BOOL(CAT, KEY) g_key_file_get_boolean(keyfile, CAT, KEY, 0)
 static gboolean nodaemon = FALSE;
 static gchar *logfile = NULL;
 static gchar *lock_file = NULL;
 static gchar *host = NULL;
 static int port = 10000;
 static gboolean ver = FALSE;
 static gboolean list_purple_settings = FALSE;
 struct FTData {
 	unsigned long id;
 	unsigned long timer;
 	bool paused;
 };
 static GOptionEntry options_entries[] = {
 	{ "nodaemon", 'n', 0, G_OPTION_ARG_NONE, &nodaemon, "Disable background daemon mode", NULL },
 	{ "logfile", 'l', 0, G_OPTION_ARG_STRING, &logfile, "Set file to log", NULL },
 	{ "pidfile", 'p', 0, G_OPTION_ARG_STRING, &lock_file, "File where to write transport PID", NULL },
 	{ "version", 'v', 0, G_OPTION_ARG_NONE, &ver, "Shows Spectrum version", NULL },
 	{ "list-purple-settings", 's', 0, G_OPTION_ARG_NONE, &list_purple_settings, "Lists purple settings which can be used in config file", NULL },
 	{ "host", 'h', 0, G_OPTION_ARG_STRING, &host, "Host to connect to", NULL },
 	{ "port", 'p', 0, G_OPTION_ARG_INT, &port, "Port to connect to", NULL },
 	{ NULL, 0, 0, G_OPTION_ARG_NONE, NULL, "", NULL }
 };
 static void *notify_user_info(PurpleConnection *gc, const char *who, PurpleNotifyUserInfo *user_info);
 static GHashTable *ui_info = NULL;
 static GHashTable *spectrum_ui_get_info(void)
+{
 	if(NULL == ui_info) {
 		ui_info = g_hash_table_new(g_str_hash, g_str_equal);
 		g_hash_table_insert(ui_info, g_strdup("name"), g_strdup("Spectrum"));
 		g_hash_table_insert(ui_info, g_strdup("version"), g_strdup("0.5"));
 		g_hash_table_insert(ui_info, g_strdup("website"), g_strdup("http://spectrum.im"));
 		g_hash_table_insert(ui_info, g_strdup("dev_website"), g_strdup("http://spectrum.im"));
 		g_hash_table_insert(ui_info, g_strdup("client_type"), g_strdup("pc"));
 		/*
 		 * This is the client key for "Pidgin."  It is owned by the AIM
 		 * account "markdoliner."  Please don't use this key for other
 		 * applications.  You can either not specify a client key, in
 		 * which case the default "libpurple" key will be used, or you
 		 * can register for your own client key at
 		 * http://developer.aim.com/manageKeys.jsp
 		 */
 		g_hash_table_insert(ui_info, g_strdup("prpl-aim-clientkey"), g_strdup("ma1cSASNCKFtrdv9"));
 		g_hash_table_insert(ui_info, g_strdup("prpl-icq-clientkey"), g_strdup("ma1cSASNCKFtrdv9"));
 		/*
 		 * This is the distid for Pidgin, given to us by AOL.  Please
 		 * don't use this for other applications.  You can just not
 		 * specify a distid and libpurple will use a default.
 		 */
 		g_hash_table_insert(ui_info, g_strdup("prpl-aim-distid"), GINT_TO_POINTER(1550));
 		g_hash_table_insert(ui_info, g_strdup("prpl-icq-distid"), GINT_TO_POINTER(1550));
+	}
 	return ui_info;
+}
 static gboolean
 badchar(char c)
+{
 	switch (c) {
 	case ' ':
 	case ',':
 	case '\0':
 	case '\n':
 	case '\r':
 	case '<':
 	case '>':
 	case '"':
 		return TRUE;
 	default:
 		return FALSE;
+	}
+}
 static gboolean
 badentity(const char *c)
+{
 	if (!g_ascii_strncasecmp(c, "&lt;", 4) ||
 		!g_ascii_strncasecmp(c, "&gt;", 4) ||
 		!g_ascii_strncasecmp(c, "&quot;", 6)) {
 		return TRUE;
+	}
 	return FALSE;
+}
 static const char *
 process_link(GString *ret,
 		const char *start, const char *c,
 		int matchlen,
 		const char *urlprefix,
 		int inside_paren)
+{
 	char *url_buf;
 	const char *t;
 	for (t = c;; t++) {
 		if (!badchar(*t) && !badentity(t))
 			continue;
 		if (t - c == matchlen)
 			break;
 		if (*t == ',' && *(t + 1) != ' ') {
 			continue;
+		}
 		if (t > start && *(t - 1) == '.')
 			t--;
 		if (t > start && *(t - 1) == ')' && inside_paren > 0)
 			t--;
 		url_buf = g_strndup(c, t - c);
 // 		tmpurlbuf = purple_unescape_html(url_buf);
 // 		std::cout << url_buf << "\n";
 		g_string_append_printf(ret, "<A HREF=\"%s%s\">%s</A>",
 				urlprefix,
 				url_buf, url_buf);
 // 		g_free(tmpurlbuf);
 		g_free(url_buf);
 		return t;
+	}
 	return c;
+}
 static gboolean ft_ui_ready(void *data) {
 	PurpleXfer *xfer = (PurpleXfer *) data;
 	FTData *ftdata = (FTData *) xfer->ui_data;
 	ftdata->timer = 0;
 	purple_xfer_ui_ready((PurpleXfer *) data);
 	return FALSE;
+}
 static char *
 spectrum_markup_linkify(const char *text)
+{
 	const char *c, *t, *q = NULL;
 	char *tmpurlbuf, *url_buf;
 	gunichar g;
 	gboolean inside_html = FALSE;
 	int inside_paren = 0;
 	GString *ret;
 	if (text == NULL)
 		return NULL;
 	ret = g_string_new("");
 	c = text;
 	while (*c) {
 		if(*c == '(' && !inside_html) {
 			inside_paren++;
 			ret = g_string_append_c(ret, *c);
 			c++;
+		}
 		if(inside_html) {
 			if(*c == '>') {
 				inside_html = FALSE;
 			} else if(!q && (*c == '\"' || *c == '\'')) {
 				q = c;
 			} else if(q) {
 				if(*c == *q)
 					q = NULL;
+			}
 		} else if(*c == '<') {
 			inside_html = TRUE;
 			if (!g_ascii_strncasecmp(c, "<A", 2)) {
 				while (1) {
 					if (!g_ascii_strncasecmp(c, "/A>", 3)) {
 						inside_html = FALSE;
 						break;
+					}
 					ret = g_string_append_c(ret, *c);
 					c++;
 					if (!(*c))
 						break;
+				}
+			}
 		} else if (!g_ascii_strncasecmp(c, "http://", 7)) {
 			c = process_link(ret, text, c, 7, "", inside_paren);
 		} else if (!g_ascii_strncasecmp(c, "https://", 8)) {
 			c = process_link(ret, text, c, 8, "", inside_paren);
 		} else if (!g_ascii_strncasecmp(c, "ftp://", 6)) {
 			c = process_link(ret, text, c, 6, "", inside_paren);
 		} else if (!g_ascii_strncasecmp(c, "sftp://", 7)) {
 			c = process_link(ret, text, c, 7, "", inside_paren);
 		} else if (!g_ascii_strncasecmp(c, "file://", 7)) {
 			c = process_link(ret, text, c, 7, "", inside_paren);
 		} else if (!g_ascii_strncasecmp(c, "www.", 4) && c[4] != '.' && (c == text || badchar(c[-1]) || badentity(c-1))) {
 			c = process_link(ret, text, c, 4, "http://", inside_paren);
 		} else if (!g_ascii_strncasecmp(c, "ftp.", 4) && c[4] != '.' && (c == text || badchar(c[-1]) || badentity(c-1))) {
 			c = process_link(ret, text, c, 4, "ftp://", inside_paren);
 		} else if (!g_ascii_strncasecmp(c, "xmpp:", 5) && (c == text || badchar(c[-1]) || badentity(c-1))) {
 			c = process_link(ret, text, c, 5, "", inside_paren);
 		} else if (!g_ascii_strncasecmp(c, "mailto:", 7)) {
 			t = c;
 			while (1) {
 				if (badchar(*t) || badentity(t)) {
 					const char *d;
 					if (t - c == 7) {
 						break;
+					}
 					if (t > text && *(t - 1) == '.')
 						t--;
 					if ((d = strstr(c + 7, "?")) != NULL && d < t)
 						url_buf = g_strndup(c + 7, d - c - 7);
 					else
 						url_buf = g_strndup(c + 7, t - c - 7);
 					if (!purple_email_is_valid(url_buf)) {
 						g_free(url_buf);
 						break;
+					}
 					g_free(url_buf);
 					url_buf = g_strndup(c, t - c);
 // 					tmpurlbuf = purple_unescape_html(url_buf);
 					g_string_append_printf(ret, "<A HREF=\"%s\">%s</A>",
 							  url_buf, url_buf);
 					g_free(url_buf);
 // 					g_free(tmpurlbuf);
 					c = t;
 					break;
+				}
 				t++;
+			}
 		} else if (c != text && (*c == '@')) {
 			int flag;
 			GString *gurl_buf = NULL;
 			const char illegal_chars[] = "!@#$%^&*()[]{}/|\\<>\":;\r\n \0";
 			if (strchr(illegal_chars,*(c - 1)) || strchr(illegal_chars, *(c + 1)))
 				flag = 0;
 			else {
 				flag = 1;
 				gurl_buf = g_string_new("");
+			}
 			t = c;
 			while (flag) {
 				/* iterate backwards grabbing the local part of an email address */
 				g = g_utf8_get_char(t);
 				if (badchar(*t) || (g >= 127) || (*t == '(') ||
 					((*t == ';') && ((t > (text+2) && (!g_ascii_strncasecmp(t - 3, "&lt;", 4) ||
 				                                       !g_ascii_strncasecmp(t - 3, "&gt;", 4))) ||
 				                     (t > (text+4) && (!g_ascii_strncasecmp(t - 5, "&quot;", 6)))))) {
 					/* local part will already be part of ret, strip it out */
 					ret = g_string_truncate(ret, ret->len - (c - t));
 					ret = g_string_append_unichar(ret, g);
 					break;
 				} else {
 					g_string_prepend_unichar(gurl_buf, g);
 					t = g_utf8_find_prev_char(text, t);
 					if (t < text) {
 						ret = g_string_assign(ret, "");
 						break;
+					}
+				}
+			}
 			t = g_utf8_find_next_char(c, NULL);
 			while (flag) {
 				/* iterate forwards grabbing the domain part of an email address */
 				g = g_utf8_get_char(t);
 				if (badchar(*t) || (g >= 127) || (*t == ')') || badentity(t)) {
 					char *d;
 					url_buf = g_string_free(gurl_buf, FALSE);
 					/* strip off trailing periods */
 					if (strlen(url_buf) > 0) {
 						for (d = url_buf + strlen(url_buf) - 1; *d == '.'; d--, t--)
 							*d = '\0';
+					}
 					tmpurlbuf = purple_unescape_html(url_buf);
 					if (purple_email_is_valid(tmpurlbuf)) {
 						g_string_append_printf(ret, "<A HREF=\"mailto:%s\">%s</A>",
 								url_buf, url_buf);
 					} else {
 						g_string_append(ret, url_buf);
+					}
 					g_free(url_buf);
 					g_free(tmpurlbuf);
 					c = t;
 					break;
 				} else {
 					g_string_append_unichar(gurl_buf, g);
 					t = g_utf8_find_next_char(t, NULL);
+				}
+			}
+		}
 		if(*c == ')' && !inside_html) {
 			inside_paren--;
 			ret = g_string_append_c(ret, *c);
 			c++;
+		}
 		if (*c == 0)
 			break;
 		ret = g_string_append_c(ret, *c);
 		c++;
+	}
 	return g_string_free(ret, FALSE);
+}
 struct authRequest {
 	PurpleAccountRequestAuthorizationCb authorize_cb;
 	PurpleAccountRequestAuthorizationCb deny_cb;
 	void *user_data;
 	std::string who;
 	PurpleAccount *account;
 	std::string mainJID;	// JID of user connected with this request
 };
 static void * requestInput(const char *title, const char *primary,const char *secondary, const char *default_value, gboolean multiline, gboolean masked, gchar *hint,const char *ok_text, GCallback ok_cb,const char *cancel_text, GCallback cancel_cb, PurpleAccount *account, const char *who,PurpleConversation *conv, void *user_data) {
 	if (primary) {
 		std::string primaryString(primary);
 		if (primaryString == "Authorization Request Message:") {
 			LOG4CXX_INFO(logger, "Authorization Request Message: calling ok_cb(...)");
 			((PurpleRequestInputCb) ok_cb)(user_data, "Please authorize me.");
 			return NULL;
+		}
 		else if (primaryString == "Authorization Request Message:") {
 			LOG4CXX_INFO(logger, "Authorization Request Message: calling ok_cb(...)");
 			((PurpleRequestInputCb) ok_cb)(user_data, "Please authorize me.");
 			return NULL;
+		}
 		else if (primaryString == "Authorization Denied Message:") {
 			LOG4CXX_INFO(logger, "Authorization Deined Message: calling ok_cb(...)");
 				((PurpleRequestActionCb) va_arg(actions, GCallback)) (user_data, 2);
+			}
+		}
+	}
 	return NULL;
+}
 static std::string getAlias(PurpleBuddy *m_buddy) {
 	std::string alias;
 	PurpleContact *contact = PURPLE_CONTACT(PURPLE_BLIST_NODE(m_buddy)->parent);
 	if (contact && contact->alias) {
 		alias = contact->alias;
+	}
 	else if (purple_buddy_get_alias(m_buddy)) {
 		alias = (std::string) purple_buddy_get_alias(m_buddy);
+	}
 	else {
 		alias = (std::string) purple_buddy_get_server_alias(m_buddy);
+	}
 	return alias;
+}
 class SpectrumNetworkPlugin : public NetworkPlugin {
 	public:
-		SpectrumNetworkPlugin(const std::string &host, int port) : NetworkPlugin() {
 		SpectrumNetworkPlugin() : NetworkPlugin() {
+		}
 		void handleExitRequest() {
 			LOG4CXX_INFO(logger, "Exiting...");
-			exit(1);
+			exit(0);
+		}
 		void getProtocolAndName(const std::string &legacyName, std::string &name, std::string &protocol) {
 			name = legacyName;
 			protocol = KEYFILE_STRING("service", "protocol");
 			if (protocol == "any") {
 				protocol = name.substr(0, name.find("."));
 				name = name.substr(name.find(".") + 1);
+			}
+		}
 		void setDefaultAvatar(PurpleAccount *account, const std::string &legacyName) {
 			char* contents;
 			gsize length;
 			gboolean ret = false;
 			if (!KEYFILE_STRING("backend", "avatars_directory").empty()) {
 				std::string f = KEYFILE_STRING("backend", "avatars_directory") + "/" + legacyName;
 				ret = g_file_get_contents (f.c_str(), &contents, &length, NULL);
+			}
 			if (!KEYFILE_STRING("backend", "default_avatar").empty() && !ret) {
 				ret = g_file_get_contents (KEYFILE_STRING("backend", "default_avatar").c_str(),
 											&contents, &length, NULL);
+			}
@@ @@ -576,156 +268,113 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 						case PURPLE_PREF_INT:
 							purple_account_set_int(account, key.c_str(), fromString<int>(KEYFILE_STRING("purple", key)));
 							break;
 						case PURPLE_PREF_STRING:
 						case PURPLE_PREF_STRING_LIST:
 							purple_account_set_string(account, key.c_str(), KEYFILE_STRING("purple", key).c_str());
 							break;
 						default:
 							continue;
+					}
 					break;
+				}
 				if (!found) {
 					purple_account_set_string(account, key.c_str(), KEYFILE_STRING("purple", key).c_str());
+				}
 				i++;
+			}
 			g_strfreev (keys);
+		}
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 			PurpleAccount *account = NULL;
 			std::string name;
 			std::string protocol;
 			getProtocolAndName(legacyName, name, protocol);
 			if (password.empty()) {
 				LOG4CXX_INFO(logger,  name.c_str() << ": Empty password");
 				np->handleDisconnected(user, 0, "Empty password.");
 				return;
+			}
 			if (!purple_find_prpl(protocol.c_str())) {
 				LOG4CXX_INFO(logger,  name.c_str() << ": Invalid protocol '" << protocol << "'");
 				np->handleDisconnected(user, 0, "Invalid protocol " + protocol);
 				return;
+			}
 			if (purple_accounts_find(name.c_str(), protocol.c_str()) != NULL) {
 				LOG4CXX_INFO(logger, "Using previously created account with name '" << name.c_str() << "' and protocol '" << protocol << "'");
 				account = purple_accounts_find(name.c_str(), protocol.c_str());
+			}
 			else {
 				LOG4CXX_INFO(logger, "Creating account with name '" << name.c_str() << "' and protocol '" << protocol << "'");
 				account = purple_account_new(name.c_str(), protocol.c_str());
 				purple_accounts_add(account);
+			}
 			m_sessions[user] = account;
 			m_accounts[account] = user;
 			// Default avatar
 			setDefaultAvatar(account, legacyName);
 			purple_account_set_password(account, password.c_str());
 			purple_account_set_bool(account, "custom_smileys", FALSE);
 			purple_account_set_bool(account, "direct_connect", FALSE);
 			setDefaultAccountOptions(account);
 			// Enable account + privacy lists
 			purple_account_set_enabled(account, "spectrum", TRUE);
 			if (KEYFILE_BOOL("service", "enable_privacy_lists")) {
 				purple_account_set_privacy_type(account, PURPLE_PRIVACY_DENY_USERS);
+			}
 			// Set the status
 			const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AVAILABLE);
 			if (status_type != NULL) {
 				purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, NULL);
+			}
+		}
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 // 				VALGRIND_DO_LEAK_CHECK;
 				m_sessions.erase(user);
 				purple_account_disconnect(account);
 				purple_account_set_enabled(account, "spectrum", FALSE);
 				g_free(account->ui_data);
 				account->ui_data = NULL;
 				m_accounts.erase(account);
 				purple_accounts_delete(account);
 //
 // 				// Remove conversations.
 // 				// This has to be called before m_account->ui_data = NULL;, because it uses
 // 				// ui_data to call SpectrumMessageHandler::purpleConversationDestroyed() callback.
 // 				GList *iter;
 // 				for (iter = purple_get_conversations(); iter; ) {
 // 					PurpleConversation *conv = (PurpleConversation*) iter->data;
 // 					iter = iter->next;
 // 					if (purple_conversation_get_account(conv) == account)
 // 						purple_conversation_destroy(conv);
 // 				}
 //
 // 				g_free(account->ui_data);
 // 				account->ui_data = NULL;
 // 				m_accounts.erase(account);
 //
 // 				purple_notify_close_with_handle(account);
 // 				purple_request_close_with_handle(account);
 //
 // 				purple_accounts_remove(account);
 //
 // 				GSList *buddies = purple_find_buddies(account, NULL);
 // 				while(buddies) {
 // 					PurpleBuddy *b = (PurpleBuddy *) buddies->data;
 // 					purple_blist_remove_buddy(b);
 // 					buddies = g_slist_delete_link(buddies, buddies);
 // 				}
 //
 // 				/* Remove any open conversation for this account */
 // 				for (GList *it = purple_get_conversations(); it; ) {
 // 					PurpleConversation *conv = (PurpleConversation *) it->data;
 // 					it = it->next;
 // 					if (purple_conversation_get_account(conv) == account)
 // 						purple_conversation_destroy(conv);
 // 				}
 //
 // 				/* Remove this account's pounces */
 // 					// purple_pounce_destroy_all_by_account(account);
 //
 // 				/* This will cause the deletion of an old buddy icon. */
 // 				purple_buddy_icons_set_account_icon(account, NULL, 0);
 //
 // 				purple_account_destroy(account);
 				// force returning of memory chunks allocated by libxml2 to kernel
 #ifndef WIN32
 				malloc_trim(0);
 #endif
 // 				VALGRIND_DO_LEAK_CHECK;
+			}
+		}
 		void handleStatusChangeRequest(const std::string &user, int status, const std::string &statusMessage) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				int st;
 				switch(status) {
 					case pbnetwork::STATUS_AWAY: {
 						st = PURPLE_STATUS_AWAY;
 						if (!purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AWAY))
 							st = PURPLE_STATUS_EXTENDED_AWAY;
 						else
 							st = PURPLE_STATUS_AWAY;
 						break;
+					}
 					case pbnetwork::STATUS_DND: {
 						st = PURPLE_STATUS_UNAVAILABLE;
 						break;
+					}
@@ @@ -747,59 +396,72 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 						st = PURPLE_STATUS_AVAILABLE;
 						break;
+				}
 				gchar *_markup = purple_markup_escape_text(statusMessage.c_str(), -1);
 				std::string markup(_markup);
 				g_free(_markup);
 				// we are already connected so we have to change status
 				const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive(account, (PurpleStatusPrimitive) st);
 				if (status_type != NULL) {
 					// send presence to legacy network
 					if (!markup.empty()) {
 						purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, "message", markup.c_str(), NULL);
+					}
 					else {
 						purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, NULL);
+					}
+				}
+			}
+		}
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
-				PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, legacyName.c_str(), account);
+				PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, legacyName.c_str(), account);
 				if (!conv) {
 					conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, legacyName.c_str());
 					conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, legacyName.c_str(), account);
 					if (!conv) {
 						conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, legacyName.c_str());
+					}
+				}
 				if (xhtml.empty()) {
 					gchar *_markup = purple_markup_escape_text(message.c_str(), -1);
 					purple_conv_im_send(PURPLE_CONV_IM(conv), _markup);
 					if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) {
 						purple_conv_im_send(PURPLE_CONV_IM(conv), _markup);
+					}
 					else if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) {
 						purple_conv_chat_send(PURPLE_CONV_CHAT(conv), _markup);
+					}
 					g_free(_markup);
+				}
 				else {
 					purple_conv_im_send(PURPLE_CONV_IM(conv), xhtml.c_str());
 					if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) {
 						purple_conv_im_send(PURPLE_CONV_IM(conv), xhtml.c_str());
+					}
 					else if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) {
 						purple_conv_chat_send(PURPLE_CONV_CHAT(conv), xhtml.c_str());
+					}
+				}
+			}
+		}
 		void handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				std::string name = legacyName;
 				if (KEYFILE_STRING("service", "protocol") == "any" && legacyName.find("prpl-") == 0) {
 					name = name.substr(name.find(".") + 1);
+				}
 				m_vcards[user + name] = id;
 				if (KEYFILE_BOOL("backend", "no_vcard_fetch") && name != purple_account_get_username(account)) {
 					PurpleNotifyUserInfo *user_info = purple_notify_user_info_new();
 					notify_user_info(purple_account_get_connection(account), name.c_str(), user_info);
 					purple_notify_user_info_destroy(user_info);
+				}
 				else {
 					serv_get_info(purple_account_get_connection(account), name.c_str());
+				}
+			}
+		}
@@ @@ -968,51 +630,51 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 			if (xfer) {
 				m_unhandledXfers.erase(user + fileName + buddyName);
 				purple_xfer_request_denied(xfer);
+			}
+		}
 		void handleFTPauseRequest(unsigned long ftID) {
 			PurpleXfer *xfer = m_xfers[ftID];
 			if (!xfer)
 				return;
 			FTData *ftData = (FTData *) xfer->ui_data;
 			ftData->paused = true;
+		}
 		void handleFTContinueRequest(unsigned long ftID) {
 			PurpleXfer *xfer = m_xfers[ftID];
 			if (!xfer)
 				return;
 			FTData *ftData = (FTData *) xfer->ui_data;
 			ftData->paused = false;
 			purple_xfer_ui_ready(xfer);
+		}
 		void sendData(const std::string &string) {
-			write(m_sock, string.c_str(), string.size());
+			write(main_socket, string.c_str(), string.size());
 			if (writeInput == 0)
-				writeInput = purple_input_add(m_sock, PURPLE_INPUT_WRITE, &transportDataReceived, NULL);
+				writeInput = purple_input_add(main_socket, PURPLE_INPUT_WRITE, &transportDataReceived, NULL);
+		}
 		void readyForData() {
 			if (m_waitingXfers.empty())
 				return;
 			std::vector<PurpleXfer *> tmp;
 			tmp.swap(m_waitingXfers);
 			for (std::vector<PurpleXfer *>::const_iterator it = tmp.begin(); it != tmp.end(); it++) {
 				FTData *ftData = (FTData *) (*it)->ui_data;
 				if (ftData->timer == 0) {
 					ftData->timer = purple_timeout_add(1, ft_ui_ready, *it);
+				}
 // 				purple_xfer_ui_ready(xfer);
+			}
+		}
 		std::map<std::string, PurpleAccount *> m_sessions;
 		std::map<PurpleAccount *, std::string> m_accounts;
 		std::map<std::string, unsigned int> m_vcards;
 		std::map<std::string, authRequest *> m_authRequests;
 		std::map<unsigned long, PurpleXfer *> m_xfers;
 		std::map<std::string, PurpleXfer *> m_unhandledXfers;
 		std::vector<PurpleXfer *> m_waitingXfers;
 		return;
 // 	PurpleBuddy *buddy = (PurpleBuddy *) node;
+}
 static PurpleBlistUiOps blistUiOps =
+{
 	NULL,
 	buddyListNewNode,
 	NULL,
 	buddyListUpdate,
 	NULL, //NodeRemoved,
 	NULL,
 	NULL,
 	NULL, // buddyListAddBuddy,
 	NULL,
 	NULL,
 	NULL, //buddyListSaveNode,
 	NULL, //buddyListRemoveNode,
 	NULL, //buddyListSaveAccount,
 	NULL
 };
 static void conv_write_im(PurpleConversation *conv, const char *who, const char *msg, PurpleMessageFlags flags, time_t mtime) {
 	// Don't forwards our own messages.
 	if (flags & PURPLE_MESSAGE_SEND || flags & PURPLE_MESSAGE_SYSTEM)
+	if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM && (flags & PURPLE_MESSAGE_SEND || flags & PURPLE_MESSAGE_SYSTEM)) {
 		return;
+	}
 	PurpleAccount *account = purple_conversation_get_account(conv);
 // 	char *striped = purple_markup_strip_html(message);
 // 	std::string msg = striped;
 // 	g_free(striped);
 	std::string w = purple_normalize(account, who);
 	size_t pos = w.find("/");
 	if (pos != std::string::npos)
 		w.erase((int) pos, w.length() - (int) pos);
 	// Escape HTML characters.
 	char *newline = purple_strdup_withhtml(msg);
 	char *strip, *xhtml;
 	purple_markup_html_to_xhtml(newline, &xhtml, &strip);
 // 	xhtml_linkified = spectrum_markup_linkify(xhtml);
 	std::string message_(strip);
 	std::string xhtml_(xhtml);
 	g_free(newline);
 	g_free(xhtml);
 // 	g_free(xhtml_linkified);
 	g_free(strip);
 	// AIM and XMPP adds <body>...</body> here...
 	if (xhtml_.find("<body>") == 0) {
 		xhtml_ = xhtml_.substr(6);
 		if (xhtml_.find("</body>") != std::string::npos) {
 			xhtml_ = xhtml_.substr(0, xhtml_.find("</body>"));
+		}
+	}
 	if (xhtml_ == message_) {
 		xhtml_ = "";
+	}
 // 	LOG4CXX_INFO(logger, "Received message body='" << message_ << "' xhtml='" << xhtml_ << "'");
 	np->handleMessage(np->m_accounts[account], w, message_, "", xhtml_);
 	if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) {
 		np->handleMessage(np->m_accounts[account], w, message_, "", xhtml_);
+	}
 	else {
 		LOG4CXX_INFO(logger, "Received message body='" << message_ << "' name='" << purple_conversation_get_name(conv) << "' " << w);
 		np->handleMessage(np->m_accounts[account], purple_conversation_get_name(conv), message_, w, xhtml_);
+	}
+}
 static void conv_chat_add_users(PurpleConversation *conv, GList *cbuddies, gboolean new_arrivals) {
 	PurpleAccount *account = purple_conversation_get_account(conv);
 	GList *l = cbuddies;
 	while (l != NULL) {
 		PurpleConvChatBuddy *cb = (PurpleConvChatBuddy *)l->data;
 		std::string name(cb->name);
 		int flags = GPOINTER_TO_INT(cb->flags);
 		if (flags & PURPLE_CBFLAGS_OP || flags & PURPLE_CBFLAGS_HALFOP) {
 // 			item->addAttribute("affiliation", "admin");
 // 			item->addAttribute("role", "moderator");
 			flags = 1;
+		}
 		else if (flags & PURPLE_CBFLAGS_FOUNDER) {
 // 			item->addAttribute("affiliation", "owner");
 // 			item->addAttribute("role", "moderator");
 			flags = 1;
+		}
 		else {
 			flags = 0;
 // 			item->addAttribute("affiliation", "member");
 // 			item->addAttribute("role", "participant");
+		}
 		np->handleParticipantChanged(np->m_accounts[account], name, purple_conversation_get_name(conv), (int) flags, pbnetwork::STATUS_ONLINE);
 		l = l->next;
+	}
+}
 static void conv_chat_remove_users(PurpleConversation *conv, GList *users) {
 	PurpleAccount *account = purple_conversation_get_account(conv);
 	GList *l = users;
 	while (l != NULL) {
 		std::string name((char *) l->data);
 		np->handleParticipantChanged(np->m_accounts[account], name, purple_conversation_get_name(conv), 0, pbnetwork::STATUS_NONE);
 		l = l->next;
+	}
+}
 static PurpleConversationUiOps conversation_ui_ops =
+{
 	NULL,
 	NULL,
-	NULL,//conv_write_chat,                              /* write_chat           */
+	conv_write_im,//conv_write_chat,                              /* write_chat           */
 	conv_write_im,             /* write_im             */
 	NULL,//conv_write_conv,           /* write_conv           */
-	NULL,//conv_chat_add_users,       /* chat_add_users       */
 	conv_chat_add_users,       /* chat_add_users       */
 	NULL,//conv_chat_rename_user,     /* chat_rename_user     */
-	NULL,//conv_chat_remove_users,    /* chat_remove_users    */
 	conv_chat_remove_users,    /* chat_remove_users    */
 	NULL,//pidgin_conv_chat_update_user,     /* chat_update_user     */
 	NULL,//pidgin_conv_present_conversation, /* present              */
 	NULL,//pidgin_conv_has_focus,            /* has_focus            */
 	NULL,//pidgin_conv_custom_smiley_add,    /* custom_smiley_add    */
 	NULL,//pidgin_conv_custom_smiley_write,  /* custom_smiley_write  */
 	NULL,//pidgin_conv_custom_smiley_close,  /* custom_smiley_close  */
 	NULL,//pidgin_conv_send_confirm,         /* send_confirm         */
 	NULL,
 	NULL,
 	NULL,
 	NULL
 };
 struct Dis {
 	std::string name;
 	std::string protocol;
 };
 static gboolean disconnectMe(void *data) {
 	Dis *d = (Dis *) data;
 	PurpleAccount *account = purple_accounts_find(d->name.c_str(), d->protocol.c_str());
 	delete d;
 	if (account) {
 			nickname = displayname;
+		}
 		// avatar
 		PurpleStoredImage *avatar = purple_buddy_icons_find_account_icon(account);
 		if (avatar) {
 			const gchar * data = (const gchar *) purple_imgstore_get_data(avatar);
 			size_t len = purple_imgstore_get_size(avatar);
 			if (len < 300000 && data) {
 				photo = std::string(data, len);
+			}
 			purple_imgstore_unref(avatar);
+		}
+	}
 	PurpleBuddy *buddy = purple_find_buddy(purple_connection_get_account(gc), who);
 	if (buddy && photo.size() == 0) {
 		gsize len;
 		PurpleBuddyIcon *icon = NULL;
 		icon = purple_buddy_icons_find(purple_connection_get_account(gc), name.c_str());
 		if (icon) {
 			if (true) {
 				gchar *data;
 				gchar *path = purple_buddy_icon_get_full_path(icon);
 				if (g_file_get_contents (path, &data, &len, NULL)) {
 					photo = std::string(data, len);
 					free(data);
 				if (path) {
 					if (g_file_get_contents(path, &data, &len, NULL)) {
 						photo = std::string(data, len);
 						g_free(data);
+					}
 					g_free(path);
+				}
 				free(path);
+			}
 			else {
 				const gchar * data = (gchar*)purple_buddy_icon_get_data(icon, &len);
 				if (len < 300000 && data) {
 					photo = std::string(data, len);
+				}
+			}
 			purple_buddy_icon_unref(icon);
+		}
+	}
 	np->handleVCard(np->m_accounts[account], np->m_vcards[np->m_accounts[account] + name], name, fullName, nickname, photo);
 	np->m_vcards.erase(np->m_accounts[account] + name);
 	return NULL;
+}
 static PurpleNotifyUiOps notifyUiOps =
+{
 		NULL,
 		NULL,
 		NULL,
 		NULL,
 		NULL,
 static void buddyTypingStopped(PurpleAccount *account, const char *who, gpointer null){
 	std::string w = purple_normalize(account, who);
 	size_t pos = w.find("/");
 	if (pos != std::string::npos)
 		w.erase((int) pos, w.length() - (int) pos);
 	np->handleBuddyStoppedTyping(np->m_accounts[account], w);
+}
 static void gotAttention(PurpleAccount *account, const char *who, PurpleConversation *conv, guint type) {
 	std::string w = purple_normalize(account, who);
 	size_t pos = w.find("/");
 	if (pos != std::string::npos)
 		w.erase((int) pos, w.length() - (int) pos);
 	np->handleAttention(np->m_accounts[account], w, "");
+}
 static bool initPurple() {
 	bool ret;
 	purple_util_set_user_dir("./");
 	remove("./accounts.xml");
 	remove("./blist.xml");
 // 	if (m_configuration.logAreas & LOG_AREA_PURPLE)
 		purple_debug_set_ui_ops(&debugUiOps);
 		purple_debug_set_verbose(true);
 	purple_debug_set_ui_ops(&debugUiOps);
 	purple_debug_set_verbose(true);
 	purple_core_set_ui_ops(&coreUiOps);
 	if (KEYFILE_STRING("service", "eventloop") == "libev") {
 		LOG4CXX_INFO(logger, "Will use libev based event loop");
+	}
 	else {
 		LOG4CXX_INFO(logger, "Will use glib based event loop");
+	}
 	purple_eventloop_set_ui_ops(getEventLoopUiOps(KEYFILE_STRING("service", "eventloop") == "libev"));
 	ret = purple_core_init("spectrum");
 	if (ret) {
 		static int blist_handle;
 		static int conversation_handle;
 		purple_set_blist(purple_blist_new());
 		purple_blist_load();
 		purple_prefs_load();
 		/* Good default preferences */
 		/* The combination of these two settings mean that libpurple will never
 		 * (of its own accord) set all the user accounts idle.
 		 */
@@ @@ -1845,215 +1557,143 @@ static bool initPurple() { @@
 		purple_signal_connect(purple_conversations_get_handle(), "buddy-typing", &conversation_handle, PURPLE_CALLBACK(buddyTyping), NULL);
 		purple_signal_connect(purple_conversations_get_handle(), "buddy-typed", &conversation_handle, PURPLE_CALLBACK(buddyTyped), NULL);
 		purple_signal_connect(purple_conversations_get_handle(), "buddy-typing-stopped", &conversation_handle, PURPLE_CALLBACK(buddyTypingStopped), NULL);
 		purple_signal_connect(purple_blist_get_handle(), "buddy-privacy-changed", &conversation_handle, PURPLE_CALLBACK(buddyPrivacyChanged), NULL);
 		purple_signal_connect(purple_conversations_get_handle(), "got-attention", &conversation_handle, PURPLE_CALLBACK(gotAttention), NULL);
 		purple_signal_connect(purple_connections_get_handle(), "signed-on", &blist_handle,PURPLE_CALLBACK(signed_on), NULL);
 // 		purple_signal_connect(purple_blist_get_handle(), "buddy-removed", &blist_handle,PURPLE_CALLBACK(buddyRemoved), NULL);
 // 		purple_signal_connect(purple_blist_get_handle(), "buddy-signed-on", &blist_handle,PURPLE_CALLBACK(buddySignedOn), NULL);
 // 		purple_signal_connect(purple_blist_get_handle(), "buddy-signed-off", &blist_handle,PURPLE_CALLBACK(buddySignedOff), NULL);
 // 		purple_signal_connect(purple_blist_get_handle(), "buddy-status-changed", &blist_handle,PURPLE_CALLBACK(buddyStatusChanged), NULL);
 		purple_signal_connect(purple_blist_get_handle(), "blist-node-removed", &blist_handle,PURPLE_CALLBACK(NodeRemoved), NULL);
 // 		purple_signal_connect(purple_conversations_get_handle(), "chat-topic-changed", &conversation_handle, PURPLE_CALLBACK(conv_chat_topic_changed), NULL);
 		static int xfer_handle;
 		purple_signal_connect(purple_xfers_get_handle(), "file-send-start", &xfer_handle, PURPLE_CALLBACK(fileSendStart), NULL);
 		purple_signal_connect(purple_xfers_get_handle(), "file-recv-start", &xfer_handle, PURPLE_CALLBACK(fileRecvStart), NULL);
 		purple_signal_connect(purple_xfers_get_handle(), "file-recv-request", &xfer_handle, PURPLE_CALLBACK(newXfer), NULL);
 		purple_signal_connect(purple_xfers_get_handle(), "file-recv-complete", &xfer_handle, PURPLE_CALLBACK(XferReceiveComplete), NULL);
 		purple_signal_connect(purple_xfers_get_handle(), "file-send-complete", &xfer_handle, PURPLE_CALLBACK(XferSendComplete), NULL);
 //
 // 		purple_commands_init();
+	}
 	return ret;
+}
 #ifndef WIN32
 static void spectrum_sigchld_handler(int sig)
+{
 	int status;
 	pid_t pid;
 	do {
 		pid = waitpid(-1, &status, WNOHANG);
 	} while (pid != 0 && pid != (pid_t)-1);
 	if ((pid == (pid_t) - 1) && (errno != ECHILD)) {
 		char errmsg[BUFSIZ];
 		snprintf(errmsg, BUFSIZ, "Warning: waitpid() returned %d", pid);
 		perror(errmsg);
+	}
+}
 #endif
 static int create_socket(char *host, int portno) {
 	struct sockaddr_in serv_addr;
 	int m_sock = socket(AF_INET, SOCK_STREAM, 0);
 	memset((char *) &serv_addr, 0, sizeof(serv_addr));
 	serv_addr.sin_family = AF_INET;
 	serv_addr.sin_port = htons(portno);
 	hostent *hos;  // Resolve name
 	if ((hos = gethostbyname(host)) == NULL) {
 		// strerror() will not work for gethostbyname() and hstrerror()
 		// is supposedly obsolete
 		exit(1);
+	}
 	serv_addr.sin_addr.s_addr = *((unsigned long *) hos->h_addr_list[0]);
 	if (connect(m_sock, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
 		close(m_sock);
 		m_sock = 0;
+	}
 	int flags = fcntl(m_sock, F_GETFL);
 	flags |= O_NONBLOCK;
 	fcntl(m_sock, F_SETFL, flags);
 	return m_sock;
+}
 static void transportDataReceived(gpointer data, gint source, PurpleInputCondition cond) {
 	if (cond & PURPLE_INPUT_READ) {
 		char buffer[65535];
 		char *ptr = buffer;
 		ssize_t n = read(source, ptr, sizeof(buffer));
 		if (n <= 0) {
 			LOG4CXX_INFO(logger, "Diconnecting from spectrum2 server");
 			exit(errno);
+		}
 		std::string d = std::string(buffer, n);
 		np->handleDataRead(d);
+	}
 	else {
 		if (writeInput != 0) {
 			purple_input_remove(writeInput);
 			writeInput = 0;
+		}
 		np->readyForData();
+	}
+}
 int main(int argc, char **argv) {
 	GError *error = NULL;
 	GOptionContext *context;
 	context = g_option_context_new("config_file_name or profile name");
 	g_option_context_add_main_entries(context, options_entries, "");
 	if (!g_option_context_parse (context, &argc, &argv, &error)) {
-		std::cout << "option parsing failed: " << error->message << "\n";
+		std::cerr << "option parsing failed: " << error->message << "\n";
 		return -1;
+	}
 	if (ver) {
 // 		std::cout << VERSION << "\n";
 		std::cout << "verze\n";
 		g_option_context_free(context);
 		return 0;
+	}
 	if (argc != 2) {
 #ifdef WIN32
 		std::cout << "Usage: spectrum.exe <configuration_file.cfg>\n";
 #else
 #if GLIB_CHECK_VERSION(2,14,0)
 	std::cout << g_option_context_get_help(context, FALSE, NULL);
 #else
 	std::cout << "Usage: spectrum <configuration_file.cfg>\n";
 	std::cout << "See \"man spectrum\" for more info.\n";
 #endif
 #endif
+	}
 	else {
 #ifndef WIN32
 		signal(SIGPIPE, SIG_IGN);
 		if (signal(SIGCHLD, spectrum_sigchld_handler) == SIG_ERR) {
 			std::cout << "SIGCHLD handler can't be set\n";
 			g_option_context_free(context);
 			return -1;
+		}
 //
 // 		if (signal(SIGINT, spectrum_sigint_handler) == SIG_ERR) {
 // 			std::cout << "SIGINT handler can't be set\n";
 // 			g_option_context_free(context);
 // 			return -1;
 // 		}
 //
 // 		if (signal(SIGTERM, spectrum_sigterm_handler) == SIG_ERR) {
 // 			std::cout << "SIGTERM handler can't be set\n";
 // 			g_option_context_free(context);
 // 			return -1;
 // 		}
 //
 // 		struct sigaction sa;
 // 		memset(&sa, 0, sizeof(sa));
 // 		sa.sa_handler = spectrum_sighup_handler;
 // 		if (sigaction(SIGHUP, &sa, NULL)) {
 // 			std::cout << "SIGHUP handler can't be set\n";
 // 			g_option_context_free(context);
 // 			return -1;
 //		}
 #endif
 		keyfile = g_key_file_new ();
 		if (!g_key_file_load_from_file (keyfile, argv[1], (GKeyFileFlags) 0, 0)) {
 			std::cout << "Can't open " << argv[1] << " configuration file.\n";
 			return 1;
+		}
 		if (KEYFILE_STRING("logging", "backend_config").empty()) {
 			LoggerPtr root = log4cxx::Logger::getRootLogger();
 #ifndef _MSC_VER
 			root->addAppender(new ConsoleAppender(new PatternLayout("%d %-5p %c: %m%n")));
 #else
 			root->addAppender(new ConsoleAppender(new PatternLayout(L"%d %-5p %c: %m%n")));
 #endif
+		}
 		else {
 			log4cxx::helpers::Properties p;
 			log4cxx::helpers::FileInputStream *istream = new log4cxx::helpers::FileInputStream(KEYFILE_STRING("logging", "backend_config"));
 			p.load(istream);
 			LogString pid, jid;
 			log4cxx::helpers::Transcoder::decode(stringOf(getpid()), pid);
 			log4cxx::helpers::Transcoder::decode(KEYFILE_STRING("service", "jid"), jid);
 #ifdef _MSC_VER
 			p.setProperty(L"pid", pid);
 			p.setProperty(L"jid", jid);
 #else
 			p.setProperty("pid", pid);
 			p.setProperty("jid", jid);
 #endif
 			log4cxx::PropertyConfigurator::configure(p);
+		}
 		initPurple();
 		m_sock = create_socket(host, port);
 		purple_input_add(m_sock, PURPLE_INPUT_READ, &transportDataReceived, NULL);
 		main_socket = create_socket(host, port);
 		purple_input_add(main_socket, PURPLE_INPUT_READ, &transportDataReceived, NULL);
 		purple_timeout_add_seconds(30, pingTimeout, NULL);
-		np = new SpectrumNetworkPlugin(host, port);
 		np = new SpectrumNetworkPlugin();
 		bool libev = KEYFILE_STRING("service", "eventloop") == "libev";
 		GMainLoop *m_loop;
 #ifdef WITH_LIBEVENT
 		if (!libev) {
 			m_loop = g_main_loop_new(NULL, FALSE);
+		}
 		else {
 			event_init();
+		}
 #endif
 		m_loop = g_main_loop_new(NULL, FALSE);
 		if (m_loop) {
 			g_main_loop_run(m_loop);
+		}
 #ifdef WITH_LIBEVENT
 		else {
 			event_loop(0);
+		}
 #endif
+	}
 	g_option_context_free(context);

backends/libpurple/utils.cpp

➞

Show inline comments

@@ new file 100644 @@
 /**
  * libtransport -- C++ library for easy XMPP Transports development
+ *
  * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "utils.h"
 #include "glib.h"
 #include "purple.h"
 #include <algorithm>
 #include <iostream>
 #include "errno.h"
 #ifndef WIN32
 #include "sys/wait.h"
 #include "sys/signal.h"
 #include <netinet/if_ether.h>
 #include <netinet/ip.h>
 #include <netinet/ip6.h>
 #include <netinet/udp.h>
 #include <netinet/tcp.h>
 #include <netinet/ether.h>
 #include "sys/socket.h"
 #include <netdb.h>
 #include <unistd.h>
 #include <fcntl.h>
 #else
 #include <process.h>
 #define getpid _getpid
 #define ssize_t SSIZE_T
 #include "win32/win32dep.h"
 #endif
 static GHashTable *ui_info = NULL;
 GHashTable *spectrum_ui_get_info(void)
+{
 	if(NULL == ui_info) {
 		ui_info = g_hash_table_new(g_str_hash, g_str_equal);
 		g_hash_table_insert(ui_info, g_strdup("name"), g_strdup("Spectrum"));
 		g_hash_table_insert(ui_info, g_strdup("version"), g_strdup("0.5"));
 		g_hash_table_insert(ui_info, g_strdup("website"), g_strdup("http://spectrum.im"));
 		g_hash_table_insert(ui_info, g_strdup("dev_website"), g_strdup("http://spectrum.im"));
 		g_hash_table_insert(ui_info, g_strdup("client_type"), g_strdup("pc"));
 		/*
 		 * This is the client key for "Pidgin."  It is owned by the AIM
 		 * account "markdoliner."  Please don't use this key for other
 		 * applications.  You can either not specify a client key, in
 		 * which case the default "libpurple" key will be used, or you
 		 * can register for your own client key at
 		 * http://developer.aim.com/manageKeys.jsp
 		 */
 		g_hash_table_insert(ui_info, g_strdup("prpl-aim-clientkey"), g_strdup("ma1cSASNCKFtrdv9"));
 		g_hash_table_insert(ui_info, g_strdup("prpl-icq-clientkey"), g_strdup("ma1cSASNCKFtrdv9"));
 		/*
 		 * This is the distid for Pidgin, given to us by AOL.  Please
 		 * don't use this for other applications.  You can just not
 		 * specify a distid and libpurple will use a default.
 		 */
 		g_hash_table_insert(ui_info, g_strdup("prpl-aim-distid"), GINT_TO_POINTER(1550));
 		g_hash_table_insert(ui_info, g_strdup("prpl-icq-distid"), GINT_TO_POINTER(1550));
+	}
 	return ui_info;
+}
 #ifndef WIN32
 void spectrum_sigchld_handler(int sig)
+{
 	int status;
 	pid_t pid;
 	do {
 		pid = waitpid(-1, &status, WNOHANG);
 	} while (pid != 0 && pid != (pid_t)-1);
 	if ((pid == (pid_t) - 1) && (errno != ECHILD)) {
 		char errmsg[BUFSIZ];
 		snprintf(errmsg, BUFSIZ, "Warning: waitpid() returned %d", pid);
 		perror(errmsg);
+	}
+}
 #endif
 int create_socket(char *host, int portno) {
 	struct sockaddr_in serv_addr;
 	int main_socket = socket(AF_INET, SOCK_STREAM, 0);
 	memset((char *) &serv_addr, 0, sizeof(serv_addr));
 	serv_addr.sin_family = AF_INET;
 	serv_addr.sin_port = htons(portno);
 	hostent *hos;  // Resolve name
 	if ((hos = gethostbyname(host)) == NULL) {
 		// strerror() will not work for gethostbyname() and hstrerror()
 		// is supposedly obsolete
 		exit(1);
+	}
 	serv_addr.sin_addr.s_addr = *((unsigned long *) hos->h_addr_list[0]);
 	if (connect(main_socket, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
 		close(main_socket);
 		main_socket = 0;
+	}
 	int flags = fcntl(main_socket, F_GETFL);
 	flags |= O_NONBLOCK;
 	fcntl(main_socket, F_SETFL, flags);
 	return main_socket;
+}

backends/libpurple/utils.h

➞

Show inline comments

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

backends/skype/main.cpp

➞

Show inline comments

 #include "glib.h"
 #include <iostream>
 #include "transport/config.h"
 #include "transport/logging.h"
 #include "transport/transport.h"
 #include "transport/usermanager.h"
 #include "transport/memoryusage.h"
 #include "transport/logger.h"
 #include "transport/sqlite3backend.h"
 #include "transport/userregistration.h"
 #include "transport/user.h"
 #include "transport/storagebackend.h"
 #include "transport/rostermanager.h"
 #include "transport/conversation.h"
 #include "transport/networkplugin.h"
 #include <boost/filesystem.hpp>
 #include "log4cxx/logger.h"
 #include "log4cxx/consoleappender.h"
 #include "log4cxx/patternlayout.h"
 #include "log4cxx/propertyconfigurator.h"
 #include "log4cxx/helpers/properties.h"
 #include "log4cxx/helpers/fileinputstream.h"
 #include "sys/wait.h"
 #include "sys/signal.h"
 // #include "valgrind/memcheck.h"
 #include "malloc.h"
 #include <dbus-1.0/dbus/dbus-glib-lowlevel.h>
 using namespace log4cxx;
 static LoggerPtr logger = Logger::getLogger("backend");
 using namespace Transport;
 class SpectrumNetworkPlugin;
 #define GET_RESPONSE_DATA(RESP, DATA) ((RESP.find(std::string(DATA) + " ") != std::string::npos) ? RESP.substr(RESP.find(DATA) + strlen(DATA) + 1) : "");
 #define GET_PROPERTY(VAR, OBJ, WHICH, PROP) std::string VAR = sk->send_command(std::string("GET ") + OBJ + " " + WHICH + " " + PROP); \
 					VAR = GET_RESPONSE_DATA(VAR, PROP);
 SpectrumNetworkPlugin *np;
 static gboolean nodaemon = FALSE;
 static gchar *logfile = NULL;
 static gchar *lock_file = NULL;
 static gchar *host = NULL;
 static int port = 10000;
 static gboolean ver = FALSE;
 static gboolean list_purple_settings = FALSE;
 int m_sock;
 static int writeInput;
 static GOptionEntry options_entries[] = {
 	{ "nodaemon", 'n', 0, G_OPTION_ARG_NONE, &nodaemon, "Disable background daemon mode", NULL },
 	{ "logfile", 'l', 0, G_OPTION_ARG_STRING, &logfile, "Set file to log", NULL },
 	{ "pidfile", 'p', 0, G_OPTION_ARG_STRING, &lock_file, "File where to write transport PID", NULL },
 	{ "version", 'v', 0, G_OPTION_ARG_NONE, &ver, "Shows Spectrum version", NULL },
 	{ "list-purple-settings", 's', 0, G_OPTION_ARG_NONE, &list_purple_settings, "Lists purple settings which can be used in config file", NULL },
 	{ "host", 'h', 0, G_OPTION_ARG_STRING, &host, "Host to connect to", NULL },
 	{ "port", 'p', 0, G_OPTION_ARG_INT, &port, "Port to connect to", NULL },
 	{ NULL, 0, 0, G_OPTION_ARG_NONE, NULL, "", NULL }
 };
 DBusHandlerResult skype_notify_handler(DBusConnection *connection, DBusMessage *message, gpointer user_data);
 static pbnetwork::StatusType getStatus(const std::string &st) {
 	pbnetwork::StatusType status = pbnetwork::STATUS_ONLINE;
 	if (st == "SKYPEOUT" || st == "OFFLINE") {
 		status = pbnetwork::STATUS_NONE;
+	}
 	else if (st == "DND") {
 		status = pbnetwork::STATUS_DND;
+	}
 	else if (st == "NA") {
 		status = pbnetwork::STATUS_XA;
+	}
 	else if (st == "AWAY") {
 		status = pbnetwork::STATUS_AWAY;
+	}
 	return status;
+}
 class Skype {
 	public:
 		Skype(const std::string &user, const std::string &username, const std::string &password);
 		~Skype() { logout(); }
+		~Skype() { LOG4CXX_INFO(logger, "Skype instance desctuctor"); logout(); }
 		void login();
 		void logout();
 		std::string send_command(const std::string &message);
 		const std::string &getUser() {
 			return m_user;
+		}
 		const std::string &getUsername() {
 			return m_username;
+		}
 		bool createDBusProxy();
 		bool loadSkypeBuddies();
 		int getPid() {
 			return (int) m_pid;
+		}
 	private:
 		std::string m_username;
 		std::string m_password;
 		GPid m_pid;
 		DBusGConnection *m_connection;
 		DBusGProxy *m_proxy;
 		std::string m_user;
 		int m_timer;
 		int m_counter;
 		int fd_output;
 };
 class SpectrumNetworkPlugin : public NetworkPlugin {
 	public:
 		SpectrumNetworkPlugin(Config *config, const std::string &host, int port) : NetworkPlugin() {
 			this->config = config;
 			LOG4CXX_INFO(logger, "Starting the backend.");
+		}
 		~SpectrumNetworkPlugin() {
 			for (std::map<Skype *, std::string>::iterator it = m_accounts.begin(); it != m_accounts.end(); it++) {
 				delete (*it).first;
+			}
+		}
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 			std::string name = legacyName;
 			name = name.substr(name.find(".") + 1);
 			if (name.find("skype.") == 0 || name.find("prpl-skype.") == 0) {
 				name = name.substr(name.find(".") + 1);
+			}
 			LOG4CXX_INFO(logger,  "Creating account with name '" << name << "'");
 			Skype *skype = new Skype(user, name, password);
 			m_sessions[user] = skype;
 			m_accounts[skype] = user;
 			skype->login();
+		}
 		void handleMemoryUsage(double &res, double &shared) {
 			res = 0;
 			shared = 0;
 			for(std::map<std::string, Skype *>::const_iterator it = m_sessions.begin(); it != m_sessions.end(); it++) {
 				Skype *skype = it->second;
 				if (skype) {
 					double r;
 					double s;
 					process_mem_usage(s, r, skype->getPid());
 					res += r;
 					shared += s;
+				}
+			}
+		}
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 			Skype *skype = m_sessions[user];
 			if (skype) {
 				LOG4CXX_INFO(logger, "User wants to logout, logging out");
 				skype->logout();
 				exit(1);
+			}
+		}
 		void handleStatusChangeRequest(const std::string &user, int status, const std::string &statusMessage) {
 			Skype *skype = m_sessions[user];
 			if (!skype)
 				return;
 			std::string st;
 			switch(status) {
 				case Swift::StatusShow::Away: {
 					st = "AWAY";
 					break;
+				}
 				case Swift::StatusShow::DND: {
 					st = "DND";
 					break;
+				}
 				case Swift::StatusShow::XA: {
 					st = "NA";
 					break;
+				}
 				case Swift::StatusShow::None: {
 					break;
+				}
 				case pbnetwork::STATUS_INVISIBLE:
 					st = "INVISIBLE";
 					break;
 				default:
 					st = "ONLINE";
 					break;
+			}
 			skype->send_command("SET USERSTATUS " + st);
 			if (!statusMessage.empty()) {
 				skype->send_command("SET PROFILE MOOD_TEXT " + statusMessage);
+			}
+		}
 		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups) {
 			Skype *skype = m_sessions[user];
 			if (skype) {
 				skype->send_command("SET USER " + buddyName + " BUDDYSTATUS 2 Please authorize me");
 				skype->send_command("SET USER " + buddyName + " ISAUTHORIZED TRUE");
+			}
+		}
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups) {
 			Skype *skype = m_sessions[user];
 			if (skype) {
 				skype->send_command("SET USER " + buddyName + " BUDDYSTATUS 1");
+			}
+		}
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml) {
 			Skype *skype = m_sessions[user];
 			if (skype) {
 				skype->send_command("MESSAGE " + legacyName + " " + message);
+			}
+		}
 		void handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id) {
 			Skype *skype = m_sessions[user];
 			if (skype) {
 				std::string name = legacyName;
 				if (name.find("skype.") == 0) {
 					name = name.substr(6);
+				}
 				std::string photo;
 				gchar *filename = NULL;
 				gchar *new_filename = NULL;
 				gchar *image_data = NULL;
 				gsize image_data_len = 0;
 				gchar *ret;
 				int fh;
 				GError *error;
 				const gchar *userfiles[] = {"user256", "user1024", "user4096", "user16384", "user32768", "user65536",
@@ @@ -232,70 +275,63 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 								//look for start of JPEG block
 								img_start = (char *)memmem(start, end-start, "\xFF\xD8", 2);
 								if (img_start)
+								{
 									//look for end of JPEG block
 									char *img_end = (char *)memmem(img_start, end-img_start, "\xFF\xD9", 2);
 									if (img_end)
+									{
 										image_data_len = img_end - img_start + 2;
 										photo = std::string(img_start, image_data_len);
+									}
+								}
+							}
+						}
 						g_free(image_data);
+					}
 					g_free(filename);
+				}
 				g_free(username);
 				std::string alias = "";
 				std::cout << skype->getUsername() << " " << name << "\n";
 				if (skype->getUsername() == name) {
 					alias = skype->send_command("GET PROFILE FULLNAME");
-					alias = alias.substr(17);
+					alias = GET_RESPONSE_DATA(alias, "FULLNAME")
+				}
 				handleVCard(user, id, legacyName, "", alias, photo);
+			}
+		}
 		void sendData(const std::string &string) {
 			write(m_sock, string.c_str(), string.size());
 // 			if (writeInput == 0)
 // 				writeInput = purple_input_add(m_sock, PURPLE_INPUT_WRITE, &transportDataReceived, NULL);
+		}
 		void handleVCardUpdatedRequest(const std::string &user, const std::string &p, const std::string &nickname) {
+		}
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups) {
+		}
 		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups) {
+		}
 		void handleBuddyBlockToggled(const std::string &user, const std::string &buddyName, bool blocked) {
+		}
 		void handleTypingRequest(const std::string &user, const std::string &buddyName) {
+		}
 		void handleTypedRequest(const std::string &user, const std::string &buddyName) {
+		}
 		void handleStoppedTypingRequest(const std::string &user, const std::string &buddyName) {
+		}
 		void handleAttentionRequest(const std::string &user, const std::string &buddyName, const std::string &message) {
+		}
 		std::map<std::string, Skype *> m_sessions;
 		std::map<Skype *, std::string> m_accounts;
 		std::map<std::string, unsigned int> m_vcards;
 		Config *config;
 	m_pid = 0;
 	m_connection = 0;
 	m_proxy = 0;
 	m_timer = -1;
 	m_counter = 0;
+}
 static gboolean load_skype_buddies(gpointer data) {
 	Skype *skype = (Skype *) data;
 	return skype->loadSkypeBuddies();
+}
 bool Skype::createDBusProxy() {
 	if (m_proxy == NULL) {
 		LOG4CXX_INFO(logger, "Creating DBus proxy for com.Skype.Api.");
 		m_counter++;
 		GError *error = NULL;
 		m_proxy = dbus_g_proxy_new_for_name_owner (m_connection, "com.Skype.API", "/com/Skype", "com.Skype.API", &error);
 		if (m_proxy == NULL && error != NULL) {
 			LOG4CXX_INFO(logger,  m_username << ":" << error->message);
 			if (m_counter == 15) {
 				np->handleDisconnected(m_user, 0, error->message);
 				LOG4CXX_ERROR(logger, "Logging out, proxy couldn't be created");
 				np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE, error->message);
 				logout();
 				g_error_free(error);
 				return FALSE;
+			}
 			g_error_free(error);
+		}
 		if (m_proxy) {
 			LOG4CXX_INFO(logger, "Proxy created.");
 			DBusObjectPathVTable vtable;
 			vtable.message_function = &skype_notify_handler;
 			dbus_connection_register_object_path(dbus_g_connection_get_connection(m_connection), "/com/Skype/Client", &vtable, this);
 			m_counter = 0;
 			m_timer = g_timeout_add_seconds(1, load_skype_buddies, this);
 			return FALSE;
+		}
 		return TRUE;
+	}
 	return FALSE;
+}
 static gboolean create_dbus_proxy(gpointer data) {
 	Skype *skype = (Skype *) data;
 	return skype->createDBusProxy();
+}
 void Skype::login() {
 	if (m_username.find("..") == 0 || m_username.find("/") != std::string::npos) {
 		np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE, "Invalid username");
 		return;
+	}
 	boost::filesystem::remove_all(std::string("/tmp/skype/") + m_username);
 	boost::filesystem::path	path(std::string("/tmp/skype/") + m_username);
 	if (!boost::filesystem::exists(path)) {
 		boost::filesystem::create_directories(path);
 		boost::filesystem::path	path2(std::string("/tmp/skype/") + m_username + "/" + m_username );
 		boost::filesystem::create_directories(path2);
+	}
 	std::string shared_xml = "<?xml version=\"1.0\"?>\n"
 							"<config version=\"1.0\" serial=\"28\" timestamp=\"" + boost::lexical_cast<std::string>(time(NULL)) + ".0\">\n"
 							"<UI>\n"
 								"<Installed>2</Installed>\n"
 								"<Language>en</Language>\n"
 							"</UI>\n"
 							"</config>\n";
 	g_file_set_contents(std::string(std::string("/tmp/skype/") + m_username + "/shared.xml").c_str(), shared_xml.c_str(), -1, NULL);
 	std::string config_xml = "<?xml version=\"1.0\"?>\n"
 							"<config version=\"1.0\" serial=\"7\" timestamp=\"" + boost::lexical_cast<std::string>(time(NULL)) + ".0\">\n"
 								"<Lib>\n"
 									"<Account>\n"
 									"<IdleTimeForAway>30000000</IdleTimeForAway>\n"
 									"<IdleTimeForNA>300000000</IdleTimeForNA>\n"
 									"<LastUsed>" + boost::lexical_cast<std::string>(time(NULL)) + "</LastUsed>\n"
 									"</Account>\n"
 								"</Lib>\n"
 								"<UI>\n"
 									"<API>\n"
 									"<Authorizations>Spectrum</Authorizations>\n"
 									"<BlockedPrograms></BlockedPrograms>\n"
 									"</API>\n"
 								"</UI>\n"
 							"</config>\n";
 	g_file_set_contents(std::string(std::string("/tmp/skype/") + m_username + "/" + m_username +"/config.xml").c_str(), config_xml.c_str(), -1, NULL);
 	sleep(1);
 	std::string db_path = std::string("/tmp/skype/") + m_username;
 	char *db = (char *) malloc(db_path.size() + 1);
 	strcpy(db, db_path.c_str());
 	LOG4CXX_INFO(logger,  m_username << ": Spawning new Skype instance dbpath=" << db);
 	gchar* argv[6] = {"skype", "--disable-cleanlooks", "--pipelogin", "--dbpath", db, 0};
 	int fd;
 	g_spawn_async_with_pipes(NULL,
 		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);
 	//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;
+		}
+	}
 	sleep(1);
 	m_timer = g_timeout_add_seconds(1, create_dbus_proxy, this);
+}
 bool Skype::loadSkypeBuddies() {
 //	std::string re = "CONNSTATUS OFFLINE";
 //	while (re == "CONNSTATUS OFFLINE" || re.empty()) {
 //		sleep(1);
 	gchar buffer[1024];
 	int bytes_read = read(fd_output, buffer, 1023);
 	if (bytes_read > 0) {
 		buffer[bytes_read] = 0;
 		np->handleDisconnected(m_user, 0, buffer);
 		close(fd_output);
 		logout();
 		return FALSE;
 		std::string b(buffer);
 		LOG4CXX_WARN(logger, "Skype wrote this on stdout '" << b << "'");
 		if (b.find("Incorrect Password") != std::string::npos) {
 			LOG4CXX_INFO(logger, "Incorrect password, logging out")
 			np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_FAILED, "Incorrect password");
 			close(fd_output);
 			logout();
 			return FALSE;
+		}
+	}
 	std::string re = send_command("NAME Spectrum");
 	if (m_counter++ > 15) {
 		np->handleDisconnected(m_user, 0, "");
 		LOG4CXX_ERROR(logger, "Logging out, because we tried to connect the Skype over DBUS 15 times without success");
 		np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE, "Skype is not ready. This issue have been logged and admins will check it and try to fix it soon.");
 		close(fd_output);
 		logout();
 		return FALSE;
+	}
 	if (re.empty() || re == "CONNSTATUS OFFLINE") {
+	if (re.empty() || re == "CONNSTATUS OFFLINE" || re == "ERROR 68") {
 		return TRUE;
+	}
 	close(fd_output);
 	if (send_command("PROTOCOL 7") != "PROTOCOL 7") {
 		np->handleDisconnected(m_user, 0, "Skype is not ready");
 		LOG4CXX_ERROR(logger, "PROTOCOL 7 failed, logging out");
 		np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE, "Skype is not ready. This issue have been logged and admins will check it and try to fix it soon.");
 		logout();
 		return FALSE;
+	}
 	np->handleConnected(m_user);
 	std::map<std::string, std::string> group_map;
 	std::string groups = send_command("SEARCH GROUPS CUSTOM");
 	groups = groups.substr(groups.find(' ') + 1);
 	std::vector<std::string> grps;
 	boost::split(grps, groups, boost::is_any_of(","));
 	BOOST_FOREACH(std::string grp, grps) {
 		std::vector<std::string> data;
 		std::string name = send_command("GET GROUP " + grp + " DISPLAYNAME");
 		boost::split(data, name, boost::is_any_of(" "));
 		name = name.substr(name.find("DISPLAYNAME") + 12);
 		std::string users = send_command("GET GROUP " + data[1] + " USERS");
 		users = name.substr(name.find("USERS") + 6);
 		boost::split(data, users, boost::is_any_of(","));
 		BOOST_FOREACH(std::string u, data) {
 			group_map[u] = grp;
 	if (groups.find(' ') != std::string::npos) {
 		groups = groups.substr(groups.find(' ') + 1);
 		std::vector<std::string> grps;
 		boost::split(grps, groups, boost::is_any_of(","));
 		BOOST_FOREACH(std::string grp, grps) {
 			std::vector<std::string> data;
 			std::string name = send_command("GET GROUP " + grp + " DISPLAYNAME");
 			if (name.find("ERROR") == 0) {
 				continue;
+			}
 			boost::split(data, name, boost::is_any_of(" "));
 			name = GET_RESPONSE_DATA(name, "DISPLAYNAME");
 			std::string users = send_command("GET GROUP " + data[1] + " USERS");
 			users = GET_RESPONSE_DATA(users, "USERS");
 			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(","));
+			}
@@ @@ -544,146 +603,152 @@ bool Skype::loadSkypeBuddies() { @@
 	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;
+	}
+}
 std::string Skype::send_command(const std::string &message) {
 	GError *error = NULL;
 	gchar *str = NULL;
 // 			int message_num;
 // 			gchar error_return[30];
 	LOG4CXX_INFO(logger, "Sending: '" << message << "'");
 	if (!dbus_g_proxy_call (m_proxy, "Invoke", &error, G_TYPE_STRING, message.c_str(), G_TYPE_INVALID,
 						G_TYPE_STRING, &str, G_TYPE_INVALID))
+	{
 			if (error && error->message)
+			{
 			LOG4CXX_INFO(logger,  m_username << ": DBUS Error: " << error->message);
 			g_error_free(error);
 			return "";
 		} else {
 			LOG4CXX_INFO(logger,  m_username << ": DBUS no response");
 			return "";
+		}
+	}
 	if (str != NULL)
+	{
 		LOG4CXX_INFO(logger,  m_username << ": DBUS:" << str);
+		LOG4CXX_INFO(logger,  m_username << ": DBUS:'" << str << "'");
+	}
 	return str ? std::string(str) : std::string();
+}
 static void handle_skype_message(std::string &message, Skype *sk) {
 	std::vector<std::string> cmd;
 	boost::split(cmd, message, boost::is_any_of(" "));
 	if (cmd[0] == "USER") {
 		if (cmd[1] == sk->getUsername()) {
 			return;
+		}
 		if (cmd[2] == "ONLINESTATUS") {
 			if (cmd[3] == "SKYPEOUT" || cmd[3] == "UNKNOWN") {
 				return;
+			}
 			else {
 				pbnetwork::StatusType status = getStatus(cmd[3]);
 				std::string mood_text = sk->send_command("GET USER " + cmd[1] + " MOOD_TEXT");
 				mood_text = mood_text.substr(mood_text.find("MOOD_TEXT") + 10);
 				std::string alias = sk->send_command("GET USER " + cmd[1] + " FULLNAME");
 				alias = alias.substr(alias.find("FULLNAME") + 9);
 				GET_PROPERTY(mood_text, "USER", cmd[1], "MOOD_TEXT");
 				GET_PROPERTY(alias, "USER", cmd[1], "FULLNAME");
 				std::vector<std::string> groups;
 				np->handleBuddyChanged(sk->getUser(), cmd[1], alias, groups, status, mood_text);
+			}
+		}
 		else if (cmd[2] == "MOOD_TEXT") {
 			std::string st = sk->send_command("GET USER " + cmd[1] + " ONLINESTATUS");
 			st = st.substr(st.find("ONLINESTATUS") + 13);
 			GET_PROPERTY(st, "USER", cmd[1], "ONLINESTATUS");
 			pbnetwork::StatusType status = getStatus(st);
-			std::string mood_text = message.substr(message.find("MOOD_TEXT") + 10);
+			std::string mood_text = GET_RESPONSE_DATA(message, "MOOD_TEXT");
 			std::vector<std::string> groups;
 			np->handleBuddyChanged(sk->getUser(), cmd[1], "", groups, status, mood_text);
+		}
 		else if (cmd[2] == "BUDDYSTATUS" && cmd[3] == "3") {
 			std::string st = sk->send_command("GET USER " + cmd[1] + " ONLINESTATUS");
 			st = st.substr(st.find("ONLINESTATUS") + 13);
 			GET_PROPERTY(mood_text, "USER", cmd[1], "MOOD_TEXT");
 			GET_PROPERTY(st, "USER", cmd[1], "ONLINESTATUS");
 			pbnetwork::StatusType status = getStatus(st);
 			std::string mood_text = message.substr(message.find("MOOD_TEXT") + 10);
 			std::vector<std::string> groups;
 			np->handleBuddyChanged(sk->getUser(), cmd[1], "", groups, status, mood_text);
+		}
 		else if (cmd[2] == "FULLNAME") {
 			std::string st = sk->send_command("GET USER " + cmd[1] + " ONLINESTATUS");
 			st = st.substr(st.find("ONLINESTATUS") + 13);
 			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::string mood_text = sk->send_command("GET USER " + cmd[1] + " MOOD_TEXT");
 			mood_text = mood_text.substr(mood_text.find("MOOD_TEXT") + 10);
 			std::string alias = message.substr(message.find("FULLNAME") + 9);
 			std::vector<std::string> groups;
 			np->handleBuddyChanged(sk->getUser(), cmd[1], alias, groups, status, mood_text);
+		}
+	}
 	else if (cmd[0] == "CHATMESSAGE") {
 		if (cmd[3] == "RECEIVED") {
 			std::string body = sk->send_command("GET CHATMESSAGE " + cmd[1] + " BODY");
 			body = body.substr(body.find("BODY") + 5);
 			GET_PROPERTY(body, "CHATMESSAGE", cmd[1], "BODY");
 			GET_PROPERTY(from_handle, "CHATMESSAGE", cmd[1], "FROM_HANDLE");
 			std::string chatname = sk->send_command("GET CHATMESSAGE " + cmd[1] + " CHATNAME");
 			size_t start = chatname.find("$") + 1;
 			size_t len = chatname.find(";") - start;
 			std::string from = chatname.substr(start, len);
 			std::string from_handle = sk->send_command("GET CHATMESSAGE " + cmd[1] + " FROM_HANDLE");
 			from_handle = from_handle.substr(from_handle.find("FROM_HANDLE") + 12);
 // 			if (from_handle != sk->getUsername()) {
 				from = from_handle;
 // 			}
 			if (from_handle == sk->getUsername())
 				return;
 			np->handleMessage(sk->getUser(), from, body);
 			np->handleMessage(sk->getUser(), from_handle, body);
 			sk->send_command("SET CHATMESSAGE " + cmd[1] + " SEEN");
+		}
+	}
 	else if (cmd[0] == "CALL") {
 		// CALL 884 STATUS RINGING
 		if (cmd[2] == "STATUS") {
 			if (cmd[3] == "RINGING" || cmd[3] == "MISSED") {
 				// handle only incoming calls
 				GET_PROPERTY(type, "CALL", cmd[1], "TYPE");
 				if (type.find("INCOMING") != 0) {
 					return;
+				}
 				GET_PROPERTY(from, "CALL", cmd[1], "PARTNER_HANDLE");
 				GET_PROPERTY(dispname, "CALL", cmd[1], "PARTNER_DISPNAME");
 				if (cmd[3] == "RINGING") {
 					np->handleMessage(sk->getUser(), from, "User " + dispname + " is calling you.");
+				}
 				else {
 					np->handleMessage(sk->getUser(), from, "You have missed call from user " + dispname + ".");
+				}
+			}
+		}
+	}
+}
 DBusHandlerResult skype_notify_handler(DBusConnection *connection, DBusMessage *message, gpointer user_data) {
 	DBusMessageIter iterator;
 	gchar *message_temp;
 	DBusMessage *temp_message;
 	temp_message = dbus_message_ref(message);
 	dbus_message_iter_init(temp_message, &iterator);
 	if (dbus_message_iter_get_arg_type(&iterator) != DBUS_TYPE_STRING)
+	{
 		dbus_message_unref(message);
 		return (DBusHandlerResult) FALSE;
+	}
 	do {
 		dbus_message_iter_get_basic(&iterator, &message_temp);
 		std::string m(message_temp);
 		LOG4CXX_INFO(logger,"DBUS message: " << m);
 		handle_skype_message(m, (Skype *) user_data);
 	} while(dbus_message_iter_has_next(&iterator) && dbus_message_iter_next(&iterator));
@@ @@ -804,60 +869,49 @@ int main(int argc, char **argv) { @@
 // 			return -1;
 // 		}
 //
 // 		if (signal(SIGTERM, spectrum_sigterm_handler) == SIG_ERR) {
 // 			std::cout << "SIGTERM handler can't be set\n";
 // 			g_option_context_free(context);
 // 			return -1;
 // 		}
 //
 // 		struct sigaction sa;
 // 		memset(&sa, 0, sizeof(sa));
 // 		sa.sa_handler = spectrum_sighup_handler;
 // 		if (sigaction(SIGHUP, &sa, NULL)) {
 // 			std::cout << "SIGHUP handler can't be set\n";
 // 			g_option_context_free(context);
 // 			return -1;
 //		}
 #endif
 		Config config;
 		if (!config.load(argv[1])) {
 			std::cout << "Can't open " << argv[1] << " configuration file.\n";
 			return 1;
+		}
 		if (CONFIG_STRING(&config, "logging.backend_config").empty()) {
 			LoggerPtr root = log4cxx::Logger::getRootLogger();
 			root->addAppender(new ConsoleAppender(new PatternLayout("%d %-5p %c: %m%n")));
+		}
 		else {
 			log4cxx::helpers::Properties p;
 			log4cxx::helpers::FileInputStream *istream = new log4cxx::helpers::FileInputStream(CONFIG_STRING(&config, "logging.backend_config"));
 			p.load(istream);
 			p.setProperty("pid", boost::lexical_cast<std::string>(getpid()));
 			log4cxx::PropertyConfigurator::configure(p);
+		}
 		Logging::initBackendLogging(&config);
 // 		initPurple(config);
 		g_type_init();
 		m_sock = create_socket(host, port);
 		g_set_printerr_handler(log_glib_error);
 	GIOChannel *channel;
 	GIOCondition cond = (GIOCondition) G_IO_IN;
 	channel = g_io_channel_unix_new(m_sock);
 	g_io_add_watch_full(channel, G_PRIORITY_DEFAULT, cond, transportDataReceived, NULL, io_destroy);
 		np = new SpectrumNetworkPlugin(&config, host, port);
 		GMainLoop *m_loop;
 		m_loop = g_main_loop_new(NULL, FALSE);
 		if (m_loop) {
 			g_main_loop_run(m_loop);
+		}
+	}

backends/smstools3/main.cpp

➞

Show inline comments

 /*
  * Copyright (C) 2008-2009 J-P Nurmi jpnurmi@gmail.com
+ *
  * This example is free, and not covered by LGPL license. There is no
  * restriction applied to their modification, redistribution, using and so on.
  * You can study them, modify them, use them in your own program - either
  * completely or partially. By using it you may give me some credits in your
  * program, but you don't have to.
  */
 #include "transport/config.h"
 #include "transport/logging.h"
 #include "transport/networkplugin.h"
 #include "transport/sqlite3backend.h"
 #include "transport/mysqlbackend.h"
 #include "transport/pqxxbackend.h"
 #include "transport/storagebackend.h"
 #include "Swiften/Swiften.h"
 #include <boost/filesystem.hpp>
 #include "unistd.h"
 #include "signal.h"
 #include "sys/wait.h"
 #include "sys/signal.h"
 #include <fstream>
 #include <streambuf>
 Swift::SimpleEventLoop *loop_;
 #include "log4cxx/logger.h"
 #include "log4cxx/consoleappender.h"
 #include "log4cxx/patternlayout.h"
 #include "log4cxx/propertyconfigurator.h"
 #include "log4cxx/helpers/properties.h"
 #include "log4cxx/helpers/fileinputstream.h"
 #include "log4cxx/helpers/transcoder.h"
 #include <boost/filesystem.hpp>
@@ @@ -291,107 +292,46 @@ int main (int argc, char* argv[]) { @@
+	}
 	if (argc < 5) {
 		return 1;
+	}
 // 	QStringList channels;
 // 	for (int i = 3; i < argc; ++i)
 // 	{
 // 		channels.append(argv[i]);
 // 	}
 //
 // 	MyIrcSession session;
 // 	session.setNick(argv[2]);
 // 	session.setAutoJoinChannels(channels);
 // 	session.connectToServer(argv[1], 6667);
 	Config config;
 	if (!config.load(argv[5])) {
 		std::cerr << "Can't open " << argv[1] << " configuration file.\n";
 		return 1;
+	}
 	if (CONFIG_STRING(&config, "logging.backend_config").empty()) {
 		LoggerPtr root = log4cxx::Logger::getRootLogger();
 #ifndef _MSC_VER
 		root->addAppender(new ConsoleAppender(new PatternLayout("%d %-5p %c: %m%n")));
 #else
 		root->addAppender(new ConsoleAppender(new PatternLayout(L"%d %-5p %c: %m%n")));
 #endif
+	}
 	else {
 		log4cxx::helpers::Properties p;
 		log4cxx::helpers::FileInputStream *istream = new log4cxx::helpers::FileInputStream(CONFIG_STRING(&config, "logging.backend_config"));
 		p.load(istream);
 		LogString pid, jid;
 		log4cxx::helpers::Transcoder::decode(boost::lexical_cast<std::string>(getpid()), pid);
 		log4cxx::helpers::Transcoder::decode(CONFIG_STRING(&config, "service.jid"), jid);
 #ifdef _MSC_VER
 		p.setProperty(L"pid", pid);
 		p.setProperty(L"jid", jid);
 #else
 		p.setProperty("pid", pid);
 		p.setProperty("jid", jid);
 #endif
 		log4cxx::PropertyConfigurator::configure(p);
+	}
 	Logging::initBackendLogging(&config);
 #ifdef WITH_SQLITE
 	if (CONFIG_STRING(&config, "database.type") == "sqlite3") {
 		storageBackend = new SQLite3Backend(&config);
 		if (!storageBackend->connect()) {
 			std::cerr << "Can't connect to database. Check the log to find out the reason.\n";
 			return -1;
+		}
+	}
 #else
 	if (CONFIG_STRING(&config, "database.type") == "sqlite3") {
 		std::cerr << "Spectrum2 is not compiled with mysql backend.\n";
 		return -2;
+	}
 #endif
 #ifdef WITH_MYSQL
 	if (CONFIG_STRING(&config, "database.type") == "mysql") {
 		storageBackend = new MySQLBackend(&config);
 		if (!storageBackend->connect()) {
 			std::cerr << "Can't connect to database. Check the log to find out the reason.\n";
 			return -1;
 	std::string error;
 	StorageBackend *storageBackend = StorageBackend::createBackend(&config, error);
 	if (storageBackend == NULL) {
 		if (!error.empty()) {
 			std::cerr << error << "\n";
 			return -2;
+		}
+	}
 #else
 	if (CONFIG_STRING(&config, "database.type") == "mysql") {
 		std::cerr << "Spectrum2 is not compiled with mysql backend.\n";
 		return -2;
+	}
 #endif
 #ifdef WITH_PQXX
 	if (CONFIG_STRING(&config, "database.type") == "pqxx") {
 		storageBackend = new PQXXBackend(&config);
 		if (!storageBackend->connect()) {
 			std::cerr << "Can't connect to database. Check the log to find out the reason.\n";
 			return -1;
+		}
+	}
 #else
 	if (CONFIG_STRING(&config, "database.type") == "pqxx") {
 		std::cerr << "Spectrum2 is not compiled with pqxx backend.\n";
 		return -2;
+	}
 #endif
 	if (CONFIG_STRING(&config, "database.type") != "mysql" && CONFIG_STRING(&config, "database.type") != "sqlite3"
 		&& CONFIG_STRING(&config, "database.type") != "pqxx" && CONFIG_STRING(&config, "database.type") != "none") {
 		std::cerr << "Unknown storage backend " << CONFIG_STRING(&config, "database.type") << "\n";
 		return -2;
 	else if (!storageBackend->connect()) {
 		std::cerr << "Can't connect to database. Check the log to find out the reason.\n";
 		return -1;
+	}
 	Swift::SimpleEventLoop eventLoop;
 	loop_ = &eventLoop;
 	np = new SMSNetworkPlugin(&config, &eventLoop, host, port);
 	loop_->run();
 	return 0;
+}

include/transport/buddy.h

➞

Show inline comments

@@ @@ -18,48 +18,51 @@ @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <string>
 #include <algorithm>
 #include "transport/transport.h"
 #include "Swiften/Swiften.h"
 namespace Transport {
 class RosterManager;
 typedef enum { 	BUDDY_NO_FLAG = 0,
 				BUDDY_JID_ESCAPING = 2,
 				BUDDY_IGNORE = 4,
 				BUDDY_BLOCKED = 8,
 			} BuddyFlag;
 /// Represents one legacy network Buddy.
 class Buddy {
 	public:
 		typedef enum { 	Ask,
 						Both,
 					} Subscription;
 		/// Constructor.
 		/// \param rosterManager RosterManager associated with this buddy.
 		/// \param id ID which identifies the buddy in database or -1 if it's new buddy which is
 		/// not in database yet.
 		Buddy(RosterManager *rosterManager, long id = -1);
 		/// Destructor
 		virtual ~Buddy();
 		/// Sets unique ID used to identify this buddy by StorageBackend.
 		/// This is set
 		/// by RosterStorage class once the buddy is stored into database or when the
 		/// buddy is loaded from database.
 		/// You should not need to set this ID manually.
 		/// \param id ID
 		void setID(long id);
 		/// Returns unique ID used to identify this buddy by StorageBackend.
 		/// \return ID which identifies the buddy in database or -1 if it's new buddy which is
 		/// not in database yet.
 		long getID();
@@ @@ -72,54 +75,54 @@ class Buddy { @@
 		/// Generates whole Presennce stanza with current status/show for this buddy.
 		/// Presence stanza does not containt "to" attribute, it has to be added manually.
 		/// \param features features used in returned stanza
 		/// \param only_new if True, this function returns Presence stanza only if it's different
 		/// than the previously generated one.
 		/// \return Presence stanza or NULL.
 		Swift::Presence::ref generatePresenceStanza(int features, bool only_new = false);
 		void setBlocked(bool block) {
 			if (block)
 				m_flags = (BuddyFlag) (m_flags | BUDDY_BLOCKED);
 			else
 				m_flags = (BuddyFlag) (m_flags & ~BUDDY_BLOCKED);
+		}
 		bool isBlocked() {
 			return (m_flags & BUDDY_BLOCKED)  != 0;
+		}
 		/// Sets current subscription.
 		/// \param subscription "to", "from", "both", "ask"
-		void setSubscription(const std::string &subscription);
+		void setSubscription(Subscription subscription);
 		/// Returns current subscription
 		/// \return subscription "to", "from", "both", "ask"
-		const std::string getSubscription();
+		Subscription getSubscription();
 		/// Sets this buddy's flags.
 		/// \param flags flags
 		void setFlags(BuddyFlag flags);
 		/// Returns this buddy's flags.
 		/// \param flags flags
 		BuddyFlag getFlags();
 		/// Returns RosterManager associated with this buddy.
 		/// \return RosterManager associated with this buddy.
 		RosterManager *getRosterManager() { return m_rosterManager; }
 		/// Returns legacy network username which does not contain unsafe characters,
 		/// so it can be used in JIDs.
 		std::string getSafeName();
 		/// This method should be called whenever some information returned by virtual functions changes.
 		/// This method sends presence to XMPP user.
 		void handleBuddyChanged();
@@ @@ -151,27 +154,28 @@ class Buddy { @@
 		/// \param statusMessage current status message is stored here
 		/// \return true if status was stored successfully
 		virtual bool getStatus(Swift::StatusShow &status, std::string &statusMessage) = 0;
 		/// Returns SHA-1 hash of buddy icon (avatar) or empty string if there is no avatar for this buddy.
 		/// \return avatar hash or empty string.
 		virtual std::string getIconHash() = 0;
 		/// Returns legacy name of buddy from JID.
 		/// \param jid Jabber ID.
 		/// \return legacy name of buddy from JID.
 		static std::string JIDToLegacyName(const Swift::JID &jid);
 		static BuddyFlag buddFlagsFromJID(const Swift::JID &jid);
 	private:
 		void generateJID();
 		long m_id;
 // 		Swift::Presence::ref m_lastPresence;
 		Swift::JID m_jid;
 		BuddyFlag m_flags;
 		RosterManager *m_rosterManager;
 		Subscription m_subscription;
 };
+}

include/transport/logging.h

➞

Show inline comments

@@ new file 100644 @@
 /**
  * libtransport -- C++ library for easy XMPP Transports development
+ *
  * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <stdio.h>
 #include <stdlib.h>
 #include <vector>
 #include <string>
 namespace Transport {
 class Config;
 namespace Logging {
 void initBackendLogging(Config *config);
 void initMainLogging(Config *config);
+}
+}

include/transport/memoryusage.h

➞

Show inline comments

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

include/transport/networkplugin.h

➞

Show inline comments

@@ @@ -190,48 +190,50 @@ class NetworkPlugin { @@
 		/// Called when XMPP user updates his own VCard.
 		/// You should update the VCard in legacy network too.
 		/// \param user XMPP JID of user for which this event occurs.
 		/// \param photo Raw photo data.
 		virtual void handleVCardUpdatedRequest(const std::string &/*user*/, const std::string &/*photo*/, const std::string &nickname) {}
 		virtual void handleJoinRoomRequest(const std::string &/*user*/, const std::string &/*room*/, const std::string &/*nickname*/, const std::string &/*pasword*/) {}
 		virtual void handleLeaveRoomRequest(const std::string &/*user*/, const std::string &/*room*/) {}
 		virtual void handleStatusChangeRequest(const std::string &/*user*/, int status, const std::string &statusMessage) {}
 		virtual void handleBuddyUpdatedRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::string &/*alias*/, const std::vector<std::string> &/*groups*/) {}
 		virtual void handleBuddyRemovedRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::vector<std::string> &/*groups*/) {}
 		virtual void handleBuddyBlockToggled(const std::string &/*user*/, const std::string &/*buddyName*/, bool /*blocked*/) {}
 		virtual void handleTypingRequest(const std::string &/*user*/, const std::string &/*buddyName*/) {}
 		virtual void handleTypedRequest(const std::string &/*user*/, const std::string &/*buddyName*/) {}
 		virtual void handleStoppedTypingRequest(const std::string &/*user*/, const std::string &/*buddyName*/) {}
 		virtual void handleAttentionRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::string &/*message*/) {}
 		virtual void handleFTStartRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::string &/*fileName*/, unsigned long size, unsigned long ftID) {}
 		virtual void handleFTFinishRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::string &/*fileName*/, unsigned long size, unsigned long ftID) {}
 		virtual void handleFTPauseRequest(unsigned long ftID) {}
 		virtual void handleFTContinueRequest(unsigned long ftID) {}
 		virtual void handleMemoryUsage(double &res, double &shared) {res = 0; shared = 0;}
 		virtual void handleExitRequest() { exit(1); }
 		void handleDataRead(std::string &data);
 		virtual void sendData(const std::string &string) {}
 		void checkPing();
 	private:
 		void handleLoginPayload(const std::string &payload);
 		void handleLogoutPayload(const std::string &payload);
 		void handleStatusChangedPayload(const std::string &payload);
 		void handleConvMessagePayload(const std::string &payload);
 		void handleJoinRoomPayload(const std::string &payload);
 		void handleLeaveRoomPayload(const std::string &payload);
 		void handleVCardPayload(const std::string &payload);
 		void handleBuddyChangedPayload(const std::string &payload);
 		void handleBuddyRemovedPayload(const std::string &payload);
 		void handleChatStatePayload(const std::string &payload, int type);
 		void handleAttentionPayload(const std::string &payload);
 		void handleFTStartPayload(const std::string &payload);
 		void handleFTFinishPayload(const std::string &payload);
 		void handleFTPausePayload(const std::string &payload);
 		void handleFTContinuePayload(const std::string &payload);
 		void send(const std::string &data);

include/transport/networkpluginserver.h

➞

Show inline comments

@@ @@ -35,62 +35,67 @@ class UserManager; @@
 class User;
 class Component;
 class Buddy;
 class LocalBuddy;
 class Config;
 class NetworkConversation;
 class VCardResponder;
 class RosterResponder;
 class BlockResponder;
 class DummyReadBytestream;
 class NetworkPluginServer {
 	public:
 		struct Backend {
 			int pongReceived;
 			std::list<User *> users;
 			Swift::SafeByteArray data;
 			boost::shared_ptr<Swift::Connection> connection;
 			unsigned long res;
 			unsigned long init_res;
 			unsigned long shared;
 			bool acceptUsers;
 			bool longRun;
 			bool willDie;
 			std::string id;
 		};
 		NetworkPluginServer(Component *component, Config *config, UserManager *userManager, FileTransferManager *ftManager);
 		virtual ~NetworkPluginServer();
 		int getBackendCount() {
 			return m_clients.size();
+		}
 		const std::list<Backend *> &getBackends() {
 			return m_clients;
+		}
 		const std::vector<std::string> &getCrashedBackends() {
 			return m_crashedBackends;
+		}
 		void collectBackend();
 		bool moveToLongRunBackend(User *user);
 		void handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &message);
 	private:
 		void handleNewClientConnection(boost::shared_ptr<Swift::Connection> c);
 		void handleSessionFinished(Backend *c);
 		void handleDataRead(Backend *c, boost::shared_ptr<Swift::SafeByteArray> data);
 		void handleConnectedPayload(const std::string &payload);
 		void handleDisconnectedPayload(const std::string &payload);
 		void handleBuddyChangedPayload(const std::string &payload);
 		void handleConvMessagePayload(const std::string &payload, bool subject = false);
 		void handleParticipantChangedPayload(const std::string &payload);
 		void handleRoomChangedPayload(const std::string &payload);
 		void handleVCardPayload(const std::string &payload);
 		void handleChatStatePayload(const std::string &payload, Swift::ChatState::ChatStateType type);
 		void handleAuthorizationPayload(const std::string &payload);
 		void handleAttentionPayload(const std::string &payload);
 		void handleStatsPayload(Backend *c, const std::string &payload);
 		void handleFTStartPayload(const std::string &payload);
 		void handleFTFinishPayload(const std::string &payload);
@@ @@ -116,27 +121,28 @@ class NetworkPluginServer { @@
 		void handleFTAccepted(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID);
 		void handleFTRejected(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size);
 		void handleFTDataNeeded(Backend *b, unsigned long ftid);
 		void send(boost::shared_ptr<Swift::Connection> &, const std::string &data);
 		void pingTimeout();
 		void sendPing(Backend *c);
 		Backend *getFreeClient(bool acceptUsers = true, bool longRun = false);
 		UserManager *m_userManager;
 		VCardResponder *m_vcardResponder;
 		RosterResponder *m_rosterResponder;
 		BlockResponder *m_blockResponder;
 		Config *m_config;
 		boost::shared_ptr<Swift::ConnectionServer> m_server;
 		std::list<Backend *>  m_clients;
 		Swift::Timer::ref m_pingTimer;
 		Swift::Timer::ref m_collectTimer;
 		Component *m_component;
 		std::list<User *> m_waitingUsers;
 		bool m_isNextLongRun;
 		std::map<unsigned long, FileTransferManager::Transfer> m_filetransfers;
 		FileTransferManager *m_ftManager;
 		std::vector<std::string> m_crashedBackends;
 };
+}

include/transport/protocol.proto

➞

Show inline comments

@@ @@ -85,48 +85,49 @@ message Participant { @@
 	required StatusType status = 5;
 	optional string statusMessage = 6;
 	optional string newname = 7;
+}
 message VCard {
 	required string userName = 1;
 	required string buddyName = 2;
 	required int32 id = 3;
 	optional string fullname = 4;
 	optional string nickname = 5;
 	optional bytes photo = 6;
+}
 message Status {
 	required string userName = 1;
 	required StatusType status = 3;
 	optional string statusMessage = 4;
+}
 message Stats {
 	required int32 res = 1;
 	required int32 init_res = 2;
 	required int32 shared = 3;
 	required string id = 4;
+}
 message File {
 	required string userName = 1;
 	required string buddyName = 2;
 	required string fileName = 3;
 	required int32 size = 4;
 	optional int32 ftID = 5;
+}
 message FileTransferData {
 	required int32 ftID = 1;
 	required bytes data = 2;
+}
 message WrapperMessage {
 	enum Type {
 		TYPE_CONNECTED 				= 1;
 		TYPE_DISCONNECTED 			= 2;
 		TYPE_LOGIN 					= 3;
 		TYPE_LOGOUT 				= 4;
 		TYPE_BUDDY_CHANGED			= 6;
 		TYPE_BUDDY_REMOVED			= 7;
 		TYPE_CONV_MESSAGE			= 8;

include/transport/storagebackend.h

➞

Show inline comments

@@ @@ -59,55 +59,59 @@ typedef enum @@
 	TYPE_OBJECT,       /**< Object pointer.                   */
 	TYPE_POINTER,      /**< Generic pointer.                  */
 	TYPE_ENUM,         /**< Enum.                             */
 	TYPE_BOXED         /**< Boxed pointer with specific type. */
 } SettingType;
 struct SettingVariableInfo {
 	int type;
 	std::string s;
 	int i;
 	bool b;
 };
 struct BuddyInfo {
 	long id;
 	std::string alias;
 	std::string legacyName;
 	std::string subscription;
 	std::vector<std::string> groups;
 	std::map<std::string, SettingVariableInfo> settings;
 	int flags;
 };
 class Config;
 /// Abstract class defining storage backends.
 class StorageBackend
+{
 	public:
 		/// Virtual desctructor.
 		virtual ~StorageBackend() {}
 		static StorageBackend *createBackend(Config *config, std::string &error);
 		/// connect
 		virtual bool connect() = 0;
 		/// createDatabase
 		virtual bool createDatabase() = 0;
 		/// setUser
 		virtual void setUser(const UserInfo &user) = 0;
 		/// getuser
 		virtual bool getUser(const std::string &barejid, UserInfo &user) = 0;
 		/// setUserOnline
 		virtual void setUserOnline(long id, bool online) = 0;
 		/// removeUser
 		virtual bool removeUser(long id) = 0;
 		/// getBuddies
 		virtual bool getBuddies(long id, std::list<BuddyInfo> &roster) = 0;
 		/// getOnlineUsers
 		virtual bool getOnlineUsers(std::vector<std::string> &users) = 0;

include/transport/usermanager.h

➞

Show inline comments

@@ @@ -95,46 +95,55 @@ class UserManager : public Swift::EntityCapsProvider { @@
 		/// Returns true if user is connected.
 		/// \return True if user is connected.
 		bool isUserConnected(const std::string &barejid) const {
 			return m_users.find(barejid) != m_users.end();
+		}
 		/// Returns pointer to UserRegistry.
 		/// \return Pointer to UserRegistry.
 		UserRegistry *getUserRegistry() {
 			return m_userRegistry;
+		}
 		Component *getComponent() {
 			return m_component;
+		}
 		/// Connects user manually.
 		/// \param user JID of user.
 		void connectUser(const Swift::JID &user);
 		/// Disconnects user manually.
 		/// \param user JID of user.
 		void disconnectUser(const Swift::JID &user);
 		void messageToXMPPSent() { m_sentToXMPP++; }
 		void messageToBackendSent() { m_sentToBackend++; }
 		unsigned long getMessagesToXMPP() { return m_sentToXMPP; }
 		unsigned long getMessagesToBackend() { return m_sentToBackend; }
 	private:
 		void handlePresence(Swift::Presence::ref presence);
 		void handleMessageReceived(Swift::Message::ref message);
 		void handleGeneralPresenceReceived(Swift::Presence::ref presence);
 		void handleProbePresence(Swift::Presence::ref presence);
 		void handleSubscription(Swift::Presence::ref presence);
 		void handleRemoveTimeout(const std::string jid, User *user, bool reconnect);
 		void handleDiscoInfo(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info);
 		void addUser(User *user);
 		long m_onlineBuddies;
 		User *m_cachedUser;
 		std::map<std::string, User *> m_users;
 		Component *m_component;
 		StorageBackend *m_storageBackend;
 		StorageResponder *m_storageResponder;
 		UserRegistry *m_userRegistry;
 		Swift::Timer::ref m_removeTimer;
 		unsigned long m_sentToXMPP;
 		unsigned long m_sentToBackend;
 		friend class RosterResponder;
 };
+}

plugin/CMakeLists.txt

➞

Show inline comments

 ADD_SUBDIRECTORY(src)
 ADD_SUBDIRECTORY(cpp)
 ADD_SUBDIRECTORY(python)

plugin/cpp/CMakeLists.txt

➞

Show inline comments

file renamed from plugin/src/CMakeLists.txt to plugin/cpp/CMakeLists.txt

plugin/cpp/networkplugin.cpp

➞

Show inline comments

@@ file renamed from plugin/src/networkplugin.cpp to plugin/cpp/networkplugin.cpp @@
@@ @@ -20,48 +20,54 @@ @@
 #include "transport/networkplugin.h"
 #include "log4cxx/logger.h"
 #include "log4cxx/basicconfigurator.h"
 #include "transport/memoryusage.h"
 #ifndef WIN32
 #include <arpa/inet.h>
 #else
 #include <winsock2.h>
 #include <stdint.h>
 #endif
 using namespace log4cxx;
 static LoggerPtr logger = Logger::getLogger("NetworkPlugin");
 namespace Transport {
 #define WRAP(MESSAGE, TYPE) 	pbnetwork::WrapperMessage wrap; \
 	wrap.set_type(TYPE); \
 	wrap.set_payload(MESSAGE); \
 	wrap.SerializeToString(&MESSAGE);
 template <class T> std::string stringOf(T object) {
 	std::ostringstream os;
 	os << object;
 	return (os.str());
+}
 NetworkPlugin::NetworkPlugin() {
 	m_pingReceived = false;
 	double shared;
 #ifndef WIN32
 	process_mem_usage(shared, m_init_res);
 #endif
+}
 NetworkPlugin::~NetworkPlugin() {
+}
 void NetworkPlugin::handleMessage(const std::string &user, const std::string &legacyName, const std::string &msg, const std::string &nickname, const std::string &xhtml) {
 	pbnetwork::ConversationMessage m;
 	m.set_username(user);
 	m.set_buddyname(legacyName);
 	m.set_message(msg);
 	m.set_nickname(nickname);
 	m.set_xhtml(xhtml);
 	std::string message;
 	m.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE);
@@ @@ -566,41 +572,47 @@ void NetworkPlugin::send(const std::string &data) { @@
+}
 void NetworkPlugin::checkPing() {
 	if (m_pingReceived == false) {
 		handleExitRequest();
+	}
 	m_pingReceived = false;
+}
 void NetworkPlugin::sendPong() {
 	m_pingReceived = true;
 	std::string message;
 	pbnetwork::WrapperMessage wrap;
 	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_PONG);
 	wrap.SerializeToString(&message);
 	send(message);
 	sendMemoryUsage();
+}
 void NetworkPlugin::sendMemoryUsage() {
 	pbnetwork::Stats stats;
 	stats.set_init_res(m_init_res);
 	double res;
 	double shared;
 	double res = 0;
 	double shared = 0;
 #ifndef WIN32
 	process_mem_usage(shared, res);
 #endif
 	stats.set_res(res);
 	stats.set_shared(shared);
 	double e_res;
 	double e_shared;
 	handleMemoryUsage(e_res, e_shared);
 	stats.set_res(res + e_res);
 	stats.set_shared(shared + e_shared);
 	stats.set_id(stringOf(getpid()));
 	std::string message;
 	stats.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_STATS);
 	send(message);
+}
+}

plugin/python/CMakeLists.txt

➞

Show inline comments

@@ new file 100644 @@
 cmake_minimum_required(VERSION 2.6)
 if (PROTOBUF_FOUND)
     ADD_CUSTOM_COMMAND(
         OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/protocol_pb2.py
         COMMAND ${PROTOBUF_PROTOC_EXECUTABLE} --python_out  ${CMAKE_CURRENT_BINARY_DIR} --proto_path ${CMAKE_CURRENT_BINARY_DIR}/../../include/transport/ ${CMAKE_CURRENT_BINARY_DIR}/../../include/transport/protocol.proto
         COMMENT "Running Python protocol buffer compiler on protocol.proto"
         DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/../../include/transport/protocol.proto
+    )
     ADD_CUSTOM_TARGET(pb-python DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/protocol_pb2.py)
 endif()

spectrum/src/main.cpp

➞

Show inline comments

 #include "transport/config.h"
 #include "transport/transport.h"
 #include "transport/filetransfermanager.h"
 #include "transport/usermanager.h"
 #include "transport/logger.h"
 #include "transport/sqlite3backend.h"
 #include "transport/mysqlbackend.h"
 #include "transport/pqxxbackend.h"
 #include "transport/userregistration.h"
 #include "transport/networkpluginserver.h"
 #include "transport/admininterface.h"
 #include "transport/statsresponder.h"
 #include "transport/usersreconnecter.h"
 #include "transport/util.h"
 #include "transport/gatewayresponder.h"
 #include "transport/logging.h"
 #include "Swiften/EventLoop/SimpleEventLoop.h"
 #include <boost/filesystem.hpp>
 #include <boost/algorithm/string.hpp>
 #ifndef WIN32
 #include "sys/signal.h"
 #include <pwd.h>
 #include <grp.h>
 #include <sys/resource.h>
 #include "libgen.h"
 #else
 #include <windows.h>
 #endif
 #include "log4cxx/logger.h"
 #include "log4cxx/consoleappender.h"
 #include "log4cxx/patternlayout.h"
 #include "log4cxx/propertyconfigurator.h"
 #include "log4cxx/helpers/properties.h"
 #include "log4cxx/helpers/transcoder.h"
 #include "log4cxx/helpers/fileinputstream.h"
 #include <sys/stat.h>
 using namespace log4cxx;
 using namespace Transport;
@@ @@ -214,113 +215,49 @@ int main(int argc, char **argv) @@
+	}
 #ifndef WIN32
 	if (!CONFIG_STRING(&config, "service.group").empty() ||!CONFIG_STRING(&config, "service.user").empty() ) {
 		struct group *gr;
 		if ((gr = getgrnam(CONFIG_STRING(&config, "service.group").c_str())) == NULL) {
 			std::cerr << "Invalid service.group name " << CONFIG_STRING(&config, "service.group") << "\n";
 			return 1;
+		}
 		struct passwd *pw;
 		if ((pw = getpwnam(CONFIG_STRING(&config, "service.user").c_str())) == NULL) {
 			std::cerr << "Invalid service.user name " << CONFIG_STRING(&config, "service.user") << "\n";
 			return 1;
+		}
 		chown(CONFIG_STRING(&config, "service.working_dir").c_str(), pw->pw_uid, gr->gr_gid);
+	}
 	if (!no_daemon) {
 		// daemonize
 		daemonize(CONFIG_STRING(&config, "service.working_dir").c_str(), CONFIG_STRING(&config, "service.pidfile").c_str());
 // 		removeOldIcons(CONFIG_STRING(&config, "service.working_dir") + "/icons");
+    }
 #endif
 	if (CONFIG_STRING(&config, "logging.config").empty()) {
 		LoggerPtr root = log4cxx::Logger::getRootLogger();
 #ifdef WIN32
 		root->addAppender(new ConsoleAppender(new PatternLayout(L"%d %-5p %c: %m%n")));
 #else
 		root->addAppender(new ConsoleAppender(new PatternLayout("%d %-5p %c: %m%n")));
 #endif
+	}
 	else {
 		log4cxx::helpers::Properties p;
 		log4cxx::helpers::FileInputStream *istream = new log4cxx::helpers::FileInputStream(CONFIG_STRING(&config, "logging.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 WIN32
 		p.setProperty(L"pid", pid);
 		p.setProperty(L"jid", jid);
 #else
 		p.setProperty("pid", pid);
 		p.setProperty("jid", jid);
 #endif
 		std::string dir;
 		BOOST_FOREACH(const log4cxx::LogString &prop, p.propertyNames()) {
 			if (boost::ends_with(prop, ".File")) {
 				log4cxx::helpers::Transcoder::encode(p.get(prop), dir);
 				boost::replace_all(dir, "${jid}", jid);
 				break;
+			}
+		}
 		if (!dir.empty()) {
 			// create directories
 			try {
 				boost::filesystem::create_directories(
 					boost::filesystem::path(dir).parent_path().string()
 				);
+			}
 			catch (...) {
 				std::cerr << "Can't create logging directory directory " << boost::filesystem::path(dir).parent_path().string() << ".\n";
 				return 1;
+			}
 #ifndef WIN32
 			if (!CONFIG_STRING(&config, "service.group").empty() && !CONFIG_STRING(&config, "service.user").empty()) {
 				struct group *gr;
 				if ((gr = getgrnam(CONFIG_STRING(&config, "service.group").c_str())) == NULL) {
 					std::cerr << "Invalid service.group name " << CONFIG_STRING(&config, "service.group") << "\n";
 					return 1;
+				}
 				struct passwd *pw;
 				if ((pw = getpwnam(CONFIG_STRING(&config, "service.user").c_str())) == NULL) {
 					std::cerr << "Invalid service.user name " << CONFIG_STRING(&config, "service.user") << "\n";
 					return 1;
+				}
 				chown(dir.c_str(), pw->pw_uid, gr->gr_gid);
+			}
 #endif
+		}
 		log4cxx::PropertyConfigurator::configure(p);
+	}
 	Logging::initMainLogging(&config);
 #ifndef WIN32
 	if (!CONFIG_STRING(&config, "service.group").empty() ||!CONFIG_STRING(&config, "service.user").empty() ) {
 		struct rlimit limit;
 		getrlimit(RLIMIT_CORE, &limit);
 		if (!CONFIG_STRING(&config, "service.group").empty()) {
 			struct group *gr;
 			if ((gr = getgrnam(CONFIG_STRING(&config, "service.group").c_str())) == NULL) {
 				std::cerr << "Invalid service.group name " << CONFIG_STRING(&config, "service.group") << "\n";
 				return 1;
+			}
 			if (((setgid(gr->gr_gid)) != 0) || (initgroups(CONFIG_STRING(&config, "service.user").c_str(), gr->gr_gid) != 0)) {
 				std::cerr << "Failed to set service.group name " << CONFIG_STRING(&config, "service.group") << " - " << gr->gr_gid << ":" << strerror(errno) << "\n";
 				return 1;
+			}
+		}
 		if (!CONFIG_STRING(&config, "service.user").empty()) {
 			struct passwd *pw;
 			if ((pw = getpwnam(CONFIG_STRING(&config, "service.user").c_str())) == NULL) {
 				std::cerr << "Invalid service.user name " << CONFIG_STRING(&config, "service.user") << "\n";
 				return 1;
@@ @@ -328,116 +265,77 @@ int main(int argc, char **argv) @@
 			if ((setuid(pw->pw_uid)) != 0) {
 				std::cerr << "Failed to set service.user name " << CONFIG_STRING(&config, "service.user") << " - " << pw->pw_uid << ":" << strerror(errno) << "\n";
 				return 1;
+			}
+		}
 		setrlimit(RLIMIT_CORE, &limit);
+	}
 	struct rlimit limit;
 	limit.rlim_max = RLIM_INFINITY;
 	limit.rlim_cur = RLIM_INFINITY;
 	setrlimit(RLIMIT_CORE, &limit);
 #endif
 	Swift::SimpleEventLoop eventLoop;
 	Swift::BoostNetworkFactories *factories = new Swift::BoostNetworkFactories(&eventLoop);
 	UserRegistry userRegistry(&config, factories);
 	Component transport(&eventLoop, factories, &config, NULL, &userRegistry);
 	component_ = &transport;
 // 	Logger logger(&transport);
 	StorageBackend *storageBackend = NULL;
 #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 sqlite3 backend.\n";
 		return -2;
+	}
 #endif
 #ifdef WITH_MYSQL
 	if (CONFIG_STRING(&config, "database.type") == "mysql") {
 		storageBackend = new MySQLBackend(&config);
 		if (!storageBackend->connect()) {
 			std::cerr << "Can't connect to database. Check the log to find out the reason.\n";
 			return -1;
 	std::string error;
 	StorageBackend *storageBackend = StorageBackend::createBackend(&config, error);
 	if (storageBackend == NULL) {
 		if (!error.empty()) {
 			std::cerr << error << "\n";
 			return -2;
+		}
+	}
 #else
 	if (CONFIG_STRING(&config, "database.type") == "mysql") {
 		std::cerr << "Spectrum2 is not compiled with mysql backend.\n";
 		return -2;
+	}
 #endif
 #ifdef WITH_PQXX
 	if (CONFIG_STRING(&config, "database.type") == "pqxx") {
 		storageBackend = new PQXXBackend(&config);
 		if (!storageBackend->connect()) {
 			std::cerr << "Can't connect to database. Check the log to find out the reason.\n";
 			return -1;
+		}
+	}
 #else
 	if (CONFIG_STRING(&config, "database.type") == "pqxx") {
 		std::cerr << "Spectrum2 is not compiled with pqxx backend.\n";
 		return -2;
+	}
 #endif
 	if (CONFIG_STRING(&config, "database.type") != "mysql" && CONFIG_STRING(&config, "database.type") != "sqlite3"
 		&& CONFIG_STRING(&config, "database.type") != "pqxx" && CONFIG_STRING(&config, "database.type") != "none") {
 		std::cerr << "Unknown storage backend " << CONFIG_STRING(&config, "database.type") << "\n";
 		return -2;
 	else if (!storageBackend->connect()) {
 		std::cerr << "Can't connect to database. Check the log to find out the reason.\n";
 		return -1;
+	}
 	UserManager userManager(&transport, &userRegistry, storageBackend);
 	userManager_ = &userManager;
 	UserRegistration *userRegistration = NULL;
 	UsersReconnecter *usersReconnecter = NULL;
 	if (storageBackend) {
 		userRegistration = new UserRegistration(&transport, &userManager, storageBackend);
 		userRegistration->start();
 		usersReconnecter = new UsersReconnecter(&transport, storageBackend);
+	}
 	FileTransferManager ftManager(&transport, &userManager);
 	NetworkPluginServer plugin(&transport, &config, &userManager, &ftManager);
 	AdminInterface adminInterface(&transport, &userManager, &plugin, storageBackend);
 	StatsResponder statsResponder(&transport, &userManager, &plugin, storageBackend);
 	statsResponder.start();
 	GatewayResponder gatewayResponder(transport.getIQRouter(), &userManager);
 	gatewayResponder.start();
 	eventLoop_ = &eventLoop;
 	eventLoop.run();
 	if (userRegistration) {
 		userRegistration->stop();
 		delete userRegistration;
+	}
 	if (usersReconnecter) {
 		delete usersReconnecter;
+	}
 	delete storageBackend;
 	delete factories;
 	return 0;
+}

spectrum/src/sample.cfg

➞

Show inline comments

 [service]
 jid = localhost
 password = secret
 server = 127.0.0.1
 port = 5222
 server_mode = 1
 backend_host=localhost
 pidfile=./test.pid
 # < this option doesn't work yet
 backend_port=10001
 admin_username=admin
 #backend_port=10001
 admin_jid=admin@localhost
 admin_password=test
 #cert=server.pfx #patch to PKCS#12 certificate
 #cert_password=test #password to that certificate if any
 users_per_backend=10
 backend=/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
 backend=../..//backends/libpurple/spectrum2_libpurple_backend
 protocol=prpl-xmpp
 #protocol=prpl-msn
 protocol=any
+#protocol=any
 #protocol=prpl-icq
 irc_server=irc.freenode.org
 working_dir=./
 [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 = mysql # or "none" without database backend.......................................................................................................................
 #database = test
 #prefix=
 #user=root
 #password=yourrootsqlpassword
 #encryption_key=hanzzik

src/admininterface.cpp

➞

Show inline comments

+		}
 		message->setBody(lst);
+	}
 	else if (message->getBody() == "online_users_count") {
 		int users = m_userManager->getUserCount();
 		message->setBody(boost::lexical_cast<std::string>(users));
+	}
 	else if (message->getBody() == "reload") {
 		bool done = m_component->getConfig()->reload();
 		if (done) {
 			message->setBody("Config reloaded");
+		}
 		else {
 			message->setBody("Error during config reload");
+		}
+	}
 	else if (message->getBody() == "online_users_per_backend") {
 		std::string lst;
 		int id = 1;
 		const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();
 		for (std::list <NetworkPluginServer::Backend *>::const_iterator b = backends.begin(); b != backends.end(); b++) {
 			NetworkPluginServer::Backend *backend = *b;
 			lst += "Backend " + boost::lexical_cast<std::string>(id);
+			lst += "Backend " + boost::lexical_cast<std::string>(id) + " (ID=" + backend->id + ")";
 			lst += backend->acceptUsers ? "" : " - not-accepting";
 			lst += backend->longRun ? " - long-running" : "";
 			lst += ":\n";
 			if (backend->users.size() == 0) {
 				lst += "   waiting for users\n";
+			}
 			else {
 				time_t now = time(NULL);
 				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));
 			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") {
 		std::string lst;
 		int id = 1;
 		const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();
 		BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {
 			lst += "Backend " + boost::lexical_cast<std::string>(id) + ": " + boost::lexical_cast<std::string>(backend->res) + "\n";
+			lst += "Backend " + boost::lexical_cast<std::string>(id) + " (ID=" + backend->id + "): " + boost::lexical_cast<std::string>(backend->res) + "\n";
 			id++;
+		}
 		message->setBody(lst);
+	}
 	else if (message->getBody() == "shr_memory_per_backend") {
 		std::string lst;
 		int id = 1;
 		const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();
 		BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {
 			lst += "Backend " + boost::lexical_cast<std::string>(id) + ": " + boost::lexical_cast<std::string>(backend->shared) + "\n";
+			lst += "Backend " + boost::lexical_cast<std::string>(id)  + " (ID=" + backend->id + "): " + boost::lexical_cast<std::string>(backend->shared) + "\n";
 			id++;
+		}
 		message->setBody(lst);
+	}
 	else if (message->getBody() == "used_memory_per_backend") {
 		std::string lst;
 		int id = 1;
 		const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();
 		BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {
-			lst += "Backend " + boost::lexical_cast<std::string>(id) + ": " + boost::lexical_cast<std::string>(backend->res - backend->shared) + "\n";
+			lst += "Backend " + boost::lexical_cast<std::string>(id)  + " (ID=" + backend->id + "): " + boost::lexical_cast<std::string>(backend->res - backend->shared) + "\n";
 			id++;
+		}
 		message->setBody(lst);
+	}
 	else if (message->getBody() == "average_memory_per_user_per_backend") {
 		std::string lst;
 		int id = 1;
 		const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();
 		BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {
 			if (backend->users.size() == 0) {
 				lst += "Backend " + boost::lexical_cast<std::string>(id) + ": 0\n";
+				lst += "Backend " + boost::lexical_cast<std::string>(id)  + " (ID=" + backend->id + "): 0\n";
+			}
 			else {
 				lst += "Backend " + boost::lexical_cast<std::string>(id) + ": " + boost::lexical_cast<std::string>((backend->res - backend->init_res) / backend->users.size()) + "\n";
+				lst += "Backend " + boost::lexical_cast<std::string>(id) + " (ID=" + backend->id + "): " + boost::lexical_cast<std::string>((backend->res - backend->init_res) / backend->users.size()) + "\n";
+			}
 			id++;
+		}
 		message->setBody(lst);
+	}
 	else if (message->getBody() == "collect_backend") {
 		m_server->collectBackend();
+	}
 	else if (message->getBody() == "crashed_backends") {
 		std::string lst;
 		const std::vector<std::string> &backends = m_server->getCrashedBackends();
 		BOOST_FOREACH(const std::string &backend, backends) {
 			lst += backend + "\n";
+		}
 		message->setBody(lst);
+	}
 	else if (message->getBody().find("help") == 0) {
 		std::string help;
 		help += "General:\n";
 		help += "    status - shows instance status\n";
 		help += "    reload - Reloads config file\n";
 		help += "Users:\n";
 		help += "    online_users - returns list of all online users\n";
 		help += "    online_users_count - number of online users\n";
 		help += "    online_users_per_backend - shows online users per backends\n";
 		help += "    has_online_user <bare_JID> - returns 1 if user is online\n";
 		help += "Backends:\n";
 		help += "    backends_count - number of active backends\n";
 		help += "    crashed_backends - returns IDs of crashed backends\n";
 		help += "Memory:\n";
 		help += "    res_memory - Total RESident memory spectrum2 and its backends use in KB\n";
 		help += "    shr_memory - Total SHaRed memory spectrum2 backends share together in KB\n";
 		help += "    used_memory - (res_memory - shr_memory)\n";
 		help += "    average_memory_per_user - (memory_used_without_any_user - res_memory)\n";
 		help += "    res_memory_per_backend - RESident memory used by backends in KB\n";
 		help += "    shr_memory_per_backend - SHaRed memory used by backends in KB\n";
 		help += "    used_memory_per_backend - (res_memory - shr_memory) per backend\n";
 		help += "    average_memory_per_user_per_backend - (memory_used_without_any_user - res_memory) per backend\n";
 		message->setBody(help);
+	}
 	else {
 		message->setBody("Unknown command. Try \"help\"");
+	}
 	m_component->getStanzaChannel()->sendMessage(message);
+}
+}

src/buddy.cpp

➞

Show inline comments

@@ @@ -5,92 +5,93 @@ @@
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/buddy.h"
 #include "transport/rostermanager.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/BlockPayload.h"
 namespace Transport {
 Buddy::Buddy(RosterManager *rosterManager, long id) : m_id(id), m_flags(BUDDY_NO_FLAG), m_rosterManager(rosterManager){
 Buddy::Buddy(RosterManager *rosterManager, long id) : m_id(id), m_flags(BUDDY_NO_FLAG), m_rosterManager(rosterManager),
 	m_subscription(Ask) {
 // 	m_rosterManager->setBuddy(this);
+}
 Buddy::~Buddy() {
 // 	m_rosterManager->unsetBuddy(this);
+}
 void Buddy::generateJID() {
 	m_jid = Swift::JID();
 	m_jid = Swift::JID(getSafeName(), m_rosterManager->getUser()->getComponent()->getJID().toString(), "bot");
+}
 void Buddy::setID(long id) {
 	m_id = id;
+}
 long Buddy::getID() {
 	return m_id;
+}
 void Buddy::setFlags(BuddyFlag flags) {
 	m_flags = flags;
 // 	generateJID();
+}
 BuddyFlag Buddy::getFlags() {
 	return m_flags;
+}
 const Swift::JID &Buddy::getJID() {
 	if (!m_jid.isValid() || m_jid.getNode().empty()) {
 		generateJID();
+	}
 	return m_jid;
+}
 void Buddy::setSubscription(const std::string &subscription) {
 // 	m_subscription = subscription;
 void Buddy::setSubscription(Subscription subscription) {
 	m_subscription = subscription;
+}
 const std::string Buddy::getSubscription() {
 	return "ask";
 Buddy::Subscription Buddy::getSubscription() {
 	return m_subscription;
+}
 Swift::Presence::ref Buddy::generatePresenceStanza(int features, bool only_new) {
 	std::string alias = getAlias();
 	std::string name = getSafeName();
 	Swift::StatusShow s;
 	std::string statusMessage;
 	if (!getStatus(s, statusMessage))
 		return Swift::Presence::ref();
 	if (m_jid.getNode().empty()) {
 		generateJID();
+	}
 	Swift::Presence::ref presence = Swift::Presence::create();
  	presence->setFrom(m_jid);
 	presence->setTo(m_rosterManager->getUser()->getJID().toBare());
 	presence->setType(Swift::Presence::Available);
 	if (!statusMessage.empty())
 		presence->setStatus(statusMessage);
 	if (s.getType() == Swift::StatusShow::None)

src/logging.cpp

➞

Show inline comments

@@ new file 100644 @@
 /**
  * libtransport -- C++ library for easy XMPP Transports development
+ *
  * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/logging.h"
 #include "transport/config.h"
 #include <boost/foreach.hpp>
 #include <iostream>
 #include <iterator>
 #include <algorithm>
 #include "log4cxx/logger.h"
 #include "log4cxx/consoleappender.h"
 #include "log4cxx/patternlayout.h"
 #include "log4cxx/propertyconfigurator.h"
 #include "log4cxx/helpers/properties.h"
 #include "log4cxx/helpers/fileinputstream.h"
 #include "log4cxx/helpers/transcoder.h"
 #include <boost/filesystem.hpp>
 #include <boost/algorithm/string.hpp>
 #ifndef WIN32
 #include "sys/signal.h"
 #include <pwd.h>
 #include <grp.h>
 #include <sys/resource.h>
 #include "libgen.h"
 #else
 #include <windows.h>
 #endif
 using namespace boost::filesystem;
 using namespace log4cxx;
 namespace Transport {
 namespace Logging {
 static LoggerPtr root;
 static void initLogging(Config *config, std::string key) {
 	if (CONFIG_STRING(config, key).empty()) {
 		root = log4cxx::Logger::getRootLogger();
 #ifdef WIN32
 		root->addAppender(new ConsoleAppender(new PatternLayout(L"%d %-5p %c: %m%n")));
 #else
 		root->addAppender(new ConsoleAppender(new PatternLayout("%d %-5p %c: %m%n")));
 #endif
+	}
 	else {
 		log4cxx::helpers::Properties p;
 		log4cxx::helpers::FileInputStream *istream = new log4cxx::helpers::FileInputStream(CONFIG_STRING(config, key));
 		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 WIN32
 		p.setProperty(L"pid", pid);
 		p.setProperty(L"jid", jid);
 #else
 		p.setProperty("pid", pid);
 		p.setProperty("jid", jid);
 #endif
 		std::string dir;
 		BOOST_FOREACH(const log4cxx::LogString &prop, p.propertyNames()) {
 			if (boost::ends_with(prop, ".File")) {
 				log4cxx::helpers::Transcoder::encode(p.get(prop), dir);
 				boost::replace_all(dir, "${jid}", jid);
 				break;
+			}
+		}
 		if (!dir.empty()) {
 			// create directories
 			try {
 				boost::filesystem::create_directories(
 					boost::filesystem::path(dir).parent_path().string()
 				);
+			}
 			catch (...) {
 				std::cerr << "Can't create logging directory directory " << boost::filesystem::path(dir).parent_path().string() << ".\n";
+			}
 #ifndef WIN32
 			if (!CONFIG_STRING(config, "service.group").empty() && !CONFIG_STRING(config, "service.user").empty()) {
 				struct group *gr;
 				if ((gr = getgrnam(CONFIG_STRING(config, "service.group").c_str())) == NULL) {
 					std::cerr << "Invalid service.group name " << CONFIG_STRING(config, "service.group") << "\n";
+				}
 				struct passwd *pw;
 				if ((pw = getpwnam(CONFIG_STRING(config, "service.user").c_str())) == NULL) {
 					std::cerr << "Invalid service.user name " << CONFIG_STRING(config, "service.user") << "\n";
+				}
 				chown(dir.c_str(), pw->pw_uid, gr->gr_gid);
+			}
 #endif
+		}
 		log4cxx::PropertyConfigurator::configure(p);
+	}
+}
 void initBackendLogging(Config *config) {
 	initLogging(config, "logging.backend_config");
+}
 void initMainLogging(Config *config) {
 	initLogging(config, "logging.config");
+}
+}
+}

src/memoryusage.cpp

➞

Show inline comments

@@ @@ -4,113 +4,122 @@ @@
  * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/memoryusage.h"
 #include <iostream>
 #include <cstring>
 #include <sstream>
 #include <fstream>
 #include <algorithm>
 #include <boost/lexical_cast.hpp>
 #ifndef WIN32
 #include <sys/param.h>
 #endif
 #ifdef 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
 void process_mem_usage(double& vm_usage, double& resident_set) {
+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;
 	mib[3] = getpid();
 	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.
 	if (size == 0) {
 		vm_usage = 0;
 		resident_set = 0;
 		return;
+	}
 	int pagesize,cnt;
 	size = sizeof(pagesize);
 	sysctlbyname("hw.pagesize", &pagesize, &size, NULL, 0);
 	resident_set = (double) (proc.ki_rssize * pagesize / 1024);
 	vm_usage = (double) proc.ki_size;
+}
 #else /* BSD */
 void process_mem_usage(double& shared, double& resident_set) {
+void process_mem_usage(double& shared, double& resident_set, pid_t pid) {
 	using std::ios_base;
 	using std::ifstream;
 	using std::string;
 	shared       = 0.0;
 	resident_set = 0.0;
 	// 'file' stat seems to give the most reliable results
 	//
 	ifstream stat_stream("/proc/self/statm",ios_base::in);
 	std::string f = "/proc/self/statm";
 	if (pid != 0) {
 		f = "/proc/" + boost::lexical_cast<std::string>(pid) + "/statm";
+	}
 	ifstream stat_stream(f.c_str(), ios_base::in);
 	if (!stat_stream.is_open()) {
 		shared = 0;
 		resident_set = 0;
 		return;
+	}
 	// dummy vars for leading entries in stat that we don't care about
 	//
-	string pid, comm, state, ppid, pgrp, session, tty_nr;
+	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 */
 #endif /* WIN32 */
+}

src/networkpluginserver.cpp

➞

Show inline comments

@@ @@ -74,49 +74,54 @@ class NetworkConversation : public Conversation { @@
 			onMessageToSend(this, message);
+		}
 		boost::signal<void (NetworkConversation *, boost::shared_ptr<Swift::Message> &)> onMessageToSend;
 };
 class NetworkFactory : public Factory {
 	public:
 		NetworkFactory(NetworkPluginServer *nps) {
 			m_nps = nps;
+		}
 		// Creates new conversation (NetworkConversation in this case)
 		Conversation *createConversation(ConversationManager *conversationManager, const std::string &legacyName) {
 			NetworkConversation *nc = new NetworkConversation(conversationManager, legacyName);
 			nc->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, m_nps, _1, _2));
 			return nc;
+		}
 		// Creates new LocalBuddy
 		Buddy *createBuddy(RosterManager *rosterManager, const BuddyInfo &buddyInfo) {
 			LocalBuddy *buddy = new LocalBuddy(rosterManager, buddyInfo.id);
 			buddy->setAlias(buddyInfo.alias);
 			buddy->setName(buddyInfo.legacyName);
 			buddy->setSubscription(buddyInfo.subscription);
 			if (buddyInfo.subscription == "both") {
 				buddy->setSubscription(Buddy::Both);
+			}
 			else {
 				buddy->setSubscription(Buddy::Ask);
+			}
 			buddy->setGroups(buddyInfo.groups);
 			buddy->setFlags((BuddyFlag) (buddyInfo.flags));
 			if (buddyInfo.settings.find("icon_hash") != buddyInfo.settings.end())
 				buddy->setIconHash(buddyInfo.settings.find("icon_hash")->second.s);
 			return buddy;
+		}
 	private:
 		NetworkPluginServer *m_nps;
 };
 // Wraps google protobuf payload into WrapperMessage and serialize it to string
 #define WRAP(MESSAGE, TYPE) 	pbnetwork::WrapperMessage wrap; \
 	wrap.set_type(TYPE); \
 	wrap.set_payload(MESSAGE); \
 	wrap.SerializeToString(&MESSAGE);
 // Executes new backend
 static unsigned long exec_(std::string path, const char *host, const char *port, const char *config) {
 	std::string original_path = path;
 	// BACKEND_ID is replaced with unique ID. The ID is increasing for every backend.
 	boost::replace_all(path, "BACKEND_ID", boost::lexical_cast<std::string>(backend_id++));
 	// Add host and port.
 	// some users are in queue waiting for this backend
 	while(!m_waitingUsers.empty()) {
 		// There's no new backend, so stop associating users and wait for new backend,
 		// which has been already spawned in getFreeClient() call.
 		if (getFreeClient() == NULL)
 			break;
 		User *u = m_waitingUsers.front();
 		m_waitingUsers.pop_front();
 		LOG4CXX_INFO(logger, "Associating " << u->getJID().toString() << " with this backend");
 		// associate backend with user
 		handleUserCreated(u);
 		// connect user if it's ready
 		if (u->isReadyToConnect()) {
 			handleUserReadyToConnect(u);
+		}
+	}
+}
 void NetworkPluginServer::handleSessionFinished(Backend *c) {
 	LOG4CXX_INFO(logger, "Backend " << c << " disconnected. Current backend count=" << (m_clients.size() - 1));
+	LOG4CXX_INFO(logger, "Backend " << c << " (ID=" << c->id << ") disconnected. Current backend count=" << (m_clients.size() - 1));
 	// This backend will do, so we can't reconnect users to it in User::handleDisconnected call
 	c->willDie = true;
 	// If there are users associated with this backend, it must have crashed, so print error output
 	// and disconnect users
 	if (!c->users.empty()) {
 		m_crashedBackends.push_back(c->id);
+	}
 	for (std::list<User *>::const_iterator it = c->users.begin(); it != c->users.end(); it++) {
 		LOG4CXX_ERROR(logger, "Backend " << c << " disconnected (probably crashed) with active user " << (*it)->getJID().toString());
+		LOG4CXX_ERROR(logger, "Backend " << c << " (ID=" << c->id << ") disconnected (probably crashed) with active user " << (*it)->getJID().toString());
 		(*it)->setData(NULL);
 		(*it)->handleDisconnected("Internal Server Error, please reconnect.");
+	}
 	std::string message;
 	pbnetwork::WrapperMessage wrap;
 	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_EXIT);
 	wrap.SerializeToString(&message);
 	send(c->connection, message);
 	c->connection->onDisconnected.disconnect_all_slots();
 	c->connection->onDataRead.disconnect_all_slots();
 	c->connection->disconnect();
 	c->connection.reset();
 	m_clients.remove(c);
 	delete c;
+}
 void NetworkPluginServer::handleConnectedPayload(const std::string &data) {
 	pbnetwork::Connected payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 	// Set proper body.
 	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 	if (subject) {
 		msg->setSubject(payload.message());
+	}
 	else {
 		msg->setBody(payload.message());
+	}
 	// Add xhtml-im payload.
 	if (!payload.xhtml().empty()) {
 		msg->addPayload(boost::make_shared<Swift::XHTMLIMPayload>(payload.xhtml()));
+	}
 	// Create new Conversation if it does not exist
 	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(payload.buddyname());
 	if (!conv) {
 		conv = new NetworkConversation(user->getConversationManager(), payload.buddyname());
 		conv->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, this, _1, _2));
+	}
 	// Forward it
 	conv->handleMessage(msg, payload.nickname());
 	m_userManager->messageToXMPPSent();
+}
 void NetworkPluginServer::handleAttentionPayload(const std::string &data) {
 	pbnetwork::ConversationMessage payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	User *user = m_userManager->getUser(payload.username());
 	if (!user)
 		return;
 	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 	msg->setBody(payload.message());
 	msg->addPayload(boost::make_shared<Swift::AttentionPayload>());
 	// Attentions trigger new Conversation creation
 	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(payload.buddyname());
 	if (!conv) {
 		conv = new NetworkConversation(user->getConversationManager(), payload.buddyname());
 		conv->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, this, _1, _2));
+	}
 	conv->handleMessage(msg);
+}
 void NetworkPluginServer::handleStatsPayload(Backend *c, const std::string &data) {
 	pbnetwork::Stats payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	c->res = payload.res();
 	c->init_res = payload.init_res();
 	c->shared = payload.shared();
 	c->id = payload.id();
+}
 void NetworkPluginServer::handleFTStartPayload(const std::string &data) {
 	pbnetwork::File payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	User *user = m_userManager->getUser(payload.username());
 	if (!user)
 		return;
 	LOG4CXX_INFO(logger, "handleFTStartPayload " << payload.filename() << " " << payload.buddyname());
 	LocalBuddy *buddy = (LocalBuddy *) user->getRosterManager()->getBuddy(payload.buddyname());
 	if (!buddy) {
 		// TODO: escape? reject?
 		return;
+	}
 	Swift::StreamInitiationFileInfo fileInfo;
 	fileInfo.setSize(payload.size());
 	fileInfo.setName(payload.filename());
@@ @@ -832,83 +843,83 @@ void NetworkPluginServer::pingTimeout() { @@
 				if (now - u->getLastActivity() > diff) {
 					usersToMove.push_back(u);
+				}
+			}
+		}
 		// Move inactive users to long-running backend.
 		BOOST_FOREACH(User *u, usersToMove) {
 			LOG4CXX_INFO(logger, "Moving user " << u->getJID().toString() << " to long-running backend");
 			if (!moveToLongRunBackend(u))
 				break;
+		}
+	}
 	// check ping responses
 	std::vector<Backend *> toRemove;
 	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {
 		// pong has been received OR backend just connected and did not have time to answer the ping
 		// request.
 		if ((*it)->pongReceived || (*it)->pongReceived == -1) {
 			sendPing((*it));
+		}
 		else {
 			LOG4CXX_INFO(logger, "Disconnecting backend " << (*it) << ". PING response not received.");
+			LOG4CXX_INFO(logger, "Disconnecting backend " << (*it) << " (ID=" << (*it)->id << "). PING response not received.");
 			toRemove.push_back(*it);
+		}
 		if ((*it)->users.size() == 0) {
 			LOG4CXX_INFO(logger, "Disconnecting backend " << (*it) << ". There are no users.");
+			LOG4CXX_INFO(logger, "Disconnecting backend " << (*it) << " (ID=" << (*it)->id << "). There are no users.");
 			toRemove.push_back(*it);
+		}
+	}
 	BOOST_FOREACH(Backend *b, toRemove) {
 		handleSessionFinished(b);
+	}
 	m_pingTimer->start();
+}
 void NetworkPluginServer::collectBackend() {
 	// Stop accepting new users to backend with the biggest memory usage. This prevents backends
 	// which are leaking to eat whole memory by connectin new users to legacy network.
 	LOG4CXX_INFO(logger, "Collect backend called, finding backend which will be set to die");
 	unsigned long max = 0;
 	Backend *backend = NULL;
 	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {
 		if ((*it)->res > max) {
 			max = (*it)->res;
 			backend = (*it);
+		}
+	}
 	if (backend) {
 		if (m_collectTimer) {
 			m_collectTimer->start();
+		}
 		LOG4CXX_INFO(logger, "Backend " << backend << "is set to die");
+		LOG4CXX_INFO(logger, "Backend " << backend << " (ID=" << backend->id << ") is set to die");
 		backend->acceptUsers = false;
+	}
+}
 bool NetworkPluginServer::moveToLongRunBackend(User *user) {
 	// Check if user has already some backend
 	Backend *old = (Backend *) user->getData();
 	if (!old) {
 		LOG4CXX_INFO(logger, "User " << user->getJID().toString() << " does not have old backend. Not moving.");
 		return true;
+	}
 	// if he's already on long run, do nothing
 	if (old->longRun) {
 		LOG4CXX_INFO(logger, "User " << user->getJID().toString() << " is already on long-running backend. Not moving.");
 		return true;
+	}
 	// Get free longrun backend, if there's no longrun backend, create one and wait
 	// for its connection
 	Backend *backend = getFreeClient(false, true);
 	if (!backend) {
 		LOG4CXX_INFO(logger, "No free long-running backend for user " << user->getJID().toString() << ". Will try later");
 		return false;
+}
 void NetworkPluginServer::handleFTStateChanged(Swift::FileTransfer::State state, const std::string &userName, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long id) {
 	User *user = m_userManager->getUser(userName);
 	if (!user) {
 		// TODO: FIXME We have to remove filetransfer when use disconnects
 		return;
+	}
 	if (state.state == Swift::FileTransfer::State::Transferring) {
 		handleFTAccepted(user, buddyName, fileName, size, id);
+	}
 	else if (state.state == Swift::FileTransfer::State::Canceled) {
 		handleFTRejected(user, buddyName, fileName, size);
+	}
+}
 void NetworkPluginServer::sendPing(Backend *c) {
 	std::string message;
 	pbnetwork::WrapperMessage wrap;
 	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_PING);
 	wrap.SerializeToString(&message);
 	if (c->connection) {
 		LOG4CXX_INFO(logger, "PING to " << c);
+		LOG4CXX_INFO(logger, "PING to " << c << " (ID=" << c->id << ")");
 		send(c->connection, message);
 		c->pongReceived = false;
+	}
 // 	LOG4CXX_INFO(logger, "PING to " << c);
+}
 NetworkPluginServer::Backend *NetworkPluginServer::getFreeClient(bool acceptUsers, bool longRun) {
 	NetworkPluginServer::Backend *c = NULL;
 	// Check all backends and find free one
 	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {
 		if ((*it)->willDie == false && (*it)->acceptUsers == acceptUsers && (*it)->users.size() < CONFIG_INT(m_config, "service.users_per_backend") && (*it)->connection && (*it)->longRun == longRun) {
 			c = *it;
 			// if we're not reusing all backends and backend is full, stop accepting new users on this backend
 			if (!CONFIG_BOOL(m_config, "service.reuse_old_backends")) {
 				if (c->users.size() + 1 >= CONFIG_INT(m_config, "service.users_per_backend")) {
 					c->acceptUsers = false;
+				}
+			}
 			break;
+		}
+	}
 	// there's no free backend, so spawn one.

src/rostermanager.cpp

➞

Show inline comments

@@ @@ -116,76 +116,86 @@ void RosterManager::sendBuddyRosterPush(Buddy *buddy) { @@
 	else {
 		item.setName(buddy->getAlias());
+	}
 	item.setGroups(buddy->getGroups());
 	item.setSubscription(Swift::RosterItemPayload::Both);
 	payload->addItem(item);
 	// In server mode we have to send pushes to all resources, but in gateway-mode we send it only to bare JID
 	if (m_component->inServerMode()) {
 		std::vector<Swift::Presence::ref> presences = m_component->getPresenceOracle()->getAllPresence(m_user->getJID().toBare());
 		BOOST_FOREACH(Swift::Presence::ref presence, presences) {
 			Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, presence->getFrom(), m_component->getIQRouter());
 			request->onResponse.connect(boost::bind(&RosterManager::handleBuddyRosterPushResponse, this, _1, request, buddy->getName()));
 			request->send();
 			m_requests.push_back(request);
+		}
+	}
 	else {
 		Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, m_user->getJID().toBare(), m_component->getIQRouter());
 		request->onResponse.connect(boost::bind(&RosterManager::handleBuddyRosterPushResponse, this, _1, request, buddy->getName()));
 		request->send();
 		m_requests.push_back(request);
+	}
 	if (buddy->getSubscription() != Buddy::Both) {
 		buddy->setSubscription(Buddy::Both);
 		handleBuddyChanged(buddy);
+	}
+}
 void RosterManager::sendBuddySubscribePresence(Buddy *buddy) {
 	Swift::Presence::ref response = Swift::Presence::create();
 	response->setTo(m_user->getJID());
 	response->setFrom(buddy->getJID());
 	response->setType(Swift::Presence::Subscribe);
 // 	TODO: NICKNAME
 	m_component->getStanzaChannel()->sendPresence(response);
+}
 void RosterManager::handleBuddyChanged(Buddy *buddy) {
 	if (m_rosterStorage) {
 		m_rosterStorage->storeBuddy(buddy);
+	}
+}
 void RosterManager::setBuddyCallback(Buddy *buddy) {
 	LOG4CXX_INFO(logger, "Associating buddy " << buddy->getName() << " with " << m_user->getJID().toString());
 	m_buddies[buddy->getName()] = buddy;
 	onBuddySet(buddy);
 	// In server mode the only way is to send jabber:iq:roster push.
 	// In component mode we send RIE or Subscribe presences, based on features.
 	if (m_component->inServerMode()) {
 		sendBuddyRosterPush(buddy);
+	}
 	else {
 		if (buddy->getSubscription() == Buddy::Both) {
 			LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Not forwarding this buddy, because subscription=both");
 			return;
+		}
 		if (m_supportRemoteRoster) {
 			sendBuddyRosterPush(buddy);
+		}
 		else {
 			// Send RIE only if there's resource which supports it.
 			Swift::JID jidWithRIE = m_user->getJIDWithFeature("http://jabber.org/protocol/rosterx");
 			if (jidWithRIE.isValid()) {
 				m_RIETimer->start();
+			}
 			else {
 				sendBuddySubscribePresence(buddy);
+			}
+		}
+	}
 	if (m_rosterStorage)
 		m_rosterStorage->storeBuddy(buddy);
+}
 void RosterManager::unsetBuddy(Buddy *buddy) {
 	m_buddies.erase(buddy->getName());
 	if (m_rosterStorage)
 		m_rosterStorage->removeBuddyFromQueue(buddy);
 	onBuddyUnset(buddy);
 				default:
 					return;
+			}
 			m_component->getStanzaChannel()->sendPresence(response);
+		}
 		else {
 			BuddyInfo buddyInfo;
 			switch (presence->getType()) {
 				// buddy is not in roster, so add him
 				case Swift::Presence::Subscribe:
 					buddyInfo.id = -1;
 					buddyInfo.alias = "";
 					buddyInfo.legacyName = Buddy::JIDToLegacyName(presence->getTo());
 					buddyInfo.subscription = "both";
 					buddyInfo.flags = Buddy::buddFlagsFromJID(presence->getTo());
 					LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Subscription received for new buddy " << buddyInfo.legacyName << " => adding to legacy network");
 					buddy = m_component->getFactory()->createBuddy(this, buddyInfo);
 					setBuddy(buddy);
 					onBuddyAdded(buddy);
 					response->setType(Swift::Presence::Subscribed);
 					break;
 				case Swift::Presence::Subscribed:
 					onBuddyAdded(buddy);
 					break;
 // 					onBuddyAdded(buddy);
 					return;
 				// buddy is already there, so nothing to do, just answer
 				case Swift::Presence::Unsubscribe:
 					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());
 		Buddy *buddy = getBuddy(Buddy::JIDToLegacyName(presence->getTo()));
 		if (buddy) {
 			switch (presence->getType()) {
 				// buddy is already there, so nothing to do, just answer
 				case Swift::Presence::Subscribe:
 					onBuddyAdded(buddy);
 					response->setType(Swift::Presence::Subscribed);
 					currentPresence = buddy->generatePresenceStanza(255);
 					if (currentPresence) {
 						currentPresence->setTo(presence->getFrom());
 						m_component->getStanzaChannel()->sendPresence(currentPresence);
+					}
 					if (buddy->getSubscription() != Buddy::Both) {
 						buddy->setSubscription(Buddy::Both);
 						handleBuddyChanged(buddy);
+					}
 					break;
 				// remove buddy
 				case Swift::Presence::Unsubscribe:
 					response->setType(Swift::Presence::Unsubscribed);
 					onBuddyRemoved(buddy);
 					break;
 				// just send response
 				case Swift::Presence::Unsubscribed:
 					response->setType(Swift::Presence::Unsubscribe);
 					// We set both here, because this Unsubscribed can be response to
 					// subscribe presence and we don't want that unsubscribe presence
 					// to be send later again
 					if (buddy->getSubscription() != Buddy::Both) {
 						buddy->setSubscription(Buddy::Both);
 						handleBuddyChanged(buddy);
+					}
 					break;
 				case Swift::Presence::Subscribed:
 					if (buddy->getSubscription() != Buddy::Both) {
 						buddy->setSubscription(Buddy::Both);
 						handleBuddyChanged(buddy);
+					}
 					return;
 				default:
 					return;
+			}
+		}
 		else {
 			BuddyInfo buddyInfo;
 			switch (presence->getType()) {
 				// buddy is not in roster, so add him
 				case Swift::Presence::Subscribe:
 					buddyInfo.id = -1;
 					buddyInfo.alias = "";
 					buddyInfo.legacyName = Buddy::JIDToLegacyName(presence->getTo());
 					buddyInfo.subscription = "both";
 					buddyInfo.flags = Buddy::buddFlagsFromJID(presence->getTo());
 					buddy = m_component->getFactory()->createBuddy(this, buddyInfo);
 					setBuddy(buddy);
 					onBuddyAdded(buddy);
 					response->setType(Swift::Presence::Subscribed);
 					break;
 				// buddy is already there, so nothing to do, just answer
 				case Swift::Presence::Unsubscribe:
 					response->setType(Swift::Presence::Unsubscribed);
 					onBuddyRemoved(buddy);
+// 					onBuddyRemoved(buddy);
 					break;
 				// just send response
 				case Swift::Presence::Unsubscribed:
 					response->setType(Swift::Presence::Unsubscribe);
 					break;
 				// just send response
 				default:
 					return;
+			}
+		}
 		m_component->getStanzaChannel()->sendPresence(response);
 		// We have to act as buddy and send its subscribe/unsubscribe just to be sure...
 		switch (response->getType()) {
 			case Swift::Presence::Unsubscribed:
 				response->setType(Swift::Presence::Unsubscribe);
 				m_component->getStanzaChannel()->sendPresence(response);
 				break;
 			case Swift::Presence::Subscribed:
 				response->setType(Swift::Presence::Subscribe);
 				m_component->getStanzaChannel()->sendPresence(response);
 				break;
 			default:

src/rosterstorage.cpp

➞

Show inline comments

+}
 RosterStorage::~RosterStorage() {
 	m_storageTimer->stop();
+}
 void RosterStorage::storeBuddy(Buddy *buddy) {
 	m_buddies[buddy->getName()] = buddy;
 	m_storageTimer->start();
+}
 bool RosterStorage::storeBuddies() {
 	if (m_buddies.size() == 0) {
 		return false;
+	}
 	m_storageBackend->beginTransaction();
 	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {
 		Buddy *buddy = (*it).second;
 		BuddyInfo buddyInfo;
 		buddyInfo.alias = buddy->getAlias();
 		buddyInfo.legacyName = buddy->getName();
 		buddyInfo.groups = buddy->getGroups();
 		buddyInfo.subscription = buddy->getSubscription();
+		buddyInfo.subscription = buddy->getSubscription() == Buddy::Ask ? "ask" : "both";
 		buddyInfo.id = buddy->getID();
 		buddyInfo.flags = buddy->getFlags();
 		buddyInfo.settings["icon_hash"].s = buddy->getIconHash();
 		buddyInfo.settings["icon_hash"].type = TYPE_STRING;
 		// Buddy is in DB
 		if (buddyInfo.id != -1) {
 			m_storageBackend->updateBuddy(m_user->getUserInfo().id, buddyInfo);
+		}
 		else {
 			buddyInfo.id = m_storageBackend->addBuddy(m_user->getUserInfo().id, buddyInfo);
 			buddy->setID(buddyInfo.id);
+		}
 // 		Log("buddyListSaveNode", id << " " << name << " " << alias << " " << s_buddy->getSubscription());
 // 		if (s_buddy->getBuddy() && id != -1) {
 // 			PurpleBuddy *buddy = s_buddy->getBuddy();
 // 			SaveData *s = new SaveData;
 // 			s->user = user;
 // 			s->id = id;
 // 			g_hash_table_foreach(buddy->node.settings, save_settings, s);
 // 			delete s;
 // 		}
+	}

src/statsresponder.cpp

➞

Show inline comments

@@ @@ -60,83 +60,95 @@ StatsResponder::~StatsResponder() { @@
 unsigned long StatsResponder::usedMemory() {
 	double shared = 0;
 	double rss = 0;
 #ifndef WIN32
 	process_mem_usage(shared, rss);
 #endif
 	rss -= shared;
 	const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();
 	BOOST_FOREACH(NetworkPluginServer::Backend * backend, backends) {
 		rss += backend->res - backend->shared;
+	}
 	return (unsigned long) rss;
+}
 bool StatsResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<StatsPayload> stats) {
 	boost::shared_ptr<StatsPayload> response(new StatsPayload());
 	if (stats->getItems().empty()) {
 		response->addItem(StatsPayload::Item("uptime"));
 		response->addItem(StatsPayload::Item("users/online"));
 		response->addItem(StatsPayload::Item("contacts/online"));
 		response->addItem(StatsPayload::Item("contacts/total"));
 		response->addItem(StatsPayload::Item("backends"));
 		response->addItem(StatsPayload::Item("messages/from-xmpp"));
 		response->addItem(StatsPayload::Item("messages/to-xmpp"));
 		response->addItem(StatsPayload::Item("backends/running"));
 		response->addItem(StatsPayload::Item("backends/crashed"));
 		response->addItem(StatsPayload::Item("memory-usage"));
+	}
 	else {
 		unsigned long contactsOnline = 0;
 		unsigned long contactsTotal = 0;
 		Swift::StatusShow s;
 		std::string statusMessage;
 		for (std::map<std::string, User *>::const_iterator it = m_userManager->getUsers().begin(); it != m_userManager->getUsers().end(); it++) {
 			if (!(*it).second) {
 				continue;
+			}
 			const RosterManager::BuddiesMap &buddies = (*it).second->getRosterManager()->getBuddies();
 			contactsTotal += buddies.size();
 			for(RosterManager::BuddiesMap::const_iterator bt = buddies.begin(); bt != buddies.end(); bt++) {
 				if (!(*bt).second) {
 					continue;
+				}
 				if (!(*bt).second->getStatus(s, statusMessage))
 					continue;
 				if (s.getType() != Swift::StatusShow::None) {
 					contactsOnline++;
+				}
+			}
+		}
 		BOOST_FOREACH(const StatsPayload::Item &item, stats->getItems()) {
 			if (item.getName() == "uptime") {
 				response->addItem(StatsPayload::Item("uptime", "seconds", boost::lexical_cast<std::string>(time(0) - m_start)));
+			}
 			else if (item.getName() == "users/online") {
 				response->addItem(StatsPayload::Item("users/online", "users", boost::lexical_cast<std::string>(m_userManager->getUserCount())));
+			}
 			else if (item.getName() == "backends") {
 				response->addItem(StatsPayload::Item("backends", "backends", boost::lexical_cast<std::string>(m_server->getBackendCount())));
 			else if (item.getName() == "backends/running") {
 				response->addItem(StatsPayload::Item("backends/running", "backends", boost::lexical_cast<std::string>(m_server->getBackendCount())));
+			}
 			else if (item.getName() == "backends/crashed") {
 				response->addItem(StatsPayload::Item("backends/crashed", "backends", boost::lexical_cast<std::string>(m_server->getCrashedBackends().size())));
+			}
 			else if (item.getName() == "memory-usage") {
 				response->addItem(StatsPayload::Item("memory-usage", "KB", boost::lexical_cast<std::string>(usedMemory())));
+			}
 			else if (item.getName() == "contacts/online") {
 				response->addItem(StatsPayload::Item("contacts/online", "contacts", boost::lexical_cast<std::string>(contactsOnline)));
+			}
 			else if (item.getName() == "contacts/total") {
 				response->addItem(StatsPayload::Item("contacts/total", "contacts", boost::lexical_cast<std::string>(contactsTotal)));
+			}
 			else if (item.getName() == "messages/from-xmpp") {
 				response->addItem(StatsPayload::Item("messages/from-xmpp", "messages", boost::lexical_cast<std::string>(m_userManager->getMessagesToBackend())));
+			}
 			else if (item.getName() == "messages/to-xmpp") {
 				response->addItem(StatsPayload::Item("messages/to-xmpp", "messages", boost::lexical_cast<std::string>(m_userManager->getMessagesToXMPP())));
+			}
+		}
+	}
 	sendResponse(from, id, response);
 	return true;
+}
 bool StatsResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<StatsPayload> stats) {
 	return false;
+}
+}

src/storagebackend.cpp

➞

Show inline comments

@@ new file 100644 @@
 #include "transport/storagebackend.h"
 #include "transport/config.h"
 #include "transport/sqlite3backend.h"
 #include "transport/mysqlbackend.h"
 #include "transport/pqxxbackend.h"
 namespace Transport {
 StorageBackend *StorageBackend::createBackend(Config *config, std::string &error) {
 	StorageBackend *storageBackend = NULL;
 #ifdef WITH_SQLITE
 	if (CONFIG_STRING(config, "database.type") == "sqlite3") {
 		storageBackend = new SQLite3Backend(config);
+	}
 #else
 	if (CONFIG_STRING(config, "database.type") == "sqlite3") {
 		error = "Libtransport is not compiled with sqlite3 backend support.";
+	}
 #endif
 #ifdef WITH_MYSQL
 	if (CONFIG_STRING(config, "database.type") == "mysql") {
 		storageBackend = new MySQLBackend(config);
+	}
 #else
 	if (CONFIG_STRING(config, "database.type") == "mysql") {
 		error = "Spectrum2 is not compiled with mysql backend support.";
+	}
 #endif
 #ifdef WITH_PQXX
 	if (CONFIG_STRING(config, "database.type") == "pqxx") {
 		storageBackend = new PQXXBackend(config);
+	}
 #else
 	if (CONFIG_STRING(config, "database.type") == "pqxx") {
 		error = "Spectrum2 is not compiled with pqxx backend support.";
+	}
 #endif
 	if (CONFIG_STRING(config, "database.type") != "mysql" && CONFIG_STRING(config, "database.type") != "sqlite3"
 		&& CONFIG_STRING(config, "database.type") != "pqxx" && CONFIG_STRING(config, "database.type") != "none") {
 		error = "Unknown storage backend " + CONFIG_STRING(config, "database.type");
+	}
 	return storageBackend;
+}
+}

src/tests/basictest.h

➞

Show inline comments

@@ @@ -51,49 +51,49 @@ class TestingConversation : public Conversation { @@
+		}
 		// Called when there's new message to legacy network from XMPP network
 		void sendMessage(boost::shared_ptr<Swift::Message> &message) {
+		}
 };
 class TestingFactory : public Factory {
 	public:
 		TestingFactory() {
+		}
 		// Creates new conversation (NetworkConversation in this case)
 		Conversation *createConversation(ConversationManager *conversationManager, const std::string &legacyName) {
 			Conversation *nc = new TestingConversation(conversationManager, legacyName);
 			return nc;
+		}
 		// Creates new LocalBuddy
 		Buddy *createBuddy(RosterManager *rosterManager, const BuddyInfo &buddyInfo) {
 			LocalBuddy *buddy = new LocalBuddy(rosterManager, buddyInfo.id);
 			buddy->setAlias(buddyInfo.alias);
 			buddy->setName(buddyInfo.legacyName);
-			buddy->setSubscription(buddyInfo.subscription);
+			buddy->setSubscription(Buddy::Ask);
 			buddy->setGroups(buddyInfo.groups);
 			buddy->setFlags((BuddyFlag) buddyInfo.flags);
 			if (buddyInfo.settings.find("icon_hash") != buddyInfo.settings.end())
 				buddy->setIconHash(buddyInfo.settings.find("icon_hash")->second.s);
 			return buddy;
+		}
 };
 class BasicTest : public Swift::XMPPParserClient {
 	public:
 		void setMeUp (void);
 		void tearMeDown (void);
 	void handleDataReceived(const Swift::SafeByteArray &data);
 	void handleStreamStart(const Swift::ProtocolHeader&);
 	void handleElement(boost::shared_ptr<Swift::Element> element);
 	void handleStreamEnd();
 	void injectPresence(boost::shared_ptr<Swift::Presence> &response);

src/user.cpp

➞

Show inline comments

 		if (m_readyForConnect == false) {
 			// Forward status message to legacy network, but only if it's sent from active resource
 // 					if (m_activeResource == presence->getFrom().getResource().getUTF8String()) {
 // 						forwardStatus(presenceShow, stanzaStatus);
 // 					}
 			boost::shared_ptr<Swift::CapsInfo> capsInfo = presence->getPayload<Swift::CapsInfo>();
 			if (capsInfo && capsInfo->getHash() == "sha-1") {
 				if (m_entityCapsManager->getCaps(presence->getFrom()) != Swift::DiscoInfo::ref()) {
 					LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");
 					m_readyForConnect = true;
 					onReadyToConnect();
+				}
+			}
 			else if (m_component->inServerMode()) {
 				LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");
 				m_readyForConnect = true;
 				onReadyToConnect();
+			}
 			else {
 				m_reconnectTimer->start();
+			}
+		}
+	}
 	bool isMUC = presence->getPayload<Swift::MUCPayload>() != NULL || *presence->getTo().getNode().c_str() == '#';
 	if (isMUC) {
 		if (presence->getType() == Swift::Presence::Unavailable) {
 			std::string room = Buddy::JIDToLegacyName(presence->getTo());
 			LOG4CXX_INFO(logger, m_jid.toString() << ": Going to left room " << room);
 			onRoomLeft(room);
+		}
 		else {
 			// force connection to legacy network to let backend to handle auto-join on connect.
 			if (!m_readyForConnect) {
 				LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");
 				m_readyForConnect = true;
 				onReadyToConnect();
+			}
 			std::string room = Buddy::JIDToLegacyName(presence->getTo());
 			LOG4CXX_INFO(logger, m_jid.toString() << ": Going to join room " << room << " as " << presence->getTo().getResource());
 			std::string password = "";
 			if (presence->getPayload<Swift::MUCPayload>() != NULL) {
 				password = presence->getPayload<Swift::MUCPayload>()->getPassword() ? *presence->getPayload<Swift::MUCPayload>()->getPassword() : "";
+			}
 			onRoomJoined(presence->getFrom(), room, presence->getTo().getResource(), password);
+		}
 		return;
+	}
@@ @@ -307,49 +308,49 @@ void User::onConnectingTimeout() { @@
 	m_readyForConnect = true;
 	onReadyToConnect();
 	Swift::Presence::ref highest = m_presenceOracle->getHighestPriorityPresence(m_jid.toBare());
 	if (highest) {
 		LOG4CXX_INFO(logger, m_jid.toString() << ": Changing legacy network presence to " << highest->getType());
 		onPresenceChanged(highest);
+	}
+}
 void User::setIgnoreDisconnect(bool ignoreDisconnect) {
 	m_ignoreDisconnect = ignoreDisconnect;
 	LOG4CXX_INFO(logger, m_jid.toString() << ": Setting ignoreDisconnect=" << m_ignoreDisconnect);
+}
 void User::handleDisconnected(const std::string &error, Swift::SpectrumErrorPayload::Error e) {
 	if (m_ignoreDisconnect) {
 		LOG4CXX_INFO(logger, m_jid.toString() << ": Disconnecting from legacy network ignored (probably moving between backends)");
 		return;
+	}
 	if (e == Swift::SpectrumErrorPayload::CONNECTION_ERROR_OTHER_ERROR || e == Swift::SpectrumErrorPayload::CONNECTION_ERROR_NETWORK_ERROR) {
 		if (m_reconnectCounter < 3) {
 			m_reconnectCounter++;
-			LOG4CXX_INFO(logger, m_jid.toString() << ": Disconnecting from legacy network for, trying to reconnect automatically.");
+			LOG4CXX_INFO(logger, m_jid.toString() << ": Disconnecting from legacy network " << error << ", trying to reconnect automatically.");
 			// Simulate destruction/resurrection :)
 			// TODO: If this stops working, create onReconnect signal
 			m_userManager->onUserDestroyed(this);
 			m_userManager->onUserCreated(this);
 			return;
+		}
+	}
 	if (error.empty()) {
 		LOG4CXX_INFO(logger, m_jid.toString() << ": Disconnected from legacy network");
+	}
 	else {
 		LOG4CXX_INFO(logger, m_jid.toString() << ": Disconnected from legacy network with error " << error);
+	}
 	onDisconnected();
 	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 	msg->setBody(error);
 	msg->setTo(m_jid.toBare());
 	msg->setFrom(m_component->getJID());
 	msg->addPayload(boost::make_shared<Swift::SpectrumErrorPayload>(e));
 	m_component->getStanzaChannel()->sendMessage(msg);
 	// In server mode, server finishes the session and pass unavailable session to userManager if we're connected to legacy network,

src/usermanager.cpp

➞

Show inline comments

@@ @@ -21,48 +21,50 @@ @@
 #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 "storageresponder.h"
 #include "log4cxx/logger.h"
 #include "Swiften/Swiften.h"
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Elements/StreamError.h"
 #include "malloc.h"
 // #include "valgrind/memcheck.h"
 using namespace log4cxx;
 namespace Transport {
 static LoggerPtr logger = Logger::getLogger("UserManager");
 UserManager::UserManager(Component *component, UserRegistry *userRegistry, StorageBackend *storageBackend) {
 	m_cachedUser = NULL;
 	m_onlineBuddies = 0;
 	m_sentToXMPP = 0;
 	m_sentToBackend = 0;
 	m_component = component;
 	m_storageBackend = storageBackend;
 	m_storageResponder = NULL;
 	m_userRegistry = userRegistry;
 	if (m_storageBackend) {
 		m_storageResponder = new StorageResponder(component->getIQRouter(), m_storageBackend, this);
 		m_storageResponder->start();
+	}
 	component->onUserPresenceReceived.connect(bind(&UserManager::handlePresence, this, _1));
 	component->onUserDiscoInfoReceived.connect(bind(&UserManager::handleDiscoInfo, this, _1, _2));
 	m_component->getStanzaChannel()->onMessageReceived.connect(bind(&UserManager::handleMessageReceived, this, _1));
 	m_component->getStanzaChannel()->onPresenceReceived.connect(bind(&UserManager::handleGeneralPresenceReceived, this, _1));
 	m_userRegistry->onConnectUser.connect(bind(&UserManager::connectUser, this, _1));
 	m_userRegistry->onDisconnectUser.connect(bind(&UserManager::disconnectUser, this, _1));
 	m_removeTimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(1);
+}
 UserManager::~UserManager(){
 	if (m_storageResponder) {
 		m_storageResponder->stop();
@@ @@ -129,48 +131,63 @@ void UserManager::removeAllUsers(bool 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();
 	std::string userkey = presence->getFrom().toBare().toString();
 	User *user = getUser(userkey);
 	// Create user class if it's not there
 	if (!user) {
 		// Admin user is not legacy network user, so do not create User class instance for him
 		if (m_component->inServerMode() && CONFIG_STRING(m_component->getConfig(), "service.admin_jid") == presence->getFrom().toBare().toString()) {
 			// Send admin contact to the user.
 			Swift::RosterPayload::ref payload = Swift::RosterPayload::ref(new Swift::RosterPayload());
 			Swift::RosterItemPayload item;
 			item.setJID(m_component->getJID());
 			item.setName("Admin");
 			item.setSubscription(Swift::RosterItemPayload::Both);
 			payload->addItem(item);
 			Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, presence->getFrom(), m_component->getIQRouter());
 			request->send();
 			Swift::Presence::ref response = Swift::Presence::create();
 			response->setTo(presence->getFrom());
 			response->setFrom(m_component->getJID());
 			m_component->getStanzaChannel()->sendPresence(response);
 			return;
+		}
 		// No user and unavailable presence -> answer with unavailable
 		if (presence->getType() == Swift::Presence::Unavailable) {
 			Swift::Presence::ref response = Swift::Presence::create();
 			response->setTo(presence->getFrom());
 			response->setFrom(presence->getTo());
 			response->setType(Swift::Presence::Unavailable);
 			m_component->getStanzaChannel()->sendPresence(response);
 			// Set user offline in database
 			if (m_storageBackend) {
 				UserInfo res;
 				bool registered = m_storageBackend->getUser(userkey, res);
 				if (registered) {
 					m_storageBackend->setUserOnline(res.id, false);
+				}
+			}
 			return;
+		}
 		UserInfo res;
 		bool registered = m_storageBackend ? m_storageBackend->getUser(userkey, res) : false;
 	// so better check for it and ignore deletion if "u" does not exist anymore.
 	User *user = getUser(jid);
 	if (user != u) {
 		return;
+	}
 	// Remove user
 	if (user) {
 		removeUser(user);
+	}
 	// Connect the user again when we're reconnecting.
 	if (reconnect) {
 		connectUser(jid);
+	}
+}
 void UserManager::handleMessageReceived(Swift::Message::ref message) {
 	User *user = getUser(message->getFrom().toBare().toString());
 	if (!user ){
 		return;
+	}
 	user->getConversationManager()->handleMessageReceived(message);
 	messageToBackendSent();
+}
 void UserManager::handleGeneralPresenceReceived(Swift::Presence::ref presence) {
 	switch(presence->getType()) {
 		case Swift::Presence::Subscribe:
 		case Swift::Presence::Subscribed:
 		case Swift::Presence::Unsubscribe:
 		case Swift::Presence::Unsubscribed:
 			handleSubscription(presence);
 			break;
 		case Swift::Presence::Available:
 		case Swift::Presence::Unavailable:
 			break;
 		case Swift::Presence::Probe:
 			handleProbePresence(presence);
 			break;
 		default:
 			break;
 	};
+}
 void UserManager::handleProbePresence(Swift::Presence::ref presence) {
 	User *user = getUser(presence->getFrom().toBare().toString());

src/userregistration.cpp

➞

Show inline comments

 	std::string newUsername(username);
 	if (!CONFIG_STRING(m_config, "registration.username_mask").empty()) {
 		newUsername = CONFIG_STRING(m_config, "registration.username_mask");
 		boost::replace_all(newUsername, "$username", username);
+	}
 //TODO: Part of spectrum1 registration stuff, this should be potentially rewritten for S2 too
 // 	if (!m_component->protocol()->isValidUsername(newUsername)) {
 // 		Log("UserRegistration", "This is not valid username: "<< newUsername);
 // 		sendError(from, id, ErrorPayload::NotAcceptable, ErrorPayload::Modify);
 // 		return true;
 // 	}
 //TODO: Part of spectrum1 registration stuff, this should be potentially rewritten for S2 too
 // #if GLIB_CHECK_VERSION(2,14,0)
 // 	if (!CONFIG_STRING(m_config, "registration.reg_allowed_usernames").empty() &&
 // 		!g_regex_match_simple(CONFIG_STRING(m_config, "registration.reg_allowed_usernames"), newUsername.c_str(),(GRegexCompileFlags) (G_REGEX_CASELESS | G_REGEX_EXTENDED), (GRegexMatchFlags) 0)) {
 // 		Log("UserRegistration", "This is not valid username: "<< newUsername);
 // 		sendError(from, id, ErrorPayload::NotAcceptable, ErrorPayload::Modify);
 // 		return true;
 // 	}
 // #endif
 	if (!registered) {
 		res.jid = barejid;
-		res.uin = username;
+		res.uin = newUsername;
 		res.password = *payload->getPassword();
 		res.language = language;
 		res.encoding = encoding;
 		res.vip = 0;
 		registerUser(res);
+	}
 	else {
 		res.jid = barejid;
-		res.uin = username;
+		res.uin = newUsername;
 		res.password = *payload->getPassword();
 		res.language = language;
 		res.encoding = encoding;
 		m_storageBackend->setUser(res);
 		onUserUpdated(res);
+	}
 	sendResponse(from, id, InBandRegistrationPayload::ref());
 	return true;
+}
+}

0 comments (0 inline, 0 general)