libtransport.git Changeset - b0bcade44c94

Changeset - b0bcade44c94

Parent rev.

Child rev.

[Not reviewed]

0 11 0

HanzZ - 14 years ago 2011-06-17 13:43:31
hanzz.k@gmail.com

Hopefully working authorizations. Tested it only once :)

11 files changed with 237 insertions and 9 deletions:

backends/libpurple/main.cpp

include/transport/networkplugin.h

include/transport/networkpluginserver.h

include/transport/rostermanager.h

spectrum/src/CMakeLists.txt

spectrum/src/sample.cfg

src/buddy.cpp

src/networkplugin.cpp

src/networkpluginserver.cpp

src/pbnetwork.proto

src/rostermanager.cpp

124

0 comments (0 inline, 0 general)

backends/libpurple/main.cpp

➞

Show inline comments

 #include "glib.h"
 #include "purple.h"
 #include <iostream>
 #include "transport/config.h"
 #include "transport/transport.h"
 #include "transport/usermanager.h"
 #include "transport/logger.h"
 #include "transport/sqlite3backend.h"
 #include "transport/userregistration.h"
 #include "transport/user.h"
 #include "transport/storagebackend.h"
 #include "transport/rostermanager.h"
 #include "transport/conversation.h"
 #include "transport/networkplugin.h"
 #include "spectrumeventloop.h"
 #include "geventloop.h"
 #define Log(X, STRING) std::cout << "[SPECTRUM] " << X << " " << STRING << "\n";
 using namespace Transport;
 class SpectrumNetworkPlugin;
 Logger *_logger;
 SpectrumNetworkPlugin *np;
 static gboolean nodaemon = FALSE;
 static gchar *logfile = NULL;
 static gchar *lock_file = NULL;
 static gchar *host = NULL;
 static int port = 10000;
 static gboolean ver = FALSE;
 static gboolean list_purple_settings = FALSE;
 static GOptionEntry options_entries[] = {
 	{ "nodaemon", 'n', 0, G_OPTION_ARG_NONE, &nodaemon, "Disable background daemon mode", NULL },
 	{ "logfile", 'l', 0, G_OPTION_ARG_STRING, &logfile, "Set file to log", NULL },
 	{ "pidfile", 'p', 0, G_OPTION_ARG_STRING, &lock_file, "File where to write transport PID", NULL },
 	{ "version", 'v', 0, G_OPTION_ARG_NONE, &ver, "Shows Spectrum version", NULL },
 	{ "list-purple-settings", 's', 0, G_OPTION_ARG_NONE, &list_purple_settings, "Lists purple settings which can be used in config file", NULL },
 	{ "host", 'h', 0, G_OPTION_ARG_STRING, &host, "Host to connect to", NULL },
 	{ "port", 'p', 0, G_OPTION_ARG_INT, &port, "Port to connect to", NULL },
 	{ NULL, 0, 0, G_OPTION_ARG_NONE, NULL, "", NULL }
 };
 struct authRequest {
 	PurpleAccountRequestAuthorizationCb authorize_cb;
 	PurpleAccountRequestAuthorizationCb deny_cb;
 	void *user_data;
 	std::string who;
 	PurpleAccount *account;
 	std::string mainJID;	// JID of user connected with this request
 };
 static void * requestInput(const char *title, const char *primary,const char *secondary, const char *default_value, gboolean multiline, gboolean masked, gchar *hint,const char *ok_text, GCallback ok_cb,const char *cancel_text, GCallback cancel_cb, PurpleAccount *account, const char *who,PurpleConversation *conv, void *user_data) {
 	std::cout << "REQUEST INPUT\n";
 	if (primary) {
 		std::string primaryString(primary);
 		std::cout << "REQUEST INPUT " << primaryString << "\n";
 		if (primaryString == "Authorization Request Message:") {
 			std::cout << "AUTHORIZING\n";
 			((PurpleRequestInputCb) ok_cb)(user_data, "Please authorize me.");
 			return NULL;
+		}
+	}
 	return NULL;
+}
 static void *requestAction(const char *title, const char *primary, const char *secondary, int default_action, PurpleAccount *account, const char *who,PurpleConversation *conv, void *user_data, size_t action_count, va_list actions){
 	std::string t(title ? title : "NULL");
 	if (t == "SSL Certificate Verification") {
 		Log("purple", "accepting SSL certificate");
 		va_arg(actions, char *);
 		((PurpleRequestActionCb) va_arg(actions, GCallback)) (user_data, 2);
+	}
 	else {
 		if (title) {
 			std::string headerString(title);
 			Log("purple", "header string: " << headerString);
 			if (headerString == "SSL Certificate Verification") {
 				va_arg(actions, char *);
 				((PurpleRequestActionCb) va_arg(actions, GCallback)) (user_data, 2);
+			}
+		}
+	}
 	return NULL;
+}
 class SpectrumNetworkPlugin : public NetworkPlugin {
 	public:
 		SpectrumNetworkPlugin(Config *config, SpectrumEventLoop *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) {
 			PurpleAccount *account = NULL;
 			const char *protocol = CONFIG_STRING(config, "service.protocol").c_str();
 			if (purple_accounts_find(legacyName.c_str(), protocol) != NULL){
 				Log(user, "this account already exists");
 				account = purple_accounts_find(legacyName.c_str(), protocol);
 // 				User *u = (User *) account->ui_data;
 // 				if (u && u != user) {
@@ @@ -249,149 +258,160 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 							else if (strcmp(*f, "gif") == 0 && format != "jpg" && format != "png") {
 								format = *f;
+							}
 							else if (format.empty()) {
 								format = *f;
+							}
+						}
 						g_strfreev(strlist);
 						img.magick(format);
 						int width, height;
 						if (CONFIG().protocol == "icq") {
 							width = 48;
 							height = 48;
+						}
 						else {
 							purple_buddy_icon_get_scale_size(&prpl_info->icon_spec, &width, &height);
+						}
 						if (img.size().width() != width || img.size().height() != height) {
 							Magick::Geometry g = Magick::Geometry(width,height);
 							g.aspect(CONFIG().protocol == "icq");
 							img.scale(g);
+						}
 						Magick::Blob output;
 						img.write(&output);
 						size = output.length();
 						// this will be freed by libpurple
 						photo = (guchar *) g_malloc(size * sizeof(guchar));
 						memcpy(photo, output.data(), size);
+					}
 					catch ( Magick::Exception & error) {
 						Log("handleVCard","Caught Magick++ exception: " << error.what());
 					} catch(...) {   // catch all other exceptions
+					}
+				}
 #endif /* WITH_IMAGEMAGICK */
 				if (!photo)
 					return;
 				purple_buddy_icons_set_account_icon(account, photo, size);
