}

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

		}

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

	// Maybe this User instance has been deleted in mean time and we would remove new one,

	// so better check for it and ignore deletion if "u" does not exist anymore.

	User *user = getUser(jid);

	if (user != u) {

		return;

	}

	// Remove user

	if (user) {

		removeUser(user);

	}

	// Connect the user again when we're reconnecting.

	if (reconnect) {

		connectUser(jid);

	}

}

void UserManager::handleMessageReceived(Swift::Message::ref message) {

	User *user = getUser(message->getFrom().toBare().toString());

	if (!user ){

		return;

	}

	user->getConversationManager()->handleMessageReceived(message);

}

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

	switch(presence->getType()) {

		case Swift::Presence::Subscribe:

		case Swift::Presence::Subscribed:

		case Swift::Presence::Unsubscribe:

		case Swift::Presence::Unsubscribed:

			handleSubscription(presence);

			break;

		case Swift::Presence::Available:

		case Swift::Presence::Unavailable:

			break;

		case Swift::Presence::Probe:

			handleProbePresence(presence);

			break;

		default:

			break;

	};

}

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

	User *user = getUser(presence->getFrom().toBare().toString());

 	if (user) {

 		user->getRosterManager()->sendCurrentPresence(presence->getTo(), presence->getFrom());

 	}

 	else {

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

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

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

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

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

	}

}

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

	// answer to subscibe for transport itself

	if (presence->getType() == Swift::Presence::Subscribe && presence->getTo().getNode().empty()) {

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

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

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

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

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

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

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

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

// 		response->setType(Swift::Presence::Subscribe);

// 		m_component->getStanzaChannel()->sendPresence(response);

		return;

	}

	// Don't let RosterManager to handle presences for us

	if (presence->getTo().getNode().empty()) {

		return;

	}

	User *user = getUser(presence->getFrom().toBare().toString());

 	if (user) {

 		user->handleSubscription(presence);

 	}

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

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

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

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

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

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

	}

// 	else {

// // 		Log(presence->getFrom().toString().getUTF8String(), "Subscribe presence received, but this user is not logged in");

// 	}

}

void UserManager::connectUser(const Swift::JID &user) {

	// Called by UserRegistry in server mode when user connects the server and wants

	// to connect legacy network

	if (m_users.find(user.toBare().toString()) != m_users.end()) {

		if (!m_component->inServerMode()) {

			return;

		}

		User *u = m_users[user.toBare().toString()];

		if (u->isConnected()) {

			// User is already logged in, so his password is OK, but this new user has different password => bad password.

			// We can't call m_userRegistry->onPasswordInvalid() here, because this fuction is called from Swift::Parser

			// and onPasswordInvalid destroys whole session together with parser itself, which leads to crash.

			if (m_userRegistry->getUserPassword(user.toBare().toString()) != u->getUserInfo().password) {

				m_userRegistry->removeLater(user);

				return;

			}

			if (CONFIG_BOOL(m_component->getConfig(), "service.more_resources")) {

				m_userRegistry->onPasswordValid(user);

			}

			else {