libtransport.git Changeset - a74d8f27a772

Changeset - a74d8f27a772

Parent rev.

Child rev.

[Not reviewed]

Merge

1 19 5

Jan Kaluza - 14 years ago 2011-06-07 15:32:22
hanzz.k@gmail.com

Merge branch 'master' of github.com:hanzz/libtransport

19 files changed with 159 insertions and 106 deletions:

backends/libircclient-qt/session.cpp

backends/libpurple/main.cpp

examples/server_connect/main.cpp

include/transport/buddy.h

include/transport/networkplugin.h

include/transport/networkpluginserver.h

include/transport/rosterresponder.h

include/transport/sqlite3backend.h

include/transport/transport.h

include/transport/usermanager.h

src/buddy.cpp

src/networkplugin.cpp

src/networkpluginserver.cpp

src/rostermanager.cpp

src/rosterresponder.cpp

src/rosterstorage.cpp

src/sqlite3backend.cpp

src/transport.cpp

src/usermanager.cpp

0 comments (0 inline, 0 general)

backends/libircclient-qt/session.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 "session.h"
 #include <QtCore>
 #include <iostream>
 #include "Swiften/Elements/StatusShow.h"
 MyIrcSession::MyIrcSession(const std::string &user, NetworkPlugin *np, QObject* parent) : Irc::Session(parent)
+{
 	this->np = np;
 	this->user = user;
+}
 void MyIrcSession::on_connected()
+{
     std::cout << "connected:\n";
 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, user, np, this);
+}
 MyIrcBuffer::MyIrcBuffer(const QString& receiver, const std::string &user, NetworkPlugin *np, Irc::Session* parent)
     : Irc::Buffer(receiver, parent)
              << (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)
+{
 	switch (code) {
 		case 251:
 			np->handleConnected(user);
 			break;
 		case 332:
 			m_topicData = params.value(2).toStdString();
 			break;
 		case 333:
 			np->handleSubject(user, params.value(1).toStdString(), m_topicData, params.value(2).toStdString());
 			break;
 		case 353:
 			QString channel = params.value(2);
 			QStringList members = params.value(3).split(" ");
 			for (int i = 0; i < members.size(); i++) {
 				int flags = 0;
 				std::string nickname = members.at(i).toStdString();
 				flags = correctNickname(nickname);
 				p->m_modes[channel.toStdString() + nickname] = flags;
 				std::cout << channel.toStdString() + nickname << " " << flags << "\n";
 				np->handleParticipantChanged(user, nickname, channel.toStdString(), flags, Swift::StatusShow::Online);
+			}
 			break;
+	}
     qDebug() << "numeric message received:" << receiver() << origin << code << params;
+}
 void MyIrcBuffer::on_unknownMessageReceived(const QString& origin, const QStringList& params)

backends/libpurple/main.cpp

➞

Show inline comments

@@ @@ -217,90 +217,102 @@ static std::string getIconHash(PurpleBuddy *m_buddy) { @@
+	}
 	return "";
+}
 static std::vector<std::string> getGroups(PurpleBuddy *m_buddy) {
 	std::vector<std::string> groups;
 	groups.push_back(purple_group_get_name(purple_buddy_get_group(m_buddy)) ? std::string(purple_group_get_name(purple_buddy_get_group(m_buddy))) : std::string("Buddies"));
 	return groups;
+}
 static void buddyListNewNode(PurpleBlistNode *node) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 	PurpleBuddy *buddy = (PurpleBuddy *) node;
 	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 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 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 buddySignedOff(PurpleBuddy *buddy) {
 static void buddyListUpdate(PurpleBuddyList *list, PurpleBlistNode *node) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 	PurpleBuddy *buddy = (PurpleBuddy *) node;
 	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;
+}
 static PurpleBlistUiOps blistUiOps =
+{
 	NULL,
 	buddyListNewNode,
 	NULL,
-	NULL, // buddyListUpdate,
 	buddyListUpdate,
 	NULL, //NodeRemoved,
 	NULL,
 	NULL,
 	NULL, // buddyListAddBuddy,
 	NULL,
 	NULL,
 	NULL, //buddyListSaveNode,
 	NULL, //buddyListRemoveNode,
 	NULL, //buddyListSaveAccount,
 	NULL
 };
 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);
 	char *striped = purple_markup_strip_html(message);
 	std::string msg = striped;
 	g_free(striped);
 	std::string w = who;
 	size_t pos = w.find("/");
 			else if (label=="Nickname"){
 				nickname = purple_notify_user_info_entry_get_value(vcardEntry);
+			}
 			else if (label=="Full Name"){
 				fullName = purple_notify_user_info_entry_get_value(vcardEntry);
+			}
+		}
 		vcardEntries = vcardEntries->next;
+	}
 	if ((!firstName.empty() || !lastName.empty()) && fullName.empty())
 		fullName = firstName + " " + lastName;
 	PurpleBuddy *buddy = purple_find_buddy(purple_connection_get_account(gc), who);
 	if (buddy) {
 		gsize len;
 		PurpleBuddyIcon *icon = NULL;
 		icon = purple_buddy_icons_find(purple_connection_get_account(gc), name.c_str());
 		if (icon) {
 			const gchar * data = (gchar*)purple_buddy_icon_get_data(icon, &len);
 			// Sometimes libpurple returns really broken pointers here
 			// They weren't able to do anything with that and I don't know what to do too,
 			// so it's better to hack through it by not trying to forward really broken things...
 			if (len < 300000 && data) {
-				photo = Swift::ByteArray(data, len);
+				photo = Swift::createByteArray(data, len);
 // 				const gchar *ext = (gchar*)purple_buddy_icon_get_extension(icon);
 // 				if (ext) {
 // 					std::string extension(ext);
 // 					if (extension != "icon") {
 // 						if (extension == "jpg") {
 // 							extension = "jpeg";
 // 						}
 // 						photo->addChild( new Tag("TYPE", "image/" + extension) );
 // 					}
 // 				}
+			}
+		}
+	}
-	np->handleVCard(np->m_accounts[account], np->m_vcards[np->m_accounts[account] + name], name, fullName, nickname, photo.toString());
+	np->handleVCard(np->m_accounts[account], np->m_vcards[np->m_accounts[account] + name], name, fullName, nickname, Swift::byteArrayToString(photo));
 	np->m_vcards.erase(np->m_accounts[account] + name);
 	return NULL;
+}
 static PurpleNotifyUiOps notifyUiOps =
+{
 		NULL,
 		NULL,
 		NULL,
 		NULL,
 		NULL,
 		NULL,
 		notify_user_info,
 		NULL,
 		NULL,
 		NULL,
 		NULL,
 		NULL,
 		NULL
 };
 static void transport_core_ui_init(void)
