libtransport.git Changeset - bc585576a9ab

Changeset - bc585576a9ab

Parent rev.

Child rev.

[Not reviewed]

0 8 0

HanzZ - 15 years ago 2011-05-13 23:37:48
hanzz.k@gmail.com

ping/pong, message transfering

8 files changed with 94 insertions and 16 deletions:

backends/libpurple/main.cpp

include/transport/conversationmanager.h

include/transport/networkplugin.h

include/transport/networkpluginserver.h

include/transport/transport.h

src/networkplugin.cpp

src/networkpluginserver.cpp

src/pbnetwork.proto

0 comments (0 inline, 0 general)

backends/libpurple/main.cpp

➞

Show inline comments

@@ @@ -224,203 +224,204 @@ static void buddyListNewNode(PurpleBlistNode *node) { @@
 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy));
+}
 static void buddyStatusChanged(PurpleBuddy *buddy, PurpleStatus *status_, PurpleStatus *old_status) {
 	PurpleAccount *account = purple_buddy_get_account(buddy);
 	Swift::StatusShow status;
 	std::string message;
 	getStatus(buddy, status, message);
 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy));
+}
 static void buddySignedOn(PurpleBuddy *buddy) {
 	PurpleAccount *account = purple_buddy_get_account(buddy);
 	Swift::StatusShow status;
 	std::string message;
 	getStatus(buddy, status, message);
 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy));
+}
 static void buddySignedOff(PurpleBuddy *buddy) {
 	PurpleAccount *account = purple_buddy_get_account(buddy);
 	Swift::StatusShow status;
 	std::string message;
 	getStatus(buddy, status, message);
 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy));
+}
 static void NodeRemoved(PurpleBlistNode *node, void *data) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 	PurpleBuddy *buddy = (PurpleBuddy *) node;
 // 	PurpleAccount *account = purple_buddy_get_account(buddy);
 // 	User *user = (User *) account->ui_data;
 	if (buddy->node.ui_data) {
 		SpectrumBuddy *s_buddy = (SpectrumBuddy *) buddy->node.ui_data;
 		s_buddy->removeBuddy(buddy);
 		buddy->node.ui_data = NULL;
 		if (s_buddy->getBuddiesCount() == 0) {
 			delete s_buddy;
+		}
+	}
+}
 static PurpleBlistUiOps blistUiOps =
+{
 	NULL,
 	buddyListNewNode,
 	NULL,
 	NULL, // buddyListUpdate,
 	NULL, //NodeRemoved,
 	NULL,
 	NULL,
 	NULL, // buddyListAddBuddy,
 	NULL,
 	NULL,
 	NULL, //buddyListSaveNode,
 	NULL, //buddyListRemoveNode,
 	NULL, //buddyListSaveAccount,
 	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) {
 	// Don't forwards our own messages.
 	if (flags & PURPLE_MESSAGE_SEND || flags & PURPLE_MESSAGE_SYSTEM)
 		return;
 	SpectrumConversation *s_conv = (SpectrumConversation *) conv->ui_data;
 	if (!s_conv)
 		return;
 	PurpleAccount *account = purple_conversation_get_account(conv);
 // 	SpectrumConversation *s_conv = (SpectrumConversation *) conv->ui_data;
 // 	if (!s_conv)
 // 		return;
 	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
+// 	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 	char *striped = purple_markup_strip_html(message);
-	msg->setBody(message);
+	std::string msg = stripped;
 	g_free(striped);
-	s_conv->handleMessage(msg);
+	np->handleMessage(np->m_accounts[account], who, 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    */
 	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
 };
 static void connection_report_disconnect(PurpleConnection *gc, PurpleConnectionError reason, const char *text){
 	PurpleAccount *account = purple_connection_get_account(gc);
 	np->handleDisconnected(np->m_accounts[account], purple_account_get_username(account), (int) reason, text ? text : "");
+}
 static PurpleConnectionUiOps conn_ui_ops =
+{
 	NULL,
 	NULL,
 	NULL,//connection_disconnected,
 	NULL,
 	NULL,
 	NULL,
 	NULL,
 	connection_report_disconnect,
 	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 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

include/transport/conversationmanager.h

➞

Show inline comments

 /**
  * 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
  */
 #pragma once
 #include <string>
 #include <algorithm>
 #include <map>
 #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; }
 		Conversation *getConversation(const std::string &name) {
 			return m_convs[name];
+		}
 		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/transport/networkplugin.h

➞

Show inline comments

 /**
  * 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
  */
 #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 "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);
 		void handleMessage(const std::string &user, const std::string &legacyName, 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;
 };
+}

include/transport/networkpluginserver.h

➞

Show inline comments

 /**
  * 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
  */
 #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 NetworkPluginServer {
 	public:
 		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(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 handleConvMessagePayload(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;
 };
+}

include/transport/transport.h

➞

Show inline comments

@@ @@ -71,98 +71,99 @@ namespace Transport { @@
 			~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; }
 			Factory *getFactory() { return m_factory; }
 			/// 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 handleConnected();
 			void handleConnectionError(const Swift::ComponentError &error);
 			void handlePresence(Swift::Presence::ref presence);
 			void handleDataRead(const std::string &data);
 			void handleDataWritten(const std::string &data);
 // 			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;
 			Factory *m_factory;
 		friend class User;
 		friend class UserRegistration;
 		friend class NetworkPluginServer;
 	};
