libtransport.git Changeset - 8fa4354942ee

Changeset - 8fa4354942ee

Parent rev.

Child rev.

[Not reviewed]

0 1 0

HanzZ - 14 years ago 2011-09-20 15:05:29
hanzz.k@gmail.com

little refactorization of libpurple backend

1 file changed with 50 insertions and 142 deletions:

backends/libpurple/main.cpp

142

0 comments (0 inline, 0 general)

backends/libpurple/main.cpp

➞

Show inline comments

@@ @@ -76,529 +76,467 @@ static GHashTable *spectrum_ui_get_info(void) @@
 		 * This is the client key for "Pidgin."  It is owned by the AIM
 		 * account "markdoliner."  Please don't use this key for other
 		 * applications.  You can either not specify a client key, in
 		 * which case the default "libpurple" key will be used, or you
 		 * can register for your own client key at
 		 * http://developer.aim.com/manageKeys.jsp
 		 */
 		g_hash_table_insert(ui_info, g_strdup("prpl-aim-clientkey"), g_strdup("ma1cSASNCKFtrdv9"));
 		g_hash_table_insert(ui_info, g_strdup("prpl-icq-clientkey"), g_strdup("ma1cSASNCKFtrdv9"));
 		/*
 		 * This is the distid for Pidgin, given to us by AOL.  Please
 		 * don't use this for other applications.  You can just not
 		 * specify a distid and libpurple will use a default.
 		 */
 		g_hash_table_insert(ui_info, g_strdup("prpl-aim-distid"), GINT_TO_POINTER(1550));
 		g_hash_table_insert(ui_info, g_strdup("prpl-icq-distid"), GINT_TO_POINTER(1550));
+	}
 	return ui_info;
+}
 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 {
 			LOG4CXX_WARN(logger, "Unhandled request input. primary=" << primaryString);
+		}
+	}
 	else {
 		LOG4CXX_WARN(logger, "Request input without primary string");
+	}
 	return NULL;
