if (!user)

		return;

	std::string name = purple_conversation_get_name(conv);

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

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

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

	SpectrumConversation *s_conv = new SpectrumConversation(user->getConversationManager(), name, conv);

	conv->ui_data = s_conv;

}

static void conv_destroy(PurpleConversation *conv) {

	SpectrumConversation *s_conv = (SpectrumConversation *) conv->ui_data;

	if (s_conv) {

		delete s_conv;

	}

}

static void conv_write_im(PurpleConversation *conv, const char *who, const char *message, PurpleMessageFlags flags, time_t mtime) {

	// Don't forwards our own messages.

	if (flags & PURPLE_MESSAGE_SEND || flags & PURPLE_MESSAGE_SYSTEM)

		return;

	char *striped = purple_markup_strip_html(message);

	g_free(striped);

}

static PurpleConversationUiOps conversation_ui_ops =

{

	conv_new,

	conv_destroy,

	NULL,//conv_write_chat,                              /* write_chat           */

	conv_write_im,             /* write_im             */

	NULL,//conv_write_conv,           /* write_conv           */

	NULL,//conv_chat_add_users,       /* chat_add_users       */

	NULL,//conv_chat_rename_user,     /* chat_rename_user     */

	NULL,//conv_chat_remove_users,    /* chat_remove_users    */

	NULL,//pidgin_conv_chat_update_user,     /* chat_update_user     */

	NULL,//pidgin_conv_present_conversation, /* present              */

	NULL,//pidgin_conv_has_focus,            /* has_focus            */

	NULL,//pidgin_conv_custom_smiley_add,    /* custom_smiley_add    */

	NULL,//pidgin_conv_custom_smiley_write,  /* custom_smiley_write  */

	NULL,//pidgin_conv_custom_smiley_close,  /* custom_smiley_close  */

	NULL,//pidgin_conv_send_confirm,         /* send_confirm         */

	NULL,

	NULL,

	NULL,

	NULL

};

#include "Swiften/Swiften.h"

namespace Transport {

class Conversation;

class User;

class Component;

class ConversationManager {

	public:

		/// Creates new ConversationManager.

		/// \param user User associated with this ConversationManager.

		/// \param component Transport instance associated with this roster.

		ConversationManager(User *user, Component *component);

		/// Destructor.

		virtual ~ConversationManager();

		/// Returns user associated with this manager.

		/// \return User

		User *getUser() { return m_user; }

		Component *getComponent() { return m_component; }

		void setConversation(Conversation *conv);

		void unsetConversation(Conversation *conv);

	private:

		void handleMessageReceived(Swift::Message::ref message);

		Component *m_component;

		User *m_user;

		std::map<std::string, Conversation *> m_convs;

		friend class UserManager;

};

}

#include "Swiften/Presence/PresenceOracle.h"

#include "Swiften/Disco/EntityCapsManager.h"

#include "Swiften/Network/ConnectionServer.h"

#include "Swiften/Network/Connection.h"

#include "Swiften/Network/BoostTimerFactory.h"

#include "Swiften/Network/BoostNetworkFactories.h"

#include "Swiften/Network/BoostIOServiceThread.h"

#include "Swiften/Network/Connection.h"

#include "storagebackend.h"

namespace Transport {

class NetworkPlugin {

	public:

		NetworkPlugin(Swift::EventLoop *loop, const std::string &host, int port);

		virtual ~NetworkPlugin();

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

			const std::string &groups, int status, const std::string &statusMessage = "", const std::string &iconHash = ""

		);

		void handleDisconnected(const std::string &user, const std::string &legacyName, int error, const std::string &message);

		virtual void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) = 0;

		virtual void handleLogoutRequest(const std::string &user, const std::string &legacyName) = 0;

	private:

		void connect();

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

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

		void handleDataRead(const Swift::ByteArray&);

		void handleConnected(bool error);

		void handleDisconnected();

		void send(const std::string &data);

		void sendPong();

		std::string m_data;

		std::string m_host;

		int m_port;

		Swift::BoostNetworkFactories *m_factories;

		Swift::BoostIOServiceThread m_boostIOServiceThread;

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

		Swift::Timer::ref m_reconnectTimer;

};

 *

 * 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 <time.h>

