purple_account_set_enabled(account, "spectrum", TRUE);

			if (KEYFILE_BOOL("service", "enable_privacy_lists")) {

				purple_account_set_privacy_type(account, PURPLE_PRIVACY_DENY_USERS);

			}

			// Set the status

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

			}

		}

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

			PurpleAccount *account = m_sessions[user];

			if (account) {

				if (purple_account_get_int(account, "version", 0) != 0) {

					std::string data = stringOf(purple_account_get_int(account, "version", 0));

					g_file_set_contents ("gfire.cfg", data.c_str(), data.size(), NULL);

				}

// 				VALGRIND_DO_LEAK_CHECK;

				m_sessions.erase(user);

				purple_account_disconnect(account);

				purple_account_set_enabled(account, "spectrum", FALSE);

				m_accounts.erase(account);

				purple_accounts_delete(account);

#ifndef WIN32

				malloc_trim(0);

#endif

// 				VALGRIND_DO_LEAK_CHECK;

			}

		}

		void handleStatusChangeRequest(const std::string &user, int status, const std::string &statusMessage) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				int st;

				switch(status) {

					case pbnetwork::STATUS_AWAY: {

						st = PURPLE_STATUS_AWAY;

						if (!purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AWAY))

							st = PURPLE_STATUS_EXTENDED_AWAY;

						else

							st = PURPLE_STATUS_AWAY;

						break;

					}

					case pbnetwork::STATUS_DND: {

// Transport includes

#include "transport/config.h"

#include "transport/networkplugin.h"

#include "transport/logging.h"

// Yahoo2

#include <yahoo2.h>

#include <yahoo2_callbacks.h>

#include <stdio.h>

#include <stdarg.h>

#include <stdlib.h>

#include "yahoohandler.h"

#include "yahoolocalaccount.h"

#include "httpfetch.h"

// Swiften

#include "Swiften/Swiften.h"

#include "Swiften/TLS/OpenSSL/OpenSSLContextFactory.h"

// for signal handler

#include "unistd.h"

#include "signal.h"

#include "sys/wait.h"

#include "sys/signal.h"

// Boost

#include <boost/algorithm/string.hpp>

using namespace boost::filesystem;

using namespace boost::program_options;

using namespace Transport;

class YahooHandler;

class YahooLocalAccount;

static std::string *currently_read_data;

static YahooLocalAccount *currently_writting_account;

YahooHandler::YahooHandler(YahooLocalAccount *account, int conn_tag, int handler_tag, void *data, yahoo_input_condition cond) :

	handler_tag(handler_tag), conn_tag(conn_tag), data(data), cond(cond), remove_later(false), account(account) {}

YahooHandler::~YahooHandler() {}

		/// Changes users online state variable in database.

		/// \param id id of user - UserInfo.id

		/// \param online online state

		void setUserOnline(long id, bool online);

		/// Removes user and all connected data from database.

		/// \param id id of user - UserInfo.id

		/// \return true if user has been found in database and removed

		bool removeUser(long id);

		/// Returns JIDs of all buddies in user's roster.

		/// \param id id of user - UserInfo.id

		/// \param roster string list used to store user's roster

		/// \return true if user has been found in database and roster has been fetched

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

		bool getOnlineUsers(std::vector<std::string> &users);

		long addBuddy(long userId, const BuddyInfo &buddyInfo);

		void updateBuddy(long userId, const BuddyInfo &buddyInfo);

		void removeBuddy(long id) {}

		void getUserSetting(long userId, const std::string &variable, int &type, std::string &value);

		void updateUserSetting(long userId, const std::string &variable, const std::string &value);

		void beginTransaction();

		void commitTransaction();

	private:

		bool exec(const std::string &query);

		class Statement {

			public:

				Statement(MYSQL *conn, const std::string &format, const std::string &statement);

				~Statement();

				int execute();

				int fetch();

				// Pushes new data used as input for the statement.

				template <typename T>

				Statement& operator << (const T& t);

				Statement& operator << (const std::string& str);

		/// Changes users online state variable in database.

		/// \param id id of user - UserInfo.id

		/// \param online online state

		void setUserOnline(long id, bool online);

		/// Removes user and all connected data from database.

		/// \param id id of user - UserInfo.id

		/// \return true if user has been found in database and removed

		bool removeUser(long id);

		/// Returns JIDs of all buddies in user's roster.

		/// \param id id of user - UserInfo.id

		/// \param roster string list used to store user's roster

		/// \return true if user has been found in database and roster has been fetched

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

		bool getOnlineUsers(std::vector<std::string> &users);

		long addBuddy(long userId, const BuddyInfo &buddyInfo);

		void updateBuddy(long userId, const BuddyInfo &buddyInfo);

		void removeBuddy(long id) {}

		void getUserSetting(long userId, const std::string &variable, int &type, std::string &value);

		void updateUserSetting(long userId, const std::string &variable, const std::string &value);

		void beginTransaction();

		void commitTransaction();

	private:

		bool exec(const std::string &query, bool show_error = true);

		bool exec(pqxx::nontransaction &txn, const std::string &query, bool show_error = true);

		template<typename T>

		std::string quote(pqxx::nontransaction &txn, const T &t);

		Config *m_config;

		std::string m_prefix;

		pqxx::connection *m_conn;

};

}