+}
 static void *requestAction(const char *title, const char *primary, const char *secondary, int default_action, PurpleAccount *account, const char *who,PurpleConversation *conv, void *user_data, size_t action_count, va_list actions){
 	std::string t(title ? title : "NULL");
 	if (t == "SSL Certificate Verification") {
 		LOG4CXX_INFO(logger,  "accepting SSL certificate");
 		va_arg(actions, char *);
 		((PurpleRequestActionCb) va_arg(actions, GCallback)) (user_data, 2);
+	}
 	else {
 		if (title) {
 			std::string headerString(title);
 			LOG4CXX_INFO(logger,  "header string: " << headerString);
 			if (headerString == "SSL Certificate Verification") {
 				va_arg(actions, char *);
 				((PurpleRequestActionCb) va_arg(actions, GCallback)) (user_data, 2);
+			}
+		}
+	}
 	return NULL;
+}
 static std::string getAlias(PurpleBuddy *m_buddy) {
 	std::string alias;
 	PurpleContact *contact = PURPLE_CONTACT(PURPLE_BLIST_NODE(m_buddy)->parent);
 	if (contact && contact->alias) {
 		alias = contact->alias;
+	}
 	else if (purple_buddy_get_alias(m_buddy)) {
 		alias = (std::string) purple_buddy_get_alias(m_buddy);
+	}
 	else {
 		alias = (std::string) purple_buddy_get_server_alias(m_buddy);
+	}
 	return alias;
+}
 class SpectrumNetworkPlugin : public NetworkPlugin {
 	public:
 		SpectrumEventLoop *m_loop;
 		SpectrumNetworkPlugin(Config *config, SpectrumEventLoop *loop, const std::string &host, int port) : NetworkPlugin(loop, host, port) {
 			this->config = config;
 			m_loop = loop;
+		}
 		void handleExit() {
 			m_loop->stop();
+		}
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 			PurpleAccount *account = NULL;
 			std::string name = legacyName;
 			std::string protocol = CONFIG_STRING(config, "service.protocol");
 			if (CONFIG_STRING(config, "service.protocol") == "any") {
 		void getProtocolAndName(const std::string &legacyName, std::string &name, std::string &protocol) {
 			name = legacyName;
 			protocol = CONFIG_STRING(config, "service.protocol");
 			if (protocol == "any") {
 				protocol = name.substr(0, name.find("."));
 				name = name.substr(name.find(".") + 1);
+			}
 			if (password.empty()) {
 				np->handleDisconnected(user, 0, "Empty password.");
 				return;
+			}
 			if (!purple_find_prpl(protocol.c_str())) {
 				np->handleDisconnected(user, 0, "Invalid protocol " + protocol);
 				return;
+			}
 			LOG4CXX_INFO(logger,  "Creating account with name '" << name.c_str() << "' and protocol '" << protocol << "'");
 			if (purple_accounts_find(name.c_str(), protocol.c_str()) != NULL){
 // 				Log(user, "this account already exists");
 				account = purple_accounts_find(name.c_str(), protocol.c_str());
 // 				User *u = (User *) account->ui_data;
 // 				if (u && u != user) {
 // 					Log(userInfo.jid, "This account is already connected by another jid " << user->getJID());
 // 					return;
 // 				}
+		}
 			else {
 // 				Log(user, "creating new account");
 				account = purple_account_new(name.c_str(), protocol.c_str());
 				purple_accounts_add(account);
+			}
 			m_sessions[user] = account;
 			m_accounts[account] = user;
-			// Default avatar
+		void setDefaultAvatar(PurpleAccount *account, const std::string &legacyName) {
 			char* contents;
 			gsize length;
 			gboolean ret = false;
 			if (!CONFIG_STRING(config, "backend.avatars_directory").empty()) {
 				std::string f = CONFIG_STRING(config, "backend.avatars_directory") + "/" + legacyName;
 				ret = g_file_get_contents (f.c_str(), &contents, &length, NULL);
+			}
 			if (!CONFIG_STRING(config, "backend.default_avatar").empty() && !ret) {
 				ret = g_file_get_contents (CONFIG_STRING(config, "backend.default_avatar").c_str(),
 											&contents, &length, NULL);
+			}
 			if (ret) {
 				purple_buddy_icons_set_account_icon(account, (guchar *) contents, length);
+			}
+		}
 			purple_account_set_password(account, password.c_str());
 			purple_account_set_bool(account, "custom_smileys", FALSE);
 			purple_account_set_bool(account, "direct_connect", FALSE);
 		void setDefaultAccountOptions(PurpleAccount *account) {
 			for (std::map<std::string,std::string>::const_iterator it = config->getUnregistered().begin();
 				it != config->getUnregistered().end(); it++) {
 				if ((*it).first.find("purple.") == 0) {
 					std::string key = (*it).first.substr((*it).first.find(".") + 1);
-					PurplePlugin *plugin = purple_find_prpl(protocol.c_str());
+					PurplePlugin *plugin = purple_find_prpl(purple_account_get_protocol_id(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(option);
 						std::string key2(purple_account_option_get_setting(option));
 						std::cout << key << " " << key2 << " " << (*it).second << "\n";
 						if (key != key2)
 							continue;
 						found = true;
 						switch (type) {
 							case PURPLE_PREF_BOOLEAN:
 								purple_account_set_bool(account, key.c_str(), boost::lexical_cast<bool>((*it).second));
 								break;
 							case PURPLE_PREF_INT:
 								std::cout << "setting int\n";
 								purple_account_set_int(account, key.c_str(), boost::lexical_cast<int>((*it).second));
 								break;
 							case PURPLE_PREF_STRING:
 							case PURPLE_PREF_STRING_LIST:
 								purple_account_set_string(account, key.c_str(), (*it).second.c_str());
 								break;
 							default:
 								continue;
+						}
 						break;
+					}
 					if (!found) {
 						std::cout << "setting string\n";
 						purple_account_set_string(account, key.c_str(), (*it).second.c_str());
+					}
+				}
+			}
+		}
 			purple_account_set_enabled(account, "spectrum", TRUE);
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 			PurpleAccount *account = NULL;
 			std::string name;
 			std::string protocol;
 			getProtocolAndName(legacyName, name, protocol);
 			if (password.empty()) {
 				np->handleDisconnected(user, 0, "Empty password.");
 				return;
+			}
 			if (!purple_find_prpl(protocol.c_str())) {
 				np->handleDisconnected(user, 0, "Invalid protocol " + protocol);
 				return;
+			}
 			LOG4CXX_INFO(logger,  "Creating account with name '" << name.c_str() << "' and protocol '" << protocol << "'");
 			if (purple_accounts_find(name.c_str(), protocol.c_str()) != NULL){
 				account = purple_accounts_find(name.c_str(), protocol.c_str());
+			}
 			else {
 				account = purple_account_new(name.c_str(), protocol.c_str());
 				purple_accounts_add(account);
+			}
 			m_sessions[user] = account;
 			m_accounts[account] = user;
 			// Default avatar
 			setDefaultAvatar(account, legacyName);
 			purple_account_set_password(account, password.c_str());
 			purple_account_set_bool(account, "custom_smileys", FALSE);
 			purple_account_set_bool(account, "direct_connect", FALSE);
 			setDefaultAccountOptions(account);
 			purple_account_set_enabled(account, "spectrum", TRUE);
 			purple_account_set_privacy_type(account, PURPLE_PRIVACY_DENY_USERS);
 			const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AVAILABLE);
 			if (status_type != NULL) {
 				purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, NULL);
+			}
+		}
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 // 				VALGRIND_DO_LEAK_CHECK;
 				m_sessions.erase(user);
 				purple_account_disconnect(account);
 				purple_account_set_enabled(account, "spectrum", FALSE);
 				// Remove conversations.
 				// This has to be called before m_account->ui_data = NULL;, because it uses
 				// ui_data to call SpectrumMessageHandler::purpleConversationDestroyed() callback.
 				GList *iter;
 				for (iter = purple_get_conversations(); iter; ) {
 					PurpleConversation *conv = (PurpleConversation*) iter->data;
 					iter = iter->next;
 					if (purple_conversation_get_account(conv) == account)
 						purple_conversation_destroy(conv);
+				}
 				g_free(account->ui_data);
 				account->ui_data = NULL;
 				m_accounts.erase(account);
 				purple_notify_close_with_handle(account);
 				purple_request_close_with_handle(account);
 				purple_accounts_remove(account);
 				GSList *buddies = purple_find_buddies(account, NULL);
 				while(buddies) {
 					PurpleBuddy *b = (PurpleBuddy *) buddies->data;
 					purple_blist_remove_buddy(b);
 					buddies = g_slist_delete_link(buddies, buddies);
+				}
 				/* Remove any open conversation for this account */
 				for (GList *it = purple_get_conversations(); it; ) {
 					PurpleConversation *conv = (PurpleConversation *) it->data;
 					it = it->next;
 					if (purple_conversation_get_account(conv) == account)
 						purple_conversation_destroy(conv);
+				}
 				/* Remove this account's pounces */
 					// purple_pounce_destroy_all_by_account(account);
 				/* This will cause the deletion of an old buddy icon. */
 				purple_buddy_icons_set_account_icon(account, NULL, 0);
 				purple_account_destroy(account);
 				// force returning of memory chunks allocated by libxml2 to kernel
 				malloc_trim(0);
 // 				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 Swift::StatusShow::Away: {
 						st = PURPLE_STATUS_AWAY;
 						if (!purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AWAY))
 							st = PURPLE_STATUS_EXTENDED_AWAY;
 						else
 							st = PURPLE_STATUS_AWAY;
 						break;