#include "Swiften/Swiften.h"

#include "Swiften/Presence/PresenceOracle.h"

#include "Swiften/Disco/EntityCapsManager.h"

#include "Swiften/Network/ConnectionServer.h"

#include "Swiften/Network/Connection.h"

#include "storagebackend.h"

namespace Transport {

class UserManager;

class User;

class Component;

class Buddy;

class LocalBuddy;

class Config;

class NetworkPluginServer {

	public:

		NetworkPluginServer(Component *component, Config *config, UserManager *userManager);

		virtual ~NetworkPluginServer();

	private:

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

		void handleSessionFinished(boost::shared_ptr<Swift::Connection>);

		void handleDataRead(boost::shared_ptr<Swift::Connection>, const Swift::ByteArray&);

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

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

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

		void handleUserCreated(User *user);

		void handleUserReadyToConnect(User *user);

		void handleUserDestroyed(User *user);

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

		void pingTimeout();

		void sendPing();

		std::string m_command;

		std::string m_data;

		UserManager *m_userManager;

		Config *m_config;

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

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

		bool m_pongReceived;

		Swift::Timer::ref m_pingTimer;

};

}

			Swift::BoostNetworkFactories *m_factories;

			Swift::Component *m_component;

			Swift::Server *m_server;

			Swift::Timer::ref m_reconnectTimer;

			Swift::BoostIOServiceThread m_boostIOServiceThread;

			Swift::EntityCapsManager *m_entityCapsManager;

			Swift::CapsManager *m_capsManager;

			Swift::CapsMemoryStorage *m_capsMemoryStorage;

			Swift::PresenceOracle *m_presenceOracle;

			Swift::StanzaChannel *m_stanzaChannel;

			Swift::IQRouter *m_iqRouter;

			Swift::UserRegistry *m_userRegistry;

			StorageBackend *m_storageBackend;

 			DiscoInfoResponder *m_discoInfoResponder;

			DiscoItemsResponder *m_discoItemsResponder;

			RosterResponder *m_rosterResponder;

			int m_reconnectCount;

			Config* m_config;

			std::string m_protocol;

			Swift::JID m_jid;

			Factory *m_factory;

		friend class User;

		friend class UserRegistration;

	};

}

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

	wrap.set_type(TYPE); \

	wrap.set_payload(MESSAGE); \

	wrap.SerializeToString(&MESSAGE);

NetworkPlugin::NetworkPlugin(Swift::EventLoop *loop, const std::string &host, int port) {

	m_factories = new Swift::BoostNetworkFactories(loop);

	m_host = host;

	m_port = port;

	m_conn = m_factories->getConnectionFactory()->createConnection();

	m_conn->onDataRead.connect(boost::bind(&NetworkPlugin::handleDataRead, this, _1));

	m_conn->onConnectFinished.connect(boost::bind(&NetworkPlugin::handleConnected, this, _1));

	m_conn->onDisconnected.connect(boost::bind(&NetworkPlugin::handleDisconnected, this));

	m_reconnectTimer = m_factories->getTimerFactory()->createTimer(1000);

	m_reconnectTimer->onTick.connect(boost::bind(&NetworkPlugin::connect, this)); 

	connect();

}

NetworkPlugin::~NetworkPlugin() {

	delete m_factories;

}

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

			const std::string &groups, int status, const std::string &statusMessage, const std::string &iconHash) {

	pbnetwork::Buddy buddy;

	buddy.set_username(user);

	buddy.set_buddyname(buddyName);

	buddy.set_alias(alias);

	buddy.set_groups(groups);

	buddy.set_status(status);

	buddy.set_statusmessage(statusMessage);

	buddy.set_iconhash(iconHash);

	std::string message;

	buddy.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);

	send(message);

}

