libtransport.git Changeset - 0d320a2990d7

Changeset - 0d320a2990d7

Parent rev.

Child rev.

[Not reviewed]

0 6 0

Jan Kaluza - 14 years ago 2011-08-23 08:02:41
hanzz.k@gmail.com

Remove from memory also users which disconnected because of error

6 files changed with 25 insertions and 46 deletions:

backends/libpurple/main.cpp

include/transport/buddy.h

include/transport/rostermanager.h

src/buddy.cpp

src/networkpluginserver.cpp

src/rostermanager.cpp

0 comments (0 inline, 0 general)

backends/libpurple/main.cpp

➞

Show inline comments

@@ @@ -208,97 +208,97 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 			m_sessions[user] = account;
 			m_accounts[account] = user;
 			// Default avatar
 			char* contents;
 			gsize length;
 			gboolean ret = false;
 			if (!CONFIG_STRING(config, "backend.avatars_directory").empty()) {
 				std::string f = CONFIG_STRING(config, "backend.avatars_directory") + "/" + legacyName;
 				ret = g_file_get_contents (f.c_str(), &contents, &length, NULL);
+			}
 			if (!CONFIG_STRING(config, "backend.default_avatar").empty() && !ret) {
 				ret = g_file_get_contents (CONFIG_STRING(config, "backend.default_avatar").c_str(),
 											&contents, &length, NULL);
+			}
 			if (ret) {
 				purple_buddy_icons_set_account_icon(account, (guchar *) contents, length);
+			}
 			purple_account_set_password(account, password.c_str());
 			purple_account_set_enabled(account, "spectrum", TRUE);
 			purple_account_set_bool(account, "custom_smileys", FALSE);
 			purple_account_set_bool(account, "direct_connect", FALSE);
 			for (std::map<std::string,std::string>::const_iterator it = config->getUnregistered().begin();
 				it != config->getUnregistered().end(); it++) {
 				if ((*it).first.find("purple.") == 0) {
 					std::string key = (*it).first.substr((*it).first.find(".") + 1);
 					LOG4CXX_INFO(logger, "Setting account string '" << key << "'='" << (*it).second << "'");
 					purple_account_set_string(account, key.c_str(), (*it).second.c_str());
+				}
+			}
 			purple_account_set_privacy_type(account, PURPLE_PRIVACY_DENY_USERS);
 			const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AVAILABLE);
 			if (status_type != NULL) {
 				purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, NULL);
+			}
+		}
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 // 				VALGRIND_DO_LEAK_CHECK;
-				m_sessions[user] = NULL;
+				m_sessions.erase(user);
 				purple_account_set_enabled(account, "spectrum", FALSE);
 				// Remove conversations.
 				// This has to be called before m_account->ui_data = NULL;, because it uses
 				// ui_data to call SpectrumMessageHandler::purpleConversationDestroyed() callback.
 				GList *iter;
 				for (iter = purple_get_conversations(); iter; ) {
 					PurpleConversation *conv = (PurpleConversation*) iter->data;
 					iter = iter->next;
 					if (purple_conversation_get_account(conv) == account)
 						purple_conversation_destroy(conv);
+				}
 				g_free(account->ui_data);
 				account->ui_data = NULL;
 				m_accounts.erase(account);
 				purple_notify_close_with_handle(account);
 				purple_request_close_with_handle(account);
 				purple_accounts_remove(account);
 				GSList *buddies = purple_find_buddies(account, NULL);
 				while(buddies) {
 					PurpleBuddy *b = (PurpleBuddy *) buddies->data;
 					purple_blist_remove_buddy(b);
 					buddies = g_slist_delete_link(buddies, buddies);
+				}
 				/* Remove any open conversation for this account */
 				for (GList *it = purple_get_conversations(); it; ) {
 					PurpleConversation *conv = (PurpleConversation *) it->data;
 					it = it->next;
 					if (purple_conversation_get_account(conv) == account)
 						purple_conversation_destroy(conv);
+				}
 				/* Remove this account's pounces */
 					// purple_pounce_destroy_all_by_account(account);
 				/* This will cause the deletion of an old buddy icon. */
 				purple_buddy_icons_set_account_icon(account, NULL, 0);
 				purple_account_destroy(account);
 				// force returning of memory chunks allocated by libxml2 to kernel
 				malloc_trim(0);
 // 				VALGRIND_DO_LEAK_CHECK;
