[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

admin_username=admin

admin_password=test

#cert=server.pfx #patch to PKCS#12 certificate

#cert_password=test #password to that certificate if any

users_per_backend=10

backend=/home/hanzz/code/libtransport/backends/libpurple/spectrum2_libpurple_backend

#protocol=prpl-msn

protocol=any

#protocol=prpl-icq

[backend]

#default_avatar=catmelonhead.jpg

#no_vcard_fetch=true

[logging]

#config=logging.cfg # log4cxx/log4j logging configuration file

#backend_config=backend_logging.cfg # log4cxx/log4j logging configuration file for backends

[database]

type = none # or "none" without database backend

database = test.sql

prefix=icq

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

	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/spectrum2.pid"), "Full path to pid file")

		("service.working_dir", value<std::string>()->default_value("/var/lib/spectrum2"), "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("10000"), "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_username", value<std::string>()->default_value(""), "Administrator username.")

		("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.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), "")

		("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(""), "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.server", value<std::string>()->default_value("localhost"), "Database server.")

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

		("database.password", value<std::string>()->default_value(""), "Database Password.")

		("database.port", value<int>()->default_value(0), "Database port.")

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

		("logging.config", value<std::string>()->default_value(""), "Path to log4cxx config file which is used for Spectrum 2 instance")

		("logging.backend_config", value<std::string>()->default_value(""), "Path to log4cxx config file which is used for backends")

		("backend.default_avatar", value<std::string>()->default_value(""), "Full path to default avatar")

		("backend.avatars_directory", value<std::string>()->default_value(""), "Path to directory with avatars")

		("backend.no_vcard_fetch", value<bool>()->default_value(false), "True if VCards for buddies should not be fetched. Only avatars will be forwarded.")

	;

		std::vector<std::string> groups;

		groups.push_back(payload.groups());

		buddy->setGroups(groups);

	}

	buddy->setStatus(Swift::StatusShow((Swift::StatusShow::Type) payload.status()), payload.statusmessage());

	buddy->setIconHash(payload.iconhash());

	buddy->setBlocked(payload.blocked());

}

NetworkPluginServer::NetworkPluginServer(Component *component, Config *config, UserManager *userManager) {

	std::cout << "BUDDY " << sizeof(LocalBuddy) << "\n";

	m_userManager = userManager;

	m_config = config;

	m_component = component;

	m_isNextLongRun = false;

	m_component->m_factory = new NetworkFactory(this);

	m_userManager->onUserCreated.connect(boost::bind(&NetworkPluginServer::handleUserCreated, this, _1));

	m_userManager->onUserDestroyed.connect(boost::bind(&NetworkPluginServer::handleUserDestroyed, this, _1));

	m_pingTimer = component->getNetworkFactories()->getTimerFactory()->createTimer(20000);

	m_pingTimer->onTick.connect(boost::bind(&NetworkPluginServer::pingTimeout, this));

	m_pingTimer->start();

		m_collectTimer->onTick.connect(boost::bind(&NetworkPluginServer::collectBackend, this));

		m_collectTimer->start();

	m_vcardResponder = new VCardResponder(component->getIQRouter(), component->getNetworkFactories(), userManager);

	m_vcardResponder->onVCardRequired.connect(boost::bind(&NetworkPluginServer::handleVCardRequired, this, _1, _2, _3));

	m_vcardResponder->onVCardUpdated.connect(boost::bind(&NetworkPluginServer::handleVCardUpdated, this, _1, _2));

	m_vcardResponder->start();

	m_rosterResponder = new RosterResponder(component->getIQRouter(), userManager);

	m_rosterResponder->onBuddyAdded.connect(boost::bind(&NetworkPluginServer::handleBuddyAdded, this, _1, _2));

	m_rosterResponder->onBuddyRemoved.connect(boost::bind(&NetworkPluginServer::handleBuddyRemoved, this, _1));

	m_rosterResponder->onBuddyUpdated.connect(boost::bind(&NetworkPluginServer::handleBuddyUpdated, this, _1, _2));

	m_rosterResponder->start();

	m_blockResponder = new BlockResponder(component->getIQRouter(), userManager);

	m_blockResponder->onBlockToggled.connect(boost::bind(&NetworkPluginServer::handleBlockToggled, this, _1));

	m_blockResponder->start();

	m_server = component->getNetworkFactories()->getConnectionServerFactory()->createConnectionServer(Swift::HostAddress(CONFIG_STRING(m_config, "service.backend_host")), boost::lexical_cast<int>(CONFIG_STRING(m_config, "service.backend_port")));

	m_server->onNewConnection.connect(boost::bind(&NetworkPluginServer::handleNewClientConnection, this, _1));

	m_server->start();

	LOG4CXX_INFO(logger, "Listening on host " << CONFIG_STRING(m_config, "service.backend_host") << " port " << CONFIG_STRING(m_config, "service.backend_port"));

#ifndef _WIN32

	signal(SIGCHLD, SigCatcher);

		}

	}

	BOOST_FOREACH(Backend *b, toRemove) {

		handleSessionFinished(b);

	}

	m_pingTimer->start();

}

void NetworkPluginServer::collectBackend() {

	// Stop accepting new users to backend with the biggest memory usage. This prevents backends

	// which are leaking to eat whole memory by connectin new users to legacy network.

	LOG4CXX_INFO(logger, "Collect backend called, finding backend which will be set to die");

	unsigned long max = 0;

	Backend *backend = NULL;

	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {

		if ((*it)->res > max) {

			max = (*it)->res;

			backend = (*it);

		}

	}

	if (backend) {

			m_collectTimer->start();

		LOG4CXX_INFO(logger, "Backend " << backend << "is set to die");

		backend->acceptUsers = false;

	}

}

bool NetworkPluginServer::moveToLongRunBackend(User *user) {

	// Check if user has already some backend

	Backend *old = (Backend *) user->getData();

	if (!old) {

		LOG4CXX_INFO(logger, "User " << user->getJID().toString() << " does not have old backend. Not moving.");

		return true;

	}

	// if he's already on long run, do nothing

	if (old->longRun) {

		LOG4CXX_INFO(logger, "User " << user->getJID().toString() << " is already on long-running backend. Not moving.");

		return true;

	}

	// Get free longrun backend, if there's no longrun backend, create one and wait

	// for its connection

	Backend *backend = getFreeClient(false, true);

	if (!backend) {

		LOG4CXX_INFO(logger, "No free long-running backend for user " << user->getJID().toString() << ". Will try later");