#endif

 */

#pragma once

#include <string>

#include <algorithm>

#include "Swiften/Swiften.h"

namespace Transport {

class User;

class StorageBackend;

class Buddy;

// Stores buddies into DB Backend.

class RosterStorage {

	public:

		RosterStorage(User *user, StorageBackend *storageBackend);

		virtual ~RosterStorage();

		// Add buddy to store queue and store it in future. Nothing

		// will happen if buddy is already added.

		void storeBuddy(Buddy *buddy);

		// Store all buddies from queue immediately. Returns true

		// if some buddies were stored.

		bool storeBuddies();

		// Remove buddy from storage queue.

		void removeBuddyFromQueue(Buddy *buddy);

	private:

		User *m_user;

		StorageBackend *m_storageBackend;

		std::map<std::string, Buddy *> m_buddies;

		Swift::Timer::ref m_storageTimer;

};

}

		/// \return true if user has been found in database

		bool getUser(const std::string &barejid, UserInfo &user);

		/// Changes users online state variable in database.

		/// \param id id of user - UserInfo.id

		/// \param online online state

		void setUserOnline(long id, bool online);

		bool getOnlineUsers(std::vector<std::string> &users);

		/// Removes user and all connected data from database.

		/// \param id id of user - UserInfo.id

		/// \return true if user has been found in database and removed

		bool removeUser(long id);

		/// Returns JIDs of all buddies in user's roster.

		/// \param id id of user - UserInfo.id

		/// \param roster string list used to store user's roster

		/// \return true if user has been found in database and roster has been fetched

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

		long addBuddy(long userId, const BuddyInfo &buddyInfo);

		void updateBuddy(long userId, const BuddyInfo &buddyInfo);

		void getUserSetting(long userId, const std::string &variable, int &type, std::string &value);

		void updateUserSetting(long userId, const std::string &variable, const std::string &value);

		void beginTransaction();

		void commitTransaction();

	private:

		bool exec(const std::string &query);

		sqlite3 *m_db;

		Config *m_config;

		std::string m_prefix;

		// statements

		sqlite3_stmt *m_setUser;

		sqlite3_stmt *m_getUser;

		sqlite3_stmt *m_getUserSetting;

		sqlite3_stmt *m_setUserSetting;

		sqlite3_stmt *m_updateUserSetting;

		sqlite3_stmt *m_removeUser;

		sqlite3_stmt *m_removeUserBuddies;

		sqlite3_stmt *m_removeUserSettings;

		sqlite3_stmt *m_removeUserBuddiesSettings;

		sqlite3_stmt *m_addBuddy;

		sqlite3_stmt *m_updateBuddy;

		sqlite3_stmt *m_updateBuddySetting;

		sqlite3_stmt *m_getBuddies;

		sqlite3_stmt *m_getBuddiesSettings;

		sqlite3_stmt *m_setUserOnline;

		sqlite3_stmt *m_getOnlineUsers;

};

}

