* 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 NetworkConversation;

class VCardResponder;

class NetworkPluginServer {

	public:

		struct Client {

			bool pongReceived;

			std::list<User *> users;

			Swift::SafeByteArray data;

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

		};

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

		virtual ~NetworkPluginServer();

		void handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &message);

	private:

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

		void handleSessionFinished(Client *c);

		void handleDataRead(Client *c, const Swift::SafeByteArray&);

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

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

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

		void handleConvMessagePayload(const std::string &payload, bool subject = false);

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

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

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

		void handleUserCreated(User *user);

		void handleRoomJoined(User *user, const std::string &room, const std::string &nickname, const std::string &password);

		void handleRoomLeft(User *user, const std::string &room);

		void handleUserReadyToConnect(User *user);

		void handleUserDestroyed(User *user);

		void handleVCardRequired(User *user, const std::string &name, unsigned int id);

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

		void pingTimeout();

		void sendPing(Client *c);

		Client *getFreeClient();

		UserManager *m_userManager;

		VCardResponder *m_vcardResponder;

		Config *m_config;

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

		std::list<Client *>  m_clients;

		Swift::Timer::ref m_pingTimer;

		Component *m_component;

};

}

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

#include "Swiften/Swiften.h"

#include "Swiften/Queries/Responder.h"

#include "Swiften/Elements/RosterPayload.h"

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;

};

}

		/// 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 handleMessageReceived(Swift::Message::ref message);

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

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

		void handleSubscription(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;

		StorageResponder *m_storageResponder;

		friend class RosterResponder;

};

}

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

#include "transport/vcardresponder.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 {

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

	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->getFactories()->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_server = component->getFactories()->getConnectionFactory()->createConnectionServer(10000);

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

	m_server->start();

	signal(SIGCHLD, SigCatcher);

	exec_(CONFIG_STRING(m_config, "service.backend").c_str(), "localhost", "10000", m_config->getConfigFile().c_str());

}

NetworkPluginServer::~NetworkPluginServer() {

	m_pingTimer->stop();

	delete m_vcardResponder;

}

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;

/**

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

#include <boost/bind.hpp>

#include "Swiften/Queries/IQRouter.h"

#include "Swiften/Swiften.h"

#include "transport/user.h"

#include "transport/usermanager.h"

#include "transport/rostermanager.h"

using namespace Swift;

using namespace boost;

namespace Transport {

	m_userManager = userManager;

}

RosterResponder::~RosterResponder() {

}

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

	// Get means we're in server mode and user wants to fetch his roster.

	// For now we send empty reponse, but TODO: Get buddies from database and send proper stored roster.

	User *user = m_userManager->getUser(from.toBare().toString());

	if (!user) {

		// Client can send jabber:iq:roster IQ before presence, so we do little hack here to

		// trigger logging in.

		// UserManager should create user now, if everything is OK.

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

		response->setTo(to);

		response->setFrom(from);

		response->setType(Swift::Presence::Available);

		m_userManager->handlePresence(response);

		// if it's not created, lets finish this get

		user = m_userManager->getUser(from.toBare().toString());

		if (!user) {

			sendResponse(from, id, boost::shared_ptr<RosterPayload>(new RosterPayload()));

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

#include "transport/user.h"

#include "transport/transport.h"

#include "transport/storagebackend.h"

#include "transport/conversationmanager.h"

#include "transport/rostermanager.h"

#include "storageresponder.h"

namespace Transport {

UserManager::UserManager(Component *component, StorageBackend *storageBackend) {

	m_cachedUser = NULL;

	m_onlineBuddies = 0;

	m_component = component;

	m_storageBackend = storageBackend;

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

// 	component->onDiscoInfoResponse.connect(bind(&UserManager::handleDiscoInfoResponse, this, _1, _2, _3));

}

UserManager::~UserManager(){

	m_storageResponder->stop();

	delete m_storageResponder;

}

void UserManager::addUser(User *user) {

	m_users[user->getJID().toBare().toString()] = user;

	onUserCreated(user);

}

User *UserManager::getUser(const std::string &barejid){

	if (m_cachedUser && barejid == m_cachedUser->getJID().toBare().toString()) {

		return m_cachedUser;

	}

	if (m_users.find(barejid) != m_users.end()) {

		User *user = m_users[barejid];

		m_cachedUser = user;

		return user;

	}

	return NULL;

}

void UserManager::removeUser(User *user) {

	m_users.erase(user->getJID().toBare().toString());

	if (m_cachedUser == user)

		m_cachedUser = NULL;