if ((!firstName.empty() || !lastName.empty()) && fullName.empty())

		fullName = firstName + " " + lastName;

	PurpleBuddy *buddy = purple_find_buddy(purple_connection_get_account(gc), who);

	if (buddy) {

		gsize len;

		PurpleBuddyIcon *icon = NULL;

		icon = purple_buddy_icons_find(purple_connection_get_account(gc), name.c_str());

		if (icon) {

			const gchar * data = (gchar*)purple_buddy_icon_get_data(icon, &len);

			// Sometimes libpurple returns really broken pointers here

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

				photo = Swift::createByteArray(data, len);

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

// 				if (ext) {

// 					std::string extension(ext);

// 					if (extension != "icon") {

// 						if (extension == "jpg") {

// 							extension = "jpeg";

// 						}

// 						photo->addChild( new Tag("TYPE", "image/" + extension) );

// 					}

// 				}

			}

		}

	}

	np->handleVCard(np->m_accounts[account], np->m_vcards[np->m_accounts[account] + name], name, fullName, nickname, Swift::byteArrayToString(photo));

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

	return NULL;

}

static PurpleNotifyUiOps notifyUiOps =

{

		NULL,

		NULL,

		NULL,

		NULL,

		NULL,

		NULL,

		notify_user_info,

		NULL,

		NULL,

		NULL,

		NULL,

		NULL,

		NULL

};

static PurpleRequestUiOps requestUiOps =

{

	requestInput,

	NULL,

	requestAction,

	NULL,

	NULL,

	NULL, //requestClose,

	NULL,

	NULL,

	NULL,

	NULL,

	NULL

};

static void transport_core_ui_init(void)

{

	purple_blist_set_ui_ops(&blistUiOps);

// 	purple_accounts_set_ui_ops(&accountUiOps);

	purple_notify_set_ui_ops(&notifyUiOps);

	purple_request_set_ui_ops(&requestUiOps);

// 	purple_xfers_set_ui_ops(getXferUiOps());

	purple_connections_set_ui_ops(&conn_ui_ops);

	purple_conversations_set_ui_ops(&conversation_ui_ops);

// #ifndef WIN32

// 	purple_dnsquery_set_ui_ops(getDNSUiOps());

// #endif

}

static PurpleCoreUiOps coreUiOps =

{

	NULL,

// 	debug_init,

	NULL,

	transport_core_ui_init,

	NULL,

	NULL,

	NULL,

	NULL,

	NULL

};

static void signed_on(PurpleConnection *gc, gpointer unused) {

	PurpleAccount *account = purple_connection_get_account(gc);

	np->handleConnected(np->m_accounts[account]);

}

static void printDebug(PurpleDebugLevel level, const char *category, const char *arg_s) {

	std::string c("[LIBPURPLE");

	if (category) {

		c.push_back('/');

		c.append(category);

	}

	c.push_back(']');

	std::cout << c << " " << arg_s;

}

/*

 * Ops....

 */

static PurpleDebugUiOps debugUiOps =

{

	printDebug,

	NULL,

	NULL,

	NULL,

	NULL,

	NULL

};

static void buddyTyping(PurpleAccount *account, const char *who, gpointer null) {

	std::string w = who;

	size_t pos = w.find("/");

	if (pos != std::string::npos)

		w.erase((int) pos, w.length() - (int) pos);

	np->handleBuddyTyping(np->m_accounts[account], w);

}

static void buddyTyped(PurpleAccount *account, const char *who, gpointer null) {

	std::string w = who;

	size_t pos = w.find("/");

	if (pos != std::string::npos)

		w.erase((int) pos, w.length() - (int) pos);

	np->handleBuddyTyped(np->m_accounts[account], w);

}

static void buddyTypingStopped(PurpleAccount *account, const char *who, gpointer null){

	std::string w = who;

	size_t pos = w.find("/");

	if (pos != std::string::npos)

		w.erase((int) pos, w.length() - (int) pos);

	np->handleBuddyStoppedTyping(np->m_accounts[account], w);

}

