libtransport.git Changeset - d54aac14c8f0

Changeset - d54aac14c8f0

Parent rev.

Child rev.

[Not reviewed]

node-cache

0 1 0

HanzZ - 13 years ago 2013-01-25 17:55:52
hanzz.k@gmail.com

Cache nodes in libpurple backend

1 file changed with 60 insertions and 2 deletions:

backends/libpurple/main.cpp

0 comments (0 inline, 0 general)

backends/libpurple/main.cpp

➞

Show inline comments

@@ @@ -45,96 +45,104 @@ int main_socket; @@
 static int writeInput;
 using namespace Transport;
 template <class T> T fromString(const std::string &str) {
 	T i;
 	std::istringstream os(str);
 	os >> i;
 	return i;
+}
 template <class T> std::string stringOf(T object) {
 	std::ostringstream os;
 	os << object;
 	return (os.str());
+}
 static std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
     std::stringstream ss(s);
     std::string item;
     while(std::getline(ss, item, delim)) {
         elems.push_back(item);
+    }
     return elems;
+}
 static std::vector<std::string> split(const std::string &s, char delim) {
     std::vector<std::string> elems;
     return split(s, delim, elems);
+}
 static void transportDataReceived(gpointer data, gint source, PurpleInputCondition cond);
 class SpectrumNetworkPlugin;
 boost::shared_ptr<Config> config;
 SpectrumNetworkPlugin *np;
 static std::string host;
 static int port = 10000;
 struct FTData {
 	unsigned long id;
 	unsigned long timer;
 	bool paused;
 };
 struct NodeCache {
 	PurpleAccount *account;
 	std::map<PurpleBlistNode *, int> nodes;
 	int timer;
 };
 bool caching = true;
 static void *notify_user_info(PurpleConnection *gc, const char *who, PurpleNotifyUserInfo *user_info);
 static gboolean ft_ui_ready(void *data) {
 	PurpleXfer *xfer = (PurpleXfer *) data;
 	FTData *ftdata = (FTData *) xfer->ui_data;
 	ftdata->timer = 0;
 	purple_xfer_ui_ready_wrapped((PurpleXfer *) data);
 	return FALSE;
+}
 struct authRequest {
 	PurpleAccountRequestAuthorizationCb authorize_cb;
 	PurpleAccountRequestAuthorizationCb deny_cb;
 	void *user_data;
 	std::string who;
 	PurpleAccount *account;
 	std::string mainJID;	// JID of user connected with this request
 };
 static void * requestInput(const char *title, const char *primary,const char *secondary, const char *default_value, gboolean multiline, gboolean masked, gchar *hint,const char *ok_text, GCallback ok_cb,const char *cancel_text, GCallback cancel_cb, PurpleAccount *account, const char *who,PurpleConversation *conv, void *user_data) {
 	if (primary) {
 		std::string primaryString(primary);
 		if (primaryString == "Authorization Request Message:") {
 			LOG4CXX_INFO(logger, "Authorization Request Message: calling ok_cb(...)");
 			((PurpleRequestInputCb) ok_cb)(user_data, "Please authorize me.");
 			return NULL;
+		}
 		else if (primaryString == "Authorization Request Message:") {
 			LOG4CXX_INFO(logger, "Authorization Request Message: calling ok_cb(...)");
 			((PurpleRequestInputCb) ok_cb)(user_data, "Please authorize me.");
 			return NULL;
+		}
 		else if (primaryString == "Authorization Denied Message:") {
 			LOG4CXX_INFO(logger, "Authorization Deined Message: calling ok_cb(...)");
 			((PurpleRequestInputCb) ok_cb)(user_data, "Authorization denied.");
 			return NULL;
+		}
 		else {
 			LOG4CXX_WARN(logger, "Unhandled request input. primary=" << primaryString);
+		}
+	}
 	else if (title) {
 		std::string titleString(title);
 		if (titleString == "Xfire Invitation Message") {
 			LOG4CXX_INFO(logger, "Authorization Request Message: calling ok_cb(...)");
 			((PurpleRequestInputCb) ok_cb)(user_data, "Please authorize me.");
 			return NULL;
+		}
@@ @@ -311,96 +319,102 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
+			}
 			if (purple_accounts_find_wrapped(name.c_str(), protocol.c_str()) != NULL) {
 				account = purple_accounts_find_wrapped(name.c_str(), protocol.c_str());
 				if (m_accounts.find(account) != m_accounts.end() && m_accounts[account] != user) {
 					LOG4CXX_INFO(logger, "Account '" << name << "' is already used by '" << m_accounts[account] << "'");
 					np->handleDisconnected(user, 0, "Account '" + name + "' is already used by '" + m_accounts[account] + "'");
 					return;
+				}
 				LOG4CXX_INFO(logger, "Using previously created account with name '" << name.c_str() << "' and protocol '" << protocol << "'");
+			}
 			else {
 				LOG4CXX_INFO(logger, "Creating account with name '" << name.c_str() << "' and protocol '" << protocol << "'");
 				account = purple_account_new_wrapped(name.c_str(), protocol.c_str());
 				purple_accounts_add_wrapped(account);
+			}
 			m_sessions[user] = account;
 			m_accounts[account] = user;
 			// Default avatar
 			setDefaultAvatar(account, legacyName);
 			purple_account_set_password_wrapped(account, password.c_str());
 			purple_account_set_bool_wrapped(account, "custom_smileys", FALSE);
 			purple_account_set_bool_wrapped(account, "direct_connect", FALSE);
 			setDefaultAccountOptions(account);
 			// Enable account + privacy lists
 			purple_account_set_enabled_wrapped(account, "spectrum", TRUE);
 #if PURPLE_MAJOR_VERSION >= 2 && PURPLE_MINOR_VERSION >= 7
 			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);
