libtransport.git Changeset - 505ea8301ce8

Changeset - 505ea8301ce8

Parent rev.

Child rev.

[Not reviewed]

0 6 0

HanzZ - 13 years ago 2013-01-25 13:26:49
hanzz.k@gmail.com

Fixed adding/removing contacts in gateway mode

6 files changed with 43 insertions and 3 deletions:

backends/libpurple/main.cpp

include/transport/networkpluginserver.h

src/networkpluginserver.cpp

src/rostermanager.cpp

src/tests/user.cpp

src/user.cpp

0 comments (0 inline, 0 general)

backends/libpurple/main.cpp

➞

Show inline comments

@@ @@ -456,192 +456,193 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
+					}
 					else if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_CHAT) {
 						purple_conv_chat_send_wrapped(PURPLE_CONV_CHAT_WRAPPED(conv), xhtml.c_str());
+					}
+				}
+			}
+		}
 		void handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				std::string name = legacyName;
 				if (CONFIG_STRING(config, "service.protocol") == "any" && legacyName.find("prpl-") == 0) {
 					name = name.substr(name.find(".") + 1);
+				}
 				m_vcards[user + name] = id;
 				if (CONFIG_BOOL(config, "backend.no_vcard_fetch") && name != purple_account_get_username_wrapped(account)) {
 					PurpleNotifyUserInfo *user_info = purple_notify_user_info_new_wrapped();
 					notify_user_info(purple_account_get_connection_wrapped(account), name.c_str(), user_info);
 					purple_notify_user_info_destroy_wrapped(user_info);
+				}
 				else {
 					serv_get_info_wrapped(purple_account_get_connection_wrapped(account), name.c_str());
+				}
+			}
+		}
 		void handleVCardUpdatedRequest(const std::string &user, const std::string &image, const std::string &nickname) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				purple_account_set_alias_wrapped(account, nickname.c_str());
 #if PURPLE_MAJOR_VERSION >= 2 && PURPLE_MINOR_VERSION >= 7
 				purple_account_set_public_alias_wrapped(account, nickname.c_str(), NULL, NULL);
 #endif
 				gssize size = image.size();
 				// this will be freed by libpurple
 				guchar *photo = (guchar *) g_malloc(size * sizeof(guchar));
 				memcpy(photo, image.c_str(), size);
 				if (!photo)
 					return;
 				purple_buddy_icons_set_account_icon_wrapped(account, photo, size);