+			}
 	g_free(newline);
 	g_free(xhtml);
 	g_free(xhtml_linkified);
 	g_free(strip);
 	// AIM and XMPP adds <body>...</body> here...
 	if (xhtml_.find("<body>") == 0) {
 		xhtml_ = xhtml_.substr(6);
 		if (xhtml_.find("</body>") != std::string::npos) {
 			xhtml_ = xhtml_.substr(0, xhtml_.find("</body>"));
+		}
+	}
 	if (xhtml_ == message_) {
 		xhtml_ = "";
+	}
 // 	LOG4CXX_INFO(logger, "Received message body='" << message_ << "' xhtml='" << xhtml_ << "'");
 	np->handleMessage(np->m_accounts[account], w, message_, "", xhtml_);
+}
 static PurpleConversationUiOps conversation_ui_ops =
+{
 	NULL,
 	NULL,
 	NULL,//conv_write_chat,                              /* write_chat           */
 	conv_write_im,             /* write_im             */
 	NULL,//conv_write_conv,           /* write_conv           */
 	NULL,//conv_chat_add_users,       /* chat_add_users       */
 	NULL,//conv_chat_rename_user,     /* chat_rename_user     */
 	NULL,//conv_chat_remove_users,    /* chat_remove_users    */
 	NULL,//pidgin_conv_chat_update_user,     /* chat_update_user     */
 	NULL,//pidgin_conv_present_conversation, /* present              */
 	NULL,//pidgin_conv_has_focus,            /* has_focus            */
 	NULL,//pidgin_conv_custom_smiley_add,    /* custom_smiley_add    */
 	NULL,//pidgin_conv_custom_smiley_write,  /* custom_smiley_write  */
 	NULL,//pidgin_conv_custom_smiley_close,  /* custom_smiley_close  */
 	NULL,//pidgin_conv_send_confirm,         /* send_confirm         */
 	NULL,
 	NULL,
 	NULL,
 	NULL
 };
 static void connection_report_disconnect(PurpleConnection *gc, PurpleConnectionError reason, const char *text){
 	PurpleAccount *account = purple_connection_get_account(gc);
 	np->handleDisconnected(np->m_accounts[account], purple_account_get_username(account), (int) reason, text ? text : "");
 	np->handleLogoutRequest(np->m_accounts[account], purple_account_get_username(account));
+}
 static PurpleConnectionUiOps conn_ui_ops =
