void UserManager::handlePresence(Swift::Presence::ref presence) {

	std::string barejid = presence->getTo().toBare().toString();

	std::string userkey = presence->getFrom().toBare().toString();

	User *user = getUser(userkey);

	// Create user class if it's not there

	if (!user) {

		// Admin user is not legacy network user, so do not create User class instance for him

		if (m_component->inServerMode()) {

			std::vector<std::string> const &x = CONFIG_VECTOR(m_component->getConfig(),"service.admin_jid");

			if (std::find(x.begin(), x.end(), presence->getFrom().toBare().toString()) != x.end()) {

				// Send admin contact to the user.

				Swift::RosterPayload::ref payload = Swift::RosterPayload::ref(new Swift::RosterPayload());

				Swift::RosterItemPayload item;

				item.setJID(m_component->getJID());

				item.setName("Admin");

				item.setSubscription(Swift::RosterItemPayload::Both);

				payload->addItem(item);

				m_component->getFrontend()->sendRosterRequest(payload, presence->getFrom());

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

				response->setTo(presence->getFrom());

				response->setFrom(m_component->getJID());

				m_component->getFrontend()->sendPresence(response);

				return;

		    }

		}

		UserInfo res;

		bool registered = m_storageBackend ? m_storageBackend->getUser(userkey, res) : false;

		// No user and unavailable presence -> answer with unavailable

		if (presence->getType() == Swift::Presence::Unavailable || presence->getType() == Swift::Presence::Probe) {

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

			response->setTo(presence->getFrom());

			response->setFrom(presence->getTo());

			response->setType(Swift::Presence::Unavailable);

			m_component->getFrontend()->sendPresence(response);

			// bother him with probe presence, just to be

			// sure he is subscribed to us.

			if (/*registered && */presence->getType() == Swift::Presence::Probe) {

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

				response->setTo(presence->getFrom());

				response->setFrom(presence->getTo());

				response->setType(Swift::Presence::Probe);

				m_component->getFrontend()->sendPresence(response);

			}

			// Set user offline in database

			if (m_storageBackend) {

				UserInfo res;

				bool registered = m_storageBackend->getUser(userkey, res);

				if (registered) {

					m_storageBackend->setUserOnline(res.id, false);

				}

			}

			return;

		}

		// In server mode, we don't need registration normally, but for networks like IRC

		// or Twitter where there's no real authorization using password, we have to force

		// registration otherwise some data (like bookmarked rooms) could leak.

		if (m_component->inServerMode()) {

			if (!registered) {

				// If we need registration, stop login process because user is not registered

				if (CONFIG_BOOL_DEFAULTED(m_component->getConfig(), "registration.needRegistration", false)

					&& CONFIG_BOOL_DEFAULTED(m_component->getConfig(), "registration.needPassword", true)) {

					m_userRegistry->onPasswordInvalid(presence->getFrom());

					LOG4CXX_INFO(logger, userkey << ": Tried to login, but is not registered.");

					return;

				}

				res.password = "";

				res.uin = presence->getFrom().getNode();

				res.jid = userkey;

				while (res.uin.find_last_of("%") != std::string::npos) { // OK

					res.uin.replace(res.uin.find_last_of("%"), 1, "@"); // OK

				}

				if (m_storageBackend) {

					// store user and getUser again to get user ID.

					m_storageBackend->setUser(res);

					registered = m_storageBackend->getUser(userkey, res);

				}

				else {

					registered = true;

				}

			}

			res.password = m_userRegistry->getUserPassword(userkey);

		}

		// We allow auto_register feature in gateway-mode. This allows IRC user to register

		// the transport just by joining the room.

		if (!m_component->inServerMode()) {

			if (!registered && (CONFIG_BOOL(m_component->getConfig(), "registration.auto_register")

				res.password = "";

				res.jid = userkey;

				bool isMUC = presence->getPayload<Swift::MUCPayload>() != NULL || *presence->getTo().getNode().c_str() == '#';

				if (isMUC) {

					res.uin = presence->getTo().getResource();

				}

				else {

					res.uin = presence->getFrom().toString();

				}

				LOG4CXX_INFO(logger, "Auto-registering user " << userkey << " with uin=" << res.uin);

				if (m_storageBackend) {

					// store user and getUser again to get user ID.

					m_storageBackend->setUser(res);

					registered = m_storageBackend->getUser(userkey, res);

				}

				else {

					registered = true;

				}

			}

		}

		// Unregistered users are not able to login

		if (!registered) {

			LOG4CXX_WARN(logger, "Unregistered user " << userkey << " tried to login");

			return;

		}

		if (CONFIG_BOOL(m_component->getConfig(), "service.vip_only") && res.vip == false) {

			if (!CONFIG_STRING(m_component->getConfig(), "service.vip_message").empty()) {

				SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Swift::Message> msg(new Swift::Message());

				msg->setBody(CONFIG_STRING(m_component->getConfig(), "service.vip_message"));

				msg->setTo(presence->getFrom());

				msg->setFrom(m_component->getJID());

				m_component->getFrontend()->sendMessage(msg);

			}

			LOG4CXX_WARN(logger, "Non VIP user " << userkey << " tried to login");

			if (m_component->inServerMode()) {

				m_userRegistry->onPasswordInvalid(presence->getFrom());

			}

			return;

		}

		bool transport_enabled = true;

		if (m_storageBackend) {

			std::string value = "1";

			int type = (int) TYPE_BOOLEAN;

			m_storageBackend->getUserSetting(res.id, "enable_transport", type, value);

			transport_enabled = value == "1";

		}

		// User can disabled the transport using adhoc commands

		if (!transport_enabled) {

			LOG4CXX_INFO(logger, "User " << userkey << " has disabled transport, not logging");

			return;

		}

		// Create new user class and set storagebackend

		user = m_component->getFrontend()->createUser(presence->getFrom(), res, m_component, this);

		user->getRosterManager()->setStorageBackend(m_storageBackend);

		addUser(user);

	}

	// User can be handleDisconnected in addUser callback, so refresh the pointer

	user = getUser(userkey);

	if (!user) {

		m_userRegistry->onPasswordInvalid(presence->getFrom());

		return;

	}

	// Handle this presence

	user->handlePresence(presence);

	// Unavailable MUC presence should not trigger whole account disconnection, so block it here.

	bool isMUC = presence->getPayload<Swift::MUCPayload>() != NULL || *presence->getTo().getNode().c_str() == '#';

	if (isMUC)

		return;

	// Unavailable presence could remove this user, because he could be unavailable

	if (presence->getType() == Swift::Presence::Unavailable) {

		if (user) {

			if (user->getUserSetting("stay_connected") == "1") {

				return;

			}

			Swift::Presence::ref highest = m_component->getPresenceOracle()->getHighestPriorityPresence(presence->getFrom().toBare());

			// There's no presence for this user, so disconnect

			if (!highest || (highest && highest->getType() == Swift::Presence::Unavailable)) {

				m_removeTimer->onTick.connect(boost::bind(&UserManager::handleRemoveTimeout, this, user->getJID().toBare().toString(), user, false));

				m_removeTimer->start();

			}

		}

	}

}