}

}

void IRCNetworkPlugin::readData() {

	size_t availableBytes = m_socket->bytesAvailable();

	if (availableBytes == 0)

		return;

	if (m_firstPing) {

		m_firstPing = false;

		// Users can join the network without registering if we allow

		// one user to connect multiple IRC networks.

		if (m_servers.empty()) {

			cfg.setNeedRegistration(false);

		}

	}

	std::string d = std::string(m_socket->readAll().data(), availableBytes);

	handleDataRead(d);

}

void IRCNetworkPlugin::sendData(const std::string &string) {

	m_socket->write(string.c_str(), string.size());

}

MyIrcSession *IRCNetworkPlugin::createSession(const std::string &user, const std::string &hostname, const std::string &nickname, const std::string &password, const std::string &suffix) {

	MyIrcSession *session = new MyIrcSession(user, this, suffix);

/// Represents Spectrum2 legacy network plugin.

/// This class is base class for all C++ legacy network plugins. It provides a way to connect 

/// Spectrum2 NetworkPluginServer and allows to use high-level API for legacy network plugins

/// development.

class NetworkPlugin {

	public:

		enum ExitCode { StorageBackendNeeded = -2 };

		class PluginConfig {

			public:

				virtual ~PluginConfig() {}

				void setNeedRegistration(bool needRegistration = false) { m_needRegistration = needRegistration; }

				void setNeedPassword(bool needPassword = true) { m_needPassword = needPassword; }

				void setSupportMUC(bool supportMUC = true) { m_supportMUC = supportMUC; }

				void setExtraFields(const std::vector<std::string> &fields) { m_extraFields = fields; }

				void setRawXML(bool rawXML = false) { m_rawXML = rawXML; }

			private:

				bool m_needPassword;

				bool m_needRegistration;

				bool m_supportMUC;

				bool m_rawXML;

				std::vector<std::string> m_extraFields;

				friend class NetworkPlugin;

		};

		/// Creates new NetworkPlugin and connects the Spectrum2 NetworkPluginServer.

		/// \param loop Event loop.

		/// \param host Host where Spectrum2 NetworkPluginServer runs.

		/// \param port Port.

		NetworkPlugin();

		/// Destructor.

void NetworkPlugin::sendConfig(const PluginConfig &cfg) {

	std::string data = "[registration]\n";

	data += std::string("needPassword=") + (cfg.m_needPassword ? "1" : "0") + "\n";

	data += std::string("needRegistration=") + (cfg.m_needRegistration ? "1" : "0") + "\n";

	for (std::vector<std::string>::const_iterator it = cfg.m_extraFields.begin(); it != cfg.m_extraFields.end(); it++) {

		data += std::string("extraField=") + (*it) + "\n";

	}

	data += "[features]\n";

	data += std::string("muc=") + (cfg.m_supportMUC ? "1" : "0") + "\n";

	data += std::string("rawxml=") + (cfg.m_rawXML ? "1" : "0") + "\n";

	pbnetwork::BackendConfig m;

	m.set_config(data);

	std::string message;

	m.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BACKEND_CONFIG);

	send(message);

}

	return commandLineArgs.str();

}

void Config::updateBackendConfig(const std::string &backendConfig) {

	options_description opts("Backend options");

	opts.add_options()

		("registration.needPassword", value<bool>()->default_value(true), "")

		("registration.needRegistration", value<bool>()->default_value(false), "")

		("registration.extraField", value<std::vector<std::string> >()->multitoken(), "")

		("features.receipts", value<bool>()->default_value(false), "")

		("features.muc", value<bool>()->default_value(false), "")

		("features.rawxml", value<bool>()->default_value(false), "")

	;

	std::stringstream ifs(backendConfig);

	parsed_options parsed = parse_config_file(ifs, opts, true);

	store(parsed, m_backendConfig);

	notify(m_backendConfig);

	onBackendConfigUpdated();

}

Config *Config::createFromArgs(int argc, char **argv, std::string &error, std::string &host, int &port) {

	std::string jid;

	std::ostringstream os;

	std::string configFile;

	boost::program_options::variables_map vm;

	boost::program_options::options_description desc("Usage: spectrum <config_file.cfg>\nAllowed options");

	desc.add_options()

		("help", "help")

		("host,h", boost::program_options::value<std::string>(&host)->default_value(""), "Host to connect to")

		("port,p", boost::program_options::value<int>(&port)->default_value(10000), "Port to connect to")

#include "Swiften/Server/ServerFromClientSession.h"

#include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"

#include "basictest.h"

#include "transport/util.h"

using namespace Transport;

class ConfigTest : public CPPUNIT_NS :: TestFixture{

	CPPUNIT_TEST_SUITE(ConfigTest);

	CPPUNIT_TEST(setStringTwice);

	CPPUNIT_TEST(updateBackendConfig);

	CPPUNIT_TEST(unregisteredList);

	CPPUNIT_TEST(unregisteredString);

	CPPUNIT_TEST(unregisteredListAsString);

	CPPUNIT_TEST(unregisteredStringAsList);

	CPPUNIT_TEST_SUITE_END();

	public:

		void setUp (void) {

		}

		void tearDown (void) {

		CPPUNIT_ASSERT_EQUAL(std::string("localhost"), CONFIG_STRING(&cfg, "service.jids"));

	}

	void updateBackendConfig() {

		Config cfg;

		CPPUNIT_ASSERT(!cfg.hasKey("registration.needPassword"));

		cfg.updateBackendConfig("[registration]\nneedPassword=0\n");

		CPPUNIT_ASSERT(cfg.hasKey("registration.needPassword"));

		CPPUNIT_ASSERT_EQUAL(false, CONFIG_BOOL(&cfg, "registration.needPassword"));

	}

	void unregisteredList() {

		Config cfg;

		std::istringstream ifs("service.irc_server = irc.freenode.org\nservice.irc_server=localhost\n");

		cfg.load(ifs);

		CPPUNIT_ASSERT_EQUAL(2, (int) CONFIG_LIST(&cfg, "service.irc_server").size());

	}

	void unregisteredString() {

		Config cfg;

		std::istringstream ifs("service.irc_server = irc.freenode.org");

		cfg.load(ifs);

		CPPUNIT_ASSERT_EQUAL(std::string("irc.freenode.org"), CONFIG_STRING(&cfg, "service.irc_server"));