#endif

		virtual bool createDatabase() = 0;

		/// setUser

		virtual void setUser(const UserInfo &user) = 0;

		/// getuser

		virtual bool getUser(const std::string &barejid, UserInfo &user) = 0;

		/// setUserOnline

		virtual void setUserOnline(long id, bool online) = 0;

		/// removeUser

		virtual bool removeUser(long id) = 0;

		/// getBuddies

		virtual bool getBuddies(long id, std::list<BuddyInfo> &roster) = 0;

		/// getOnlineUsers

		virtual bool getOnlineUsers(std::vector<std::string> &users) = 0;

		virtual long addBuddy(long userId, const BuddyInfo &buddyInfo) = 0;

		virtual void updateBuddy(long userId, const BuddyInfo &buddyInfo) = 0;

		virtual void removeBuddy(long id) = 0;

		virtual void getUserSetting(long userId, const std::string &variable, int &type, std::string &value) = 0;

		virtual void updateUserSetting(long userId, const std::string &variable, const std::string &value) = 0;

		virtual void beginTransaction() = 0;

		virtual void commitTransaction() = 0;

		/// onStorageError

// 		boost::signal<void (const std::string &statement, const std::string &error)> onStorageError;

};

}

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

	buddy->setName(payload.buddyname());

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

		groups.push_back(payload.group(i));

	}

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

	m_ftManager = ftManager;

	m_userManager = userManager;

	m_config = config;

	m_component = component;

	m_isNextLongRun = false;

	m_adminInterface = NULL;

	if (m_rosterStorage)

		delete m_rosterStorage;

}

void RosterManager::setBuddy(Buddy *buddy) {

// 	m_setBuddyTimer->onTick.connect(boost::bind(&RosterManager::setBuddyCallback, this, buddy));

// 	m_setBuddyTimer->start();

	setBuddyCallback(buddy);

}

void RosterManager::removeBuddy(const std::string &name) {

	Buddy *buddy = getBuddy(name);

	if (!buddy) {

		LOG4CXX_WARN(logger, m_user->getJID().toString() << ": Tried to remove unknown buddy " << name);

		return;

	}

	if (m_component->inServerMode() || m_remoteRosterRequest) {

		sendBuddyRosterRemove(buddy);

	}

	else {

		sendBuddyUnsubscribePresence(buddy);

	}

	unsetBuddy(buddy);

	delete buddy;

}