+			}
+		}
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<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_wrapped(account, buddyName.c_str());
 				if (buddy) {
 					purple_account_remove_buddy_wrapped(account, buddy, purple_buddy_get_group_wrapped(buddy));
 					purple_blist_remove_buddy_wrapped(buddy);
+				}
+			}
+		}
 		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups_) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				std::string groups = groups_.empty() ? "" : groups_[0];
 				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_wrapped(account, buddyName.c_str());
 				if (buddy) {
 					if (getAlias(buddy) != alias) {
 						purple_blist_alias_buddy_wrapped(buddy, alias.c_str());
 						purple_blist_server_alias_buddy_wrapped(buddy, alias.c_str());
 						serv_alias_buddy_wrapped(buddy);
+					}
 					PurpleGroup *group = purple_find_group_wrapped(groups.c_str());
 					if (!group) {
 						group = purple_group_new_wrapped(groups.c_str());
+					}
 					purple_blist_add_contact_wrapped(purple_buddy_get_contact_wrapped(buddy), group ,NULL);
+				}
 				else {
 					PurpleBuddy *buddy = purple_buddy_new_wrapped(account, buddyName.c_str(), alias.c_str());
 					// Add newly created buddy to legacy network roster.
 					PurpleGroup *group = purple_find_group_wrapped(groups.c_str());
 					if (!group) {
 						group = purple_group_new_wrapped(groups.c_str());
+					}
 					purple_blist_add_buddy_wrapped(buddy, NULL, group ,NULL);
 					purple_account_add_buddy_wrapped(account, buddy);
 					LOG4CXX_INFO(logger, "Adding new buddy " << buddyName.c_str() << " to legacy network roster");
+				}
+			}
+		}
 		void handleBuddyBlockToggled(const std::string &user, const std::string &buddyName, bool blocked) {
 			if (CONFIG_BOOL(config, "service.enable_privacy_lists")) {
 				PurpleAccount *account = m_sessions[user];
 				if (account) {
 					if (blocked) {
 						purple_privacy_deny_wrapped(account, buddyName.c_str(), FALSE, FALSE);
+					}
 					else {
 						purple_privacy_allow_wrapped(account, buddyName.c_str(), FALSE, FALSE);
+					}
+				}
+			}
+		}
 		void handleTypingRequest(const std::string &user, const std::string &buddyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				LOG4CXX_INFO(logger, user << ": sending typing notify to " << buddyName);
 				serv_send_typing_wrapped(purple_account_get_connection_wrapped(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_wrapped(purple_account_get_connection_wrapped(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_wrapped(purple_account_get_connection_wrapped(account), buddyName.c_str(), PURPLE_NOT_TYPING);
+			}
+		}
 		void handleAttentionRequest(const std::string &user, const std::string &buddyName, const std::string &message) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				purple_prpl_send_attention_wrapped(purple_account_get_connection_wrapped(account), buddyName.c_str(), 0);
+			}
+		}
 		void handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &pasword) {
 			PurpleAccount *account = m_sessions[user];
 			if (!account) {
 				return;
+			}
 			PurpleConnection *gc = purple_account_get_connection_wrapped(account);
 			GHashTable *comps = NULL;
 			// Check if the PurpleChat is not stored in buddy list
 			PurpleChat *chat = purple_blist_find_chat_wrapped(account, room.c_str());
 			if (chat) {
 				comps = purple_chat_get_components_wrapped(chat);
+			}
 			else if (PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info_defaults != NULL) {
 				comps = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info_defaults(gc, room.c_str());
+			}
 			LOG4CXX_INFO(logger, user << ": Joining the room " << room);
 			if (comps) {
 				serv_join_chat_wrapped(gc, comps);
 				g_hash_table_destroy(comps);
+			}
+		}
 		void handleLeaveRoomRequest(const std::string &user, const std::string &room) {
 			PurpleAccount *account = m_sessions[user];
 			if (!account) {
 				return;
+			}
 			PurpleConversation *conv = purple_find_conversation_with_account_wrapped(PURPLE_CONV_TYPE_CHAT, room.c_str(), account);
 			purple_conversation_destroy_wrapped(conv);
+		}
 		void handleFTStartRequest(const std::string &user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID) {
 			PurpleXfer *xfer = m_unhandledXfers[user + fileName + buddyName];
 			if (xfer) {
 				m_unhandledXfers.erase(user + fileName + buddyName);
 				FTData *ftData = (FTData *) xfer->ui_data;
 				ftData->id = ftID;
 				m_xfers[ftID] = xfer;
 				purple_xfer_request_accepted_wrapped(xfer, fileName.c_str());
 				purple_xfer_ui_ready_wrapped(xfer);
+			}
+		}
 		void handleFTFinishRequest(const std::string &user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID) {

include/transport/networkpluginserver.h

➞

Show inline comments

@@ @@ -34,141 +34,143 @@ @@
 namespace Transport {
 class UserManager;
 class User;
 class Component;
 class Buddy;
 class LocalBuddy;
 class Config;
 class NetworkConversation;
 class VCardResponder;
 class RosterResponder;
 class BlockResponder;
 class DummyReadBytestream;
 class AdminInterface;
 class DiscoItemsResponder;
 class NetworkPluginServer {
 	public:
 		struct Backend {
 			int pongReceived;
 			std::list<User *> users;
 			Swift::SafeByteArray data;
 			boost::shared_ptr<Swift::Connection> connection;
 			unsigned long res;
 			unsigned long init_res;
 			unsigned long shared;
 			bool acceptUsers;
 			bool longRun;
 			bool willDie;
 			std::string id;
 		};
 		NetworkPluginServer(Component *component, Config *config, UserManager *userManager, FileTransferManager *ftManager, DiscoItemsResponder *discoItemsResponder);
 		virtual ~NetworkPluginServer();
 		void start();
 		void setAdminInterface(AdminInterface *adminInterface) {
 			m_adminInterface = adminInterface;
+		}
 		int getBackendCount() {
 			return m_clients.size();
+		}
 		const std::list<Backend *> &getBackends() {
 			return m_clients;
+		}
 		const std::vector<std::string> &getCrashedBackends() {
 			return m_crashedBackends;
+		}
 		void collectBackend();
 		bool moveToLongRunBackend(User *user);
 		void handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &message);
 	public:
 		void handleNewClientConnection(boost::shared_ptr<Swift::Connection> c);
 		void handleSessionFinished(Backend *c);
 		void handlePongReceived(Backend *c);
 		void handleDataRead(Backend *c, boost::shared_ptr<Swift::SafeByteArray> data);
 		void handleConnectedPayload(const std::string &payload);
 		void handleDisconnectedPayload(const std::string &payload);
 		void handleBuddyChangedPayload(const std::string &payload);
 		void handleBuddyRemovedPayload(const std::string &payload);
 		void handleConvMessagePayload(const std::string &payload, bool subject = false);
 		void handleConvMessageAckPayload(const std::string &payload);
 		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 handleAttentionPayload(const std::string &payload);
 		void handleStatsPayload(Backend *c, const std::string &payload);
 		void handleFTStartPayload(const std::string &payload);
 		void handleFTFinishPayload(const std::string &payload);
 		void handleFTDataPayload(Backend *b, const std::string &payload);
 		void handleQueryPayload(Backend *b, const std::string &payload);
 		void handleBackendConfigPayload(const std::string &payload);
 		void handleRoomListPayload(const std::string &payload);
 		void handleUserCreated(User *user);
 		void handleRoomJoined(User *user, const Swift::JID &who, 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 handleUserBuddyAdded(User *user, Buddy *buddy);
 		void handleUserBuddyRemoved(User *user, Buddy *buddy);
 		void handleBlockToggled(Buddy *buddy);
 		void handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> vcard);
 		void handleVCardRequired(User *user, const std::string &name, unsigned int id);
 		void handleFTStateChanged(Swift::FileTransfer::State state, const std::string &userName, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long id);
 		void handleFTAccepted(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID);
 		void handleFTRejected(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size);
 		void handleFTDataNeeded(Backend *b, unsigned long ftid);
 		void handlePIDTerminated(unsigned long pid);
 	private:
 		void send(boost::shared_ptr<Swift::Connection> &, const std::string &data);
 		void pingTimeout();
 		void sendPing(Backend *c);
 		Backend *getFreeClient(bool acceptUsers = true, bool longRun = false, bool check = false);
 		void connectWaitingUsers();
 		void loginDelayFinished();
 		UserManager *m_userManager;
 		VCardResponder *m_vcardResponder;
 		RosterResponder *m_rosterResponder;
 		BlockResponder *m_blockResponder;
 		Config *m_config;
 		boost::shared_ptr<Swift::ConnectionServer> m_server;
 		std::list<Backend *>  m_clients;
 		std::vector<unsigned long> m_pids;
 		Swift::Timer::ref m_pingTimer;
 		Swift::Timer::ref m_collectTimer;
 		Swift::Timer::ref m_loginTimer;
 		Component *m_component;
 		std::list<User *> m_waitingUsers;
 		bool m_isNextLongRun;
 		std::map<unsigned long, FileTransferManager::Transfer> m_filetransfers;
 		FileTransferManager *m_ftManager;
 		std::vector<std::string> m_crashedBackends;
 		AdminInterface *m_adminInterface;
 		bool m_startingBackend;
 		DiscoItemsResponder *m_discoItemsResponder;
 		time_t m_lastLogin;
 };
+}

