[service]

jid = localhost

password = secret

server = 127.0.0.1

port = 5222

server_mode = 1

backend_host=localhost # < this option doesn't work yet

backend_port=10001

users_per_backend=2

backend=../../backends/libpurple/libpurple_backend

#backend=../../backends/libircclient-qt/libircclient-qt_backend

protocol=prpl-jabber

#protocol=prpl-msn

#protocol=prpl-icq

[database]

type = sqlite3 # or "none" without database backend

database = test.sql

prefix=icq

#include "transport/config.h"

#include <fstream>

using namespace boost::program_options;

namespace Transport {

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

	std::ifstream ifs(configfile.c_str());

	if (!ifs.is_open())

		return false;

	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.backend", value<std::string>()->default_value("libpurple_backend"), "Backend")

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

		("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("10000"), "Port to bind backend server to")

		("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(""), "Instructions showed to user in registration form")

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

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

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

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

		("database.database", value<std::string>()->default_value(""), "Database used to store data")

		("database.prefix", value<std::string>()->default_value(""), "Prefix of tables in database")

	;

    store(parse_config_file(ifs, opts), m_variables);

	notify(m_variables);

	m_file = configfile;

	onConfigReloaded();

	return true;

}

bool Config::load(const std::string &configfile) {

	options_description opts("Transport options");

	return load(configfile, opts);

			return true;

		}

		mutable std::map<std::string, std::string> users;

		mutable Component *component;

};

Component::Component(Swift::EventLoop *loop, Config *config, Factory *factory) {

	m_component = NULL;

	m_userRegistry = NULL;

	m_server = NULL;

	m_reconnectCount = 0;

	m_config = config;

	m_factory = factory;

	m_jid = Swift::JID(CONFIG_STRING(m_config, "service.jid"));

	m_factories = new BoostNetworkFactories(loop);

	m_reconnectTimer = m_factories->getTimerFactory()->createTimer(1000);

	m_reconnectTimer->onTick.connect(bind(&Component::connect, this)); 

	if (CONFIG_BOOL(m_config, "service.server_mode")) {

		m_userRegistry = new MyUserRegistry(this);

		m_server = new Swift::Server(loop, m_factories, m_userRegistry, m_jid, CONFIG_INT(m_config, "service.port"));

		m_server->start();

		m_stanzaChannel = m_server->getStanzaChannel();

		m_iqRouter = m_server->getIQRouter();

		m_server->addPayloadParserFactory(new GenericPayloadParserFactory<StorageParser>("private", "jabber:iq:private"));

		m_server->onDataRead.connect(bind(&Component::handleDataRead, this, _1));

		m_server->onDataWritten.connect(bind(&Component::handleDataWritten, this, _1));

	}

	else {

		m_component = new Swift::Component(loop, m_factories, m_jid, CONFIG_STRING(m_config, "service.password"));

		m_component->setSoftwareVersion("", "");

		m_component->onConnected.connect(bind(&Component::handleConnected, this));

		m_component->onError.connect(bind(&Component::handleConnectionError, this, _1));

		m_component->onDataRead.connect(bind(&Component::handleDataRead, this, _1));

		m_component->onDataWritten.connect(bind(&Component::handleDataWritten, this, _1));

		m_stanzaChannel = m_component->getStanzaChannel();

		m_iqRouter = m_component->getIQRouter();

	}

	m_capsMemoryStorage = new CapsMemoryStorage();

	m_capsManager = new CapsManager(m_capsMemoryStorage, m_stanzaChannel, m_iqRouter);

	m_entityCapsManager = new EntityCapsManager(m_capsManager, m_stanzaChannel);

 	m_entityCapsManager->onCapsChanged.connect(boost::bind(&Component::handleCapsChanged, this, _1));