+{
@@ @@ -522,51 +534,51 @@ static bool initPurple(Config &cfg) { @@
 		/* Good default preferences */
 		/* The combination of these two settings mean that libpurple will never
 		 * (of its own accord) set all the user accounts idle.
 		 */
 		purple_prefs_set_bool("/purple/away/away_when_idle", false);
 		/*
 		 * This must be set to something not "none" for idle reporting to work
 		 * for, e.g., the OSCAR prpl. We don't implement the UI ops, so this is
 		 * okay for now.
 		 */
 		purple_prefs_set_string("/purple/away/idle_reporting", "system");
 		/* Disable all logging */
 		purple_prefs_set_bool("/purple/logging/log_ims", false);
 		purple_prefs_set_bool("/purple/logging/log_chats", false);
 		purple_prefs_set_bool("/purple/logging/log_system", false);
 // 		purple_signal_connect(purple_conversations_get_handle(), "received-im-msg", &conversation_handle, PURPLE_CALLBACK(newMessageReceived), NULL);
 // 		purple_signal_connect(purple_conversations_get_handle(), "buddy-typing", &conversation_handle, PURPLE_CALLBACK(buddyTyping), NULL);
 // 		purple_signal_connect(purple_conversations_get_handle(), "buddy-typed", &conversation_handle, PURPLE_CALLBACK(buddyTyped), NULL);
 // 		purple_signal_connect(purple_conversations_get_handle(), "buddy-typing-stopped", &conversation_handle, PURPLE_CALLBACK(buddyTypingStopped), NULL);
 		purple_signal_connect(purple_connections_get_handle(), "signed-on", &blist_handle,PURPLE_CALLBACK(signed_on), NULL);
 // 		purple_signal_connect(purple_blist_get_handle(), "buddy-removed", &blist_handle,PURPLE_CALLBACK(buddyRemoved), NULL);
 		purple_signal_connect(purple_blist_get_handle(), "buddy-signed-on", &blist_handle,PURPLE_CALLBACK(buddySignedOn), NULL);
 		purple_signal_connect(purple_blist_get_handle(), "buddy-signed-off", &blist_handle,PURPLE_CALLBACK(buddySignedOff), NULL);
 		purple_signal_connect(purple_blist_get_handle(), "buddy-status-changed", &blist_handle,PURPLE_CALLBACK(buddyStatusChanged), NULL);
 // 		purple_signal_connect(purple_blist_get_handle(), "buddy-signed-on", &blist_handle,PURPLE_CALLBACK(buddySignedOn), NULL);
 // 		purple_signal_connect(purple_blist_get_handle(), "buddy-signed-off", &blist_handle,PURPLE_CALLBACK(buddySignedOff), NULL);
 // 		purple_signal_connect(purple_blist_get_handle(), "buddy-status-changed", &blist_handle,PURPLE_CALLBACK(buddyStatusChanged), NULL);
 		purple_signal_connect(purple_blist_get_handle(), "blist-node-removed", &blist_handle,PURPLE_CALLBACK(NodeRemoved), NULL);
 // 		purple_signal_connect(purple_conversations_get_handle(), "chat-topic-changed", &conversation_handle, PURPLE_CALLBACK(conv_chat_topic_changed), NULL);
 //
 // 		purple_commands_init();
+	}
 	return ret;
+}
 int main(int argc, char **argv) {
 	GError *error = NULL;
 	GOptionContext *context;
 	context = g_option_context_new("config_file_name or profile name");
 	g_option_context_add_main_entries(context, options_entries, "");
 	if (!g_option_context_parse (context, &argc, &argv, &error)) {
 		std::cout << "option parsing failed: " << error->message << "\n";
 		return -1;
+	}
 	if (ver) {
 // 		std::cout << VERSION << "\n";
 		std::cout << "verze\n";
 		g_option_context_free(context);

examples/server_connect/main.cpp

➞

Show inline comments

 #include "transport/config.h"
 #include "transport/transport.h"
 #include "transport/logger.h"
 #include "Swiften/EventLoop/SimpleEventLoop.h"
 #include "Swiften/Network/BoostTimerFactory.h"
 #include "Swiften/Network/BoostIOServiceThread.h"
 #include "Swiften/Network/BoostNetworkFactories.h"
 #include "Swiften/Server/UserRegistry.h"
 #include "Swiften/Server/Server.h"
 #include "Swiften/Swiften.h"
 using namespace Transport;
 class DummyUserRegistry : public Swift::UserRegistry {
 	public:
 		DummyUserRegistry() {}
 		virtual bool isValidUserPassword(const Swift::JID&, const std::string&) const {
 		virtual bool isValidUserPassword(const Swift::JID&user, const Swift::SafeByteArray&) const {
 			onPasswordValid(user.toString());
 			return true;
+		}
 };
 int main(void)
+{
 	Swift::logging = true;
 	Swift::SimpleEventLoop loop;
 	Swift::BoostNetworkFactories *m_factories = new Swift::BoostNetworkFactories(&loop);
 	DummyUserRegistry dummyregistry;
 	Swift::Server server(&loop, m_factories, &dummyregistry, "localhost", 5222);
 	server.start();
 	loop.run();
+}

include/transport/buddy.h

➞

Show inline comments

@@ @@ -86,48 +86,50 @@ class Buddy { @@
 		/// Returns current subscription
 		/// \return subscription "to", "from", "both", "ask"
 		const std::string &getSubscription();
 		/// Sets this buddy's flags.
 		/// \param flags flags
 		void setFlags(BuddyFlag flags);
 		/// Returns this buddy's flags.
 		/// \param flags flags
 		BuddyFlag getFlags();
 		/// Returns RosterManager associated with this buddy
 		/// \return rosterManager
 		RosterManager *getRosterManager() { return m_rosterManager; }
 		/// Returns legacy network username which does not contain unsafe characters,
 		/// so it can be used in JIDs.
 		std::string getSafeName();
 		void buddyChanged();
 		void handleVCardReceived(const std::string &id, const Swift::JID &to, Swift::VCard::ref vcard);
 		boost::signal<void ()> onBuddyChanged;
 		virtual void getVCard(const std::string &id, const Swift::JID &to) = 0;
 		/// Returns legacy network username of this buddy. (for example UIN for ICQ,
 		/// JID for Jabber, ...).
 		/// \return legacy network username
 		virtual std::string getName() = 0;
 		/// Returns alias (nickname) of this buddy.
 		/// \return alias (nickname)
 		virtual std::string getAlias() = 0;
 		/// Returns list of groups this buddy is in.
 		/// \return groups
 		virtual std::vector<std::string> getGroups() = 0;
 		/// Returns current legacy network status and statuMessage of this buddy.
 		/// \param status current status/show is stored here
 		/// \param statusMessage current status message is stored here
 		/// \return true if status was stored successfully
 		virtual bool getStatus(Swift::StatusShow &status, std::string &statusMessage) = 0;
 		/// Returns SHA-1 hash of buddy icon (avatar) or empty string if there is no avatar
 		/// for this buddy.
 		/// \return avatar hash or empty string.

include/transport/networkplugin.h

➞

Show inline comments

@@ @@ -53,44 +53,44 @@ class NetworkPlugin { @@
 		void handleMessage(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &nickname = "");
 		void handleSubject(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &nickname = "");
 		void handleRoomChanged(const std::string &user, const std::string &room, const std::string &nickname);
 		void handleVCard(const std::string &user, unsigned int id, const std::string &legacyName, const std::string &fullName, const std::string &nickname, const std::string &photo);
 		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 handleVCardRequest(const std::string &/*user*/, const std::string &/*legacyName*/, unsigned int /*id*/) {}
 		virtual void handleJoinRoomRequest(const std::string &/*user*/, const std::string &/*room*/, const std::string &/*nickname*/, const std::string &/*pasword*/) {}
 		virtual void handleLeaveRoomRequest(const std::string &/*user*/, const std::string &/*room*/) {}
 	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 handleLeaveRoomPayload(const std::string &payload);
 		void handleVCardPayload(const std::string &payload);
-		void handleDataRead(const Swift::ByteArray&);
+		void handleDataRead(const Swift::SafeByteArray&);
 		void _handleConnected(bool error);
 		void handleDisconnected();
 		void send(const std::string &data);
 		void sendPong();
 		void pingTimeout();
-		std::string m_data;
+		Swift::SafeByteArray 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_pingTimer;
 		bool m_pingReceived;
 };
+}

include/transport/networkpluginserver.h

➞

Show inline comments

@@ @@ -17,77 +17,79 @@ @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <time.h>
 #include "Swiften/Swiften.h"
 #include "Swiften/Presence/PresenceOracle.h"
 #include "Swiften/Disco/EntityCapsManager.h"
 #include "Swiften/Network/ConnectionServer.h"
 #include "Swiften/Network/Connection.h"
 #include "storagebackend.h"
 namespace Transport {
 class UserManager;
 class User;
 class Component;
 class Buddy;
 class LocalBuddy;
 class Config;
 class NetworkConversation;
 class VCardResponder;
 class RosterResponder;
 class NetworkPluginServer {
 	public:
 		struct Client {
 			bool pongReceived;
 			std::list<User *> users;
-			std::string data;
+			Swift::SafeByteArray data;
 			boost::shared_ptr<Swift::Connection> connection;
 		};
 		NetworkPluginServer(Component *component, Config *config, UserManager *userManager);
 		virtual ~NetworkPluginServer();
 		void handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &message);
 	private:
 		void handleNewClientConnection(boost::shared_ptr<Swift::Connection> c);
 		void handleSessionFinished(Client *c);
-		void handleDataRead(Client *c, const Swift::ByteArray&);
+		void handleDataRead(Client *c, const Swift::SafeByteArray&);
 		void handleConnectedPayload(const std::string &payload);
 		void handleDisconnectedPayload(const std::string &payload);
 		void handleBuddyChangedPayload(const std::string &payload);
 		void handleConvMessagePayload(const std::string &payload, bool subject = false);
 		void handleParticipantChangedPayload(const std::string &payload);
 		void handleRoomChangedPayload(const std::string &payload);
 		void handleVCardPayload(const std::string &payload);
 		void handleUserCreated(User *user);
 		void handleRoomJoined(User *user, const std::string &room, const std::string &nickname, const std::string &password);
 		void handleRoomLeft(User *user, const std::string &room);
 		void handleUserReadyToConnect(User *user);
 		void handleUserDestroyed(User *user);
 		void handleVCardRequired(User *user, const std::string &name, unsigned int id);
 		void send(boost::shared_ptr<Swift::Connection> &, const std::string &data);
 		void pingTimeout();
 		void sendPing(Client *c);
 		Client *getFreeClient();
 		UserManager *m_userManager;
 		VCardResponder *m_vcardResponder;
 		RosterResponder *m_rosterResponder;
 		Config *m_config;
 		boost::shared_ptr<Swift::ConnectionServer> m_server;
 		std::list<Client *>  m_clients;
 		Swift::Timer::ref m_pingTimer;
 		Component *m_component;
 };
+}

include/transport/rosterresponder.h

➞

Show inline comments

@@ file renamed from src/rosterresponder.h to include/transport/rosterresponder.h @@
@@ @@ -6,40 +6,38 @@ @@
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <vector>
 #include "Swiften/Swiften.h"
 #include "Swiften/Queries/Responder.h"
 #include "Swiften/Elements/RosterPayload.h"
 namespace Transport {
 class StorageBackend;
 class UserManager;
 class RosterResponder : public Swift::Responder<Swift::RosterPayload> {
 	public:
-		RosterResponder(Swift::IQRouter *router, StorageBackend *storageBackend, UserManager *userManager);
 		RosterResponder(Swift::IQRouter *router, UserManager *userManager);
 		~RosterResponder();
 	private:
 		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload);
 		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload);
 		StorageBackend *m_storageBackend;
 		UserManager *m_userManager;
 };
+}
@@ \ No newline at end of file @@

