#include "transport/config.h"

#include "transport/transport.h"

#include "transport/usermanager.h"

#include "transport/logger.h"

#include "transport/sqlite3backend.h"

#include "transport/userregistration.h"

#include "Swiften/EventLoop/SimpleEventLoop.h"

using namespace Transport;

int main(void)

{

	Config config;

	if (!config.load("sample.cfg")) {

		std::cout << "Can't open sample.cfg configuration file.\n";

		return 1;

	}

	Swift::SimpleEventLoop eventLoop;

	Logger logger(&transport);

	SQLite3Backend sql(&config);

	logger.setStorageBackend(&sql);

	if (!sql.connect()) {

		std::cout << "Can't connect to database.\n";

	}

	UserManager userManager(&transport, &sql);

	UserRegistration userRegistration(&transport, &userManager, &sql);

	logger.setUserRegistration(&userRegistration);

	logger.setUserManager(&userManager);

	transport.connect();

	eventLoop.run();

}

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(AbstractConversation *conv);

		void unsetConversation(AbstractConversation *conv);

	private:

		Component *m_component;

		User *m_user;

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

};

}

 * 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 <vector>

#include "Swiften/Swiften.h"

#include "Swiften/Server/Server.h"

#include "Swiften/Disco/GetDiscoInfoRequest.h"

#include "Swiften/Disco/EntityCapsManager.h"

#include "Swiften/Disco/CapsManager.h"

#include "Swiften/Disco/CapsMemoryStorage.h"

#include "Swiften/Presence/PresenceOracle.h"

#include "Swiften/Network/BoostTimerFactory.h"

#include "Swiften/Network/BoostIOServiceThread.h"

#include "Swiften/Server/UserRegistry.h"

#include <boost/bind.hpp>

#include "transport/config.h"

#define tr(lang,STRING)    (STRING)

#define _(STRING)    (STRING)

namespace Transport {

	// typedef enum { 	CLIENT_FEATURE_ROSTERX = 2,

	// 				CLIENT_FEATURE_XHTML_IM = 4,

	// 				CLIENT_FEATURE_FILETRANSFER = 8,

	// 				CLIENT_FEATURE_CHATSTATES = 16

	// 				} SpectrumImportantFeatures;

	// 

	class StorageBackend;

	class DiscoInfoResponder;

	class DiscoItemsResponder;

	class RosterResponder;

	/// Represents one transport instance.

	/// It's used to connect

	/// the Jabber server and provides transaction layer between Jabber server

	/// and other classes.

	class Component {

		public:

			/// Creates new Component instance.

			/// \param loop main event loop 

			/// \param config cofiguration, this class uses following Config values:

			/// 	- service.jid

			/// 	- service.password

			/// 	- service.server

			/// 	- service.port

			/// Component destructor.

			~Component();

			/// Returns Swift::Component associated with this Transport::Component.

			/// You can use it to send presences and other stanzas.

			/// \return Swift::Component associated with this Transport::Component

			Swift::StanzaChannel *getStanzaChannel();

			Swift::IQRouter *getIQRouter() { return m_iqRouter; }

			/// Returns Swift::PresenceOracle associated with this Transport::Component.

			/// You can use it to check current resource connected for particular user.

			/// \return Swift::PresenceOracle associated with this Transport::Component

			Swift::PresenceOracle *getPresenceOracle();

			bool inServerMode() { return m_server != NULL; }

			const std::string &getUserRegistryPassword(const std::string &barejid);

			/// Connects the Jabber server.

			/// \see Component()

			void connect();

			/// Sets disco#info features which are sent as answer to

			/// disco#info IQ-get. This sets features of transport contact (For example "j2j.domain.tld").

			/// \param features list of features as sent in disco#info response

			void setTransportFeatures(std::list<std::string> &features);

			/// Sets disco#info features which are sent as answer to

			/// disco#info IQ-get. This sets features of legacy network buddies (For example "me\40gmail.com@j2j.domain.tld").

			/// \param features list of features as sent in disco#info response

			void setBuddyFeatures(std::list<std::string> &features);

			/// Returns Jabber ID of this transport.

			/// \return Jabber ID of this transport

			Swift::JID &getJID() { return m_jid; }

			Swift::BoostNetworkFactories *getFactories() { return m_factories; }

			/// This signal is emitted when server disconnects the transport because of some error.

			/// \param error disconnection error

			boost::signal<void (const Swift::ComponentError &error)> onConnectionError;

			/// This signal is emitted when transport successfully connects the server.

			boost::signal<void ()> onConnected;

			/// This signal is emitted when XML stanza is sent to server.

			/// \param xml xml stanza

			boost::signal<void (const std::string &xml)> onXMLOut;

			/// This signal is emitted when XML stanza is received from server.

			/// \param xml xml stanza

			boost::signal<void (const std::string &xml)> onXMLIn;

			/// This signal is emitted when presence from XMPP user (for example "user@domain.tld")

