libtransport.git Changeset - d93cc2ce66eb

Changeset - d93cc2ce66eb

Parent rev.

Child rev.

[Not reviewed]

0 23 0

Florian Kinder - 8 years ago 2017-06-12 00:41:35
Fank@users.noreply.github.com

General cleanup (#216)

23 files changed with 419 insertions and 410 deletions:

backends/libpurple/main.cpp

backends/smstools3/main.cpp

backends/swiften/main.cpp

backends/twitter/HTTPRequest.cpp

backends/twitter/Requests/CreateFriendRequest.cpp

backends/twitter/Requests/DestroyFriendRequest.cpp

backends/twitter/Requests/DirectMessageRequest.cpp

backends/twitter/Requests/FetchFriends.cpp

backends/twitter/Requests/PINExchangeProcess.cpp

backends/twitter/Requests/ProfileImageRequest.cpp

backends/twitter/Requests/RetweetRequest.cpp

backends/twitter/Requests/StatusUpdateRequest.cpp

backends/twitter/Requests/TimelineRequest.cpp

backends/twitter/TwitterPlugin.cpp

146

backends/twitter/TwitterResponseParser.cpp

backends/twitter/main.cpp

libtransport/HTTPRequest.cpp

libtransport/ThreadPool.cpp

libtransport/User.cpp

libtransport/UserManager.cpp

spectrum/src/frontends/slack/SlackSession.cpp

spectrum/src/frontends/xmpp/XMPPUserRegistration.cpp

spectrum/src/main.cpp

0 comments (0 inline, 0 general)

backends/libpurple/main.cpp

➞

Show inline comments

 #include "utils.h"
 #include "glib.h"
 // win32/libc_interface.h defines its own socket(), read() and so on.
 // We don't want to use it here.
 #define _LIBC_INTERFACE_H_ 1
 #include "purple.h"
 #include <algorithm>
 #include <iostream>
-#include <fstream>
 #include <fstream>
 #include "transport/NetworkPlugin.h"
 #include "transport/Logging.h"
 #include "transport/Config.h"
 #include "transport/StorageBackend.h"
 #include "geventloop.h"
 #include "Swiften/SwiftenCompat.h"
 // #include "valgrind/memcheck.h"
 #if !defined(__FreeBSD__) && !defined(__APPLE__)
 #include "malloc.h"
 #endif
@@ @@ -179,47 +179,47 @@ static std::string getAlias(PurpleBuddy *m_buddy) { @@
+	}
 	else {
 		alias = (std::string) purple_buddy_get_server_alias_wrapped(m_buddy);
+	}
 	return alias;
+}
 static boost::mutex dblock;
 static std::string OAUTH_TOKEN = "hangouts_oauth_token";
 static bool getUserOAuthToken(const std::string user, std::string &token)
+{
   boost::mutex::scoped_lock lock(dblock);
   UserInfo info;
   if(storagebackend->getUser(user, info) == false) {
     LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
       return false;
+  }
   token = "";
   int type = TYPE_STRING;
   storagebackend->getUserSetting((long)info.id, OAUTH_TOKEN, type, token);
   return true;
 	boost::mutex::scoped_lock lock(dblock);
 	UserInfo info;
 	if(storagebackend->getUser(user, info) == false) {
 		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!");
 		return false;
+	}
 	token = "";
 	int type = TYPE_STRING;
 	storagebackend->getUserSetting((long)info.id, OAUTH_TOKEN, type, token);
 	return true;
+}
 static bool storeUserOAuthToken(const std::string user, const std::string OAuthToken)
+{
   boost::mutex::scoped_lock lock(dblock);
   UserInfo info;
   if(storagebackend->getUser(user, info) == false) {
     LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
       return false;
+  }
   storagebackend->updateUserSetting((long)info.id, OAUTH_TOKEN, OAuthToken);
   return true;
+}
 	boost::mutex::scoped_lock lock(dblock);
 	UserInfo info;
 	if(storagebackend->getUser(user, info) == false) {
 		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!");
 		return false;
+	}
 	storagebackend->updateUserSetting((long)info.id, OAUTH_TOKEN, OAuthToken);
 	return true;
+}
 class SpectrumNetworkPlugin : public NetworkPlugin {
 	public:
 		SpectrumNetworkPlugin() : NetworkPlugin() {
 			LOG4CXX_INFO(logger, "Starting libpurple backend " << SPECTRUM_VERSION);
+		}
 		void handleExitRequest() {
 			LOG4CXX_INFO(logger, "Exiting...");
 			exit(0);
+		}
@@ @@ -265,25 +265,25 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
+ 				}
 				PurplePlugin *plugin = purple_find_prpl_wrapped(purple_account_get_protocol_id_wrapped(account));
 				PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(plugin);
 				bool found = false;
 				for (GList *l = prpl_info->protocol_options; l != NULL; l = l->next) {
 					PurpleAccountOption *option = (PurpleAccountOption *) l->data;
 					PurplePrefType type = purple_account_option_get_type_wrapped(option);
 					std::string key2(purple_account_option_get_setting_wrapped(option));
 					if (strippedKey != key2) {
 						continue;
+					}
 					found = true;
 					switch (type) {
 						case PURPLE_PREF_BOOLEAN:
 							purple_account_set_bool_wrapped(account, strippedKey.c_str(), keyItem.second.as<bool>());
 							break;
 						case PURPLE_PREF_INT:
 							purple_account_set_int_wrapped(account, strippedKey.c_str(), fromString<int>(keyItem.second.as<std::string>()));
 							break;
 						case PURPLE_PREF_STRING:
 						case PURPLE_PREF_STRING_LIST:
@@ @@ -304,27 +304,27 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 			char* contents;
 			gsize length;
 			gboolean ret = g_file_get_contents ("gfire.cfg", &contents, &length, NULL);
 			if (ret) {
 				purple_account_set_int_wrapped(account, "version", fromString<int>(std::string(contents, length)));
+			}
 			if (CONFIG_STRING(config, "service.protocol") == "prpl-novell") {
 				std::string username(purple_account_get_username_wrapped(account));
 				std::vector <std::string> u = split(username, '@');
 				purple_account_set_username_wrapped(account, (const char*) u.front().c_str());
-				std::vector <std::string> s = split(u.back(), ':');
 				std::vector <std::string> s = split(u.back(), ':');
 				purple_account_set_string_wrapped(account, "server", s.front().c_str());
-				purple_account_set_int_wrapped(account, "port", atoi(s.back().c_str()));
 				purple_account_set_int_wrapped(account, "port", atoi(s.back().c_str()));
+			}
 			if (!CONFIG_STRING_DEFAULTED(config, "proxy.type", "").empty()) {
 				PurpleProxyInfo *info = purple_proxy_info_new_wrapped();
 				if (CONFIG_STRING_DEFAULTED(config, "proxy.type", "") == "http") {
 					purple_proxy_info_set_type_wrapped(info, PURPLE_PROXY_HTTP);
+				}
 				else if (CONFIG_STRING_DEFAULTED(config, "proxy.type", "") == "socks4") {
 					purple_proxy_info_set_type_wrapped(info, PURPLE_PROXY_SOCKS4);
+				}
 				else if (CONFIG_STRING_DEFAULTED(config, "proxy.type", "") == "socks5") {
 					purple_proxy_info_set_type_wrapped(info, PURPLE_PROXY_SOCKS5);
@@ @@ -421,25 +421,25 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 			if (CONFIG_BOOL(config, "service.enable_privacy_lists")) {
 				purple_account_set_privacy_type_wrapped(account, PURPLE_PRIVACY_DENY_USERS);
+			}
 #endif
 			// Set the status
 			const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive_wrapped(account, PURPLE_STATUS_AVAILABLE);
 			if (status_type != NULL) {
 				purple_account_set_status_wrapped(account, purple_status_type_get_id_wrapped(status_type), TRUE, NULL);
+			}
 			// OAuth helper
 			if (protocol == "prpl-hangouts") {
 				LOG4CXX_INFO(logger, user << ": Adding Buddy " << adminLegacyName << " " << adminAlias)
+				LOG4CXX_INFO(logger, user << ": Adding Buddy " << adminLegacyName << " " << adminAlias);
 				handleBuddyChanged(user, adminLegacyName, adminAlias, std::vector<std::string>(), pbnetwork::STATUS_ONLINE);
+			}
+		}
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				if (account->ui_data) {
 					NodeCache *cache = (NodeCache *) account->ui_data;
 					purple_timeout_remove_wrapped(cache->timer);
 					delete cache;
 					account->ui_data = NULL;
@@ @@ -523,25 +523,25 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 			if (account) {
 				LOG4CXX_INFO(logger, "Sending message to '" << legacyName << "'");
 				PurpleConversation *conv = purple_find_conversation_with_account_wrapped(PURPLE_CONV_TYPE_CHAT, LegacyNameToName(account, legacyName).c_str(), account);
 				if (legacyName == adminLegacyName) {
 					// expect OAuth code
 					if (m_inputRequests.find(user) != m_inputRequests.end()) {
 						LOG4CXX_INFO(logger, "Updating token for '" << user << "'");
 						m_inputRequests[user]->ok_cb(m_inputRequests[user]->user_data, message.c_str());
 						m_inputRequests.erase(user);
+					}
 					return;
+				}
 				if (!conv) {
 					conv = purple_find_conversation_with_account_wrapped(PURPLE_CONV_TYPE_IM, LegacyNameToName(account, legacyName).c_str(), account);
 					if (!conv) {
 						conv = purple_conversation_new_wrapped(PURPLE_CONV_TYPE_IM, account, LegacyNameToName(account, legacyName).c_str());
+					}
+				}
 				if (xhtml.empty()) {
 					gchar *_markup = purple_markup_escape_text_wrapped(message.c_str(), -1);
 					if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_IM) {
 						purple_conv_im_send_wrapped(PURPLE_CONV_IM_WRAPPED(conv), _markup);
+					}
 					else if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_CHAT) {
@@ @@ -806,25 +806,25 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 				return;
+			}
 			PurpleConversation *conv = purple_find_conversation_with_account_wrapped(PURPLE_CONV_TYPE_CHAT, LegacyNameToName(account, room).c_str(), account);
 			purple_conversation_destroy_wrapped(conv);
+		}
 		void handleFTStartRequest(const std::string &user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID) {
 			PurpleXfer *xfer = m_unhandledXfers[user + fileName + buddyName];
 			if (xfer) {
 				m_unhandledXfers.erase(user + fileName + buddyName);
 				FTData *ftData = (FTData *) xfer->ui_data;
 				ftData->id = ftID;
 				m_xfers[ftID] = xfer;
 				purple_xfer_request_accepted_wrapped(xfer, fileName.c_str());
 				purple_xfer_ui_ready_wrapped(xfer);
+			}
+		}
 		void handleFTFinishRequest(const std::string &user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID) {
 			PurpleXfer *xfer = m_unhandledXfers[user + fileName + buddyName];
 			if (xfer) {
 				m_unhandledXfers.erase(user + fileName + buddyName);
 				purple_xfer_request_denied_wrapped(xfer);
@@ @@ -1026,25 +1026,25 @@ void buddyListNewNode(PurpleBlistNode *node) { @@
 	if (caching) {
 		if (!account->ui_data) {
 			NodeCache *cache = new NodeCache;
 			cache->account = account;
 			cache->timer = purple_timeout_add_wrapped(400, new_node_cache, cache);
 			account->ui_data = (void *) cache;
+		}
 		NodeCache *cache = (NodeCache *) account->ui_data;
 		cache->nodes[node] = 1;
 		return;
+	}
 	std::vector<std::string> groups = getGroups(buddy);
 	LOG4CXX_INFO(logger, "Buddy updated " << np->m_accounts[account] << " " << purple_buddy_get_name_wrapped(buddy) << " " << getAlias(buddy) << " group (" << groups.size() << ")=" << groups[0]);
 	// Status
 	pbnetwork::StatusType status = pbnetwork::STATUS_NONE;
 	std::string message;
 	getStatus(buddy, status, message);
 	// Tooltip
 	PurplePlugin *prpl = purple_find_prpl_wrapped(purple_account_get_protocol_id_wrapped(account));
 	PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
 		if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_IM) {
 			std::string w = purple_normalize_wrapped(account, who);
 			size_t pos = w.find("/");
 			if (pos != std::string::npos)
 				w.erase((int) pos, w.length() - (int) pos);
 			np->handleMessage(np->m_accounts[account], w, message_, "", xhtml_, timestamp);
+		}
 		else {
 			std::string conversationName = purple_conversation_get_name_wrapped(conv);
 			LOG4CXX_INFO(logger, "Received message body='" << message_ << "' name='" << conversationName << "' " << who);
 			np->handleMessage(np->m_accounts[account], np->NameToLegacyName(account, conversationName), message_, who, xhtml_, timestamp);
+		}
+		}
+	}
+}
 static char *calculate_data_hash(guchar *data, size_t len,
     const gchar *hash_algo)
+{
 	PurpleCipherContext *context;
 	static gchar digest[129]; /* 512 bits hex + \0 */
 	context = purple_cipher_context_new_by_name(hash_algo, NULL);
 	if (context == NULL)
+	{
 					LOG4CXX_ERROR(logger, "Open file failure: " << strerror(errno));
 					return;
+				}
 				output.write((char *)data, len);
 				output.close();
+			}
 			else {
 				LOG4CXX_WARN(logger, "Image bigger than 1MB.");
 				purple_imgstore_unref_wrapped(image);
 				return;
+			}
 			purple_imgstore_unref_wrapped(image);
 			std::string src = CONFIG_STRING(config, "service.web_url") + "/" + name + "." + ext;
 			std::string img = "<img src=\"" + src + "\"/>";
 			boost::replace_all(body, "<img id=\"" + id + "\">", img);
 			boost::replace_all(plain, "<img id=\"" + id + "\">", src);
+		}
 		LOG4CXX_INFO(logger, "New image body='" << body << "'");
 		char *strip, *xhtml;
 		purple_markup_html_to_xhtml_wrapped(body.c_str(), &xhtml, &strip);
 		message_ = strip;
 		if (message_.empty()) {
 			message_ = plain;
+		}
@@ @@ -1479,25 +1479,25 @@ static PurpleConnectionUiOps conn_ui_ops = @@
 	NULL,
 	NULL
 };
 static void *notify_user_info(PurpleConnection *gc, const char *who, PurpleNotifyUserInfo *user_info) {
 	PurpleAccount *account = purple_connection_get_account_wrapped(gc);
 	std::string name(purple_normalize_wrapped(account, who));
 	size_t pos = name.find("/");
 	if (pos != std::string::npos)
 		name.erase((int) pos, name.length() - (int) pos);
 	GList *vcardEntries = purple_notify_user_info_get_entries_wrapped(user_info);
 	PurpleNotifyUserInfoEntry *vcardEntry;
 	std::string firstName;
 	std::string lastName;
 	std::string fullName;
 	std::string nickname;
 	std::string header;
 	std::string label;
 	std::string photo;
 	while (vcardEntries) {
 		vcardEntry = (PurpleNotifyUserInfoEntry *)(vcardEntries->data);
 					g_free(path);
+				}
+			}
 			else {
 				const gchar * data = (gchar*)purple_buddy_icon_get_data_wrapped(icon, &len);
 				if (len < 300000 && data) {
 					photo = std::string(data, len);
+				}
+			}
 			purple_buddy_icon_unref_wrapped(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;
+}
 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.");
+}
 static void XferNotSent(PurpleXfer *xfer, const guchar *buffer, gsize size) {
 // 	FiletransferRepeater *repeater = (FiletransferRepeater *) xfer->ui_data;
 // 	repeater->handleDataNotSent(buffer, size);
+}
 static gssize XferRead(PurpleXfer *xfer, guchar **buffer, gssize size) {
 // 	FiletransferRepeater *repeater = (FiletransferRepeater *) xfer->ui_data;
 // 	int data_size = repeater->getDataToSend(buffer, size);
 // 	if (data_size == 0)
 // 		return 0;
-//
 //
 // 	return data_size;
 	return 0;
+}
 static PurpleXferUiOps xferUiOps =
