this->user = user;

}

	std::cout << "connected:\n";

}

void MyIrcBuffer::on_numericMessageReceived(const QString& origin, uint code, const QStringList& params)

{

	switch (code) {

		case 332:

			m_topicData = params.value(2).toStdString();

			break;

	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy));

}

	PurpleAccount *account = purple_buddy_get_account(buddy);

	Swift::StatusShow status;

	std::string message;

	getStatus(buddy, status, message);

	NULL,

	buddyListNewNode,

	NULL,

	NULL, //NodeRemoved,

	NULL,

	NULL,

			// They weren't able to do anything with that and I don't know what to do too,

			// so it's better to hack through it by not trying to forward really broken things...

			if (len < 300000 && data) {

// 				const gchar *ext = (gchar*)purple_buddy_icon_get_extension(icon);

// 				if (ext) {

// 					std::string extension(ext);

	}

	np->m_vcards.erase(np->m_accounts[account] + name);

	return NULL;

// 		purple_signal_connect(purple_conversations_get_handle(), "buddy-typing-stopped", &conversation_handle, PURPLE_CALLBACK(buddyTypingStopped), NULL);

		purple_signal_connect(purple_connections_get_handle(), "signed-on", &blist_handle,PURPLE_CALLBACK(signed_on), NULL);

// 		purple_signal_connect(purple_blist_get_handle(), "buddy-removed", &blist_handle,PURPLE_CALLBACK(buddyRemoved), NULL);

		purple_signal_connect(purple_blist_get_handle(), "blist-node-removed", &blist_handle,PURPLE_CALLBACK(NodeRemoved), NULL);

// 		purple_signal_connect(purple_conversations_get_handle(), "chat-topic-changed", &conversation_handle, PURPLE_CALLBACK(conv_chat_topic_changed), NULL);

// 

	public:

		DummyUserRegistry() {}

			return true;

		}

};

		void handleVCardReceived(const std::string &id, const Swift::JID &to, Swift::VCard::ref vcard);

		virtual void getVCard(const std::string &id, const Swift::JID &to) = 0;

		/// Returns legacy network username of this buddy. (for example UIN for ICQ,

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

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

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

		void _handleConnected(bool error);

		void handleDisconnected();

		void sendPong();

		void pingTimeout();

		std::string m_host;

		int m_port;

		Swift::BoostNetworkFactories *m_factories;

class Config;

class NetworkConversation;

class VCardResponder;

class NetworkPluginServer {

	public:

		struct Client {

			bool pongReceived;

			std::list<User *> users;

			boost::shared_ptr<Swift::Connection> connection;

		};

	private:

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

		void handleSessionFinished(Client *c);

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

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

		UserManager *m_userManager;

		VCardResponder *m_vcardResponder;

		Config *m_config;

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

		std::list<Client *>  m_clients;

namespace Transport {

class UserManager;

class RosterResponder : public Swift::Responder<Swift::RosterPayload> {

	public:

		~RosterResponder();

	private:

		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload);

		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload);

		UserManager *m_userManager;

};

		sqlite3_stmt *m_removeUserBuddiesSettings;

		sqlite3_stmt *m_addBuddy;

		sqlite3_stmt *m_updateBuddy;

		sqlite3_stmt *m_getBuddies;

		sqlite3_stmt *m_getBuddiesSettings;

};

			void handleConnected();

			void handleConnectionError(const Swift::ComponentError &error);

			void handlePresence(Swift::Presence::ref presence);

// 			void handleDiscoInfoResponse(boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid);

			void handleCapsChanged(const Swift::JID& jid);

		Component *m_component;

		StorageBackend *m_storageBackend;

		StorageResponder *m_storageResponder;

		friend class RosterResponder;

};

		// caps

// 		presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::CapsInfo (CONFIG().caps)));

			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::VCardUpdate (getIconHash())));

	}

	if (only_new) {

	if (presence) {

		m_rosterManager->getUser()->getComponent()->getStanzaChannel()->sendPresence(presence);

	}

}

void Buddy::handleVCardReceived(const std::string &id, const Swift::JID &to, Swift::VCard::ref vcard) {

}

void NetworkPlugin::handleConnected(const std::string &user) {

	pbnetwork::Connected d;

	d.set_user(user);

	handleVCardRequest(payload.username(), payload.buddyname(), payload.id());

}

	while (m_data.size() != 0) {

		if (m_data.size() >= 4) {

			if (m_data.size() - 4 < expected_size)

				return;

		}

			return;

		}

		pbnetwork::WrapperMessage wrapper;

			return;

		}

		switch(wrapper.type()) {

			case pbnetwork::WrapperMessage_Type_TYPE_LOGIN:

}

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

}

void NetworkPlugin::sendPong() {

	wrap.SerializeToString(&message);

	send(message);

}

