libtransport.git Changeset - 1ebe5535c4f3

Changeset - 1ebe5535c4f3

Parent rev.

Child rev.

[Not reviewed]

0 11 2

HanzZ - 14 years ago 2011-05-15 15:18:31
hanzz.k@gmail.com

join IRC room

13 files changed with 326 insertions and 25 deletions:

backends/libircclient-qt/CMakeLists.txt

backends/libircclient-qt/main.cpp

backends/libircclient-qt/session.cpp

153

backends/libircclient-qt/session.h

include/transport/networkplugin.h

include/transport/networkpluginserver.h

include/transport/user.h

src/networkplugin.cpp

src/networkpluginserver.cpp

src/pbnetwork.proto

src/transport.cpp

src/user.cpp

src/usermanager.cpp

0 comments (0 inline, 0 general)

backends/libircclient-qt/CMakeLists.txt

➞

Show inline comments

 cmake_minimum_required(VERSION 2.6)
 FILE(GLOB SRC *.cpp)
 FILE(GLOB HEADERS *.h)
 QT4_WRAP_CPP(SRC ${HEADERS})
 ADD_EXECUTABLE(libircclient-qt_backend ${SRC})
-target_link_libraries(libircclient-qt_backend ${IRC_LIBRARIES} ${QT_LIBRARIES} transport)
+target_link_libraries(libircclient-qt_backend ${IRC_LIBRARY} ${QT_LIBRARIES} transport)

backends/libircclient-qt/main.cpp

➞

Show inline comments

 /*
  * Copyright (C) 2008-2009 J-P Nurmi jpnurmi@gmail.com
+ *
  * This example is free, and not covered by LGPL license. There is no
  * restriction applied to their modification, redistribution, using and so on.
  * You can study them, modify them, use them in your own program - either
  * completely or partially. By using it you may give me some credits in your
  * program, but you don't have to.
  */
 #include "transport/config.h"
 #include "transport/networkplugin.h"
-#include "ircsession.h"
+#include "session.h"
 #include <QtCore>
 #include "Swiften/EventLoop/Qt/QtEventLoop.h"
 using namespace boost::program_options;
 using namespace Transport;
 class IRCNetworkPlugin;
 IRCNetworkPlugin * np = NULL;
 class IRCNetworkPlugin : public NetworkPlugin {
 	public:
 		IRCNetworkPlugin(Config *config, Swift::QtEventLoop *loop, const std::string &host, int port) : NetworkPlugin(loop, host, port) {
 			this->config = config;
+		}
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 			Swift::JID jid(legacyName);
 			MyIrcSession *session = new MyIrcSession();
 			session->setNick(QString::fromStdString(jid.getNode()));
 			session->connectToServer(QString::fromStdString(jid.getDomain()), 6667);
 			std::cout << "CONNECTING IRC NETWORK " << jid.getNode() << " " << jid.getDomain() << "\n";
 			m_sessions[user] = session;
+		}
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 			if (m_sessions[user] == NULL)
 				return;
 			m_sessions[user]->disconnectFromServer();
 			m_sessions[user]->deleteLater();