+{
 	XferCreated,
 	XferDestroyed,
 	NULL,
 	NULL,
 	xferCanceled,
 	xferCanceled,
+			}
 			else if (fstring == "users") {
 				usersId = id;
+			}
 			else {
 				LOG4CXX_INFO(logger, "Uknown RoomList field " << fstring);
+			}
+		}
 		GList *rooms;
 		std::list<std::string> m_topics;
 		for (rooms = list->rooms; rooms != NULL; rooms = rooms->next) {
-			PurpleRoomlistRoom *room = (PurpleRoomlistRoom *)rooms->data;
 			PurpleRoomlistRoom *room = (PurpleRoomlistRoom *)rooms->data;
 			np->m_rooms[np->m_accounts[list->account]].push_back(room->name);
 			if (topicId == -1) {
 				m_topics.push_back(room->name);
+			}
 			else {
 				char *topic = (char *) g_list_nth_data(purple_roomlist_room_get_fields(room), topicId);
 				if (topic) {
 					m_topics.push_back(topic);
+				}
 				else {
 					if (usersId) {
@@ @@ -1938,25 +1938,25 @@ static PurpleRoomlistUiOps roomlist_ui_ops = @@
 };
 static void transport_core_ui_init(void)
+{
 	purple_blist_set_ui_ops_wrapped(&blistUiOps);
 	purple_accounts_set_ui_ops_wrapped(&accountUiOps);
 	purple_notify_set_ui_ops_wrapped(&notifyUiOps);
 	purple_request_set_ui_ops_wrapped(&requestUiOps);
 	purple_xfers_set_ui_ops_wrapped(&xferUiOps);
 	purple_connections_set_ui_ops_wrapped(&conn_ui_ops);
 	purple_conversations_set_ui_ops_wrapped(&conversation_ui_ops);
 	purple_roomlist_set_ui_ops_wrapped(&roomlist_ui_ops);
 // #ifndef WIN32
 // 	purple_dnsquery_set_ui_ops_wrapped(getDNSUiOps());
 // #endif
+}
 /***** Core Ui Ops *****/
 static void
 spectrum_glib_log_handler(const gchar *domain,
 						  GLogLevelFlags flags,
 						  const gchar *message,
 						  gpointer user_data)
+{
@@ @@ -2009,25 +2009,25 @@ debug_init(void) @@
 #define REGISTER_G_LOG_HANDLER(name) \
 	g_log_set_handler((name), \
 		(GLogLevelFlags)(G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL \
 										  | G_LOG_FLAG_RECURSION), \
 					  spectrum_glib_log_handler, NULL)
 	REGISTER_G_LOG_HANDLER(NULL);
 	REGISTER_G_LOG_HANDLER("GLib");
 	REGISTER_G_LOG_HANDLER("GModule");
 	REGISTER_G_LOG_HANDLER("GLib-GObject");
 	REGISTER_G_LOG_HANDLER("GThread");
 	REGISTER_G_LOG_HANDLER("GConf");
 #undef REGISTER_G_LOD_HANDLER
+}
 static PurpleCoreUiOps coreUiOps =
+{
 	NULL,
 	debug_init,
 	transport_core_ui_init,
 	NULL,
 	spectrum_ui_get_info,
 	NULL,
@@ @@ -2036,25 +2036,25 @@ static PurpleCoreUiOps coreUiOps = @@
 };
 static void signed_on(PurpleConnection *gc, gpointer unused) {
 	PurpleAccount *account = purple_connection_get_account_wrapped(gc);
 	np->handleConnected(np->m_accounts[account]);
 #ifndef WIN32
 #if !defined(__FreeBSD__) && !defined(__APPLE__)
 	// force returning of memory chunks allocated by libxml2 to kernel
 	malloc_trim(0);
 #endif
 #endif
 	purple_roomlist_get_list_wrapped(gc);
 	// For prpl-gg
 	execute_purple_plugin_action(gc, "Download buddylist from Server");
 	if (CONFIG_STRING(config, "service.protocol") == "prpl-hangouts") {
 		storeUserOAuthToken(np->m_accounts[account], purple_account_get_password_wrapped(account));
+	}
+}
 static void printDebug(PurpleDebugLevel level, const char *category, const char *arg_s) {
 	std::string c("");
 	std::string args(arg_s);
 	args.erase(args.size() - 1);
@@ @@ -2120,25 +2120,25 @@ static bool initPurple() { @@
 	if (!resolvePurpleFunctions()) {
 		LOG4CXX_ERROR(logger, "Unable to load libpurple.dll or some of the needed methods");
 		return false;
+	}
 	std::string pluginsDir = CONFIG_STRING_DEFAULTED(config, "purple.plugins_dir", "./plugins");
 	LOG4CXX_INFO(logger, "Setting libpurple plugins directory to: " << pluginsDir);
 	purple_plugins_add_search_path_wrapped(pluginsDir.c_str());
 	std::string cacertsDir = CONFIG_STRING_DEFAULTED(config, "purple.cacerts_dir", "./ca-certs");
 	LOG4CXX_INFO(logger, "Setting libpurple cacerts directory to: " << cacertsDir);
 	purple_certificate_add_ca_search_path_wrapped(cacertsDir.c_str());
 	std::string userDir = CONFIG_STRING_DEFAULTED(config, "service.working_dir", "./");
 	LOG4CXX_INFO(logger, "Setting libpurple user directory to: " << userDir);
 	purple_util_set_user_dir_wrapped(userDir.c_str());
 	remove("./accounts.xml");
 	remove("./blist.xml");
 	purple_debug_set_ui_ops_wrapped(&debugUiOps);
 // 	purple_debug_set_verbose_wrapped(true);
 	purple_core_set_ui_ops_wrapped(&coreUiOps);
 	if (CONFIG_STRING_DEFAULTED(config, "service.eventloop", "") == "libev") {
@@ @@ -2187,25 +2187,25 @@ static bool initPurple() { @@
 // 		purple_signal_connect_wrapped(purple_blist_get_handle_wrapped(), "buddy-removed", &blist_handle,PURPLE_CALLBACK(buddyRemoved), NULL);
 // 		purple_signal_connect_wrapped(purple_blist_get_handle_wrapped(), "buddy-signed-on", &blist_handle,PURPLE_CALLBACK(buddySignedOn), NULL);
 // 		purple_signal_connect_wrapped(purple_blist_get_handle_wrapped(), "buddy-signed-off", &blist_handle,PURPLE_CALLBACK(buddySignedOff), NULL);
 // 		purple_signal_connect_wrapped(purple_blist_get_handle_wrapped(), "buddy-status-changed", &blist_handle,PURPLE_CALLBACK(buddyStatusChanged), NULL);
 		purple_signal_connect_wrapped(purple_blist_get_handle_wrapped(), "blist-node-removed", &blist_handle,PURPLE_CALLBACK(NodeRemoved), NULL);
 		purple_signal_connect_wrapped(purple_conversations_get_handle_wrapped(), "chat-topic-changed", &conversation_handle, PURPLE_CALLBACK(conv_chat_topic_changed), NULL);
 		static int xfer_handle;
 		purple_signal_connect_wrapped(purple_xfers_get_handle_wrapped(), "file-send-start", &xfer_handle, PURPLE_CALLBACK(fileSendStart), NULL);
 		purple_signal_connect_wrapped(purple_xfers_get_handle_wrapped(), "file-recv-start", &xfer_handle, PURPLE_CALLBACK(fileRecvStart), NULL);
 		purple_signal_connect_wrapped(purple_xfers_get_handle_wrapped(), "file-recv-request", &xfer_handle, PURPLE_CALLBACK(newXfer), NULL);
 		purple_signal_connect_wrapped(purple_xfers_get_handle_wrapped(), "file-recv-complete", &xfer_handle, PURPLE_CALLBACK(XferReceiveComplete), NULL);
 		purple_signal_connect_wrapped(purple_xfers_get_handle_wrapped(), "file-send-complete", &xfer_handle, PURPLE_CALLBACK(XferSendComplete), NULL);
-//
 //
 // 		purple_commands_init();
+	}
 	return ret;
+}
 static void transportDataReceived(gpointer data, gint source, PurpleInputCondition cond) {
 	if (cond & PURPLE_INPUT_READ) {
 		char buffer[65535];
 		char *ptr = buffer;
 #ifdef WIN32
 #endif
 		if (n <= 0) {
 			if (errno == EAGAIN) {
 				return;
+			}
 			LOG4CXX_INFO(logger, "Diconnecting from spectrum2 server");
 			exit(errno);
+		}
 		std::string d = std::string(buffer, n);
 		if (firstPing) {
 			firstPing = false;
-			NetworkPlugin::PluginConfig cfg;
 			NetworkPlugin::PluginConfig cfg;
 			cfg.setSupportMUC(true);
 			if (CONFIG_STRING(config, "service.protocol") == "prpl-telegram") {
 				cfg.setNeedPassword(false);
+			}
 			if (CONFIG_STRING(config, "service.protocol") == "prpl-hangouts") {
 				cfg.setNeedPassword(false);
+			}
 			if (CONFIG_BOOL(config, "service.server_mode") || CONFIG_STRING(config, "service.protocol") == "prpl-irc") {
 				cfg.setNeedRegistration(false);
+			}
 			else {
 				cfg.setNeedRegistration(true);
@@ @@ -2268,45 +2268,45 @@ int main(int argc, char **argv) { @@
 			return -1;
+		}
 #endif
 	std::string error;
 	Config *cfg = Config::createFromArgs(argc, argv, error, host, port);
 	if (cfg == NULL) {
 		std::cerr << error;
 		return 1;
+	}
 	config = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Config>(cfg);
 	Logging::initBackendLogging(config.get());
 	if (CONFIG_STRING(config, "service.protocol") == "prpl-hangouts") {
 		storagebackend = StorageBackend::createBackend(config.get(), error);
 		if (storagebackend == NULL) {
 			LOG4CXX_ERROR(logger, "Error creating StorageBackend! " << error);
 			LOG4CXX_ERROR(logger, "Hangouts backend needs storage backend configured to work! " << error);
 			return NetworkPlugin::StorageBackendNeeded;
+		}
 		else if (!storagebackend->connect()) {
 			LOG4CXX_ERROR(logger, "Can't connect to database!")
 				return -1;
 			LOG4CXX_ERROR(logger, "Can't connect to database!");
 			return -1;
+		}
+	}
 	initPurple();
 	main_socket = create_socket(host.c_str(), port);
 	purple_input_add_wrapped(main_socket, PURPLE_INPUT_READ, &transportDataReceived, NULL);
 	purple_timeout_add_seconds_wrapped(30, pingTimeout, NULL);
 	np = new SpectrumNetworkPlugin();
 	bool libev = CONFIG_STRING_DEFAULTED(config, "service.eventloop", "") == "libev";
 	GMainLoop *m_loop;
 #ifdef WITH_LIBEVENT
 	if (!libev) {
 		m_loop = g_main_loop_new(NULL, FALSE);
+	}
 	else {
 		event_init();
+	}
 #endif

backends/smstools3/main.cpp

➞

Show inline comments

@@ @@ -73,25 +73,25 @@ class SMSNetworkPlugin : public NetworkPlugin { @@
 			// Alias = XMPP user JID to which the messages from this number is sent to.
 			// TODO: This should be per Modem!!!
 			UserInfo info;
 			info.jid = INTERNAL_USER;
 			info.password = "";
 			storageBackend->setUser(info);
 			storageBackend->getUser(INTERNAL_USER, info);
 			m_internalUser = info.id;
+		}
 		void handleSMS(const std::string &sms) {
 			LOG4CXX_INFO(logger, "Handling SMS " << sms << ".")
+			LOG4CXX_INFO(logger, "Handling SMS " << sms << ".");
 			std::ifstream t(sms.c_str());
 			std::string str;
 			t.seekg(0, std::ios::end);
 			str.reserve(t.tellg());
 			t.seekg(0, std::ios::beg);
 			str.assign((std::istreambuf_iterator<char>(t)), std::istreambuf_iterator<char>());
 			std::string from = "";
 			std::string msg = "";
 			while(str.find("\n") != std::string::npos) {
@@ @@ -140,25 +140,25 @@ class SMSNetworkPlugin : public NetworkPlugin { @@
 						handleSMS(itr->path().string());
 						remove(itr->path());
+					}
+				}
 				catch (const filesystem_error& ex) {
 					LOG4CXX_ERROR(logger, "Error when removing the SMS: " << ex.what() << ".");
+				}
+			}
 			m_timer->start();
+		}
 		void sendSMS(const std::string &to, const std::string &msg) {
-			// TODO: Probably
 			// TODO: Probably
 			std::string data = "To: " + to + "\n";
 			data += "\n";
 			data += msg;
 			// generate random string here...
 			std::string bucket = "abcdefghijklmnopqrstuvwxyz";
 			std::string uuid;
 			for (int i = 0; i < 10; i++) {
 				uuid += bucket[rand() % bucket.size()];
+			}
 			std::ofstream myfile;
 			myfile.open (std::string("/var/spool/sms/outgoing/spectrum." + uuid).c_str());
@@ @@ -223,25 +223,25 @@ class SMSNetworkPlugin : public NetworkPlugin { @@
 		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups) {
 			LOG4CXX_INFO(logger, user << ": Added buddy " << buddyName << ".");
 			handleBuddyChanged(user, buddyName, alias, groups, pbnetwork::STATUS_ONLINE);
+		}
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups) {
+		}
 	private:
 		Config *config;
 };
 static void spectrum_sigchld_handler(int sig)
+{
 	int status;
 	pid_t pid;
 	do {
 		pid = waitpid(-1, &status, WNOHANG);
 	} while (pid != 0 && pid != (pid_t)-1);

backends/swiften/main.cpp

➞

Show inline comments

@@ @@ -60,34 +60,34 @@ class ForwardIQHandler : public Swift::IQHandler { @@
 				m_id2resource[iq->getID()] = iq->getFrom().getResource();
+			}
 			iq->setTo(m_user);
 			std::string xml = safeByteArrayToString(serializer->serializeElement(iq));
 			m_np->sendRawXML(xml);
 			return true;
+		}
 	private:
 		NetworkPlugin *m_np;
 		std::string m_user;
 };
 class SwiftenPlugin : public NetworkPlugin, Swift::XMPPParserClient {
 	public:
 		Swift::BoostNetworkFactories *m_factories;
 		Swift::BoostIOServiceThread m_boostIOServiceThread;
 		SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Connection> m_conn;
 		bool m_firstPing;
 		Swift::FullPayloadSerializerCollection collection;
 		Swift::XMPPParser *m_xmppParser;
 		Swift::FullPayloadParserFactoryCollection m_collection2;
 		SwiftenPlugin(Config *config, Swift::SimpleEventLoop *loop, const std::string &host, int port) : NetworkPlugin() {
 			this->config = config;
 			m_firstPing = true;
 			m_factories = new Swift::BoostNetworkFactories(loop);
 			m_conn = m_factories->getConnectionFactory()->createConnection();
 			m_conn->onDataRead.connect(boost::bind(&SwiftenPlugin::_handleDataRead, this, _1));
 			m_conn->connect(Swift::HostAddressPort(SWIFT_HOSTADDRESS(host), port));
 #if HAVE_SWIFTEN_3
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Presence> presence = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Swift::Presence>(stanza);
 			if (presence) {
 				client->sendPresence(presence);
 				return;
+			}
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::IQ> iq = SWIFTEN_SHRPTR_NAMESPACE::dynamic_pointer_cast<Swift::IQ>(stanza);
 			if (iq) {
 				if (m_handlers[user]->m_id2resource.find(stanza->getID()) != m_handlers[user]->m_id2resource.end()) {
 					std::string resource = m_handlers[user]->m_id2resource[stanza->getID()];
 					if (resource.empty()) {
-						iq->setTo(Swift::JID(iq->getTo().getNode(), iq->getTo().getDomain()));
 						iq->setTo(Swift::JID(iq->getTo().getNode(), iq->getTo().getDomain()));
 					} else {
-						iq->setTo(Swift::JID(iq->getTo().getNode(), iq->getTo().getDomain(), resource));
 						iq->setTo(Swift::JID(iq->getTo().getNode(), iq->getTo().getDomain(), resource));
+					}
 					m_handlers[user]->m_id2resource.erase(stanza->getID());
+				}
 				client->getIQRouter()->sendIQ(iq);
 				return;
+			}
+		}
 		void handleStreamEnd() {}
 		void handleRawXML(const std::string &xml) {
 			m_xmppParser->parse(xml);
+		}
 			m_users[user]->requestRoster();
 			Swift::Presence::ref response = Swift::Presence::create();
 			response->setFrom(m_users[user]->getJID());
 			m_users[user]->sendPresence(response);
+		}
 		void handleSwiftRosterReceived(const std::string &user) {
 			Swift::PresenceOracle *oracle = m_users[user]->getPresenceOracle();
 			BOOST_FOREACH(const Swift::XMPPRosterItem &item, m_users[user]->getRoster()->getItems()) {
 				Swift::Presence::ref lastPresence = oracle->getLastPresence(item.getJID());
 				pbnetwork::StatusType status = lastPresence ? ((pbnetwork::StatusType) lastPresence->getShow()) : pbnetwork::STATUS_NONE;
 				handleBuddyChanged(user, item.getJID().toBare().toString(),
-								   item.getName(), item.getGroups(), status);
 					item.getName(), item.getGroups(), status);
+			}
+		}
 		void handleSwiftPresenceChanged(const std::string &user, Swift::Presence::ref presence) {
 // 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Client> client = m_users[user];
 // 			if (client->getMUCRegistry()->isMUC(presence->getFrom().toBare())) {
 // 				return;
 // 			}
 //
 // 			if (presence->getPayload<Swift::MUCUserPayload>() != NULL || presence->getPayload<Swift::MUCPayload>() != NULL) {
 // 				return;
 // 			}
 //
 // 			LOG4CXX_INFO(logger, user << ": " << presence->getFrom().toBare().toString() << " presence changed");
 //
 // 			std::string message = presence->getStatus();
 // 			std::string photo = "";
 //
 // 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCardUpdate> update = presence->getPayload<Swift::VCardUpdate>();
 // 			if (update) {
 // 				photo = update->getPhotoHash();
 // 			}
 //
 // 			boost::optional<Swift::XMPPRosterItem> item = m_users[user]->getRoster()->getItem(presence->getFrom());
 // 			if (item) {
 // 				handleBuddyChanged(user, presence->getFrom().toBare().toString(), item->getName(), item->getGroups(), (pbnetwork::StatusType) presence->getShow(), message, photo);
 // 			}
 // 			else {
 // 				std::vector<std::string> groups;
 // 				handleBuddyChanged(user, presence->getFrom().toBare().toString(), presence->getFrom().toBare(), groups, (pbnetwork::StatusType) presence->getShow(), message, photo);
 // 			}
 //			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Client> client = m_users[user];
 //			if (client->getMUCRegistry()->isMUC(presence->getFrom().toBare())) {
 //				return;
 //			}
 //
 //			if (presence->getPayload<Swift::MUCUserPayload>() != NULL || presence->getPayload<Swift::MUCPayload>() != NULL) {
 //				return;
 //			}
 //
 //			LOG4CXX_INFO(logger, user << ": " << presence->getFrom().toBare().toString() << " presence changed");
 //
 //			std::string message = presence->getStatus();
 //			std::string photo = "";
 //
 //			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCardUpdate> update = presence->getPayload<Swift::VCardUpdate>();
 //			if (update) {
 //				photo = update->getPhotoHash();
 //			}
 //
 //			boost::optional<Swift::XMPPRosterItem> item = m_users[user]->getRoster()->getItem(presence->getFrom());
 //			if (item) {
 //				handleBuddyChanged(user, presence->getFrom().toBare().toString(), item->getName(), item->getGroups(), (pbnetwork::StatusType) presence->getShow(), message, photo);
 //			}
 //			else {
 //				std::vector<std::string> groups;
 //				handleBuddyChanged(user, presence->getFrom().toBare().toString(), presence->getFrom().toBare(), groups, (pbnetwork::StatusType) presence->getShow(), message, photo);
 //			}
 			presence->setTo(user);
 			std::string xml = safeByteArrayToString(serializer->serializeElement(presence));
 			sendRawXML(xml);
+		}
 		void handleSwiftMessageReceived(const std::string &user, Swift::Message::ref message) {
 			message->setTo(user);
 			std::string xml = safeByteArrayToString(serializer->serializeElement(message));
 			sendRawXML(xml);
+		}
 		void handleSwiftenDataRead(const Swift::SafeByteArray &data) {
 		void handleSubscriptionRevoked(const std::string &user, const Swift::JID& jid, const std::string& message) {
 			Swift::Presence::ref presence = Swift::Presence::create();
 			presence->setTo(user);
 			presence->setFrom(jid);
 			presence->setType(Swift::Presence::Unsubscribe);
 			handleSwiftPresenceChanged(user, presence);
+		}
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				client->onConnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftConnected, this, user));
-// 				client->onDisconnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftDisconnected, this, user, _1));
 //				client->onDisconnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftDisconnected, this, user, _1));
 				client->onMessageReceived.disconnect(boost::bind(&SwiftenPlugin::handleSwiftMessageReceived, this, user, _1));
 				client->getRoster()->onInitialRosterPopulated.disconnect(boost::bind(&SwiftenPlugin::handleSwiftRosterReceived, this, user));
 				client->getPresenceOracle()->onPresenceChange.disconnect(boost::bind(&SwiftenPlugin::handleSwiftPresenceChanged, this, user, _1));
 				client->disconnect();
+			}
+		}
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &msg, const std::string &xhtml = "", const std::string &id = "") {
+		}
 		void handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id) {
+		}
 		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups) {
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				LOG4CXX_INFO(logger, user << ": Added/Updated buddy " << buddyName << ".");
 				if (!client->getRoster()->containsJID(buddyName) || client->getRoster()->getSubscriptionStateForJID(buddyName) != Swift::RosterItemPayload::Both) {
 					Swift::RosterItemPayload item;
 					item.setName(alias);
 					item.setJID(buddyName);
 					item.setGroups(groups);
 					SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::RosterPayload> roster(new Swift::RosterPayload());
 					roster->addItem(item);
 					Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(roster, client->getIQRouter());
-// 					request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));
 //					request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));
 					request->send();
 					client->getSubscriptionManager()->requestSubscription(buddyName);
+				}
 				else {
 					Swift::JID contact(buddyName);
 					Swift::RosterItemPayload item(contact, alias, client->getRoster()->getSubscriptionStateForJID(contact));
 					item.setGroups(groups);
 					SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::RosterPayload> roster(new Swift::RosterPayload());
 					roster->addItem(item);
 					Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(roster, client->getIQRouter());
-// 					request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));
 //					request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));
 					request->send();
+				}
+			}
+		}
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups) {
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Client> client = m_users[user];
 			if (client) {
 				Swift::RosterItemPayload item(buddyName, "", Swift::RosterItemPayload::Remove);
 				SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::RosterPayload> roster(new Swift::RosterPayload());
 				roster->addItem(item);
 				Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(roster, client->getIQRouter());
-// 				request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));
 //				request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));
 				request->send();
+			}
+		}
 		void handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &password) {
+		}
 		void handleLeaveRoomRequest(const std::string &user, const std::string &room) {
+		}