+			}
+		}
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::string &groups) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				if (m_authRequests.find(user + buddyName) != m_authRequests.end()) {
 					m_authRequests[user + buddyName]->deny_cb(m_authRequests[user + buddyName]->user_data);
 					m_authRequests.erase(user + buddyName);
+				}
 				PurpleBuddy *buddy = purple_find_buddy(account, buddyName.c_str());
 				if (buddy) {
 					purple_account_remove_buddy(account, buddy, purple_buddy_get_group(buddy));
 					purple_blist_remove_buddy(buddy);
+				}
+			}
+		}
 		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::string &groups) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				if (m_authRequests.find(user + buddyName) != m_authRequests.end()) {
 					m_authRequests[user + buddyName]->authorize_cb(m_authRequests[user + buddyName]->user_data);
 					m_authRequests.erase(user + buddyName);
+				}
 				PurpleBuddy *buddy = purple_find_buddy(account, buddyName.c_str());
 				if (buddy) {
 					purple_blist_alias_buddy(buddy, alias.c_str());
 					purple_blist_server_alias_buddy(buddy, alias.c_str());
 					serv_alias_buddy(buddy);
+				}
 				else {
 					std::cout << "ADDING NEW BUDDY\n";
 					PurpleBuddy *buddy = purple_buddy_new(account, buddyName.c_str(), alias.c_str());
 					// Add newly created buddy to legacy network roster.
 					PurpleGroup *group = purple_find_group(groups.c_str());
 					purple_blist_add_buddy(buddy, NULL, group ,NULL);
 					purple_account_add_buddy(account, buddy);
+				}
+			}
+		}
 		void handleTypingRequest(const std::string &user, const std::string &buddyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				serv_send_typing(purple_account_get_connection(account), buddyName.c_str(), PURPLE_TYPING);
+			}
+		}
 		void handleTypedRequest(const std::string &user, const std::string &buddyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				serv_send_typing(purple_account_get_connection(account), buddyName.c_str(), PURPLE_TYPED);
+			}
+		}
 		void handleStoppedTypingRequest(const std::string &user, const std::string &buddyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				serv_send_typing(purple_account_get_connection(account), buddyName.c_str(), PURPLE_NOT_TYPING);
+			}
+		}
 		std::map<std::string, PurpleAccount *> m_sessions;
 		std::map<PurpleAccount *, std::string> m_accounts;
 		std::map<std::string, unsigned int> m_vcards;
 		std::map<std::string, authRequest *> m_authRequests;
 	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 bool getStatus(PurpleBuddy *m_buddy, Swift::StatusShow &status, std::string &statusMessage) {
 	PurplePresence *pres = purple_buddy_get_presence(m_buddy);
 	if (pres == NULL)
 		return false;
 	PurpleStatus *stat = purple_presence_get_active_status(pres);
 	if (stat == NULL)
 		return false;
 	int st = purple_status_type_get_primitive(purple_status_get_type(stat));
 	switch(st) {
 		case PURPLE_STATUS_AVAILABLE: {
 			break;
+		}
 		case PURPLE_STATUS_AWAY: {
 			status = Swift::StatusShow::Away;
 			break;
+		}
 		case PURPLE_STATUS_UNAVAILABLE: {
 			status = Swift::StatusShow::DND;
 			break;
+		}
 		case PURPLE_STATUS_EXTENDED_AWAY: {
 			status = Swift::StatusShow::XA;
 			break;
+		}
 		case PURPLE_STATUS_OFFLINE: {
 			status = Swift::StatusShow::None;
 			break;
+		}
 		default:
 			break;
+	}
 	const char *message = purple_status_get_attr_string(stat, "message");
 // 							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, 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 PurpleRequestUiOps requestUiOps =
+{
 	requestInput,
 	NULL,
 	requestAction,
 	NULL,
 	NULL,
 	NULL, //requestClose,
 	NULL,
 	NULL,
 	NULL,
 	NULL,
 	NULL
 };
 static void * accountRequestAuth(PurpleAccount *account, const char *remote_user, const char *id, const char *alias, const char *message, gboolean on_list, PurpleAccountRequestAuthorizationCb authorize_cb, PurpleAccountRequestAuthorizationCb deny_cb, void *user_data) {
 	authRequest *req = new authRequest;
 	req->authorize_cb = authorize_cb;
 	req->deny_cb = deny_cb;
 	req->user_data = user_data;
 	req->account = account;
 	req->who = remote_user;
 	req->mainJID = np->m_accounts[account];
 	np->m_authRequests[req->mainJID + req->who] = req;
 	np->handleAuthorization(req->mainJID, req->who);
 	return req;
+}
 static void accountRequestClose(void *data){
 	authRequest *req = (authRequest *) data;
 	np->m_authRequests.erase(req->mainJID + req->who);
+}
 static PurpleAccountUiOps accountUiOps =
+{
 	NULL,
 	NULL,
 	NULL,
 	accountRequestAuth,
 	accountRequestClose,
 	NULL,
 	NULL,
 	NULL,
 	NULL
 };
 static void transport_core_ui_init(void)
+{
 	purple_blist_set_ui_ops(&blistUiOps);
-// 	purple_accounts_set_ui_ops(&accountUiOps);
 	purple_accounts_set_ui_ops(&accountUiOps);
 	purple_notify_set_ui_ops(&notifyUiOps);
 	purple_request_set_ui_ops(&requestUiOps);
 // 	purple_xfers_set_ui_ops(getXferUiOps());
 	purple_connections_set_ui_ops(&conn_ui_ops);
 	purple_conversations_set_ui_ops(&conversation_ui_ops);
 // #ifndef WIN32
 // 	purple_dnsquery_set_ui_ops(getDNSUiOps());
 // #endif
+}
 static PurpleCoreUiOps coreUiOps =
+{
 	NULL,
 // 	debug_init,
 	NULL,
 	transport_core_ui_init,
 	NULL,
 	NULL,
 	NULL,
 	NULL,
 	NULL
 };
 static void signed_on(PurpleConnection *gc, gpointer unused) {
 	PurpleAccount *account = purple_connection_get_account(gc);
 	np->handleConnected(np->m_accounts[account]);
+}
 static void printDebug(PurpleDebugLevel level, const char *category, const char *arg_s) {
 	std::string c("[LIBPURPLE");
 	if (category) {
 		c.push_back('/');
 		c.append(category);
+	}
 	c.push_back(']');
 	std::cout << c << " " << arg_s;
+}
 /*
  * Ops....
  */
 static PurpleDebugUiOps debugUiOps =
+{
 	printDebug,
 	NULL,

include/transport/networkplugin.h

➞

Show inline comments

@@ @@ -19,96 +19,98 @@ @@
  */
 #pragma once
 #include <time.h>
 #include "Swiften/Swiften.h"
 #include "Swiften/Presence/PresenceOracle.h"
 #include "Swiften/Disco/EntityCapsManager.h"
 #include "Swiften/Network/ConnectionServer.h"
 #include "Swiften/Network/Connection.h"
 #include "Swiften/Network/BoostTimerFactory.h"
 #include "Swiften/Network/BoostNetworkFactories.h"
 #include "Swiften/Network/BoostIOServiceThread.h"
 #include "Swiften/Network/Connection.h"
 #include "storagebackend.h"
 namespace Transport {
 class NetworkPlugin {
 	public:
 		NetworkPlugin(Swift::EventLoop *loop, const std::string &host, int port);
 		virtual ~NetworkPlugin();
 		void handleBuddyChanged(const std::string &user, const std::string &buddyName, const std::string &alias,
 			const std::string &groups, int status, const std::string &statusMessage = "", const std::string &iconHash = ""
 		);
 		void handleParticipantChanged(const std::string &user, const std::string &nickname, const std::string &room, int flags, int status = Swift::StatusShow::None, const std::string &statusMessage = "", const std::string &newname = "");
 		void handleDisconnected(const std::string &user, const std::string &legacyName, int error, const std::string &message);
 		void handleConnected(const std::string &user);
 		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);
 		void handleBuddyTyping(const std::string &user, const std::string &buddyName);
 		void handleBuddyTyped(const std::string &user, const std::string &buddyName);
 		void handleBuddyStoppedTyping(const std::string &user, const std::string &buddyName);
 		void handleAuthorization(const std::string &user, const std::string &buddyName);
 		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 handleVCardUpdatedRequest(const std::string &/*user*/, const std::string &/*photo*/) {}
 		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*/) {}
 		virtual void handleStatusChangeRequest(const std::string &/*user*/, int status, const std::string &statusMessage) {}
 		virtual void handleBuddyUpdatedRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::string &/*alias*/, const std::string &/*groups*/) {}
 		virtual void handleBuddyRemovedRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::string &/*groups*/) {}
 		virtual void handleTypingRequest(const std::string &/*user*/, const std::string &/*buddyName*/) {}
 		virtual void handleTypedRequest(const std::string &/*user*/, const std::string &/*buddyName*/) {}
 		virtual void handleStoppedTypingRequest(const std::string &/*user*/, const std::string &/*buddyName*/) {}
 	private:
 		void connect();
 		void handleLoginPayload(const std::string &payload);
 		void handleLogoutPayload(const std::string &payload);
 		void handleStatusChangedPayload(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 handleBuddyChangedPayload(const std::string &payload);
 		void handleBuddyRemovedPayload(const std::string &payload);
 		void handleChatStatePayload(const std::string &payload, Swift::ChatState::ChatStateType type);
 		void handleDataRead(const Swift::SafeByteArray&);
 		void _handleConnected(bool error);
 		void handleDisconnected();
 		void send(const std::string &data);
 		void sendPong();
 		void pingTimeout();
 		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

@@ @@ -23,80 +23,81 @@ @@
 #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;
 			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::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 handleChatStatePayload(const std::string &payload, Swift::ChatState::ChatStateType type);
 		void handleAuthorizationPayload(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 handleUserPresenceChanged(User *user, Swift::Presence::ref presence);
 		void handleUserDestroyed(User *user);
 		void handleBuddyUpdated(Buddy *buddy, const Swift::RosterItemPayload &item);
 		void handleBuddyRemoved(Buddy *buddy);
 		void handleBuddyAdded(Buddy *buddy, const Swift::RosterItemPayload &item);
 		void handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> vcard);
 		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/rostermanager.h

➞

Show inline comments

@@ @@ -31,67 +31,71 @@ namespace Transport { @@
 class Buddy;
 class User;
 class Component;
 class StorageBackend;
 class RosterStorage;
 /// Manages roster of one XMPP user.
 class RosterManager {
 	public:
 		/// Creates new RosterManager.
 		/// \param user User associated with this RosterManager.
 		/// \param component Transport instance associated with this roster.
 		RosterManager(User *user, Component *component);
 		/// Destructor.
 		virtual ~RosterManager();
 		/// Associates the buddy with this roster,
 		/// and if the buddy is not already in XMPP user's server-side roster, the proper requests
 		/// are sent to XMPP user (subscribe presences, Roster Item Exchange stanza or
 		/// the buddy is added to server-side roster using remote-roster protoXEP).
 		/// \param buddy Buddy
 		void setBuddy(Buddy *buddy);
 		/// Deassociates the buddy with this roster.
 		/// \param buddy Buddy.
 		void unsetBuddy(Buddy *buddy);
 		Buddy *getBuddy(const std::string &name);
 		void setStorageBackend(StorageBackend *storageBackend);
 		void storeBuddy(Buddy *buddy);
 		Swift::RosterPayload::ref generateRosterPayload();
 		/// Returns user associated with this roster.
 		/// \return User
 		User *getUser() { return m_user; }
 		/// Called when new Buddy is added to this roster.
 		/// \param buddy newly added Buddy
 		boost::signal<void (Buddy *buddy)> onBuddySet;
 		/// Called when Buddy has been removed from this roster.
 		/// \param buddy removed Buddy
 		boost::signal<void (Buddy *buddy)> onBuddyUnset;
 		boost::signal<void (Buddy *buddy)> onBuddyAdded;
 		boost::signal<void (Buddy *buddy)> onBuddyRemoved;
 		void handleSubscription(Swift::Presence::ref presence);
 	private:
 		void setBuddyCallback(Buddy *buddy);
 		void sendBuddyRosterPush(Buddy *buddy);
 		void sendRIE();
 		void handleBuddyRosterPushResponse(Swift::ErrorPayload::ref error, const std::string &key);
 		std::map<std::string, Buddy *> m_buddies;
 		Component *m_component;
 		RosterStorage *m_rosterStorage;
 		User *m_user;
 		Swift::Timer::ref m_setBuddyTimer;
 		Swift::Timer::ref m_RIETimer;
 };
+}

spectrum/src/CMakeLists.txt

➞

Show inline comments

 cmake_minimum_required(VERSION 2.6)
 FILE(GLOB SRC *.cpp)
 ADD_EXECUTABLE(spectrum2 ${SRC})
 ADD_DEPENDENCIES(spectrum2 libpurple_backend)
 ADD_DEPENDENCIES(spectrum2 libircclient-qt_backend)
 ADD_DEPENDENCIES(spectrum2 spectrum_libpurple_backend)
 ADD_DEPENDENCIES(spectrum2 spectrum_libircclient-qt_backend)
 target_link_libraries(spectrum2 transport)
 INSTALL(TARGETS spectrum2 RUNTIME DESTINATION bin)
 INSTALL(FILES
 	sample2.cfg
 	RENAME spectrum.cfg.example
 	DESTINATION /etc/spectrum2
+	)

spectrum/src/sample.cfg

➞

Show inline comments

 [service]
 jid = localhost
 password = secret
 server = 127.0.0.1
 port = 5222
 server_mode = 1
 backend_host=localhost # < this option doesn't work yet
 backend_port=10001
 #cert= #patch to PKCS#12 certificate
 #cert_password= #password to that certificate if any
 users_per_backend=2
 backend=../../backends/libpurple/libpurple_backend
 #backend=../../backends/libircclient-qt/libircclient-qt_backend
 backend=../../backends/libpurple/spectrum_libpurple_backend
 #backend=../../backends/libircclient-qt/spectrum_libircclient-qt_backend
 protocol=prpl-jabber
 #protocol=prpl-msn
 #protocol=prpl-icq
 [database]
 type = sqlite3 # or "none" without database backend
 database = test.sql
 prefix=icq

src/buddy.cpp

➞

Show inline comments

+	}
 	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::handleBuddyChanged() {
 	Swift::Presence::ref presence = generatePresenceStanza(255);
 	if (presence) {
 		m_rosterManager->getUser()->getComponent()->getStanzaChannel()->sendPresence(presence);
+	}
 	onBuddyChanged();
+}
 void Buddy::handleVCardReceived(const std::string &id, 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();
 		// Psi sucks...
 		if (name.find_last_of("\\40") != std::string::npos) {
 			name.replace(name.find_last_of("\\40"), 1, "@");
+		}
+	}
 	return name;