src/networkpluginserver.cpp

➞

Show inline comments

@@ @@ -1160,477 +1160,509 @@ void NetworkPluginServer::pingTimeout() { @@
 #endif
+		}
 		if ((*it)->users.size() == 0) {
 			LOG4CXX_INFO(logger, "Disconnecting backend " << (*it) << " (ID=" << (*it)->id << "). There are no users.");
 			toRemove.push_back(*it);
+		}
+	}
 	BOOST_FOREACH(Backend *b, toRemove) {
 		handleSessionFinished(b);
+	}
 	m_pingTimer->start();
+}
 void NetworkPluginServer::collectBackend() {
 	// Stop accepting new users to backend with the biggest memory usage. This prevents backends
 	// which are leaking to eat whole memory by connectin new users to legacy network.
 	LOG4CXX_INFO(logger, "Collect backend called, finding backend which will be set to die");
 	unsigned long max = 0;
 	Backend *backend = NULL;
 	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {
 		if ((*it)->res > max) {
 			max = (*it)->res;
 			backend = (*it);
+		}
+	}
 	if (backend) {
 		if (m_collectTimer) {
 			m_collectTimer->start();
+		}
 		LOG4CXX_INFO(logger, "Backend " << backend << " (ID=" << backend->id << ") is set to die");
 		backend->acceptUsers = false;
+	}
+}
 bool NetworkPluginServer::moveToLongRunBackend(User *user) {
 	// Check if user has already some backend
 	Backend *old = (Backend *) user->getData();
 	if (!old) {
 		LOG4CXX_INFO(logger, "User " << user->getJID().toString() << " does not have old backend. Not moving.");
 		return true;
+	}
 	// if he's already on long run, do nothing
 	if (old->longRun) {
 		LOG4CXX_INFO(logger, "User " << user->getJID().toString() << " is already on long-running backend. Not moving.");
 		return true;
+	}
 	// Get free longrun backend, if there's no longrun backend, create one and wait
 	// for its connection
 	Backend *backend = getFreeClient(false, true);
 	if (!backend) {
 		LOG4CXX_INFO(logger, "No free long-running backend for user " << user->getJID().toString() << ". Will try later");
 		return false;
+	}
 	// old backend will trigger disconnection which has to be ignored to keep user online
 	user->setIgnoreDisconnect(true);
 	// remove user from the old backend
 	// If backend is empty, it will be collected by pingTimeout
 	old->users.remove(user);
 	// switch to new backend and connect
 	user->setData(backend);
 	backend->users.push_back(user);
 	// connect him
 	handleUserReadyToConnect(user);
 	return true;
+}
 void NetworkPluginServer::handleUserCreated(User *user) {
 	// Get free backend to handle this user or spawn new one if there's no free one.
 	Backend *c = getFreeClient();
 	// Add user to queue if there's no free backend to handle him so far.
 	if (!c) {
 		LOG4CXX_INFO(logger, "There is no backend to handle user " << user->getJID().toString() << ". Adding him to queue.");
 		m_waitingUsers.push_back(user);
 		return;
+	}
 	// Associate users with backend
 	user->setData(c);
 	c->users.push_back(user);
 	// Don't forget to disconnect these in handleUserDestroyed!!!
 	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, _4));
 	user->onRoomLeft.connect(boost::bind(&NetworkPluginServer::handleRoomLeft, this, user, _1));
 	user->getRosterManager()->onBuddyAdded.connect(boost::bind(&NetworkPluginServer::handleUserBuddyAdded, this, user, _1));
 	user->getRosterManager()->onBuddyRemoved.connect(boost::bind(&NetworkPluginServer::handleUserBuddyRemoved, 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);
 	std::string message;
 	login.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_LOGIN);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleUserPresenceChanged(User *user, Swift::Presence::ref presence) {
 	if (presence->getShow() == Swift::StatusShow::None)
 		return;
 	UserInfo userInfo = user->getUserInfo();
 	pbnetwork::Status status;
 	status.set_username(user->getJID().toBare());
 	bool isInvisible = presence->getPayload<Swift::InvisiblePayload>() != NULL;
 	if (isInvisible) {
 		LOG4CXX_INFO(logger, "This presence is invisible");
 		status.set_status((pbnetwork::STATUS_INVISIBLE));
+	}
 	else {
 		status.set_status((pbnetwork::StatusType) presence->getShow());
+	}
 	status.set_statusmessage(presence->getStatus());
 	std::string message;
 	status.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_STATUS_CHANGED);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleRoomJoined(User *user, const Swift::JID &who, const std::string &r, const std::string &nickname, const std::string &password) {
 	UserInfo userInfo = user->getUserInfo();
 	pbnetwork::Room room;
 	room.set_username(user->getJID().toBare());
 	room.set_nickname(nickname);
 	room.set_room(r);
 	room.set_password(password);
 	std::string message;
 	room.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_JOIN_ROOM);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleRoomLeft(User *user, const std::string &r) {
 	UserInfo userInfo = user->getUserInfo();
 	pbnetwork::Room room;
 	room.set_username(user->getJID().toBare());
 	room.set_nickname("");
 	room.set_room(r);
 	room.set_password("");
 	std::string message;
 	room.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_LEAVE_ROOM);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleUserDestroyed(User *user) {
 	m_waitingUsers.remove(user);
 	UserInfo userInfo = user->getUserInfo();
 	user->onReadyToConnect.disconnect(boost::bind(&NetworkPluginServer::handleUserReadyToConnect, this, user));
 	user->onPresenceChanged.disconnect(boost::bind(&NetworkPluginServer::handleUserPresenceChanged, this, user, _1));
 	user->onRoomJoined.disconnect(boost::bind(&NetworkPluginServer::handleRoomJoined, this, user, _1, _2, _3, _4));
 	user->onRoomLeft.disconnect(boost::bind(&NetworkPluginServer::handleRoomLeft, this, user, _1));
 	user->getRosterManager()->onBuddyAdded.disconnect(boost::bind(&NetworkPluginServer::handleUserBuddyAdded, this, user, _1));
 	user->getRosterManager()->onBuddyRemoved.disconnect(boost::bind(&NetworkPluginServer::handleUserBuddyRemoved, this, user, _1));
 	pbnetwork::Logout logout;
 	logout.set_user(user->getJID().toBare());
 	logout.set_legacyname(userInfo.uin);
 	std::string message;
 	logout.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_LOGOUT);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
 	c->users.remove(user);
 	// If backend should handle only one user, it must not accept another one before
 	// we kill it, so set up willDie to true
 	if (c->users.size() == 0 && CONFIG_INT(m_config, "service.users_per_backend") == 1) {
 		LOG4CXX_INFO(logger, "Backend " << c->id << " will die, because the last user disconnected");
 		c->willDie = true;
+	}
+}
 void NetworkPluginServer::handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &msg) {
 	conv->getConversationManager()->getUser()->updateLastActivity();
 	boost::shared_ptr<Swift::ChatState> statePayload = msg->getPayload<Swift::ChatState>();
 	if (statePayload) {
 		pbnetwork::WrapperMessage_Type type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED;
 		switch (statePayload->getChatState()) {
 			case Swift::ChatState::Active:
 				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_STOPPED_TYPING;
 				break;
 			case Swift::ChatState::Composing:
 				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING;
 				break;
 			case Swift::ChatState::Paused:
 				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPED;
 				break;
 			default:
 				break;
+		}
 		if (type != pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED) {
 			pbnetwork::Buddy buddy;
 			buddy.set_username(conv->getConversationManager()->getUser()->getJID().toBare());
 			buddy.set_buddyname(conv->getLegacyName());
 			std::string message;
 			buddy.SerializeToString(&message);
 			WRAP(message, type);
 			Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 			if (!c) {
 				return;
+			}
 			send(c->connection, message);
+		}
+	}
 	boost::shared_ptr<Swift::AttentionPayload> attentionPayload = msg->getPayload<Swift::AttentionPayload>();
 	if (attentionPayload) {
 		pbnetwork::ConversationMessage m;
 		m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());
 		m.set_buddyname(conv->getLegacyName());
 		m.set_message(msg->getBody());
 		std::string message;
 		m.SerializeToString(&message);
 		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_ATTENTION);
 		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 		send(c->connection, message);
 		return;
