case Swift::ClientError::InvalidServerIdentityError: message = ("Certificate does not match the host identity"); break;

				}

			}

			LOG4CXX_INFO(logger, user << ": Disconnected " << message);

			handleDisconnected(user, reconnect ? 0 : 3, message);

			boost::shared_ptr<Swift::Client> client = m_users[user];

			if (client) {

				client->onConnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftConnected, this, user));

				client->onDisconnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftDisconnected, this, user, _1));

				client->onMessageReceived.disconnect(boost::bind(&SwiftenPlugin::handleSwiftMessageReceived, this, user, _1));

				m_users.erase(user);

				m_handlers.erase(user);

			}

#ifndef WIN32

#ifndef __FreeBSD__

#ifndef __MACH__

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

			malloc_trim(0);

#endif

#endif

#endif

		}

		void handleSwiftConnected(const std::string &user) {

			LOG4CXX_INFO(logger, user << ": Connected to XMPP server.");

			handleConnected(user);

			m_users[user]->requestRoster();

			Swift::Presence::ref response = Swift::Presence::create();

			response->setFrom(m_users[user]->getJID());

			m_users[user]->sendPresence(response);

		}

		void handleSwiftRosterReceived(const std::string &user) {

			Swift::PresenceOracle *oracle = m_users[user]->getPresenceOracle();

			BOOST_FOREACH(const Swift::XMPPRosterItem &item, m_users[user]->getRoster()->getItems()) {

				Swift::Presence::ref lastPresence = oracle->getLastPresence(item.getJID());

				pbnetwork::StatusType status = lastPresence ? ((pbnetwork::StatusType) lastPresence->getShow()) : pbnetwork::STATUS_NONE;

				handleBuddyChanged(user, item.getJID().toBare().toString(),

								   item.getName(), item.getGroups(), status);

			}

		}

		void handleSwiftPresenceChanged(const std::string &user, Swift::Presence::ref presence) {

// 			boost::shared_ptr<Swift::Client> client = m_users[user];

// 			if (client->getMUCRegistry()->isMUC(presence->getFrom().toBare())) {

// 				return;

// 			}

// 

// 			if (presence->getPayload<Swift::MUCUserPayload>() != NULL || presence->getPayload<Swift::MUCPayload>() != NULL) {

// 				return;

// 			}

// 

// 			LOG4CXX_INFO(logger, user << ": " << presence->getFrom().toBare().toString() << " presence changed");

// 

// 			std::string message = presence->getStatus();

// 			std::string photo = "";

// 

// 			boost::shared_ptr<Swift::VCardUpdate> update = presence->getPayload<Swift::VCardUpdate>();

// 			if (update) {

// 				photo = update->getPhotoHash();

// 			}

// 

// 			boost::optional<Swift::XMPPRosterItem> item = m_users[user]->getRoster()->getItem(presence->getFrom());

// 			if (item) {

// 				handleBuddyChanged(user, presence->getFrom().toBare().toString(), item->getName(), item->getGroups(), (pbnetwork::StatusType) presence->getShow(), message, photo);

// 			}

// 			else {

// 				std::vector<std::string> groups;

// 				handleBuddyChanged(user, presence->getFrom().toBare().toString(), presence->getFrom().toBare(), groups, (pbnetwork::StatusType) presence->getShow(), message, photo);

// 			}

			presence->setTo(user);

			std::string xml = safeByteArrayToString(serializer->serializeElement(presence));

			sendRawXML(xml);

		}

		void handleSwiftMessageReceived(const std::string &user, Swift::Message::ref message) {

			message->setTo(user);

			std::string xml = safeByteArrayToString(serializer->serializeElement(message));

			sendRawXML(xml);

		}

		void handleSwiftenDataRead(const Swift::SafeByteArray &data) {

			std::string d = safeByteArrayToString(data);

			if (!boost::starts_with(d, "<auth")) {

				LOG4CXX_INFO(logger_xml, "XML IN " << d);

			}

		}

		void handleSwiftenDataWritten(const Swift::SafeByteArray &data) {

			LOG4CXX_INFO(logger_xml, "XML OUT " << safeByteArrayToString(data));

		}

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

			LOG4CXX_INFO(logger, user << ": connecting as " << legacyName);

			m_users[user] = client;

			client->setAlwaysTrustCertificates();

			client->onConnected.connect(boost::bind(&SwiftenPlugin::handleSwiftConnected, this, user));

			client->onDisconnected.connect(boost::bind(&SwiftenPlugin::handleSwiftDisconnected, this, user, _1));

			client->onMessageReceived.connect(boost::bind(&SwiftenPlugin::handleSwiftMessageReceived, this, user, _1));

			client->getRoster()->onInitialRosterPopulated.connect(boost::bind(&SwiftenPlugin::handleSwiftRosterReceived, this, user));

			client->getPresenceOracle()->onPresenceChange.connect(boost::bind(&SwiftenPlugin::handleSwiftPresenceChanged, this, user, _1));

			client->onDataRead.connect(boost::bind(&SwiftenPlugin::handleSwiftenDataRead, this, _1));

			client->onDataWritten.connect(boost::bind(&SwiftenPlugin::handleSwiftenDataWritten, this, _1));

			client->getSubscriptionManager()->onPresenceSubscriptionRequest.connect(boost::bind(&SwiftenPlugin::handleSubscriptionRequest, this, user, _1, _2, _3));

			client->getSubscriptionManager()->onPresenceSubscriptionRevoked.connect(boost::bind(&SwiftenPlugin::handleSubscriptionRevoked, this, user, _1, _2));

			Swift::ClientOptions opt;

			opt.allowPLAINWithoutTLS = true;

			client->connect(opt);

			boost::shared_ptr<ForwardIQHandler> handler = boost::make_shared<ForwardIQHandler>(this, user);

			client->getIQRouter()->addHandler(handler);

			m_handlers[user] = handler;

		}

		void handleSubscriptionRequest(const std::string &user, const Swift::JID& jid, const std::string& message, Swift::Presence::ref presence) {

			handleSwiftPresenceChanged(user, presence);

		}

		void handleSubscriptionRevoked(const std::string &user, const Swift::JID& jid, const std::string& message) {

			Swift::Presence::ref presence = Swift::Presence::create();

			presence->setTo(user);

			presence->setFrom(jid);

			presence->setType(Swift::Presence::Unsubscribe);

			handleSwiftPresenceChanged(user, presence);

		}

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

			boost::shared_ptr<Swift::Client> client = m_users[user];

			if (client) {

				client->onConnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftConnected, this, user));

