*.pb.cc

*.pb.h

 *

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

#include "transport/transport.h"

#include "Swiften/Elements/VCard.h"

namespace Transport {

class RosterManager;

typedef enum { 	BUDDY_NO_FLAG = 0,

				BUDDY_JID_ESCAPING = 2,

				BUDDY_IGNORE = 4,

				BUDDY_BLOCKED = 8,

			} BuddyFlag;

/// Represents one legacy network Buddy.

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

#include "transport/transport.h"

#include "Swiften/Elements/Message.h"

namespace Transport {

class ConversationManager;

/// Represents one XMPP-Legacy network conversation.

class Conversation {

	public:

		typedef enum {

			PARTICIPANT_FLAG_NONE = 0,

			PARTICIPANT_FLAG_MODERATOR = 1,

			PARTICIPANT_FLAG_CONFLICT = 2,

class UserManager;

class User;

class Component;

class Buddy;

class LocalBuddy;

class Config;

class NetworkConversation;

class VCardResponder;

class RosterResponder;

class BlockResponder;

class DummyReadBytestream;

class AdminInterface;

class NetworkPluginServer : Swift::XMPPParserClient {

	public:

		struct Backend {

			int pongReceived;

			std::list<User *> users;

			Swift::SafeByteArray data;

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

			unsigned long res;

			unsigned long init_res;

			unsigned long shared;

			bool acceptUsers;

			bool longRun;

			bool willDie;

			std::string id;

		};

		virtual ~NetworkPluginServer();

		void start();

		void setAdminInterface(AdminInterface *adminInterface) {

			m_adminInterface = adminInterface;

		}

		int getBackendCount() {

			return m_clients.size();

		}

		std::vector<unsigned long> m_pids;

		Swift::Timer::ref m_pingTimer;

		Swift::Timer::ref m_collectTimer;

		Swift::Timer::ref m_loginTimer;

		Component *m_component;

		std::list<User *> m_waitingUsers;

		bool m_isNextLongRun;

		std::map<unsigned long, FileTransferManager::Transfer> m_filetransfers;

		FileTransferManager *m_ftManager;

		std::vector<std::string> m_crashedBackends;

		AdminInterface *m_adminInterface;

		bool m_startingBackend;

		time_t m_lastLogin;

		Swift::XMPPParser *m_xmppParser;

		Swift::FullPayloadParserFactoryCollection m_collection;

		Swift::XMPPSerializer *m_serializer;

		Swift::FullPayloadSerializerCollection m_collection2;

		std::map <std::string, std::string> m_id2resource;

};

}

#pragma once

#include <map>

#include <string>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Base/boost_bsignals.h>

namespace Transport {

class PresenceOracle {

	public:

		~PresenceOracle();

		Swift::Presence::ref getLastPresence(const Swift::JID&) const;

		Swift::Presence::ref getHighestPriorityPresence(const Swift::JID& bareJID) const;

		std::vector<Swift::Presence::ref> getAllPresence(const Swift::JID& bareJID) const;

		void clearPresences(const Swift::JID& bareJID);

	public:

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

	private:

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

		void handleStanzaChannelAvailableChanged(bool);

	private:

		typedef std::map<Swift::JID, Swift::Presence::ref> PresenceMap;

		typedef std::map<Swift::JID, PresenceMap> PresencesMap;

		PresencesMap entries_;

};

}

#include "Swiften/Roster/SetRosterRequest.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/Network/Timer.h"

namespace Transport {

class Buddy;

class User;

class Component;

class StorageBackend;

class RosterStorage;

/// Manages roster of one XMPP user.

class RosterManager {

	public:

		typedef std::map<std::string, Buddy *, std::less<std::string>, boost::pool_allocator< std::pair<std::string, Buddy *> > > BuddiesMap;

		/// Creates new RosterManager.

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

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

		RosterManager(User *user, Component *component);

		/// Destructor.

		virtual ~RosterManager();

		/// Associates the buddy with this roster,

		/// and if the buddy is not already in XMPP user's server-side roster, the proper requests

		/// are sent to XMPP user (subscribe presences, Roster Item Exchange stanza or

		/// the buddy is added to server-side roster using remote-roster protoXEP).

		/// \param buddy Buddy

		void setBuddy(Buddy *buddy);

		/// Deassociates the buddy with this roster.

		/// \param buddy Buddy.

		void unsetBuddy(Buddy *buddy);

		/// Removes buddy from this roster, sends proper XML to XMPP side and deletes it.

		/// Called when Buddy has been removed from this roster.

		/// \param buddy removed Buddy

		boost::signal<void (Buddy *buddy)> onBuddyUnset;

		boost::signal<void (Buddy *buddy)> onBuddyAdded;

		boost::signal<void (Buddy *buddy)> onBuddyRemoved;

		void handleBuddyChanged(Buddy *buddy);

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

		void sendBuddyRosterRemove(Buddy *buddy);

		void sendBuddySubscribePresence(Buddy *buddy);