+		}
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message) {
+		}
 		void handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &password) {
 			std::cout << "JOIN\n";
 			if (m_sessions[user] == NULL)
 				return;
 			m_sessions[user]->addAutoJoinChannel(QString::fromStdString(room));
 			m_sessions[user]->join(QString::fromStdString(room), QString::fromStdString(password));
+		}
 		std::map<std::string, MyIrcSession *> m_sessions;
 	private:
 		Config *config;
 };
 int main (int argc, char* argv[]) {
 	std::string host;
 	int port;
 	boost::program_options::options_description desc("Usage: spectrum [OPTIONS] <config_file.cfg>\nAllowed options");
 	desc.add_options()
 		("host,h", value<std::string>(&host), "host")
 		("port,p", value<int>(&port), "port")
+		;
 	try
+	{
 		boost::program_options::variables_map vm;
 		boost::program_options::store(boost::program_options::parse_command_line(argc, argv, desc), vm);
 		boost::program_options::notify(vm);
+	}
 	catch (std::runtime_error& e)
+	{
 		std::cout << desc << "\n";
 		exit(1);

backends/libircclient-qt/session.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (C) 2008-2009 J-P Nurmi jpnurmi@gmail.com
+ *
  * This example is free, and not covered by LGPL license. There is no
  * restriction applied to their modification, redistribution, using and so on.
  * You can study them, modify them, use them in your own program - either
  * completely or partially. By using it you may give me some credits in your
  * program, but you don't have to.
  */
 #include "session.h"
 #include <QtCore>
 #include <iostream>
 MyIrcSession::MyIrcSession(QObject* parent) : Irc::Session(parent)
+{
+}
 void MyIrcSession::on_connected()
+{
     std::cout << "connected:\n";
+}
 void MyIrcSession::on_disconnected()
+{
     std::cout << "disconnected:\n";
+}
 void MyIrcSession::on_bufferAdded(Irc::Buffer* buffer)
+{
     qDebug() << "buffer added:" << buffer->receiver();
+}
 void MyIrcSession::on_bufferRemoved(Irc::Buffer* buffer)
+{
     qDebug() << "buffer removed:" << buffer->receiver();
+}
 Irc::Buffer* MyIrcSession::createBuffer(const QString& receiver)
+{
     return new MyIrcBuffer(receiver, this);
+}
 MyIrcBuffer::MyIrcBuffer(const QString& receiver, Irc::Session* parent)
     : Irc::Buffer(receiver, parent)
+{
     connect(this, SIGNAL(receiverChanged(QString)), SLOT(on_receiverChanged(QString)));
     connect(this, SIGNAL(joined(QString)), SLOT(on_joined(QString)));
     connect(this, SIGNAL(parted(QString, QString)), SLOT(on_parted(QString, QString)));
     connect(this, SIGNAL(quit(QString, QString)), SLOT(on_quit(QString, QString)));
     connect(this, SIGNAL(nickChanged(QString, QString)), SLOT(on_nickChanged(QString, QString)));
     connect(this, SIGNAL(modeChanged(QString, QString, QString)), SLOT(on_modeChanged(QString, QString, QString)));
     connect(this, SIGNAL(topicChanged(QString, QString)), SLOT(on_topicChanged(QString, QString)));
     connect(this, SIGNAL(invited(QString, QString, QString)), SLOT(on_invited(QString, QString, QString)));
     connect(this, SIGNAL(kicked(QString, QString, QString)), SLOT(on_kicked(QString, QString, QString)));
     connect(this, SIGNAL(messageReceived(QString, QString, Irc::Buffer::MessageFlags)),
                   SLOT(on_messageReceived(QString, QString, Irc::Buffer::MessageFlags)));
     connect(this, SIGNAL(noticeReceived(QString, QString, Irc::Buffer::MessageFlags)),
                   SLOT(on_noticeReceived(QString, QString, Irc::Buffer::MessageFlags)));
     connect(this, SIGNAL(ctcpRequestReceived(QString, QString, Irc::Buffer::MessageFlags)),
                   SLOT(on_ctcpRequestReceived(QString, QString, Irc::Buffer::MessageFlags)));
     connect(this, SIGNAL(ctcpReplyReceived(QString, QString, Irc::Buffer::MessageFlags)),
                   SLOT(on_ctcpReplyReceived(QString, QString, Irc::Buffer::MessageFlags)));
     connect(this, SIGNAL(ctcpActionReceived(QString, QString, Irc::Buffer::MessageFlags)),
                   SLOT(on_ctcpActionReceived(QString, QString, Irc::Buffer::MessageFlags)));
     connect(this, SIGNAL(numericMessageReceived(QString, uint, QStringList)), SLOT(on_numericMessageReceived(QString, uint, QStringList)));
     connect(this, SIGNAL(unknownMessageReceived(QString, QStringList)), SLOT(on_unknownMessageReceived(QString, QStringList)));
+}
 void MyIrcBuffer::on_receiverChanged(const QString& receiver)
+{
     qDebug() << "receiver changed:" << receiver;
+}
 void MyIrcBuffer::on_joined(const QString& origin)
+{
     qDebug() << "joined:" << receiver() << origin;
+}
 void MyIrcBuffer::on_parted(const QString& origin, const QString& message)
+{
     qDebug() << "parted:" << receiver() << origin << message;
+}
 void MyIrcBuffer::on_quit(const QString& origin, const QString& message)
+{
     qDebug() << "quit:" << receiver() << origin << message;
+}
 void MyIrcBuffer::on_nickChanged(const QString& origin, const QString& nick)
+{
     qDebug() << "nick changed:" << receiver() << origin << nick;
+}
 void MyIrcBuffer::on_modeChanged(const QString& origin, const QString& mode, const QString& args)
+{
     qDebug() << "mode changed:" << receiver() << origin << mode << args;
+}
 void MyIrcBuffer::on_topicChanged(const QString& origin, const QString& topic)
+{
     qDebug() << "topic changed:" << receiver() << origin << topic;
+}
 void MyIrcBuffer::on_invited(const QString& origin, const QString& receiver, const QString& channel)
+{
     qDebug() << "invited:" << Irc::Buffer::receiver() << origin << receiver << channel;
+}
 void MyIrcBuffer::on_kicked(const QString& origin, const QString& nick, const QString& message)
+{
     qDebug() << "kicked:" << receiver() << origin << nick << message;
+}
 void MyIrcBuffer::on_messageReceived(const QString& origin, const QString& message, Irc::Buffer::MessageFlags flags)
+{
     qDebug() << "message received:" << receiver() << origin << message
              << (flags & Irc::Buffer::IdentifiedFlag ? "(identified!)" : "(not identified)");
+}
 void MyIrcBuffer::on_noticeReceived(const QString& origin, const QString& notice, Irc::Buffer::MessageFlags flags)
+{
     qDebug() << "notice received:" << receiver() << origin << notice
              << (flags & Irc::Buffer::IdentifiedFlag ? "(identified!)" : "(not identified)");
+}
 void MyIrcBuffer::on_ctcpRequestReceived(const QString& origin, const QString& request, Irc::Buffer::MessageFlags flags)
+{
     qDebug() << "ctcp request received:" << receiver() << origin << request
              << (flags & Irc::Buffer::IdentifiedFlag ? "(identified!)" : "(not identified)");
+}
 void MyIrcBuffer::on_ctcpReplyReceived(const QString& origin, const QString& reply, Irc::Buffer::MessageFlags flags)
+{
     qDebug() << "ctcp reply received:" << receiver() << origin << reply
              << (flags & Irc::Buffer::IdentifiedFlag ? "(identified!)" : "(not identified)");
+}
 void MyIrcBuffer::on_ctcpActionReceived(const QString& origin, const QString& action, Irc::Buffer::MessageFlags flags)
+{
     qDebug() << "ctcp action received:" << receiver() << origin << action
              << (flags & Irc::Buffer::IdentifiedFlag ? "(identified!)" : "(not identified)");
+}
 void MyIrcBuffer::on_numericMessageReceived(const QString& origin, uint code, const QStringList& params)
+{
     qDebug() << "numeric message received:" << receiver() << origin << code << params;
+}
 void MyIrcBuffer::on_unknownMessageReceived(const QString& origin, const QStringList& params)
+{
     qDebug() << "unknown message received:" << receiver() << origin << params;
+}

backends/libircclient-qt/session.h

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright (C) 2008-2009 J-P Nurmi jpnurmi@gmail.com
+ *
  * This example is free, and not covered by LGPL license. There is no
  * restriction applied to their modification, redistribution, using and so on.
  * You can study them, modify them, use them in your own program - either
  * completely or partially. By using it you may give me some credits in your
  * program, but you don't have to.
  */
 #ifndef SESSION_H
 #define SESSION_H
 #include <IrcSession>
 #include <IrcBuffer>
 class MyIrcSession : public Irc::Session
+{
     Q_OBJECT
 public:
     MyIrcSession(QObject* parent = 0);
 protected Q_SLOTS:
     void on_connected();
     void on_disconnected();
     void on_bufferAdded(Irc::Buffer* buffer);
     void on_bufferRemoved(Irc::Buffer* buffer);
 protected:
     virtual Irc::Buffer* createBuffer(const QString& receiver);
 };
 class MyIrcBuffer : public Irc::Buffer
+{
     Q_OBJECT
 public:
     MyIrcBuffer(const QString& receiver, Irc::Session* parent);
 protected Q_SLOTS:
     void on_receiverChanged(const QString& receiver);
     void on_joined(const QString& origin);
     void on_parted(const QString& origin, const QString& message);
     void on_quit(const QString& origin, const QString& message);
     void on_nickChanged(const QString& origin, const QString& nick);
     void on_modeChanged(const QString& origin, const QString& mode, const QString& args);
     void on_topicChanged(const QString& origin, const QString& topic);
     void on_invited(const QString& origin, const QString& receiver, const QString& channel);
     void on_kicked(const QString& origin, const QString& nick, const QString& message);
     void on_messageReceived(const QString& origin, const QString& message, Irc::Buffer::MessageFlags flags);
     void on_noticeReceived(const QString& origin, const QString& notice, Irc::Buffer::MessageFlags flags);
     void on_ctcpRequestReceived(const QString& origin, const QString& request, Irc::Buffer::MessageFlags flags);
     void on_ctcpReplyReceived(const QString& origin, const QString& reply, Irc::Buffer::MessageFlags flags);
     void on_ctcpActionReceived(const QString& origin, const QString& action, Irc::Buffer::MessageFlags flags);
     void on_numericMessageReceived(const QString& origin, uint code, const QStringList& params);
     void on_unknownMessageReceived(const QString& origin, const QStringList& params);
 };
 #endif // SESSION_H

include/transport/networkplugin.h

➞

Show inline comments

@@ @@ -30,49 +30,51 @@ @@
 #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;
 		virtual void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message) = 0;
 		virtual void handleJoinRoomRequest(const std::string &/*user*/, const std::string &/*room*/, const std::string &/*nickname*/, const std::string &/*pasword*/) {}
 	private:
 		void connect();
 		void handleLoginPayload(const std::string &payload);
 		void handleLogoutPayload(const std::string &payload);
 		void handleConvMessagePayload(const std::string &payload);
 		void handleJoinRoomPayload(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

@@ @@ -36,43 +36,44 @@ 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 handleRoomJoined(User *user, const std::string &room, const std::string &nickname, const std::string &password);
 		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/user.h

➞

Show inline comments

@@ @@ -56,44 +56,46 @@ class User { @@
 		UserInfo &getUserInfo() { return m_userInfo; }
 		RosterManager *getRosterManager() { return m_rosterManager; }
 		ConversationManager *getConversationManager() { return m_conversationManager; }
 		Component *getComponent() { return m_component; }
 		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);
 		void handleSubscription(Swift::Presence::ref presence);
 		/// Returns language.
 		/// \return language
 		const char *getLang() { return "en"; }
 		void handleDisconnected(const std::string &error);
 		boost::signal<void ()> onReadyToConnect;
 		boost::signal<void (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;
 		RosterManager *m_rosterManager;
 		UserManager *m_userManager;
 		ConversationManager *m_conversationManager;
 		Swift::EntityCapsManager *m_entityCapsManager;
 		Swift::PresenceOracle *m_presenceOracle;
 		UserInfo m_userInfo;
 		void *m_data;
 		bool m_connected;
 		bool m_readyForConnect;
 		Swift::Timer::ref m_reconnectTimer;
 };
+}

src/networkplugin.cpp

➞

Show inline comments

 	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);
 	std::cout << "SENDING MESSAGE\n";