+}
+}

src/networkplugin.cpp

➞

Show inline comments

 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);
 	send(message);
+}
 void NetworkPlugin::handleBuddyTyping(const std::string &user, const std::string &buddyName) {
 	pbnetwork::Buddy buddy;
 	buddy.set_username(user);
 	buddy.set_buddyname(buddyName);
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING);
 	send(message);
+}
 void NetworkPlugin::handleBuddyTyped(const std::string &user, const std::string &buddyName) {
 	pbnetwork::Buddy buddy;
 	buddy.set_username(user);
 	buddy.set_buddyname(buddyName);
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPED);
 	send(message);
+}
 void NetworkPlugin::handleBuddyStoppedTyping(const std::string &user, const std::string &buddyName) {
 	pbnetwork::Buddy buddy;
 	buddy.set_username(user);
 	buddy.set_buddyname(buddyName);
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_STOPPED_TYPING);
 	send(message);
+}
 void NetworkPlugin::handleAuthorization(const std::string &user, const std::string &buddyName) {
 	pbnetwork::Buddy buddy;
 	buddy.set_username(user);
 	buddy.set_buddyname(buddyName);
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_AUTH_REQUEST);
 	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);
+}
 void NetworkPlugin::handleParticipantChanged(const std::string &user, const std::string &nickname, const std::string &room, int flags, int status, const std::string &statusMessage, const std::string &newname) {
 	pbnetwork::Participant d;
 	d.set_username(user);
 	d.set_nickname(nickname);
 	d.set_room(room);
 	d.set_flag(flags);
 	d.set_newname(newname);
 	d.set_status(status);
 	d.set_statusmessage(statusMessage);
 	std::string message;
 	d.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_PARTICIPANT_CHANGED);
 	send(message);