+}

src/networkplugin.cpp

➞

Show inline comments

 /**
  * 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/networkplugin.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 "Swiften/Swiften.h"
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Elements/StreamError.h"
 #include "pbnetwork.pb.h"
 namespace Transport {
 #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::handleMessage(const std::string &user, const std::string &legacyName, const std::string &msg) {
 	pbnetwork::ConversationMessage m;
 	m.set_username(user);
 	m.set_buddyname(legacyName);
 	m.set_message(msg);
 	std::string message;
 	m.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE);
 	send(message);
+}
 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);
 	d.set_message(msg);
 	std::string message;
 	d.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_DISCONNECTED);
 	send(message);
+}
 void NetworkPlugin::handleConnected(bool error) {
 	if (error) {
 		std::cout << "Connecting error\n";
 		m_reconnectTimer->start();
+	}
 	else {
 		std::cout << "Connected\n";
 		m_reconnectTimer->stop();
+	}
+}
 void NetworkPlugin::handleDisconnected() {
 	std::cout << "Disconnected\n";
 	m_reconnectTimer->start();
+}
 void NetworkPlugin::connect() {
 	std::cout << "Trying to connect the server\n";
 	m_conn->connect(Swift::HostAddressPort(Swift::HostAddress(m_host), m_port));
 	m_reconnectTimer->stop();
+}
 void NetworkPlugin::handleLoginPayload(const std::string &data) {
 	pbnetwork::Login payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	handleLoginRequest(payload.user(), payload.legacyname(), payload.password());
+}
 void NetworkPlugin::handleLogoutPayload(const std::string &data) {
 	pbnetwork::Logout payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	handleLogoutRequest(payload.user(), payload.legacyname());
+}
 void NetworkPlugin::handleDataRead(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) {
 			expected_size = (((((m_data[0] << 8) | m_data[1]) << 8) | m_data[2]) << 8) | m_data[3];
 			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;

src/networkpluginserver.cpp

➞

Show inline comments

 /**
  * 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/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 "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) : Conversation(conversationManager, legacyName) {
+		}
 		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) {
 			return new LocalBuddy(rosterManager, -1);
+		}
 	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);
 		exit(1);
 	} 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_pongReceived = false;
 	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_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();
+}
 void NetworkPluginServer::handleNewClientConnection(boost::shared_ptr<Swift::Connection> c) {
 	if (m_client) {
 		c->disconnect();
+	}
 	m_client = c;
 	m_pongReceived = false;
 	c->onDisconnected.connect(boost::bind(&NetworkPluginServer::handleSessionFinished, this, c));
 	c->onDataRead.connect(boost::bind(&NetworkPluginServer::handleDataRead, this, c, _1));
 	sendPing();
 	m_pingTimer->start();
+}
 void NetworkPluginServer::handleSessionFinished(boost::shared_ptr<Swift::Connection> c) {
 	if (c == m_client) {
 		m_client.reset();
+	}
 	m_pingTimer->stop();
 	exec_(CONFIG_STRING(m_config, "service.backend").c_str(), "localhost", "10000", m_config->getConfigFile().c_str());
+}
 void NetworkPluginServer::handleConnectedPayload(const std::string &data) {
 	pbnetwork::Connected payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	std::cout << payload.name() << "\n";
+}
 void NetworkPluginServer::handleDisconnectedPayload(const std::string &data) {
 	pbnetwork::Disconnected payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	User *user = m_userManager->getUser(payload.user());
 	if (!user)
 		return;
 	user->handleDisconnected(payload.message());
+}
 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::handleConvMessagePayload(const std::string &data) {
 	pbnetwork::ConversationMessage 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) {
 		conv = new NetworkConversation(user->getConversationManager(), payload.buddyname());
+	}
 	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 	msg->setBody(payload.message());
 	conv->handleMessage(msg);
+}
 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_CONV_MESSAGE:
 				handleConvMessagePayload(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 {
 		exec_(CONFIG_STRING(m_config, "service.backend").c_str(), "localhost", "10000", m_config->getConfigFile().c_str());
+	}
+}
 void NetworkPluginServer::handleUserCreated(User *user) {
 // 	UserInfo userInfo = user->getUserInfo();
 	user->onReadyToConnect.connect(boost::bind(&NetworkPluginServer::handleUserReadyToConnect, this, user));
+}
 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);
 	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::handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &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";
+}
+}

src/pbnetwork.proto

➞

Show inline comments

 package pbnetwork;
 message Connected {
 	required string user = 1;
 	required string name = 2;
+}
 message Disconnected {
 	required string user = 1;
 	required string name = 2;
 	required int32 error = 3;
 	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 Conversation {
 	required string userName = 1;
 	required string buddyName = 2;
+}
 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;
 		TYPE_CONV_CREATED	= 8;
 		TYPE_CONV_WRITE		= 9;
 		TYPE_CONV_REMOVED	= 10;
 		TYPE_PING			= 11;
 		TYPE_PONG			= 12;
 		TYPE_CONV_MESSAGE	= 8;
 		TYPE_PING			= 9;
 		TYPE_PONG			= 10;
+	}
 	required Type type = 1;
 	optional bytes payload = 2;
+}
+;
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)