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

				LOG4CXX_INFO(logger, "Using previously created account with name '" << name.c_str() << "' and protocol '" << protocol << "'");

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

			}

			else {

				LOG4CXX_INFO(logger, "Creating account with name '" << name.c_str() << "' and protocol '" << protocol << "'");

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

				purple_accounts_add(account);

			}

			m_sessions[user] = account;

			m_accounts[account] = user;

			// Default avatar

			setDefaultAvatar(account, legacyName);

			purple_account_set_password(account, password.c_str());

			purple_account_set_bool(account, "custom_smileys", FALSE);

			purple_account_set_bool(account, "direct_connect", FALSE);

			setDefaultAccountOptions(account);

			// Enable account + privacy lists

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

						st = PURPLE_STATUS_UNAVAILABLE;

						break;

					}

					case pbnetwork::STATUS_XA: {

						if (!purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_EXTENDED_AWAY))

							st = PURPLE_STATUS_AWAY;

						else

							st = PURPLE_STATUS_EXTENDED_AWAY;

						break;

					}

					case pbnetwork::STATUS_NONE: {

						st = PURPLE_STATUS_OFFLINE;

						break;

					}

					case pbnetwork::STATUS_INVISIBLE:

						st = PURPLE_STATUS_INVISIBLE;

						break;

					default:

						st = PURPLE_STATUS_AVAILABLE;

						break;

				}

				gchar *_markup = purple_markup_escape_text(statusMessage.c_str(), -1);

				std::string markup(_markup);

				g_free(_markup);

// 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() {}

void YahooHandler::ready(std::string *buffer) {

	if (cond == YAHOO_INPUT_WRITE) {

		YahooLocalAccount *old = currently_writting_account;

		currently_writting_account = account;

		yahoo_write_ready(account->id, (void *) conn_tag, data);

		currently_writting_account = old;

	}

	else {

		if (!buffer) {

			return;

		}

		// yahoo_read_ready calls ext_yahoo_read(...) in a loop, so we just have to choose proper buffer from which will

		// that method read. We do that by static currently_read_data pointer.

		currently_read_data = buffer;

		// libyahoo2 reads data per 1024 bytes, so if we still have some data after the first ext_yahoo_read call,

		// we have to call yahoo_read_ready again...

		do {

			yahoo_read_ready(account->id, (void *) conn_tag, data);

		} while (currently_read_data->size() != 0);

	}

}

		/// Destructor.

		~MySQLBackend();

		/// Connects to the database and creates it if it's needed. This method call createDatabase() function

		/// automatically.

		/// \return true if database is opened successfully.

		bool connect();

		void disconnect();

		/// Creates database structure.

		/// \see connect()

		/// \return true if database structure has been created successfully. Note that it returns True also if database structure

		/// already exists.

		bool createDatabase();

		/// Stores user into database.

		/// \param user user struct containing all information about user which have to be stored

		void setUser(const UserInfo &user);

		/// Gets user data from database and stores them into user reference.

		/// \param barejid barejid of user

		/// \param user UserInfo object where user data will be stored

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

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

				// Pulls fetched data by previous execute(); call.

				template <typename T>

				Statement& operator >> (T& t);

				Statement& operator >> (std::string& t);

			private:

				MYSQL_STMT *m_stmt;

				MYSQL *m_conn;

				std::vector<MYSQL_BIND> m_params;

				std::vector<MYSQL_BIND> m_results;

				int m_resultOffset;

				int m_offset;

				int m_error;

				std::string m_string;

		};

		MYSQL m_conn;

		Config *m_config;

		std::string m_prefix;

		// statements