+			}
+		}
 		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;
+				}
 				if (purple_account_get_int_wrapped(account, "version", 0) != 0) {
 					std::string data = stringOf(purple_account_get_int_wrapped(account, "version", 0));
 					g_file_set_contents ("gfire.cfg", data.c_str(), data.size(), NULL);
+				}
 // 				VALGRIND_DO_LEAK_CHECK;
 				m_sessions.erase(user);
 				purple_account_disconnect_wrapped(account);
 				purple_account_set_enabled_wrapped(account, "spectrum", FALSE);
 				m_accounts.erase(account);
 				purple_accounts_delete_wrapped(account);
 #ifndef WIN32
 #ifndef __FreeBSD__
 				malloc_trim(0);
 #endif
 #endif
 // 				VALGRIND_DO_LEAK_CHECK;
+			}
+		}
 		void handleStatusChangeRequest(const std::string &user, int status, const std::string &statusMessage) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				int st;
 				switch(status) {
 					case pbnetwork::STATUS_AWAY: {
 						st = PURPLE_STATUS_AWAY;
 						if (!purple_account_get_status_type_with_primitive_wrapped(account, PURPLE_STATUS_AWAY))
 							st = PURPLE_STATUS_EXTENDED_AWAY;
 						else
 							st = PURPLE_STATUS_AWAY;
 						break;
+					}
 					case pbnetwork::STATUS_DND: {
 						st = PURPLE_STATUS_UNAVAILABLE;
 						break;
+					}
 					case pbnetwork::STATUS_XA: {
 						if (!purple_account_get_status_type_with_primitive_wrapped(account, PURPLE_STATUS_EXTENDED_AWAY))
 							st = PURPLE_STATUS_AWAY;
 						else
 							st = PURPLE_STATUS_EXTENDED_AWAY;
 						break;
+					}
 					case pbnetwork::STATUS_NONE: {
 						st = PURPLE_STATUS_OFFLINE;
 						break;
@@ @@ -760,178 +774,222 @@ static std::string getIconHash(PurpleBuddy *m_buddy) { @@
+	}
 	if (avatarHash) {
 		// Check if it's patched libpurple which saves icons to directories
 		char *hash = strrchr(avatarHash,'/');
 		std::string h;
 		if (hash) {
 			char *dot;
 			hash++;
 			dot = strchr(hash, '.');
 			if (dot)
 				*dot = '\0';
 			std::string ret(hash);
 			g_free(avatarHash);
 			return ret;
+		}
 		else {
 			std::string ret(avatarHash);
 			g_free(avatarHash);
 			return ret;
+		}
+	}
 	return "";
+}
 static std::vector<std::string> getGroups(PurpleBuddy *m_buddy) {
 	std::vector<std::string> groups;
 	if (purple_buddy_get_name_wrapped(m_buddy)) {
 		GSList *buddies = purple_find_buddies_wrapped(purple_buddy_get_account_wrapped(m_buddy), purple_buddy_get_name_wrapped(m_buddy));
 		while(buddies) {
 			PurpleGroup *g = purple_buddy_get_group_wrapped((PurpleBuddy *) buddies->data);
 			buddies = g_slist_delete_link(buddies, buddies);
 			if(g && purple_group_get_name_wrapped(g)) {
 				groups.push_back(purple_group_get_name_wrapped(g));
+			}
+		}
+	}
 	if (groups.empty()) {
 		groups.push_back("Buddies");
+	}
 	return groups;
+}
 static void buddyListNewNode(PurpleBlistNode *node) {
 void buddyListNewNode(PurpleBlistNode *node);
 static gboolean new_node_cache(void *data) {
 	NodeCache *cache = (NodeCache *) data;
 	caching = false;
 	for (std::map<PurpleBlistNode *, int>::const_iterator it = cache->nodes.begin(); it != cache->nodes.end(); it++) {
 		buddyListNewNode(it->first);
+	}
 	caching = true;
 	cache->account->ui_data = NULL;
 	delete cache;
 	return FALSE;
+}
 static void buddyNodeRemoved(PurpleBuddyList *list, PurpleBlistNode *node) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY_WRAPPED(node))
 		return;
 	PurpleBuddy *buddy = (PurpleBuddy *) node;
 	PurpleAccount *account = purple_buddy_get_account_wrapped(buddy);
 	if (!account->ui_data) {
 		return;
+	}
 	NodeCache *cache = (NodeCache *) account->ui_data;
 	cache->nodes.erase(node);
+}
 void buddyListNewNode(PurpleBlistNode *node) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY_WRAPPED(node))
 		return;
 	PurpleBuddy *buddy = (PurpleBuddy *) node;
 	PurpleAccount *account = purple_buddy_get_account_wrapped(buddy);
 	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);
 	bool blocked = false;
 	if (CONFIG_BOOL(config, "service.enable_privacy_lists")) {
 		if (prpl_info && prpl_info->tooltip_text) {
 			PurpleNotifyUserInfo *user_info = purple_notify_user_info_new_wrapped();
 			prpl_info->tooltip_text(buddy, user_info, true);
 			GList *entries = purple_notify_user_info_get_entries_wrapped(user_info);
 			while (entries) {
 				PurpleNotifyUserInfoEntry *entry = (PurpleNotifyUserInfoEntry *)(entries->data);
 				if (purple_notify_user_info_entry_get_label_wrapped(entry) && purple_notify_user_info_entry_get_value_wrapped(entry)) {
 					std::string label = purple_notify_user_info_entry_get_label_wrapped(entry);
 					if (label == "Blocked" ) {
 						if (std::string(purple_notify_user_info_entry_get_value_wrapped(entry)) == "Yes") {
 							blocked = true;
 							break;
+						}
+					}
+				}
 				entries = entries->next;
+			}
 			purple_notify_user_info_destroy_wrapped(user_info);
+		}
 		if (!blocked) {
 			blocked = purple_privacy_check_wrapped(account, purple_buddy_get_name_wrapped(buddy)) == false;
+		}
 		else {
 			bool purpleBlocked = purple_privacy_check_wrapped(account, purple_buddy_get_name_wrapped(buddy)) == false;
 			if (blocked != purpleBlocked) {
 				purple_privacy_deny_wrapped(account, purple_buddy_get_name_wrapped(buddy), FALSE, FALSE);
+			}
+		}
+	}
 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name_wrapped(buddy), getAlias(buddy), getGroups(buddy), status, message, getIconHash(buddy),
 		blocked
 	);