backends/twitter/HTTPRequest.cpp

➞

Show inline comments

@@ @@ -2,71 +2,71 @@ @@
 DEFINE_LOGGER(logger, "HTTPRequest")
 bool HTTPRequest::init()
+{
 	curlhandle = curl_easy_init();
 	if(curlhandle) {
 		curlhandle = curl_easy_init();
 		curl_easy_setopt(curlhandle, CURLOPT_PROXY, NULL);
 		curl_easy_setopt(curlhandle, CURLOPT_PROXYUSERPWD, NULL);
 		curl_easy_setopt(curlhandle, CURLOPT_PROXYAUTH, (long)CURLAUTH_ANY);
 		return true;
+	}
 	LOG4CXX_ERROR(logger, "Couldn't Initialize curl!")
+	LOG4CXX_ERROR(logger, "Couldn't Initialize curl!");
 	return false;
+}
 void HTTPRequest::setProxy(std::string IP, std::string port, std::string username, std::string password)
+{
 	if(curlhandle) {
 		std::string proxyIpPort = IP + ":" + port;
 		curl_easy_setopt(curlhandle, CURLOPT_PROXY, proxyIpPort.c_str());
 		if(username.length() && password.length()) {
 			std::string proxyUserPass = username + ":" + password;
 			curl_easy_setopt(curlhandle, CURLOPT_PROXYUSERPWD, proxyUserPass.c_str());
+		}
 	} else {
 		LOG4CXX_ERROR(logger, "Trying to set proxy while CURL isn't initialized")
+		LOG4CXX_ERROR(logger, "Trying to set proxy while CURL isn't initialized");
+	}
+}
 int HTTPRequest::curlCallBack(char* data, size_t size, size_t nmemb, HTTPRequest* obj)
+{
     int writtenSize = 0;
     if(obj && data) {
        obj->callbackdata.append(data, size*nmemb);
 	   writtenSize = (int)(size*nmemb);
+    }
     return writtenSize;
 	int writtenSize = 0;
 	if(obj && data) {
 		obj->callbackdata.append(data, size*nmemb);
 		writtenSize = (int)(size*nmemb);
+	}
 	return writtenSize;
+}
-bool HTTPRequest::GET(std::string url, 	std::string &data)
 bool HTTPRequest::GET(std::string url, std::string &data)
+{
 	if(curlhandle) {
 		curl_easy_setopt(curlhandle, CURLOPT_CUSTOMREQUEST, NULL);
 		curl_easy_setopt(curlhandle, CURLOPT_ENCODING, "");
 		data = "";
 		callbackdata = "";
 		memset(curl_errorbuffer, 0, 1024);
 		curl_easy_setopt(curlhandle, CURLOPT_ERRORBUFFER, curl_errorbuffer);
 		curl_easy_setopt(curlhandle, CURLOPT_WRITEFUNCTION, curlCallBack);
 		curl_easy_setopt(curlhandle, CURLOPT_WRITEDATA, this);
 		/* Set http request and url */
 		curl_easy_setopt(curlhandle, CURLOPT_HTTPGET, 1);
-// 		curl_easy_setopt(curlhandle, CURLOPT_VERBOSE, 1);
 //		curl_easy_setopt(curlhandle, CURLOPT_VERBOSE, 1);
 		curl_easy_setopt(curlhandle, CURLOPT_URL, url.c_str());
 		/* Send http request and return status*/
 		if(CURLE_OK == curl_easy_perform(curlhandle)) {
 			data = callbackdata;
 			return true;
+		}
 	} else {
 		LOG4CXX_ERROR(logger, "CURL not initialized!")
+		LOG4CXX_ERROR(logger, "CURL not initialized!");
 		strcpy(curl_errorbuffer, "CURL not initialized!");
+	}
 	return false;
+}

backends/twitter/Requests/CreateFriendRequest.cpp

➞

Show inline comments

 #include "CreateFriendRequest.h"
 #include "../HTTPRequest.h"
 DEFINE_LOGGER(logger, "CreateFriendRequest")
 void CreateFriendRequest::run()
+{
 	LOG4CXX_INFO(logger, user << " - Sending follow request for " << frnd)
+	LOG4CXX_INFO(logger, user << " - Sending follow request for " << frnd);
 	replyMsg = "";
 	success = twitObj->friendshipCreate(frnd, false);
 	if(success) {
 		twitObj->getLastWebResponse(replyMsg);
-		LOG4CXX_INFO(logger, user << replyMsg)
+		LOG4CXX_INFO(logger, user << replyMsg);
 	   	friendInfo = getUser(replyMsg);
 		if(friendInfo.getScreenName() == "") {LOG4CXX_INFO(logger, user << " - Was unable to fetch user info for " << frnd)}
 		if(friendInfo.getScreenName() == "") LOG4CXX_INFO(logger, user << " - Was unable to fetch user info for " << frnd);
 		HTTPRequest req;
 		std::string img;
 		req.init();
 		req.setProxy(twitObj->getProxyServerIp(), twitObj->getProxyServerPort(), twitObj->getProxyUserName(), twitObj->getProxyPassword());
 		profileImg = "";
 		if(req.GET(friendInfo.getProfileImgURL(), img)) profileImg = img;
 		else {
 			LOG4CXX_INFO(logger, user << " - Was unable to fetch profile image of user " << frnd);
+		}
+	}
+}
 void CreateFriendRequest::finalize()
+{
 	Error error;
 	if(!success) {
 		std::string curlerror;
 		twitObj->getLastCurlError(curlerror);
 		error.setMessage(curlerror);
 		LOG4CXX_ERROR(logger, user << " - Curl error: " << curlerror)
 		error.setMessage(curlerror);
 		LOG4CXX_ERROR(logger, user << " - Curl error: " << curlerror);
 		callBack(user, friendInfo, profileImg, error);
 	} else {
 		error = getErrorMessage(replyMsg);
 		if(error.getMessage().length()) {
 			LOG4CXX_ERROR(logger, user << " - " << error.getMessage())
+			LOG4CXX_ERROR(logger, user << " - " << error.getMessage());
+		}
 		else LOG4CXX_INFO(logger, user << ": Now following " << frnd)
+		else LOG4CXX_INFO(logger, user << ": Now following " << frnd);
 		callBack(user, friendInfo, profileImg, error);
+	}
+}

backends/twitter/Requests/DestroyFriendRequest.cpp

➞

Show inline comments

 #include "DestroyFriendRequest.h"
 DEFINE_LOGGER(logger, "DestroyFriendRequest")
 void DestroyFriendRequest::run()
+{
 	replyMsg = "";
 	success = twitObj->friendshipDestroy(frnd, false);
 	if(success) {
 		twitObj->getLastWebResponse(replyMsg);
 		LOG4CXX_INFO(logger, user << replyMsg)
 		LOG4CXX_INFO(logger, user << replyMsg);
 	   	friendInfo = getUser(replyMsg);
 		if(friendInfo.getScreenName() == "") LOG4CXX_INFO(logger, user << " - Was unable to fetch user info for " << frnd);
+	}
+}
 void DestroyFriendRequest::finalize()
+{
 	Error error;
 	if(!success) {
 		std::string curlerror;
 		twitObj->getLastCurlError(curlerror);
 		error.setMessage(curlerror);
 		LOG4CXX_ERROR(logger, user << " Curl error: " << curlerror)
 		error.setMessage(curlerror);
 		LOG4CXX_ERROR(logger, user << " Curl error: " << curlerror);
 		callBack(user, friendInfo, error);
 	} else {
 		error = getErrorMessage(replyMsg);
 		if(error.getMessage().length()) LOG4CXX_ERROR(logger, user << " - " << error.getMessage())
+		if(error.getMessage().length()) LOG4CXX_ERROR(logger, user << " - " << error.getMessage());
 		callBack(user, friendInfo, error);
+	}
+}

backends/twitter/Requests/DirectMessageRequest.cpp

➞

Show inline comments

 #include "DirectMessageRequest.h"
 DEFINE_LOGGER(logger, "DirectMessageRequest")
-void DirectMessageRequest::run()
 void DirectMessageRequest::run()
+{
 	replyMsg = "";
 	if(username != "") success = twitObj->directMessageSend(username, data, false);
 	else success = twitObj->directMessageGet(data); /* data will contain sinceId */
 	if(success) {
 		twitObj->getLastWebResponse( replyMsg );
 		if(username == "" ) messages = getDirectMessages( replyMsg );
+	}
+}
 void DirectMessageRequest::finalize()
+{
 	Error error;
 	if(!success) {
 		std::string curlerror;
 		twitObj->getLastCurlError(curlerror);
-		error.setMessage(curlerror);
 		error.setMessage(curlerror);
 		LOG4CXX_ERROR(logger, user << " Curl error: " << curlerror);
 		callBack(user, username, messages, error);
 	} else {
 		error = getErrorMessage(replyMsg);
 		if(error.getMessage().length()) LOG4CXX_ERROR(logger,  user << " - " << error.getMessage())
 		else LOG4CXX_INFO(logger, user << " - " << replyMsg)
 		callBack(user, username, messages, error);
 		if(error.getMessage().length()) {
 			LOG4CXX_ERROR(logger,  user << " - " << error.getMessage());
 		} else {
 			LOG4CXX_INFO(logger, user << " - " << replyMsg);
+		}
 		callBack(user, username, messages, error);
+	}
+}

backends/twitter/Requests/FetchFriends.cpp

➞

Show inline comments

 #include "FetchFriends.h"
 #include "../HTTPRequest.h"
 DEFINE_LOGGER(logger, "FetchFriends")
 void FetchFriends::run()
+{
 	replyMsg = "";
 void FetchFriends::run()
+{
 	replyMsg = "";
 	std::string next = "";
 	success = twitObj->friendsIdsGet(next, twitObj->getTwitterUsername(), false);
-	if(!success) return;
 	if(!success) return;
 	twitObj->getLastWebResponse( replyMsg );
 	std::vector<std::string> IDs = getIDs( replyMsg );
 	success = twitObj->userLookup(IDs, true);
 	if(!success) return;
 	twitObj->getLastWebResponse( replyMsg );
 	friends = getUsers( replyMsg );
 	HTTPRequest req;
 	req.init();
 	req.setProxy(twitObj->getProxyServerIp(), twitObj->getProxyServerPort(), twitObj->getProxyUserName(), twitObj->getProxyPassword());
 	for(int i=0 ; i<friends.size() ; i++) {
 		std::string img;
 		friendAvatars.push_back("");
 		if(req.GET(friends[i].getProfileImgURL(), img)) friendAvatars[i] = img;
 		else {
 			LOG4CXX_INFO(logger, "Warning: Couldn't fetch Profile Image for " << user << "'s friend " << friends[i].getScreenName())
+			LOG4CXX_INFO(logger, "Warning: Couldn't fetch Profile Image for " << user << "'s friend " << friends[i].getScreenName());
+		}
+	}
+}
 void FetchFriends::finalize()
+{
 	Error error;
 	if(!success) {
 		std::string curlerror;
 		twitObj->getLastCurlError(curlerror);
 		error.setMessage(curlerror);
 		LOG4CXX_ERROR(logger,  user << " - " << curlerror)
 		error.setMessage(curlerror);
 		LOG4CXX_ERROR(logger,  user << " - " << curlerror);
 		callBack(user, friends, friendAvatars, error);
 	} else {
 		error = getErrorMessage(replyMsg);
 		if(error.getMessage().length()) LOG4CXX_ERROR(logger,  user << " - " << error.getMessage())
 		callBack(user, friends, friendAvatars, error);
+	}
 		if(error.getMessage().length()) LOG4CXX_ERROR(logger,  user << " - " << error.getMessage());
 		callBack(user, friends, friendAvatars, error);
+	}
+}

backends/twitter/Requests/PINExchangeProcess.cpp

➞

Show inline comments

 #include "PINExchangeProcess.h"
 DEFINE_LOGGER(logger, "PINExchangeProcess")
 void PINExchangeProcess::run()
+{
 	LOG4CXX_INFO(logger, user << ": Sending PIN " << data)
 	LOG4CXX_INFO(logger, user << " " << twitObj->getProxyServerIp() << " " << twitObj->getProxyServerPort())
 	LOG4CXX_INFO(logger, user << ": Sending PIN " << data);
 	LOG4CXX_INFO(logger, user << " " << twitObj->getProxyServerIp() << " " << twitObj->getProxyServerPort());
 	twitObj->getOAuth().setOAuthPin( data );
 	success = twitObj->oAuthAccessToken();
+}
 void PINExchangeProcess::finalize()
+{
 	if(!success) {
 		LOG4CXX_ERROR(logger, user << ": Error while exchanging PIN for Access Token!")
+		LOG4CXX_ERROR(logger, user << ": Error while exchanging PIN for Access Token!");
 		np->handleMessage(user, "twitter.com", "Error while exchanging PIN for Access Token!");
 		np->handleLogoutRequest(user, "");
 	} else {
 		std::string replyMsg;
 		while(replyMsg.length() == 0) {
 			twitObj->getLastWebResponse(replyMsg);
+		}
 		Error error = getErrorMessage(replyMsg);
 		if(error.getMessage().length()) {
 			LOG4CXX_ERROR(logger, user << ": Error while exchanging PIN for Access Token! " << error.getMessage())
+			LOG4CXX_ERROR(logger, user << ": Error while exchanging PIN for Access Token! " << error.getMessage());
 			np->handleMessage(user, "twitter.com", error.getMessage());
 			np->handleLogoutRequest(user, "");
 			return;
+		}
 		std::string OAuthAccessTokenKey, OAuthAccessTokenSecret;
 		twitObj->getOAuth().getOAuthTokenKey( OAuthAccessTokenKey );
 		twitObj->getOAuth().getOAuthTokenSecret( OAuthAccessTokenSecret );
 		if(np->storeUserOAuthKeyAndSecret(user, OAuthAccessTokenKey, OAuthAccessTokenSecret) == false) {
 			np->handleLogoutRequest(user, "");
 			return;
+		}
 		np->pinExchangeComplete(user, OAuthAccessTokenKey, OAuthAccessTokenSecret);
 		np->handleMessage(user, "twitter.com", "PIN is OK. You are now authorized.");
 		np->handleMessage(user, "twitter.com", "Send '#help' (without the quotes) to see how to use this transport.");
 		LOG4CXX_INFO(logger, user << ": Sent PIN " << data << " and obtained Access Token");
+	}
+}
 /*void handlePINExchange(const std::string &user, std::string &data) {
 	sessions[user]->getOAuth().setOAuthPin( data );
 	if (sessions[user]->oAuthAccessToken() == false) {
 		LOG4CXX_ERROR(logger, user << ": Error while exchanging PIN for Access Token!")
+		LOG4CXX_ERROR(logger, user << ": Error while exchanging PIN for Access Token!");
 		handleLogoutRequest(user, "");
 		return;
+	}
 	std::string OAuthAccessTokenKey, OAuthAccessTokenSecret;
 	sessions[user]->getOAuth().getOAuthTokenKey( OAuthAccessTokenKey );
 	sessions[user]->getOAuth().getOAuthTokenSecret( OAuthAccessTokenSecret );
 	UserInfo info;
 	if(storagebackend->getUser(user, info) == false) {
 		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
+		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!");
 		handleLogoutRequest(user, "");
 		return;
+	}
 	storagebackend->updateUserSetting((long)info.id, OAUTH_KEY, OAuthAccessTokenKey);
 	storagebackend->updateUserSetting((long)info.id, OAUTH_SECRET, OAuthAccessTokenSecret);
 	storagebackend->updateUserSetting((long)info.id, OAUTH_KEY, OAuthAccessTokenKey);
 	storagebackend->updateUserSetting((long)info.id, OAUTH_SECRET, OAuthAccessTokenSecret);
 	connectionState[user] = CONNECTED;
 	LOG4CXX_INFO(logger, user << ": Sent PIN " << data << " and obtained Access Token");
 }*/

backends/twitter/Requests/ProfileImageRequest.cpp

➞

Show inline comments

 #include "ProfileImageRequest.h"
 #include "../HTTPRequest.h"
 DEFINE_LOGGER(logger, "ProfileImageRequest")
 void ProfileImageRequest::run()
+{
 void ProfileImageRequest::run()
+{
 	HTTPRequest req;
 	req.init();
 	req.setProxy(ip, port, puser, ppasswd);
 	success = req.GET(url, callbackdata);
 	if(!success) error.assign(req.getCurlError());
+}
 void ProfileImageRequest::finalize()
+{
 	Error errResponse;
 	if(!success) {
 		LOG4CXX_ERROR(logger,  user << " - " << error)
+		LOG4CXX_ERROR(logger,  user << " - " << error);
 		img = "";
 		errResponse.setMessage(error);
 		callBack(user, buddy, img, reqID, errResponse);
 	} else {
 		LOG4CXX_INFO(logger, user << " - " << callbackdata);
 		img = callbackdata;
 		callBack(user, buddy, img, reqID, errResponse);
+	}
 		callBack(user, buddy, img, reqID, errResponse);
+	}
+}

