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

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

		void handleUserCreated(User *user);

		void handleRoomJoined(User *user, const Swift::JID &who, const std::string &room, const std::string &nickname, const std::string &password);

		void handleRoomLeft(User *user, const std::string &room);

		void handleUserReadyToConnect(User *user);

		void handleUserPresenceChanged(User *user, Swift::Presence::ref presence);

		void handleUserDestroyed(User *user);

		void handleBuddyUpdated(Buddy *buddy, const Swift::RosterItemPayload &item);

		void handleBuddyRemoved(Buddy *buddy);

		void handleBuddyAdded(Buddy *buddy, const Swift::RosterItemPayload &item);

		void handleBlockToggled(Buddy *buddy);

		void handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> vcard);

		void handleVCardRequired(User *user, const std::string &name, unsigned int id);

		void handleFTStateChanged(Swift::FileTransfer::State state, const std::string &userName, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long id);

		void handleFTAccepted(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID);

		void handleFTRejected(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size);

		void handleFTDataNeeded(Backend *b, unsigned long ftid);

	private:

		void send(boost::shared_ptr<Swift::Connection> &, const std::string &data);

		void pingTimeout();

		void sendPing(Backend *c);

		Backend *getFreeClient(bool acceptUsers = true, bool longRun = false, bool check = false);

		void connectWaitingUsers();

		void loginDelayFinished();

		UserManager *m_userManager;

		VCardResponder *m_vcardResponder;

		RosterResponder *m_rosterResponder;

		BlockResponder *m_blockResponder;

		Config *m_config;

		boost::shared_ptr<Swift::ConnectionServer> m_server;

		std::list<Backend *>  m_clients;

		Swift::Timer::ref m_pingTimer;

		Swift::Timer::ref m_collectTimer;

		Swift::Timer::ref m_loginTimer;

		Component *m_component;

		std::list<User *> m_waitingUsers;

		bool m_isNextLongRun;

		std::map<unsigned long, FileTransferManager::Transfer> m_filetransfers;

		FileTransferManager *m_ftManager;

		std::vector<std::string> m_crashedBackends;

		AdminInterface *m_adminInterface;

		bool m_startingBackend;

		DiscoItemsResponder *m_discoItemsResponder;

		time_t m_lastLogin;

};

}

log4j.rootLogger=debug, R

log4j.appender.R=org.apache.log4j.RollingFileAppender

log4j.appender.R.MaxFileSize=10000KB

# Keep one backup file

log4j.appender.R.MaxBackupIndex=1

log4j.appender.R.layout=org.apache.log4j.PatternLayout

		;

	os << desc;

	try

	{

		boost::program_options::positional_options_description p;

		p.add("config", -1);

		boost::program_options::store(boost::program_options::command_line_parser(argc, argv).

			options(desc).positional(p).allow_unregistered().run(), vm);

		boost::program_options::notify(vm);

		if(vm.count("help"))

		{

			error = os.str();

			return NULL;

		}

		if(vm.count("config") == 0) {

			error = os.str();

			return NULL;

		}

	}

	catch (std::runtime_error& e)

	{

		return NULL;

	}

	catch (...)

	{

		error = os.str();

		return NULL;

	}

	Config *config = new Config(argc, argv);

	if (!config->load(configFile)) {

		error = "Can't open " + configFile + " configuration file.\n";

		delete config;

		return NULL;

	}

	return config;

}

}

		root->addAppender(new ConsoleAppender(new PatternLayout(L"%d %-5p %c: %m%n")));

#else

		root->addAppender(new ConsoleAppender(new PatternLayout("%d %-5p %c: %m%n")));

