BOOST_FOREACH(std::string &vhost, vhosts) {

					Config vhostCfg;

					if (vhostCfg.load(itr->path().string(), vhost) == false) {

						std::cerr << "Can't load config file " << itr->path().string() << ". Skipping...\n";

						continue;

					}

					int pid = isRunning(CONFIG_STRING(&vhostCfg, "service.pidfile"));

					if (pid) {

						std::cout << itr->path() << ": " << vhost << " Running\n";

					}

					else {

						ret = 3;

						std::cout << itr->path() << ": " << vhost << " Stopped\n";

					}

				}

			}

		}

	}

	catch (const filesystem_error& ex) {

		std::cerr << "boost filesystem error\n";

		exit(5);

	}

	return ret;

}

static void ask_local_servers(ManagerConfig *config, Swift::BoostNetworkFactories &networkFactories, const std::string &message) {

	path p(CONFIG_STRING(config, "service.config_directory"));

	try {

		if (!exists(p)) {

			std::cerr << "Config directory " << CONFIG_STRING(config, "service.config_directory") << " does not exist\n";

			exit(6);

		}

		if (!is_directory(p)) {

			std::cerr << "Config directory " << CONFIG_STRING(config, "service.config_directory") << " does not exist\n";

			exit(7);

		}

		directory_iterator end_itr;

		for (directory_iterator itr(p); itr != end_itr; ++itr) {

			if (is_regular(itr->path()) && extension(itr->path()) == ".cfg") {

				Config cfg;

				if (cfg.load(itr->path().string()) == false) {

					std::cerr << "Can't load config file " << itr->path().string() << ". Skipping...\n";

				}

					std::cerr << itr->path().string() << ": service.admin_jid or service.admin_password empty. This server can't be queried over XMPP.\n";

				}

				finished++;

				Swift::Client *client = new Swift::Client(CONFIG_VECTOR(&cfg, "service.admin_jid")[0], CONFIG_STRING(&cfg, "service.admin_password"), &networkFactories);

				client->setAlwaysTrustCertificates();

				client->onConnected.connect(boost::bind(&handleConnected, client, CONFIG_STRING(&cfg, "service.jid")));

				client->onDisconnected.connect(bind(&handleDisconnected, client, _1, CONFIG_STRING(&cfg, "service.jid")));

				client->onMessageReceived.connect(bind(&handleMessageReceived, client, _1, CONFIG_STRING(&cfg, "service.jid")));

				Swift::ClientOptions opt;

				opt.allowPLAINWithoutTLS = true;

				client->connect(opt);

			}

		}

	}

	catch (const filesystem_error& ex) {

		std::cerr << "boost filesystem error\n";

		exit(5);

	}

}

int main(int argc, char **argv)

{

	ManagerConfig config;

	std::string config_file;

	std::string command;

	boost::program_options::variables_map vm;

	boost::program_options::options_description desc("Usage: spectrum [OPTIONS] <COMMAND>\nCommands:\n"

													 " start - start all local Spectrum2 instances\n"

													 " stop  - stop all  local Spectrum2 instances\n"

													 " status - status of local Spectrum2 instances\n"

													 " <other> - send command to all local + remote Spectrum2 instances and print output\n"

													 "Allowed options");

	desc.add_options()

		("help,h", "Show help output")

		("config,c", boost::program_options::value<std::string>(&config_file)->default_value("/etc/spectrum2/spectrum_manager.cfg"), "Spectrum manager config file")

		("command", boost::program_options::value<std::string>(&command)->default_value(""), "Command")

		;

	try

	{

		boost::program_options::positional_options_description p;

		p.add("command", -1);

		boost::program_options::store(boost::program_options::command_line_parser(argc, argv).

          options(desc).positional(p).run(), vm);

		boost::program_options::notify(vm);

/**

 * libtransport -- C++ library for easy XMPP Transports development

 *

 * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

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

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

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

			LOG4CXX_INFO(logger, key << ": Stopping login process (user probably disconnected while logging in)");

			users.erase(key);

		}

		else {

			LOG4CXX_WARN(logger, key << ": Stopping login process (user probably disconnected while logging in), but this is not active session");

		}

	}

	else {

		LOG4CXX_WARN(logger, key << ": Stopping login process (user probably disconnected while logging in) for invalid user");

	}

	// ::removeLater can be called only by libtransport, not by Swift and libtransport

	// takes care about user disconnecting itself, so don't call our signal.

	if (!m_inRemoveLater)

		onDisconnectUser(user);

}

void UserRegistry::onPasswordValid(const Swift::JID &user) {

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

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

		LOG4CXX_INFO(logger, key << ": Password is valid");

		users[key].session->handlePasswordValid();

		users.erase(key);

	}