void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {

			PurpleAccount *account = NULL;

			const char *protocol = CONFIG_STRING(config, "service.protocol").c_str();

			if (purple_accounts_find(legacyName.c_str(), protocol) != NULL){

// 				Log(user, "this account already exists");

				account = purple_accounts_find(legacyName.c_str(), protocol);

// 				User *u = (User *) account->ui_data;

// 				if (u && u != user) {

// 					Log(userInfo.jid, "This account is already connected by another jid " << user->getJID());

// 					return;

// 				}

			}

			else {

// 				Log(user, "creating new account");

				account = purple_account_new(legacyName.c_str(), protocol);

				purple_accounts_add(account);

			}

			m_sessions[user] = account;

			// Default avatar

			char* contents;

			gsize length;

			if (!CONFIG_STRING(config, "backend.avatars_directory").empty()) {

				std::string f = CONFIG_STRING(config, "backend.avatars_directory") + "/" + legacyName;

				ret = g_file_get_contents (f.c_str(), &contents, &length, NULL);

			}

			if (!CONFIG_STRING(config, "backend.default_avatar").empty() && !ret) {

				ret = g_file_get_contents (CONFIG_STRING(config, "backend.default_avatar").c_str(),

											&contents, &length, NULL);

			}

			if (ret) {

				purple_buddy_icons_set_account_icon(account, (guchar *) contents, length);

			}

			purple_account_set_password(account, password.c_str());

			purple_account_set_enabled(account, "spectrum", TRUE);

			const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AVAILABLE);

			if (status_type != NULL) {

				purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, NULL);

			}

			m_accounts[account] = user;

		}

#include "storagebackend.h"

namespace Transport {

class UserManager;

class User;

class Component;

class Buddy;

class LocalBuddy;

class Config;

class NetworkConversation;

class VCardResponder;

class RosterResponder;

class NetworkPluginServer {

	public:

		struct Backend {

			int pongReceived;

			std::list<User *> users;

			Swift::SafeByteArray data;

			boost::shared_ptr<Swift::Connection> connection;

			unsigned long res;

			unsigned long init_res;

			unsigned long shared;

		};

		NetworkPluginServer(Component *component, Config *config, UserManager *userManager);

		virtual ~NetworkPluginServer();

		int getBackendCount() {

			return m_clients.size();

		}

		const std::list<Backend *> &getBackends() {

			return m_clients;

		}

		void handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &message);

	private:

		void handleNewClientConnection(boost::shared_ptr<Swift::Connection> c);

		void handleSessionFinished(Backend *c);

		void handleDataRead(Backend *c, const Swift::SafeByteArray&);

		void handleConnectedPayload(const std::string &payload);

		void handleDisconnectedPayload(const std::string &payload);

		void handleBuddyChangedPayload(const std::string &payload);

[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= #patch to PKCS#12 certificate

#cert_password= #password to that certificate if any

backend=../../backends/libpurple/spectrum_libpurple_backend

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

#protocol=prpl-jabber

protocol=prpl-msn

#protocol=prpl-icq

[backend]

default_avatar=catmelonhead.jpg

[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

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

	signal(SIGCHLD, SigCatcher);

	exec_(CONFIG_STRING(m_config, "service.backend").c_str(), CONFIG_STRING(m_config, "service.backend_host").c_str(), CONFIG_STRING(m_config, "service.backend_port").c_str(), m_config->getConfigFile().c_str());

}

NetworkPluginServer::~NetworkPluginServer() {

	m_pingTimer->stop();

	m_server->stop();

	m_server.reset();

	delete m_component->m_factory;

	delete m_vcardResponder;

	delete m_rosterResponder;

}

void NetworkPluginServer::handleNewClientConnection(boost::shared_ptr<Swift::Connection> c) {

	Backend *client = new Backend;

	client->pongReceived = -1;

	client->connection = c;

	client->res = 0;

	client->init_res = 0;

	client->shared = 0;

	LOG4CXX_INFO(logger, "New backend " << client << " connected. Current backend count=" << (m_clients.size() + 1));

	if (m_clients.size() == 0) {

		// first backend connected, start the server, we're ready.

		m_component->start();

	}

	c->onDisconnected.connect(boost::bind(&NetworkPluginServer::handleSessionFinished, this, client));

	c->onDataRead.connect(boost::bind(&NetworkPluginServer::handleDataRead, this, client, _1));

	sendPing(client);

	client->pongReceived = -1;

	// some users are in queue waiting for this backend

	while(!m_waitingUsers.empty()) {

		// There's no new backend, so stop associating users and wait for new backend,

		// which has been already spawned in getFreeClient() call.

		if (getFreeClient() == NULL)

			break;

		User *u = m_waitingUsers.front();

		m_waitingUsers.pop_front();

		LOG4CXX_INFO(logger, "Associating " << u->getJID().toString() << " with this backend");

		// associate backend with user

		handleUserCreated(u);

		// connect user if it's ready

		if (u->isReadyToConnect()) {

			handleUserReadyToConnect(u);

		return;

	}

	send(c->connection, message);

}

void NetworkPluginServer::sendPing(Backend *c) {

	std::string message;

	pbnetwork::WrapperMessage wrap;

	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_PING);

	wrap.SerializeToString(&message);

	if (c->connection) {

		send(c->connection, message);

		c->pongReceived = false;

	}

// 	LOG4CXX_INFO(logger, "PING to " << c);

}

NetworkPluginServer::Backend *NetworkPluginServer::getFreeClient() {

	NetworkPluginServer::Backend *c = NULL;

	bool spawnNew = false;

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

		// This backend is free.

			c = *it;

			break;

		}

	}

	if (c == NULL) {

		exec_(CONFIG_STRING(m_config, "service.backend").c_str(), CONFIG_STRING(m_config, "service.backend_host").c_str(), CONFIG_STRING(m_config, "service.backend_port").c_str(), m_config->getConfigFile().c_str());

	}

	return c;

}

}