}

}

void IRCNetworkPlugin::handleLogoutRequest(const std::string &user, const std::string &legacyName) {

	if (m_sessions[user] == NULL) {

		LOG4CXX_WARN(logger, user << ": Already disconnected.");

		return;

	}

	LOG4CXX_INFO(logger, user << ": Disconnecting.");

	m_sessions[user]->close();

	m_sessions[user]->deleteLater();

	m_sessions.erase(user);

}

std::string IRCNetworkPlugin::getSessionName(const std::string &user, const std::string &legacyName) {

	std::string u = user;

	if (!CONFIG_BOOL(config, "service.server_mode") && m_servers.empty()) {

		u = user + legacyName.substr(legacyName.find("@") + 1);

		if (u.find("/") != std::string::npos) {

			u = u.substr(0, u.find("/"));

		}

	}

	return u;

}

std::string IRCNetworkPlugin::getTargetName(const std::string &legacyName) {

	std::string r = legacyName;

// 	if (!CONFIG_BOOL(config, "service.server_mode")) {

		if (legacyName.find("/") == std::string::npos) {

			r = legacyName.substr(0, r.find("@"));

		}

		else {

			r = legacyName.substr(legacyName.find("/") + 1);

		}

// 	}

	return r;

}

void IRCNetworkPlugin::handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &/*xhtml*/) {

	std::string session = getSessionName(user, legacyName);

	if (m_sessions[session] == NULL) {

		LOG4CXX_WARN(logger, user << ": Session name: " << session << ", No session for user");

		return;

	}

	std::string target = getTargetName(legacyName);

	LOG4CXX_INFO(logger, user << ": Session name: " << session << ", message to " << target);

	if (target.find("#") == 0) {

		handleMessage(user, legacyName, message, TO_UTF8(m_sessions[session]->nickName()));

	}

}

void IRCNetworkPlugin::handleRoomSubjectChangedRequest(const std::string &user, const std::string &room, const std::string &message) {

	std::string session = getSessionName(user, room);

	if (m_sessions[session] == NULL) {

		LOG4CXX_WARN(logger, user << ": Session name: " << session << ", No session for user");

		return;

	}

	std::string target = getTargetName(room);

	m_sessions[session]->sendCommand(IrcCommand::createTopic(FROM_UTF8(target), FROM_UTF8(message)));

}

void IRCNetworkPlugin::handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &password) {

	std::string session = getSessionName(user, room);

	std::string target = getTargetName(room);

	LOG4CXX_INFO(logger, user << ": Session name: " << session << ", Joining room " << target);

	if (m_sessions[session] == NULL) {

		if (m_servers.empty()) {

			// in gateway mode we want to login this user to network according to legacyName

			if (room.find("@") != std::string::npos) {

				// suffix is %irc.freenode.net to let MyIrcSession return #room%irc.freenode.net

				m_sessions[session] = createSession(user, room.substr(room.find("@") + 1), nickname, "", room.substr(room.find("@")));

			}

			else {

				LOG4CXX_WARN(logger, user << ": There's no proper server defined in room to which this user wants to join: " << room);

				return;

			}

		}

		else {

			LOG4CXX_WARN(logger, user << ": Join room requested for unconnected user");

			return;

		}

	}

	m_sessions[session]->addAutoJoinChannel(target, password);

	m_sessions[session]->sendCommand(IrcCommand::createJoin(FROM_UTF8(target), FROM_UTF8(password)));

	m_sessions[session]->rooms += 1;

	// update nickname, because we have nickname per session, no nickname per room.

	handleRoomNicknameChanged(user, target, TO_UTF8(m_sessions[session]->nickName()));

}

void IRCNetworkPlugin::handleLeaveRoomRequest(const std::string &user, const std::string &room) {

		bool flags = m_modes[it->second->getChannel() + nickname];

		LOG4CXX_INFO(logger, user << ": " << nickname << " changed nickname to " << TO_UTF8(m->nick()));

		np->handleParticipantChanged(user, nickname, it->second->getChannel() + suffix,(int) flags, pbnetwork::STATUS_ONLINE, "", TO_UTF8(m->nick()));

	}

}

