return;

		}

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

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

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

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

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

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

			m_component->getStanzaChannel()->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;

		}

		UserInfo res;

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

		// In server mode, there's no registration, but we store users into database

		// (if storagebackend is available) because of caching. Passwords are not stored

		// in server mode.

		if (m_component->inServerMode()) {

			if (!registered) {

				res.password = "";

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

				res.jid = userkey;

				if (res.uin.find_last_of("%") != std::string::npos) {

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

				}

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

		}

		// Unregistered users are not able to login

		if (!registered) {

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

			return;

		}

		// Create new user class and set storagebackend

		user = new User(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) {

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

			}

		}

	}

}

void UserManager::handleRemoveTimeout(const std::string jid, User *u, bool reconnect) {

	m_removeTimer->onTick.disconnect(boost::bind(&UserManager::handleRemoveTimeout, this, jid, u, reconnect));

	User *user = getUser(jid);

	if (user != u) {

		return;

	}

	if (user) {