backends/twitter/Requests/RetweetRequest.cpp

➞

Show inline comments

 #include "RetweetRequest.h"
 DEFINE_LOGGER(logger, "RetweetRequest")
 void RetweetRequest::run()
+{
 	LOG4CXX_INFO(logger, user << " Retweeting " << data)
+	LOG4CXX_INFO(logger, user << " Retweeting " << data);
 	success = twitObj->retweetById( data );
+}
 void RetweetRequest::finalize()
+{
 	Error error;
 	if(!success) {
 		std::string curlerror;
 		twitObj->getLastCurlError(curlerror);
 		error.setMessage(curlerror);
 		LOG4CXX_ERROR(logger, user << " Curl error: " << curlerror)
 		error.setMessage(curlerror);
 		LOG4CXX_ERROR(logger, user << " Curl error: " << curlerror);
 		callBack(user, error);
 	} else {
 		twitObj->getLastWebResponse(replyMsg);
 		error = getErrorMessage(replyMsg);
 		if(error.getMessage().length()) LOG4CXX_ERROR(logger, user << " - " << error.getMessage())
 		else LOG4CXX_INFO(logger, user << " " << replyMsg);
 		if(error.getMessage().length()) {
 			LOG4CXX_ERROR(logger, user << " - " << error.getMessage());
 		} else {
 			LOG4CXX_INFO(logger, user << " " << replyMsg);
+		}
 		callBack(user, error);
+	}
+}

backends/twitter/Requests/StatusUpdateRequest.cpp

➞

Show inline comments

 #include "StatusUpdateRequest.h"
 #include "../TwitterResponseParser.h"
 DEFINE_LOGGER(logger, "StatusUpdateRequest")
-void StatusUpdateRequest::run()
 void StatusUpdateRequest::run()
+{
 	replyMsg = "";
 	success = twitObj->statusUpdate(data);
 	if(success) {
 		twitObj->getLastWebResponse( replyMsg );
 		LOG4CXX_INFO(logger, user << "StatusUpdateRequest response " << replyMsg );
+	}
+}
 void StatusUpdateRequest::finalize()
+{
 	Error error;
 	if(!success) {
 		std::string curlerror;
 		twitObj->getLastCurlError(curlerror);
-		error.setMessage(curlerror);
 		error.setMessage(curlerror);
 		LOG4CXX_ERROR(logger, user << " - Curl error: " << curlerror);
 		callBack(user, error);
 	} else {
 		error = getErrorMessage(replyMsg);
 		if(error.getMessage().length()) LOG4CXX_ERROR(logger, user << " - " << error.getMessage())
 		else LOG4CXX_INFO(logger, "Updated status for " << user << ": " << data);
 		if(error.getMessage().length()) {
 			LOG4CXX_ERROR(logger, user << " - " << error.getMessage());
 		} else {
 			LOG4CXX_INFO(logger, "Updated status for " << user << ": " << data);
+		}
 		callBack(user, error);
+	}
+}

backends/twitter/Requests/TimelineRequest.cpp

➞

Show inline comments

 #include "TimelineRequest.h"
 DEFINE_LOGGER(logger, "TimelineRequest")
 void TimelineRequest::run()
+{
 	LOG4CXX_INFO(logger, "Sending timeline request for user " << userRequested)
+{
 	LOG4CXX_INFO(logger, "Sending timeline request for user " << userRequested);
 	if(userRequested != "") success = twitObj->timelineUserGet(false, false, 20, userRequested, false);
 	else success = twitObj->timelineHomeGet(since_id);
 	if(!success) return;
 	replyMsg = "";
 	replyMsg = "";
 	twitObj->getLastWebResponse( replyMsg );
 	//LOG4CXX_INFO(logger, user << " - " << replyMsg.length() << " " << replyMsg << "\n" );
 	tweets = getTimeline(replyMsg);
+}
 void TimelineRequest::finalize()
+{
 	Error error;
 	if(!success) {
 		std::string curlerror;
 		twitObj->getLastCurlError(curlerror);
 		error.setMessage(curlerror);
 		LOG4CXX_ERROR(logger,  user << " - Curl error: " << curlerror)
 		error.setMessage(curlerror);
 		LOG4CXX_ERROR(logger,  user << " - Curl error: " << curlerror);
 		callBack(user, userRequested, tweets, error);
 	} else {
 		error = getErrorMessage(replyMsg);
 		if(error.getMessage().length()) LOG4CXX_ERROR(logger,  user << " - " << error.getMessage())
+		if(error.getMessage().length()) LOG4CXX_ERROR(logger,  user << " - " << error.getMessage());
 		callBack(user, userRequested, tweets, error);
+	}
+	}
+}

backends/twitter/TwitterPlugin.cpp

➞

Show inline comments

@@ @@ -14,64 +14,64 @@ @@
 DEFINE_LOGGER(logger, "Twitter Backend");
 TwitterPlugin *np = NULL;
 Swift::SimpleEventLoop *loop_; // Event Loop
 const std::string OLD_APP_KEY = "PCWAdQpyyR12ezp2fVwEhw";
 const std::string OLD_APP_SECRET = "EveLmCXJIg2R7BTCpm6OWV8YyX49nI0pxnYXh7JMvDg";
 #define abs(x) ((x)<0?-(x):(x))
 #define SHA(x) (Swift::Hexify::hexify(Swift::SHA1::getHash(Swift::createByteArray((x)))))
-//Compares two +ve intergers 'a' and 'b' represented as strings
 //Compares two +ve intergers 'a' and 'b' represented as strings
 static int cmp(std::string a, std::string b)
+{
 	int diff = abs((int)a.size() - (int)b.size());
 	if(a.size() < b.size()) a = std::string(diff,'0') + a;
 	else b = std::string(diff,'0') + b;
 	if(a == b) return 0;
 	if(a < b) return -1;
 	return 1;
+}
-TwitterPlugin::TwitterPlugin(Config *config, Swift::SimpleEventLoop *loop, StorageBackend *storagebackend, const std::string &host, int port) : NetworkPlugin()
 TwitterPlugin::TwitterPlugin(Config *config, Swift::SimpleEventLoop *loop, StorageBackend *storagebackend, const std::string &host, int port) : NetworkPlugin()
+{
 	this->config = config;
 	this->storagebackend = storagebackend;
 	this->m_firstPing = true;
 	if (CONFIG_HAS_KEY(config, "twitter.consumer_key") == false) {
 		consumerKey = "5mFePMiJi0KpeURONkelg";
+	}
 	else {
 		consumerKey = CONFIG_STRING(config, "twitter.consumer_key");
+	}
 	if (CONFIG_HAS_KEY(config, "twitter.consumer_secret") == false) {
 		consumerSecret = "YFZCDJwRhbkccXEnaYr1waCQejTJcOY8F7l5Wim3FA";
+	}
 	else {
 		consumerSecret = CONFIG_STRING(config, "twitter.consumer_secret");
+	}
 	if (consumerSecret.empty() || consumerKey.empty()) {
 		LOG4CXX_ERROR(logger, "Consumer key and Consumer secret can't be empty.");
 		exit(1);
+	}
 	adminLegacyName = "twitter.com";
 	adminChatRoom = "#twitter";
 	adminNickName = "twitter";
 	adminLegacyName = "twitter.com";
 	adminChatRoom = "#twitter";
 	adminNickName = "twitter";
 	adminAlias = "twitter";
 	OAUTH_KEY = "twitter_oauth_token";
 	OAUTH_SECRET = "twitter_oauth_secret";
 	MODE = "mode";
 	m_factories = new Swift::BoostNetworkFactories(loop);
 	m_conn = m_factories->getConnectionFactory()->createConnection();
 	m_conn->onDataRead.connect(boost::bind(&TwitterPlugin::_handleDataRead, this, _1));
 	m_conn->connect(Swift::HostAddressPort(SWIFT_HOSTADDRESS(host), port));
 	tp = new ThreadPool(loop_, 10);
 	tweet_timer = m_factories->getTimerFactory()->createTimer(CONFIG_INT_DEFAULTED(config, "twitter.fetch_timeout", 90000));
 	message_timer = m_factories->getTimerFactory()->createTimer(CONFIG_INT_DEFAULTED(config, "twitter.fetch_timeout", 90000));
 	tweet_timer->onTick.connect(boost::bind(&TwitterPlugin::pollForTweets, this));
 	message_timer->onTick.connect(boost::bind(&TwitterPlugin::pollForDirectMessages, this));
 	tweet_timer->start();
 	message_timer->start();
 #if HAVE_SWIFTEN_3
 		cryptoProvider = SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::CryptoProvider>(Swift::PlatformCryptoProvider::create());
 #endif
 	LOG4CXX_INFO(logger, "Starting the plugin.");
+}
-TwitterPlugin::~TwitterPlugin()
 TwitterPlugin::~TwitterPlugin()
+{
 	delete storagebackend;
 	std::set<std::string>::iterator it;
 	for(it = onlineUsers.begin() ; it != onlineUsers.end() ; it++) delete userdb[*it].sessions;
 	delete tp;
+}
 // Send data to NetworkPlugin server
-void TwitterPlugin::sendData(const std::string &string)
 void TwitterPlugin::sendData(const std::string &string)
+{
 	m_conn->write(Swift::createSafeByteArray(string));
+}
 // Receive date from the NetworkPlugin server and invoke the appropirate payload handler (implement in the NetworkPlugin class)
 void TwitterPlugin::_handleDataRead(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::SafeByteArray> data)
+{
 	if (m_firstPing) {
 		m_firstPing = false;
 		// Users can join the network without registering if we allow
 		// one user to connect multiple IRC networks.
 		NetworkPlugin::PluginConfig cfg;
 		cfg.setNeedPassword(false);
 		sendConfig(cfg);
+	}
 	std::string d(data->begin(), data->end());
 	handleDataRead(d);
+}
 // User trying to login into his twitter account
-void TwitterPlugin::handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password)
 void TwitterPlugin::handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password)
+{
 	if(userdb.count(user) && (userdb[user].connectionState == NEW ||
 										userdb[user].connectionState == CONNECTED ||
 	if(userdb.count(user) && (userdb[user].connectionState == NEW ||
 										userdb[user].connectionState == CONNECTED ||
 										userdb[user].connectionState == WAITING_FOR_PIN)) {
 		LOG4CXX_INFO(logger, std::string("A session corresponding to ") + user + std::string(" is already active"))
+		LOG4CXX_INFO(logger, std::string("A session corresponding to ") + user + std::string(" is already active"));
 		return;
+	}
 	LOG4CXX_INFO(logger, std::string("Received login request for ") + user)
 	LOG4CXX_INFO(logger, std::string("Received login request for ") + user);
 	initUserSession(user, legacyName, password);
 	handleConnected(user);
 	LOG4CXX_INFO(logger, "SPECTRUM 1 USER? - " << (userdb[user].spectrum1User? "true" : "false"))
 	LOG4CXX_INFO(logger, user << ": Adding Buddy " << adminLegacyName << " " << adminAlias)
 	LOG4CXX_INFO(logger, "SPECTRUM 1 USER? - " << (userdb[user].spectrum1User? "true" : "false"));
 	LOG4CXX_INFO(logger, user << ": Adding Buddy " << adminLegacyName << " " << adminAlias);
 	handleBuddyChanged(user, adminLegacyName, adminAlias, std::vector<std::string>(), pbnetwork::STATUS_ONLINE);
 	userdb[user].nickName = "";
 	LOG4CXX_INFO(logger, "Querying database for usersettings of " << user)
 	LOG4CXX_INFO(logger, "Querying database for usersettings of " << user);
 	std::string key, secret;
 	getUserOAuthKeyAndSecret(user, key, secret);
 	if(key == "" || secret == "") {
 		LOG4CXX_INFO(logger, "Intiating OAuth Flow for user " << user)
 	if(key == "" || secret == "") {
 		LOG4CXX_INFO(logger, "Intiating OAuth Flow for user " << user);
 		setTwitterMode(user, 0);
 		tp->runAsThread(new OAuthFlow(np, userdb[user].sessions, user, userdb[user].sessions->getTwitterUsername()));
 	} else {
 		LOG4CXX_INFO(logger, user << " is already registerd. Using the stored oauth key and secret")
 		LOG4CXX_INFO(logger, key << " " << secret)
 		LOG4CXX_INFO(logger, user << " is already registerd. Using the stored oauth key and secret");
 		LOG4CXX_INFO(logger, key << " " << secret);
 		pinExchangeComplete(user, key, secret);
+	}
+}
 // User logging out
-void TwitterPlugin::handleLogoutRequest(const std::string &user, const std::string &legacyName)
 void TwitterPlugin::handleLogoutRequest(const std::string &user, const std::string &legacyName)
+{
 	if (userdb.count(user)) {
 		delete userdb[user].sessions;
 		userdb[user].sessions = NULL;
 		userdb[user].connectionState = DISCONNECTED;
+	}
 	if(onlineUsers.count(user)) {
 		onlineUsers.erase(user);
+	}
+}
 // User joining a Chatroom
 void TwitterPlugin::handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &password)
+{
 	if(room == adminChatRoom) {
 		LOG4CXX_INFO(logger, "Received Join Twitter room request for " << user << " '" << nickname << "'")
 	if(room == adminChatRoom) {
 		LOG4CXX_INFO(logger, "Received Join Twitter room request for " << user << " '" << nickname << "'");
 		setTwitterMode(user, 2);
 		handleParticipantChanged(user, nickname, room, 0, pbnetwork::STATUS_ONLINE);
 		handleParticipantChanged(user, adminNickName, room, 0, pbnetwork::STATUS_ONLINE);
 		userdb[user].nickName = nickname;
 		handleMessage(user, adminChatRoom, "Connected to Twitter room! Populating your followers list", adminNickName);
 		tp->runAsThread(new FetchFriends(userdb[user].sessions, user,
 										 boost::bind(&TwitterPlugin::populateRoster, this, _1, _2, _3, _4)));
 	} else {
 		setTwitterMode(user, 0);
 		LOG4CXX_ERROR(logger, "Couldn't connect to chatroom - " << room <<"! Try twitter-chatroom as the chatroom to access Twitter account")
+		LOG4CXX_ERROR(logger, "Couldn't connect to chatroom - " << room <<"! Try twitter-chatroom as the chatroom to access Twitter account");
 		handleMessage(user, adminLegacyName, "Couldn't connect to chatroom! Try twitter-chatroom as the chatroom to access Twitter account");
+	}
+	}
+}
 // User leaving a Chatroom
 void TwitterPlugin::handleLeaveRoomRequest(const std::string &user, const std::string &room)
+{
 	if(room == adminChatRoom && onlineUsers.count(user)) {
 		LOG4CXX_INFO(logger, "Leaving chatroom! Switching back to default mode 0")
+		LOG4CXX_INFO(logger, "Leaving chatroom! Switching back to default mode 0");
 		setTwitterMode(user, 0);
 		handleBuddyChanged(user, adminLegacyName, adminAlias, std::vector<std::string>(), pbnetwork::STATUS_ONLINE);
+	}
+}
 // Messages to be sent to Twitter
 void TwitterPlugin::handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml, const std::string &/*id*/)
 // Messages to be sent to Twitter
 void TwitterPlugin::handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml, const std::string &/*id*/)
+{
 	LOG4CXX_INFO(logger, "Received " << user << " --> " << legacyName << " - " << message)
 	LOG4CXX_INFO(logger, "Received " << user << " --> " << legacyName << " - " << message);
 	if(legacyName == adminLegacyName || legacyName == adminChatRoom)  {
 		std::string cmd = "", data = "";
 		/** Parsing the message - Assuming message format to be <cmd>[ ]*<data>**/
 		/** Parsing the message - Assuming message format to be <cmd>[ ]*<data>**/
 		int i;
 		for(i=0 ; i<message.size() && message[i] != ' '; i++) cmd += message[i];
 		while(i<message.size() && message[i] == ' ') i++;
 		data = message.substr(i);
 		/***********************************************************************/
 		if(cmd == "#pin")
 		if(cmd == "#pin")
 			tp->runAsThread(new PINExchangeProcess(np, userdb[user].sessions, user, data));
-		else if(cmd == "#help")
 		else if(cmd == "#help")
 			tp->runAsThread(new HelpMessageRequest(user, CONFIG_STRING(config, "service.jid"), boost::bind(&TwitterPlugin::helpMessageResponse, this, _1, _2)));
 		else if(cmd[0] == '@') {
-			std::string username = cmd.substr(1);
 			std::string username = cmd.substr(1);
 			tp->runAsThread(new DirectMessageRequest(userdb[user].sessions, user, username, data,
 												     boost::bind(&TwitterPlugin::directMessageResponse, this, _1, _2, _3, _4)));
+		}
-		else if(cmd == "#status")
 		else if(cmd == "#status")
 			tp->runAsThread(new StatusUpdateRequest(userdb[user].sessions, user, data,
 														boost::bind(&TwitterPlugin::statusUpdateResponse, this, _1, _2)));
-		else if(cmd == "#timeline")
 		else if(cmd == "#timeline")
 			tp->runAsThread(new TimelineRequest(userdb[user].sessions, user, data, "",
 														boost::bind(&TwitterPlugin::displayTweets, this, _1, _2, _3, _4)));
-		else if(cmd == "#friends")
 		else if(cmd == "#friends")
 			tp->runAsThread(new FetchFriends(userdb[user].sessions, user,
 													   boost::bind(&TwitterPlugin::displayFriendlist, this, _1, _2, _3, _4)));
-		else if(cmd == "#follow")
 		else if(cmd == "#follow")
 			tp->runAsThread(new CreateFriendRequest(userdb[user].sessions, user, data.substr(0,data.find('@')),
 													   boost::bind(&TwitterPlugin::createFriendResponse, this, _1, _2, _3, _4)));
-		else if(cmd == "#unfollow")
 		else if(cmd == "#unfollow")
 			tp->runAsThread(new DestroyFriendRequest(userdb[user].sessions, user, data.substr(0,data.find('@')),
 													   boost::bind(&TwitterPlugin::deleteFriendResponse, this, _1, _2, _3)));
-		else if(cmd == "#retweet")
 		else if(cmd == "#retweet")
 			tp->runAsThread(new RetweetRequest(userdb[user].sessions, user, data,
 													   boost::bind(&TwitterPlugin::RetweetResponse, this, _1, _2)));
 		else if(cmd == "#mode") {
 			int m = 0;
 			m = atoi(data.c_str());
 			mode prevm = userdb[user].twitterMode;
 			if((mode)m == userdb[user].twitterMode) return; //If same as current mode return
 			if(m < 0 || m > 1) { // Invalid modes
 				handleMessage(user, adminLegacyName, std::string("Error! Unknown mode ") + data + ". Allowed values 0 or 1." );
 				return;
+			}
 			setTwitterMode(user, m);
 			if((userdb[user].twitterMode == SINGLECONTACT || userdb[user].twitterMode == CHATROOM) && prevm == MULTIPLECONTACT) clearRoster(user);
-			else if(userdb[user].twitterMode == MULTIPLECONTACT)
 			else if(userdb[user].twitterMode == MULTIPLECONTACT)
 				tp->runAsThread(new FetchFriends(userdb[user].sessions, user, boost::bind(&TwitterPlugin::populateRoster, this, _1, _2, _3, _4)));
 			handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 								std::string("Changed mode to ") + data, userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 			LOG4CXX_INFO(logger, user << ": Changed mode to " << data  << " <" << (userdb[user].twitterMode == CHATROOM ? adminNickName : "") << ">" )
+			LOG4CXX_INFO(logger, user << ": Changed mode to " << data  << " <" << (userdb[user].twitterMode == CHATROOM ? adminNickName : "") << ">" );
+		}
 		else if(userdb[user].twitterMode == CHATROOM) {
 			std::string buddy = message.substr(0, message.find(":"));
 			if(userdb[user].buddies.count(buddy) == 0) {
 				tp->runAsThread(new StatusUpdateRequest(userdb[user].sessions, user, message,
 														boost::bind(&TwitterPlugin::statusUpdateResponse, this, _1, _2)));
 			} else {
 				data = message.substr(message.find(":")+1); //Can parse better??:P
 				tp->runAsThread(new DirectMessageRequest(userdb[user].sessions, user, buddy, data,
 												 		 boost::bind(&TwitterPlugin::directMessageResponse, this, _1, _2, _3, _4)));
+			}
+		}
 		else handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 				                 "Unknown command! Type #help for a list of available commands.", userdb[user].twitterMode == CHATROOM ? adminNickName : "");
+	}
+	}
-	else {
 	else {
 		std::string buddy = legacyName;
 		if(userdb[user].twitterMode == CHATROOM) buddy = legacyName.substr(legacyName.find("/") + 1);
 		if(legacyName != "twitter") {
 			tp->runAsThread(new DirectMessageRequest(userdb[user].sessions, user, buddy, message,
 												 boost::bind(&TwitterPlugin::directMessageResponse, this, _1, _2, _3, _4)));
+		}
+	}
+}
-void TwitterPlugin::handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups)
 void TwitterPlugin::handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups)