+{
 	NULL,
 	NULL,
 	NULL,//connection_disconnected,
 	NULL,
 	NULL,
 	NULL,
 	NULL,
 	connection_report_disconnect,
 	NULL,
 	NULL,
 	NULL
 };
 static void *notify_user_info(PurpleConnection *gc, const char *who, PurpleNotifyUserInfo *user_info) {
 	std::string name(who);
 	std::transform(name.begin(), name.end(), name.begin(),(int(*)(int)) std::tolower);
 	size_t pos = name.find("/");
 	if (pos != std::string::npos)
 		name.erase((int) pos, name.length() - (int) pos);
 	PurpleAccount *account = purple_connection_get_account(gc);
 	GList *vcardEntries = purple_notify_user_info_get_entries(user_info);
 	PurpleNotifyUserInfoEntry *vcardEntry;
 	std::string firstName;
 	std::string lastName;
 	std::string fullName;
 	std::string nickname;
 	std::string header;
 	std::string label;
 	Swift::ByteArray photo;
 	while (vcardEntries) {
 		vcardEntry = (PurpleNotifyUserInfoEntry *)(vcardEntries->data);
 		if (purple_notify_user_info_entry_get_label(vcardEntry) && purple_notify_user_info_entry_get_value(vcardEntry)){
 			label = purple_notify_user_info_entry_get_label(vcardEntry);
 			if (label == "Given Name" || label == "First Name") {
 				firstName = purple_notify_user_info_entry_get_value(vcardEntry);
+			}
 			else if (label == "Family Name" || label == "Last Name") {
 				lastName = purple_notify_user_info_entry_get_value(vcardEntry);
+			}
 			else if (label=="Nickname" || label == "Nick") {
 				nickname = purple_notify_user_info_entry_get_value(vcardEntry);

include/transport/buddy.h

➞

Show inline comments

 /**
  * XMPP - libpurple transport
+ *
  * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #pragma once
 #include <string>
 #include <algorithm>
 #include "transport/transport.h"
 #include "Swiften/Swiften.h"
 namespace Transport {
 class RosterManager;
 typedef enum { 	BUDDY_NO_FLAG = 0,
 				BUDDY_JID_ESCAPING = 2,
 				BUDDY_IGNORE = 4
 				BUDDY_IGNORE = 4,
 				BUDDY_BLOCKED = 8,
 			} BuddyFlag;
 /// Represents one legacy network Buddy.
 class Buddy {
 	public:
 		/// Constructor.
 		/// \param rosterManager RosterManager associated with this buddy.
 		/// \param id ID which identifies the buddy in database or -1 if it's new buddy which is
 		/// not in database yet.
 		Buddy(RosterManager *rosterManager, long id = -1);
 		/// Destructor
 		virtual ~Buddy();
 		/// Sets unique ID used to identify this buddy by StorageBackend.
 		/// This is set
 		/// by RosterStorage class once the buddy is stored into database or when the
 		/// buddy is loaded from database.
 		/// You should not need to set this ID manually.
 		/// \param id ID
 		void setID(long id);
 		/// Returns unique ID used to identify this buddy by StorageBackend.
 		/// \return ID which identifies the buddy in database or -1 if it's new buddy which is
 		/// not in database yet.
 		long getID();
 		/// Returns full JID of this buddy.
 		/// \param hostname hostname used as domain in returned JID
 		/// \return full JID of this buddy
 		const Swift::JID &getJID();
 		/// Generates whole Presennce stanza with current status/show for this buddy.
 		/// Presence stanza does not containt "to" attribute, it has to be added manually.
 		/// \param features features used in returned stanza
 		/// \param only_new if True, this function returns Presence stanza only if it's different
 		/// than the previously generated one.
 		/// \return Presence stanza or NULL.
 		Swift::Presence::ref generatePresenceStanza(int features, bool only_new = false);
 		/// Marks this buddy as available.
 		void setOnline();
 		/// Marks this buddy as offline.
 		void setOffline();
 		void setBlocked(bool block) {
 			m_blocked = block;
 			if (block)
 				m_flags = (BuddyFlag) (m_flags | BUDDY_BLOCKED);
 			else
 				m_flags = (BuddyFlag) (m_flags & ~BUDDY_BLOCKED);
+		}
 		bool isBlocked() {
-			return m_blocked;
+			return m_flags & BUDDY_BLOCKED;
+		}
 		/// Returns true if this buddy is marked as available/online.
 		/// \return true if this buddy is marked as available/online.
 		bool isOnline();
 		/// Sets current subscription.
 		/// \param subscription "to", "from", "both", "ask"
 		void setSubscription(const std::string &subscription);
 		/// Returns current subscription
 		/// \return subscription "to", "from", "both", "ask"
-		const std::string &getSubscription();
 		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 associated with this buddy.
 		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();
 		/// This method should be called whenever some information returned by virtual functions changes.
 		/// This method sends presence to XMPP user.
 		void handleBuddyChanged();
 		/// Handles VCard from legacy network and forwards it to XMPP user.
 		/// \param id ID used in IQ-result.
 		/// \param vcard VCard which will be sent.
 		void handleVCardReceived(const std::string &id, Swift::VCard::ref vcard);
 		/// This signal is emitted when buddyChanged method is called.
 		boost::signal<void ()> onBuddyChanged;
 		/// 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.
 		virtual std::string getIconHash() = 0;
 		/// Returns legacy name of buddy from JID.
 		/// \param jid Jabber ID.
 		/// \return legacy name of buddy from JID.
 		static std::string JIDToLegacyName(const Swift::JID &jid);
 	private:
 		void generateJID();
 		long m_id;
 		bool m_online;
 		bool m_blocked;
 		std::string m_subscription;
 // 		Swift::Presence::ref m_lastPresence;
 		Swift::JID m_jid;
 		BuddyFlag m_flags;
 		RosterManager *m_rosterManager;
 };
+}

include/transport/rostermanager.h

➞

Show inline comments

@@ @@ -35,75 +35,77 @@ 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 handleBuddyChanged(Buddy *buddy);
 		void handleSubscription(Swift::Presence::ref presence);
 		void sendBuddyRosterPush(Buddy *buddy);
 		void sendBuddySubscribePresence(Buddy *buddy);
 		void sendCurrentPresences(const Swift::JID &to);
 		void sendCurrentPresence(const Swift::JID &from, const Swift::JID &to);
 		void sendUnavailablePresences(const Swift::JID &to);
 	private:
 		void setBuddyCallback(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;
 };
+}

src/buddy.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/buddy.h"
 #include "transport/rostermanager.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "Swiften/Elements/BlockPayload.h"
 namespace Transport {
-Buddy::Buddy(RosterManager *rosterManager, long id) : m_id(id), m_online(false), m_blocked(false), m_subscription("ask"), m_flags(BUDDY_NO_FLAG), m_rosterManager(rosterManager){
 Buddy::Buddy(RosterManager *rosterManager, long id) : m_id(id), m_flags(BUDDY_NO_FLAG), m_rosterManager(rosterManager){
 // 	m_rosterManager->setBuddy(this);
+}
 Buddy::~Buddy() {
 // 	m_rosterManager->unsetBuddy(this);
+}
 void Buddy::generateJID() {
 	m_jid = Swift::JID();
 	m_jid = Swift::JID(getSafeName(), m_rosterManager->getUser()->getComponent()->getJID().toString(), "bot");
+}
 void Buddy::setID(long id) {
 	m_id = id;
+}
 long Buddy::getID() {
 	return m_id;
+}
 void Buddy::setFlags(BuddyFlag flags) {
 	m_flags = flags;
 	generateJID();
+}
 BuddyFlag Buddy::getFlags() {
 	return m_flags;
+}
 const Swift::JID &Buddy::getJID() {
 	if (!m_jid.isValid()) {
 		generateJID();
+	}
 	return m_jid;
+}
 void Buddy::setOnline() {
 	m_online = true;
+}
 void Buddy::setOffline() {
 	m_online = false;
 // 	m_lastPresence = Swift::Presence::ref();
+}
 bool Buddy::isOnline() {
 	return m_online;
+}
 void Buddy::setSubscription(const std::string &subscription) {
 	m_subscription = subscription;
+// 	m_subscription = subscription;
+}
 const std::string &Buddy::getSubscription() {
 	return m_subscription;
 const std::string Buddy::getSubscription() {
 	return "ask";
+}
 Swift::Presence::ref Buddy::generatePresenceStanza(int features, bool only_new) {
 	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*/) {
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::VCardUpdate (getIconHash())));
 // 		}
-		if (m_blocked) {
+		if (isBlocked()) {
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::BlockPayload ()));
+		}
+	}
 // 	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::handleBuddyChanged() {
 	Swift::Presence::ref presence = generatePresenceStanza(255);
 	if (presence) {
 		m_rosterManager->getUser()->getComponent()->getStanzaChannel()->sendPresence(presence);
+	}
-	onBuddyChanged();
+	m_rosterManager->handleBuddyChanged(this);
+}
 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/networkpluginserver.cpp