include/transport/sqlite3backend.h

➞

Show inline comments

@@ @@ -88,29 +88,30 @@ class SQLite3Backend : public StorageBackend @@
 		void updateUserSetting(long userId, const std::string &variable, const std::string &value);
 		void beginTransaction();
 		void commitTransaction();
 	private:
 		bool exec(const std::string &query);
 		sqlite3 *m_db;
 		Config *m_config;
 		std::string m_prefix;
 		// statements
 		sqlite3_stmt *m_setUser;
 		sqlite3_stmt *m_getUser;
 		sqlite3_stmt *m_getUserSetting;
 		sqlite3_stmt *m_setUserSetting;
 		sqlite3_stmt *m_updateUserSetting;
 		sqlite3_stmt *m_removeUser;
 		sqlite3_stmt *m_removeUserBuddies;
 		sqlite3_stmt *m_removeUserSettings;
 		sqlite3_stmt *m_removeUserBuddiesSettings;
 		sqlite3_stmt *m_addBuddy;
 		sqlite3_stmt *m_updateBuddy;
 		sqlite3_stmt *m_updateBuddySetting;
 		sqlite3_stmt *m_getBuddies;
 		sqlite3_stmt *m_getBuddiesSettings;
 };
+}

include/transport/transport.h

➞

Show inline comments

@@ @@ -112,50 +112,50 @@ namespace Transport { @@
 			/// 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 handleDataRead(const Swift::SafeByteArray &data);
 			void handleDataWritten(const Swift::SafeByteArray &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;
 			int m_reconnectCount;
 			Config* m_config;
 			std::string m_protocol;
 			Swift::JID m_jid;
 			Factory *m_factory;

include/transport/usermanager.h

➞

Show inline comments

@@ @@ -62,29 +62,28 @@ class UserManager { @@
 		/// Called when new User class is created.
 		/// \param user newly created User class
 		boost::signal<void (User *user)> onUserCreated;
 		/// Called when User class is going to be removed
 		/// \param user removed User class
 		boost::signal<void (User *user)> onUserDestroyed;
 	private:
 		void handlePresence(Swift::Presence::ref presence);
 		void handleMessageReceived(Swift::Message::ref message);
 		void handleGeneralPresenceReceived(Swift::Presence::ref presence);
 		void handleProbePresence(Swift::Presence::ref presence);
 		void handleSubscription(Swift::Presence::ref presence);
 // 		void handleDiscoInfoResponse(boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid);
 		void addUser(User *user);
 		long m_onlineBuddies;
 		User *m_cachedUser;
 		std::map<std::string, User *> m_users;
 		Component *m_component;
 		StorageBackend *m_storageBackend;
 		StorageResponder *m_storageResponder;
 		RosterResponder *m_rosterResponder;
 		friend class RosterResponder;
 };
+}

src/buddy.cpp

➞

Show inline comments

 	std::string alias = getAlias();
 	std::string name = getSafeName();
 	Swift::StatusShow s;
 	std::string statusMessage;
 	if (!getStatus(s, statusMessage))
 		return Swift::Presence::ref();
 	Swift::Presence::ref presence = Swift::Presence::create();
  	presence->setFrom(m_jid);
 	presence->setTo(m_rosterManager->getUser()->getJID().toBare());
 	presence->setType(Swift::Presence::Available);
 	if (!statusMessage.empty())
 		presence->setStatus(statusMessage);
 	if (s.getType() == Swift::StatusShow::None)
 		presence->setType(Swift::Presence::Unavailable);
 	presence->setShow(s.getType());
 	if (presence->getType() != Swift::Presence::Unavailable) {
 		// caps
 // 		presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::CapsInfo (CONFIG().caps)));
 		if (features & 0/*TRANSPORT_FEATURE_AVATARS*/) {
+// 		if (features & 0/*TRANSPORT_FEATURE_AVATARS*/) {
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::VCardUpdate (getIconHash())));
+		}
+// 		}
+	}
 	if (only_new) {
 		if (m_lastPresence)
 			m_lastPresence->setTo(Swift::JID(""));
 		if (m_lastPresence == presence) {
 			return Swift::Presence::ref();
+		}
 		m_lastPresence = presence;
+	}
 	return presence;