+	}
 	if (!msg->getSubject().empty()) {
 		pbnetwork::ConversationMessage m;
 		m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());
 		m.set_buddyname(conv->getLegacyName());
 		m.set_message(msg->getSubject());
 		std::string message;
 		m.SerializeToString(&message);
 		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_ROOM_SUBJECT_CHANGED);
 		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 		send(c->connection, message);
 		return;
+	}
 	std::string xhtml;
 	boost::shared_ptr<Swift::XHTMLIMPayload> xhtmlPayload = msg->getPayload<Swift::XHTMLIMPayload>();
 	if (xhtmlPayload) {
 		xhtml = xhtmlPayload->getBody();
+	}
 	// Send normal message
 	if (!msg->getBody().empty() || !xhtml.empty()) {
 		pbnetwork::ConversationMessage m;
 		m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());
 		m.set_buddyname(conv->getLegacyName());
 		m.set_message(msg->getBody());
 		m.set_xhtml(xhtml);
 		boost::shared_ptr<Swift::DeliveryReceiptRequest> receiptPayload = msg->getPayload<Swift::DeliveryReceiptRequest>();
 		if (receiptPayload && !msg->getID().empty()) {
 			m.set_id(msg->getID());
+		}
 		std::string message;
 		m.SerializeToString(&message);
 		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE);
 		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 		if (!c) {
 			return;
+		}
 		send(c->connection, message);