static bool initPurple(Config &cfg) {

	bool ret;

	purple_util_set_user_dir("./");

	remove("./accounts.xml");

	remove("./blist.xml");

// 	if (m_configuration.logAreas & LOG_AREA_PURPLE)

		purple_debug_set_ui_ops(&debugUiOps);

	purple_core_set_ui_ops(&coreUiOps);

	purple_eventloop_set_ui_ops(getEventLoopUiOps());

	ret = purple_core_init("spectrum");

	if (ret) {

		static int blist_handle;

		static int conversation_handle;

		purple_set_blist(purple_blist_new());

		purple_blist_load();

		purple_prefs_load();

		/* Good default preferences */

		/* The combination of these two settings mean that libpurple will never

		 * (of its own accord) set all the user accounts idle.

		 */

		purple_prefs_set_bool("/purple/away/away_when_idle", false);

		/*

		 * This must be set to something not "none" for idle reporting to work

		 * for, e.g., the OSCAR prpl. We don't implement the UI ops, so this is

		 * okay for now.

		 */

		purple_prefs_set_string("/purple/away/idle_reporting", "system");

		/* Disable all logging */

		purple_prefs_set_bool("/purple/logging/log_ims", false);

		purple_prefs_set_bool("/purple/logging/log_chats", false);

		purple_prefs_set_bool("/purple/logging/log_system", false);

// 		purple_signal_connect(purple_conversations_get_handle(), "received-im-msg", &conversation_handle, PURPLE_CALLBACK(newMessageReceived), NULL);

[service]

jid = localhost

password = secret

server = 127.0.0.1

port = 5222

server_mode = 1

backend=../../backends/libpurple/libpurple_backend

#backend=../../backends/libircclient-qt/libircclient-qt_backend

protocol=prpl-jabber

#protocol=prpl-msn

#protocol=prpl-icq

[database]

database = test.sql

prefix=icq

/**

 * libtransport -- C++ library for easy XMPP Transports development

 *

 * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>

 *

 * 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

 */

#include "transport/config.h"

#include <fstream>

using namespace boost::program_options;

namespace Transport {

bool Config::load(const std::string &configfile, boost::program_options::options_description &opts) {

	std::ifstream ifs(configfile.c_str());

	if (!ifs.is_open())

		return false;

	opts.add_options()

		("service.jid", value<std::string>()->default_value(""), "Transport Jabber ID")

		("service.server", value<std::string>()->default_value(""), "Server to connect to")

		("service.password", value<std::string>()->default_value(""), "Password used to auth the server")

		("service.port", value<int>()->default_value(0), "Port the server is listening on")

		("service.backend", value<std::string>()->default_value("libpurple_backend"), "Backend")

		("service.protocol", value<std::string>()->default_value(""), "Protocol")

		("service.allowed_servers", value<std::string>()->default_value(""), "Only users from these servers can connect")

		("service.server_mode", value<bool>()->default_value(false), "True if Spectrum should behave as server")

		("registration.enable_public_registration", value<bool>()->default_value(true), "True if users should be able to register.")

		("registration.language", value<std::string>()->default_value("en"), "Default language for registration form")

		("registration.instructions", value<std::string>()->default_value(""), "Instructions showed to user in registration form")

		("registration.username_field", value<std::string>()->default_value(""), "Label for username field")

		("registration.username_mask", value<std::string>()->default_value(""), "Username mask")

		("registration.encoding", value<std::string>()->default_value("en"), "Default encoding in registration form")

		("database.database", value<std::string>()->default_value(""), "Database used to store data")

		("database.prefix", value<std::string>()->default_value(""), "Prefix of tables in database")

	;

    store(parse_config_file(ifs, opts), m_variables);

	notify(m_variables);

	m_file = configfile;

	onConfigReloaded();

	return true;

}

bool Config::load(const std::string &configfile) {

	options_description opts("Transport options");

	return load(configfile, opts);

}

}

/**

 * 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

 */

#include "transport/conversationmanager.h"

#include "transport/conversation.h"

#include "transport/usermanager.h"

#include "transport/buddy.h"

#include "transport/factory.h"

#include "transport/user.h"

#include "Swiften/Roster/SetRosterRequest.h"

#include "Swiften/Elements/RosterPayload.h"

#include "Swiften/Elements/RosterItemPayload.h"

namespace Transport {

ConversationManager::ConversationManager(User *user, Component *component){

	m_user = user;

	m_component = component;

}

ConversationManager::~ConversationManager() {

	while(!m_convs.empty()) {

		delete (*m_convs.begin()).second;

	}

}

void ConversationManager::addConversation(Conversation *conv) {

	m_convs[conv->getLegacyName()] = conv;

}

void ConversationManager::removeConversation(Conversation *conv) {

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

		if ((*it).second->getRoom() == conv->getLegacyName()) {

			(*it).second->setRoom("");

		}

	}

	m_convs.erase(conv->getLegacyName());

}

void ConversationManager::handleMessageReceived(Swift::Message::ref message) {

	std::string name = message->getTo().getUnescapedNode();

	if (name.find_last_of("%") != std::string::npos) {

		name.replace(name.find_last_of("%"), 1, "@");

	}

	if (!m_convs[name]) {

		m_convs[name] = m_component->getFactory()->createConversation(this, name);

	}

	else if (m_convs[name]->isMUC() && message->getType() != Swift::Message::Groupchat) {

		std::string room_name = name;

		name = message->getTo().getResource();

		if (!m_convs[name]) {

			m_convs[name] = m_component->getFactory()->createConversation(this, name);

			m_convs[name]->setRoom(room_name);

		}

	}

	m_convs[name]->sendMessage(message);

}

}

namespace Transport {

class NetworkConversation : public Conversation {

	public:

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

		}

		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;

		}

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

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

			nc->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, m_nps, _1, _2));

			return nc;

		}

		Buddy *createBuddy(RosterManager *rosterManager, const BuddyInfo &buddyInfo) {

			LocalBuddy *buddy = new LocalBuddy(rosterManager, buddyInfo.id);

			buddy->setAlias(buddyInfo.alias);

			buddy->setName(buddyInfo.legacyName);

			buddy->setSubscription(buddyInfo.subscription);

			buddy->setGroups(buddyInfo.groups);

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

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

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

			return buddy;

		}

	private:

		NetworkPluginServer *m_nps;

};

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

	wrap.set_type(TYPE); \

	wrap.set_payload(MESSAGE); \

	wrap.SerializeToString(&MESSAGE);