// 		MYSQL_STMT *m_setUser;

		Statement *m_setUser;

		Statement *m_getUser;

		/// Destructor.

		~PQXXBackend();

		/// Connects to the database and creates it if it's needed. This method call createDatabase() function

		/// automatically.

		/// \return true if database is opened successfully.

		bool connect();

		void disconnect();

		/// Creates database structure.

		/// \see connect()

		/// \return true if database structure has been created successfully. Note that it returns True also if database structure

		/// already exists.

		bool createDatabase();

		/// Stores user into database.

		/// \param user user struct containing all information about user which have to be stored

		void setUser(const UserInfo &user);

		/// Gets user data from database and stores them into user reference.

		/// \param barejid barejid of user

		/// \param user UserInfo object where user data will be stored

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

		/// 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

/**

 * XMPP - libpurple transport

 *

 * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

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

};

}

		/// 	- service.prefix - prefix for tables created by createDatabase method

		SQLite3Backend(Config *config);

		/// Destructor.

		~SQLite3Backend();

		/// Connects to the database and creates it if it's needed. This method call createDatabase() function

		/// automatically.

		/// \return true if database is opened successfully.

		bool connect();

		/// Creates database structure.

		/// \see connect()

		/// \return true if database structure has been created successfully. Note that it returns True also if database structure

		/// already exists.

		bool createDatabase();

		/// Stores user into database.

		/// \param user user struct containing all information about user which have to be stored

		void setUser(const UserInfo &user);

		/// Gets user data from database and stores them into user reference.

		/// \param barejid barejid of user

		/// \param user UserInfo object where user data will be stored

		/// \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

	long id;

	std::string alias;

	std::string legacyName;

	std::string subscription;

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

	std::map<std::string, SettingVariableInfo> settings;

	int flags;

};

class Config;

/// Abstract class defining storage backends.

class StorageBackend

{

	public:

		/// Virtual desctructor.

		virtual ~StorageBackend() {}

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

		/// connect

		virtual bool connect() = 0;

		/// createDatabase

		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;

};

}

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

	// fork and exec

	pid_t pid = fork();

	if ( pid == 0 ) {

		setsid();

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

	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;

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

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

		m_collectTimer->start();

	}

	m_vcardResponder = new VCardResponder(component->getIQRouter(), component->getNetworkFactories(), userManager);

	m_vcardResponder->onVCardRequired.connect(boost::bind(&NetworkPluginServer::handleVCardRequired, this, _1, _2, _3));

	m_vcardResponder->onVCardUpdated.connect(boost::bind(&NetworkPluginServer::handleVCardUpdated, this, _1, _2));

	m_vcardResponder->start();

	m_rosterResponder = new RosterResponder(component->getIQRouter(), userManager);

	m_rosterResponder->onBuddyAdded.connect(boost::bind(&NetworkPluginServer::handleBuddyAdded, this, _1, _2));

	m_rosterResponder->onBuddyRemoved.connect(boost::bind(&NetworkPluginServer::handleBuddyRemoved, this, _1));

	m_rosterResponder->onBuddyUpdated.connect(boost::bind(&NetworkPluginServer::handleBuddyUpdated, this, _1, _2));

	m_rosterResponder->start();

	if (m_remoteRosterRequest) {

		m_remoteRosterRequest->onResponse.disconnect_all_slots();

		m_component->getIQRouter()->removeHandler(m_remoteRosterRequest);

	}

	for (std::map<std::string, Buddy *, std::less<std::string>, boost::pool_allocator< std::pair<std::string, Buddy *> > >::iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {

		Buddy *buddy = (*it).second;

		if (!buddy) {

			continue;

		}

		delete buddy;

	}

	if (m_requests.size() != 0) {

		LOG4CXX_INFO(logger, m_user->getJID().toString() <<  ": Removing " << m_requests.size() << " unresponded IQs");

		BOOST_FOREACH(Swift::SetRosterRequest::ref request, m_requests) {

			request->onResponse.disconnect_all_slots();

			m_component->getIQRouter()->removeHandler(request);

		}

		m_requests.clear();

	}

	boost::singleton_pool<boost::pool_allocator_tag, sizeof(unsigned int)>::release_memory();

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