void sendData(const std::string &string) {

			m_conn->write(Swift::createSafeByteArray(string));

		}

		void _handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data) {

			std::string d(data->begin(), data->end());

			handleDataRead(d);

		}

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

			np->handleConnected(user);

// 			sleep(1);

// 			np->handleMessage(np->m_user, "zork", first_msg);

		}

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

			if (games.find(user) != games.end()) {

				kill(games[user].pid, SIGTERM);

				games.erase(user);

			}

// 			exit(0);

		}

		else {

			std::string ret(avatarHash);

			g_free(avatarHash);

			return ret;

		}

	}

	return "";

}

static std::vector<std::string> getGroups(PurpleBuddy *m_buddy) {

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

	return groups;

}

static void buddyListNewNode(PurpleBlistNode *node) {

	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))

		return;

	PurpleBuddy *buddy = (PurpleBuddy *) node;

	PurpleAccount *account = purple_buddy_get_account(buddy);

	// Status

	pbnetwork::StatusType status = pbnetwork::STATUS_NONE;

	std::string message;

		if (!blocked) {

			blocked = purple_privacy_check(account, purple_buddy_get_name(buddy)) == false;

		}

		else {

			bool purpleBlocked = purple_privacy_check(account, purple_buddy_get_name(buddy)) == false;

			if (blocked != purpleBlocked) {

				purple_privacy_deny(account, purple_buddy_get_name(buddy), FALSE, FALSE);

			}

		}

	}

		blocked

	);

}

static void buddyListUpdate(PurpleBuddyList *list, PurpleBlistNode *node) {

	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))

		return;

	buddyListNewNode(node);

}

static void buddyPrivacyChanged(PurpleBlistNode *node, void *data) {

	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))

		virtual ~NetworkPlugin();

		/// Call this function when legacy network buddy changed.

		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")

		/// \param buddyName Name of legacy network buddy. (eg. "user2@gmail.com")

		/// \param alias Alias of legacy network buddy. If empty, then it's not changed on XMPP side.

		/// \param groups Groups in which buddy currently is. If empty, then it's not changed on XMPP side.

		/// \param status Status of this buddy.

		/// \param statusMessage Status message of this buddy.

		/// \param iconHash MD5 hash of buddy icon. Empty if none buddy icon.

		/// \param blocked True if this buddy is blocked in privacy lists in legacy network.

		void handleBuddyChanged(const std::string &user, const std::string &buddyName, const std::string &alias,

			bool blocked = false

		);

		/// Call this function when participant in room changed.

		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")

		/// \param nickname Nickname of participant. If participant renamed, this is old name of participant. (eg. "HanzZ")

		/// \param room Room in which participant changed. (eg. #spectrum)

		/// \param flags Participant flags.

		/// \param status Current status of participant. Swift::StatusShow::None if participant left the room.

		/// \param statusMessage Current status message of participant.

		/// \param newname New name of participant if he changed the nickname. Otherwise empty.

		void handleParticipantChanged(const std::string &user, const std::string &nickname, const std::string &room, int flags,

		virtual void handleVCardRequest(const std::string &/*user*/, const std::string &/*legacyName*/, unsigned int /*id*/) {}

		/// Called when XMPP user updates his own VCard.

		/// You should update the VCard in legacy network too.

		/// \param user XMPP JID of user for which this event occurs.

		/// \param photo Raw photo data.

		virtual void handleVCardUpdatedRequest(const std::string &/*user*/, const std::string &/*photo*/, const std::string &nickname) {}

		virtual void handleJoinRoomRequest(const std::string &/*user*/, const std::string &/*room*/, const std::string &/*nickname*/, const std::string &/*pasword*/) {}

		virtual void handleLeaveRoomRequest(const std::string &/*user*/, const std::string &/*room*/) {}

		virtual void handleStatusChangeRequest(const std::string &/*user*/, int status, const std::string &statusMessage) {}

		virtual void handleBuddyBlockToggled(const std::string &/*user*/, const std::string &/*buddyName*/, bool /*blocked*/) {}

		virtual void handleTypingRequest(const std::string &/*user*/, const std::string &/*buddyName*/) {}

		virtual void handleTypedRequest(const std::string &/*user*/, const std::string &/*buddyName*/) {}

		virtual void handleStoppedTypingRequest(const std::string &/*user*/, const std::string &/*buddyName*/) {}

		virtual void handleAttentionRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::string &/*message*/) {}

		virtual void handleFTStartRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::string &/*fileName*/, unsigned long size, unsigned long ftID) {}

		virtual void handleFTFinishRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::string &/*fileName*/, unsigned long size, unsigned long ftID) {}

		virtual void handleFTPauseRequest(unsigned long ftID) {}

		virtual void handleFTContinueRequest(unsigned long ftID) {}

	required string password = 3;

}

