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;

					}

					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;

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

				}

				serv_get_info(purple_account_get_connection(account), name.c_str());

				m_vcards[user + name] = id;

			}

		}

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

			PurpleAccount *account = m_sessions[user];

			if (account) {

				gssize size = p.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 */

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