bool support_set_chat_topic = prpl_info && prpl_info->set_chat_topic;

				if (support_set_chat_topic) {

					LOG4CXX_INFO(logger, user << ": Setting room subject for room " << legacyName);

					prpl_info->set_chat_topic(purple_account_get_connection_wrapped(account),

											  purple_conv_chat_get_id(PURPLE_CONV_CHAT(conv)),

											  message.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;

				PurplePlugin *prpl = purple_find_prpl_wrapped(purple_account_get_protocol_id_wrapped(account));

				PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);

				bool support_get_info = prpl_info && prpl_info->get_info;

				if (!support_get_info || (CONFIG_BOOL(config, "backend.no_vcard_fetch") && name != purple_account_get_username_wrapped(account))) {

					PurpleNotifyUserInfo *user_info = purple_notify_user_info_new_wrapped();

					notify_user_info(purple_account_get_connection_wrapped(account), name.c_str(), user_info);

					purple_notify_user_info_destroy_wrapped(user_info);

				}

				else {

					serv_get_info_wrapped(purple_account_get_connection_wrapped(account), name.c_str());

				}

			}

		}

		void handleVCardUpdatedRequest(const std::string &user, const std::string &image, const std::string &nickname) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				purple_account_set_alias_wrapped(account, nickname.c_str());

#if PURPLE_MAJOR_VERSION >= 2 && PURPLE_MINOR_VERSION >= 7

				purple_account_set_public_alias_wrapped(account, nickname.c_str(), NULL, NULL);