void NetworkPlugin::pingTimeout() {

#include "transport/config.h"

#include "transport/conversation.h"

#include "transport/vcardresponder.h"

#include "Swiften/Swiften.h"

#include "Swiften/Server/ServerStanzaChannel.h"

#include "Swiften/Elements/StreamError.h"

			buddy->setSubscription(buddyInfo.subscription);

			buddy->setGroups(buddyInfo.groups);

			buddy->setFlags((BuddyFlag) buddyInfo.flags);

			return buddy;

		}

	private:

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

	m_vcardResponder->start();

	m_server = component->getFactories()->getConnectionFactory()->createConnectionServer(10000);

	m_server->onNewConnection.connect(boost::bind(&NetworkPluginServer::handleNewClientConnection, this, _1));

	m_server->start();

NetworkPluginServer::~NetworkPluginServer() {

	m_pingTimer->stop();

	delete m_vcardResponder;

}

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

void NetworkPluginServer::handleConnectedPayload(const std::string &data) {

	pbnetwork::Connected payload;

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

		// TODO: ERROR

		return;

	}

	m_component->m_userRegistry->onPasswordValid(payload.user());

// 	std::cout << payload.name() << "\n";

}

	std::cout << "OMG?\n";

	boost::shared_ptr<Swift::VCard> vcard(new Swift::VCard());

	vcard->setFullName(payload.fullname());

	vcard->setNickname(payload.nickname());

	m_vcardResponder->sendVCard(payload.id(), vcard);

	conv->handleMessage(msg, payload.nickname());

}

	while (c->data.size() != 0) {

		if (c->data.size() >= 4) {

			if (c->data.size() - 4 < expected_size)

				return;

		}

			return;

		}

		pbnetwork::WrapperMessage wrapper;

			return;

		}

		switch(wrapper.type()) {

			case pbnetwork::WrapperMessage_Type_TYPE_CONNECTED:

}

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

}

void NetworkPluginServer::pingTimeout() {

RosterManager::~RosterManager() {

	m_setBuddyTimer->stop();

	m_RIETimer->stop();

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

		Buddy *buddy = (*it).second;

		delete buddy;

	payload->addItem(item);

	request->onResponse.connect(boost::bind(&RosterManager::handleBuddyRosterPushResponse, this, _1, buddy->getName()));

	request->send();

}

void RosterManager::setBuddyCallback(Buddy *buddy) {

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

	std::cout << "ADDING " << buddy->getName() << "\n";

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

	onBuddySet(buddy);

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

		Buddy *buddy = (*it).second;

		Swift::RosterItemExchangePayload::Item item;

		payload->addItem(item);

	}

void RosterManager::setStorageBackend(StorageBackend *storageBackend) {

	if (m_rosterStorage) {

	}

	m_rosterStorage = new RosterStorage(m_user, storageBackend);

		Buddy *buddy = m_component->getFactory()->createBuddy(this, *it);

		std::cout << "CREATING BUDDY FROM DATABASE CACHE " << buddy->getName() << "\n";

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

		onBuddySet(buddy);

	}

}

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

 */

#include <iostream>

#include <boost/bind.hpp>

namespace Transport {

	m_userManager = userManager;

}

		buddyInfo.subscription = buddy->getSubscription();

		buddyInfo.id = buddy->getID();

		buddyInfo.flags = buddy->getFlags();

		// Buddy is in DB

		if (buddyInfo.id != -1) {

		FINALIZE_STMT(m_getUserSetting);

		FINALIZE_STMT(m_setUserSetting);

		FINALIZE_STMT(m_updateUserSetting);

		sqlite3_close(m_db);

	}

}

	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_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=?");

		onStorageError("addBuddy query", (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));

		return -1;

	}

}

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

	BIND_STR(m_updateBuddy, buddyInfo.legacyName);

	EXECUTE_STATEMENT(m_updateBuddy, "updateBuddy query");

}

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

		}

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

			buddy_id = GET_INT(m_getBuddiesSettings);

			var.type = GET_INT(m_getBuddiesSettings);

					var.s = val;

					break;

				default:

					break;

			}

			if (buddy_id == b.id) {

	public:

		MyUserRegistry(Component *c) {component = c;}

		~MyUserRegistry() {}

			Swift::Presence::ref response = Swift::Presence::create();

			response->setTo(component->getJID());

			response->setFrom(user);

	m_reconnectTimer->start();

}

}

}

void Component::handlePresence(Swift::Presence::ref presence) {

#include "transport/conversationmanager.h"

#include "transport/rostermanager.h"

#include "storageresponder.h"

namespace Transport {

	m_storageResponder = new StorageResponder(component->getIQRouter(), m_storageBackend, this);

	m_storageResponder->start();

	component->onUserPresenceReceived.connect(bind(&UserManager::handlePresence, this, _1));

	m_component->getStanzaChannel()->onMessageReceived.connect(bind(&UserManager::handleMessageReceived, this, _1));

	m_component->getStanzaChannel()->onPresenceReceived.connect(bind(&UserManager::handleGeneralPresenceReceived, this, _1));

UserManager::~UserManager(){

	m_storageResponder->stop();

	delete m_storageResponder;

}

void UserManager::addUser(User *user) {