+// 	std::cout << "SENDING MESSAGE\n";
 	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) {
 		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::handleConvMessagePayload(const std::string &data) {
 	pbnetwork::ConversationMessage payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	handleMessageSendRequest(payload.username(), payload.buddyname(), payload.message());
+}
 void NetworkPlugin::handleJoinRoomPayload(const std::string &data) {
 	pbnetwork::Room payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	handleJoinRoomRequest(payload.username(), payload.room(), payload.nickname(), payload.password());
+}
 void NetworkPlugin::handleDataRead(const Swift::ByteArray &data) {
 	long expected_size = 0;
 	m_data += data.toString();
 	std::cout << "received data; size = " << m_data.size() << "\n";
+// 	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";
+// 			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_LOGIN:
 				handleLoginPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_LOGOUT:
 				handleLogoutPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_PING:
 				sendPong();
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE:
 				handleConvMessagePayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_JOIN_ROOM:
 				handleJoinRoomPayload(wrapper.payload());
 				break;
 			default:
 				return;
+		}
+	}
+}
 void NetworkPlugin::send(const std::string &data) {
 	std::string header("    ");
 	std::cout << data.size() << "\n";
+// 	std::cout << data.size() << "\n";
 	boost::int32_t size = data.size();
 	for (int i = 0; i != 4; ++i) {
 		header.at(i) = static_cast<char>(size >> (8 * (3 - i)));
 		std::cout << std::hex << (int) header.at(i) << "\n";
+// 		std::cout << std::hex << (int) header.at(i) << "\n";
+	}
 	m_conn->write(Swift::ByteArray(header + data));
+}
 void NetworkPlugin::sendPong() {
 	std::string message;
 	pbnetwork::WrapperMessage wrap;
 	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_PONG);
 	wrap.SerializeToString(&message);
 	send(message);
 	std::cout << "SENDING PONG\n";