void RosterManager::sendBuddyRosterRemove(Buddy *buddy) {

	Swift::RosterPayload::ref p = Swift::RosterPayload::ref(new Swift::RosterPayload());

	Swift::RosterItemPayload item;

	item.setJID(buddy->getJID().toBare());

	item.setSubscription(Swift::RosterItemPayload::Remove);

	p->addItem(item);

	// In server mode we have to send pushes to all resources, but in gateway-mode we send it only to bare JID

	if (m_component->inServerMode()) {

		std::vector<Swift::Presence::ref> presences = m_component->getPresenceOracle()->getAllPresence(m_user->getJID().toBare());

		BOOST_FOREACH(Swift::Presence::ref presence, presences) {

			Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(p, presence->getFrom(), m_component->getIQRouter());

			request->send();

		}

	}

	else {

		Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(p, m_user->getJID().toBare(), m_component->getIQRouter());

		request->send();

	}

// 	}

// 	Log("buddyListSaveNode", id << " " << name << " " << alias << " " << s_buddy->getSubscription());

// 	if (s_buddy->getBuddy() && id != -1) {

// 		PurpleBuddy *buddy = s_buddy->getBuddy();

// 		SaveData *s = new SaveData;

// 		s->user = user;

// 		s->id = id;

// 		g_hash_table_foreach(buddy->node.settings, save_settings, s);

// 		delete s;

// 	}

// 	return TRUE;

// }

RosterStorage::RosterStorage(User *user, StorageBackend *storageBackend) {

	m_user = user;

	m_storageBackend = storageBackend;

	m_storageTimer = m_user->getComponent()->getNetworkFactories()->getTimerFactory()->createTimer(5000);

	m_storageTimer->onTick.connect(boost::bind(&RosterStorage::storeBuddies, this));

}

RosterStorage::~RosterStorage() {

	m_storageTimer->stop();

}

void RosterStorage::storeBuddy(Buddy *buddy) {

	if (!buddy) {

		return;

	}

	if (buddy->getName().empty()) {

		return;

	}

	m_buddies[buddy->getName()] = buddy;

	m_storageTimer->start();

}

bool RosterStorage::storeBuddies() {

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

		return false;

	}

	m_storageBackend->beginTransaction();

	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {

		Buddy *buddy = (*it).second;

		BuddyInfo buddyInfo;

		buddyInfo.alias = buddy->getAlias();

		buddyInfo.legacyName = buddy->getName();

SQLite3Backend::SQLite3Backend(Config *config) {

	m_config = config;

	m_db = NULL;

	m_prefix = CONFIG_STRING(m_config, "database.prefix");

}

SQLite3Backend::~SQLite3Backend(){

	if (m_db) {

		// Would be nice to use this:

		//

		//   sqlite3_stmt *pStmt;

		//   while((pStmt = sqlite3_next_stmt(db, 0)) != 0 ) {

		//    sqlite3_finalize(pStmt);

		//   }

		//

		// But requires SQLite3 >= 3.6.0 beta

		FINALIZE_STMT(m_setUser);

		FINALIZE_STMT(m_getUser);

		FINALIZE_STMT(m_removeUser);

		FINALIZE_STMT(m_removeUserBuddies);

		FINALIZE_STMT(m_removeUserSettings);

		FINALIZE_STMT(m_removeUserBuddiesSettings);

		FINALIZE_STMT(m_addBuddy);

		FINALIZE_STMT(m_updateBuddy);

		FINALIZE_STMT(m_getBuddies);

		FINALIZE_STMT(m_getBuddiesSettings);

		FINALIZE_STMT(m_getUserSetting);

		FINALIZE_STMT(m_setUserSetting);

		FINALIZE_STMT(m_updateUserSetting);

		FINALIZE_STMT(m_updateBuddySetting);

		FINALIZE_STMT(m_setUserOnline);

		FINALIZE_STMT(m_getOnlineUsers);

		sqlite3_close(m_db);

	}

}

bool SQLite3Backend::connect() {

	LOG4CXX_INFO(logger, "Opening database " << CONFIG_STRING(m_config, "database.database"));

	if (sqlite3_open(CONFIG_STRING(m_config, "database.database").c_str(), &m_db)) {

		sqlite3_close(m_db);

		return false;

	}

	sqlite3_busy_timeout(m_db, 1500);

	if (createDatabase() == false)

		return false;

	PREP_STMT(m_setUser, "INSERT OR REPLACE INTO " + m_prefix + "users (jid, uin, password, language, encoding, last_login, vip) VALUES (?, ?, ?, ?, ?, DATETIME('NOW'), ?)");

	PREP_STMT(m_getUser, "SELECT id, jid, uin, password, encoding, language, vip FROM " + m_prefix + "users WHERE jid=?");

	PREP_STMT(m_removeUser, "DELETE FROM " + m_prefix + "users WHERE id=?");

	PREP_STMT(m_removeUserBuddies, "DELETE FROM " + m_prefix + "buddies WHERE user_id=?");

	PREP_STMT(m_removeUserSettings, "DELETE FROM " + m_prefix + "users_settings WHERE user_id=?");

	PREP_STMT(m_removeUserBuddiesSettings, "DELETE FROM " + m_prefix + "buddies_settings WHERE user_id=?");

	PREP_STMT(m_addBuddy, "INSERT INTO " + m_prefix + "buddies (user_id, uin, subscription, groups, nickname, flags) VALUES (?, ?, ?, ?, ?, ?)");

	PREP_STMT(m_updateBuddy, "UPDATE " + m_prefix + "buddies SET groups=?, nickname=?, flags=?, subscription=? WHERE user_id=? AND uin=?");

	PREP_STMT(m_getBuddies, "SELECT id, uin, subscription, nickname, groups, flags FROM " + m_prefix + "buddies WHERE user_id=? ORDER BY id ASC");

	PREP_STMT(m_getBuddiesSettings, "SELECT buddy_id, type, var, value FROM " + m_prefix + "buddies_settings WHERE user_id=? ORDER BY buddy_id ASC");

	PREP_STMT(m_updateBuddySetting, "INSERT OR REPLACE INTO " + m_prefix + "buddies_settings (user_id, buddy_id, var, type, value) VALUES (?, ?, ?, ?, ?)");

	PREP_STMT(m_getUserSetting, "SELECT type, value FROM " + m_prefix + "users_settings WHERE user_id=? AND var=?");

	PREP_STMT(m_setUserSetting, "INSERT INTO " + m_prefix + "users_settings (user_id, var, type, value) VALUES (?,?,?,?)");

	PREP_STMT(m_updateUserSetting, "UPDATE " + m_prefix + "users_settings SET value=? WHERE user_id=? AND var=?");

	PREP_STMT(m_setUserOnline, "UPDATE " + m_prefix + "users SET online=?, last_login=DATETIME('NOW') WHERE id=?");

	PREP_STMT(m_getOnlineUsers, "SELECT jid FROM " + m_prefix + "users WHERE online=1");

	return true;

}

bool SQLite3Backend::createDatabase() {

	int not_exist = exec("CREATE TABLE " + m_prefix + "buddies ("

				"  id INTEGER PRIMARY KEY NOT NULL,"

				"  user_id int(10) NOT NULL,"

				"  uin varchar(255) NOT NULL,"

				"  subscription varchar(20) NOT NULL,"

				"  nickname varchar(255) NOT NULL,"

				"  groups varchar(255) NOT NULL,"

				"  flags int(4) NOT NULL DEFAULT '0'"

				");");

	if (not_exist) {

		exec("CREATE UNIQUE INDEX IF NOT EXISTS user_id ON " + m_prefix + "buddies (user_id, uin);");

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

	}

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

	}

	if (ret != SQLITE_DONE) {

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

		return false;

	}

	return true;

}

bool SQLite3Backend::removeUser(long id) {

	sqlite3_reset(m_removeUser);

	sqlite3_bind_int(m_removeUser, 1, id);

	if(sqlite3_step(m_removeUser) != SQLITE_DONE) {

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

		return false;

	}

	sqlite3_reset(m_removeUserSettings);

	sqlite3_bind_int(m_removeUserSettings, 1, id);

	if(sqlite3_step(m_removeUserSettings) != SQLITE_DONE) {

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

		return false;

	}

	sqlite3_reset(m_removeUserBuddies);

	sqlite3_bind_int(m_removeUserBuddies, 1, id);

	if(sqlite3_step(m_removeUserBuddies) != SQLITE_DONE) {

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

		return false;

	}

	sqlite3_reset(m_removeUserBuddiesSettings);

	sqlite3_bind_int(m_removeUserBuddiesSettings, 1, id);

		BIND_INT(m_setUserSetting, id);

		BIND_STR(m_setUserSetting, variable);

		BIND_INT(m_setUserSetting, type);

		BIND_STR(m_setUserSetting, value);

		EXECUTE_STATEMENT(m_setUserSetting, "m_setUserSetting");

	}

	else {

		type = GET_INT(m_getUserSetting);

		value = GET_STR(m_getUserSetting);

	}

	int ret;

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

	}

}

void SQLite3Backend::updateUserSetting(long id, const std::string &variable, const std::string &value) {

	BEGIN(m_updateUserSetting);

	BIND_STR(m_updateUserSetting, value);

	BIND_INT(m_updateUserSetting, id);

	BIND_STR(m_updateUserSetting, variable);

	EXECUTE_STATEMENT(m_updateUserSetting, "m_updateUserSetting");

}

void SQLite3Backend::beginTransaction() {

	exec("BEGIN TRANSACTION;");

}

void SQLite3Backend::commitTransaction() {

	exec("COMMIT TRANSACTION;");

}

}

#endif