+{
 	if(userdb[user].connectionState != CONNECTED) {
 		LOG4CXX_ERROR(logger, user << " is not connected to twitter!")
+		LOG4CXX_ERROR(logger, user << " is not connected to twitter!");
 		return;
+	}
 	LOG4CXX_INFO(logger, user << " - Adding Twitter contact " << buddyName)
 	tp->runAsThread(new CreateFriendRequest(userdb[user].sessions, user, buddyName,
 	LOG4CXX_INFO(logger, user << " - Adding Twitter contact " << buddyName);
 	tp->runAsThread(new CreateFriendRequest(userdb[user].sessions, user, buddyName,
 											boost::bind(&TwitterPlugin::createFriendResponse, this, _1, _2, _3, _4)));
+}
-void TwitterPlugin::handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups)
 void TwitterPlugin::handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups)
+{
 	if(userdb[user].connectionState != CONNECTED) {
 		LOG4CXX_ERROR(logger, user << " is not connected to twitter!")
+		LOG4CXX_ERROR(logger, user << " is not connected to twitter!");
 		return;
+	}
 	if (getTwitterMode(user) == MULTIPLECONTACT) {
 		LOG4CXX_ERROR(logger, user << " not removing Twitter contact " << buddyName << ", because the mode is not MULTIPLECONTACT")
+		LOG4CXX_ERROR(logger, user << " not removing Twitter contact " << buddyName << ", because the mode is not MULTIPLECONTACT");
 		return;
+	}
 	LOG4CXX_INFO(logger, user << " - Removing Twitter contact " << buddyName)
 	tp->runAsThread(new DestroyFriendRequest(userdb[user].sessions, user, buddyName,
 	LOG4CXX_INFO(logger, user << " - Removing Twitter contact " << buddyName);
 	tp->runAsThread(new DestroyFriendRequest(userdb[user].sessions, user, buddyName,
 											 boost::bind(&TwitterPlugin::deleteFriendResponse, this, _1, _2, _3)));
+}
 void TwitterPlugin::handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id)
+{
 	if(userdb[user].connectionState != CONNECTED) {
 		LOG4CXX_ERROR(logger, user << " is not connected to twitter!")
+		LOG4CXX_ERROR(logger, user << " is not connected to twitter!");
 		return;
+	}
 	LOG4CXX_INFO(logger, user << " - VCardRequest for " << legacyName << ", " << userdb[user].buddiesInfo[legacyName].getProfileImgURL())
 	if(getTwitterMode(user) != SINGLECONTACT && userdb[user].buddies.count(legacyName)
 	LOG4CXX_INFO(logger, user << " - VCardRequest for " << legacyName << ", " << userdb[user].buddiesInfo[legacyName].getProfileImgURL());
 	if(getTwitterMode(user) != SINGLECONTACT && userdb[user].buddies.count(legacyName)
 		&& userdb[user].buddiesInfo[legacyName].getProfileImgURL().length()) {
 		if(userdb[user].buddiesImgs.count(legacyName) == 0) {
 			tp->runAsThread(new ProfileImageRequest(config, user, legacyName, userdb[user].buddiesInfo[legacyName].getProfileImgURL(), id,
 													boost::bind(&TwitterPlugin::profileImageResponse, this, _1, _2, _3, _4, _5)));
+		}
 		handleVCard(user, id, legacyName, legacyName, "", userdb[user].buddiesImgs[legacyName]);
+	}
+}
 void TwitterPlugin::pollForTweets()
+{
 	boost::mutex::scoped_lock lock(userlock);
@@ @@ -359,268 +359,268 @@ void TwitterPlugin::pollForDirectMessages() @@
 	boost::mutex::scoped_lock lock(userlock);
 	std::set<std::string>::iterator it = onlineUsers.begin();
 	while(it != onlineUsers.end()) {
 		std::string user = *it;
 		tp->runAsThread(new DirectMessageRequest(userdb[user].sessions, user, "", getMostRecentDMIDUnsafe(user),
 											boost::bind(&TwitterPlugin::directMessageResponse, this, _1, _2, _3, _4)));
 		it++;
+	}
 	message_timer->start();
+}
-bool TwitterPlugin::getUserOAuthKeyAndSecret(const std::string user, std::string &key, std::string &secret)
 bool TwitterPlugin::getUserOAuthKeyAndSecret(const std::string user, std::string &key, std::string &secret)
+{
 	boost::mutex::scoped_lock lock(dblock);
 	UserInfo info;
 	if(storagebackend->getUser(user, info) == false) {
 		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
+		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!");
 		return false;
+	}
 	key="", secret=""; int type = TYPE_STRING;;
 	storagebackend->getUserSetting((long)info.id, OAUTH_KEY, type, key);
 	storagebackend->getUserSetting((long)info.id, OAUTH_SECRET, type, secret);
 	return true;
+}
-bool TwitterPlugin::checkSpectrum1User(const std::string user)
 bool TwitterPlugin::checkSpectrum1User(const std::string user)
+{
 	boost::mutex::scoped_lock lock(dblock);
 	UserInfo info;
 	if(storagebackend->getUser(user, info) == false) {
 		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
+		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!");
 		return false;
+	}
 	std::string first_synchronization_done = "";
 	int type = TYPE_STRING;
 	storagebackend->getUserSetting((long)info.id, "first_synchronization_done", type, first_synchronization_done);
 	LOG4CXX_INFO(logger, "first_synchronization_done: " << first_synchronization_done)
+	LOG4CXX_INFO(logger, "first_synchronization_done: " << first_synchronization_done);
 	if(first_synchronization_done.length()) return true;
 	return false;
+}
-int TwitterPlugin::getTwitterMode(const std::string user)
 int TwitterPlugin::getTwitterMode(const std::string user)
+{
 	boost::mutex::scoped_lock lock(dblock);
 	UserInfo info;
 	if(storagebackend->getUser(user, info) == false) {
 		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
+		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!");
 		return -1;
+	}
 	int type = TYPE_STRING; int m;
 	std::string s_m;
 	storagebackend->getUserSetting((long)info.id, MODE, type, s_m);
 	if(s_m == "") {
 		s_m  = "0";
 		storagebackend->updateUserSetting((long)info.id, MODE, s_m);
+	}
 	m = atoi(s_m.c_str());
 	return m;
+}
-bool TwitterPlugin::setTwitterMode(const std::string user, int m)
 bool TwitterPlugin::setTwitterMode(const std::string user, int m)
+{
 	boost::mutex::scoped_lock lock(dblock);
 	UserInfo info;
 	if(storagebackend->getUser(user, info) == false) {
 		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
+		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!");
 		return false;
+	}
 	if(m < 0 || m > 2) {
 		LOG4CXX_ERROR(logger, "Unknown mode " << m <<". Using default mode 0")
+		LOG4CXX_ERROR(logger, "Unknown mode " << m <<". Using default mode 0");
 		m = 0;
+	}
 	userdb[user].twitterMode = (mode)m;
 	//int type;
 	std::string s_m = std::string(1,m+'0');
 	LOG4CXX_INFO(logger, "Storing mode " << m <<" for user " << user)
+	LOG4CXX_INFO(logger, "Storing mode " << m <<" for user " << user);
 	storagebackend->updateUserSetting((long)info.id, MODE, s_m);
 	return true;
+}
-bool TwitterPlugin::storeUserOAuthKeyAndSecret(const std::string user, const std::string OAuthKey, const std::string OAuthSecret)
 bool TwitterPlugin::storeUserOAuthKeyAndSecret(const std::string user, const std::string OAuthKey, const std::string OAuthSecret)
+{
 	boost::mutex::scoped_lock lock(dblock);
 	UserInfo info;
 	if(storagebackend->getUser(user, info) == false) {
 		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
+		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!");
 		return false;
+	}
-	storagebackend->updateUserSetting((long)info.id, OAUTH_KEY, OAuthKey);
 	storagebackend->updateUserSetting((long)info.id, OAUTH_KEY, OAuthKey);
 	storagebackend->updateUserSetting((long)info.id, OAUTH_SECRET, OAuthSecret);
 	return true;
+}
 void TwitterPlugin::initUserSession(const std::string user, const std::string legacyName, const std::string password)
+{
 	boost::mutex::scoped_lock lock(userlock);
 	std::string username = legacyName;
 	std::string passwd = password;
 	LOG4CXX_INFO(logger, username + "  " + passwd)
+	LOG4CXX_INFO(logger, username + "  " + passwd);
 	userdb[user].sessions = new twitCurl();
 	if(CONFIG_HAS_KEY(config,"proxy.server")) {
 	userdb[user].sessions = new twitCurl();
 	if(CONFIG_HAS_KEY(config,"proxy.server")) {
 		std::string ip = CONFIG_STRING(config,"proxy.server");
-		std::ostringstream out;
 		std::ostringstream out;
 		out << CONFIG_INT(config,"proxy.port");
 		std::string port = out.str();
 		std::string puser = CONFIG_STRING(config,"proxy.user");
 		std::string ppasswd = CONFIG_STRING(config,"proxy.password");
 		LOG4CXX_INFO(logger, ip << " " << port << " " << puser << " " << ppasswd)
 		LOG4CXX_INFO(logger, ip << " " << port << " " << puser << " " << ppasswd);
 		if(ip != "localhost" && port != "0") {
 			userdb[user].sessions->setProxyServerIp(ip);
 			userdb[user].sessions->setProxyServerPort(port);
 			userdb[user].sessions->setProxyUserName(puser);
 			userdb[user].sessions->setProxyPassword(ppasswd);
+		}
+	}
 	//Check if the user is spectrum1 user
 	userdb[user].spectrum1User = checkSpectrum1User(user);
 	userdb[user].connectionState = NEW;
-	userdb[user].legacyName = username;
 	userdb[user].legacyName = username;
 	userdb[user].sessions->setTwitterUsername(username);
 	userdb[user].sessions->setTwitterPassword(passwd);
 	if(!userdb[user].spectrum1User) {
 		userdb[user].sessions->getOAuth().setConsumerKey(consumerKey);
 		userdb[user].sessions->getOAuth().setConsumerSecret(consumerSecret);
 	} else {
 		userdb[user].sessions->getOAuth().setConsumerKey(OLD_APP_KEY);
 		userdb[user].sessions->getOAuth().setConsumerSecret(OLD_APP_SECRET);
+	}
+}
-void TwitterPlugin::OAuthFlowComplete(const std::string user, twitCurl *obj)
 void TwitterPlugin::OAuthFlowComplete(const std::string user, twitCurl *obj)
+{
-	boost::mutex::scoped_lock lock(userlock);
 	boost::mutex::scoped_lock lock(userlock);
 	delete userdb[user].sessions;
-	userdb[user].sessions = obj->clone();
 	userdb[user].sessions = obj->clone();
 	userdb[user].connectionState = WAITING_FOR_PIN;
+}
+}
-void TwitterPlugin::pinExchangeComplete(const std::string user, const std::string OAuthAccessTokenKey, const std::string OAuthAccessTokenSecret)
 void TwitterPlugin::pinExchangeComplete(const std::string user, const std::string OAuthAccessTokenKey, const std::string OAuthAccessTokenSecret)
+{
 	boost::mutex::scoped_lock lock(userlock);
 	boost::mutex::scoped_lock lock(userlock);
 	userdb[user].sessions->getOAuth().setOAuthTokenKey( OAuthAccessTokenKey );
 	userdb[user].sessions->getOAuth().setOAuthTokenSecret( OAuthAccessTokenSecret );
 	userdb[user].connectionState = CONNECTED;
 	userdb[user].twitterMode = (mode)getTwitterMode(user);
 	if(userdb[user].twitterMode == MULTIPLECONTACT) {
 		tp->runAsThread(new FetchFriends(userdb[user].sessions, user, boost::bind(&TwitterPlugin::populateRoster, this, _1, _2, _3, _4)));
+	}
 	onlineUsers.insert(user);
 	userdb[user].mostRecentTweetID = "";
 	userdb[user].mostRecentDirectMessageID = "";
+}
+}
 void TwitterPlugin::updateLastTweetID(const std::string user, const std::string ID)
+{
-	boost::mutex::scoped_lock lock(userlock);
 	boost::mutex::scoped_lock lock(userlock);
 	userdb[user].mostRecentTweetID = ID;
 	UserInfo info;
 	if(storagebackend->getUser(user, info) == false) {
 		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
+		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!");
 		return;
+	}
 	storagebackend->updateUserSetting((long)info.id, "twitter_last_tweet", ID);
+}
 std::string TwitterPlugin::getMostRecentTweetIDUnsafe(const std::string user)
+{
+{
 	std::string ID = "";
 	if(onlineUsers.count(user)) {
 		ID = userdb[user].mostRecentTweetID;
 		if (ID.empty()) {
 			int type = TYPE_STRING;
 			UserInfo info;
 			if(storagebackend->getUser(user, info) == false) {
 				LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
+				LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!");
+			}
 			else {
 				storagebackend->getUserSetting(info.id, "twitter_last_tweet", type, ID);
+			}
+		}
+	}
 	return ID;
+}
 std::string TwitterPlugin::getMostRecentTweetID(const std::string user)
+{
+{
 	boost::mutex::scoped_lock lock(userlock);
 	return getMostRecentTweetIDUnsafe(user);
+}
 void TwitterPlugin::updateLastDMID(const std::string user, const std::string ID)
+{
-	boost::mutex::scoped_lock lock(userlock);
 	boost::mutex::scoped_lock lock(userlock);
 	userdb[user].mostRecentDirectMessageID = ID;
 	UserInfo info;
 	if(storagebackend->getUser(user, info) == false) {
 		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
+		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!");
 		return;
+	}
 	storagebackend->updateUserSetting((long)info.id, "twitter_last_dm", ID);
+}
 std::string TwitterPlugin::getMostRecentDMIDUnsafe(const std::string user) {
 	std::string ID = "";
 	if(onlineUsers.count(user)) {
 		ID = userdb[user].mostRecentDirectMessageID;
 		if (ID.empty()) {
 			int type = TYPE_STRING;
 			UserInfo info;
 			if(storagebackend->getUser(user, info) == false) {
 				LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
+				LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!");
+			}
 			else {
 				storagebackend->getUserSetting(info.id, "twitter_last_dm", type, ID);
+			}
+		}
+	}
 	return ID;
+}
 std::string TwitterPlugin::getMostRecentDMID(const std::string user)
+{
-	boost::mutex::scoped_lock lock(userlock);
 	boost::mutex::scoped_lock lock(userlock);
 	return getMostRecentDMIDUnsafe(user);
+}
 /************************************** Twitter response functions **********************************/
 void TwitterPlugin::statusUpdateResponse(std::string &user, Error &errMsg)
+{
 	if(errMsg.getMessage().length()) {
 		if (errMsg.isCurlError()) {
 			handleDisconnected(user, 3, errMsg.getMessage());
 			return;
+		}
 		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 void TwitterPlugin::clearRoster(const std::string user)
+{
 	if(userdb[user].buddies.size() == 0) return;
 	std::set<std::string>::iterator it = userdb[user].buddies.begin();
 	while(it != userdb[user].buddies.end()) {
 		handleBuddyRemoved(user, *it);
 		it++;
+	}
 	userdb[user].buddies.clear();
+}
-void TwitterPlugin::populateRoster(std::string &user, std::vector<User> &friends, std::vector<std::string> &friendAvatars, Error &errMsg)
 void TwitterPlugin::populateRoster(std::string &user, std::vector<User> &friends, std::vector<std::string> &friendAvatars, Error &errMsg)
+{
-	if(errMsg.getMessage().length() == 0)
 	if(errMsg.getMessage().length() == 0)
+	{
 		for(int i=0 ; i<friends.size() ; i++) {
 			userdb[user].buddies.insert(friends[i].getScreenName());
 			userdb[user].buddiesInfo[friends[i].getScreenName()] = friends[i];
 			userdb[user].buddiesImgs[friends[i].getScreenName()] = friendAvatars[i];
 			if(userdb[user].twitterMode == MULTIPLECONTACT) {
 				std::string lastTweet = friends[i].getLastStatus().getTweet();
 				//LOG4CXX_INFO(logger, user << " - " << SHA(friendAvatars[i]))
-				handleBuddyChanged(user, friends[i].getScreenName(), friends[i].getUserName(), std::vector<std::string>(),
 				handleBuddyChanged(user, friends[i].getScreenName(), friends[i].getUserName(), std::vector<std::string>(),
 #if HAVE_SWIFTEN_3
 					pbnetwork::STATUS_ONLINE, lastTweet, Swift::Hexify::hexify(cryptoProvider->getSHA1Hash(Swift::createByteArray(friendAvatars[i]))));
 #else
 								   pbnetwork::STATUS_ONLINE, lastTweet, SHA(friendAvatars[i]));
 #endif
+			}
 			else if(userdb[user].twitterMode == CHATROOM)
 				handleParticipantChanged(user, friends[i].getScreenName(), adminChatRoom, 0, pbnetwork::STATUS_ONLINE);
 			/*handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
-							   	friends[i].getScreenName() + " - " + friends[i].getLastStatus().getTweet(),
 							   	friends[i].getScreenName() + " - " + friends[i].getLastStatus().getTweet(),
 								userdb[user].twitterMode == CHATROOM ? adminNickName : "");*/
+		}
 	} else {
 		if (errMsg.isCurlError()) {
 			handleDisconnected(user, 3, errMsg.getMessage());
 			return;
+		}
 		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 							   std::string("Error populating roster - ") + errMsg.getMessage(), userdb[user].twitterMode == CHATROOM ? adminNickName : "");
+	}
 	if(userdb[user].twitterMode == CHATROOM) handleParticipantChanged(user, userdb[user].nickName, adminChatRoom, 0, pbnetwork::STATUS_ONLINE);
+}
 void TwitterPlugin::displayFriendlist(std::string &user, std::vector<User> &friends, std::vector<std::string> &friendAvatars, Error &errMsg)
+{
-	if(errMsg.getMessage().length() == 0)
 	if(errMsg.getMessage().length() == 0)
+	{
 		std::string userlist = "\n***************USER LIST****************\n";
 		for(int i=0 ; i < friends.size() ; i++) {
 			userlist += " - " + friends[i].getUserName() + " (" + friends[i].getScreenName() + ")\n";
+		}
+		}
 		userlist += "***************************************\n";
 		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
-							userlist, userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 							userlist, userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 	} else {
 		if (errMsg.isCurlError()) {
 			handleDisconnected(user, 3, errMsg.getMessage());
 			return;
+		}
 		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 							   errMsg.getMessage(), userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 							   errMsg.getMessage(), userdb[user].twitterMode == CHATROOM ? adminNickName : "");
+	}
+}
 void TwitterPlugin::displayTweets(std::string &user, std::string &userRequested, std::vector<Status> &tweets , Error &errMsg)
+{
 	if(errMsg.getMessage().length() == 0) {
 		std::map<std::string, int> lastTweet;
 		std::map<std::string, int>::iterator it;
 		for(int i = tweets.size() - 1 ; i >= 0 ; i--) {
 			if(userdb[user].twitterMode != CHATROOM) {
 				std::string m = " - " + tweets[i].getUserData().getScreenName() + ": " + tweets[i].getTweet() + " (MsgId: " + (tweets[i].getRetweetID().empty() ? tweets[i].getID() : tweets[i].getRetweetID()) + ")\n";
 				handleMessage(user, adminLegacyName, m, "", "", tweets[i].getCreationTime(), true);
 				std::string scrname = tweets[i].getUserData().getScreenName();
 				if(lastTweet.count(scrname) == 0 || cmp(tweets[lastTweet[scrname]].getID(), tweets[i].getID()) <= 0) lastTweet[scrname] = i;
 			} else {
 				handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 									tweets[i].getTweet() + " (MsgId: " + (tweets[i].getRetweetID().empty() ? tweets[i].getID() : tweets[i].getRetweetID()) + ")", tweets[i].getUserData().getScreenName(), "", tweets[i].getCreationTime(), true);
+			}
+		}
 		if(userdb[user].twitterMode == MULTIPLECONTACT) {
 			//Set as status user's last tweet
 			for(it=lastTweet.begin() ; it!=lastTweet.end() ; it++) {
 				int t =  it->second;
 				if (userdb[user].buddies.count(tweets[t].getUserData().getScreenName()) != 0) {
-					handleBuddyChanged(user, tweets[t].getUserData().getScreenName(), tweets[t].getUserData().getUserName(),
 					handleBuddyChanged(user, tweets[t].getUserData().getScreenName(), tweets[t].getUserData().getUserName(),
 									std::vector<std::string>(), pbnetwork::STATUS_ONLINE, tweets[t].getTweet());
+				}
+			}
+		}
 		if((userRequested == "" || userRequested == user) && tweets.size()) {
 			std::string tweetID = getMostRecentTweetID(user);
 			if(tweetID != tweets[0].getID()) updateLastTweetID(user, tweets[0].getID());
+		}
 	} else {
 		if (errMsg.isCurlError()) {
 			handleDisconnected(user, 3, errMsg.getMessage());
 			return;
+		}
 		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
-							   errMsg.getMessage(), userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 							   errMsg.getMessage(), userdb[user].twitterMode == CHATROOM ? adminNickName : "");
+	}
+}
 void TwitterPlugin::directMessageResponse(std::string &user, std::string &username, std::vector<DirectMessage> &messages, Error &errMsg)
+{
 	if(errMsg.getCode() == "93") //Permission Denied
 		return;
 	if(errMsg.getMessage().length()) {
 		if (errMsg.isCurlError()) {
 			handleDisconnected(user, 3, errMsg.getMessage());
 			return;
 		if(username != "")
 			handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 						  std::string("Error while sending direct message! - ") + errMsg.getMessage(), userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 		else
 			handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 						  std::string("Error while fetching direct messages! - ") + errMsg.getMessage(), userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 		return;
+	}
 	if(username != "") {
 		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
-						   "Message delivered!", userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 						   "Message delivered!", userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 		return;
+	}
 	if(!messages.size()) return;
 	if(userdb[user].twitterMode == SINGLECONTACT) {
 		std::string msglist = "";
 		std::string msgID = getMostRecentDMID(user);
 		std::string maxID = msgID;
 		for(int i=0 ; i < messages.size() ; i++) {
 			if(cmp(msgID, messages[i].getID()) == -1) {
 				msglist += " - " + messages[i].getSenderData().getScreenName() + ": " + messages[i].getMessage() + "\n";
 				if(cmp(maxID, messages[i].getID()) == -1) maxID = messages[i].getID();
+			}
+		}
+		}
-		if(msglist.length()) handleMessage(user, adminLegacyName, msglist, "");
 		if(msglist.length()) handleMessage(user, adminLegacyName, msglist, "");
 		updateLastDMID(user, maxID);
 	} else {
 		std::string msgID = getMostRecentDMID(user);
 		std::string maxID = msgID;
 		for(int i=0 ; i < messages.size() ; i++) {
 			if(cmp(msgID, messages[i].getID()) == -1) {
 				if(userdb[user].twitterMode == MULTIPLECONTACT)
 					handleMessage(user, messages[i].getSenderData().getScreenName(), messages[i].getMessage(), "");
 				else
 					handleMessage(user, adminChatRoom, messages[i].getMessage() + " - <Direct Message>", messages[i].getSenderData().getScreenName());
 				if(cmp(maxID, messages[i].getID()) == -1) maxID = messages[i].getID();
+			}
+		}
 		if(maxID == getMostRecentDMID(user)) LOG4CXX_INFO(logger, "No new direct messages for " << user)
+		}
 		if(maxID == getMostRecentDMID(user)) LOG4CXX_INFO(logger, "No new direct messages for " << user);
 		updateLastDMID(user, maxID);
+	}
+}
 void TwitterPlugin::createFriendResponse(std::string &user, User &frnd, std::string &img, Error &errMsg)