+}
 void NetworkPlugin::handleRoomChanged(const std::string &user, const std::string &r, const std::string &nickname) {
 	pbnetwork::Room room;

src/networkpluginserver.cpp

➞

Show inline comments

+	}
 	exec_(CONFIG_STRING(m_config, "service.backend").c_str(), CONFIG_STRING(m_config, "service.backend_host").c_str(), CONFIG_STRING(m_config, "service.backend_port").c_str(), 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 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;
+	}
 	m_component->m_userRegistry->onPasswordInvalid(payload.user());
 	User *user = m_userManager->getUser(payload.user());
 	if (!user) {
 		return;
+	}
 	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;
+	}
 	boost::shared_ptr<Swift::VCard> vcard(new Swift::VCard());
 	vcard->setFullName(payload.fullname());
 	vcard->setPhoto(Swift::createByteArray(payload.photo()));
 	vcard->setNickname(payload.nickname());
 	m_vcardResponder->sendVCard(payload.id(), vcard);
+}
 void NetworkPluginServer::handleAuthorizationPayload(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;
 	Swift::Presence::ref response = Swift::Presence::create();
 	response->setTo(user->getJID());
 	std::string name = payload.buddyname();
 // 	name = Swift::JID::getEscapedNode(name)
 	if (name.find_last_of("@") != std::string::npos) {
 		name.replace(name.find_last_of("@"), 1, "%");
+	}
 	response->setFrom(Swift::JID(name, m_component->getJID().toString()));
 	response->setType(Swift::Presence::Subscribe);
 	m_component->getStanzaChannel()->sendPresence(response);
+}
 void NetworkPluginServer::handleChatStatePayload(const std::string &data, Swift::ChatState::ChatStateType type) {
 	pbnetwork::Buddy payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	User *user = m_userManager->getUser(payload.username());
 	if (!user)
 		return;
 	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(payload.buddyname());
 	if (!conv) {
 		std::cout << "handling chatstate: NO conv with buddyname=" << payload.buddyname() << "\n";
 		return;
+	}
 	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 	msg->addPayload(boost::make_shared<Swift::ChatState>(type));
 	conv->handleMessage(msg);
+}
 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->handleBuddyChanged();