message Logout {

	required string user = 1;

	required string legacyName = 2;

}

message Buddy {

	required string userName = 1;

	required string buddyName = 2;

	optional string alias = 3;

	optional StatusType status = 5;

	optional string statusMessage = 6;

	optional string iconHash = 7;

	optional bool blocked = 8;

}

message ConversationMessage {

	required string userName = 1;

	required string buddyName = 2;

	required string message = 3;

	optional string nickname = 4;

	optional string xhtml = 5;

#include "Swiften/StringCodecs/Base64.h"

namespace Transport {

namespace Util {

void removeEverythingOlderThan(const std::vector<std::string> &dirs, time_t t);

std::string encryptPassword(const std::string &password, const std::string &key);

std::string decryptPassword(std::string &encrypted, const std::string &key);

}

}

	m.set_nickname(nickname);

	std::string message;

	m.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_ROOM_SUBJECT_CHANGED);

// 	std::cout << "SENDING MESSAGE\n";

	send(message);

}

void NetworkPlugin::handleBuddyChanged(const std::string &user, const std::string &buddyName, const std::string &alias,

	pbnetwork::Buddy buddy;

	buddy.set_username(user);

	buddy.set_buddyname(buddyName);

	buddy.set_alias(alias);

	buddy.set_status((pbnetwork::StatusType) status);

	buddy.set_statusmessage(statusMessage);

	buddy.set_iconhash(iconHash);

	buddy.set_blocked(blocked);

	std::string message;

	buddy.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);

	send(message);

}

}

void NetworkPlugin::handleBuddyChangedPayload(const std::string &data) {

	pbnetwork::Buddy payload;

	if (payload.ParseFromString(data) == false) {

		// TODO: ERROR

		return;

	}

	if (payload.has_blocked()) {

		handleBuddyBlockToggled(payload.username(), payload.buddyname(), payload.blocked());

	}

	else {

	}

}

void NetworkPlugin::handleBuddyRemovedPayload(const std::string &data) {

	pbnetwork::Buddy payload;

	if (payload.ParseFromString(data) == false) {

		// TODO: ERROR

		return;

	}

}

void NetworkPlugin::handleChatStatePayload(const std::string &data, int type) {

	pbnetwork::Buddy payload;

	if (payload.ParseFromString(data) == false) {

		// TODO: ERROR

		return;

	}

	switch(type) {

		case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING:

			handleTypingRequest(payload.username(), payload.buddyname());

server = 127.0.0.1

port = 5222

server_mode = 1

backend_host=localhost

pidfile=./test.pid

# < this option doesn't work yet

backend_port=10001

admin_username=admin

admin_password=test

#cert=server.pfx #patch to PKCS#12 certificate

#cert_password=test #password to that certificate if any

users_per_backend=10

#backend=/usr/bin/mono /home/hanzz/code/networkplugin-csharp/msnp-sharp-backend/bin/Debug/msnp-sharp-backend.exe

#backend=/home/hanzz/code/libtransport/backends/frotz/spectrum2_frotz_backend

#protocol=prpl-msn

protocol=any

#protocol=prpl-icq

irc_server=irc.freenode.org

[backend]

#default_avatar=catmelonhead.jpg

#no_vcard_fetch=true

[logging]

#config=logging.cfg # log4cxx/log4j logging configuration file

#backend_config=/home/hanzz/code/libtransport/spectrum/src/backend-logging.cfg # log4cxx/log4j logging configuration file for backends

	if (!mysql_real_connect(&m_conn, CONFIG_STRING(m_config, "database.server").c_str(),

					   CONFIG_STRING(m_config, "database.user").c_str(),

					   CONFIG_STRING(m_config, "database.password").c_str(),

					   CONFIG_STRING(m_config, "database.database").c_str(),

					   CONFIG_INT(m_config, "database.port"), NULL, 0)) {

		LOG4CXX_ERROR(logger, "Can't connect database: " << mysql_error(&m_conn));

		return false;

	}

	createDatabase();

	m_getUser = new Statement(&m_conn, "s|isssssb", "SELECT id, jid, uin, password, encoding, language, vip FROM " + m_prefix + "users WHERE jid=?");

	m_removeUser = new Statement(&m_conn, "i", "DELETE FROM " + m_prefix + "users WHERE id=?");

	m_removeUserBuddies = new Statement(&m_conn, "i", "DELETE FROM " + m_prefix + "buddies WHERE user_id=?");

	m_removeUserSettings = new Statement(&m_conn, "i", "DELETE FROM " + m_prefix + "users_settings WHERE user_id=?");

	m_removeUserBuddiesSettings = new Statement(&m_conn, "i", "DELETE FROM " + m_prefix + "buddies_settings WHERE user_id=?");

	m_addBuddy = new Statement(&m_conn, "issssi", "INSERT INTO " + m_prefix + "buddies (user_id, uin, subscription, groups, nickname, flags) VALUES (?, ?, ?, ?, ?, ?)");

	m_updateBuddy = new Statement(&m_conn, "ssisis", "UPDATE " + m_prefix + "buddies SET groups=?, nickname=?, flags=?, subscription=? WHERE user_id=? AND uin=?");

	m_getBuddies = new Statement(&m_conn, "i|issssi", "SELECT id, uin, subscription, nickname, groups, flags FROM " + m_prefix + "buddies WHERE user_id=? ORDER BY id ASC");

	m_getBuddiesSettings = new Statement(&m_conn, "i|iiss", "SELECT buddy_id, type, var, value FROM " + m_prefix + "buddies_settings WHERE user_id=? ORDER BY buddy_id ASC");

	m_updateBuddySetting = new Statement(&m_conn, "iisiss", "INSERT INTO " + m_prefix + "buddies_settings (user_id, buddy_id, var, type, value) VALUES (?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE value=?");

	if (mysql_query(&m_conn, query.c_str())) {

		LOG4CXX_ERROR(logger, query << " " << mysql_error(&m_conn));

		return false;

	}

	return true;

}

void MySQLBackend::setUser(const UserInfo &user) {

	std::string encrypted = user.password;

	if (!CONFIG_STRING(m_config, "database.encryption_key").empty()) {

		encrypted = Util::encryptPassword(encrypted, CONFIG_STRING(m_config, "database.encryption_key"));

	}

	EXEC(m_setUser, setUser(user));

}

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

	*m_getUser << barejid;

	EXEC(m_getUser, getUser(barejid, user));

	if (!exec_ok)

		return false;

	int ret = false;

	while (m_getUser->fetch() == 0) {

		ret = true;

	}

	return ret;

}