+{
 	if(errMsg.getMessage().length()) {
 		if (errMsg.isCurlError()) {
 			handleDisconnected(user, 3, errMsg.getMessage());
 			return;
+		}
 		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 							errMsg.getMessage(), userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 		return;
+	}
 	handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 						std::string("You are now following ") + frnd.getScreenName(), userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 	userdb[user].buddies.insert(frnd.getScreenName());
 	userdb[user].buddiesInfo[frnd.getScreenName()] = frnd;
 	userdb[user].buddiesImgs[frnd.getScreenName()] = img;
 	LOG4CXX_INFO(logger, user << " - " << frnd.getScreenName() << ", " << frnd.getProfileImgURL())
 	LOG4CXX_INFO(logger, user << " - " << frnd.getScreenName() << ", " << frnd.getProfileImgURL());
 	if(userdb[user].twitterMode == MULTIPLECONTACT) {
 #if HAVE_SWIFTEN_3
 		handleBuddyChanged(user, frnd.getScreenName(), frnd.getUserName(), std::vector<std::string>(), pbnetwork::STATUS_ONLINE, "", Swift::byteArrayToString(cryptoProvider->getSHA1Hash(Swift::createByteArray(img))));
 #else
 		handleBuddyChanged(user, frnd.getScreenName(), frnd.getUserName(), std::vector<std::string>(), pbnetwork::STATUS_ONLINE, "", SHA(img));
 #endif
 	} else if(userdb[user].twitterMode == CHATROOM) {
 		handleParticipantChanged(user, frnd.getScreenName(), adminChatRoom, 0, pbnetwork::STATUS_ONLINE);
+	}
+}
 void TwitterPlugin::deleteFriendResponse(std::string &user, User &frnd, Error &errMsg)
+{
 	if(errMsg.getMessage().length()) {
 		if (errMsg.isCurlError()) {
 			handleDisconnected(user, 3, errMsg.getMessage());
 			return;
+		}
-		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 							errMsg.getMessage(), userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 		return;
+	}
 	LOG4CXX_INFO(logger, user << " - " << frnd.getScreenName() << ", " << frnd.getProfileImgURL())
+	}
 	LOG4CXX_INFO(logger, user << " - " << frnd.getScreenName() << ", " << frnd.getProfileImgURL());
 	userdb[user].buddies.erase(frnd.getScreenName());
 	handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 						std::string("You are not following ") + frnd.getScreenName() + " anymore", userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 	if (userdb[user].twitterMode == CHATROOM) {
 		handleParticipantChanged(user, frnd.getScreenName(), adminLegacyName, 0, pbnetwork::STATUS_NONE);
+	}
 	if(userdb[user].twitterMode == MULTIPLECONTACT) {
 		handleBuddyRemoved(user, frnd.getScreenName());
+	}
+	}
+}
 void TwitterPlugin::RetweetResponse(std::string &user, Error &errMsg)
+{
 	if(errMsg.getMessage().length()) {
 		if (errMsg.isCurlError()) {
 			handleDisconnected(user, 3, errMsg.getMessage());
 			return;
+		}
 		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 							errMsg.getMessage(), userdb[user].twitterMode == CHATROOM ? adminNickName : "");
+}
 void TwitterPlugin::profileImageResponse(std::string &user, std::string &buddy, std::string &img, unsigned int reqID, Error &errMsg)
+{
 	if(errMsg.getMessage().length()) {
 		if (errMsg.isCurlError()) {
 			handleDisconnected(user, 3, errMsg.getMessage());
 			return;
+		}
 		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 							errMsg.getMessage(), userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 	} else {
 		LOG4CXX_INFO(logger, user << " - Sending VCard for " << buddy)
+		LOG4CXX_INFO(logger, user << " - Sending VCard for " << buddy);
 		handleVCard(user, reqID, buddy, buddy, "", img);
+	}
+}

backends/twitter/TwitterResponseParser.cpp

➞

Show inline comments

+}
 static std::string toIsoTime(std::string in) {
 	std::locale locale(std::locale::classic(), new boost::local_time::local_time_input_facet("%a %b %d %H:%M:%S +0000 %Y"));
 	boost::local_time::local_time_facet* output_facet = new boost::local_time::local_time_facet();
 	boost::local_time::local_date_time ldt(boost::local_time::not_a_date_time);
 	std::stringstream ss(in);
 	ss.imbue(locale);
 	ss.imbue(std::locale(ss.getloc(), output_facet));
 	output_facet->format("%Y%m%dT%H%M%S"); // boost::local_time::local_time_facet::iso_time_format_specifier ?
 	ss >> ldt;
 	ss.str("");
-	ss << ldt;
 	ss << ldt;
 	return ss.str();
+}
 EmbeddedStatus getEmbeddedStatus(const rapidjson::Value &element)
+{
 	EmbeddedStatus status;
 	if(!element.IsObject()) {
 		LOG4CXX_ERROR(logger, "Not a status element!")
+		LOG4CXX_ERROR(logger, "Not a status element!");
 		return status;
+	}
 	status.setCreationTime( toIsoTime ( std::string( element[TwitterReponseTypes::created_at.c_str()].GetString() ) ) );
 	status.setID( stringOf( element[TwitterReponseTypes::id.c_str()].GetInt64() ) );
 	status.setTweet( unescape ( std::string( element[TwitterReponseTypes::text.c_str()].GetString() ), getUrlEntities(element) ) );
 	status.setTruncated( element[TwitterReponseTypes::truncated.c_str()].GetBool());
 	status.setReplyToStatusID( element[TwitterReponseTypes::in_reply_to_status_id.c_str()].IsNull() ?
 "" : stringOf(element[TwitterReponseTypes::in_reply_to_status_id.c_str()].GetInt64()) );
 	status.setReplyToUserID( element[TwitterReponseTypes::in_reply_to_user_id.c_str()].IsNull() ?
 "" : stringOf(element[TwitterReponseTypes::in_reply_to_user_id.c_str()].GetInt64())  );
 	status.setReplyToScreenName( element[TwitterReponseTypes::in_reply_to_screen_name.c_str()].IsNull() ?
 "" : std::string(element[TwitterReponseTypes::in_reply_to_screen_name.c_str()].GetString()) );
 	status.setRetweetCount( element[TwitterReponseTypes::retweet_count.c_str()].GetInt64() );
 	status.setFavorited( element[TwitterReponseTypes::favorited.c_str()].GetBool() );
-	status.setRetweeted( element[TwitterReponseTypes::retweeted.c_str()].GetBool());
 	status.setRetweeted( element[TwitterReponseTypes::retweeted.c_str()].GetBool());
 	return status;
+}
-User getUser(const rapidjson::Value &element)
 User getUser(const rapidjson::Value &element)
+{
 	User user;
 	if(!element.IsObject()) {
 		LOG4CXX_ERROR(logger, "Not a user element!")
+		LOG4CXX_ERROR(logger, "Not a user element!");
 		return user;
+	}
 	user.setUserID( stringOf( element[TwitterReponseTypes::id.c_str()].GetInt64() ) );
 	user.setScreenName( tolowercase( std::string( element[TwitterReponseTypes::screen_name.c_str()].GetString() ) ) );
 	user.setUserName( std::string( element[TwitterReponseTypes::name.c_str()].GetString() ) );
 	user.setProfileImgURL( std::string( element[TwitterReponseTypes::profile_image_url.c_str()].GetString() ) );
 	user.setNumberOfTweets( element[TwitterReponseTypes::statuses_count.c_str()].GetInt64() );
-	if(element[TwitterReponseTypes::status.c_str()].IsObject())
 	if(element[TwitterReponseTypes::status.c_str()].IsObject())
 		user.setLastStatus(getEmbeddedStatus(element[TwitterReponseTypes::status.c_str()]));
 	return user;
+}
-Status getStatus(const rapidjson::Value &element)
 Status getStatus(const rapidjson::Value &element)