		void sendBuddyUnsubscribePresence(Buddy *buddy);

		void sendCurrentPresences(const Swift::JID &to);

		void sendCurrentPresence(const Swift::JID &from, const Swift::JID &to);

		void sendUnavailablePresences(const Swift::JID &to);

		std::map<std::string, Buddy *, std::less<std::string>, boost::pool_allocator< std::pair<std::string, Buddy *> > > m_buddies;

		Component *m_component;

		RosterStorage *m_rosterStorage;

		User *m_user;

		Swift::Timer::ref m_setBuddyTimer;

		Swift::Timer::ref m_RIETimer;

		std::list <Swift::SetRosterRequest::ref> m_requests;

		bool m_supportRemoteRoster;

};

}

		~RosterResponder();

		boost::signal<void (Buddy *, const Swift::RosterItemPayload &item)> onBuddyUpdated;

		boost::signal<void (Buddy *)> onBuddyRemoved;

		boost::signal<void (Buddy *, const Swift::RosterItemPayload &item)> onBuddyAdded;

	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;

};

}

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

#include "Swiften/Network/BoostIOServiceThread.h"

namespace Transport {

	class StorageBackend;

	class Factory;

	class UserRegistry;

		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

			/// 	- service.server_mode

			/// \param factories Swift::NetworkFactories.

			/// \param factory Transport Abstract factory used to create basic transport structures.

			/// \param userRegistery UserRegistry class instance. It's needed only when running transport in server-mode.

			/// Component destructor.

			~Component();

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

			/// Returns True if the component is in server mode.

			/// \return True if the component is in server mode.

			/// Starts the Component.

			/// In server-mode, it starts listening on particular port for new client connections.

			/// In gateway-mode, it connects the XMPP server.

			void start();

			/// Stops the component.

			void stop();

			/// Returns Jabber ID of this transport.

			/// \return Swift::NetworkFactories which can be used to create new connections.

			Swift::NetworkFactories *getNetworkFactories() { return m_factories; }

			/// Returns Transport Factory used to create basic Transport components.

			/// \return Transport Factory used to create basic Transport components.

			Factory *getFactory() { return m_factory; }

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

			/// \param error disconnection error

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

			Config *getConfig() { return m_config; }

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

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

			/// MUC (for example to="#chat%irc.freenode.org@irc.domain.tld")

			/// \param presence Presence.

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

			boost::signal<void (boost::shared_ptr<Swift::IQ>)> onRawIQReceived;

			}

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

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

			void handleBackendConfigChanged();

			Swift::NetworkFactories *m_factories;

			Swift::Timer::ref m_reconnectTimer;

			PresenceOracle *m_presenceOracle;

			Transport::UserRegistry *m_userRegistry;

			StorageBackend *m_storageBackend;

			int m_reconnectCount;

			Config* m_config;

			Swift::JID m_jid;

			Factory *m_factory;

			Swift::EventLoop *m_loop;

			bool m_rawXML;

		friend class User;

		friend class UserRegistration;

		friend class NetworkPluginServer;

	};

}

#include "Swiften/Network/Connection.h"

namespace Transport {

class Component;

class RosterManager;

class ConversationManager;

class UserManager;

class PresenceOracle;

struct UserInfo;

/// Represents online XMPP user.

	public:

		/// Creates new User class.

		/// \param jid XMPP JID associated with this user

		/// \param userInfo UserInfo struct with informations needed to connect

		/// this user to legacy network

		/// \param component Component associated with this user

		User(const Swift::JID &jid, UserInfo &userInfo, Component * component, UserManager *userManager);

		/// Destroyes User.

		virtual ~User();

		/// Returns JID of XMPP user who is currently connected using this User class.

		/// \return full JID

		const Swift::JID &getJID();

		/// Returns full JID which supports particular feature or invalid JID.

		/// \param feature disco#info feature.

		/// \return full JID which supports particular feature or invalid JID.

		std::vector<Swift::JID> getJIDWithFeature(const std::string &feature);

		/// Returns UserInfo struct with informations needed to connect the legacy network.

		/// \return UserInfo struct

		UserInfo &getUserInfo() { return m_userInfo; }

		RosterManager *getRosterManager() { return m_rosterManager; }

		ConversationManager *getConversationManager() { return m_conversationManager; }

		Component *getComponent() { return m_component; }

		UserManager *getUserManager() { return m_userManager; }

		void setData(void *data) { m_data = data; }

		void *getData() { return m_data; }

		/// Handles presence from XMPP JID associated with this user.

		/// \param presence Swift::Presence.

		void handlePresence(Swift::Presence::ref presence, bool forceJoin = false);

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

		void handleDiscoInfo(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info);

		boost::signal<void (const Swift::JID &who, const std::string &room, const std::string &nickname, const std::string &password)> onRoomJoined;

		boost::signal<void (const std::string &room)> onRoomLeft;

		boost::signal<void ()> onDisconnected;

	private:

		void onConnectingTimeout();

		Swift::JID m_jid;

		Component *m_component;