+// 	std::cout << "SENDING PONG\n";
+}
+}

src/networkpluginserver.cpp

➞

Show inline comments

 	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";
+// 	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;
 	std::cout << "payload...\n";
+// 	std::cout << "payload...\n";
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	std::cout << "payload 2...\n";
+// 	std::cout << "payload 2...\n";
 	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());
 		conv->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, this, _1, _2));
+	}
 	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";
+// 	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";
+// 			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:
+}
 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));
 	user->onRoomJoined.connect(boost::bind(&NetworkPluginServer::handleRoomJoined, this, user, _1, _2, _3));
+}
 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::handleRoomJoined(User *user, const std::string &r, const std::string &nickname, const std::string &password) {
 	UserInfo userInfo = user->getUserInfo();
 	pbnetwork::Room room;
 	room.set_username(user->getJID().toBare());
 	room.set_nickname(nickname);
 	room.set_room(r);
 	room.set_password(password);
 	std::string message;
 	room.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_JOIN_ROOM);
 	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> &msg) {
 	pbnetwork::ConversationMessage m;
 	m.set_username(conv->getConversationManager()->getUser()->getUserInfo().uin);
 	m.set_buddyname(conv->getLegacyName());
 	m.set_message(msg->getBody());
 	std::string message;
 	m.SerializeToString(&message);

src/pbnetwork.proto

➞

Show inline comments

@@ @@ -18,40 +18,58 @@ message Login { @@
 	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 Room {
 	required string userName = 1;
 	required string nickname = 2;
 	required string room = 3;
 	optional string password = 4;
+}
 message Participant {
 	required string userName = 1;
 	required string room = 2;
 	required string nickname = 3;
 	required int32 flag = 4;
+}
 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_MESSAGE	= 8;
 		TYPE_PING			= 9;
 		TYPE_PONG			= 10;
 		TYPE_CONNECTED 				= 1;
 		TYPE_DISCONNECTED 			= 2;
 		TYPE_LOGIN 					= 3;
 		TYPE_LOGOUT 				= 4;
 		TYPE_BUDDY_CHANGED			= 6;
 		TYPE_BUDDY_REMOVED			= 7;
 		TYPE_CONV_MESSAGE			= 8;
 		TYPE_PING					= 9;
 		TYPE_PONG					= 10;
 		TYPE_JOIN_ROOM				= 11;
 		TYPE_PART_ROOM				= 12;
 		TYPE_PARTICIPANT_CHANGED	= 13;
 		TYPE_PARTICIPANT_LEFT		= 14;
+	}
 	required Type type = 1;
 	optional bytes payload = 2;
+}
+;
@@ \ No newline at end of file @@