+{
 	Status status;
 	status.setCreationTime( toIsoTime ( std::string( element[TwitterReponseTypes::created_at.c_str()].GetString() ) ) );
 	status.setID( stringOf( element[TwitterReponseTypes::id.c_str()].GetInt64()  ));
 	status.setTweet( unescape ( std::string( element[TwitterReponseTypes::text.c_str()].GetString() ), getUrlEntities(element) ) );
 	status.setTruncated( element[TwitterReponseTypes::truncated.c_str()].GetBool());
 	status.setReplyToStatusID( element[TwitterReponseTypes::in_reply_to_status_id.c_str()].IsNull() ?
 "" : stringOf(element[TwitterReponseTypes::in_reply_to_status_id.c_str()].GetInt64()) );
 	status.setReplyToUserID( element[TwitterReponseTypes::in_reply_to_user_id.c_str()].IsNull() ?
 "" : stringOf(element[TwitterReponseTypes::in_reply_to_user_id.c_str()].GetInt64())  );
 	status.setReplyToScreenName( element[TwitterReponseTypes::in_reply_to_screen_name.c_str()].IsNull() ?
@@ @@ -107,192 +107,192 @@ Status getStatus(const rapidjson::Value &element) @@
 	status.setUserData( getUser(element[TwitterReponseTypes::user.c_str()]) );
 	status.setRetweetCount( element[TwitterReponseTypes::retweet_count.c_str()].GetInt64() );
 	status.setFavorited( element[TwitterReponseTypes::favorited.c_str()].GetBool() );
 	status.setRetweeted( element[TwitterReponseTypes::retweeted.c_str()].GetBool());
 	const rapidjson::Value &rt = element[TwitterReponseTypes::retweeted_status.c_str()];
 	if (rt.IsObject()) {
 		status.setTweet(unescape( std::string( rt[TwitterReponseTypes::text.c_str()].GetString()) + " (RT by @" + status.getUserData().getScreenName() + ")"
 			, getUrlEntities(element)) );
 		status.setRetweetID( stringOf(rt[TwitterReponseTypes::id.c_str()].GetInt64()) );
 		status.setCreationTime( toIsoTime ( std::string (rt[TwitterReponseTypes::created_at.c_str()].GetString() ) ) );
 		status.setUserData( getUser ( rt[TwitterReponseTypes::user.c_str()]) );
+	}
 	return status;
+}
-DirectMessage getDirectMessage(const rapidjson::Value &element)
 DirectMessage getDirectMessage(const rapidjson::Value &element)
+{
 	DirectMessage DM;
 	DM.setCreationTime( toIsoTime ( std::string( element[TwitterReponseTypes::created_at.c_str()].GetString() ) ) );
 	DM.setID( stringOf( element[TwitterReponseTypes::id.c_str()].GetInt64() ) );
 	DM.setMessage( unescape ( std::string( element[TwitterReponseTypes::text.c_str()].GetString() ), getUrlEntities(element) ) );
 	DM.setSenderID( stringOf( element[TwitterReponseTypes::sender_id.c_str()].GetInt64())  );
 	DM.setRecipientID( stringOf( element[TwitterReponseTypes::recipient_id.c_str()].GetInt64() ) );
 	DM.setSenderScreenName( std::string( element[TwitterReponseTypes::sender_screen_name.c_str()].GetString() ) );
 	DM.setRecipientScreenName( std::string( element[TwitterReponseTypes::recipient_screen_name.c_str()].GetString() ) );
 	DM.setSenderData( getUser(element[TwitterReponseTypes::sender.c_str()] ));
 	DM.setRecipientData( getUser(element[TwitterReponseTypes::recipient.c_str()]) );
 	return DM;
+}
 std::vector<Status> getTimeline(std::string &json)
+{
 	std::vector<Status> statuses;
 	rapidjson::Document rootElement;
 	if(rootElement.Parse<0>(json.c_str()).HasParseError()) {
 		LOG4CXX_ERROR(logger, "Error while parsing JSON")
         LOG4CXX_ERROR(logger, json)
 		LOG4CXX_ERROR(logger, "Error while parsing JSON");
 		LOG4CXX_ERROR(logger, json);
 		return statuses;
+	}
 	if(!rootElement.IsArray()) {
 		LOG4CXX_ERROR(logger, "JSON doesn't correspond to timeline:")
         LOG4CXX_ERROR(logger, json)
 		LOG4CXX_ERROR(logger, "JSON doesn't correspond to timeline:");
 		LOG4CXX_ERROR(logger, json);
 		return statuses;
+	}
 	for(rapidjson::SizeType i = 0; i < rootElement.Size(); i++) {
 		statuses.push_back(getStatus(rootElement[i]));
+	}
 	return statuses;
+}
 std::vector<DirectMessage> getDirectMessages(std::string &json)
+{
 	std::vector<DirectMessage> DMs;
 	rapidjson::Document rootElement;
 	if(rootElement.Parse<0>(json.c_str()).HasParseError()) {
 		LOG4CXX_ERROR(logger, "Error while parsing JSON")
         LOG4CXX_ERROR(logger, json)
 		LOG4CXX_ERROR(logger, "Error while parsing JSON");
 		LOG4CXX_ERROR(logger, json);
 		return DMs;
+	}
 	if(!rootElement.IsArray()) {
 		LOG4CXX_ERROR(logger, "JSON doesn't correspond to direct messages:")
         LOG4CXX_ERROR(logger, json)
 		LOG4CXX_ERROR(logger, "JSON doesn't correspond to direct messages:");
 		LOG4CXX_ERROR(logger, json);
 		return DMs;
+	}
 	for(rapidjson::SizeType i = 0; i < rootElement.Size(); i++) {
 		DMs.push_back(getDirectMessage(rootElement[i]));
+	}
 	return DMs;
+}
 std::vector<User> getUsers(std::string &json)
+{
 	std::vector<User> users;
 	rapidjson::Document rootElement;
 	if(rootElement.Parse<0>(json.c_str()).HasParseError()) {
 		LOG4CXX_ERROR(logger, "Error while parsing JSON")
         LOG4CXX_ERROR(logger, json)
 		LOG4CXX_ERROR(logger, "Error while parsing JSON");
 		LOG4CXX_ERROR(logger, json);
 		return users;
+	}
 	if(!rootElement.IsArray()) {
 		LOG4CXX_ERROR(logger, "JSON doesn't correspond to user list:")
         LOG4CXX_ERROR(logger, json)
 		LOG4CXX_ERROR(logger, "JSON doesn't correspond to user list:");
 		LOG4CXX_ERROR(logger, json);
 		return users;
+	}
 	for(rapidjson::SizeType i = 0; i < rootElement.Size(); i++) {
 		users.push_back(getUser(rootElement[i]));
+	}
-	return users;
 	return users;
+}
 User getUser(std::string &json)
+{
 	User user;
 	rapidjson::Document rootElement;
 	if(rootElement.Parse<0>(json.c_str()).HasParseError()) {
 		LOG4CXX_ERROR(logger, "Error while parsing JSON")
         LOG4CXX_ERROR(logger, json)
 		LOG4CXX_ERROR(logger, "Error while parsing JSON");
 		LOG4CXX_ERROR(logger, json);
 		return user;
+	}
 	if(!rootElement.IsObject()) {
 		LOG4CXX_ERROR(logger, "JSON doesn't correspond to user object")
         LOG4CXX_ERROR(logger, json)
 		LOG4CXX_ERROR(logger, "JSON doesn't correspond to user object");
 		LOG4CXX_ERROR(logger, json);
 		return user;
+	}
 	return user = getUser(rootElement);
+}
 std::vector<std::string> getIDs(std::string &json)
+{
 	std::vector<std::string> IDs;
 	rapidjson::Document rootElement;
 	if(rootElement.Parse<0>(json.c_str()).HasParseError()) {
 		LOG4CXX_ERROR(logger, "Error while parsing JSON")
         LOG4CXX_ERROR(logger, json)
 		LOG4CXX_ERROR(logger, "Error while parsing JSON");
 		LOG4CXX_ERROR(logger, json);
 		return IDs;
+	}
 	if(!rootElement.IsObject()) {
 		LOG4CXX_ERROR(logger, "JSON doesn't correspond to id_list");
-        LOG4CXX_ERROR(logger, json)
+		LOG4CXX_ERROR(logger, json);
 		return IDs;
+	}
 	const rapidjson::Value & ids = rootElement[TwitterReponseTypes::ids.c_str()];
 	for(int i=0 ; i<ids.Size() ; i++) {
 		IDs.push_back(stringOf( ids[i].GetInt64()) );
+	}
 	return IDs;
+}
 Error getErrorMessage(std::string &json)
+{
 	std::string error = "";
 	std::string code = "0";
 	Error resp;
 	rapidjson::Document rootElement;
 	if(rootElement.Parse<0>(json.c_str()).HasParseError()) {
 		LOG4CXX_ERROR(logger, "Error while parsing JSON")
         LOG4CXX_ERROR(logger, json)
 		LOG4CXX_ERROR(logger, "Error while parsing JSON");
 		LOG4CXX_ERROR(logger, json);
 		return resp;
+	}
 	if (rootElement.IsObject()) {
-		if (!rootElement["errors"].IsNull()) {
 		if (!rootElement["errors"].IsNull()) {
 			const rapidjson::Value &errorElement = rootElement["errors"][0u]; // first error
 			error = std::string(errorElement["message"].GetString());
 			code = stringOf(errorElement["code"].GetInt64());
 			resp.setCode(code);
 			resp.setMessage(error);
+		}
+	}
 	return resp;
+}
-std::vector<UrlEntity> getUrlEntities(const rapidjson::Value &element)
 std::vector<UrlEntity> getUrlEntities(const rapidjson::Value &element)
+{
 	std::vector<UrlEntity> url_entities;
 	const rapidjson::Value &entities = element["entities"];
 	if (entities.IsObject()) {
 		const rapidjson::Value &urls = entities["urls"];
-		if (urls.IsArray()) {
 		if (urls.IsArray()) {
 			for (rapidjson::SizeType i = 0; i < urls.Size(); i++) {
-				UrlEntity entity(urls[i]["url"].GetString(), urls[i]["expanded_url"].GetString());
 				UrlEntity entity(urls[i]["url"].GetString(), urls[i]["expanded_url"].GetString());
 				url_entities.push_back(entity);
+			}
+		}
+	}
 	return url_entities;
+}

backends/twitter/main.cpp

➞

Show inline comments

@@ @@ -39,23 +39,23 @@ int main (int argc, char* argv[]) { @@
 	Logging::initBackendLogging(cfg);
 	StorageBackend *storagebackend;
 	storagebackend = StorageBackend::createBackend(cfg, error);
 	if (storagebackend == NULL) {
 		LOG4CXX_ERROR(logger, "Error creating StorageBackend! " << error);
 		LOG4CXX_ERROR(logger, "Twitter backend needs storage backend configured to work! " << error);
 		return NetworkPlugin::StorageBackendNeeded;
+	}
 	else if (!storagebackend->connect()) {
 		LOG4CXX_ERROR(logger, "Can't connect to database!")
+		LOG4CXX_ERROR(logger, "Can't connect to database!");
 		return -1;
+	}
 	Swift::SimpleEventLoop eventLoop;
 	loop_ = &eventLoop;
 	np = new TwitterPlugin(cfg, &eventLoop, storagebackend, host, port);
 	loop_->run();
 	return 0;
+}

libtransport/HTTPRequest.cpp

➞

Show inline comments

@@ @@ -31,76 +31,76 @@ bool HTTPRequest::init() { @@
 	if (curlhandle) {
 		return true;
+	}
 	curlhandle = curl_easy_init();
 	if (curlhandle) {
 		curl_easy_setopt(curlhandle, CURLOPT_PROXY, NULL);
 		curl_easy_setopt(curlhandle, CURLOPT_PROXYUSERPWD, NULL);
 		curl_easy_setopt(curlhandle, CURLOPT_PROXYAUTH, (long)CURLAUTH_ANY);
 		return true;
+	}
 	LOG4CXX_ERROR(logger, "Couldn't Initialize curl!")
+	LOG4CXX_ERROR(logger, "Couldn't Initialize curl!");
 	return false;
+}
 void HTTPRequest::setProxy(std::string IP, std::string port, std::string username, std::string password) {
 	if (curlhandle) {
 		std::string proxyIpPort = IP + ":" + port;
 		curl_easy_setopt(curlhandle, CURLOPT_PROXY, proxyIpPort.c_str());
 		if(username.length() && password.length()) {
 			std::string proxyUserPass = username + ":" + password;
 			curl_easy_setopt(curlhandle, CURLOPT_PROXYUSERPWD, proxyUserPass.c_str());
+		}
 	} else {
 		LOG4CXX_ERROR(logger, "Trying to set proxy while CURL isn't initialized")
+		LOG4CXX_ERROR(logger, "Trying to set proxy while CURL isn't initialized");
+	}
+}
 int HTTPRequest::curlCallBack(char* data, size_t size, size_t nmemb, HTTPRequest* obj) {
 	int writtenSize = 0;
 	if (obj && data) {
 		obj->callbackdata.append(data, size*nmemb);
 		writtenSize = (int)(size*nmemb);
+	}
 	return writtenSize;
+}
 bool HTTPRequest::GET(std::string url, 	std::string &data) {
 	if (curlhandle) {
 		curl_easy_setopt(curlhandle, CURLOPT_CUSTOMREQUEST, NULL);
 		curl_easy_setopt(curlhandle, CURLOPT_ENCODING, "");
 		data = "";
 		callbackdata = "";
 		memset(curl_errorbuffer, 0, 1024);
 		curl_easy_setopt(curlhandle, CURLOPT_ERRORBUFFER, curl_errorbuffer);
 		curl_easy_setopt(curlhandle, CURLOPT_WRITEFUNCTION, curlCallBack);
 		curl_easy_setopt(curlhandle, CURLOPT_WRITEDATA, this);
 		/* Set http request and url */
 		curl_easy_setopt(curlhandle, CURLOPT_HTTPGET, 1);
 		curl_easy_setopt(curlhandle, CURLOPT_VERBOSE, 0);
 		curl_easy_setopt(curlhandle, CURLOPT_URL, url.c_str());
 		/* Send http request and return status*/
 		if(CURLE_OK == curl_easy_perform(curlhandle)) {
 			data = callbackdata;
 			return true;
+		}
 	} else {
 		LOG4CXX_ERROR(logger, "CURL not initialized!")
+		LOG4CXX_ERROR(logger, "CURL not initialized!");
 		strcpy(curl_errorbuffer, "CURL not initialized!");
+	}
 	LOG4CXX_ERROR(logger, "Error fetching " << url);
 	return false;
+}
 bool HTTPRequest::GET(std::string url, rapidjson::Document &json) {
 	if (!GET(url, m_data)) {
 		return false;
+	}
 	if(json.Parse<0>(m_data.c_str()).HasParseError()) {

libtransport/ThreadPool.cpp

➞

Show inline comments

@@ @@ -26,27 +26,27 @@ ThreadPool::~ThreadPool() @@
 			delete worker[i];
+		}
+	}
 	free(worker);
 	while(!requestQueue.empty()) {
 		Thread *t = requestQueue.front(); requestQueue.pop();
 		delete t;
+	}
+}
 int ThreadPool::getActiveThreadCount()
+{
+{
 	int res;
-	count_lock.lock();
 	count_lock.lock();
 	res = activeThreads;
 	count_lock.unlock();
 	return res;
+}
 void ThreadPool::updateActiveThreadCount(int k)
+{
 	count_lock.lock();
 	activeThreads += k;
 	count_lock.unlock();
+}
@@ @@ -62,66 +62,66 @@ int ThreadPool::getFreeThread() @@
 	pool_lock.unlock();
 	return res;
+}
 void ThreadPool::releaseThread(int i)
+{
 	if(i < 0 || i > MAX_THREADS) return;
 	pool_lock.lock();
 	delete worker[i];
 	worker[i] = NULL;
 	freeThreads.push(i);
 	updateActiveThreadCount(1);
 	pool_lock.unlock();
+}
 void ThreadPool::cleandUp(Thread *t, int wid)
+{
 	LOG4CXX_INFO(logger, "Cleaning up thread #" << t->getThreadID())
+	LOG4CXX_INFO(logger, "Cleaning up thread #" << t->getThreadID());
 	t->finalize();
 	delete t;
 	releaseThread(wid);
-	onWorkerAvailable();
 	onWorkerAvailable();
+}
 void ThreadPool::scheduleFromQueue()
+{
-	criticalregion.lock();
 	criticalregion.lock();
 	while(!requestQueue.empty()) {
 		int  w = getFreeThread();
 		if(w == -1) break;
 		LOG4CXX_INFO(logger, "Worker Available. Creating thread #" << w)
+		LOG4CXX_INFO(logger, "Worker Available. Creating thread #" << w);
 		Thread *t = requestQueue.front(); requestQueue.pop();
 		t->setThreadID(w);
 		worker[w] = new boost::thread(boost::bind(&ThreadPool::workerBody, this, _1, _2), t, w, loop);
 		updateActiveThreadCount(-1);
+	}
 	criticalregion.unlock();
+}
 void ThreadPool::runAsThread(Thread *t)
+{
 	int w;
 	if((w = getFreeThread()) != -1) {
 		LOG4CXX_INFO(logger, "Creating thread #" << w)
+		LOG4CXX_INFO(logger, "Creating thread #" << w);
 		t->setThreadID(w);
 		worker[w] = new boost::thread(boost::bind(&ThreadPool::workerBody, this, _1, _2), t, w, loop);
 		updateActiveThreadCount(-1);
+	}
 	else {
 		LOG4CXX_INFO(logger, "No workers available! adding to queue.")
+		LOG4CXX_INFO(logger, "No workers available! adding to queue.");
 		requestQueue.push(t);
+	}
+}
 void ThreadPool::workerBody(Thread *t, int wid) {
 	LOG4CXX_INFO(logger, "Starting thread " << wid)
+	LOG4CXX_INFO(logger, "Starting thread " << wid);
 	t->run();
 	loop->postEvent(boost::bind(&ThreadPool::cleandUp, this, t, wid), SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::EventOwner>());
+}
+}

libtransport/User.cpp

➞

Show inline comments

 	m_presenceOracle = component->m_presenceOracle;
 	m_userManager = userManager;
 	m_userInfo = userInfo;
 	m_connected = false;
 	m_readyForConnect = false;
 	m_ignoreDisconnect = false;
 	m_resources = 0;
 	m_reconnectCounter = 0;
 	m_reconnectLimit = 3;
 	m_storageBackend = NULL;
 	m_reconnectTimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(5000);
-	m_reconnectTimer->onTick.connect(boost::bind(&User::onConnectingTimeout, this));
 	m_reconnectTimer->onTick.connect(boost::bind(&User::onConnectingTimeout, this));
 	m_rosterManager = component->getFrontend()->createRosterManager(this, m_component);
 	m_conversationManager = new ConversationManager(this, m_component);
 	LOG4CXX_INFO(logger, m_jid.toString() << ": Created");
 	updateLastActivity();
+}
 User::~User(){
 	LOG4CXX_INFO(logger, m_jid.toString() << ": Destroying");
 // 	if (m_component->inServerMode()) {
 // #if HAVE_SWIFTEN_3
@@ @@ -171,25 +171,25 @@ void User::leaveRoom(const std::string &room) { @@
 void User::handlePresence(Swift::Presence::ref presence, bool forceJoin) {
 	LOG4CXX_INFO(logger, "PRESENCE " << presence->getFrom().toString() << " " << presence->getTo().toString());
 	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::VCardUpdate> vcardUpdate = presence->getPayload<Swift::VCardUpdate>();
 	if (vcardUpdate) {
 		std::string value = "";
 		int type = (int) TYPE_STRING;
 		if (m_storageBackend) {
 			m_storageBackend->getUserSetting(m_userInfo.id, "photohash", type, value);
+		}
 		if (value != vcardUpdate->getPhotoHash()) {
 			LOG4CXX_INFO(logger, m_jid.toString() << ": Requesting VCard")
+			LOG4CXX_INFO(logger, m_jid.toString() << ": Requesting VCard");
 			if (m_storageBackend) {
 				m_storageBackend->updateUserSetting(m_userInfo.id, "photohash", vcardUpdate->getPhotoHash());
+			}
 			requestVCard();
+		}
+	}
 	if (!m_connected) {
 		// we are not connected to legacy network, so we should do it when disco#info arrive :)
 		if (m_readyForConnect == false) {
 			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::CapsInfo> capsInfo = presence->getPayload<Swift::CapsInfo>();
 			if (capsInfo && capsInfo->getHash() == "sha-1") {

libtransport/UserManager.cpp

➞

Show inline comments

@@ @@ -25,25 +25,25 @@ @@
 #include "transport/ConversationManager.h"
 #include "transport/RosterManager.h"
 #include "transport/UserRegistry.h"
 #include "transport/Logging.h"
 #include "transport/Frontend.h"
 #include "transport/PresenceOracle.h"
 #include "transport/Config.h"
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Elements/StreamError.h"
 #include "Swiften/Elements/MUCPayload.h"
 #include "Swiften/Elements/ChatState.h"
-#ifndef __FreeBSD__
 #ifndef __FreeBSD__
 #ifndef __MACH__
 #include "malloc.h"
 #endif
 #endif
 // #include "valgrind/memcheck.h"
 namespace Transport {
 DEFINE_LOGGER(logger, "UserManager");
 UserManager::UserManager(Component *component, UserRegistry *userRegistry, StorageBackend *storageBackend) {
 	m_cachedUser = NULL;
@@ @@ -86,25 +86,25 @@ User *UserManager::getUser(const std::string &barejid){ @@
 		User *user = m_users[barejid];
 		m_cachedUser = user;
 		return user;
+	}
 	return NULL;
+}
 // Swift::DiscoInfo::ref UserManager::getCaps(const Swift::JID &jid) const {
 // 	std::map<std::string, User *>::const_iterator it = m_users.find(jid.toBare().toString());
 // 	if (it == m_users.end()) {
 // 		return Swift::DiscoInfo::ref();
 // 	}
-//
 //
 // 	User *user = it->second;
 // 	return user->getCaps(jid);
 // }
 void UserManager::removeUser(User *user, bool onUserBehalf) {
 	m_users.erase(user->getJID().toBare().toString());
 	if (m_cachedUser == user)
 		m_cachedUser = NULL;
 	if (m_component->inServerMode()) {
 		disconnectUser(user->getJID());
+	}
 	UserInfo res;
 	bool registered = m_storageBackend ? m_storageBackend->getUser(userkey, res) : false;
 	if (registered) {
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setFrom(presence->getTo().toBare());
 		response->setTo(presence->getFrom().toBare());
 		response->setType(Swift::Presence::Subscribe);
 		m_component->getFrontend()->sendPresence(response);
+	}
+}
 void UserManager::handleSubscription(Swift::Presence::ref presence) {
 	// answer to subscibe for transport itself
 	if (presence->getType() == Swift::Presence::Subscribe && presence->getTo().getNode().empty()) {
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setFrom(presence->getTo().toBare());
 		response->setTo(presence->getFrom().toBare());
 		response->setType(Swift::Presence::Subscribed);
 		m_component->getFrontend()->sendPresence(response);
 // 		response = Swift::Presence::create();
 // 		response->setFrom(presence->getTo());
 // 		response->setTo(presence->getFrom());
 // 		response->setType(Swift::Presence::Subscribe);
@@ @@ -558,25 +558,25 @@ void UserManager::connectUser(const Swift::JID &user) { @@
 				SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());
 				msg->setBody("You have signed on from another location.");
 				msg->setTo(user);
 				msg->setFrom(m_component->getJID());
 				m_component->getFrontend()->sendMessage(msg);
 				// Switch the session = accept new one, disconnect old one.
 				// Unavailable presence from old session has to be ignored, otherwise it would disconnect the user from legacy network.
 				m_userRegistry->onPasswordValid(user);
 				m_component->onUserPresenceReceived.disconnect(bind(&UserManager::handlePresence, this, _1));
 // #if HAVE_SWIFTEN_3
 // 				dynamic_cast<Swift::ServerStanzaChannel *>(m_component->getFrontend())->finishSession(user, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::ToplevelElement>(new Swift::StreamError()), true);
-// #else
 // #else
 // 				dynamic_cast<Swift::ServerStanzaChannel *>(m_component->getFrontend())->finishSession(user, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Element>(new Swift::StreamError()), true);
 // #endif
 				m_component->onUserPresenceReceived.connect(bind(&UserManager::handlePresence, this, _1));
+			}
+		}
 		else {
 			// User is created, but not connected => he's loggin in or he just logged out, but hasn't been deleted yet.
 			// Stop deletion process if there's any
 			m_removeTimer->onTick.disconnect(boost::bind(&UserManager::handleRemoveTimeout, this, user.toBare().toString(), m_users[user.toBare().toString()], false));
 			// Delete old User instance but create new one immediatelly
 			m_removeTimer->onTick.connect(boost::bind(&UserManager::handleRemoveTimeout, this, user.toBare().toString(), m_users[user.toBare().toString()], true));

spectrum/src/frontends/slack/SlackSession.cpp

➞

Show inline comments

 	presence->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 	m_component->getFrontend()->onPresenceReceived(presence);
+}
 void SlackSession::leaveRoom(const std::string &channel_) {
 	std::string channel = channel_;
 	if (channel[0] == '#') {
 		channel.erase(0, 1);
+	}
 	std::string channelId = m_idManager->getId(channel);
 	std::string to = m_channel2jid[channelId];
 	if (to.empty()) {
 		LOG4CXX_ERROR(logger, "Spectrum 2 is not configured to transport this Slack channel.")
+		LOG4CXX_ERROR(logger, "Spectrum 2 is not configured to transport this Slack channel.");
 		return;
+	}
 	LOG4CXX_INFO(logger, m_uinfo.jid << ": Leaving the legacy network room " << to);
 	Swift::Presence::ref presence = Swift::Presence::create();
 	presence->setFrom(Swift::JID(m_uinfo.jid + "/default"));
 	presence->setTo(Swift::JID(to + "/" + m_uinfo.uin));
 	presence->setType(Swift::Presence::Unavailable);
 	presence->addPayload(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 	m_component->getFrontend()->onPresenceReceived(presence);
+}

spectrum/src/frontends/xmpp/XMPPUserRegistration.cpp

➞

Show inline comments

@@ @@ -27,25 +27,25 @@ @@
 #include "transport/User.h"
 #include "transport/Logging.h"
 #include "formutils.h"
 #include "transport/Buddy.h"
 #include "transport/Config.h"
 #include "Swiften/Elements/ErrorPayload.h"
 #include "Swiften/EventLoop/SimpleEventLoop.h"
 #include "Swiften/Network/BoostNetworkFactories.h"
 #include "Swiften/Client/Client.h"
 #include <boost/shared_ptr.hpp>
 #include <boost/thread.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/regex.hpp>
 #include <boost/regex.hpp>
 #if HAVE_SWIFTEN_3
 #include <Swiften/Elements/Form.h>
 #endif
 #include "XMPPFrontend.h"
 using namespace Swift;
 namespace Transport {
 DEFINE_LOGGER(logger, "XMPPUserRegistration");
 XMPPUserRegistration::XMPPUserRegistration(Component *component, UserManager *userManager,
+}
 bool XMPPUserRegistration::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::InBandRegistrationPayload> payload) {
 	// TODO: backend should say itself if registration is needed or not...
 	if (CONFIG_STRING(m_config, "service.protocol") == "irc") {
 		sendError(from, id, ErrorPayload::BadRequest, ErrorPayload::Modify);
 		return true;
+	}
 	if (!CONFIG_BOOL(m_config,"registration.enable_public_registration")) {
 		std::vector<std::string> const &x = CONFIG_VECTOR(m_config,"service.allowed_servers");
 		if (std::find(x.begin(), x.end(), from.getDomain()) == x.end()) {
 			LOG4CXX_INFO(logger, from.toBare().toString() << ": This user has no permissions to register an account")
+			LOG4CXX_INFO(logger, from.toBare().toString() << ": This user has no permissions to register an account");
 			sendError(from, id, ErrorPayload::BadRequest, ErrorPayload::Modify);
 			return true;
+		}
+	}
 	SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<InBandRegistrationPayload> reg = generateInBandRegistrationPayload(from);
 	sendResponse(from, id, reg);
 	return true;
+}
 bool XMPPUserRegistration::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::InBandRegistrationPayload> payload) {
 	// TODO: backend should say itself if registration is needed or not...
 	if (CONFIG_STRING(m_config, "service.protocol") == "irc") {
 		sendError(from, id, ErrorPayload::BadRequest, ErrorPayload::Modify);
 		return true;
+	}
 	std::string barejid = from.toBare().toString();
 	if (!CONFIG_BOOL(m_config,"registration.enable_public_registration")) {
 		std::vector<std::string> const &x = CONFIG_VECTOR(m_config,"service.allowed_servers");
 		if (std::find(x.begin(), x.end(), from.getDomain()) == x.end()) {
 			LOG4CXX_INFO(logger, barejid << ": This user has no permissions to register an account")
+			LOG4CXX_INFO(logger, barejid << ": This user has no permissions to register an account");
 			sendError(from, id, ErrorPayload::BadRequest, ErrorPayload::Modify);
 			return true;
+		}
+	}
 	UserInfo res;
 	bool registered = m_storageBackend->getUser(barejid, res);
 	std::string encoding;
 	std::string language;
 	std::string local_username;
 	std::string local_password;
 		unregisterUser(barejid);
 		sendResponse(from, id, InBandRegistrationPayload::ref());
 		return true;
+	}
 	if (CONFIG_BOOL(m_config,"registration.require_local_account")) {
 	/*	if (!local_username || !local_password) {
 			sendResponse(from, id, InBandRegistrationPayload::ref());
 			return true
 		} else */ if (local_username == "" || local_password == "") {
 			sendResponse(from, id, InBandRegistrationPayload::ref());
 			return true;
+		}
+		}
 //		Swift::logging = true;
 		bool validLocal = false;
 		std::string localLookupServer = CONFIG_STRING(m_config, "registration.local_account_server");
 		std::string localLookupJID = local_username + std::string("@") + localLookupServer;
 		SimpleEventLoop localLookupEventLoop;
 		BoostNetworkFactories localLookupNetworkFactories(&localLookupEventLoop);
 		Client localLookupClient(localLookupJID, local_password, &localLookupNetworkFactories);
 		// TODO: this is neccessary on my server ... but should maybe omitted
 		localLookupClient.setAlwaysTrustCertificates();
 		localLookupClient.connect();
 		class SimpleLoopRunner {
 			public:
 				SimpleLoopRunner() {};
 				static void run(SimpleEventLoop * loop) {
 					loop->run();
 				};
 		};

spectrum/src/main.cpp

➞

Show inline comments

@@ @@ -60,31 +60,31 @@ static void stop_spectrum() { @@
 	eventLoop_->stop();
+}
 static void spectrum_sigint_handler(int sig) {
 	eventLoop_->postEvent(&stop_spectrum);
+}
 static void spectrum_sigterm_handler(int sig) {
 	eventLoop_->postEvent(&stop_spectrum);
+}
 #ifdef WIN32
-BOOL spectrum_control_handler( DWORD fdwCtrlType ) {
 BOOL spectrum_control_handler( DWORD fdwCtrlType ) {
 	if (fdwCtrlType == CTRL_C_EVENT || fdwCtrlType == CTRL_CLOSE_EVENT) {
 		eventLoop_->postEvent(&stop_spectrum);
 		return TRUE;
+	}
 	return FALSE;
+}
+}
 #endif
 static void removeOldIcons(std::string iconDir) {
 	std::vector<std::string> dirs;
 	dirs.push_back(iconDir);
 	boost::thread thread(boost::bind(Util::removeEverythingOlderThan, dirs, time(NULL) - 3600*24*14));
+}
 #ifndef WIN32
 static void daemonize(const char *cwd, const char *lock_file) {
 	pid_t pid, sid;
 	/* Create a new SID for the child process */
 	sid = setsid();
 	if (sid < 0) {
 		exit(1);
+	}
 	/* Change the current working directory.  This prevents the current
 		directory from being locked; hence not being able to remove it. */
 	if ((chdir(cwd)) < 0) {
 		exit(1);
+	}
 	if (freopen( "/dev/null", "r", stdin) == NULL) {
 		std::cout << "EE cannot open /dev/null. Exiting\n";
 		exit(1);
+	}
+}
 #endif
 static void _createDirectories(Transport::Config *config, boost::filesystem::path ph) {
 	if (ph.empty() || exists(ph)) {
 		return;
+	}
 	// First create branch, by calling ourself recursively
 	_createDirectories(config, ph.branch_path());
 	// Now that parent's path exists, create the directory
 	boost::filesystem::create_directory(ph);
 #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";
@@ @@ -208,27 +208,27 @@ int mainloop() { @@
 	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);
 	Frontend *frontend = NULL;
 	std::string frontend_name = CONFIG_STRING_DEFAULTED(config_, "service.frontend", "xmpp");
 	std::string plugin_fc = "create_" + frontend_name + "_frontend_plugin";
 	dll::shared_library self(dll::program_location());
 	boost::function<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<FrontendPlugin>()> creator;
 	try {
 		creator = self.get_alias<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<FrontendPlugin>()>(plugin_fc);
 	} catch(boost::system::system_error& e) {
 		LOG4CXX_ERROR(logger, "Error when loading frontend " << e.what());
 		return -3;
+	}
@@ @@ -302,66 +302,66 @@ int main(int argc, char **argv) @@
+{
 	Config config(argc, argv);
 	config_ = &config;
 	boost::program_options::variables_map vm;
 	bool no_daemon = false;
 	std::string config_file;
 	std::string jid;
 #ifdef WIN32
 	std::string install_service_name, uninstall_service_name, run_service_name;
 	// determine the name of the currently executing file
 	char szFilePath[MAX_PATH];
 	GetModuleFileNameA(NULL, szFilePath, sizeof(szFilePath));
 	std::string exe_file(szFilePath);
 #endif
 	std::string exe_file(szFilePath);
 #endif
 	setlocale(LC_ALL, "");
 #ifndef WIN32
 #ifndef __FreeBSD__
 #ifndef __MACH__
 	mallopt(M_CHECK_ACTION, 2);
 	mallopt(M_PERTURB, 0xb);
 #endif
 #endif
 #endif
 #ifndef WIN32
 	if (signal(SIGINT, spectrum_sigint_handler) == SIG_ERR) {
 		std::cout << "SIGINT handler can't be set\n";
 		return -1;
+	}
 	if (signal(SIGTERM, spectrum_sigterm_handler) == SIG_ERR) {
 		std::cout << "SIGTERM handler can't be set\n";
 		return -1;
+	}
 #else
 	if( !SetConsoleCtrlHandler( (PHANDLER_ROUTINE) spectrum_control_handler, TRUE ) )
+	{
 	if( !SetConsoleCtrlHandler( (PHANDLER_ROUTINE) spectrum_control_handler, TRUE ) )
+	{
 		std::cout << "control handler can't be set\n";
 		return -1;
+	}
+	}
 #endif
 	boost::program_options::options_description desc(std::string("Spectrum version: ") + SPECTRUM_VERSION + "\nUsage: spectrum [OPTIONS] <config_file.cfg>\nAllowed options");
 	desc.add_options()
 		("help,h", "help")
 		("no-daemonize,n", "Do not run spectrum as daemon")
 		("no-debug,d", "Create coredumps on crash")
 		("jid,j", boost::program_options::value<std::string>(&jid)->default_value(""), "Specify JID of transport manually")
 		("config", boost::program_options::value<std::string>(&config_file)->default_value(""), "Config file")
 		("version,v", "Shows Spectrum version")
+		;
 #ifdef WIN32
- 	desc.add_options()
 	desc.add_options()
 		("install-service,i", boost::program_options::value<std::string>(&install_service_name)->default_value(""), "Install spectrum as Windows service")
- 		("uninstall-service,u", boost::program_options::value<std::string>(&uninstall_service_name)->default_value(""), "Uninstall Windows service")
 		("uninstall-service,u", boost::program_options::value<std::string>(&uninstall_service_name)->default_value(""), "Uninstall Windows service")
 		("run-as-service,r", boost::program_options::value<std::string>(&run_service_name)->default_value(""), "stub for Windows Service Manager");
 #endif
 	try
+	{
 		boost::program_options::positional_options_description p;
 		p.add("config", -1);
 		boost::program_options::store(boost::program_options::command_line_parser(argc, argv).
           options(desc).positional(p).allow_unregistered().run(), vm);
 		boost::program_options::notify(vm);
 		if (vm.count("version")) {
 			std::cout << SPECTRUM_VERSION << "\n";
@@ @@ -373,59 +373,59 @@ int main(int argc, char **argv) @@
 			std::cout << desc << "\n";
 			return 1;
+		}
 		if(vm.count("config") == 0) {
 			std::cout << desc << "\n";
 			return 1;
+		}
 		if(vm.count("no-daemonize")) {
 			no_daemon = true;
+		}
 #ifdef WIN32
 		if (!install_service_name.empty()) {
 #ifdef WIN32
 		if (!install_service_name.empty()) {
 			// build command line for Service Manager
 			std::string service_path = exe_file + std::string(" --config ") + vm["config"].as<std::string>()
 						+ std::string(" --run-as-service ") + install_service_name;
 			std::string service_path = exe_file + std::string(" --config ") + vm["config"].as<std::string>()
 						+ std::string(" --run-as-service ") + install_service_name;
 			ServiceWrapper ntservice((char *)install_service_name.c_str());
 			if (!ntservice.IsInstalled()) {
 				if (ntservice.Install((char *)service_path.c_str())) {
 					std::cout << "Successfully installed " << install_service_name << std::endl;
 					return 0;
 				} else {
 					std::cout << "Error installing service, are you an Administrator?" << std::endl;
 					return 1;
+				}
+				}
 			} else {
 				std::cout << "Already installed " << install_service_name << std::endl;
 				return 1;
+			}
+		}
 		if (!uninstall_service_name.empty()) {
 			ServiceWrapper ntservice((char *)uninstall_service_name.c_str());
 			if (ntservice.IsInstalled()) {
 				if (ntservice.UnInstall()) {
 					std::cout << "Successfully removed " << uninstall_service_name << std::endl;
 					return 0;
 				} else {
 					std::cout << "Error removing service, are you an Administrator?" << std::endl;
 					return 1;
+				}
+				}
 			} else {
 				std::cout << "Service not installed: " << uninstall_service_name << std::endl;
 				return 1;
+			}
+		}
+		}
 #endif
+	}
 	catch (std::runtime_error& e)
+	{
 		std::cout << desc << "\n";
 		return 1;
+	}
 	catch (...)
+	{
 		std::cout << desc << "\n";
 		return 1;
+	}
@@ @@ -479,25 +479,25 @@ int main(int argc, char **argv) @@
 		exit(1);
+	}
 	sprintf(backendport,"%s\n",CONFIG_STRING(&config, "service.backend_port").c_str());
 	if (fwrite(backendport,1,strlen(backendport),port_file_f) < strlen(backendport)) {
 		std::cerr << "Cannot write to port file " << CONFIG_STRING(&config, "service.portfile") << ". Exiting\n";
 		exit(1);
+	}
 	fclose(port_file_f);
 	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");
 //		removeOldIcons(CONFIG_STRING(&config, "service.working_dir") + "/icons");
+	}
 	else {
 		if ((chdir(CONFIG_STRING(&config, "service.working_dir").c_str())) < 0) {
 			std::cerr << "Cannot change directory to " << CONFIG_STRING(&config, "service.working_dir") << "\n";
 			exit(1);
+		}
+	}
 #endif
 #ifdef WIN32
 	if (!run_service_name.empty()) {
 		ServiceWrapper ntservice((char *)run_service_name.c_str());
 		if (ntservice.IsInstalled()) {

0 comments (0 inline, 0 general)