// 				client->onDisconnected.disconnect(boost::bind(&SwiftenPlugin::handleSwiftDisconnected, this, user, _1));

				client->onMessageReceived.disconnect(boost::bind(&SwiftenPlugin::handleSwiftMessageReceived, this, user, _1));

				client->getRoster()->onInitialRosterPopulated.disconnect(boost::bind(&SwiftenPlugin::handleSwiftRosterReceived, this, user));

				client->getPresenceOracle()->onPresenceChange.disconnect(boost::bind(&SwiftenPlugin::handleSwiftPresenceChanged, this, user, _1));

				client->disconnect();

			}

		}

		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &msg, const std::string &xhtml = "", const std::string &id = "") {

		}

		void handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id) {

		}

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

			boost::shared_ptr<Swift::Client> client = m_users[user];

			if (client) {

				LOG4CXX_INFO(logger, user << ": Added/Updated buddy " << buddyName << ".");

				if (!client->getRoster()->containsJID(buddyName) || client->getRoster()->getSubscriptionStateForJID(buddyName) != Swift::RosterItemPayload::Both) {

					Swift::RosterItemPayload item;

					item.setName(alias);

					item.setJID(buddyName);

					item.setGroups(groups);

					boost::shared_ptr<Swift::RosterPayload> roster(new Swift::RosterPayload());

					roster->addItem(item);

					Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(roster, client->getIQRouter());

// 					request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));

					request->send();

					client->getSubscriptionManager()->requestSubscription(buddyName);

				}

				else {

					Swift::JID contact(buddyName);

					Swift::RosterItemPayload item(contact, alias, client->getRoster()->getSubscriptionStateForJID(contact));

					item.setGroups(groups);

					boost::shared_ptr<Swift::RosterPayload> roster(new Swift::RosterPayload());

					roster->addItem(item);

					Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(roster, client->getIQRouter());

// 					request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));

					request->send();

				}

			}

		}

		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups) {

			boost::shared_ptr<Swift::Client> client = m_users[user];

			if (client) {

				Swift::RosterItemPayload item(buddyName, "", Swift::RosterItemPayload::Remove);

				boost::shared_ptr<Swift::RosterPayload> roster(new Swift::RosterPayload());

				roster->addItem(item);

				Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(roster, client->getIQRouter());

// 				request->onResponse.connect(boost::bind(&RosterController::handleRosterSetError, this, _1, roster));

				request->send();

			}

		}

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

		}