void MyIrcSession::on_modeChanged(IrcMessage *message) {

	IrcModeMessage *m = (IrcModeMessage *) message;

	// mode changed: "#testik" "HanzZ" "+o" "hanzz_k"

	std::string nickname = TO_UTF8(m->argument());

	std::string mode = TO_UTF8(m->mode());

	if (nickname.empty())

		return;

	LOG4CXX_INFO(logger, user << ": " << nickname << " changed mode to " << mode);

	for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {

		if (mode == "+o") {

			m_modes[it->second->getChannel() + nickname] = 1;

		}

		else {

			m_modes[it->second->getChannel() + nickname] = 0;

		}

		bool flags = m_modes[it->second->getChannel() + nickname];

		np->handleParticipantChanged(user, nickname, it->second->getChannel() + suffix,(int) flags, pbnetwork::STATUS_ONLINE, "");

	}

}

void MyIrcSession::on_topicChanged(IrcMessage *message) {

	IrcTopicMessage *m = (IrcTopicMessage *) message;

	bool flags = 0;

	std::string nickname = TO_UTF8(m->sender().name());

	flags = correctNickname(nickname);

	LOG4CXX_INFO(logger, user << ": " << nickname << " topic changed to " << TO_UTF8(m->topic()));

	np->handleSubject(user, TO_UTF8(m->channel()) + suffix, TO_UTF8(m->topic()), nickname);

}

void MyIrcSession::on_messageReceived(IrcMessage *message) {

	IrcPrivateMessage *m = (IrcPrivateMessage *) message;

	if (m->isRequest()) {

		QString request = m->message().split(" ", QString::SkipEmptyParts).value(0).toUpper();

		if (request == "PING" || request == "TIME" || request == "VERSION") {

			LOG4CXX_INFO(logger, user << ": " << TO_UTF8(request) << " received and has been answered");

			return;

		}

	}

	std::string target = TO_UTF8(m->target());

	LOG4CXX_INFO(logger, user << ": Message from " << target);

	if (target.find("#") == 0) {

		bool flags = 0;

		std::string nickname = TO_UTF8(m->sender().name());

		flags = correctNickname(nickname);

	}

	else {

		bool flags = 0;

		std::string nickname = TO_UTF8(m->sender().name());

		flags = correctNickname(nickname);

		LOG4CXX_INFO(logger, nickname + suffix);

	}

}