+}
 static void buddyListUpdate(PurpleBuddyList *list, PurpleBlistNode *node) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY_WRAPPED(node))
 		return;
 	buddyListNewNode(node);
+}
 static void buddyPrivacyChanged(PurpleBlistNode *node, void *data) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY_WRAPPED(node))
 		return;
 	buddyListUpdate(NULL, node);
+}
 static void NodeRemoved(PurpleBlistNode *node, void *data) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY_WRAPPED(node))
 		return;
 // 	PurpleBuddy *buddy = (PurpleBuddy *) node;
+}
 static PurpleBlistUiOps blistUiOps =
+{
 	NULL,
 	buddyListNewNode,
 	NULL,
 	buddyListUpdate,
-	NULL, //NodeRemoved,
+	buddyNodeRemoved,
 	NULL,
 	NULL,
 	NULL, // buddyListAddBuddy,
 	NULL,
 	NULL,
 	NULL, //buddyListSaveNode,
 	NULL, //buddyListRemoveNode,
 	NULL, //buddyListSaveAccount,
 	NULL
 };
 static void conv_write_im(PurpleConversation *conv, const char *who, const char *msg, PurpleMessageFlags flags, time_t mtime) {
 	// Don't forwards our own messages.
 	if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_IM && (flags & PURPLE_MESSAGE_SEND || flags & PURPLE_MESSAGE_SYSTEM)) {
 		return;
+	}
 	PurpleAccount *account = purple_conversation_get_account_wrapped(conv);
 // 	char *striped = purple_markup_strip_html_wrapped(message);
 // 	std::string msg = striped;
 // 	g_free(striped);
 	// Escape HTML characters.
 	char *newline = purple_strdup_withhtml_wrapped(msg);
 	char *strip, *xhtml;
 	purple_markup_html_to_xhtml_wrapped(newline, &xhtml, &strip);
 // 	xhtml_linkified = spectrum_markup_linkify(xhtml);
 	std::string message_(strip);
 	std::string xhtml_(xhtml);
 	g_free(newline);
 	g_free(xhtml);
 // 	g_free(xhtml_linkified);
 	g_free(strip);
 	// AIM and XMPP adds <body>...</body> here...
 	if (xhtml_.find("<body>") == 0) {
 		xhtml_ = xhtml_.substr(6);
 		if (xhtml_.find("</body>") != std::string::npos) {
 			xhtml_ = xhtml_.substr(0, xhtml_.find("</body>"));
+		}
+	}
 	if (xhtml_ == message_) {
 		xhtml_ = "";
+	}

0 comments (0 inline, 0 general)