+	}
+}
 void NetworkPluginServer::handleBuddyRemoved(Buddy *b) {
 	User *user = b->getRosterManager()->getUser();
 	pbnetwork::Buddy buddy;
 	buddy.set_username(user->getJID().toBare());
 	buddy.set_buddyname(b->getName());
 	buddy.set_alias(b->getAlias());
 	BOOST_FOREACH(const std::string &g, b->getGroups()) {
 		buddy.add_group(g);
+	}
 	buddy.set_status(pbnetwork::STATUS_NONE);
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_REMOVED);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleBuddyUpdated(Buddy *b, const Swift::RosterItemPayload &item) {
 	User *user = b->getRosterManager()->getUser();
 	dynamic_cast<LocalBuddy *>(b)->setAlias(item.getName());
 	dynamic_cast<LocalBuddy *>(b)->setGroups(item.getGroups());
 	pbnetwork::Buddy buddy;
 	buddy.set_username(user->getJID().toBare());
 	buddy.set_buddyname(b->getName());
 	buddy.set_alias(b->getAlias());
 	BOOST_FOREACH(const std::string &g, b->getGroups()) {
 		buddy.add_group(g);
+	}
 	buddy.set_status(pbnetwork::STATUS_NONE);
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleBuddyAdded(Buddy *buddy, const Swift::RosterItemPayload &item) {
 	handleBuddyUpdated(buddy, item);
+}
 void NetworkPluginServer::handleUserBuddyAdded(User *user, Buddy *b) {
 	pbnetwork::Buddy buddy;
 	buddy.set_username(user->getJID().toBare());
 	buddy.set_buddyname(b->getName());
 	buddy.set_alias(b->getAlias());
 	BOOST_FOREACH(const std::string &g, b->getGroups()) {
 		buddy.add_group(g);
+	}
 	buddy.set_status(pbnetwork::STATUS_NONE);
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleUserBuddyRemoved(User *user, Buddy *b) {
 	handleBuddyRemoved(b);
+}
 void NetworkPluginServer::handleBlockToggled(Buddy *b) {
 	User *user = b->getRosterManager()->getUser();
 	pbnetwork::Buddy buddy;
 	buddy.set_username(user->getJID().toBare());
 	buddy.set_buddyname(b->getName());
 	buddy.set_alias(b->getAlias());
 	BOOST_FOREACH(const std::string &g, b->getGroups()) {
 		buddy.add_group(g);
+	}
 	buddy.set_status(pbnetwork::STATUS_NONE);
 	buddy.set_blocked(!b->isBlocked());
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> v) {
 	pbnetwork::VCard vcard;
 	vcard.set_username(user->getJID().toBare());
 	vcard.set_buddyname("");
 	vcard.set_id(0);
 	vcard.set_photo(&v->getPhoto()[0], v->getPhoto().size());
 	vcard.set_nickname(v->getNickname());
 	std::string message;
 	vcard.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_VCARD);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleVCardRequired(User *user, const std::string &name, unsigned int id) {
 	pbnetwork::VCard vcard;
 	vcard.set_username(user->getJID().toBare());
 	vcard.set_buddyname(name);
 	vcard.set_id(id);
 	std::string message;
 	vcard.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_VCARD);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleFTAccepted(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID) {
 	pbnetwork::File f;
 	f.set_username(user->getJID().toBare());
 	f.set_buddyname(buddyName);
 	f.set_filename(fileName);
 	f.set_size(size);
 	f.set_ftid(ftID);
 	std::string message;
 	f.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_START);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	send(c->connection, message);
+}
 void NetworkPluginServer::handleFTRejected(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size) {
 	pbnetwork::File f;
 	f.set_username(user->getJID().toBare());
 	f.set_buddyname(buddyName);
 	f.set_filename(fileName);
 	f.set_size(size);
 	f.set_ftid(0);
 	std::string message;
 	f.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_FINISH);

src/rostermanager.cpp

➞

Show inline comments

 					buddyInfo.subscription = "both";
 					buddyInfo.flags = Buddy::buddyFlagsFromJID(presence->getTo());
 					LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Subscription received for new buddy " << buddyInfo.legacyName << " => adding to legacy network");
 					buddy = m_component->getFactory()->createBuddy(this, buddyInfo);
 					setBuddy(buddy);
 					onBuddyAdded(buddy);
 					response->setType(Swift::Presence::Subscribed);
 					break;
 				case Swift::Presence::Subscribed:
 // 					onBuddyAdded(buddy);
 					return;
 				// buddy is not there, so nothing to do, just answer
 				case Swift::Presence::Unsubscribe:
 					buddyInfo.id = -1;
 					buddyInfo.alias = "";
 					buddyInfo.legacyName = Buddy::JIDToLegacyName(presence->getTo());
 					buddyInfo.subscription = "both";
 					buddyInfo.flags = Buddy::buddyFlagsFromJID(presence->getTo());
 					buddy = m_component->getFactory()->createBuddy(this, buddyInfo);
 					onBuddyRemoved(buddy);
 					delete buddy;
 					response->setType(Swift::Presence::Unsubscribed);
 					break;
 				default:
 					return;
+			}
 			m_component->getStanzaChannel()->sendPresence(response);