+	}
 	else {
 		buddy = new LocalBuddy(user->getRosterManager(), -1);
 		handleBuddyPayload(buddy, payload);
 		user->getRosterManager()->setBuddy(buddy);
+	}
+}
 void NetworkPluginServer::handleParticipantChangedPayload(const std::string &data) {
 	pbnetwork::Participant payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	User *user = m_userManager->getUser(payload.username());
 	if (!user)
 		return;
 	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(payload.room());
 	if (!conv) {
 		return;
+	}
 	conv->handleParticipantChanged(payload.nickname(), payload.flag(), payload.status(), payload.statusmessage(), payload.newname());
 // 	LocalBuddy *buddy = (LocalBuddy *) user->getRosterManager()->getBuddy(payload.buddyname());
 // 	if (buddy) {
 // 		handleBuddyPayload(buddy, payload);
 // 		buddy->buddyChanged();
 // 	}
 			return;
+		}
 		pbnetwork::WrapperMessage wrapper;
 		if (wrapper.ParseFromArray(&c->data[4], expected_size) == false) {
 			std::cout << "PARSING ERROR " << expected_size << "\n";
 			c->data.erase(c->data.begin(), c->data.begin() + 4 + expected_size);
 			continue;
+		}
 		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;
 			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING:
 				handleChatStatePayload(wrapper.payload(), Swift::ChatState::Composing);
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPED:
 				handleChatStatePayload(wrapper.payload(), Swift::ChatState::Paused);
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_STOPPED_TYPING:
 				handleChatStatePayload(wrapper.payload(), Swift::ChatState::Active);
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_AUTH_REQUEST:
 				handleAuthorizationPayload(wrapper.payload());
 				break;
 			default:
 				return;