			/// is received. It's emitted only for presences addressed to transport itself

			/// (for example to="j2j.domain.tld").

			/// \param presence presence data

			boost::signal<void (Swift::Presence::ref presence)> onUserPresenceReceived;

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

		private:

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

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

			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;

		friend class User;

		friend class UserRegistration;

	};

}

		/// Returns user according to his bare JID.

		/// \param barejid bare JID of user

		/// \return User class associated with this user

		User *getUser(const std::string &barejid);

		/// Returns number of online users.

		/// \return number of online users

		int getUserCount();

		/// Removes user. This function disconnects user and safely removes

		/// User class. This does *not* remove user from database.

		/// \param user User class to remove

		void removeUser(User *user);

		/// Called when new User class is created.

		/// \param user newly created User class

		boost::signal<void (User *user)> onUserCreated;

		/// Called when User class is going to be removed

		/// \param user removed User class

		boost::signal<void (User *user)> onUserDestroyed;

	private:

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

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

		void addUser(User *user);

		long m_onlineBuddies;

		User *m_cachedUser;

		std::map<std::string, User *> m_users;

		Component *m_component;

		StorageBackend *m_storageBackend;

};

}

#include "glib.h"

#include "purple.h"

#include <iostream>

#include "transport/config.h"

#include "transport/transport.h"

#include "transport/usermanager.h"

#include "transport/logger.h"

#include "transport/sqlite3backend.h"

#include "transport/userregistration.h"

#include "transport/user.h"

#include "transport/storagebackend.h"

#include "transport/rostermanager.h"

#include "spectrumeventloop.h"

#include "spectrumbuddy.h"

#include "spectrumconversation.h"

#include "geventloop.h"

#define Log(X, STRING) std::cout << "[SPECTRUM] " << X << " " << STRING << "\n";

using namespace Transport;

Logger *_logger;

static gboolean nodaemon = FALSE;

static gchar *logfile = NULL;

static gchar *lock_file = NULL;

static gboolean ver = FALSE;

static gboolean upgrade_db = FALSE;

static gboolean check_db_version = FALSE;

static gboolean list_purple_settings = FALSE;

static GOptionEntry options_entries[] = {

	{ "nodaemon", 'n', 0, G_OPTION_ARG_NONE, &nodaemon, "Disable background daemon mode", NULL },

	{ "logfile", 'l', 0, G_OPTION_ARG_STRING, &logfile, "Set file to log", NULL },

	{ "pidfile", 'p', 0, G_OPTION_ARG_STRING, &lock_file, "File where to write transport PID", NULL },

static void conv_new(PurpleConversation *conv) {

	PurpleAccount *account = purple_conversation_get_account(conv);

	User *user = (User *) account->ui_data;

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

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

	if (!s_conv)

		return;

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

	msg->setBody(message);

	s_conv->handleMessage(msg);

}

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

// 	Log(m_jid, "UIN:" << m_username << " USER_ID:" << m_userID);

}

static void handleUserDestroyed(User *user, UserManager *userManager, Config *config) {

	PurpleAccount *account = (PurpleAccount *) user->getData();

	if (account) {

		purple_account_set_enabled(account, "spectrum", FALSE);

		// Remove conversations.

		// This has to be called before m_account->ui_data = NULL;, because it uses

		// ui_data to call SpectrumMessageHandler::purpleConversationDestroyed() callback.

		GList *iter;

		for (iter = purple_get_conversations(); iter; ) {

			PurpleConversation *conv = (PurpleConversation*) iter->data;

			iter = iter->next;

			if (purple_conversation_get_account(conv) == account)

				purple_conversation_destroy(conv);

		}

		account->ui_data = NULL;

// 		Transport::instance()->collector()->collect(m_account);

	}

}