#endif

				gssize size = image.size();

				// this will be freed by libpurple

				guchar *photo = (guchar *) g_malloc(size * sizeof(guchar));

				memcpy(photo, image.c_str(), size);

				if (!photo)

					return;

				purple_buddy_icons_set_account_icon_wrapped(account, photo, size);

			}

		}

		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<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_wrapped(account, buddyName.c_str());

				if (buddy) {

					purple_account_remove_buddy_wrapped(account, buddy, purple_buddy_get_group_wrapped(buddy));

					purple_blist_remove_buddy_wrapped(buddy);

				}

			}

		}

		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups_) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				std::string groups = groups_.empty() ? "" : groups_[0];

				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_wrapped(account, buddyName.c_str());

				if (buddy) {

					if (getAlias(buddy) != alias) {

						purple_blist_alias_buddy_wrapped(buddy, alias.c_str());

						purple_blist_server_alias_buddy_wrapped(buddy, alias.c_str());

						serv_alias_buddy_wrapped(buddy);

					}

					PurpleGroup *group = purple_find_group_wrapped(groups.c_str());

					if (!group) {

						group = purple_group_new_wrapped(groups.c_str());

					}

					purple_blist_add_contact_wrapped(purple_buddy_get_contact_wrapped(buddy), group ,NULL);

				}

				else {

					PurpleBuddy *buddy = purple_buddy_new_wrapped(account, buddyName.c_str(), alias.c_str());

					// Add newly created buddy to legacy network roster.

					PurpleGroup *group = purple_find_group_wrapped(groups.c_str());

					if (!group) {

						group = purple_group_new_wrapped(groups.c_str());

					}

					purple_blist_add_buddy_wrapped(buddy, NULL, group ,NULL);

					purple_account_add_buddy_wrapped(account, buddy);

					LOG4CXX_INFO(logger, "Adding new buddy " << buddyName.c_str() << " to legacy network roster");

				}

			}

		}

		void handleBuddyBlockToggled(const std::string &user, const std::string &buddyName, bool blocked) {

			if (CONFIG_BOOL(config, "service.enable_privacy_lists")) {

				PurpleAccount *account = m_sessions[user];

				if (account) {

					if (blocked) {

						purple_privacy_deny_wrapped(account, buddyName.c_str(), FALSE, FALSE);

					}

					else {

						purple_privacy_allow_wrapped(account, buddyName.c_str(), FALSE, FALSE);

					}

				}

			}

		}

		void updateConversationActivity(PurpleAccount *account, const std::string &buddyName) {

			PurpleConversation *conv = purple_find_conversation_with_account_wrapped(PURPLE_CONV_TYPE_CHAT, buddyName.c_str(), account);

			if (!conv) {

				conv = purple_find_conversation_with_account_wrapped(PURPLE_CONV_TYPE_IM, buddyName.c_str(), account);

			}

			if (conv) {

				purple_conversation_set_data_wrapped(conv, "unseen_count", 0);

				purple_conversation_update_wrapped(conv, PURPLE_CONV_UPDATE_UNSEEN);

			}

		}

		void handleTypingRequest(const std::string &user, const std::string &buddyName) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				LOG4CXX_INFO(logger, user << ": sending typing notify to " << buddyName);

				serv_send_typing_wrapped(purple_account_get_connection_wrapped(account), buddyName.c_str(), PURPLE_TYPING);

				updateConversationActivity(account, buddyName);

			}

		}

		void handleTypedRequest(const std::string &user, const std::string &buddyName) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				serv_send_typing_wrapped(purple_account_get_connection_wrapped(account), buddyName.c_str(), PURPLE_TYPED);

				updateConversationActivity(account, buddyName);

			}

		}

		void handleStoppedTypingRequest(const std::string &user, const std::string &buddyName) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				serv_send_typing_wrapped(purple_account_get_connection_wrapped(account), buddyName.c_str(), PURPLE_NOT_TYPING);

				updateConversationActivity(account, buddyName);

			}

		}

		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_wrapped(purple_account_get_connection_wrapped(account), buddyName.c_str(), 0);

			}

		}

		void handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &pasword) {

			PurpleAccount *account = m_sessions[user];

			if (!account) {

				return;

			}

			PurpleConnection *gc = purple_account_get_connection_wrapped(account);

			GHashTable *comps = NULL;

			// Check if the PurpleChat is not stored in buddy list

			PurpleChat *chat = purple_blist_find_chat_wrapped(account, room.c_str());

			if (chat) {

				comps = purple_chat_get_components_wrapped(chat);

			}

			else if (PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info_defaults != NULL) {

				if (CONFIG_STRING(config, "service.protocol") == "prpl-jabber") {

					comps = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info_defaults(gc, (room + "/" + nickname).c_str());

				} else {

					comps = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info_defaults(gc, room.c_str());

				}

			}

			if (CONFIG_STRING(config, "service.protocol") != "prpl-jabber") {

				np->handleParticipantChanged(np->m_accounts[account], nickname, room, 0, pbnetwork::STATUS_ONLINE);

				const char *disp;

				if ((disp = purple_connection_get_display_name(account->gc)) == NULL) {

					disp = purple_account_get_username(account);

				}

				if (nickname != disp) {

					handleRoomNicknameChanged(np->m_accounts[account], room, disp);

					np->handleParticipantChanged(np->m_accounts[account], nickname, room, 0, pbnetwork::STATUS_ONLINE, "", disp);

				}

			}

			LOG4CXX_INFO(logger, user << ": Joining the room " << room);

			if (comps) {

				serv_join_chat_wrapped(gc, comps);

				g_hash_table_destroy(comps);

			}

		}

		void handleLeaveRoomRequest(const std::string &user, const std::string &room) {

			PurpleAccount *account = m_sessions[user];

			if (!account) {

				return;

			}

			PurpleConversation *conv = purple_find_conversation_with_account_wrapped(PURPLE_CONV_TYPE_CHAT, 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);

			}

		}

		void handleFTPauseRequest(unsigned long ftID) {

			PurpleXfer *xfer = m_xfers[ftID];

			if (!xfer)

				return;

			FTData *ftData = (FTData *) xfer->ui_data;

			ftData->paused = true;

		}

		void handleFTContinueRequest(unsigned long ftID) {

			PurpleXfer *xfer = m_xfers[ftID];

			if (!xfer)

				return;

			FTData *ftData = (FTData *) xfer->ui_data;

			ftData->paused = false;

			purple_xfer_ui_ready_wrapped(xfer);

		}

		void sendData(const std::string &string) {

#ifdef WIN32

			::send(main_socket, string.c_str(), string.size(), 0);

#else

			write(main_socket, string.c_str(), string.size());

#endif

			if (writeInput == 0)

				writeInput = purple_input_add_wrapped(main_socket, PURPLE_INPUT_WRITE, &transportDataReceived, NULL);

		}

		void readyForData() {

			if (m_waitingXfers.empty())

				return;

			std::vector<PurpleXfer *> tmp;

			tmp.swap(m_waitingXfers);

			for (std::vector<PurpleXfer *>::const_iterator it = tmp.begin(); it != tmp.end(); it++) {

				FTData *ftData = (FTData *) (*it)->ui_data;

				if (ftData->timer == 0) {

					ftData->timer = purple_timeout_add_wrapped(1, ft_ui_ready, *it);

				}

// 				purple_xfer_ui_ready_wrapped(xfer);

			}

		}

		std::map<std::string, PurpleAccount *> m_sessions;

		std::map<PurpleAccount *, std::string> m_accounts;

		std::map<std::string, unsigned int> m_vcards;

		std::map<std::string, authRequest *> m_authRequests;

		std::map<unsigned long, PurpleXfer *> m_xfers;

		std::map<std::string, PurpleXfer *> m_unhandledXfers;

		std::vector<PurpleXfer *> m_waitingXfers;

};

static bool getStatus(PurpleBuddy *m_buddy, pbnetwork::StatusType &status, std::string &statusMessage) {

	PurplePresence *pres = purple_buddy_get_presence_wrapped(m_buddy);

	if (pres == NULL)

		return false;

	PurpleStatus *stat = purple_presence_get_active_status_wrapped(pres);

	if (stat == NULL)

		return false;

	int st = purple_status_type_get_primitive_wrapped(purple_status_get_type_wrapped(stat));

	switch(st) {

		case PURPLE_STATUS_AVAILABLE: {

			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_wrapped(stat, "message");

	if (message != NULL) {

		char *stripped = purple_markup_strip_html_wrapped(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_wrapped(purple_buddy_get_account_wrapped(m_buddy), purple_buddy_get_name_wrapped(m_buddy));

	if (icon) {

		avatarHash = purple_buddy_icon_get_full_path_wrapped(icon);

		purple_buddy_icon_unref_wrapped(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_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");

	}