+		}
+	}
+}
 void NetworkPluginServer::send(boost::shared_ptr<Swift::Connection> &c, const std::string &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(), CONFIG_STRING(m_config, "service.backend_host").c_str(), CONFIG_STRING(m_config, "service.backend_port").c_str(), m_config->getConfigFile().c_str());
+		}
+	}
+}
 void NetworkPluginServer::handleUserCreated(User *user) {
 	Client *c = getFreeClient();
 	if (!c) {
 		user->handleDisconnected("Internal Server Error, please reconnect.");
 		return;
+	}
 	user->setData(c);
 	c->users.push_back(user);
 // 	UserInfo userInfo = user->getUserInfo();
 	user->onReadyToConnect.connect(boost::bind(&NetworkPluginServer::handleUserReadyToConnect, this, user));
 	user->onPresenceChanged.connect(boost::bind(&NetworkPluginServer::handleUserPresenceChanged, this, user, _1));
 	user->onRoomJoined.connect(boost::bind(&NetworkPluginServer::handleRoomJoined, this, user, _1, _2, _3));
 	user->onRoomLeft.connect(boost::bind(&NetworkPluginServer::handleRoomLeft, this, user, _1));
+}
 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);

src/pbnetwork.proto

➞

Show inline comments

@@ @@ -47,53 +47,54 @@ message Room { @@
+}
 message Participant {
 	required string userName = 1;
 	required string room = 2;
 	required string nickname = 3;
 	required int32 flag = 4;
 	required int32 status = 5;
 	optional string statusMessage = 6;
 	optional string newname = 7;
+}
 message VCard {
 	required string userName = 1;
 	required string buddyName = 2;
 	required int32 id = 3;
 	optional string fullname = 4;
 	optional string nickname = 5;
 	optional bytes photo = 6;
+}
 message Status {
 	required string userName = 1;
 	required int32 status = 3;
 	optional string statusMessage = 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_JOIN_ROOM				= 11;
 		TYPE_LEAVE_ROOM				= 12;
 		TYPE_PARTICIPANT_CHANGED	= 13;
 		TYPE_ROOM_NICKNAME_CHANGED	= 14;
 		TYPE_ROOM_SUBJECT_CHANGED	= 15;
 		TYPE_VCARD					= 16;
 		TYPE_STATUS_CHANGED			= 17;
 		TYPE_BUDDY_TYPING			= 18;
 		TYPE_BUDDY_STOPPED_TYPING	= 19;
 		TYPE_BUDDY_TYPED			= 20;
 		TYPE_AUTH_REQUEST			= 21;
+	}
 	required Type type = 1;
 	optional bytes payload = 2;