void MySQLBackend::setUserOnline(long id, bool online) {

	*m_setUserOnline << online << id;

	EXEC(m_setUserOnline, setUserOnline(id, online));

}

long MySQLBackend::addBuddy(long userId, const BuddyInfo &buddyInfo) {

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

	*m_addBuddy << userId << buddyInfo.legacyName << buddyInfo.subscription;

	*m_addBuddy << buddyInfo.alias << buddyInfo.flags;

	EXEC(m_addBuddy, addBuddy(userId, buddyInfo));

	long id = (long) mysql_insert_id(&m_conn);

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

	if (!buddyInfo.settings.find("icon_hash")->second.s.empty()) {

		*m_updateBuddySetting << userId << id << buddyInfo.settings.find("icon_hash")->first << (int) TYPE_STRING << buddyInfo.settings.find("icon_hash")->second.s << buddyInfo.settings.find("icon_hash")->second.s;

		EXEC(m_updateBuddySetting, addBuddy(userId, buddyInfo));

	}

	return id;

}

void MySQLBackend::updateBuddy(long userId, const BuddyInfo &buddyInfo) {

// 	"UPDATE " + m_prefix + "buddies SET groups=?, nickname=?, flags=?, subscription=? WHERE user_id=? AND uin=?"

	*m_updateBuddy << buddyInfo.alias << buddyInfo.flags << buddyInfo.subscription;

	*m_updateBuddy << userId << buddyInfo.legacyName;

	EXEC(m_updateBuddy, updateBuddy(userId, buddyInfo));

}

bool MySQLBackend::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

	*m_getBuddies << id;

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

	*m_getBuddiesSettings << id;

	std::string key;

	EXEC(m_getBuddies, getBuddies(id, roster));

	if (!exec_ok)

		return false;

	while (m_getBuddies->fetch() == 0) {

		BuddyInfo b;

		std::string group;

		*m_getBuddies >> b.id >> b.legacyName >> b.subscription >> b.alias >> group >> b.flags;

		roster.push_back(b);

	}

	EXEC(m_getBuddiesSettings, getBuddies(id, roster));

	if (!exec_ok)

		return false;

	BOOST_FOREACH(BuddyInfo &b, roster) {

		if (buddy_id == b.id) {

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

			b.settings[key] = var;

}

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

		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;

		}

		send(c->connection, message);

	}

}

void NetworkPluginServer::handleBuddyRemoved(Buddy *b) {

	User *user = b->getRosterManager()->getUser();

	pbnetwork::Buddy buddy;

	buddy.set_username(user->getJID().toBare());

	buddy.set_buddyname(b->getName());

	buddy.set_alias(b->getAlias());

	buddy.set_status(pbnetwork::STATUS_NONE);

	std::string message;

	buddy.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_REMOVED);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

