m_identify = "NickServ identify $name $password";

	}

}

void IRCNetworkPlugin::tryNextServer() {

	if (!m_servers.empty()) {

		int nextServer = (m_currentServer + 1) % m_servers.size();

		LOG4CXX_INFO(logger, "Server " << m_servers[m_currentServer] << " disconnected user. Next server to try will be " << m_servers[nextServer]);

		m_currentServer = nextServer;

	}

}

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

			NetworkPlugin::PluginConfig cfg;

			cfg.setNeedRegistration(false);

			sendConfig(cfg);

		}

	}

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

	session->setUserName(FROM_UTF8(nickname));

	session->setNickName(FROM_UTF8(nickname));

	session->setRealName(FROM_UTF8(nickname));

	session->setHost(FROM_UTF8(hostname));

	session->setPort(6667);

// 	session->setEncoding("UTF8");

	if (!password.empty()) {

		std::string identify = m_identify;

		boost::replace_all(identify, "$password", password);

#endif

#include <algorithm>

#include "errno.h"

#include <boost/make_shared.hpp>

#ifdef WITH_LIBEVENT

#include <event.h>

#endif

#ifdef WIN32

#include "win32/win32dep.h"

#define close closesocket

#define ssize_t SSIZE_T

#include <process.h>

#define getpid _getpid

#endif

#include "purple_defs.h"

DEFINE_LOGGER(logger_libpurple, "libpurple");

DEFINE_LOGGER(logger, "backend");

int main_socket;

static int writeInput;

using namespace Transport;

template <class T> T fromString(const std::string &str) {

	T i;

	std::istringstream os(str);

	os >> i;

	return i;

}

template <class T> std::string stringOf(T object) {

	std::ostringstream os;

	os << object;

	return (os.str());

}

static std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {

    std::stringstream ss(s);

    std::string item;

    while(std::getline(ss, item, delim)) {

        elems.push_back(item);

    }

    return elems;

}

// 		purple_commands_init();

	}

	return ret;

}

static void transportDataReceived(gpointer data, gint source, PurpleInputCondition cond) {

	if (cond & PURPLE_INPUT_READ) {

		char buffer[65535];

		char *ptr = buffer;

#ifdef WIN32

		ssize_t n = recv(source, ptr, sizeof(buffer), 0);

#else

		ssize_t n = read(source, ptr, sizeof(buffer));

#endif

		if (n <= 0) {

			if (errno == EAGAIN) {

				return;

			}

			LOG4CXX_INFO(logger, "Diconnecting from spectrum2 server");

			exit(errno);

		}

		std::string d = std::string(buffer, n);

		np->handleDataRead(d);

	}

	else {

		if (writeInput != 0) {

			purple_input_remove_wrapped(writeInput);

			writeInput = 0;

		}

		np->readyForData();

	}

}

int main(int argc, char **argv) {

#ifndef WIN32

#ifndef __FreeBSD__

		mallopt(M_CHECK_ACTION, 2);

		mallopt(M_PERTURB, 0xb);

#endif

		signal(SIGPIPE, SIG_IGN);

		if (signal(SIGCHLD, spectrum_sigchld_handler) == SIG_ERR) {

			std::cout << "SIGCHLD handler can't be set\n";

			return -1;

		}

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

 */

#pragma once

#include <time.h>

#include "transport/protocol.pb.h"

// #include "conversation.h"

#include <iostream>

#include <list>

namespace Transport {

/// 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 setExtraFields(const std::vector<std::string> &fields) { m_extraFields = fields; }

			private:

				bool m_needPassword;

				bool m_needRegistration;

				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.

		virtual ~NetworkPlugin();

		void sendConfig(const PluginConfig &cfg);

		/// Call this function when legacy network buddy changed.

		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")

		/// \param buddyName Name of legacy network buddy. (eg. "user2@gmail.com")

		/// \param alias Alias of legacy network buddy. If empty, then it's not changed on XMPP side.

		/// \param groups Groups in which buddy currently is. If empty, then it's not changed on XMPP side.

		/// \param status Status of this buddy.

		/// \param statusMessage Status message of this buddy.

		/// \param iconHash MD5 hash of buddy icon. Empty if none buddy icon.

	return (os.str());

}

NetworkPlugin::NetworkPlugin() {

	m_pingReceived = false;

	double shared;

#ifndef WIN32

	process_mem_usage(shared, m_init_res);

#endif

}

NetworkPlugin::~NetworkPlugin() {

}

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

	}

	pbnetwork::BackendConfig m;

	m.set_config(data);

	std::string message;

	m.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BACKEND_CONFIG);

	send(message);

}

