Changeset - a6781df77f76
Parent rev.
Child rev.
[Not reviewed]
0 9 0
Jan Kaluza - 14 years ago 2011-06-09 13:54:09
hanzz.k@gmail.com
Working buddy rename
9 files changed with 85 insertions and 7 deletions:
backends/libpurple/main.cpp
13
1
include/transport/networkplugin.h
2
include/transport/networkpluginserver.h
4
include/transport/rostermanager.h
2
include/transport/rosterresponder.h
7
src/networkplugin.cpp
13
src/networkpluginserver.cpp
35
3
src/rostermanager.cpp
6
src/rosterresponder.cpp
3
3
0 comments (0 inline, 0 general)
backends/libpurple/main.cpp
➞
Show inline comments
 
@@ -109,32 +109,44 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 
			PurpleAccount *account = m_sessions[user];
 
			if (account) {
 
				PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, legacyName.c_str(), account);
 
				if (!conv) {
 
					conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, legacyName.c_str());
 
				}
 
				gchar *_markup = purple_markup_escape_text(message.c_str(), -1);
 
				purple_conv_im_send(PURPLE_CONV_IM(conv), _markup);
 
				g_free(_markup);
 
			}
 
		}
 

			




	
	
	
		
 
		virtual void handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id) {

			




	
	
	
		
 
		void handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id) {

			




	
	
	
		
 
			PurpleAccount *account = m_sessions[user];

			




	
	
	
		
 
			if (account) {

			




	
	
	
		
 
				serv_get_info(purple_account_get_connection(account), legacyName.c_str());

			




	
	
	
		
 
				m_vcards[user + legacyName] = id;

			




	
	
	
		
 
			}

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		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) {

			




	
	
	
		
 
				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);

			




	
	
	
		
 
				}

			




	
	
	
		
 
			}

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		std::map<std::string, PurpleAccount *> m_sessions;

			




	
	
	
		
 
		std::map<PurpleAccount *, std::string> m_accounts;

			




	
	
	
		
 
		std::map<std::string, unsigned int> m_vcards;

			




	
	
	
		
 
	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

			




        

    


    
    

    

        

                

                    include/transport/networkplugin.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -55,34 +55,36 @@ class NetworkPlugin {

			




	
	
	
		
 
		void handleSubject(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &nickname = "");

			




	
	
	
		
 

			




	
	
	
		
 
		void handleRoomChanged(const std::string &user, const std::string &room, const std::string &nickname);

			




	
	
	
		
 

			




	
	
	
		
 
		void handleVCard(const std::string &user, unsigned int id, const std::string &legacyName, const std::string &fullName, const std::string &nickname, const std::string &photo);

			




	
	
	
		
 

			




	
	
	
		
 
		virtual void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) = 0;

			




	
	
	
		
 
		virtual void handleLogoutRequest(const std::string &user, const std::string &legacyName) = 0;

			




	
	
	
		
 
		virtual void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message) = 0;

			




	
	
	
		
 
		virtual void handleVCardRequest(const std::string &/*user*/, const std::string &/*legacyName*/, unsigned int /*id*/) {}

			




	
	
	
		
 
		virtual void handleJoinRoomRequest(const std::string &/*user*/, const std::string &/*room*/, const std::string &/*nickname*/, const std::string &/*pasword*/) {}

			




	
	
	
		
 
		virtual void handleLeaveRoomRequest(const std::string &/*user*/, const std::string &/*room*/) {}

			




	
	
	
		
 
		virtual void handleBuddyUpdatedRequest(const std::string &/*user*/, const std::string &/*buddyName*/, const std::string &/*alias*/, const std::string &/*groups*/) {}

			




	
	
	
		
 
		

			




	
	
	
		
 

			




	
	
	
		
 
	private:

			




	
	
	
		
 
		void connect();

			




	
	
	
		
 
		void handleLoginPayload(const std::string &payload);

			




	
	
	
		
 
		void handleLogoutPayload(const std::string &payload);

			




	
	
	
		
 
		void handleConvMessagePayload(const std::string &payload);

			




	
	
	
		
 
		void handleJoinRoomPayload(const std::string &payload);

			




	
	
	
		
 
		void handleLeaveRoomPayload(const std::string &payload);

			




	
	
	
		
 
		void handleVCardPayload(const std::string &payload);

			




	
	
	
		
 
		void handleBuddyChangedPayload(const std::string &payload);

			




	
	
	
		
 
		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;

			




        

    


    
    

    

        

                

                    include/transport/networkpluginserver.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -65,24 +65,28 @@ class NetworkPluginServer {

			




	
	
	
		
 
		void handleBuddyChangedPayload(const std::string &payload);

			




	
	
	
		
 
		void handleConvMessagePayload(const std::string &payload, bool subject = false);

			




	
	
	
		
 
		void handleParticipantChangedPayload(const std::string &payload);

			




	
	
	
		
 
		void handleRoomChangedPayload(const std::string &payload);

			




	
	
	
		
 
		void handleVCardPayload(const std::string &payload);

			




	
	
	
		
 

			




	
	
	
		
 
		void handleUserCreated(User *user);

			




	
	
	
		
 
		void handleRoomJoined(User *user, const std::string &room, const std::string &nickname, const std::string &password);

			




	
	
	
		
 
		void handleRoomLeft(User *user, const std::string &room);

			




	
	
	
		
 
		void handleUserReadyToConnect(User *user);

			




	
	
	
		
 
		void handleUserDestroyed(User *user);

			




	
	
	
		
 

			




	
	
	
		
 
		void handleBuddyUpdated(Buddy *buddy, const Swift::RosterItemPayload &item);

			




	
	
	
		
 
		void handleBuddyRemoved(Buddy *buddy);

			




	
	
	
		
 
		void handleBuddyAdded(Buddy *buddy, const Swift::RosterItemPayload &item);

			




	
	
	
		
 

			




	
	
	
		
 
		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;

			




        

    


    
    

    

        

                

                    include/transport/rostermanager.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -51,24 +51,26 @@ class RosterManager {

			




	
	
	
		
 
		/// 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

			




        

    


    
    

    

        

                

                    include/transport/rosterresponder.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -19,25 +19,32 @@

			




	
	
	
		
 
 */

			




	
	
	
		
 

			




	
	
	
		
 
#pragma once

			




	
	
	
		
 

			




	
	
	
		
 
#include <vector>

			




	
	
	
		
 
#include "Swiften/Swiften.h"

			




	
	
	
		
 
#include "Swiften/Queries/Responder.h"

			




	
	
	
		
 
#include "Swiften/Elements/RosterPayload.h"

			




	
	
	
		
 

			




	
	
	
		
 
namespace Transport {

			




	
	
	
		
 

			




	
	
	
		
 
class UserManager;

			




	
	
	
		
 
class Buddy;

			




	
	
	
		
 

			




	
	
	
		
 
class RosterResponder : public Swift::Responder<Swift::RosterPayload> {

			




	
	
	
		
 
	public:

			




	
	
	
		
 
		RosterResponder(Swift::IQRouter *router, UserManager *userManager);

			




	
	
	
		
 
		~RosterResponder();

			




	
	
	
		
 

			




	
	
	
		
 
		boost::signal<void (Buddy *, const Swift::RosterItemPayload &item)> onBuddyUpdated;

			




	
	
	
		
 

			




	
	
	
		
 
		boost::signal<void (Buddy *)> onBuddyRemoved;

			




	
	
	
		
 

			




	
	
	
		
 
		boost::signal<void (Buddy *, const Swift::RosterItemPayload &item)> onBuddyAdded;

			




	
	
	
		
 

			




	
	
	
		
 
	private:

			




	
	
	
		
 
		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload);

			




	
	
	
		
 
		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload);

			




	
	
	
		
 
		UserManager *m_userManager;

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
}

			




	
	
		
 
\ No newline at end of file

			




        

    


    
    

    

        

                

                    src/networkplugin.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -256,24 +256,34 @@ void NetworkPlugin::handleLeaveRoomPayload(const std::string &data) {

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPlugin::handleVCardPayload(const std::string &data) {

			




	
	
	
		
 
	pbnetwork::VCard payload;

			




	
	
	
		
 
	if (payload.ParseFromString(data) == false) {

			




	
	
	
		
 
		// TODO: ERROR

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	handleVCardRequest(payload.username(), payload.buddyname(), payload.id());

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPlugin::handleBuddyChangedPayload(const std::string &data) {

			




	
	
	
		
 
	pbnetwork::Buddy payload;

			




	
	
	
		
 
	if (payload.ParseFromString(data) == false) {

			




	
	
	
		
 
		// TODO: ERROR

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	handleBuddyUpdatedRequest(payload.username(), payload.buddyname(), payload.alias(), payload.groups());

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPlugin::handleDataRead(const Swift::SafeByteArray &data) {

			




	
	
	
		
 
	m_data.insert(m_data.end(), data.begin(), data.end());

			




	
	
	
		
 

			




	
	
	
		
 
	while (m_data.size() != 0) {

			




	
	
	
		
 
		unsigned int expected_size;

			




	
	
	
		
 

			




	
	
	
		
 
		if (m_data.size() >= 4) {

			




	
	
	
		
 
			expected_size = *((unsigned int*) &m_data[0]);

			




	
	
	
		
 
			expected_size = ntohl(expected_size);

			




	
	
	
		
 
			if (m_data.size() - 4 < expected_size)

			




	
	
	
		
 
				return;

			




	
	
	
		
 
		}

			




	
	
		
 
@@ -301,24 +311,27 @@ void NetworkPlugin::handleDataRead(const Swift::SafeByteArray &data) {

			




	
	
	
		
 
			case pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE:

			




	
	
	
		
 
				handleConvMessagePayload(wrapper.payload());

			




	
	
	
		
 
				break;

			




	
	
	
		
 
			case pbnetwork::WrapperMessage_Type_TYPE_JOIN_ROOM:

			




	
	
	
		
 
				handleJoinRoomPayload(wrapper.payload());

			




	
	
	
		
 
				break;

			




	
	
	
		
 
			case pbnetwork::WrapperMessage_Type_TYPE_LEAVE_ROOM:

			




	
	
	
		
 
				handleLeaveRoomPayload(wrapper.payload());

			




	
	
	
		
 
				break;

			




	
	
	
		
 
			case pbnetwork::WrapperMessage_Type_TYPE_VCARD:

			




	
	
	
		
 
				handleVCardPayload(wrapper.payload());

			




	
	
	
		
 
				break;

			




	
	
	
		
 
			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED:

			




	
	
	
		
 
				handleBuddyChangedPayload(wrapper.payload());

			




	
	
	
		
 
				break;

			




	
	
	
		
 
			default:

			




	
	
	
		
 
				return;

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPlugin::send(const std::string &data) {

			




	
	
	
		
 
	char header[4];

			




	
	
	
		
 
	*((int*)(header)) = htonl(data.size());

			




	
	
	
		
 
	m_conn->write(Swift::createSafeByteArray(std::string(header, 4) + data));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    src/networkpluginserver.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -119,24 +119,27 @@ NetworkPluginServer::NetworkPluginServer(Component *component, Config *config, U

			




	
	
	
		
 
	m_component->m_factory = new NetworkFactory(this);

			




	
	
	
		
 
	m_userManager->onUserCreated.connect(boost::bind(&NetworkPluginServer::handleUserCreated, this, _1));

			




	
	
	
		
 
	m_userManager->onUserDestroyed.connect(boost::bind(&NetworkPluginServer::handleUserDestroyed, this, _1));

			




	
	
	
		
 

			




	
	
	
		
 
	m_pingTimer = component->getFactories()->getTimerFactory()->createTimer(10000);

			




	
	
	
		
 
	m_pingTimer->onTick.connect(boost::bind(&NetworkPluginServer::pingTimeout, this)); 

			




	
	
	
		
 

			




	
	
	
		
 
	m_vcardResponder = new VCardResponder(component->getIQRouter(), userManager);

			




	
	
	
		
 
	m_vcardResponder->onVCardRequired.connect(boost::bind(&NetworkPluginServer::handleVCardRequired, this, _1, _2, _3));

			




	
	
	
		
 
	m_vcardResponder->start();

			




	
	
	
		
 

			




	
	
	
		
 
	m_rosterResponder = new RosterResponder(component->getIQRouter(), userManager);

			




	
	
	
		
 
	m_rosterResponder->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_server = component->getFactories()->getConnectionFactory()->createConnectionServer(10000);

			




	
	
	
		
 
	m_server->onNewConnection.connect(boost::bind(&NetworkPluginServer::handleNewClientConnection, this, _1));

			




	
	
	
		
 
	m_server->start();

			




	
	
	
		
 

			




	
	
	
		
 
	signal(SIGCHLD, SigCatcher);

			




	
	
	
		
 

			




	
	
	
		
 
	exec_(CONFIG_STRING(m_config, "service.backend").c_str(), "localhost", "10000", m_config->getConfigFile().c_str());

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
NetworkPluginServer::~NetworkPluginServer() {

			




	
	
		
 
@@ -217,25 +220,25 @@ void NetworkPluginServer::handleVCardPayload(const std::string &data) {

			




	
	
	
		
 
	vcard->setPhoto(Swift::createByteArray(payload.photo()));

			




	
	
	
		
 
	vcard->setNickname(payload.nickname());

			




	
	
	
		
 

			




	
	
	
		
 
	m_vcardResponder->sendVCard(payload.id(), vcard);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::handleBuddyChangedPayload(const std::string &data) {

			




	
	
	
		
 
	pbnetwork::Buddy payload;

			




	
	
	
		
 
	if (payload.ParseFromString(data) == false) {

			




	
	
	
		
 
		// TODO: ERROR

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 
	std::cout << payload.buddyname() << "\n";

			




	
	
	
		
 

			




	
	
	
		
 
	User *user = m_userManager->getUser(payload.username());

			




	
	
	
		
 
	if (!user)

			




	
	
	
		
 
		return;

			




	
	
	
		
 

			




	
	
	
		
 
	LocalBuddy *buddy = (LocalBuddy *) user->getRosterManager()->getBuddy(payload.buddyname());

			




	
	
	
		
 
	if (buddy) {

			




	
	
	
		
 
		handleBuddyPayload(buddy, payload);

			




	
	
	
		
 
		buddy->buddyChanged();

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else {

			




	
	
	
		
 
		buddy = new LocalBuddy(user->getRosterManager(), -1);

			




	
	
	
		
 
		handleBuddyPayload(buddy, payload);

			




	
	
		
 
@@ -314,46 +317,45 @@ void NetworkPluginServer::handleConvMessagePayload(const std::string &data, bool

			




	
	
	
		
 

			




	
	
	
		
 
	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(payload.buddyname());

			




	
	
	
		
 
	if (!conv) {

			




	
	
	
		
 
		conv = new NetworkConversation(user->getConversationManager(), payload.buddyname());

			




	
	
	
		
 
		conv->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, this, _1, _2));

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	conv->handleMessage(msg, payload.nickname());

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::handleDataRead(Client *c, const Swift::SafeByteArray &data) {

			




	
	
	
		
 
	c->data.insert(c->data.end(), data.begin(), data.end());

			




	
	
	
		
 
	std::cout << "READ\n";

			




	
	
	
		
 
	while (c->data.size() != 0) {

			




	
	
	
		
 
		unsigned int expected_size;

			




	
	
	
		
 

			




	
	
	
		
 
		if (c->data.size() >= 4) {

			




	
	
	
		
 
			expected_size = *((unsigned int*) &c->data[0]);

			




	
	
	
		
 
			expected_size = ntohl(expected_size);

			




	
	
	
		
 
			if (c->data.size() - 4 < expected_size)

			




	
	
	
		
 
				return;

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else {

			




	
	
	
		
 
			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);

			




	
	
	
		
 
		std::cout << "TYPE "  << wrapper.type() << " " << (int) pbnetwork::WrapperMessage_Type_TYPE_CONNECTED << " " << c->data.size() << "\n";

			




	
	
	
		
 

			




	
	
	
		
 
		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());

			




	
	
		
 
@@ -509,24 +511,54 @@ void NetworkPluginServer::handleMessageReceived(NetworkConversation *conv, boost

			




	
	
	
		
 
	m.set_buddyname(conv->getLegacyName());

			




	
	
	
		
 
	m.set_message(msg->getBody());

			




	
	
	
		
 

			




	
	
	
		
 
	std::string message;

			




	
	
	
		
 
	m.SerializeToString(&message);

			




	
	
	
		
 

			




	
	
	
		
 
	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE);

			




	
	
	
		
 

			




	
	
	
		
 
	Client *c = (Client *) conv->getConversationManager()->getUser()->getData();

			




	
	
	
		
 
	send(c->connection, message);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::handleBuddyRemoved(Buddy *buddy) {

			




	
	
	
		
 
	

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::handleBuddyUpdated(Buddy *b, const Swift::RosterItemPayload &item) {

			




	
	
	
		
 
	User *user = b->getRosterManager()->getUser();

			




	
	
	
		
 

			




	
	
	
		
 
	dynamic_cast<LocalBuddy *>(b)->setAlias(item.getName());

			




	
	
	
		
 
	user->getRosterManager()->storeBuddy(b);

			




	
	
	
		
 

			




	
	
	
		
 
	pbnetwork::Buddy buddy;

			




	
	
	
		
 
	buddy.set_username(user->getJID().toBare());

			




	
	
	
		
 
	buddy.set_buddyname(b->getName());

			




	
	
	
		
 
	buddy.set_alias(b->getAlias());

			




	
	
	
		
 
	buddy.set_groups(b->getGroups().size() == 0 ? "" : b->getGroups()[0]);

			




	
	
	
		
 
	buddy.set_status(Swift::StatusShow::None);

			




	
	
	
		
 

			




	
	
	
		
 
	std::string message;

			




	
	
	
		
 
	buddy.SerializeToString(&message);

			




	
	
	
		
 

			




	
	
	
		
 
	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);

			




	
	
	
		
 

			




	
	
	
		
 
	Client *c = (Client *) user->getData();

			




	
	
	
		
 
	send(c->connection, message);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::handleBuddyAdded(Buddy *buddy, const Swift::RosterItemPayload &item) {

			




	
	
	
		
 
	handleBuddyUpdated(buddy, item);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::handleVCardRequired(User *user, const std::string &name, unsigned int id) {

			




	
	
	
		
 
	std::cout << "VCARD REQUIRED " << name << " " << id << "\n";

			




	
	
	
		
 
	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);

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    src/rostermanager.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -110,24 +110,30 @@ 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]->buddyChanged();

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
Buddy *RosterManager::getBuddy(const std::string &name) {

			




	
	
	
		
 
	return m_buddies[name];

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void RosterManager::sendRIE() {

			




	
	
	
		
 
	m_RIETimer->stop();

			




        

    


    
    

    

        

                

                    src/rosterresponder.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -74,36 +74,36 @@ bool RosterResponder::handleSetRequest(const Swift::JID& from, const Swift::JID&

			




	
	
	
		
 
		return true;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	if (payload->getItems().size() == 0) {

			




	
	
	
		
 
		return true;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	Swift::RosterItemPayload item = payload->getItems()[0];

			




	
	
	
		
 

			




	
	
	
		
 
	Buddy *buddy = user->getRosterManager()->getBuddy(Buddy::JIDToLegacyName(item.getJID()));

			




	
	
	
		
 
	if (buddy) {

			




	
	
	
		
 
		if (item.getSubscription() == Swift::RosterItemPayload::Remove) {

			




	
	
	
		
 
			std::cout << "BUDDY REMOVED\n";

			




	
	
	
		
 
			onBuddyRemoved(buddy);

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else {

			




	
	
	
		
 
			std::cout << "BUDDY UPDATED\n";

			




	
	
	
		
 
			onBuddyUpdated(buddy, item);

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else if (item.getSubscription() != Swift::RosterItemPayload::Remove) {

			




	
	
	
		
 
		// Roster push for this new buddy is sent by RosterManager

			




	
	
	
		
 
		BuddyInfo buddyInfo;

			




	
	
	
		
 
		buddyInfo.id = -1;

			




	
	
	
		
 
		buddyInfo.alias = item.getName();

			




	
	
	
		
 
		buddyInfo.legacyName = Buddy::JIDToLegacyName(item.getJID());

			




	
	
	
		
 
		buddyInfo.subscription = "both";

			




	
	
	
		
 
		buddyInfo.flags = 0;

			




	
	
	
		
 

			




	
	
	
		
 
		buddy = user->getComponent()->getFactory()->createBuddy(user->getRosterManager(), buddyInfo);

			




	
	
	
		
 
		user->getRosterManager()->setBuddy(buddy);

			




	
	
	
		
 
		std::cout << "BUDDY ADDED\n";

			




	
	
	
		
 
		onBuddyAdded(buddy, item);

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	return true;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
}

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: srv01-10621
    
    
        This site is powered by
            Kallithea,
        which is
        © 2010–2021 by various authors & licensed under GPLv3.
            – Support