+					}
 					case Swift::StatusShow::DND: {
 						st = PURPLE_STATUS_UNAVAILABLE;
 						break;
+					}
 					case Swift::StatusShow::XA: {
 						if (!purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_EXTENDED_AWAY))
 							st = PURPLE_STATUS_AWAY;
 						else
 							st = PURPLE_STATUS_EXTENDED_AWAY;
 						break;
+					}
 					case Swift::StatusShow::None: {
 						st = PURPLE_STATUS_OFFLINE;
 						break;
+					}
 					case 255:
 						st = PURPLE_STATUS_INVISIBLE;
 						break;
 					default:
 						st = PURPLE_STATUS_AVAILABLE;
 						break;
+				}
 				gchar *_markup = purple_markup_escape_text(statusMessage.c_str(), -1);
 				std::string markup(_markup);
 				g_free(_markup);
 				// we are already connected so we have to change status
 				const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive(account, (PurpleStatusPrimitive) st);
 				if (status_type != NULL) {
 					// send presence to legacy network
 					if (!markup.empty()) {
 						purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, "message", markup.c_str(), NULL);
+					}
 					else {
 						purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, NULL);
+					}
+				}
+			}
+		}
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, legacyName.c_str(), account);
 				if (!conv) {
 					conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, legacyName.c_str());