#endif

	}

	else {

		log4cxx::helpers::Properties p;

		log4cxx::helpers::FileInputStream *istream = NULL;

		try {

			istream = new log4cxx::helpers::FileInputStream(CONFIG_STRING(config, key));

		}

		catch(log4cxx::helpers::IOException &ex) {

			std::cerr << "Can't create FileInputStream logger instance: " << ex.what() << "\n";

		}

		catch (...) {

			std::cerr << "Can't create FileInputStream logger instance\n";

		}

		if (!istream) {

			return;

		}

		p.load(istream);

		log4cxx::helpers::Transcoder::decode(boost::lexical_cast<std::string>(getpid()), pid);

		log4cxx::helpers::Transcoder::decode(CONFIG_STRING(config, "service.jid"), jid);

#ifdef _MSC_VER

		p.setProperty(L"pid", pid);

		p.setProperty(L"jid", jid);

#else

		p.setProperty("pid", pid);

		p.setProperty("jid", jid);

#endif

		std::string dir;

		BOOST_FOREACH(const log4cxx::LogString &prop, p.propertyNames()) {

				log4cxx::helpers::Transcoder::encode(p.get(prop), dir);

				boost::replace_all(dir, "${jid}", jid);

				break;

		}

		mode_t old_cmask;

		if (!dir.empty()) {

			// create directories

#ifndef WIN32

			old_cmask = umask(0007);

#endif

			try {

				Transport::Util::createDirectories(config, boost::filesystem::path(dir).parent_path());

			}

			catch (const boost::filesystem::filesystem_error &e) {

				std::cerr << "Can't create logging directory directory " << boost::filesystem::path(dir).parent_path().string() << ": " << e.what() << ".\n";

			}

		}

		log4cxx::PropertyConfigurator::configure(p);

		// Change owner of main log file

#ifndef WIN32

	if (!CONFIG_STRING(config, "service.group").empty() && !CONFIG_STRING(config, "service.user").empty()) {

		struct group *gr;

		if ((gr = getgrnam(CONFIG_STRING(config, "service.group").c_str())) == NULL) {

			std::cerr << "Invalid service.group name " << CONFIG_STRING(config, "service.group") << "\n";

		}

#include <Swiften/FileTransfer/ReadBytestream.h>

#include <Swiften/Elements/StreamInitiationFileInfo.h>

#ifdef _WIN32

#include "windows.h"

#include <stdint.h>

#else

#include "sys/wait.h"

#include "sys/signal.h"

#include <sys/types.h>

#include <signal.h>

#include "popt.h"

#endif

using namespace Transport::Util;

namespace Transport {

static unsigned long backend_id;

static unsigned long bytestream_id;

DEFINE_LOGGER(logger, "NetworkPluginServer");

class NetworkConversation : public Conversation {

	public:

		NetworkConversation(ConversationManager *conversationManager, const std::string &legacyName, bool muc = false) : Conversation(conversationManager, legacyName, muc) {

		}

		// Called when there's new message to legacy network from XMPP network

		void sendMessage(boost::shared_ptr<Swift::Message> &message) {

			onMessageToSend(this, message);

		}

		boost::signal<void (NetworkConversation *, boost::shared_ptr<Swift::Message> &)> onMessageToSend;

};

class NetworkFactory : public Factory {

	public:

		NetworkFactory(NetworkPluginServer *nps) {

			m_nps = nps;

		}

		virtual ~NetworkFactory() {}

		// Creates new conversation (NetworkConversation in this case)

		Conversation *createConversation(ConversationManager *conversationManager, const std::string &legacyName, bool isMuc) {

			NetworkConversation *nc = new NetworkConversation(conversationManager, legacyName, isMuc);

				return NULL;

			}

			if (buddyInfo.subscription == "both") {

				buddy->setSubscription(Buddy::Both);

			}

			else {

				buddy->setSubscription(Buddy::Ask);

			}

			if (buddyInfo.settings.find("icon_hash") != buddyInfo.settings.end())

				buddy->setIconHash(buddyInfo.settings.find("icon_hash")->second.s);

			return buddy;

		}

	private:

		NetworkPluginServer *m_nps;

};

// Wraps google protobuf payload into WrapperMessage and serialize it to string

#define WRAP(MESSAGE, TYPE) 	pbnetwork::WrapperMessage wrap; \

	wrap.set_type(TYPE); \

	wrap.set_payload(MESSAGE); \

	wrap.SerializeToString(&MESSAGE);

// Executes new backend

	// BACKEND_ID is replaced with unique ID. The ID is increasing for every backend.

	std::string finalExePath = boost::replace_all_copy(exePath, "BACKEND_ID", boost::lexical_cast<std::string>(backend_id++));	

#ifdef _WIN32

	// Add host and port.

	std::ostringstream fullCmdLine;

	fullCmdLine << "\"" << finalExePath << "\" --host " << host << " --port " << port;

	if (cmdlineArgs)

		fullCmdLine << " " << cmdlineArgs;

	LOG4CXX_INFO(logger, "Starting new backend " << fullCmdLine.str());

	// We must provide a non-const buffer to CreateProcess below

	std::vector<wchar_t> rawCommandLineArgs( fullCmdLine.str().size() + 1 );

	wcscpy_s(&rawCommandLineArgs[0], rawCommandLineArgs.size(), utf8ToUtf16(fullCmdLine.str()).c_str());

	STARTUPINFO         si;

	PROCESS_INFORMATION pi;

	ZeroMemory (&si, sizeof(si));

	si.cb=sizeof (si);

	if (! CreateProcess(

		utf8ToUtf16(finalExePath).c_str(),

		&rawCommandLineArgs[0],

		0,                    // process attributes

		0,                    // thread attributes

		0,                    // inherit handles

		0,                    // creation flags

		0,                    // environment

		0,                    // cwd

		&si,

		&pi

		)

	)  {

		LOG4CXX_ERROR(logger, "Could not start process");

	}

	return 0;

#else

	// Add host and port.

	LOG4CXX_INFO(logger, "Starting new backend " << finalExePath);

	// Create array of char * from string using -lpopt library

	char *p = (char *) malloc(finalExePath.size() + 1);

	strcpy(p, finalExePath.c_str());

	int argc;

	char **argv;

	poptParseArgvString(p, &argc, (const char ***) &argv);

	// fork and exec

	pid_t pid = fork();

	if ( pid == 0 ) {

		setsid();

		// close all files

		int maxfd=sysconf(_SC_OPEN_MAX);

		for(int fd=3; fd<maxfd; fd++) {

			close(fd);

		}

		// child process

		errno = 0;

		int ret = execv(argv[0], argv);

		if (ret == -1) {

			exit(errno);

		}

		exit(0);

	} else if ( pid < 0 ) {

		LOG4CXX_ERROR(logger, "Fork failed");

	}

	free(p);

	return (unsigned long) pid;

#endif

}

#ifndef _WIN32

static void SigCatcher(int n) {

	pid_t result;

	int status;

	// Read exit code from all children to not have zombies arround

	// WARNING: Do not put LOG4CXX_ here, because it can lead to deadlock

	while ((result = waitpid(-1, &status, WNOHANG)) > 0) {

		if (result != 0) {

			if (WIFEXITED(status)) {

				if (WEXITSTATUS(status) != 0) {

// 					LOG4CXX_ERROR(logger, "Backend can not be started, exit_code=" << WEXITSTATUS(status));

				}

			}

			else {

// 				LOG4CXX_ERROR(logger, "Backend can not be started");

			}

		}

	}

}

#endif

static void handleBuddyPayload(LocalBuddy *buddy, const pbnetwork::Buddy &payload) {

	// Set alias only if it's not empty. Backends are allowed to send empty alias if it has

	// not changed.

	if (!payload.alias().empty()) {

		buddy->setAlias(payload.alias());

	}

	// Change groups if it's not empty. The same as above...

	std::vector<std::string> groups;

	for (int i = 0; i < payload.group_size(); i++) {

		std::string group = payload.group(i);

		utf8::replace_invalid(payload.group(i).begin(), payload.group(i).end(), group.begin(), '_');

		groups.push_back(group);

	}

	if (!groups.empty()) {

		buddy->setGroups(groups);

	}

	buddy->setStatus(Swift::StatusShow((Swift::StatusShow::Type) payload.status()), payload.statusmessage());

	buddy->setIconHash(payload.iconhash());

	buddy->setBlocked(payload.blocked());

}

NetworkPluginServer::NetworkPluginServer(Component *component, Config *config, UserManager *userManager, FileTransferManager *ftManager, DiscoItemsResponder *discoItemsResponder) {

	m_ftManager = ftManager;

	m_userManager = userManager;

	m_config = config;

	m_component = component;

	m_isNextLongRun = false;

	m_adminInterface = NULL;

	m_startingBackend = false;

	m_lastLogin = 0;

	m_discoItemsResponder = discoItemsResponder;

	m_component->m_factory = new NetworkFactory(this);

	m_userManager->onUserCreated.connect(boost::bind(&NetworkPluginServer::handleUserCreated, this, _1));

	m_userManager->onUserDestroyed.connect(boost::bind(&NetworkPluginServer::handleUserDestroyed, this, _1));

	m_pingTimer = component->getNetworkFactories()->getTimerFactory()->createTimer(20000);

	m_pingTimer->onTick.connect(boost::bind(&NetworkPluginServer::pingTimeout, this));

	m_pingTimer->start();

	m_loginTimer = component->getNetworkFactories()->getTimerFactory()->createTimer(CONFIG_INT(config, "service.login_delay") * 1000);

	m_loginTimer->onTick.connect(boost::bind(&NetworkPluginServer::loginDelayFinished, this));

	m_loginTimer->start();

	if (CONFIG_INT(m_config, "service.memory_collector_time") != 0) {

		m_collectTimer = component->getNetworkFactories()->getTimerFactory()->createTimer(CONFIG_INT(m_config, "service.memory_collector_time"));

		m_collectTimer->onTick.connect(boost::bind(&NetworkPluginServer::collectBackend, this));

		std::string message;

		pbnetwork::WrapperMessage wrap;

		wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_EXIT);

		wrap.SerializeToString(&message);

		Backend *c = (Backend *) *it;

		send(c->connection, message);

	}

	m_pingTimer->stop();

	m_server->stop();

	m_server.reset();

	delete m_component->m_factory;

	delete m_vcardResponder;

	delete m_rosterResponder;

	delete m_blockResponder;

}