➞

Show inline comments

 	} else if ( pid < 0 ) {
 		// fork failed
+	}
 	free(p);
 	return pid;
+}
 static void SigCatcher(int n) {
 	pid_t result;
 	int status;
 	// Read exit code from all children to not have zombies arround
 	// WARNING: Do not put LOG4CXX_ here, because it can lead to deadlock
 	while ((result = waitpid(0, &status, WNOHANG)) > 0) {
 		if (result != 0) {
 			if (WIFEXITED(status)) {
 				if (WEXITSTATUS(status) != 0) {
 // 					LOG4CXX_ERROR(logger, "Backend can not be started, exit_code=" << WEXITSTATUS(status));
+				}
+			}
 			else {
 // 				LOG4CXX_ERROR(logger, "Backend can not be started");
+			}
+		}
+	}
+}
 static void handleBuddyPayload(LocalBuddy *buddy, const pbnetwork::Buddy &payload) {
 	buddy->setName(payload.buddyname());
 	// Set alias only if it's not empty. Backends are allowed to send empty alias if it has
 	// not changed.
 	if (!payload.alias().empty()) {
 		buddy->setAlias(payload.alias());
+	}
 	// Change groups if it's not empty. The same as above...
 	if (!payload.groups().empty()) {
 		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());
 	buddy->setBlocked(payload.blocked());
+}
 NetworkPluginServer::NetworkPluginServer(Component *component, Config *config, UserManager *userManager) {
 	std::cout << "BUDDY " << sizeof(Buddy) << "\n";
 	m_userManager = userManager;
 	m_config = config;
 	m_component = component;
 	m_isNextLongRun = false;
 	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->getNetworkFactories()->getTimerFactory()->createTimer(20000);
 	m_pingTimer->onTick.connect(boost::bind(&NetworkPluginServer::pingTimeout, this));
 	m_pingTimer->start();
 	m_collectTimer = component->getNetworkFactories()->getTimerFactory()->createTimer(2*3600000);
 	m_collectTimer->onTick.connect(boost::bind(&NetworkPluginServer::collectBackend, this));
 	m_collectTimer->start();
 	m_vcardResponder = new VCardResponder(component->getIQRouter(), component->getNetworkFactories(), userManager);
 	m_vcardResponder->onVCardRequired.connect(boost::bind(&NetworkPluginServer::handleVCardRequired, this, _1, _2, _3));
 	m_vcardResponder->onVCardUpdated.connect(boost::bind(&NetworkPluginServer::handleVCardUpdated, this, _1, _2));
 	m_vcardResponder->start();
 	m_rosterResponder = new RosterResponder(component->getIQRouter(), userManager);
 	m_rosterResponder->onBuddyAdded.connect(boost::bind(&NetworkPluginServer::handleBuddyAdded, this, _1, _2));
 	m_rosterResponder->onBuddyRemoved.connect(boost::bind(&NetworkPluginServer::handleBuddyRemoved, this, _1));
 	m_rosterResponder->onBuddyUpdated.connect(boost::bind(&NetworkPluginServer::handleBuddyUpdated, this, _1, _2));
 	m_rosterResponder->start();
 	m_blockResponder = new BlockResponder(component->getIQRouter(), userManager);
 	m_blockResponder->onBlockToggled.connect(boost::bind(&NetworkPluginServer::handleBlockToggled, this, _1));
 	m_blockResponder->start();
 	m_server = Swift::BoostConnectionServer::create(Swift::HostAddress(CONFIG_STRING(m_config, "service.backend_host")), boost::lexical_cast<int>(CONFIG_STRING(m_config, "service.backend_port")), component->getNetworkFactories()->getIOServiceThread()->getIOService(), component->m_loop);
 	m_server->onNewConnection.connect(boost::bind(&NetworkPluginServer::handleNewClientConnection, this, _1));
 	m_server->start();
 	LOG4CXX_INFO(logger, "Listening on host " << CONFIG_STRING(m_config, "service.backend_host") << " port " << CONFIG_STRING(m_config, "service.backend_port"));
 	signal(SIGCHLD, SigCatcher);
 	exec_(CONFIG_STRING(m_config, "service.backend"), CONFIG_STRING(m_config, "service.backend_host").c_str(), CONFIG_STRING(m_config, "service.backend_port").c_str(), m_config->getConfigFile().c_str());
+}
 NetworkPluginServer::~NetworkPluginServer() {
 	m_pingTimer->stop();
 	m_server->stop();
 	m_server.reset();
 	delete m_component->m_factory;
 	delete m_vcardResponder;

src/rostermanager.cpp

➞

Show inline comments

@@ @@ -55,102 +55,104 @@ RosterManager::~RosterManager() { @@
 	sendUnavailablePresences(m_user->getJID().toBare());
 	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {
 		Buddy *buddy = (*it).second;
 		if (!buddy) {
 			continue;
+		}
 		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) {
 	if (!m_user->isConnected())
 		return;
 	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::sendBuddySubscribePresence(Buddy *buddy) {
 	Swift::Presence::ref response = Swift::Presence::create();
 	response->setTo(m_user->getJID());
 	response->setFrom(buddy->getJID());
 	response->setType(Swift::Presence::Subscribe);
 // 	TODO: NICKNAME
 	m_component->getStanzaChannel()->sendPresence(response);
+}
 void RosterManager::setBuddyCallback(Buddy *buddy) {
 	m_setBuddyTimer->onTick.disconnect(boost::bind(&RosterManager::setBuddyCallback, this, buddy));
 void RosterManager::handleBuddyChanged(Buddy *buddy) {
 	if (m_rosterStorage) {
-		buddy->onBuddyChanged.connect(boost::bind(&RosterStorage::storeBuddy, m_rosterStorage, buddy));
+		m_rosterStorage->storeBuddy(buddy);
+	}
+}
 void RosterManager::setBuddyCallback(Buddy *buddy) {
 	m_setBuddyTimer->onTick.disconnect(boost::bind(&RosterManager::setBuddyCallback, this, buddy));
 	LOG4CXX_INFO(logger, "Associating buddy " << buddy->getName() << " with " << m_user->getJID().toString());
 	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();
 			// Send RIE only if there's resource which supports it.
 			Swift::JID jidWithRIE = m_user->getJIDWithFeature("http://jabber.org/protocol/rosterx");
 			if (jidWithRIE.isValid()) {
 				m_RIETimer->start();
+			}
 			else {
 				sendBuddySubscribePresence(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();
+	}
+}
 					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);
 					onBuddyRemoved(buddy);
 					break;
 				// just send response
 				case Swift::Presence::Unsubscribed:
 					response->setType(Swift::Presence::Unsubscribe);
 					break;
 				// just send response
 				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);
 		LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Adding cached buddy " << buddy->getName() << " fom database");
 		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;
 		if (!buddy) {
 			continue;
+		}
 		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;
+}
 void RosterManager::sendCurrentPresences(const Swift::JID &to) {
 	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {
 		Buddy *buddy = (*it).second;
 		if (!buddy) {
 			continue;
+		}
 		Swift::Presence::ref presence = buddy->generatePresenceStanza(255);
 		if (presence) {
 			presence->setTo(to);
 			m_component->getStanzaChannel()->sendPresence(presence);
+		}
+	}
+}
 void RosterManager::sendCurrentPresence(const Swift::JID &from, const Swift::JID &to) {
 	Buddy *buddy = getBuddy(Buddy::JIDToLegacyName(from));
 	if (buddy) {
 		Swift::Presence::ref presence = buddy->generatePresenceStanza(255);
 		if (presence) {
 			presence->setTo(to);
 			m_component->getStanzaChannel()->sendPresence(presence);
+		}
+	}
 	else {
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo(to);

0 comments (0 inline, 0 general)