int main(int argc, char **argv) {

	GError *error = NULL;

	GOptionContext *context;

	context = g_option_context_new("config_file_name or profile name");

	g_option_context_add_main_entries(context, options_entries, "");

	if (!g_option_context_parse (context, &argc, &argv, &error)) {

		std::cout << "option parsing failed: " << error->message << "\n";

		return -1;

	}

	if (ver) {

// 		std::cout << VERSION << "\n";

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

		g_option_context_free(context);

		return 0;

	}

	if (argc != 2) {

#ifdef WIN32

		std::cout << "Usage: spectrum.exe <configuration_file.cfg>\n";

#else

#if GLIB_CHECK_VERSION(2,14,0)

	std::cout << g_option_context_get_help(context, FALSE, NULL);

// 		if (signal(SIGTERM, spectrum_sigterm_handler) == SIG_ERR) {

// 			std::cout << "SIGTERM handler can't be set\n";

// 			g_option_context_free(context);

// 			return -1;

// 		}

// 

// 		struct sigaction sa;

// 		memset(&sa, 0, sizeof(sa)); 

// 		sa.sa_handler = spectrum_sighup_handler;

// 		if (sigaction(SIGHUP, &sa, NULL)) {

// 			std::cout << "SIGHUP handler can't be set\n";

// 			g_option_context_free(context);

// 			return -1;

//		}

#endif

		Config config;

		if (!config.load(argv[1])) {

			std::cout << "Can't open " << argv[1] << " configuration file.\n";

			return 1;

		}

		initPurple(config);

		SpectrumEventLoop eventLoop;

		Logger logger(&transport);

		_logger = &logger;

		SQLite3Backend sql(&config);

		logger.setStorageBackend(&sql);

		if (!sql.connect()) {

			std::cout << "Can't connect to database.\n";

		}

		UserManager userManager(&transport, &sql);

		userManager.onUserCreated.connect(boost::bind(&handleUserCreated, _1, &userManager, &config));

		userManager.onUserDestroyed.connect(boost::bind(&handleUserDestroyed, _1, &userManager, &config));

		UserRegistration userRegistration(&transport, &userManager, &sql);

		logger.setUserRegistration(&userRegistration);

		logger.setUserManager(&userManager);

		transport.connect();

		eventLoop.run();

	}

	g_option_context_free(context);

}

 * (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 "spectrumconversation.h"

#include "transport/user.h"

#define Log(X, STRING) std::cout << "[SPECTRUM] " << X << " " << STRING << "\n";

SpectrumConversation::SpectrumConversation(ConversationManager *conversationManager, const std::string &legacyName, PurpleConversation *conv) : AbstractConversation(conversationManager, legacyName), m_conv(conv) {

}

SpectrumConversation::~SpectrumConversation() {

}

void SpectrumConversation::sendMessage(boost::shared_ptr<Swift::Message> &message) {

}

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

#include "account.h"

#include "glib.h"

#include <algorithm>

#include "transport/abstractconversation.h"

#include "transport/conversationmanager.h"

using namespace Transport;

// Wrapper for PurpleBuddy

class SpectrumConversation : public AbstractConversation {

	public:

		SpectrumConversation(ConversationManager *conversationManager, const std::string &legacyName, PurpleConversation *conv);

		virtual ~SpectrumConversation();

		PurpleConversation *getConversation() { return m_conv; }

		void sendMessage(boost::shared_ptr<Swift::Message> &message);

	private:

		PurpleConversation *m_conv;

};

 * 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 <iostream>

#include "transport/abstractconversation.h"

#include "transport/conversationmanager.h"

#include "transport/user.h"

#include "transport/transport.h"

#include "transport/abstractbuddy.h"

#include "transport/rostermanager.h"

namespace Transport {

AbstractConversation::AbstractConversation(ConversationManager *conversationManager, const std::string &legacyName) : m_conversationManager(conversationManager) {

	m_legacyName = legacyName;

}

AbstractConversation::~AbstractConversation() {

	m_conversationManager->unsetConversation(this);

}

void AbstractConversation::handleMessage(boost::shared_ptr<Swift::Message> &message) {

	message->setTo(m_conversationManager->getUser()->getJID().toBare());

	AbstractBuddy *buddy = m_conversationManager->getUser()->getRosterManager()->getBuddy(m_legacyName);

	if (buddy) {

		std::cout << m_legacyName << " 222222\n";

		message->setFrom(buddy->getJID());

	}

	else {

		std::cout << m_legacyName << " 1111111\n";

		// TODO: escape from and setFrom

	}

	m_conversationManager->getComponent()->getStanzaChannel()->sendMessage(message);

}

}

/**

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

#include "transport/usermanager.h"

#include "transport/abstractbuddy.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() {

}

void ConversationManager::setConversation(AbstractConversation *conv) {

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

}

void ConversationManager::unsetConversation(AbstractConversation *conv) {

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

}

}

/**

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

#include <boost/bind.hpp>

#include "transport/storagebackend.h"

#include "discoinforesponder.h"

#include "discoitemsresponder.h"

#include "rosterresponder.h"

using namespace Swift;

using namespace boost;

namespace Transport {

class MyUserRegistry : public Swift::UserRegistry {

	public:

		MyUserRegistry() {}

		~MyUserRegistry() {}

		bool isValidUserPassword(const JID& user, const std::string& password) const {

			users[user.toBare().toString()] = password;

			return true;

		}

		mutable std::map<std::string, std::string> users;

};

	m_component = NULL;

	m_userRegistry = NULL;

	m_server = NULL;

	m_reconnectCount = 0;

	m_config = config;

	m_jid = Swift::JID(CONFIG_STRING(m_config, "service.jid"));

	m_factories = new BoostNetworkFactories(loop);

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

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

	if (CONFIG_BOOL(m_config, "service.server_mode")) {

		m_userRegistry = new MyUserRegistry();

		m_server = new Swift::Server(loop, m_factories, m_userRegistry, m_jid, CONFIG_INT(m_config, "service.port"));

		m_server->start();

		m_stanzaChannel = m_server->getStanzaChannel();