void NetworkPluginServer::start() {

	m_server->start();

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

	while (true) {

		LOG4CXX_INFO(logger, "Tried to spawn first backend with pid " << pid);

		LOG4CXX_INFO(logger, "Backend should now connect to Spectrum2 instance. Spectrum2 won't accept any connection before backend connects");

#ifndef _WIN32

		// wait if the backend process will still be alive after 1 second

		sleep(1);

		pid_t result;

		int status;

		result = waitpid(-1, &status, WNOHANG);

		if (result != 0) {

			if (WIFEXITED(status)) {

				if (WEXITSTATUS(status) != 0) {

					if (status == 254) {

						LOG4CXX_ERROR(logger, "Backend can not be started, because it needs database to store data, but the database backend is not configured.");

					}

					else {

						LOG4CXX_ERROR(logger, "Backend can not be started, exit_code=" << WEXITSTATUS(status) << ", possible error: " << strerror(WEXITSTATUS(status)));

					}

					LOG4CXX_ERROR(logger, "Check backend log for more details");

					continue;

				}

			}

			else {

				LOG4CXX_ERROR(logger, "Backend can not be started");

				continue;

			}

		}

		signal(SIGCHLD, SigCatcher);

#endif

		// quit the while loop

		break;

	}

}

void NetworkPluginServer::loginDelayFinished() {

	m_loginTimer->stop();

	connectWaitingUsers();

}

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

	// Create new Backend instance

	Backend *client = new Backend;

	client->pongReceived = -1;

	client->connection = c;

	client->res = 0;

	client->init_res = 0;

	client->shared = 0;

	// Until we receive first PONG from backend, backend is in willDie state.

	client->willDie = true;

	// Backend does not accept new clients automatically if it's long-running

	client->acceptUsers = !m_isNextLongRun;

	}

	if (state.state == Swift::FileTransfer::State::Transferring) {

		handleFTAccepted(user, buddyName, fileName, size, id);

	}

	else if (state.state == Swift::FileTransfer::State::Canceled) {

		handleFTRejected(user, buddyName, fileName, size);

	}

}

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

		LOG4CXX_INFO(logger, "PING to " << c << " (ID=" << c->id << ")");

		send(c->connection, message);

		c->pongReceived = false;

	}

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

}