+				}
 				if (xhtml.empty()) {
 					gchar *_markup = purple_markup_escape_text(message.c_str(), -1);
 					purple_conv_im_send(PURPLE_CONV_IM(conv), _markup);
 					g_free(_markup);
+				}
 				else {
 					purple_conv_im_send(PURPLE_CONV_IM(conv), xhtml.c_str());
+				}
+			}
+		}
 		void handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				std::string name = legacyName;
 				if (CONFIG_STRING(config, "service.protocol") == "any" && legacyName.find("prpl-") == 0) {
 					name = name.substr(name.find(".") + 1);
+				}
 				m_vcards[user + name] = id;
 				std::cout << name << " " << purple_account_get_username(account) << "\n";
 				if (CONFIG_BOOL(config, "backend.no_vcard_fetch") && name != purple_account_get_username(account)) {
 					PurpleNotifyUserInfo *user_info = purple_notify_user_info_new();
 					notify_user_info(purple_account_get_connection(account), name.c_str(), user_info);
 					purple_notify_user_info_destroy(user_info);
+				}
 				else {
 					serv_get_info(purple_account_get_connection(account), name.c_str());
+				}
+			}
+		}
-		void handleVCardUpdatedRequest(const std::string &user, const std::string &p) {
+		void handleVCardUpdatedRequest(const std::string &user, const std::string &image) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
-				gssize size = p.size();
+				gssize size = image.size();
 				// this will be freed by libpurple
 				guchar *photo = (guchar *) g_malloc(size * sizeof(guchar));
 				memcpy(photo, p.c_str(), size);
 #ifdef WITH_IMAGEMAGICK
 				if (size != 0) {
 					PurplePlugin *plugin = purple_find_prpl(Transport::instance()->protocol()->protocol().c_str());
 					PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(plugin);
 					if (prpl_info->icon_spec.format == NULL) {
 						g_free(photo);
 						return;
+					}
 					try {
 						Magick::Blob blob(photo, size);
 						g_free(photo);
 						photo = NULL;
 						Magick::Image img(blob);
 						std::string format;
 						gchar **strlist = g_strsplit(prpl_info->icon_spec.format, ",", 10);
 						for (gchar **f = strlist; *f != NULL; f++) {
 							// jpeg is the best
 							if (strcmp(*f, "jpeg") == 0 || strcmp(*f, "jpg") == 0) {
 								format = "jpg";
+							}
 							// png is number two
 							else if (strcmp(*f, "png") == 0 && format != "jpg") {
 								format = *f;
+							}
 							// gif is alright if there's not jpeg or png
 							else if (strcmp(*f, "gif") == 0 && format != "jpg" && format != "png") {
 								format = *f;
+							}
 							else if (format.empty()) {
 								format = *f;
+							}
+						}
 						g_strfreev(strlist);
 						img.magick(format);
 						int width, height;
 						if (CONFIG().protocol == "icq") {
 							width = 48;
 							height = 48;
+						}
 						else {
 							purple_buddy_icon_get_scale_size(&prpl_info->icon_spec, &width, &height);
+						}
 						if (img.size().width() != width || img.size().height() != height) {
 							Magick::Geometry g = Magick::Geometry(width,height);
 							g.aspect(CONFIG().protocol == "icq");
 							img.scale(g);
+						}
 						Magick::Blob output;
 						img.write(&output);
 						size = output.length();
 						// this will be freed by libpurple
 						photo = (guchar *) g_malloc(size * sizeof(guchar));
 						memcpy(photo, output.data(), size);
+					}
 					catch ( Magick::Exception & error) {
 						Log("handleVCard","Caught Magick++ exception: " << error.what());
 					} catch(...) {   // catch all other exceptions
+					}
+				}
 #endif /* WITH_IMAGEMAGICK */
 				memcpy(photo, image.c_str(), size);
 				if (!photo)
 					return;
 				purple_buddy_icons_set_account_icon(account, photo, size);
+			}
+		}
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::string &groups) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				if (m_authRequests.find(user + buddyName) != m_authRequests.end()) {
 					m_authRequests[user + buddyName]->deny_cb(m_authRequests[user + buddyName]->user_data);
 					m_authRequests.erase(user + buddyName);
+				}
 				PurpleBuddy *buddy = purple_find_buddy(account, buddyName.c_str());
 				if (buddy) {
 					purple_account_remove_buddy(account, buddy, purple_buddy_get_group(buddy));
 					purple_blist_remove_buddy(buddy);
+				}
+			}
+		}
 		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::string &groups) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				if (m_authRequests.find(user + buddyName) != m_authRequests.end()) {
 					m_authRequests[user + buddyName]->authorize_cb(m_authRequests[user + buddyName]->user_data);
 					m_authRequests.erase(user + buddyName);
+				}
 				PurpleBuddy *buddy = purple_find_buddy(account, buddyName.c_str());
 				if (buddy) {
 					if (getAlias(buddy) != alias) {
 						purple_blist_alias_buddy(buddy, alias.c_str());
 						purple_blist_server_alias_buddy(buddy, alias.c_str());
 						serv_alias_buddy(buddy);
+					}
 					PurpleGroup *group = purple_find_group(groups.c_str());
 					if (!group) {
 						group = purple_group_new(groups.c_str());
+					}
 					purple_blist_add_contact(purple_buddy_get_contact(buddy), group ,NULL);
+				}
 				else {
 					PurpleBuddy *buddy = purple_buddy_new(account, buddyName.c_str(), alias.c_str());
 					// Add newly created buddy to legacy network roster.
 					PurpleGroup *group = purple_find_group(groups.c_str());
 					if (!group) {
 						group = purple_group_new(groups.c_str());
+					}
 					purple_blist_add_buddy(buddy, NULL, group ,NULL);
 					purple_account_add_buddy(account, buddy);
+				}
+			}
+		}
 		void handleBuddyBlockToggled(const std::string &user, const std::string &buddyName, bool blocked) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				if (blocked) {
 					purple_privacy_deny(account, buddyName.c_str(), FALSE, FALSE);
+				}
 				else {
 					purple_privacy_allow(account, buddyName.c_str(), FALSE, FALSE);
+				}
+			}
+		}
 		void handleTypingRequest(const std::string &user, const std::string &buddyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				serv_send_typing(purple_account_get_connection(account), buddyName.c_str(), PURPLE_TYPING);
+			}
+		}
 		void handleTypedRequest(const std::string &user, const std::string &buddyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				serv_send_typing(purple_account_get_connection(account), buddyName.c_str(), PURPLE_TYPED);
+			}
+		}
 		void handleStoppedTypingRequest(const std::string &user, const std::string &buddyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				serv_send_typing(purple_account_get_connection(account), buddyName.c_str(), PURPLE_NOT_TYPING);
+			}
+		}
 		void handleAttentionRequest(const std::string &user, const std::string &buddyName, const std::string &message) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				purple_prpl_send_attention(purple_account_get_connection(account), buddyName.c_str(), 0);
 		statusMessage = "";
 	return true;