void NetworkPluginServer::handleBuddyUpdated(Buddy *b, const Swift::RosterItemPayload &item) {

	User *user = b->getRosterManager()->getUser();

	dynamic_cast<LocalBuddy *>(b)->setAlias(item.getName());

	dynamic_cast<LocalBuddy *>(b)->setGroups(item.getGroups());

	user->getRosterManager()->storeBuddy(b);

	pbnetwork::Buddy buddy;

	buddy.set_username(user->getJID().toBare());

	buddy.set_buddyname(b->getName());

	buddy.set_alias(b->getAlias());

	buddy.set_status(pbnetwork::STATUS_NONE);

	std::string message;

	buddy.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

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

	handleBuddyUpdated(buddy, item);

}

void NetworkPluginServer::handleBlockToggled(Buddy *b) {

	User *user = b->getRosterManager()->getUser();

	pbnetwork::Buddy buddy;

	buddy.set_username(user->getJID().toBare());

	buddy.set_buddyname(b->getName());

	buddy.set_alias(b->getAlias());

	buddy.set_status(pbnetwork::STATUS_NONE);

	buddy.set_blocked(!b->isBlocked());

	std::string message;

	buddy.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

 * 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

 */

#ifdef WITH_SQLITE

#include "transport/sqlite3backend.h"

#include <boost/bind.hpp>

#include "log4cxx/logger.h"

using namespace log4cxx;

#define SQLITE_DB_VERSION 3

#define CHECK_DB_RESPONSE(stmt) \

	if(stmt) { \

		sqlite3_exec(m_db, "ROLLBACK;", NULL, NULL, NULL); \

		return 0; \

	}

	BEGIN(m_setUserOnline);

	BIND_INT(m_setUserOnline, (int)online);

	BIND_INT(m_setUserOnline, id);

	EXECUTE_STATEMENT(m_setUserOnline, "setUserOnline query");

}

long SQLite3Backend::addBuddy(long userId, const BuddyInfo &buddyInfo) {

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

	BEGIN(m_addBuddy);

	BIND_INT(m_addBuddy, userId);

	BIND_STR(m_addBuddy, buddyInfo.legacyName);

	BIND_STR(m_addBuddy, buddyInfo.subscription);

	BIND_STR(m_addBuddy, buddyInfo.alias);

	BIND_INT(m_addBuddy, buddyInfo.flags);

	if(sqlite3_step(m_addBuddy) != SQLITE_DONE) {

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

		return -1;

	}

	long id = (long) sqlite3_last_insert_rowid(m_db);

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

	BEGIN(m_updateBuddySetting);

	BIND_INT(m_updateBuddySetting, 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");

	return id;

}

void SQLite3Backend::updateBuddy(long userId, const BuddyInfo &buddyInfo) {

// 	UPDATE " + m_prefix + "buddies SET groups=?, nickname=?, flags=?, subscription=? WHERE user_id=? AND uin=?

	BEGIN(m_updateBuddy);

	BIND_STR(m_updateBuddy, buddyInfo.alias);

	BIND_INT(m_updateBuddy, buddyInfo.flags);

	BIND_STR(m_updateBuddy, buddyInfo.subscription);

	BIND_INT(m_updateBuddy, userId);

	BIND_STR(m_updateBuddy, buddyInfo.legacyName);

	EXECUTE_STATEMENT(m_updateBuddy, "updateBuddy query");

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

	BEGIN(m_updateBuddySetting);

	BIND_INT(m_updateBuddySetting, userId);

	BIND_INT(m_updateBuddySetting, buddyInfo.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);

		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;

		}

		while(buddy_id == -1 && (ret = sqlite3_step(m_getBuddiesSettings)) == SQLITE_ROW) {

			RESET_GET_COUNTER(m_getBuddiesSettings);

			buddy_id = GET_INT(m_getBuddiesSettings);

 *

 * 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

 */

#include "transport/util.h"

#include <boost/foreach.hpp>

#include <iostream>

#include <iterator>

#include <algorithm>

#include <boost/filesystem.hpp>

using namespace boost::filesystem;

using namespace boost;

namespace Transport {

namespace Util {

void removeEverythingOlderThan(const std::vector<std::string> &dirs, time_t t) {

	BOOST_FOREACH(const std::string &dir, dirs) {

		path p(dir);

	std::string password;

	password.resize(encrypted.size());

	for (int i = 0; i < encrypted.size(); i++) {

		char c = encrypted[i];

		char keychar = key[i % key.size()];

		c -= keychar;

		password[i] = c;

	}

	return password;

}

}

}