void MyIrcSession::on_numericMessageReceived(IrcMessage *message) {

	QString channel;

	QStringList members;

	IrcNumericMessage *m = (IrcNumericMessage *) message;

	switch (m->code()) {

		case 332:

			m_topicData = TO_UTF8(m->parameters().value(2));

			break;

		case 333:

			 np->handleSubject(user, TO_UTF8(m->parameters().value(1)) + suffix, m_topicData, TO_UTF8(m->parameters().value(2)));

			break;

		case 353:

			channel = m->parameters().value(2);

			members = m->parameters().value(3).split(" ");

			LOG4CXX_INFO(logger, user << ": Received members for " << TO_UTF8(channel) << suffix);

			for (int i = 0; i < members.size(); i++) {

				bool flags = 0;

				std::string nickname = TO_UTF8(members.at(i));

				flags = correctNickname(nickname);

				m_modes[TO_UTF8(channel) + nickname] = flags;

				np->handleParticipantChanged(user, nickname, TO_UTF8(channel) + suffix,(int) flags, pbnetwork::STATUS_ONLINE);

			}

			break;

		case 432:

			np->handleDisconnected(user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Erroneous Nickname");

			break;

		default:

			break;

	}

	//qDebug() << "numeric message received:" << receiver() << origin << code << params;

}

void MyIrcSession::onMessageReceived(IrcMessage *message) {

	LOG4CXX_INFO(logger, user << ": " << TO_UTF8(message->toString()));

	switch (message->type()) {

		case IrcMessage::Join:

			on_joined(message);

			break;

		case IrcMessage::Part:

			on_parted(message);

			break;

		case IrcMessage::Quit:

[service]

# 1 if Spectrum should run in server mode.

server_mode = 1

# The name of user/group Spectrum runs as.

#user=spectrum

#group=spectrum

# JID of Spectrum instance.

jid = localhost

# Password used to connect the XMPP server in gateway mode.

# In server mode, this option is ignored.

password = secret

# XMPP server to which Spectrum connects in gateway mode.

# In server mode, this option is ignored.

server = 127.0.0.1

# XMPP server port.

port = 5222

# Interface on which Spectrum listens for backends.

backend_host = localhost

# Port on which Spectrum listens for backends.

# By default Spectrum chooses random backend port and there's

# no need to change it normally

#backend_port=10001

# Full path to PKCS#12 cetficiate used for TLS in server mode.

#cert=

# Certificate password if any.

#cert_password= 

# Number of users per one legacy network backend.

users_per_backend=10

# Full path to backend binary.

backend=/usr/bin/spectrum2_libpurple_backend

# For skype:

#backend=/usr/bin/xvfb-run -n BACKEND_ID -s "-screen 0 10x10x8" -f /tmp/x-skype-gw /usr/bin/spectrum2_skype_backend

# Libpurple protocol-id for spectrum_libpurple_backend

protocol=prpl-jabber

#protocol=prpl-msn

#protocol=prpl-icq

# prpl-any means that user sets his protocol in his JID which has to be

# in following format: protocol.username@domain.tld

# So for example: prpl-jabber.hanzz.k%gmail.com@domain.tld

#protocol=prpl-any

[identity]

# Name of Spectrum instance in service discovery

name=Spectrum Jabber Transport

# Type of transport ("msn", "icq", "xmpp").

# Check http://xmpp.org/registrar/disco-categories.html#gateway

type=xmpp

# Category of transport, default is "gateway

#category=gateway

[logging]

# log4cxx/log4j logging configuration file in ini format used for main spectrum2 instance.

config = /etc/spectrum2/logging.cfg

# log4cxx/log4j logging configuration file in ini format used for backends.

backend_config = /etc/spectrum2/backend-logging.cfg

[database]

# Database backend type

# "sqlite3", "mysql", "pqxx", or "none" without database backend

type = none

# For SQLite3: Full path to database

# For MySQL and PostgreSQL: name of database

# default database = /var/lib/spectrum2/$jid/database.sql

#database = jabber_transport

# Server.

#server = localhost

# Port.

#port = 0

# User.

#include "transport/storagebackend.h"

#include "transport/config.h"

#include "transport/sqlite3backend.h"

#include "transport/mysqlbackend.h"

#include "transport/pqxxbackend.h"

namespace Transport {

StorageBackend *StorageBackend::createBackend(Config *config, std::string &error) {

	StorageBackend *storageBackend = NULL;

#ifdef WITH_SQLITE

		storageBackend = new SQLite3Backend(config);

	}

#else

	if (CONFIG_STRING(config, "database.type") == "sqlite3") {

		error = "Libtransport is not compiled with sqlite3 backend support.";

	}

#endif

#ifdef WITH_MYSQL

	if (CONFIG_STRING(config, "database.type") == "mysql") {

		storageBackend = new MySQLBackend(config);

	}

#else

	if (CONFIG_STRING(config, "database.type") == "mysql") {

		error = "Spectrum2 is not compiled with mysql backend support.";

	}

#endif

#ifdef WITH_PQXX

	if (CONFIG_STRING(config, "database.type") == "pqxx") {

		storageBackend = new PQXXBackend(config);

	}

#else

	if (CONFIG_STRING(config, "database.type") == "pqxx") {

		error = "Spectrum2 is not compiled with pqxx backend support.";

	}

#endif

	if (CONFIG_STRING(config, "database.type") != "mysql" && CONFIG_STRING(config, "database.type") != "sqlite3"

		&& CONFIG_STRING(config, "database.type") != "pqxx" && CONFIG_STRING(config, "database.type") != "none") {

		error = "Unknown storage backend " + CONFIG_STRING(config, "database.type");

	}

	return storageBackend;

}

}