+}
 static std::string getIconHash(PurpleBuddy *m_buddy) {
 	char *avatarHash = NULL;
 	PurpleBuddyIcon *icon = purple_buddy_icons_find(purple_buddy_get_account(m_buddy), purple_buddy_get_name(m_buddy));
 	if (icon) {
 		avatarHash = purple_buddy_icon_get_full_path(icon);
 		purple_buddy_icon_unref(icon);
+	}
 	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;
 	groups.push_back((purple_buddy_get_group(m_buddy) && purple_group_get_name(purple_buddy_get_group(m_buddy))) ? std::string(purple_group_get_name(purple_buddy_get_group(m_buddy))) : std::string("Buddies"));
 	return groups;
+}
 static void buddyListNewNode(PurpleBlistNode *node) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 	PurpleBuddy *buddy = (PurpleBuddy *) node;
 	PurpleAccount *account = purple_buddy_get_account(buddy);
 	// Status
 	Swift::StatusShow status;
 	std::string message;
 	getStatus(buddy, status, message);
 	// Tooltip
 	PurplePlugin *prpl = purple_find_prpl(purple_account_get_protocol_id(account));
 	PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
 	bool blocked = false;
 	if (prpl_info && prpl_info->tooltip_text) {
 		PurpleNotifyUserInfo *user_info = purple_notify_user_info_new();
 		prpl_info->tooltip_text(buddy, user_info, true);
 		GList *entries = purple_notify_user_info_get_entries(user_info);
 		while (entries) {
 			PurpleNotifyUserInfoEntry *entry = (PurpleNotifyUserInfoEntry *)(entries->data);
 			if (purple_notify_user_info_entry_get_label(entry) && purple_notify_user_info_entry_get_value(entry)) {
 				std::string label = purple_notify_user_info_entry_get_label(entry);
 				if (label == "Blocked" ) {
 					if (std::string(purple_notify_user_info_entry_get_value(entry)) == "Yes") {
 						blocked = true;
 						break;
+					}
+				}
+			}
 			entries = entries->next;
+		}
 		purple_notify_user_info_destroy(user_info);
+	}
 	if (!blocked) {
 		blocked = purple_privacy_check(account, purple_buddy_get_name(buddy)) == false;
+	}
 	else {
 		bool purpleBlocked = purple_privacy_check(account, purple_buddy_get_name(buddy)) == false;
 		if (blocked != purpleBlocked) {
 			purple_privacy_deny(account, purple_buddy_get_name(buddy), FALSE, FALSE);
+		}
+	}
 	std::cout << "BLOCKED?" << (purple_privacy_check(account, purple_buddy_get_name(buddy)) == false) << "\n";
 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], status.getType(), message, getIconHash(buddy),
 		blocked
 	);
