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

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;

[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

	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;

	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;

}

}