void NetworkPlugin::handleDisconnected(const std::string &user, const std::string &legacyName, int error, const std::string &msg) {

	pbnetwork::Disconnected d;

	d.set_user(user);

	d.set_name(legacyName);

	d.set_error(error);

 * 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/networkpluginserver.h"

#include "transport/user.h"

#include "transport/transport.h"

#include "transport/storagebackend.h"

#include "transport/rostermanager.h"

#include "transport/usermanager.h"

#include "transport/conversationmanager.h"

#include "transport/localbuddy.h"

#include "transport/config.h"

#include "Swiften/Swiften.h"

#include "Swiften/Server/ServerStanzaChannel.h"

#include "Swiften/Elements/StreamError.h"

#include "pbnetwork.pb.h"

#include "sys/wait.h"

#include "sys/signal.h"

namespace Transport {

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

		exit(1);

	} else if ( pid < 0 ) {

		// fork failed

		status = -1;

	}

	return status;

}

static void SigCatcher(int n) {

	wait3(NULL,WNOHANG,NULL);

}

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

	}

	else {

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

		handleBuddyPayload(buddy, payload);

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

	}

}

void NetworkPluginServer::handleDataRead(boost::shared_ptr<Swift::Connection> c, const Swift::ByteArray &data) {

	long expected_size = 0;

	m_data += data.toString();

	std::cout << "received data; size = " << m_data.size() << "\n";

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

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

			unsigned char * head = (unsigned char*) m_data.c_str();

			expected_size = (((((*head << 8) | *(head + 1)) << 8) | *(head + 2)) << 8) | *(head + 3);

			//expected_size = m_data[0];

			std::cout << "expected_size=" << expected_size << "\n";

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

				return;

		}

		else {

			return;

		}

		std::string msg = m_data.substr(4, expected_size);

		m_data.erase(0, 4 + expected_size);

		pbnetwork::WrapperMessage wrapper;

		if (wrapper.ParseFromString(msg) == false) {

			// TODO: ERROR

			return;

		}

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

				m_pongReceived = true;

				break;

			default:

				return;

		}

	}

}

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

	std::string header("    ");

	for (int i = 0; i != 4; ++i)

		header.at(i) = static_cast<char>(data.size() >> (8 * (3 - i)));

	c->write(Swift::ByteArray(header + data));

}

void NetworkPluginServer::pingTimeout() {

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

	if (m_pongReceived) {

		sendPing();

		m_pingTimer->start();

	}

	else {

	std::string message;

	login.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_LOGIN);

	send(m_client, message);

}

void NetworkPluginServer::handleUserDestroyed(User *user) {

	UserInfo userInfo = user->getUserInfo();

	pbnetwork::Logout logout;

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

	logout.set_legacyname(userInfo.uin);

	std::string message;

	logout.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_LOGOUT);

	send(m_client, message);

}

void NetworkPluginServer::sendPing() {

	std::string message;

	pbnetwork::WrapperMessage wrap;

	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_PING);

	wrap.SerializeToString(&message);

	send(m_client, message);

	m_pongReceived = false;

	std::cout << "SENDING PING\n";

}

}

	optional string message = 4;

}

message Login {

	required string user = 1;

	required string legacyName = 2;

	required string password = 3;

}

message Logout {

	required string user = 1;

	required string legacyName = 2;

}

message Buddy {

	required string userName = 1;

	required string buddyName = 2;

	required string alias = 3;

	required string groups = 4;

	required int32 status = 5;

	optional string statusMessage = 6;

	optional string iconHash = 7;

}

message ConversationMessage {

	required string userName = 1;

	required string buddyName = 2;

	required string message = 3;

}

message WrapperMessage {

	enum Type { 

		TYPE_CONNECTED 		= 1;

		TYPE_DISCONNECTED 	= 2;

		TYPE_LOGIN 			= 3;

		TYPE_LOGOUT 		= 4;

		TYPE_BUDDY_CHANGED	= 6;

		TYPE_BUDDY_REMOVED	= 7;

	}

	required Type type = 1;

	optional bytes payload = 2;

}

;