+}
 // static void buddyStatusChanged(PurpleBuddy *buddy, PurpleStatus *status_, PurpleStatus *old_status) {
 // 	PurpleAccount *account = purple_buddy_get_account(buddy);
 //
 // 	Swift::StatusShow status;
 // 	std::string message;
 // 	getStatus(buddy, status, message);
 //
 // 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy));
 // }
 //
 // static void buddySignedOn(PurpleBuddy *buddy) {
 // 	PurpleAccount *account = purple_buddy_get_account(buddy);
 //
 // 	Swift::StatusShow status;
 // 	std::string message;
 // 	getStatus(buddy, status, message);
 //
 // 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy));
 // }
 //
 // static void buddySignedOff(PurpleBuddy *buddy) {
 // 	PurpleAccount *account = purple_buddy_get_account(buddy);
 //
 // 	Swift::StatusShow status;
 // 	std::string message;
 // 	getStatus(buddy, status, message);
 //
 // 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy));
 // }
 static void buddyListUpdate(PurpleBuddyList *list, PurpleBlistNode *node) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 	buddyListNewNode(node);
+}
 static void buddyPrivacyChanged(PurpleBlistNode *node, void *data) {
 	std::cout << "PRIVACY CHANGED\n";
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 	buddyListUpdate(NULL, node);
+}
 static void NodeRemoved(PurpleBlistNode *node, void *data) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 // 	PurpleBuddy *buddy = (PurpleBuddy *) node;