NetworkPluginServer::Backend *NetworkPluginServer::getFreeClient(bool acceptUsers, bool longRun, bool check) {

	NetworkPluginServer::Backend *c = NULL;

	unsigned long diff = CONFIG_INT(m_config, "service.login_delay");

	time_t now = time(NULL);

	if (diff && (now - m_lastLogin < diff)) {

		m_loginTimer->start();

		return NULL;

	}

	if (!check) {

		m_lastLogin = time(NULL);

	}

	// Check all backends and find free one

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

		if ((*it)->willDie == false && (*it)->acceptUsers == acceptUsers && (*it)->users.size() < CONFIG_INT(m_config, "service.users_per_backend") && (*it)->connection && (*it)->longRun == longRun) {

			c = *it;

			// if we're not reusing all backends and backend is full, stop accepting new users on this backend

			if (!CONFIG_BOOL(m_config, "service.reuse_old_backends")) {

				if (c->users.size() + 1 >= CONFIG_INT(m_config, "service.users_per_backend")) {

					c->acceptUsers = false;

				}

			}

			break;

		}

	}

	// there's no free backend, so spawn one.

	if (c == NULL && !m_startingBackend) {

		m_isNextLongRun = longRun;

		m_startingBackend = true;

	}

	return c;

}

}

	BEGIN(m_updateBuddySetting);

	BIND_INT(m_updateBuddySetting, userId);

	BIND_INT(m_updateBuddySetting, buddyInfo.id);

	BIND_STR(m_updateBuddySetting, buddyInfo.settings.find("icon_hash")->first);

	BIND_INT(m_updateBuddySetting, TYPE_STRING);

	BIND_STR(m_updateBuddySetting, buddyInfo.settings.find("icon_hash")->second.s);

	EXECUTE_STATEMENT(m_updateBuddySetting, "updateBuddySetting query");

}