+		}
+	}
 	else {
 		Swift::Presence::ref response = Swift::Presence::create();
 		Swift::Presence::ref currentPresence;
 		response->setTo(presence->getFrom().toBare());
 		response->setFrom(presence->getTo().toBare());
 		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:
 					onBuddyAdded(buddy);
 					response->setType(Swift::Presence::Subscribed);
 					currentPresence = buddy->generatePresenceStanza(255);
 					if (currentPresence) {
 						currentPresence->setTo(presence->getFrom());
 						m_component->getStanzaChannel()->sendPresence(currentPresence);
+					}
 					if (buddy->getSubscription() != Buddy::Both) {
 						buddy->setSubscription(Buddy::Both);
 						storeBuddy(buddy);
+					}
 					break;
 				// remove buddy
 				case Swift::Presence::Unsubscribe:
 					response->setType(Swift::Presence::Unsubscribed);
 					onBuddyRemoved(buddy);
 					removeBuddy(buddy->getName());
 					buddy = NULL;
 					break;
 				// just send response
 				case Swift::Presence::Unsubscribed:
 					response->setType(Swift::Presence::Unsubscribe);
 					// We set both here, because this Unsubscribed can be response to
 					// subscribe presence and we don't want that unsubscribe presence
 					// to be send later again
 					if (buddy->getSubscription() != Buddy::Both) {
 						buddy->setSubscription(Buddy::Both);
 						storeBuddy(buddy);
+					}
 					break;
 				case Swift::Presence::Subscribed:
 					if (buddy->getSubscription() != Buddy::Both) {
 						buddy->setSubscription(Buddy::Both);
 						storeBuddy(buddy);
+					}
 					return;
 				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 = Buddy::buddyFlagsFromJID(presence->getTo());
 					buddy = m_component->getFactory()->createBuddy(this, buddyInfo);
 					setBuddy(buddy);
 					onBuddyAdded(buddy);
 					LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Subscription received for new buddy " << buddyInfo.legacyName << " => adding to legacy network");
 					response->setType(Swift::Presence::Subscribed);
 					break;
 				case Swift::Presence::Unsubscribe:
 					buddyInfo.id = -1;
 					buddyInfo.alias = "";
 					buddyInfo.legacyName = Buddy::JIDToLegacyName(presence->getTo());
 					buddyInfo.subscription = "both";
 					buddyInfo.flags = Buddy::buddyFlagsFromJID(presence->getTo());
 					response->setType(Swift::Presence::Unsubscribed);
 					buddy = m_component->getFactory()->createBuddy(this, buddyInfo);
 					onBuddyRemoved(buddy);
 					delete buddy;
 					buddy = NULL;
 					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;
+	}
 	RosterStorage *storage = 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);
 		if (buddy) {
 			LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Adding cached buddy " << buddy->getName() << " fom database");
 			m_buddies[buddy->getName()] = buddy;
 			onBuddySet(buddy);
+		}
+	}
 	m_rosterStorage = storage;
+}
 Swift::RosterPayload::ref RosterManager::generateRosterPayload() {
 	Swift::RosterPayload::ref payload = Swift::RosterPayload::ref(new Swift::RosterPayload());
 	for (std::map<std::string, Buddy *, std::less<std::string>, boost::pool_allocator< std::pair<std::string, Buddy *> > >::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 *, std::less<std::string>, boost::pool_allocator< std::pair<std::string, Buddy *> > >::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->getType() == Swift::Presence::Available) {
 			presence->setTo(to);
 			m_component->getStanzaChannel()->sendPresence(presence);
+		}
+	}
+}

src/tests/user.cpp

➞