void NetworkPlugin::handleMessage(const std::string &user, const std::string &legacyName, const std::string &msg, const std::string &nickname, const std::string &xhtml, const std::string &timestamp, bool headline) {

	pbnetwork::ConversationMessage m;

	m.set_username(user);

	m.set_buddyname(legacyName);

	m.set_message(msg);

	m.set_nickname(nickname);

	m.set_xhtml(xhtml);

	m.set_timestamp(timestamp);

	m.set_headline(headline);

	std::string message;

	m.SerializeToString(&message);

			sectionValues[varItem.first] = varItem.second;

	}

	return sectionValues;

}

std::string Config::getCommandLineArgs() const {

	std::ostringstream commandLineArgs;

	// Return the command-line arguments that were passed to us originally (but remove the initial .exe part)

	for (int i = 1; i < m_argc; ++i) 	{

		commandLineArgs << "\"" << m_argv[i] << "\" ";

	}

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

	;

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

		("no-daemonize,n", "Do not run spectrum as daemon")

		("no-debug,d", "Create coredumps on crash")

		("jid,j", boost::program_options::value<std::string>(&jid)->default_value(""), "Specify JID of transport manually")

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

 */

#include "discoinforesponder.h"

#include <iostream>

#include <boost/bind.hpp>

#include <boost/algorithm/string.hpp>

#include "Swiften/Disco/DiscoInfoResponder.h"

#include "Swiften/Queries/IQRouter.h"

#include "Swiften/Elements/DiscoInfo.h"

#include "transport/config.h"

#include "transport/logging.h"

#include "Swiften/Disco/CapsInfoGenerator.h"

using namespace Swift;

using namespace boost;

DEFINE_LOGGER(logger, "DiscoInfoResponder");

namespace Transport {

DiscoInfoResponder::DiscoInfoResponder(Swift::IQRouter *router, Config *config) : Swift::GetResponder<DiscoInfo>(router) {

	m_config = config;

	m_buddyInfo = NULL;

	m_transportInfo.addIdentity(DiscoInfo::Identity(CONFIG_STRING(m_config, "identity.name"),

													CONFIG_STRING(m_config, "identity.category"),

													CONFIG_STRING(m_config, "identity.type")));

}

DiscoInfoResponder::~DiscoInfoResponder() {

	delete m_buddyInfo;

}

	std::list<std::string> features;

	features.push_back("http://jabber.org/protocol/disco#items");

	features.push_back("http://jabber.org/protocol/disco#info");

	features.push_back("http://jabber.org/protocol/chatstates");

	features.push_back("http://jabber.org/protocol/xhtml-im");

	if (CONFIG_BOOL_DEFAULTED(m_config, "features.receipts", false)) {

		features.push_back("urn:xmpp:receipts");

	}

	setBuddyFeatures(features);

}

void DiscoInfoResponder::setTransportFeatures(std::list<std::string> &features) {

	for (std::list<std::string>::iterator it = features.begin(); it != features.end(); it++) {

		if (!m_transportInfo.hasFeature(*it)) {

			m_transportInfo.addFeature(*it);

		}

	}

}

void DiscoInfoResponder::setBuddyFeatures(std::list<std::string> &f) {

	delete m_buddyInfo;

	m_buddyInfo = new Swift::DiscoInfo;

	m_buddyInfo->addIdentity(DiscoInfo::Identity(CONFIG_STRING(m_config, "identity.name"), "client", "pc"));

class Config;

class DiscoInfoResponder : public Swift::GetResponder<Swift::DiscoInfo> {

	public:

		DiscoInfoResponder(Swift::IQRouter *router, Config *config);

		~DiscoInfoResponder();

		void setTransportFeatures(std::list<std::string> &features);

		void setBuddyFeatures(std::list<std::string> &features);

		void addRoom(const std::string &jid, const std::string &name);

		void clearRooms();

		void addAdHocCommand(const std::string &node, const std::string &name);

		boost::signal<void (const Swift::CapsInfo &capsInfo)> onBuddyCapsInfoChanged;

		Swift::CapsInfo &getBuddyCapsInfo() {

				return m_capsInfo;

		}

	private:

		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::DiscoInfo> payload);

		Swift::DiscoInfo m_transportInfo;

		Swift::DiscoInfo *m_buddyInfo;

		Config *m_config;

		Swift::CapsInfo m_capsInfo;

		std::map<std::string, std::string> m_rooms;

		std::map<std::string, std::string> m_commands;

};

}