static int exec_(const char *path, const char *host, const char *port, const char *config) {

// 	char *argv[] = {(char*)script_name, '\0'}; 

	int status = 0;

	pid_t pid = fork();

	if ( pid == 0 ) {

		// child process

		execlp(path, path, "--host", host, "--port", port, config, NULL);

		abort();

	} else if ( pid < 0 ) {

		// fork failed

		status = -1;

	}

	return status;

}

static void SigCatcher(int n) {

	wait3(NULL,WNOHANG,NULL);

}

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

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

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

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

	groups.push_back(payload.groups());

	buddy->setGroups(groups);

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

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

}

NetworkPluginServer::NetworkPluginServer(Component *component, Config *config, UserManager *userManager) {

	m_userManager = userManager;

	m_config = config;

	m_component = component;

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

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

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

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

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

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

	m_server->start();

	signal(SIGCHLD, SigCatcher);

}

NetworkPluginServer::~NetworkPluginServer() {

	m_pingTimer->stop();

	delete m_vcardResponder;

	delete m_rosterResponder;

}

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

	Client *client = new Client;

	client->pongReceived = true;

	client->connection = c;

	m_clients.push_back(client);

	c->onDisconnected.connect(boost::bind(&NetworkPluginServer::handleSessionFinished, this, client));

	c->onDataRead.connect(boost::bind(&NetworkPluginServer::handleDataRead, this, client, _1));

	sendPing(client);

	m_pingTimer->start();

}

void NetworkPluginServer::handleSessionFinished(Client *c) {

	for (std::list<User *>::const_iterator it = c->users.begin(); it != c->users.end(); it++) {

		(*it)->setData(NULL);

		(*it)->handleDisconnected("Internal Server Error, please reconnect.");

	}

	m_clients.remove(c);

	delete c;

	// Execute new session only if there's no free one after this crash/disconnection

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

		if ((*it)->users.size() < 1) {

			return;

		}

	}

}

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

	pbnetwork::Connected payload;

	std::cout << "CONNECTED LOGIN 2 " << payload.user() << "\n";

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

		// TODO: ERROR

		return;

	}

	std::cout << "CONNECTED LOGIN 3 " << payload.user() << "\n";

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

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

}

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

	pbnetwork::Disconnected payload;

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

		// TODO: ERROR

		return;

	}

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

	User *user = m_userManager->getUser(payload.user());

	if (!user) {

		return;

	}

	user->handleDisconnected(payload.message());

}

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

	pbnetwork::VCard payload;

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

		std::cout << "PARSING ERROR\n";

		// TODO: ERROR

		return;

	}

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

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

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

	vcard->setPhoto(Swift::createByteArray(payload.photo()));

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

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

}