Show inline comments

 		// We're not forwarding current presence in server-mode
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
+	}
 	void handlePresence() {
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("localhost");
 		response->setFrom("user@localhost/resource");
 		response->setShow(Swift::StatusShow::Away);
 		injectPresence(response);
 		loop->processEvents();
 		// no presence received in server mode, just disco#info
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 		CPPUNIT_ASSERT(changedPresence);
 		CPPUNIT_ASSERT_EQUAL(Swift::StatusShow::Away, changedPresence->getShow());
+	}
 	void handlePresenceJoinRoom() {
 		User *user = userManager->getUser("user@localhost");
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string("room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string("hanzz"), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string("password"), roomPassword);
 		room = "";
 		roomNickname = "";
 		roomPassword = "";
 		// simulate that backend joined the room
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "room", true);
 		conv->addJID("user@localhost/resource");
 		user->getConversationManager()->addConversation(conv);
 		received.clear();
 		injectPresence(response);
 		loop->processEvents();
 		// no presence received in server mode, just disco#info
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
+	}
 	void handlePresenceJoinRoomTwoResources() {
 		handlePresenceJoinRoom();
 		User *user = userManager->getUser("user@localhost");
 		// Add 1 participant
 		Conversation *conv = user->getConversationManager()->getConversation("room");
 		conv->handleParticipantChanged("anotheruser", Conversation::PARTICIPANT_FLAG_NONE, Swift::StatusShow::Away, "my status message");
 		// Connect 2nd resource
 		connectSecondResource();
 		received2.clear();
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource2");
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		CPPUNIT_ASSERT_EQUAL(1, (int) received2.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received2[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::StatusShow::Away, dynamic_cast<Swift::Presence *>(getStanza(received2[0]))->getShow());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource2"), dynamic_cast<Swift::Presence *>(getStanza(received2[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("room@localhost/anotheruser"), dynamic_cast<Swift::Presence *>(getStanza(received2[0]))->getFrom().toString());
 		CPPUNIT_ASSERT(getStanza(received2[0])->getPayload<Swift::MUCUserPayload>());
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Member, *getStanza(received2[0])->getPayload<Swift::MUCUserPayload>()->getItems()[0].affiliation);
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Participant, *getStanza(received2[0])->getPayload<Swift::MUCUserPayload>()->getItems()[0].role);
+	}
 	void handlePresenceLeaveRoom() {
 		received.clear();
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string("room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 // 		CPPUNIT_ASSERT_EQUAL(std::string("room"), room);
 // 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 // 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
+	}
 	void handlePresenceLeaveRoomTwoResources() {
 		handlePresenceJoinRoomTwoResources();
 		received.clear();
 		// User is still connected from resource2, so he should not leave the room
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		// disconnect also from resource
 		// User is still connected from resource2, so he should not leave the room
 		response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource2");
 		response->setType(Swift::Presence::Unavailable);
 		payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string("room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
+	}
 	void handlePresenceLeaveRoomTwoResourcesOneDisconnects() {
 		handlePresenceJoinRoomTwoResources();
 		received.clear();
 		User *user = userManager->getUser("user@localhost");
 		// User is still connected from resource2, so he should not leave the room
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		Conversation *conv = user->getConversationManager()->getConversation("room");
 		CPPUNIT_ASSERT_EQUAL(1, (int) conv->getJIDs().size());
 		CPPUNIT_ASSERT_EQUAL(Swift::JID("user@localhost/resource2"), conv->getJIDs().front());
+	}
 	void handlePresenceLeaveRoomBouncer() {
 		User *user = userManager->getUser("user@localhost");
 		user->addUserSetting("stay_connected", "1");
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
+	}
 	void handlePresenceLeaveRoomTwoResourcesBouncer() {
 		User *user = userManager->getUser("user@localhost");
 		user->addUserSetting("stay_connected", "1");
 		handlePresenceJoinRoomTwoResources();
 		received.clear();
 		// User is still connected from resource2, so he should not leave the room
 		Swift::Presence::ref response = Swift::Presence::create();

src/user.cpp

➞

Show inline comments

@@ @@ -144,192 +144,195 @@ void User::sendCurrentPresence() { @@
 			continue;
+		}
 		if (m_connected) {
 			Swift::Presence::ref highest = m_presenceOracle->getHighestPriorityPresence(m_jid.toBare());
 			if (highest) {
 				Swift::Presence::ref response = Swift::Presence::create(highest);
 				response->setTo(presence->getFrom());
 				response->setFrom(m_component->getJID());
 				m_component->getStanzaChannel()->sendPresence(response);
+			}
 			else {
 				Swift::Presence::ref response = Swift::Presence::create();
 				response->setTo(presence->getFrom());
 				response->setFrom(m_component->getJID());
 				response->setType(Swift::Presence::Unavailable);
 				m_component->getStanzaChannel()->sendPresence(response);
+			}
+		}
 		else {
 			Swift::Presence::ref response = Swift::Presence::create();
 			response->setTo(presence->getFrom());
 			response->setFrom(m_component->getJID());
 			response->setType(Swift::Presence::Unavailable);
 			response->setStatus("Connecting");
 			m_component->getStanzaChannel()->sendPresence(response);
+		}
+	}
+}
 void User::setConnected(bool connected) {
 	m_connected = connected;
 	m_reconnectCounter = 0;
 	setIgnoreDisconnect(false);
 	updateLastActivity();
 	sendCurrentPresence();
 	if (m_connected) {
 		BOOST_FOREACH(Swift::Presence::ref &presence, m_joinedRooms) {
 			handlePresence(presence, true);
+		}
+	}
+}
 void User::setCacheMessages(bool cacheMessages) {
 	if (m_component->inServerMode() && !m_cacheMessages && cacheMessages) {
 		m_conversationManager->sendCachedChatMessages();
+	}
 	m_cacheMessages = cacheMessages;
+}
 void User::handlePresence(Swift::Presence::ref presence, bool forceJoin) {
 	LOG4CXX_INFO(logger, "PRESENCE " << presence->getFrom().toString() << " " << presence->getTo().toString());
 	if (!m_connected) {
 		// we are not connected to legacy network, so we should do it when disco#info arrive :)
 		if (m_readyForConnect == false) {
 			// Forward status message to legacy network, but only if it's sent from active resource
 // 					if (m_activeResource == presence->getFrom().getResource().getUTF8String()) {
 // 						forwardStatus(presenceShow, stanzaStatus);
 // 					}
 			boost::shared_ptr<Swift::CapsInfo> capsInfo = presence->getPayload<Swift::CapsInfo>();
 			if (capsInfo && capsInfo->getHash() == "sha-1") {
 				if (m_entityCapsManager->getCaps(presence->getFrom()) != Swift::DiscoInfo::ref()) {
 					LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");
 					m_readyForConnect = true;
 					onReadyToConnect();
+				}
 				else {
 					m_reconnectTimer->start();
+				}
+			}
 			else if (m_component->inServerMode()) {
 				LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");
 				m_readyForConnect = true;
 				onReadyToConnect();
+			}
 			else {
 				m_reconnectTimer->start();
+			}
+		}
+	}
 	if (!presence->getTo().getNode().empty()) {
 		bool isMUC = presence->getPayload<Swift::MUCPayload>() != NULL || *presence->getTo().getNode().c_str() == '#';
 		if (presence->getType() == Swift::Presence::Unavailable) {
 			std::string room = Buddy::JIDToLegacyName(presence->getTo());
 			Conversation *conv = m_conversationManager->getConversation(room);
 			if (conv) {
 				conv->removeJID(presence->getFrom());
 				if (!conv->getJIDs().empty()) {
 					return;
+				}
+			}
 			else {
 				return;
+			}
 			if (getUserSetting("stay_connected") != "1") {
 				LOG4CXX_INFO(logger, m_jid.toString() << ": Going to left room " << room);
 				onRoomLeft(room);
 				BOOST_FOREACH(Swift::Presence::ref &p, m_joinedRooms) {
 					if (p->getTo() == presence->getTo()) {
 						m_joinedRooms.remove(p);
 						break;
+					}
+				}
 				if (conv) {
 					m_conversationManager->removeConversation(conv);
 					delete conv;
+				}
+			}
+		}
 		else if (isMUC) {
 			// force connection to legacy network to let backend to handle auto-join on connect.
 			if (!m_readyForConnect) {
 				LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");
 				m_readyForConnect = true;
 				onReadyToConnect();
+			}
 			std::string room = Buddy::JIDToLegacyName(presence->getTo());
 			std::string password = "";
 			if (presence->getPayload<Swift::MUCPayload>() != NULL) {
 				password = presence->getPayload<Swift::MUCPayload>()->getPassword() ? *presence->getPayload<Swift::MUCPayload>()->getPassword() : "";
+			}
 			Conversation *conv = m_conversationManager->getConversation(room);
 			if (conv != NULL) {
 				if (std::find(conv->getJIDs().begin(), conv->getJIDs().end(), presence->getFrom()) != conv->getJIDs().end()) {
 					LOG4CXX_INFO(logger, m_jid.toString() << ": User has already tried to join room " << room << " as " << presence->getTo().getResource());
+				}
 				else {
 					conv->addJID(presence->getFrom());
 					conv->sendParticipants(presence->getFrom());
 					conv->sendCachedMessages(presence->getFrom());
+				}
 				if (forceJoin) {
 					onRoomJoined(presence->getFrom(), room, presence->getTo().getResource(), password);
+				}
 				return;
+			}
 			bool isInJoined = false;
 			BOOST_FOREACH(Swift::Presence::ref &p, m_joinedRooms) {
 				if (p->getTo() == presence->getTo()) {
 					isInJoined = true;
+				}
+			}
 			if (!isInJoined) {
 				m_joinedRooms.push_back(presence);
+			}
 			if (!m_connected) {
 				LOG4CXX_INFO(logger, m_jid.toString() << ": Joining room " << room << " postponed, because use is not connected to legacy network yet.");
 				return;
+			}
 			LOG4CXX_INFO(logger, m_jid.toString() << ": Going to join room " << room << " as " << presence->getTo().getResource());
 			conv = m_component->getFactory()->createConversation(m_conversationManager, room, true);
 			m_conversationManager->addConversation(conv);
 			conv->setNickname(presence->getTo().getResource());
 			conv->addJID(presence->getFrom());
 			onRoomJoined(presence->getFrom(), room, presence->getTo().getResource(), password);
+		}
 		return;
+	}
 	int currentResourcesCount = m_presenceOracle->getAllPresence(m_jid).size();
 	m_conversationManager->resetResources();
 	if (presence->getType() == Swift::Presence::Unavailable) {
 		m_conversationManager->removeJID(presence->getFrom());
 		std::string presences;
 		std::vector<Swift::Presence::ref> ps = m_presenceOracle->getAllPresence(m_jid);
 		BOOST_FOREACH(Swift::Presence::ref p, ps) {
 			if (p != presence) {
 				presences += p->getFrom().toString() + " ";
+			}
 		};
 		if (!presences.empty()) {
 			LOG4CXX_INFO(logger, m_jid.toString() << ": User is still connected from following clients: " << presences);
+		}
 		else {

0 comments (0 inline, 0 general)