libtransport.git Changeset - b62274f1ddda

Changeset - b62274f1ddda

Parent rev.

Child rev.

[Not reviewed]

0 5 0

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

messages in both directions

5 files changed with 49 insertions and 7 deletions:

backends/libpurple/main.cpp

include/transport/conversation.h

include/transport/networkplugin.h

src/networkplugin.cpp

src/networkpluginserver.cpp

0 comments (0 inline, 0 general)

backends/libpurple/main.cpp

➞

Show inline comments

@@ @@ -86,48 +86,63 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 			const char *protocol = CONFIG_STRING(config, "service.protocol").c_str();
 			PurpleAccount *account = purple_accounts_find(legacyName.c_str(), protocol);
 			if (account) {
 				purple_account_set_enabled(account, "spectrum", FALSE);
 				// Remove conversations.
 				// This has to be called before m_account->ui_data = NULL;, because it uses
 				// ui_data to call SpectrumMessageHandler::purpleConversationDestroyed() callback.
 				GList *iter;
 				for (iter = purple_get_conversations(); iter; ) {
 					PurpleConversation *conv = (PurpleConversation*) iter->data;
 					iter = iter->next;
 					if (purple_conversation_get_account(conv) == account)
 						purple_conversation_destroy(conv);
+				}
 				g_free(account->ui_data);
 				account->ui_data = NULL;
 				m_accounts.erase(account);
+			}
+		}
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message) {
 			const char *protocol = CONFIG_STRING(config, "service.protocol").c_str();
 			PurpleAccount *account = purple_accounts_find(user.c_str(), protocol);
 			std::cout << user << "\n";
 			if (account) {
 				PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, legacyName.c_str(), account);
 				if (!conv) {
 					conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, legacyName.c_str());
+				}
 				gchar *_markup = purple_markup_escape_text(message.c_str(), -1);
 				purple_conv_im_send(PURPLE_CONV_IM(conv), _markup);
 				g_free(_markup);
+			}
+		}
 		std::map<PurpleAccount *, std::string> m_accounts;
 	private:
 		Config *config;
 };
 static std::string getAlias(PurpleBuddy *m_buddy) {
 	std::string alias;
 	if (purple_buddy_get_server_alias(m_buddy))
 		alias = (std::string) purple_buddy_get_server_alias(m_buddy);
 	else
 		alias = (std::string) purple_buddy_get_alias(m_buddy);
 	return alias;
+}
 static std::string getName(PurpleBuddy *m_buddy) {
 	std::string name(purple_buddy_get_name(m_buddy));
 	if (name.empty()) {
 		Log("getName", "Name is EMPTY!");
+	}
 	return name;
+}
 static bool getStatus(PurpleBuddy *m_buddy, Swift::StatusShow &status, std::string &statusMessage) {
 	PurplePresence *pres = purple_buddy_get_presence(m_buddy);
@@ @@ -297,53 +312,48 @@ static void conv_new(PurpleConversation *conv) { @@
 	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;
 	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());
 	char *striped = purple_markup_strip_html(message);
 	std::string msg = striped;
 	g_free(striped);
 	std::string w = who;
 	size_t pos = w.find("/");
 	if (pos != std::string::npos)
 		w.erase((int) pos, w.length() - (int) pos);
 	np->handleMessage(np->m_accounts[account], w, msg);
+}
 static PurpleConversationUiOps conversation_ui_ops =
+{
 	NULL,
 	NULL,
 	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     */

include/transport/conversation.h

➞

Show inline comments

@@ @@ -24,30 +24,34 @@ @@
 #include <algorithm>
 #include "transport/transport.h"
 #include "Swiften/Swiften.h"
 #include "Swiften/Elements/Message.h"
 namespace Transport {
 class ConversationManager;
 class Conversation {
 	public:
 		/// Constructor.
 		Conversation(ConversationManager *conversationManager, const std::string &legacyName);
 		/// Destructor
 		virtual ~Conversation();
 		const std::string &getLegacyName() { return m_legacyName; }
 		void handleMessage(boost::shared_ptr<Swift::Message> &message);
 		virtual void sendMessage(boost::shared_ptr<Swift::Message> &message) = 0;
 		ConversationManager *getConversationManager() {
 			return m_conversationManager;
+		}
 	private:
 		ConversationManager *m_conversationManager;
 		std::string m_legacyName;
 };
+}

include/transport/networkplugin.h

➞

Show inline comments

@@ @@ -29,47 +29,50 @@ @@
 #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;
 		virtual void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message) = 0;
 	private:
 		void connect();
 		void handleLoginPayload(const std::string &payload);
 		void handleLogoutPayload(const std::string &payload);
 		void handleConvMessagePayload(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;
 };
+}

src/networkplugin.cpp

➞

Show inline comments

@@ @@ -125,82 +125,95 @@ void NetworkPlugin::handleDisconnected() { @@
 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::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::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;
+		}
 		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;
 			default:
 				return;
+		}
+	}
+}
 void NetworkPlugin::send(const std::string &data) {
 	std::string header("    ");
 	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";
+	}
 	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);

src/networkpluginserver.cpp

➞

Show inline comments

 	} 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;
 	component->m_factory = new NetworkFactory(this);
 	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();
+	}
 		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";
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	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";
 	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);
 	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::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);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE);
 	send(m_client, 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";
+}
+}

0 comments (0 inline, 0 general)