void NetworkPluginServer::handleChatStatePayload(const std::string &data, Swift::ChatState::ChatStateType type) {

	pbnetwork::Buddy payload;

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

		// TODO: ERROR

		return;

	}

	User *user = m_userManager->getUser(payload.username());

	if (!user)

		return;

	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(payload.buddyname());

	if (!conv) {

		std::cout << "handling chatstate: NO conv with buddyname=" << payload.buddyname() << "\n";

		return;

	}

	boost::shared_ptr<Swift::Message> msg(new Swift::Message());

	msg->addPayload(boost::make_shared<Swift::ChatState>(type));

	conv->handleMessage(msg);

}

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

	pbnetwork::Buddy payload;

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

		// TODO: ERROR

		return;

	}

	User *user = m_userManager->getUser(payload.username());

	if (!user)

		return;

	LocalBuddy *buddy = (LocalBuddy *) user->getRosterManager()->getBuddy(payload.buddyname());

	if (buddy) {

		handleBuddyPayload(buddy, payload);

		buddy->handleBuddyChanged();

	}

	else {

		buddy = new LocalBuddy(user->getRosterManager(), -1);

		handleBuddyPayload(buddy, payload);

		user->getRosterManager()->setBuddy(buddy);

	}

}

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

	pbnetwork::Participant payload;

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

	if (subject) {

		msg->setSubject(payload.message());

	}

	else {

		msg->setBody(payload.message());

	}

	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(payload.buddyname());

	if (!conv) {

		conv = new NetworkConversation(user->getConversationManager(), payload.buddyname());

		conv->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, this, _1, _2));

	}

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

}

void NetworkPluginServer::handleDataRead(Client *c, const Swift::SafeByteArray &data) {

	c->data.insert(c->data.end(), data.begin(), data.end());

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

		unsigned int expected_size;

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

			expected_size = *((unsigned int*) &c->data[0]);

			expected_size = ntohl(expected_size);

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

				return;

		}

		else {

			return;

		}

		pbnetwork::WrapperMessage wrapper;

		if (wrapper.ParseFromArray(&c->data[4], expected_size) == false) {

			std::cout << "PARSING ERROR " << expected_size << "\n";

			c->data.erase(c->data.begin(), c->data.begin() + 4 + expected_size);

			continue;

		}

		c->data.erase(c->data.begin(), c->data.begin() + 4 + expected_size);

		switch(wrapper.type()) {

			case pbnetwork::WrapperMessage_Type_TYPE_CONNECTED:

				handleConnectedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_DISCONNECTED:

				handleDisconnectedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED:

				handleBuddyChangedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE:

				handleConvMessagePayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_ROOM_SUBJECT_CHANGED:

				handleConvMessagePayload(wrapper.payload(), true);

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_PONG:

				c->pongReceived = true;

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_PARTICIPANT_CHANGED:

				handleParticipantChangedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_ROOM_NICKNAME_CHANGED:

				handleRoomChangedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_VCARD:

				handleVCardPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING:

				handleChatStatePayload(wrapper.payload(), Swift::ChatState::Composing);

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPED:

				handleChatStatePayload(wrapper.payload(), Swift::ChatState::Paused);

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_STOPPED_TYPING:

				handleChatStatePayload(wrapper.payload(), Swift::ChatState::Active);

				break;

			default:

				return;

		}

	}

}

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

	char header[4];

	*((int*)(header)) = htonl(data.size());

	c->write(Swift::createSafeByteArray(std::string(header, 4) + data));

}

void NetworkPluginServer::pingTimeout() {

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

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

		if ((*it)->pongReceived) {

			sendPing((*it));

			m_pingTimer->start();

		}

		else {

		}

	}

}

void NetworkPluginServer::handleUserCreated(User *user) {

	Client *c = getFreeClient();

	if (!c) {

		user->handleDisconnected("Internal Server Error, please reconnect.");

		return;

	}

	user->setData(c);

	c->users.push_back(user);

// 	UserInfo userInfo = user->getUserInfo();

	user->onReadyToConnect.connect(boost::bind(&NetworkPluginServer::handleUserReadyToConnect, this, user));

	user->onPresenceChanged.connect(boost::bind(&NetworkPluginServer::handleUserPresenceChanged, this, user, _1));

	user->onRoomJoined.connect(boost::bind(&NetworkPluginServer::handleRoomJoined, this, user, _1, _2, _3));

	user->onRoomLeft.connect(boost::bind(&NetworkPluginServer::handleRoomLeft, this, user, _1));

}

void NetworkPluginServer::handleUserReadyToConnect(User *user) {

	UserInfo userInfo = user->getUserInfo();

	pbnetwork::Login login;

	login.set_user(user->getJID().toBare());

	login.set_legacyname(userInfo.uin);

	login.set_password(userInfo.password);

	std::string message;

	login.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_LOGIN);

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

	send(c->connection, message);

}

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

	if (presence->getShow() == Swift::StatusShow::None)

		return;

	UserInfo userInfo = user->getUserInfo();

	pbnetwork::Status status;

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

	status.set_status((int) presence->getShow());

	status.set_statusmessage(presence->getStatus());

	std::string message;

	status.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_STATUS_CHANGED);

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

	send(c->connection, message);

}

void NetworkPluginServer::handleRoomJoined(User *user, const std::string &r, const std::string &nickname, const std::string &password) {

	UserInfo userInfo = user->getUserInfo();

	pbnetwork::Room room;

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