Changeset - 098f6a995a82
Parent rev.
Child rev.
[Not reviewed]
1 5 1
Jan Kaluza - 14 years ago 2011-06-01 15:50:54
hanzz.k@gmail.com
handleVCardRequired callback
6 files changed with 53 insertions and 14 deletions:
include/transport/networkpluginserver.h
4
include/transport/usermanager.h
2
include/transport/vcardresponder.h
14
3
src/networkpluginserver.cpp
10
src/usermanager.cpp
5
src/vcardresponder.cpp
25
4
0 comments (0 inline, 0 general)
include/transport/networkpluginserver.h
➞
Show inline comments
 
@@ -28,24 +28,25 @@
 
#include "Swiften/Network/Connection.h"
 
#include "storagebackend.h"
 

			




	
	
	
		
 
namespace Transport {

			




	
	
	
		
 

			




	
	
	
		
 
class UserManager;

			




	
	
	
		
 
class User;

			




	
	
	
		
 
class Component;

			




	
	
	
		
 
class Buddy;

			




	
	
	
		
 
class LocalBuddy;

			




	
	
	
		
 
class Config;

			




	
	
	
		
 
class NetworkConversation;

			




	
	
	
		
 
class VCardResponder;

			




	
	
	
		
 

			




	
	
	
		
 
class NetworkPluginServer {

			




	
	
	
		
 
	public:

			




	
	
	
		
 
		struct Client {

			




	
	
	
		
 
			bool pongReceived;

			




	
	
	
		
 
			std::list<User *> users;

			




	
	
	
		
 
			std::string data;

			




	
	
	
		
 
			boost::shared_ptr<Swift::Connection> connection;

			




	
	
	
		
 
		};

			




	
	
	
		
 

			




	
	
	
		
 
		NetworkPluginServer(Component *component, Config *config, UserManager *userManager);

			




	
	
	
		
 

			




	
	
		
 
@@ -62,26 +63,29 @@ class NetworkPluginServer {

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
		void handleUserCreated(User *user);

			




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

			




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

			




	
	
	
		
 
		void handleUserReadyToConnect(User *user);

			




	
	
	
		
 
		void handleUserDestroyed(User *user);

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
		void send(boost::shared_ptr<Swift::Connection> &, const std::string &data);

			




	
	
	
		
 

			




	
	
	
		
 
		void pingTimeout();

			




	
	
	
		
 
		void sendPing(Client *c);

			




	
	
	
		
 
		Client *getFreeClient();

			




	
	
	
		
 

			




	
	
	
		
 
		UserManager *m_userManager;

			




	
	
	
		
 
		VCardResponder *m_vcardResponder;

			




	
	
	
		
 
		Config *m_config;

			




	
	
	
		
 
		boost::shared_ptr<Swift::ConnectionServer> m_server;

			




	
	
	
		
 
		std::list<Client *>  m_clients;

			




	
	
	
		
 
		Swift::Timer::ref m_pingTimer;

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    include/transport/usermanager.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -22,25 +22,24 @@

			




	
	
	
		
 

			




	
	
	
		
 
#include <string>

			




	
	
	
		
 
#include <map>

			




	
	
	
		
 
#include "Swiften/Swiften.h"

			




	
	
	
		
 

			




	
	
	
		
 
namespace Transport {

			




	
	
	
		
 

			




	
	
	
		
 
class User;

			




	
	
	
		
 
class Component;

			




	
	
	
		
 
class StorageBackend;

			




	
	
	
		
 
class StorageResponder;

			




	
	
	
		
 
class RosterResponder;

			




	
	
	
		
 
class VCardResponder;

			




	
	
	
		
 

			




	
	
	
		
 
/// Manages online XMPP Users.

			




	
	
	
		
 

			




	
	
	
		
 
/// This class handles presences and creates User classes when new user connects.

			




	
	
	
		
 
/// It also removes the User class once the last user's resource disconnected.

			




	
	
	
		
 
class UserManager {

			




	
	
	
		
 
	public:

			




	
	
	
		
 
		/// Creates new UserManager.

			




	
	
	
		
 
		/// \param component Component which's presence will be handled

			




	
	
	
		
 
		/// \param storageBackend Storage backend used to fetch UserInfos

			




	
	
	
		
 
		UserManager(Component *component, StorageBackend *storageBackend);

			




	
	
	
		
 

			




	
	
		
 
@@ -76,17 +75,16 @@ class UserManager {

			




	
	
	
		
 
		void handleProbePresence(Swift::Presence::ref presence);

			




	
	
	
		
 
		void handleSubscription(Swift::Presence::ref presence);

			




	
	
	
		
 
// 		void handleDiscoInfoResponse(boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid);

			




	
	
	
		
 
		void addUser(User *user);

			




	
	
	
		
 

			




	
	
	
		
 
		long m_onlineBuddies;

			




	
	
	
		
 
		User *m_cachedUser;

			




	
	
	
		
 
		std::map<std::string, User *> m_users;

			




	
	
	
		
 
		Component *m_component;

			




	
	
	
		
 
		StorageBackend *m_storageBackend;

			




	
	
	
		
 
		StorageResponder *m_storageResponder;

			




	
	
	
		
 
		RosterResponder *m_rosterResponder;

			




	
	
	
		
 
		VCardResponder *m_vcardResponder;

			




	
	
	
		
 
		friend class RosterResponder;

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    include/transport/vcardresponder.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
file renamed from src/vcardresponder.h to include/transport/vcardresponder.h

			




	
	
		
 
@@ -20,27 +20,38 @@

			




	
	
	
		
 

			




	
	
	
		
 
#pragma once

			




	
	
	
		
 

			




	
	
	
		
 
#include <vector>

			




	
	
	
		
 
#include "Swiften/Swiften.h"

			




	
	
	
		
 
#include "Swiften/Queries/Responder.h"

			




	
	
	
		
 
#include "Swiften/Elements/VCard.h"

			




	
	
	
		
 

			




	
	
	
		
 
namespace Transport {

			




	
	
	
		
 

			




	
	
	
		
 
class StorageBackend;

			




	
	
	
		
 
class UserManager;

			




	
	
	
		
 
class User;

			




	
	
	
		
 

			




	
	
	
		
 
class VCardResponder : public Swift::Responder<Swift::VCard> {

			




	
	
	
		
 
	public:

			




	
	
	
		
 
		VCardResponder(Swift::IQRouter *router, StorageBackend *storageBackend, UserManager *userManager);

			




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

			




	
	
	
		
 
		~VCardResponder();

			




	
	
	
		
 
		boost::signal<void (const Swift::JID& from, const Swift::JID& to, const std::string& id)> onVCardRequired;

			




	
	
	
		
 

			




	
	
	
		
 
		void sendVCard(unsigned int id, boost::shared_ptr<Swift::VCard> vcard);

			




	
	
	
		
 

			




	
	
	
		
 
		boost::signal<void (User *, const std::string &name, unsigned int id)> onVCardRequired;

			




	
	
	
		
 

			




	
	
	
		
 
	private:

			




	
	
	
		
 
		struct VCardData {

			




	
	
	
		
 
			Swift::JID from;

			




	
	
	
		
 
			Swift::JID to;

			




	
	
	
		
 
			std::string id;

			




	
	
	
		
 
		};

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
		StorageBackend *m_storageBackend;

			




	
	
	
		
 
		UserManager *m_userManager;

			




	
	
	
		
 
		std::map<unsigned int, VCardData> m_queries;

			




	
	
	
		
 
		unsigned int m_id;

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
}

			




	
	
		
 
\ No newline at end of file

			




        

    


    
    

    

        

                

                    src/networkpluginserver.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -19,24 +19,25 @@

			




	
	
	
		
 
 */

			




	
	
	
		
 

			




	
	
	
		
 
#include "transport/networkpluginserver.h"

			




	
	
	
		
 
#include "transport/user.h"

			




	
	
	
		
 
#include "transport/transport.h"

			




	
	
	
		
 
#include "transport/storagebackend.h"

			




	
	
	
		
 
#include "transport/rostermanager.h"

			




	
	
	
		
 
#include "transport/usermanager.h"

			




	
	
	
		
 
#include "transport/conversationmanager.h"

			




	
	
	
		
 
#include "transport/localbuddy.h"

			




	
	
	
		
 
#include "transport/config.h"

			




	
	
	
		
 
#include "transport/conversation.h"

			




	
	
	
		
 
#include "transport/vcardresponder.h"

			




	
	
	
		
 
#include "Swiften/Swiften.h"

			




	
	
	
		
 
#include "Swiften/Server/ServerStanzaChannel.h"

			




	
	
	
		
 
#include "Swiften/Elements/StreamError.h"

			




	
	
	
		
 
#include "pbnetwork.pb.h"

			




	
	
	
		
 
#include "sys/wait.h"

			




	
	
	
		
 
#include "sys/signal.h"

			




	
	
	
		
 

			




	
	
	
		
 
namespace Transport {

			




	
	
	
		
 

			




	
	
	
		
 
class NetworkConversation : public Conversation {

			




	
	
	
		
 
	public:

			




	
	
	
		
 
		NetworkConversation(ConversationManager *conversationManager, const std::string &legacyName, bool muc = false) : Conversation(conversationManager, legacyName, muc) {

			




	
	
		
 
@@ -109,35 +110,40 @@ static void handleBuddyPayload(LocalBuddy *buddy, const pbnetwork::Buddy &payloa

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
NetworkPluginServer::NetworkPluginServer(Component *component, Config *config, UserManager *userManager) {

			




	
	
	
		
 
	m_userManager = userManager;

			




	
	
	
		
 
	m_config = config;

			




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

			




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

			




	
	
	
		
 
	m_server->start();

			




	
	
	
		
 

			




	
	
	
		
 
	signal(SIGCHLD, SigCatcher);

			




	
	
	
		
 

			




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

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
NetworkPluginServer::~NetworkPluginServer() {

			




	
	
	
		
 
	m_pingTimer->stop();

			




	
	
	
		
 
	delete m_vcardResponder;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::handleNewClientConnection(boost::shared_ptr<Swift::Connection> c) {

			




	
	
	
		
 
	Client *client = new Client;

			




	
	
	
		
 
	client->pongReceived = true;

			




	
	
	
		
 
	client->connection = c;

			




	
	
	
		
 

			




	
	
	
		
 
	m_clients.push_back(client);

			




	
	
	
		
 

			




	
	
	
		
 
	c->onDisconnected.connect(boost::bind(&NetworkPluginServer::handleSessionFinished, this, client));

			




	
	
	
		
 
	c->onDataRead.connect(boost::bind(&NetworkPluginServer::handleDataRead, this, client, _1));

			




	
	
	
		
 
	sendPing(client);

			




	
	
		
 
@@ -471,24 +477,28 @@ 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::handleVCardRequired(User *user, const std::string &name, unsigned int id) {

			




	
	
	
		
 
	

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::sendPing(Client *c) {

			




	
	
	
		
 

			




	
	
	
		
 
	std::string message;

			




	
	
	
		
 
	pbnetwork::WrapperMessage wrap;

			




	
	
	
		
 
	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_PING);

			




	
	
	
		
 
	wrap.SerializeToString(&message);

			




	
	
	
		
 

			




	
	
	
		
 
	send(c->connection, message);

			




	
	
	
		
 
	c->pongReceived = false;

			




	
	
	
		
 
	std::cout << "SENDING PING\n";

			




	
	
	
		
 
}

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    src/usermanager.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -17,54 +17,49 @@

			




	
	
	
		
 
 * along with this program; if not, write to the Free Software

			




	
	
	
		
 
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

			




	
	
	
		
 
 */

			




	
	
	
		
 

			




	
	
	
		
 
#include "transport/usermanager.h"

			




	
	
	
		
 
#include "transport/user.h"

			




	
	
	
		
 
#include "transport/transport.h"

			




	
	
	
		
 
#include "transport/storagebackend.h"

			




	
	
	
		
 
#include "transport/conversationmanager.h"

			




	
	
	
		
 
#include "transport/rostermanager.h"

			




	
	
	
		
 
#include "storageresponder.h"

			




	
	
	
		
 
#include "rosterresponder.h"

			




	
	
	
		
 
#include "vcardresponder.h"

			




	
	
	
		
 

			




	
	
	
		
 
namespace Transport {

			




	
	
	
		
 

			




	
	
	
		
 
UserManager::UserManager(Component *component, StorageBackend *storageBackend) {

			




	
	
	
		
 
	m_cachedUser = NULL;

			




	
	
	
		
 
	m_onlineBuddies = 0;

			




	
	
	
		
 
	m_component = component;

			




	
	
	
		
 
	m_storageBackend = storageBackend;

			




	
	
	
		
 

			




	
	
	
		
 
	m_storageResponder = new StorageResponder(component->getIQRouter(), m_storageBackend, this);

			




	
	
	
		
 
	m_storageResponder->start();

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	m_rosterResponder->start();

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	m_vcardResponder->start();

			




	
	
	
		
 

			




	
	
	
		
 
	component->onUserPresenceReceived.connect(bind(&UserManager::handlePresence, this, _1));

			




	
	
	
		
 
	m_component->getStanzaChannel()->onMessageReceived.connect(bind(&UserManager::handleMessageReceived, this, _1));

			




	
	
	
		
 
	m_component->getStanzaChannel()->onPresenceReceived.connect(bind(&UserManager::handleGeneralPresenceReceived, this, _1));

			




	
	
	
		
 
// 	component->onDiscoInfoResponse.connect(bind(&UserManager::handleDiscoInfoResponse, this, _1, _2, _3));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
UserManager::~UserManager(){

			




	
	
	
		
 
	m_storageResponder->stop();

			




	
	
	
		
 
	delete m_storageResponder;

			




	
	
	
		
 
	delete m_rosterResponder;

			




	
	
	
		
 
	delete m_vcardResponder;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void UserManager::addUser(User *user) {

			




	
	
	
		
 
	m_users[user->getJID().toBare().toString()] = user;

			




	
	
	
		
 
	onUserCreated(user);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
User *UserManager::getUser(const std::string &barejid){

			




	
	
	
		
 
	if (m_cachedUser && barejid == m_cachedUser->getJID().toBare().toString()) {

			




	
	
	
		
 
		return m_cachedUser;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    src/vcardresponder.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -9,48 +9,69 @@

			




	
	
	
		
 
 * (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 "vcardresponder.h"

			




	
	
	
		
 
#include "transport/vcardresponder.h"

			




	
	
	
		
 

			




	
	
	
		
 
#include <iostream>

			




	
	
	
		
 
#include <boost/bind.hpp>

			




	
	
	
		
 
#include "Swiften/Queries/IQRouter.h"

			




	
	
	
		
 
#include "Swiften/Swiften.h"

			




	
	
	
		
 
#include "transport/user.h"

			




	
	
	
		
 
#include "transport/usermanager.h"

			




	
	
	
		
 
#include "transport/rostermanager.h"

			




	
	
	
		
 

			




	
	
	
		
 
using namespace Swift;

			




	
	
	
		
 
using namespace boost;

			




	
	
	
		
 

			




	
	
	
		
 
namespace Transport {

			




	
	
	
		
 

			




	
	
	
		
 
VCardResponder::VCardResponder(Swift::IQRouter *router, StorageBackend *storageBackend, UserManager *userManager) : Swift::Responder<VCard>(router) {

			




	
	
	
		
 
	m_storageBackend = storageBackend;

			




	
	
	
		
 
VCardResponder::VCardResponder(Swift::IQRouter *router, UserManager *userManager) : Swift::Responder<VCard>(router) {

			




	
	
	
		
 
	m_id = 0;

			




	
	
	
		
 
	m_userManager = userManager;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
VCardResponder::~VCardResponder() {

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void VCardResponder::sendVCard(unsigned int id, boost::shared_ptr<Swift::VCard> vcard) {

			




	
	
	
		
 
	if (m_queries.find(id) == m_queries.end())

			




	
	
	
		
 
		return;

			




	
	
	
		
 

			




	
	
	
		
 
	sendResponse(m_queries[id].to, m_queries[id].from, m_queries[id].id, vcard);

			




	
	
	
		
 
	m_queries.erase(id);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool VCardResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::VCard> payload) {

			




	
	
	
		
 
	// Get means we're in server mode and user wants to fetch his roster.

			




	
	
	
		
 
	// For now we send empty reponse, but TODO: Get buddies from database and send proper stored roster.

			




	
	
	
		
 
	onVCardRequired(from, to, id);

			




	
	
	
		
 
	User *user = m_userManager->getUser(from.toBare().toString());

			




	
	
	
		
 
	if (!user) {

			




	
	
	
		
 
		return false;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	std::string name = to.getUnescapedNode();

			




	
	
	
		
 
	if (name.find_last_of("%") != std::string::npos) {

			




	
	
	
		
 
		name.replace(name.find_last_of("%"), 1, "@");

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	m_queries[m_id].from = from;

			




	
	
	
		
 
	m_queries[m_id].to = to;

			




	
	
	
		
 
	m_queries[m_id].id = id; 

			




	
	
	
		
 
	onVCardRequired(user, name, m_id++);

			




	
	
	
		
 
	return true;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool VCardResponder::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::VCard> payload) {

			




	
	
	
		
 
	sendResponse(from, id, boost::shared_ptr<VCard>(new VCard()));

			




	
	
	
		
 
	return true;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
}

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








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