static std::string getArg(const std::string &body) {

	std::string ret;

	if (body.find(" ") == std::string::npos)

		return ret;

	return body.substr(body.find(" ") + 1);

}

AdminInterface::AdminInterface(Component *component, UserManager *userManager, NetworkPluginServer *server, StorageBackend *storageBackend) {

	m_component = component;

	m_storageBackend = storageBackend;

	m_userManager = userManager;

	m_server = server;

	m_component->getStanzaChannel()->onMessageReceived.connect(bind(&AdminInterface::handleMessageReceived, this, _1));

}

AdminInterface::~AdminInterface() {

}

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

	if (!message->getTo().getNode().empty())

		return;

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

	    LOG4CXX_WARN(logger, "Message not from admin user, but from " << message->getFrom().toBare().toString());

	    return;

	}

	// Ignore empty messages

	if (message->getBody().empty()) {

		return;

	}

	LOG4CXX_INFO(logger, "Message from admin received");

	message->setTo(message->getFrom());

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

	if (message->getBody() == "status") {

		int users = m_userManager->getUserCount();

		int backends = m_server->getBackendCount();

		message->setBody("Running (" + boost::lexical_cast<std::string>(users) + " users connected using " + boost::lexical_cast<std::string>(backends) + " backends)");

	}

	else if (message->getBody() == "online_users") {

		std::string lst;

		const std::map<std::string, User *> &users = m_userManager->getUsers();

		if (users.size() == 0)

	return ret;

}

bool Config::load(std::istream &ifs, boost::program_options::options_description &opts, const std::string &_jid) {

	m_unregistered.clear();

	opts.add_options()

		("service.jid", value<std::string>()->default_value(""), "Transport Jabber ID")

		("service.server", value<std::string>()->default_value(""), "Server to connect to")

		("service.password", value<std::string>()->default_value(""), "Password used to auth the server")

		("service.port", value<int>()->default_value(0), "Port the server is listening on")

		("service.user", value<std::string>()->default_value(""), "The name of user Spectrum runs as.")

		("service.group", value<std::string>()->default_value(""), "The name of group Spectrum runs as.")

		("service.backend", value<std::string>()->default_value("libpurple_backend"), "Backend")

		("service.protocol", value<std::string>()->default_value(""), "Protocol")

		("service.pidfile", value<std::string>()->default_value("/var/run/spectrum2/$jid.pid"), "Full path to pid file")

		("service.working_dir", value<std::string>()->default_value("/var/lib/spectrum2/$jid"), "Working dir")

		("service.allowed_servers", value<std::string>()->default_value(""), "Only users from these servers can connect")

		("service.server_mode", value<bool>()->default_value(false), "True if Spectrum should behave as server")

		("service.users_per_backend", value<int>()->default_value(100), "Number of users per one legacy network backend")

		("service.backend_host", value<std::string>()->default_value("localhost"), "Host to bind backend server to")

		("service.backend_port", value<std::string>()->default_value("0"), "Port to bind backend server to")

		("service.cert", value<std::string>()->default_value(""), "PKCS#12 Certificate.")

		("service.cert_password", value<std::string>()->default_value(""), "PKCS#12 Certificate password.")

		("service.admin_password", value<std::string>()->default_value(""), "Administrator password.")

		("service.reuse_old_backends", value<bool>()->default_value(true), "True if Spectrum should use old backends which were full in the past.")

		("service.idle_reconnect_time", value<int>()->default_value(0), "Time in seconds after which idle users are reconnected to let their backend die.")

		("service.memory_collector_time", value<int>()->default_value(0), "Time in seconds after which backend with most memory is set to die.")

		("service.more_resources", value<bool>()->default_value(false), "Allow more resources to be connected in server mode at the same time.")

		("service.enable_privacy_lists", value<bool>()->default_value(true), "")

		("vhosts.vhost", value<std::vector<std::string> >()->multitoken(), "")

		("identity.name", value<std::string>()->default_value("Spectrum 2 Transport"), "Name showed in service discovery.")

		("identity.category", value<std::string>()->default_value("gateway"), "Disco#info identity category. 'gateway' by default.")

		("identity.type", value<std::string>()->default_value(""), "Type of transport ('icq','msn','gg','irc', ...)")

		("registration.enable_public_registration", value<bool>()->default_value(true), "True if users should be able to register.")

		("registration.language", value<std::string>()->default_value("en"), "Default language for registration form")

		("registration.instructions", value<std::string>()->default_value("Enter your legacy network username and password."), "Instructions showed to user in registration form")

		("registration.username_label", value<std::string>()->default_value("Legacy network username:"), "Label for username field")

		("registration.username_mask", value<std::string>()->default_value(""), "Username mask")

		("registration.auto_register", value<bool>()->default_value(false), "Register new user automatically when the presence arrives.")

		("registration.encoding", value<std::string>()->default_value("utf8"), "Default encoding in registration form")

		("registration.require_local_account", value<bool>()->default_value(false), "True if users have to have a local account to register to this transport from remote servers.")

		("registration.local_username_label", value<std::string>()->default_value("Local username:"), "Label for local usernme field")

		("registration.local_account_server", value<std::string>()->default_value("localhost"), "The server on which the local accounts will be checked for validity")

		("registration.local_account_server_timeout", value<int>()->default_value(10000), "Timeout when checking local user on local_account_server (msecs)")

		("gateway_responder.prompt", value<std::string>()->default_value("Contact ID"), "Value of <prompt> </promt> field")

		("gateway_responder.label", value<std::string>()->default_value("Enter legacy network contact ID."), "Label for add contact ID field")

		("database.type", value<std::string>()->default_value("none"), "Database type.")

	}

}