+}
 static PurpleBlistUiOps blistUiOps =
+{
 	NULL,
 	buddyListNewNode,
 	NULL,
 	buddyListUpdate,
 	NULL, //NodeRemoved,
 	NULL,
 	NULL,
 	NULL, // buddyListAddBuddy,
 	NULL,
 	NULL,
 	NULL, //buddyListSaveNode,
 	NULL, //buddyListRemoveNode,
 	NULL, //buddyListSaveAccount,
 	NULL
 };
 static void conv_write_im(PurpleConversation *conv, const char *who, const char *msg, PurpleMessageFlags flags, time_t mtime) {
 	// Don't forwards our own messages.
 	if (flags & PURPLE_MESSAGE_SEND || flags & PURPLE_MESSAGE_SYSTEM)
 		return;
 	PurpleAccount *account = purple_conversation_get_account(conv);
 // 	char *striped = purple_markup_strip_html(message);
 // 	std::string msg = striped;
 // 	g_free(striped);
 	std::string w = who;
 	size_t pos = w.find("/");
 	if (pos != std::string::npos)
 		w.erase((int) pos, w.length() - (int) pos);
 	// Escape HTML characters.
 	char *newline = purple_strdup_withhtml(msg);
 	char *strip, *xhtml, *xhtml_linkified;
 	purple_markup_html_to_xhtml(newline, &xhtml, &strip);
 	xhtml_linkified = purple_markup_linkify(xhtml);
 	std::string message_(strip);
 	std::string xhtml_(xhtml_linkified);
 	g_free(newline);
 	g_free(xhtml);
 	g_free(xhtml_linkified);
 	g_free(strip);
 	// AIM and XMPP adds <body>...</body> here...
 	if (xhtml_.find("<body>") == 0) {
 		xhtml_ = xhtml_.substr(6);
 		if (xhtml_.find("</body>") != std::string::npos) {
 			xhtml_ = xhtml_.substr(0, xhtml_.find("</body>"));
+		}
+	}
 	if (xhtml_ == message_) {
 		xhtml_ = "";
+	}
 // 	LOG4CXX_INFO(logger, "Received message body='" << message_ << "' xhtml='" << xhtml_ << "'");
 	np->handleMessage(np->m_accounts[account], w, message_, "", xhtml_);
+}
 static PurpleConversationUiOps conversation_ui_ops =
+{
 	NULL,
 	NULL,
 	NULL,//conv_write_chat,                              /* write_chat           */
 	conv_write_im,             /* write_im             */
 	NULL,//conv_write_conv,           /* write_conv           */
 	NULL,//conv_chat_add_users,       /* chat_add_users       */
 	NULL,//conv_chat_rename_user,     /* chat_rename_user     */
 	NULL,//conv_chat_remove_users,    /* chat_remove_users    */
 	NULL,//pidgin_conv_chat_update_user,     /* chat_update_user     */
 	NULL,//pidgin_conv_present_conversation, /* present              */
 	NULL,//pidgin_conv_has_focus,            /* has_focus            */
 	NULL,//pidgin_conv_custom_smiley_add,    /* custom_smiley_add    */

0 comments (0 inline, 0 general)