+}
 std::string Buddy::getSafeName() {
 	if (m_jid.isValid()) {
 		return m_jid.getNode();
+	}
 	std::string name = getName();
 // 	Transport::instance()->protocol()->prepareUsername(name, purple_buddy_get_account(m_buddy));
 	if (getFlags() & BUDDY_JID_ESCAPING) {
 		name = Swift::JID::getEscapedNode(name);
+	}
 	else {
 		if (name.find_last_of("@") != std::string::npos) {
 			name.replace(name.find_last_of("@"), 1, "%");
+		}
+	}
 // 	if (name.empty()) {
 // 		Log("SpectrumBuddy::getSafeName", "Name is EMPTY! Previous was " << getName() << ".");
 // 	}
 	return name;
+}
 void Buddy::buddyChanged() {
 	Swift::Presence::ref presence = generatePresenceStanza(255);
 	if (presence) {
 		m_rosterManager->getUser()->getComponent()->getStanzaChannel()->sendPresence(presence);
+	}
 	onBuddyChanged();
+}
 void Buddy::handleVCardReceived(const std::string &id, const Swift::JID &to, Swift::VCard::ref vcard) {
 	boost::shared_ptr<Swift::GenericRequest<Swift::VCard> > request(new Swift::GenericRequest<Swift::VCard>(Swift::IQ::Result, m_rosterManager->getUser()->getJID(), vcard, m_rosterManager->getUser()->getComponent()->getIQRouter()));
 	request->send();
+}
 std::string Buddy::JIDToLegacyName(const Swift::JID &jid) {
 	std::string name;
 	if (jid.getUnescapedNode() == jid.getNode()) {
 		name = jid.getNode();
 		if (name.find_last_of("%") != std::string::npos) {
 			name.replace(name.find_last_of("%"), 1, "@");
+		}
+	}
 	else {
 		name = jid.getUnescapedNode();
+	}
 	return name;
+}
+}

src/networkplugin.cpp

➞

Show inline comments

 	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::handleConnected(const std::string &user) {
 	std::cout << "LOGIN SENT\n";
 	pbnetwork::Connected d;
 	d.set_user(user);
 	std::string message;
 	d.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONNECTED);
 	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);
 	handleJoinRoomRequest(payload.username(), payload.room(), payload.nickname(), payload.password());
+}
 void NetworkPlugin::handleLeaveRoomPayload(const std::string &data) {
 	pbnetwork::Room payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	handleLeaveRoomRequest(payload.username(), payload.room());
+}
 void NetworkPlugin::handleVCardPayload(const std::string &data) {
 	pbnetwork::VCard payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	handleVCardRequest(payload.username(), payload.buddyname(), payload.id());
+}
 void NetworkPlugin::handleDataRead(const Swift::ByteArray &data) {
 	long expected_size = 0;
 	m_data += data.toString();
 // 	std::cout << "received data; size = " << m_data.size() << "\n";
 void NetworkPlugin::handleDataRead(const Swift::SafeByteArray &data) {
 	m_data.insert(m_data.begin(), data.begin(), data.end());
 	while (m_data.size() != 0) {
 		unsigned int expected_size;
 		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";
 			expected_size = *((unsigned int*) &m_data[0]);
 			expected_size = ntohl(expected_size);
 			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
 		if (wrapper.ParseFromArray(&m_data[4], expected_size) == false) {
 			m_data.erase(m_data.begin(), m_data.begin() + 4 + expected_size);
 			return;
+		}
 		m_data.erase(m_data.begin(), m_data.begin() + 4 + expected_size);
 		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;
 			case pbnetwork::WrapperMessage_Type_TYPE_LEAVE_ROOM:
 				handleLeaveRoomPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_VCARD:
 				handleVCardPayload(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));
 	char header[4];
 	*((int*)(header)) = htonl(data.size());
 	m_conn->write(Swift::createSafeByteArray(std::string(header, 4) + data));
+}
 void NetworkPlugin::sendPong() {
 	m_pingReceived = true;
 	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";
+}
 void NetworkPlugin::pingTimeout() {
 	std::cout << "PINGTIMEOUT " << m_pingReceived << " " << this << "\n";
 	if (m_pingReceived == false) {
 		exit(1);
+	}
 	m_pingReceived = false;
 	m_pingTimer->start();
+}
+}

src/networkpluginserver.cpp

➞

Show inline comments

@@ @@ -8,88 +8,91 @@ @@
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/networkpluginserver.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/storagebackend.h"
 #include "transport/rostermanager.h"
 #include "transport/usermanager.h"
 #include "transport/conversationmanager.h"
 #include "transport/localbuddy.h"
 #include "transport/config.h"
 #include "transport/conversation.h"
 #include "transport/vcardresponder.h"
 #include "transport/rosterresponder.h"
 #include "Swiften/Swiften.h"
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Elements/StreamError.h"
 #include "pbnetwork.pb.h"
 #include "sys/wait.h"
 #include "sys/signal.h"
 namespace Transport {
 class NetworkConversation : public Conversation {
 	public:
 		NetworkConversation(ConversationManager *conversationManager, const std::string &legacyName, bool muc = false) : Conversation(conversationManager, legacyName, muc) {
+		}
 		void sendMessage(boost::shared_ptr<Swift::Message> &message) {
 			onMessageToSend(this, message);
+		}
 		boost::signal<void (NetworkConversation *, boost::shared_ptr<Swift::Message> &)> onMessageToSend;
 };
 class NetworkFactory : public Factory {
 	public:
 		NetworkFactory(NetworkPluginServer *nps) {
 			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) {
 			LocalBuddy *buddy = new LocalBuddy(rosterManager, buddyInfo.id);
 			buddy->setAlias(buddyInfo.alias);
 			buddy->setName(buddyInfo.legacyName);
 			buddy->setSubscription(buddyInfo.subscription);
 			buddy->setGroups(buddyInfo.groups);
 			buddy->setFlags((BuddyFlag) buddyInfo.flags);
 			if (buddyInfo.settings.find("icon_hash") != buddyInfo.settings.end())
 				buddy->setIconHash(buddyInfo.settings.find("icon_hash")->second.s);
 			return buddy;
+		}
 	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;
 	buddy->setName(payload.buddyname());
 	buddy->setAlias(payload.alias());
 	std::vector<std::string> groups;
 	groups.push_back(payload.groups());
 	buddy->setGroups(groups);
 	buddy->setStatus(Swift::StatusShow((Swift::StatusShow::Type) payload.status()), payload.statusmessage());
 	buddy->setIconHash(payload.iconhash());
+}
 NetworkPluginServer::NetworkPluginServer(Component *component, Config *config, UserManager *userManager) {
 	m_userManager = userManager;
 	m_config = config;
 	m_component = component;
 	m_component->m_factory = new NetworkFactory(this);
 	m_userManager->onUserCreated.connect(boost::bind(&NetworkPluginServer::handleUserCreated, this, _1));
 	m_userManager->onUserDestroyed.connect(boost::bind(&NetworkPluginServer::handleUserDestroyed, this, _1));
 	m_pingTimer = component->getFactories()->getTimerFactory()->createTimer(10000);
 	m_pingTimer->onTick.connect(boost::bind(&NetworkPluginServer::pingTimeout, this));
 	m_vcardResponder = new VCardResponder(component->getIQRouter(), userManager);
 	m_vcardResponder->onVCardRequired.connect(boost::bind(&NetworkPluginServer::handleVCardRequired, this, _1, _2, _3));
 	m_vcardResponder->start();
 	m_rosterResponder = new RosterResponder(component->getIQRouter(), userManager);
 	m_rosterResponder->start();
 	m_server = component->getFactories()->getConnectionFactory()->createConnectionServer(10000);
 	m_server->onNewConnection.connect(boost::bind(&NetworkPluginServer::handleNewClientConnection, this, _1));
 	m_server->start();
 	signal(SIGCHLD, SigCatcher);
 	exec_(CONFIG_STRING(m_config, "service.backend").c_str(), "localhost", "10000", m_config->getConfigFile().c_str());
+}
 NetworkPluginServer::~NetworkPluginServer() {
 	m_pingTimer->stop();
 	delete m_vcardResponder;
 	delete m_rosterResponder;
+}
 void NetworkPluginServer::handleNewClientConnection(boost::shared_ptr<Swift::Connection> c) {
 	Client *client = new Client;
 	client->pongReceived = true;
 	client->connection = c;
 	m_clients.push_back(client);
 	c->onDisconnected.connect(boost::bind(&NetworkPluginServer::handleSessionFinished, this, client));
 	c->onDataRead.connect(boost::bind(&NetworkPluginServer::handleDataRead, this, client, _1));
 	sendPing(client);
 	m_pingTimer->start();
+}
 void NetworkPluginServer::handleSessionFinished(Client *c) {
 	for (std::list<User *>::const_iterator it = c->users.begin(); it != c->users.end(); it++) {
 		(*it)->setData(NULL);
 		(*it)->handleDisconnected("Internal Server Error, please reconnect.");
+	}
 	m_clients.remove(c);
 	delete c;
 	// Execute new session only if there's no free one after this crash/disconnection
 	for (std::list<Client *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {
 		if ((*it)->users.size() < 1) {
 			return;
+		}
+	}
 	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;
 	std::cout << "CONNECTED LOGIN 2 " << payload.user() << "\n";
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
-	std::cout << "CONNECTED LOGIN 2 " << payload.user() << "\n";
+	std::cout << "CONNECTED LOGIN 3 " << payload.user() << "\n";
 	m_component->m_userRegistry->onPasswordValid(payload.user());
 // 	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;
+	}
 	m_component->m_userRegistry->onPasswordInvalid(payload.user());
 	user->handleDisconnected(payload.message());
+}
 void NetworkPluginServer::handleVCardPayload(const std::string &data) {
 	pbnetwork::VCard payload;
 	if (payload.ParseFromString(data) == false) {
 		std::cout << "PARSING ERROR\n";
 		// TODO: ERROR
 		return;
+	}
 	std::cout << "OMG?\n";
 	boost::shared_ptr<Swift::VCard> vcard(new Swift::VCard());
 	vcard->setFullName(payload.fullname());
-	vcard->setPhoto(Swift::ByteArray(payload.photo()));
+	vcard->setPhoto(Swift::createByteArray(payload.photo()));
 	vcard->setNickname(payload.nickname());
 	m_vcardResponder->sendVCard(payload.id(), vcard);
+}
 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);
 		return;