+}
+;
@@ \ No newline at end of file @@

src/rostermanager.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 "transport/rostermanager.h"
 #include "transport/rosterstorage.h"
 #include "transport/storagebackend.h"
 #include "transport/buddy.h"
 #include "transport/usermanager.h"
 #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->getNetworkFactories()->getTimerFactory()->createTimer(1000);
 	m_RIETimer = m_component->getNetworkFactories()->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());
 	item.setSubscription(Swift::RosterItemPayload::Both);
 	payload->addItem(item);
 	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));
+	}
@@ @@ -112,85 +109,209 @@ void RosterManager::setBuddyCallback(Buddy *buddy) { @@
 	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::storeBuddy(Buddy *buddy) {
 	if (m_rosterStorage) {
 		m_rosterStorage->storeBuddy(buddy);
+	}
+}
 void RosterManager::handleBuddyRosterPushResponse(Swift::ErrorPayload::ref error, const std::string &key) {
 	if (m_buddies[key] != NULL) {
 		m_buddies[key]->handleBuddyChanged();
+	}
+}
 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.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());
 	// For server mode the subscription changes are handler in rosterresponder.cpp
 	// using roster pushes.
 	if (m_component->inServerMode()) {
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo(presence->getFrom());
 		response->setFrom(presence->getTo());
 		Buddy *buddy = getBuddy(Buddy::JIDToLegacyName(presence->getTo()));
 		if (buddy) {
 			switch (presence->getType()) {
 				case Swift::Presence::Subscribe:
 					response->setType(Swift::Presence::Subscribed);
 					break;
 				case Swift::Presence::Unsubscribe:
 					response->setType(Swift::Presence::Unsubscribed);
 					break;
 				default:
 					return;
+			}
 			m_component->getStanzaChannel()->sendPresence(response);
+		}
 		else {
 			BuddyInfo buddyInfo;
 			switch (presence->getType()) {
 				// buddy is not in roster, so add him
 				case Swift::Presence::Subscribe:
 					buddyInfo.id = -1;
 					buddyInfo.alias = "";
 					buddyInfo.legacyName = Buddy::JIDToLegacyName(presence->getTo());
 					buddyInfo.subscription = "both";
 					buddyInfo.flags = 0;
 					buddy = m_component->getFactory()->createBuddy(this, buddyInfo);
 					setBuddy(buddy);
 					onBuddyAdded(buddy);
 					response->setType(Swift::Presence::Subscribed);
 					break;
 				// buddy is already there, so nothing to do, just answer
 				case Swift::Presence::Unsubscribe:
 					response->setType(Swift::Presence::Unsubscribed);
 					break;
 				default:
 					return;
+			}
 			m_component->getStanzaChannel()->sendPresence(response);
+		}
+	}
 	else {
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo(presence->getFrom());
 		response->setFrom(presence->getTo());
 		Buddy *buddy = getBuddy(Buddy::JIDToLegacyName(presence->getTo()));
 		if (buddy) {
 			switch (presence->getType()) {
 				// buddy is already there, so nothing to do, just answer
 				case Swift::Presence::Subscribe:
 					response->setType(Swift::Presence::Subscribed);
 					break;
 				// remove buddy
 				case Swift::Presence::Unsubscribe:
 					response->setType(Swift::Presence::Unsubscribed);
 					onBuddyRemoved(buddy);
 					break;
 				// just send response
 				case Swift::Presence::Unsubscribed:
 					response->setType(Swift::Presence::Unsubscribe);
 					break;
 				// just send response
 				case Swift::Presence::Subscribed:
 					response->setType(Swift::Presence::Subscribe);
 					break;
 				default:
 					return;
+			}
+		}
 		else {
 			BuddyInfo buddyInfo;
 			switch (presence->getType()) {
 				// buddy is not in roster, so add him
 				case Swift::Presence::Subscribe:
 					buddyInfo.id = -1;
 					buddyInfo.alias = "";
 					buddyInfo.legacyName = Buddy::JIDToLegacyName(presence->getTo());
 					buddyInfo.subscription = "both";
 					buddyInfo.flags = 0;
 					buddy = m_component->getFactory()->createBuddy(this, buddyInfo);
 					setBuddy(buddy);
 					onBuddyAdded(buddy);
 					response->setType(Swift::Presence::Subscribed);
 					break;
 				// buddy is already there, so nothing to do, just answer
 				case Swift::Presence::Unsubscribe:
 					response->setType(Swift::Presence::Unsubscribed);
 					break;
 				// just send response
 				case Swift::Presence::Unsubscribed:
 					response->setType(Swift::Presence::Unsubscribe);
 					break;
 				// just send response
 				case Swift::Presence::Subscribed:
 					response->setType(Swift::Presence::Subscribe);
 					break;
 				default:
 					return;
+			}
+		}
 		m_component->getStanzaChannel()->sendPresence(response);
 		// We have to act as buddy and send its subscribe/unsubscribe just to be sure...
 		switch (response->getType()) {
 			case Swift::Presence::Unsubscribed:
 				response->setType(Swift::Presence::Unsubscribe);
 				m_component->getStanzaChannel()->sendPresence(response);
 				break;
 			case Swift::Presence::Subscribed:
 				response->setType(Swift::Presence::Subscribe);
 				m_component->getStanzaChannel()->sendPresence(response);
 				break;
 			default:
 				break;
+		}
+	}
+}
 void RosterManager::setStorageBackend(StorageBackend *storageBackend) {
 	if (m_rosterStorage || !storageBackend) {
 		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());
 		item.setSubscription(Swift::RosterItemPayload::Both);
 		payload->addItem(item);
+	}
 	return payload;
+}
+}

0 comments (0 inline, 0 general)