int UserManager::getUserCount() {

	return m_users.size();

}

void UserManager::handleDiscoInfo(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info) {

	User *user = getUser(jid.toBare().toString());

	if (!user) {

		return;

	}

	user->handleDiscoInfo(jid, info);

}

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

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

			Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, presence->getFrom(), m_component->getIQRouter());

			request->send();

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

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

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

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

			return;

		    }

		}

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

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

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

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

#include <string>

#include <map>

#include "Swiften/Swiften.h"

#include "Swiften/Server/UserRegistry.h"

#include "transport/userregistry.h"

#include "transport/logging.h"

namespace Transport {

DEFINE_LOGGER(logger, "UserRegistry");

UserRegistry::UserRegistry(Config *cfg, Swift::NetworkFactories *factories) {

	config = cfg;

	m_removeTimer = factories->getTimerFactory()->createTimer(1);

	m_inRemoveLater = false;

}

UserRegistry::~UserRegistry() { m_removeTimer->stop(); }

void UserRegistry::isValidUserPassword(const Swift::JID& user, Swift::ServerFromClientSession *session, const Swift::SafeByteArray& password) {

		if (std::find(x.begin(), x.end(), user.toBare().toString()) != x.end()) {

		    if (Swift::safeByteArrayToString(password) == CONFIG_STRING(config, "service.admin_password")) {

			session->handlePasswordValid();

		    }

		    else {

			session->handlePasswordInvalid();

		    }

		    return;

	    }

	std::string key = user.toBare().toString();

	// Users try to connect twice

	if (users.find(key) != users.end()) {

		// Kill the first session

		LOG4CXX_INFO(logger, key << ": Removing previous session and making this one active");

		Swift::ServerFromClientSession *tmp = users[key].session;

		users[key].session = session;

		tmp->handlePasswordInvalid();

	}

	LOG4CXX_INFO(logger, key << ": Connecting this user to find if password is valid");

	users[key].password = Swift::safeByteArrayToString(password);

	users[key].session = session;

	onConnectUser(user);

	return;

}

void UserRegistry::stopLogin(const Swift::JID& user, Swift::ServerFromClientSession *session) {

	std::string key = user.toBare().toString();

	if (users.find(key) != users.end()) {

		if (users[key].session == session) {