+	}
 // 	std::cout << "payload 2...\n";
 	User *user = m_userManager->getUser(payload.username());
 	if (!user)
 		return;
 	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 	if (subject) {
 		msg->setSubject(payload.message());
+	}
 	else {
 		msg->setBody(payload.message());
+	}
 	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));
+	}
 	conv->handleMessage(msg, payload.nickname());
+}
 void NetworkPluginServer::handleDataRead(Client *c, const Swift::ByteArray &data) {
 	long expected_size = 0;
 	c->data += data.toString();
 // 	std::cout << "received data; size = " << m_data.size() << "\n";
 void NetworkPluginServer::handleDataRead(Client *c, const Swift::SafeByteArray &data) {
 	c->data.insert(c->data.begin(), data.begin(), data.end());
 	while (c->data.size() != 0) {
 		unsigned int expected_size;
 		if (c->data.size() >= 4) {
 			unsigned char * head = (unsigned char*) c->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";
 			expected_size = *((unsigned int*) &c->data[0]);
 			expected_size = ntohl(expected_size);
 			if (c->data.size() - 4 < expected_size)
 				return;
+		}
 		else {
 			return;
+		}
 		std::string msg = c->data.substr(4, expected_size);
 		c->data.erase(0, 4 + expected_size);
 		pbnetwork::WrapperMessage wrapper;
 		if (wrapper.ParseFromString(msg) == false) {
 			// TODO: ERROR
 		if (wrapper.ParseFromArray(&c->data[4], expected_size) == false) {
 			c->data.erase(c->data.begin(), c->data.begin() + 4 + expected_size);
 			return;
+		}
 		c->data.erase(c->data.begin(), c->data.begin() + 4 + expected_size);
 		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_ROOM_SUBJECT_CHANGED:
 				handleConvMessagePayload(wrapper.payload(), true);
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_PONG:
 				c->pongReceived = true;
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_PARTICIPANT_CHANGED:
 				handleParticipantChangedPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_ROOM_NICKNAME_CHANGED:
 				handleRoomChangedPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_VCARD:
 				handleVCardPayload(wrapper.payload());
 				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));
 	char header[4];
 	*((int*)(header)) = htonl(data.size());
 	c->write(Swift::createSafeByteArray(std::string(header, 4) + data));
+}
 void NetworkPluginServer::pingTimeout() {
 	std::cout << "pingtimeout\n";
 	for (std::list<Client *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {
 		if ((*it)->pongReceived) {
 			sendPing((*it));
 			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) {
 	Client *c = getFreeClient();
 	user->setData(c);
 	c->users.push_back(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));
 	user->onRoomLeft.connect(boost::bind(&NetworkPluginServer::handleRoomLeft, this, user, _1));

src/rostermanager.cpp

➞

Show inline comments

@@ @@ -26,151 +26,163 @@ @@
 #include "transport/buddy.h"
 #include "transport/user.h"
 #include "Swiften/Roster/SetRosterRequest.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/Elements/RosterItemPayload.h"
 #include "Swiften/Elements/RosterItemExchangePayload.h"
 namespace Transport {
 RosterManager::RosterManager(User *user, Component *component){
 	m_rosterStorage = NULL;
 	m_user = user;
 	m_component = component;
 	m_setBuddyTimer = m_component->getFactories()->getTimerFactory()->createTimer(1000);
 	m_RIETimer = m_component->getFactories()->getTimerFactory()->createTimer(5000);
 	m_RIETimer->onTick.connect(boost::bind(&RosterManager::sendRIE, this));
+}
 RosterManager::~RosterManager() {
 	m_setBuddyTimer->stop();
 	m_RIETimer->stop();
 	if (m_rosterStorage) {
 // 		for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {
 // 			Buddy *buddy = (*it).second;
 // 			m_rosterStorage->storeBuddy(buddy);
 // 		}
 		m_rosterStorage->storeBuddies();
+	}
 	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {
 		Buddy *buddy = (*it).second;
 		delete buddy;
+	}
 	if (m_rosterStorage)
 		delete m_rosterStorage;
+}
 void RosterManager::setBuddy(Buddy *buddy) {
 // 	m_setBuddyTimer->onTick.connect(boost::bind(&RosterManager::setBuddyCallback, this, buddy));
 // 	m_setBuddyTimer->start();
 	setBuddyCallback(buddy);
+}
 void RosterManager::sendBuddyRosterPush(Buddy *buddy) {
 	Swift::RosterPayload::ref payload = Swift::RosterPayload::ref(new Swift::RosterPayload());
 	Swift::RosterItemPayload item;
 	item.setJID(buddy->getJID().toBare());
 	item.setName(buddy->getAlias());
 	item.setGroups(buddy->getGroups());
 	payload->addItem(item);
-	Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, m_component->getIQRouter(), m_user->getJID().toBare());
+	Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, m_user->getJID().toBare(), m_component->getIQRouter());
 	request->onResponse.connect(boost::bind(&RosterManager::handleBuddyRosterPushResponse, this, _1, buddy->getName()));
 	request->send();
+}
 void RosterManager::setBuddyCallback(Buddy *buddy) {
 	m_setBuddyTimer->onTick.disconnect(boost::bind(&RosterManager::setBuddyCallback, this, buddy));
 	if (m_rosterStorage) {
 		buddy->onBuddyChanged.connect(boost::bind(&RosterStorage::storeBuddy, m_rosterStorage, buddy));
+	}
 	std::cout << "ADDING " << buddy->getName() << "\n";
 	m_buddies[buddy->getName()] = buddy;
 	onBuddySet(buddy);
 	// In server mode the only way is to send jabber:iq:roster push.
 	// In component mode we send RIE or Subscribe presences, based on features.
 	if (m_component->inServerMode()) {
 		sendBuddyRosterPush(buddy);
+	}
 	else {
 		if (m_setBuddyTimer->onTick.empty()) {
 			m_setBuddyTimer->stop();
 			if (true /*&& rie_is_supported*/) {
 				m_RIETimer->start();
+			}
+		}
+	}
 	if (m_rosterStorage)
 		m_rosterStorage->storeBuddy(buddy);
+}
 void RosterManager::unsetBuddy(Buddy *buddy) {
 	m_buddies.erase(buddy->getName());
 	if (m_rosterStorage)
 		m_rosterStorage->removeBuddyFromQueue(buddy);
 	onBuddyUnset(buddy);
+}
 void RosterManager::handleBuddyRosterPushResponse(Swift::ErrorPayload::ref error, const std::string &key) {
 	if (m_buddies[key] != NULL) {
 		m_buddies[key]->buddyChanged();
+	}
+}
 Buddy *RosterManager::getBuddy(const std::string &name) {
 	return m_buddies[name];
+}
 void RosterManager::sendRIE() {
 	m_RIETimer->stop();
 	Swift::RosterItemExchangePayload::ref payload = Swift::RosterItemExchangePayload::ref(new Swift::RosterItemExchangePayload());
 	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {
 		Buddy *buddy = (*it).second;
 		Swift::RosterItemExchangePayload::Item item;
 		item.jid = buddy->getJID().toBare();
 		item.name = buddy->getAlias();
 		item.action = Swift::RosterItemExchangePayload::Add;
 		item.groups = buddy->getGroups();
 		item.setJID(buddy->getJID().toBare());
 		item.setName(buddy->getAlias());
 		item.setAction(Swift::RosterItemExchangePayload::Item::Add);
 		item.setGroups(buddy->getGroups());
 		payload->addItem(item);
+	}
 	boost::shared_ptr<Swift::GenericRequest<Swift::RosterItemExchangePayload> > request(new Swift::GenericRequest<Swift::RosterItemExchangePayload>(Swift::IQ::Set, m_user->getJID(), payload, m_component->getIQRouter()));
 	request->send();
+}
 void RosterManager::handleSubscription(Swift::Presence::ref presence) {
 	std::string legacyName = Buddy::JIDToLegacyName(presence->getTo());
+}
 void RosterManager::setStorageBackend(StorageBackend *storageBackend) {
 	if (m_rosterStorage) {
 		m_rosterStorage->storeBuddies();
 		delete m_rosterStorage;
 		return;
+	}
 	m_rosterStorage = new RosterStorage(m_user, storageBackend);
 	std::list<BuddyInfo> roster;
 	storageBackend->getBuddies(m_user->getUserInfo().id, roster);
 	for (std::list<BuddyInfo>::const_iterator it = roster.begin(); it != roster.end(); it++) {
 		Buddy *buddy = m_component->getFactory()->createBuddy(this, *it);
 		std::cout << "CREATING BUDDY FROM DATABASE CACHE " << buddy->getName() << "\n";
 		m_buddies[buddy->getName()] = buddy;
 		buddy->onBuddyChanged.connect(boost::bind(&RosterStorage::storeBuddy, m_rosterStorage, buddy));
 		onBuddySet(buddy);
+	}
+}
 Swift::RosterPayload::ref RosterManager::generateRosterPayload() {
 	Swift::RosterPayload::ref payload = Swift::RosterPayload::ref(new Swift::RosterPayload());
 	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {
 		Buddy *buddy = (*it).second;
 		Swift::RosterItemPayload item;
 		item.setJID(buddy->getJID().toBare());
 		item.setName(buddy->getAlias());
 		item.setGroups(buddy->getGroups());
 		payload->addItem(item);
+	}
 	return payload;
+}
+}

src/rosterresponder.cpp

➞

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
  */
 #include "rosterresponder.h"
+#include "transport/rosterresponder.h"
 #include <iostream>
 #include <boost/bind.hpp>
 #include "Swiften/Queries/IQRouter.h"
 #include "Swiften/Swiften.h"
 #include "transport/user.h"
 #include "transport/usermanager.h"
 #include "transport/rostermanager.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
 RosterResponder::RosterResponder(Swift::IQRouter *router, StorageBackend *storageBackend, UserManager *userManager) : Swift::Responder<RosterPayload>(router) {
 	m_storageBackend = storageBackend;
 RosterResponder::RosterResponder(Swift::IQRouter *router, UserManager *userManager) : Swift::Responder<RosterPayload>(router) {
 	m_userManager = userManager;
+}
 RosterResponder::~RosterResponder() {
+}
 bool RosterResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload) {
 	// Get means we're in server mode and user wants to fetch his roster.
 	// For now we send empty reponse, but TODO: Get buddies from database and send proper stored roster.
 	User *user = m_userManager->getUser(from.toBare().toString());
 	if (!user) {
 		// Client can send jabber:iq:roster IQ before presence, so we do little hack here to
 		// trigger logging in.
 		// UserManager should create user now, if everything is OK.
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo(to);
 		response->setFrom(from);
 		response->setType(Swift::Presence::Available);
 		m_userManager->handlePresence(response);
 		// if it's not created, lets finish this get
 		user = m_userManager->getUser(from.toBare().toString());
 		if (!user) {
 			sendResponse(from, id, boost::shared_ptr<RosterPayload>(new RosterPayload()));

src/rosterstorage.cpp

➞

Show inline comments

@@ @@ -85,48 +85,50 @@ RosterStorage::~RosterStorage() { @@
 	m_storageTimer->stop();
+}
 void RosterStorage::storeBuddy(Buddy *buddy) {
 	m_buddies[buddy->getName()] = buddy;
 	m_storageTimer->start();
+}
 bool RosterStorage::storeBuddies() {
 	if (m_buddies.size() == 0) {
 		return false;
+	}
 	m_storageBackend->beginTransaction();
 	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {
 		Buddy *buddy = (*it).second;
 		BuddyInfo buddyInfo;
 		buddyInfo.alias = buddy->getAlias();
 		buddyInfo.legacyName = buddy->getName();
 		buddyInfo.groups = buddy->getGroups();
 		buddyInfo.subscription = buddy->getSubscription();
 		buddyInfo.id = buddy->getID();
 		buddyInfo.flags = buddy->getFlags();
 		buddyInfo.settings["icon_hash"].s = buddy->getIconHash();
 		buddyInfo.settings["icon_hash"].type = TYPE_STRING;
 		// Buddy is in DB
 		if (buddyInfo.id != -1) {
 			m_storageBackend->updateBuddy(m_user->getUserInfo().id, buddyInfo);
+		}
 		else {
 			buddyInfo.id = m_storageBackend->addBuddy(m_user->getUserInfo().id, buddyInfo);
 			buddy->setID(buddyInfo.id);
+		}
 // 		Log("buddyListSaveNode", id << " " << name << " " << alias << " " << s_buddy->getSubscription());
 // 		if (s_buddy->getBuddy() && id != -1) {
 // 			PurpleBuddy *buddy = s_buddy->getBuddy();
 // 			SaveData *s = new SaveData;
 // 			s->user = user;
 // 			s->id = id;
 // 			g_hash_table_foreach(buddy->node.settings, save_settings, s);
 // 			delete s;
 // 		}
+	}
 	m_storageBackend->commitTransaction();
 	return true;
+}

src/sqlite3backend.cpp

➞

Show inline comments

@@ @@ -68,73 +68,76 @@ SQLite3Backend::SQLite3Backend(Config *config) { @@
 SQLite3Backend::~SQLite3Backend(){
 	if (m_db) {
 		// Would be nice to use this:
 		//
 		//   sqlite3_stmt *pStmt;
 		//   while((pStmt = sqlite3_next_stmt(db, 0)) != 0 ) {
 		//    sqlite3_finalize(pStmt);
 		//   }
 		//
 		// But requires SQLite3 >= 3.6.0 beta
 		FINALIZE_STMT(m_setUser);
 		FINALIZE_STMT(m_getUser);
 		FINALIZE_STMT(m_removeUser);
 		FINALIZE_STMT(m_removeUserBuddies);
 		FINALIZE_STMT(m_removeUserSettings);
 		FINALIZE_STMT(m_removeUserBuddiesSettings);
 		FINALIZE_STMT(m_addBuddy);
 		FINALIZE_STMT(m_updateBuddy);
 		FINALIZE_STMT(m_getBuddies);
 		FINALIZE_STMT(m_getBuddiesSettings);
 		FINALIZE_STMT(m_getUserSetting);
 		FINALIZE_STMT(m_setUserSetting);
 		FINALIZE_STMT(m_updateUserSetting);
 		FINALIZE_STMT(m_updateBuddySetting);
 		sqlite3_close(m_db);
+	}
+}
 bool SQLite3Backend::connect() {
 	if (sqlite3_open(CONFIG_STRING(m_config, "database.database").c_str(), &m_db)) {
 		sqlite3_close(m_db);
 		return false;
+	}
 	if (createDatabase() == false)
 		return false;
 	PREP_STMT(m_setUser, "INSERT INTO " + m_prefix + "users (jid, uin, password, language, encoding, last_login, vip) VALUES (?, ?, ?, ?, ?, DATETIME('NOW'), ?)");
 	PREP_STMT(m_getUser, "SELECT id, jid, uin, password, encoding, language, vip FROM " + m_prefix + "users WHERE jid=?");
 	PREP_STMT(m_removeUser, "DELETE FROM " + m_prefix + "users WHERE id=?");
 	PREP_STMT(m_removeUserBuddies, "DELETE FROM " + m_prefix + "buddies WHERE user_id=?");
 	PREP_STMT(m_removeUserSettings, "DELETE FROM " + m_prefix + "users_settings WHERE user_id=?");
 	PREP_STMT(m_removeUserBuddiesSettings, "DELETE FROM " + m_prefix + "buddies_settings WHERE user_id=?");
 	PREP_STMT(m_addBuddy, "INSERT INTO " + m_prefix + "buddies (user_id, uin, subscription, groups, nickname, flags) VALUES (?, ?, ?, ?, ?, ?)");
 	PREP_STMT(m_updateBuddy, "UPDATE " + m_prefix + "buddies SET groups=?, nickname=?, flags=?, subscription=? WHERE user_id=? AND uin=?");
 	PREP_STMT(m_getBuddies, "SELECT id, uin, subscription, nickname, groups, flags FROM " + m_prefix + "buddies WHERE user_id=? ORDER BY id ASC");
 	PREP_STMT(m_getBuddiesSettings, "SELECT buddy_id, type, var, value FROM " + m_prefix + "buddies_settings WHERE user_id=? ORDER BY buddy_id ASC");
 	PREP_STMT(m_updateBuddySetting, "INSERT OR REPLACE INTO " + m_prefix + "buddies_settings (user_id, buddy_id, var, type, value) VALUES (?, ?, ?, ?, ?)");
 	PREP_STMT(m_getUserSetting, "SELECT type, value FROM " + m_prefix + "users_settings WHERE user_id=? AND var=?");
 	PREP_STMT(m_setUserSetting, "INSERT INTO " + m_prefix + "users_settings (user_id, var, type, value) VALUES (?,?,?,?)");
 	PREP_STMT(m_updateUserSetting, "UPDATE " + m_prefix + "users_settings SET value=? WHERE user_id=? AND var=?");
 	return true;
+}
 bool SQLite3Backend::createDatabase() {
 	int not_exist = exec("CREATE TABLE " + m_prefix + "buddies ("
 				"  id INTEGER PRIMARY KEY NOT NULL,"
 				"  user_id int(10) NOT NULL,"
 				"  uin varchar(255) NOT NULL,"
 				"  subscription varchar(20) NOT NULL,"
 				"  nickname varchar(255) NOT NULL,"
 				"  groups varchar(255) NOT NULL,"
 				"  flags int(4) NOT NULL DEFAULT '0'"
 				");");
 	if (not_exist) {
 		exec("CREATE UNIQUE INDEX IF NOT EXISTS user_id ON " + m_prefix + "buddies (user_id, uin);");
 		exec("CREATE TABLE IF NOT EXISTS " + m_prefix + "buddies_settings ("
 					"  user_id int(10) NOT NULL,"
 					"  buddy_id int(10) NOT NULL,"
 		onStorageError("getUser query", (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));
+	}
 	return false;
+}
 void SQLite3Backend::setUserOnline(long id, bool online) {
+}
 long SQLite3Backend::addBuddy(long userId, const BuddyInfo &buddyInfo) {
 // 	"INSERT INTO " + m_prefix + "buddies (user_id, uin, subscription, groups, nickname, flags) VALUES (?, ?, ?, ?, ?, ?)"
 	BEGIN(m_addBuddy);
 	BIND_INT(m_addBuddy, userId);
 	BIND_STR(m_addBuddy, buddyInfo.legacyName);
 	BIND_STR(m_addBuddy, buddyInfo.subscription);
 	BIND_STR(m_addBuddy, buddyInfo.groups[0]); // TODO: serialize groups
 	BIND_STR(m_addBuddy, buddyInfo.alias);
 	BIND_INT(m_addBuddy, buddyInfo.flags);
 	if(sqlite3_step(m_addBuddy) != SQLITE_DONE) {
 		onStorageError("addBuddy query", (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));
 		return -1;
+	}
 	return (long) sqlite3_last_insert_rowid(m_db);
 	long id = (long) sqlite3_last_insert_rowid(m_db);
 // 	INSERT OR REPLACE INTO " + m_prefix + "buddies_settings (user_id, buddy_id, var, type, value) VALUES (?, ?, ?, ?, ?)
 	BEGIN(m_updateBuddySetting);
 	BIND_INT(m_updateBuddySetting, userId);
 	BIND_INT(m_updateBuddySetting, id);
 	BIND_STR(m_updateBuddySetting, buddyInfo.settings.find("icon_hash")->first);
 	BIND_INT(m_updateBuddySetting, TYPE_STRING);
 	BIND_STR(m_updateBuddySetting, buddyInfo.settings.find("icon_hash")->second.s);
 	EXECUTE_STATEMENT(m_updateBuddySetting, "updateBuddySetting query");
 	return id;
+}
 void SQLite3Backend::updateBuddy(long userId, const BuddyInfo &buddyInfo) {
 // 	UPDATE " + m_prefix + "buddies SET groups=?, nickname=?, flags=?, subscription=? WHERE user_id=? AND uin=?
 	BEGIN(m_updateBuddy);
 	BIND_STR(m_updateBuddy, buddyInfo.groups[0]); // TODO: serialize groups
 	BIND_STR(m_updateBuddy, buddyInfo.alias);
 	BIND_INT(m_updateBuddy, buddyInfo.flags);
 	BIND_STR(m_updateBuddy, buddyInfo.subscription);
 	BIND_INT(m_updateBuddy, userId);
 	BIND_STR(m_updateBuddy, buddyInfo.legacyName);
 	EXECUTE_STATEMENT(m_updateBuddy, "updateBuddy query");
 // 	INSERT OR REPLACE INTO " + m_prefix + "buddies_settings (user_id, buddy_id, var, type, value) VALUES (?, ?, ?, ?, ?)
 	BEGIN(m_updateBuddySetting);
 	BIND_INT(m_updateBuddySetting, userId);
 	BIND_INT(m_updateBuddySetting, buddyInfo.id);
 	BIND_STR(m_updateBuddySetting, buddyInfo.settings.find("icon_hash")->first);
 	BIND_INT(m_updateBuddySetting, TYPE_STRING);
 	BIND_STR(m_updateBuddySetting, buddyInfo.settings.find("icon_hash")->second.s);
 	EXECUTE_STATEMENT(m_updateBuddySetting, "updateBuddySetting query");
+}
 bool SQLite3Backend::getBuddies(long id, std::list<BuddyInfo> &roster) {
 //	SELECT id, uin, subscription, nickname, groups, flags FROM " + m_prefix + "buddies WHERE user_id=? ORDER BY id ASC
 	BEGIN(m_getBuddies);
 	BIND_INT(m_getBuddies, id);
 // 	"SELECT buddy_id, type, var, value FROM " + m_prefix + "buddies_settings WHERE user_id=? ORDER BY buddy_id ASC"
 	BEGIN(m_getBuddiesSettings);
 	BIND_INT(m_getBuddiesSettings, id);
 	SettingVariableInfo var;
 	long buddy_id = -1;
 	std::string key;
 	int ret;
 	while((ret = sqlite3_step(m_getBuddies)) == SQLITE_ROW) {
 		BuddyInfo b;
 		RESET_GET_COUNTER(m_getBuddies);
 		b.id = GET_INT(m_getBuddies);
 		b.legacyName = GET_STR(m_getBuddies);
 		b.subscription = GET_STR(m_getBuddies);
 		b.alias = GET_STR(m_getBuddies);
 		b.groups.push_back(GET_STR(m_getBuddies));
 		b.flags = GET_INT(m_getBuddies);
 		if (buddy_id == b.id) {
 			std::cout << "Adding buddy info " << key << "\n";
 			b.settings[key] = var;
 			buddy_id = -1;
+		}
 		while(buddy_id == -1 && (ret = sqlite3_step(m_getBuddiesSettings)) == SQLITE_ROW) {
 			RESET_GET_COUNTER(m_getBuddiesSettings);
 			buddy_id = GET_INT(m_getBuddiesSettings);
 			var.type = GET_INT(m_getBuddiesSettings);
 			key = GET_STR(m_getBuddiesSettings);
 			std::string val = GET_STR(m_getBuddiesSettings);
 			switch (var.type) {
 				case TYPE_BOOLEAN:
 					var.b = atoi(val.c_str());
 					break;
 				case TYPE_STRING:
 					var.s = val;
 					break;
 				default:
 					if (buddy_id == b.id) {
 						buddy_id = -1;
+					}
 					continue;
 					break;
+			}
 			if (buddy_id == b.id) {
 				std::cout << "Adding buddy info " << key << "=" << val << "\n";
 				b.settings[key] = var;
 				buddy_id = -1;
+			}
+		}
 // 		if (ret != SQLITE_DONE) {
 // 			onStorageError("getBuddiesSettings query", (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));
 // 			return false;
 // 		}
 		roster.push_back(b);
+	}
 	if (ret != SQLITE_DONE) {
 		onStorageError("getBuddies query", (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));
 		return false;
+	}
 	return true;
+}

src/transport.cpp

➞

Show inline comments

@@ @@ -15,50 +15,50 @@ @@
+ *
  * 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/transport.h"
 #include <boost/bind.hpp>
 #include "transport/storagebackend.h"
 #include "transport/factory.h"
 #include "discoinforesponder.h"
 #include "discoitemsresponder.h"
 #include "storageparser.h"
 using namespace Swift;
 using namespace boost;
 namespace Transport {
 class MyUserRegistry : public Swift::UserRegistry {
 	public:
 		MyUserRegistry(Component *c) {component = c;}
 		~MyUserRegistry() {}
 		bool isValidUserPassword(const JID& user, const std::string& password) const {
 			users[user.toBare().toString()] = password;
 		bool isValidUserPassword(const JID& user, const Swift::SafeByteArray& password) const {
 			users[user.toBare().toString()] = Swift::safeByteArrayToString(password);
 			Swift::Presence::ref response = Swift::Presence::create();
 			response->setTo(component->getJID());
 			response->setFrom(user);
 			response->setType(Swift::Presence::Available);
 			component->onUserPresenceReceived(response);
 			std::cout << "CONNECTED LOGIN 1" << user.toString() << "\n";
 			return true;
+		}
 		mutable std::map<std::string, std::string> users;
 		mutable Component *component;
 };
 Component::Component(Swift::EventLoop *loop, Config *config, Factory *factory) {
 	m_component = NULL;
 	m_userRegistry = NULL;
 	m_server = NULL;
 	m_reconnectCount = 0;
 	m_config = config;
 	m_factory = factory;
 	m_jid = Swift::JID(CONFIG_STRING(m_config, "service.jid"));
 	m_factories = new BoostNetworkFactories(loop);
 	m_discoInfoResponder->setBuddyFeatures(features);
+}
 void Component::connect() {
 	if (!m_component)
 		return;
 	m_reconnectCount++;
 	m_component->connect(CONFIG_STRING(m_config, "service.server"), CONFIG_INT(m_config, "service.port"));
 	m_reconnectTimer->stop();
+}
 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::handleDataRead(const Swift::SafeByteArray &data) {
 	onXMLIn(safeByteArrayToString(data));
+}
 void Component::handleDataWritten(const std::string &data) {
 	onXMLOut(data);
 void Component::handleDataWritten(const Swift::SafeByteArray &data) {
 	onXMLOut(safeByteArrayToString(data));
+}
 void Component::handlePresence(Swift::Presence::ref presence) {
 	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()) {
 		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";
+		}
 // 		else {
 // 			GetDiscoInfoRequest::ref discoInfoRequest = GetDiscoInfoRequest::create(presence->getFrom(), m_iqRouter);
 // 			discoInfoRequest->onResponse.connect(boost::bind(&Component::handleDiscoInfoResponse, this, _1, _2, presence->getFrom()));

src/usermanager.cpp

➞

Show inline comments

@@ @@ -4,74 +4,69 @@ @@
  * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/usermanager.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/storagebackend.h"
 #include "transport/conversationmanager.h"
 #include "transport/rostermanager.h"
 #include "storageresponder.h"
 #include "rosterresponder.h"
 namespace Transport {
 UserManager::UserManager(Component *component, StorageBackend *storageBackend) {
 	m_cachedUser = NULL;
 	m_onlineBuddies = 0;
 	m_component = component;
 	m_storageBackend = storageBackend;
 	m_storageResponder = new StorageResponder(component->getIQRouter(), m_storageBackend, this);
 	m_storageResponder->start();
 	m_rosterResponder = new RosterResponder(component->getIQRouter(), m_storageBackend, this);
 	m_rosterResponder->start();
 	component->onUserPresenceReceived.connect(bind(&UserManager::handlePresence, this, _1));
 	m_component->getStanzaChannel()->onMessageReceived.connect(bind(&UserManager::handleMessageReceived, this, _1));
 	m_component->getStanzaChannel()->onPresenceReceived.connect(bind(&UserManager::handleGeneralPresenceReceived, this, _1));
 // 	component->onDiscoInfoResponse.connect(bind(&UserManager::handleDiscoInfoResponse, this, _1, _2, _3));
+}
 UserManager::~UserManager(){
 	m_storageResponder->stop();
 	delete m_storageResponder;
 	delete m_rosterResponder;
+}
 void UserManager::addUser(User *user) {
 	m_users[user->getJID().toBare().toString()] = user;
 	onUserCreated(user);
+}
 User *UserManager::getUser(const std::string &barejid){
 	if (m_cachedUser && barejid == m_cachedUser->getJID().toBare().toString()) {
 		return m_cachedUser;
+	}
 	if (m_users.find(barejid) != m_users.end()) {
 		User *user = m_users[barejid];
 		m_cachedUser = user;
 		return user;
+	}
 	return NULL;
+}
 void UserManager::removeUser(User *user) {
 	m_users.erase(user->getJID().toBare().toString());
 	if (m_cachedUser == user)
 		m_cachedUser = NULL;

0 comments (0 inline, 0 general)