void getProtocolAndName(const std::string &legacyName, std::string &name, std::string &protocol) {

			name = legacyName;

			protocol = KEYFILE_STRING("service", "protocol");

			if (protocol == "any") {

				protocol = name.substr(0, name.find("."));

				name = name.substr(name.find(".") + 1);

			}

		}

		void setDefaultAvatar(PurpleAccount *account, const std::string &legacyName) {

			char* contents;

			gsize length;

			gboolean ret = false;

			if (!KEYFILE_STRING("backend", "avatars_directory").empty()) {

				std::string f = KEYFILE_STRING("backend", "avatars_directory") + "/" + legacyName;

				ret = g_file_get_contents (f.c_str(), &contents, &length, NULL);

			}

			if (!KEYFILE_STRING("backend", "default_avatar").empty() && !ret) {

				ret = g_file_get_contents (KEYFILE_STRING("backend", "default_avatar").c_str(),

											&contents, &length, NULL);

			}

			if (ret) {

				purple_buddy_icons_set_account_icon(account, (guchar *) contents, length);

			}

		}

		void setDefaultAccountOptions(PurpleAccount *account) {

			int i = 0;

			gchar **keys = g_key_file_get_keys (keyfile, "purple", NULL, NULL);

			while (keys && keys[i] != NULL) {

				std::string key = keys[i];

				if (key == "fb_api_key" || key == "fb_api_secret") {

					purple_account_set_bool(account, "auth_fb", TRUE);

				}

				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));

					if (key != key2) {

						continue;

					}

					found = true;

					switch (type) {

						case PURPLE_PREF_BOOLEAN:

							purple_account_set_bool(account, key.c_str(), fromString<bool>(KEYFILE_STRING("purple", key)));

							break;

						case PURPLE_PREF_INT:

							purple_account_set_int(account, key.c_str(), fromString<int>(KEYFILE_STRING("purple", key)));

							break;

						case PURPLE_PREF_STRING:

						case PURPLE_PREF_STRING_LIST:

							purple_account_set_string(account, key.c_str(), KEYFILE_STRING("purple", key).c_str());

							break;

						default:

							continue;

					}

					break;

				}

				if (!found) {

					purple_account_set_string(account, key.c_str(), KEYFILE_STRING("purple", key).c_str());

				}

				i++;

			}

			g_strfreev (keys);

		}

		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {

			PurpleAccount *account = NULL;

			std::string name;

			std::string protocol;

			getProtocolAndName(legacyName, name, protocol);

			if (password.empty()) {

				LOG4CXX_INFO(logger,  name.c_str() << ": Empty password");

				np->handleDisconnected(user, 0, "Empty password.");

				return;

			}

			if (!purple_find_prpl(protocol.c_str())) {

				LOG4CXX_INFO(logger,  name.c_str() << ": Invalid protocol '" << protocol << "'");

				np->handleDisconnected(user, 0, "Invalid protocol " + protocol);

				return;

			}

				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);

			if (KEYFILE_BOOL("service", "enable_privacy_lists")) {

				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);

				g_free(account->ui_data);

				account->ui_data = NULL;

				m_accounts.erase(account);

				purple_accounts_delete(account);

// 

// 				// Remove conversations.

// 				// This has to be called before m_account->ui_data = NULL;, because it uses

// 				// ui_data to call SpectrumMessageHandler::purpleConversationDestroyed() callback.

// 				GList *iter;

// 				for (iter = purple_get_conversations(); iter; ) {

// 					PurpleConversation *conv = (PurpleConversation*) iter->data;

// 					iter = iter->next;

// 					if (purple_conversation_get_account(conv) == account)

// 						purple_conversation_destroy(conv);

// 				}

// 

// 				g_free(account->ui_data);

// 				account->ui_data = NULL;

// 				m_accounts.erase(account);

// 

// 				purple_notify_close_with_handle(account);

// 				purple_request_close_with_handle(account);

// 

// 				purple_accounts_remove(account);

// 

// 				GSList *buddies = purple_find_buddies(account, NULL);

// 				while(buddies) {

// 					PurpleBuddy *b = (PurpleBuddy *) buddies->data;

// 					purple_blist_remove_buddy(b);

// 					buddies = g_slist_delete_link(buddies, buddies);

// 				}

// 

// 				/* Remove any open conversation for this account */

// 				for (GList *it = purple_get_conversations(); it; ) {

// 					PurpleConversation *conv = (PurpleConversation *) it->data;

// 					it = it->next;

// 					if (purple_conversation_get_account(conv) == account)

// 						purple_conversation_destroy(conv);

// 				}

// 

// 				/* Remove this account's pounces */

// 					// purple_pounce_destroy_all_by_account(account);

// 

// 				/* This will cause the deletion of an old buddy icon. */

// 				purple_buddy_icons_set_account_icon(account, NULL, 0);

// 

// 				purple_account_destroy(account);

				// force returning of memory chunks allocated by libxml2 to kernel

#ifndef WIN32

				malloc_trim(0);

#endif

// 				VALGRIND_DO_LEAK_CHECK;

			}

		}

		void handleStatusChangeRequest(const std::string &user, int status, const std::string &statusMessage) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				int st;

				switch(status) {

			status = pbnetwork::STATUS_ONLINE;

			break;

		}

		case PURPLE_STATUS_AWAY: {

			status = pbnetwork::STATUS_AWAY;

			break;

		}

		case PURPLE_STATUS_UNAVAILABLE: {

			status = pbnetwork::STATUS_DND;

			break;

		}

		case PURPLE_STATUS_EXTENDED_AWAY: {

			status = pbnetwork::STATUS_XA;

			break;

		}

		case PURPLE_STATUS_OFFLINE: {

			status = pbnetwork::STATUS_NONE;

			break;

		}

		default:

			status = pbnetwork::STATUS_ONLINE;

			break;

	}

	const char *message = purple_status_get_attr_string(stat, "message");

	if (message != NULL) {

		char *stripped = purple_markup_strip_html(message);

		statusMessage = std::string(stripped);

		g_free(stripped);

	}

	else

		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;

	if (purple_buddy_get_name(m_buddy)) {

		GSList *buddies = purple_find_buddies(purple_buddy_get_account(m_buddy), purple_buddy_get_name(m_buddy));

		while(buddies) {

			PurpleGroup *g = purple_buddy_get_group((PurpleBuddy *) buddies->data);

			buddies = g_slist_delete_link(buddies, buddies);

			if(g && purple_group_get_name(g)) {

				groups.push_back(purple_group_get_name(g));

			}

		}

	}

	if (groups.empty()) {

		groups.push_back("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

	pbnetwork::StatusType status = pbnetwork::STATUS_NONE;

	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 (KEYFILE_BOOL("service", "enable_privacy_lists")) {

		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);

			}

		}

	}

	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy), status, message, getIconHash(buddy),

		blocked

	);

}

static void buddyListUpdate(PurpleBuddyList *list, PurpleBlistNode *node) {

	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))

		return;

	buddyListNewNode(node);

}

static void buddyPrivacyChanged(PurpleBlistNode *node, void *data) {

	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 = purple_normalize(account, who);

	size_t pos = w.find("/");