src/transport.cpp

➞

Show inline comments

@@ @@ -148,50 +148,49 @@ void Component::connect() { @@
+}
 void Component::handleConnected() {
 	onConnected();
 	m_reconnectCount = 0;
+}
 void Component::handleConnectionError(const ComponentError &error) {
 	onConnectionError(error);
 // 	if (m_reconnectCount == 2)
 // 		Component::instance()->userManager()->removeAllUsers();
 	m_reconnectTimer->start();
+}
 void Component::handleDataRead(const std::string &data) {
 	onXMLIn(data);
+}
 void Component::handleDataWritten(const std::string &data) {
 	onXMLOut(data);
+}
 void Component::handlePresence(Swift::Presence::ref presence) {
 	bool isMUC = presence->getPayload<MUCPayload>() != NULL;
 	bool isMUC = presence->getPayload<MUCPayload>() != NULL || *presence->getTo().getNode().c_str() == '#';
 	// filter out login/logout presence spam
 	if (!presence->getTo().getNode().empty() && isMUC == false)
 		return;
 	// filter out bad presences
 	if (!presence->getFrom().isValid()) {
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo(presence->getFrom());
 		response->setFrom(presence->getTo());
 		response->setType(Swift::Presence::Error);
 		response->addPayload(boost::shared_ptr<Payload>(new ErrorPayload(ErrorPayload::JIDMalformed, ErrorPayload::Modify)));
 		m_component->sendPresence(response);
 		return;
+	}
 	// check if we have this client's capabilities and ask for them
 	bool haveFeatures = false;
 	if (presence->getType() != Swift::Presence::Unavailable) {
 		boost::shared_ptr<CapsInfo> capsInfo = presence->getPayload<CapsInfo>();
 		if (capsInfo && capsInfo->getHash() == "sha-1") {
 			haveFeatures = m_entityCapsManager->getCaps(presence->getFrom()) != DiscoInfo::ref();
 			std::cout << "has capsInfo " << haveFeatures << "\n";

src/user.cpp

➞

Show inline comments

@@ @@ -6,48 +6,49 @@ @@
  * 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/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 "Swiften/Elements/MUCPayload.h"
 namespace Transport {
 User::User(const Swift::JID &jid, UserInfo &userInfo, Component *component, UserManager *userManager) {
 	m_jid = jid;
 	m_component = component;
 	m_presenceOracle = component->m_presenceOracle;
 	m_entityCapsManager = component->m_entityCapsManager;
 	m_userManager = userManager;
 	m_userInfo = userInfo;
 	m_connected = false;
 	m_readyForConnect = false;
 	m_reconnectTimer = m_component->getFactories()->getTimerFactory()->createTimer(10000);
 	m_reconnectTimer->onTick.connect(boost::bind(&User::onConnectingTimeout, this));
 	m_rosterManager = new RosterManager(this, m_component);
 	m_conversationManager = new ConversationManager(this, m_component);
+}
 User::~User(){
 	m_reconnectTimer->stop();
 	delete m_rosterManager;
@@ @@ -60,48 +61,55 @@ const Swift::JID &User::getJID() { @@
 void User::handlePresence(Swift::Presence::ref presence) {
 	Swift::Presence::ref highest = m_presenceOracle->getHighestPriorityPresence(m_jid.toBare());
 	if (!m_connected) {
 		// we are not connected to legacy network, so we should do it when disco#info arrive :)
 		if (m_readyForConnect == false) {
 			// Forward status message to legacy network, but only if it's sent from active resource
 // 					if (m_activeResource == presence->getFrom().getResource().getUTF8String()) {
 // 						forwardStatus(presenceShow, stanzaStatus);
 // 					}
 			boost::shared_ptr<Swift::CapsInfo> capsInfo = presence->getPayload<Swift::CapsInfo>();
 			if (capsInfo && capsInfo->getHash() == "sha-1") {
 				if (m_entityCapsManager->getCaps(presence->getFrom()) != Swift::DiscoInfo::ref()) {
 					m_readyForConnect = true;
 					onReadyToConnect();
+				}
+			}
 			else {
 				m_reconnectTimer->start();
+			}
+		}
+	}
 	std::cout << "HANDLE PRESENCE\n";
 	bool isMUC = presence->getPayload<Swift::MUCPayload>() != NULL || *presence->getTo().getNode().c_str() == '#';
 	if (isMUC) {
 		std::cout << "AAAAAAAAA\n";
 		onRoomJoined(presence->getTo().getNode(), presence->getTo().getResource(), "");
 		return;
+	}
 	if (highest) {
 		highest->setTo(presence->getFrom().toBare());
 		highest->setFrom(m_component->getJID());
 		m_component->getStanzaChannel()->sendPresence(highest);
+	}
 	else {
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo(m_jid.toBare());
 		response->setFrom(m_component->getJID());
 		response->setType(Swift::Presence::Unavailable);
 		m_component->getStanzaChannel()->sendPresence(response);
+	}
+}
 void User::handleSubscription(Swift::Presence::ref presence) {
 	m_rosterManager->handleSubscription(presence);
+}
 void User::onConnectingTimeout() {
 	if (m_connected || m_readyForConnect)
 		return;
 	m_reconnectTimer->stop();

src/usermanager.cpp

➞

Show inline comments

 			return;
+		}
 		// TODO: isVIP
 // // 			bool isVip = res.vip;
 // // 			std::list<std::string> const &x = CONFIG().allowedServers;
 // // 			if (CONFIG().onlyForVIP && !isVip && std::find(x.begin(), x.end(), presence->getFrom().getDomain().getUTF8String()) == x.end()) {
 // // 				Log(presence->getFrom().toString().getUTF8String(), "This user is not VIP, can't login...");
 // // 				return;
 // // 			}
 // //
 // //
 				user = new User(presence->getFrom(), res, m_component, this);
 				user->getRosterManager()->setStorageBackend(m_storageBackend);
 				// TODO: handle features somehow
 // // 			user->setFeatures(isVip ? CONFIG().VIPFeatures : CONFIG().transportFeatures);
 // // // 				if (c != NULL)
 // // // 					if (Transport::instance()->hasClientCapabilities(c->findAttribute("ver")))
 // // // 						user->setResource(stanza.from().resource(), stanza.priority(), Transport::instance()->getCapabilities(c->findAttribute("ver")));
 // // //
 			addUser(user);
+	}
 	user->handlePresence(presence);
 	bool isMUC = presence->getPayload<Swift::MUCPayload>() != NULL || *presence->getTo().getNode().c_str() == '#';
 	if (isMUC)
 		return;
 	if (presence->getType() == Swift::Presence::Unavailable) {
 		if (user) {
 			Swift::Presence::ref highest = m_component->getPresenceOracle()->getHighestPriorityPresence(presence->getFrom().toBare());
 			// There's no presence for this user, so disconnect
 			if (!highest || (highest && highest->getType() == Swift::Presence::Unavailable)) {
 				removeUser(user);
+			}
+		}
 		// TODO: HANDLE MUC SOMEHOW
 // 		else if (user && Transport::instance()->protocol()->tempAccountsAllowed() && !((User *) user)->hasOpenedMUC()) {
 // 			Transport::instance()->userManager()->removeUser(user);
 // 		}
+	}
+}
 void UserManager::handleMessageReceived(Swift::Message::ref message) {
 	User *user = getUser(message->getFrom().toBare().toString());
 	if (!user ){
 		return;
+	}
 	user->getConversationManager()->handleMessageReceived(message);
+}

0 comments (0 inline, 0 general)