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], (int) 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    */

	NULL,//pidgin_conv_custom_smiley_write,  /* custom_smiley_write  */

	NULL,//pidgin_conv_custom_smiley_close,  /* custom_smiley_close  */

	NULL,//pidgin_conv_send_confirm,         /* send_confirm         */

	NULL,

	NULL,

	NULL,

	NULL

};

static void connection_report_disconnect(PurpleConnection *gc, PurpleConnectionError reason, const char *text){

	PurpleAccount *account = purple_connection_get_account(gc);

	np->handleDisconnected(np->m_accounts[account], purple_account_get_username(account), (int) reason, text ? text : "");

}

static PurpleConnectionUiOps conn_ui_ops =

{

	NULL,

	NULL,

	NULL,//connection_disconnected,

	NULL,

	NULL,

	NULL,

	NULL,

	connection_report_disconnect,

	NULL,

	NULL,

	NULL

};

static void *notify_user_info(PurpleConnection *gc, const char *who, PurpleNotifyUserInfo *user_info) {

	std::string name(who);

	std::transform(name.begin(), name.end(), name.begin(),(int(*)(int)) std::tolower);

	PurpleAccount *account = purple_connection_get_account(gc);

	GList *vcardEntries = purple_notify_user_info_get_entries(user_info);

	PurpleNotifyUserInfoEntry *vcardEntry;

	std::string firstName;

	std::string lastName;

	std::string fullName;

	std::string nickname;

	std::string header;

	std::string label;

	Swift::ByteArray photo;

	while (vcardEntries) {

		vcardEntry = (PurpleNotifyUserInfoEntry *)(vcardEntries->data);

		if (purple_notify_user_info_entry_get_label(vcardEntry) && purple_notify_user_info_entry_get_value(vcardEntry)){

			label = purple_notify_user_info_entry_get_label(vcardEntry);

			if (label == "Given Name" || label == "First Name") {

				firstName = purple_notify_user_info_entry_get_value(vcardEntry);

			}

			else if (label == "Family Name" || label == "Last Name") {

				lastName = purple_notify_user_info_entry_get_value(vcardEntry);

			}

			else if (label=="Nickname" || label == "Nick") {

				nickname = purple_notify_user_info_entry_get_value(vcardEntry);

			}

			else if (label=="Full Name") {

				fullName = purple_notify_user_info_entry_get_value(vcardEntry);

			}

			else {

				LOG4CXX_WARN(logger, "Unhandled VCard Label '" << purple_notify_user_info_entry_get_label(vcardEntry) << "' " << purple_notify_user_info_entry_get_value(vcardEntry));

			}

		}

		vcardEntries = vcardEntries->next;

	}

	if ((!firstName.empty() || !lastName.empty()) && fullName.empty())

		fullName = firstName + " " + lastName;

	if (nickname.empty() && !fullName.empty()) {

		nickname = fullName;

	}

	bool ownInfo = name == purple_account_get_username(account);

	std::cout << "RECEIVED " << name << " " << purple_account_get_username(account) << "\n";

	if (ownInfo) {

		const gchar *displayname = purple_connection_get_display_name(gc);

		if (!displayname) {

			displayname = purple_account_get_name_for_display(account);

		}

		if (displayname && nickname.empty()) {

			nickname = displayname;

		}

		// avatar

		PurpleStoredImage *avatar = purple_buddy_icons_find_account_icon(account);

		if (avatar) {

			const gchar * data = (const gchar *) purple_imgstore_get_data(avatar);

			size_t len = purple_imgstore_get_size(avatar);

			if (len < 300000 && data) {

				photo = Swift::createByteArray(data, len);

			}

			purple_imgstore_unref(avatar);

		}

	}

	PurpleBuddy *buddy = purple_find_buddy(purple_connection_get_account(gc), who);

	if (buddy && photo.size() == 0) {

		gsize len;

		PurpleBuddyIcon *icon = NULL;

		icon = purple_buddy_icons_find(purple_connection_get_account(gc), name.c_str());

		if (icon) {

			if (true) {

				gchar *data;

				gchar *path = purple_buddy_icon_get_full_path(icon);

				if (g_file_get_contents (path, &data, &len, NULL)) {

					photo = Swift::createByteArray(data, len);

					free(data);

				}

				free(path);

			}

			else {

				const gchar * data = (gchar*)purple_buddy_icon_get_data(icon, &len);

				if (len < 300000 && data) {

					photo = Swift::createByteArray(data, len);

				}

			}

			purple_buddy_icon_unref(icon);

		}

	}

	np->handleVCard(np->m_accounts[account], np->m_vcards[np->m_accounts[account] + name], name, fullName, nickname, Swift::byteArrayToString(photo));

	np->m_vcards.erase(np->m_accounts[account] + name);

	return NULL;

}

static PurpleNotifyUiOps notifyUiOps =

{

		NULL,

		NULL,

		NULL,

		NULL,

		NULL,

		NULL,

		notify_user_info,

		NULL,

		NULL,

		NULL,

		NULL,

		NULL,

		NULL

};

static PurpleRequestUiOps requestUiOps =

{

	requestInput,

	NULL,

	requestAction,

	NULL,

	NULL,

	NULL, //requestClose,

	NULL,

	NULL,

	NULL,

	NULL,

	NULL

};

static void * accountRequestAuth(PurpleAccount *account, const char *remote_user, const char *id, const char *alias, const char *message, gboolean on_list, PurpleAccountRequestAuthorizationCb authorize_cb, PurpleAccountRequestAuthorizationCb deny_cb, void *user_data) {

	authRequest *req = new authRequest;

	req->authorize_cb = authorize_cb;

	req->deny_cb = deny_cb;

	req->user_data = user_data;

	req->account = account;

	req->who = remote_user;

	req->mainJID = np->m_accounts[account];

	np->m_authRequests[req->mainJID + req->who] = req;

	np->handleAuthorization(req->mainJID, req->who);

	return req;

}

static void accountRequestClose(void *data){

	authRequest *req = (authRequest *) data;

	np->m_authRequests.erase(req->mainJID + req->who);

}

static PurpleAccountUiOps accountUiOps =

{

	NULL,

	NULL,

	NULL,

	accountRequestAuth,

	accountRequestClose,

	NULL,

	NULL,

	NULL,

	NULL

};

static void transport_core_ui_init(void)

{

	purple_blist_set_ui_ops(&blistUiOps);

	purple_accounts_set_ui_ops(&accountUiOps);

	purple_notify_set_ui_ops(&notifyUiOps);

	purple_request_set_ui_ops(&requestUiOps);

// 	purple_xfers_set_ui_ops(getXferUiOps());

	purple_connections_set_ui_ops(&conn_ui_ops);

	purple_conversations_set_ui_ops(&conversation_ui_ops);

// #ifndef WIN32

// 	purple_dnsquery_set_ui_ops(getDNSUiOps());

// #endif

}

static PurpleCoreUiOps coreUiOps =

{

	NULL,

// 	debug_init,

	NULL,

	transport_core_ui_init,

	NULL,

	spectrum_ui_get_info,

	NULL,

	NULL,

	NULL

};

static void signed_on(PurpleConnection *gc, gpointer unused) {

	PurpleAccount *account = purple_connection_get_account(gc);