bool SQLite3Backend::getBuddies(long id, std::list<BuddyInfo> &roster) {

//	SELECT id, uin, subscription, nickname, groups, flags FROM " + m_prefix + "buddies WHERE user_id=? ORDER BY id ASC

	BEGIN(m_getBuddies);

	BIND_INT(m_getBuddies, id);

// 	"SELECT buddy_id, type, var, value FROM " + m_prefix + "buddies_settings WHERE user_id=? ORDER BY buddy_id ASC"

	BEGIN(m_getBuddiesSettings);

	BIND_INT(m_getBuddiesSettings, id);

	SettingVariableInfo var;

	long buddy_id = -1;

	std::string key;

	int ret;

	while((ret = sqlite3_step(m_getBuddies)) == SQLITE_ROW) {

		BuddyInfo b;

		RESET_GET_COUNTER(m_getBuddies);

		b.id = GET_INT(m_getBuddies);

		b.legacyName = GET_STR(m_getBuddies);

		b.subscription = GET_STR(m_getBuddies);

		b.alias = GET_STR(m_getBuddies);

		std::string groups = GET_STR(m_getBuddies);

		b.groups = StorageBackend::deserializeGroups(groups);

		b.flags = GET_INT(m_getBuddies);

		if (buddy_id == b.id) {

			std::cout << "Adding buddy info " << key << "\n";

			b.settings[key] = var;

			buddy_id = -1;

		}

			RESET_GET_COUNTER(m_getBuddiesSettings);

			buddy_id = GET_INT(m_getBuddiesSettings);

			var.type = GET_INT(m_getBuddiesSettings);

			key = GET_STR(m_getBuddiesSettings);

			std::string val = GET_STR(m_getBuddiesSettings);

			switch (var.type) {

				case TYPE_BOOLEAN:

					var.b = atoi(val.c_str());

					break;

				case TYPE_STRING:

					var.s = val;

					break;

				default:

					if (buddy_id == b.id) {

						buddy_id = -1;

					}

					continue;

					break;

			}

			if (buddy_id == b.id) {

				std::cout << "Adding buddy info " << key << "=" << val << "\n";

				b.settings[key] = var;

				buddy_id = -1;

			}

		}

// 		if (ret != SQLITE_DONE) {

// 			LOG4CXX_ERROR(logger, "getBuddiesSettings query"<< (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));

// 			return false;

// 		}

		roster.push_back(b);

	}

	if (ret != SQLITE_DONE) {

		return false;

	}

	return true;