Changeset - 7e8720849725
Parent rev.
Child rev.
[Not reviewed]
0 13 0
Jan Kaluza - 14 years ago 2011-09-07 14:03:27
hanzz.k@gmail.com
Fixed spectrum2 compilation with MSVC. Thanks to Vitaly Takmazov
13 files changed with 61 insertions and 36 deletions:
include/Swiften/TLS/OpenSSL/OpenSSLServerContext.cpp
3
3
include/transport/buddy.h
1
1
include/transport/sqlite3backend.h
1
1
spectrum/src/main.cpp
14
4
src/logger.cpp
12
12
src/memoryusage.cpp
2
src/networkplugin.cpp
4
src/networkpluginserver.cpp
3
3
src/rostermanager.cpp
9
6
src/sqlite3backend.cpp
1
1
src/transport.cpp
5
5
src/user.cpp
4
src/usermanager.cpp
2
0 comments (0 inline, 0 general)
include/Swiften/TLS/OpenSSL/OpenSSLServerContext.cpp
➞
Show inline comments
 
@@ -9,27 +9,27 @@
 
#include <windows.h>
 
#include <wincrypt.h>
 
#endif
 

			




	
	
	
		
 
#include <vector>

			




	
	
	
		
 
#include <openssl/err.h>

			




	
	
	
		
 
#include <openssl/pkcs12.h>

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
#include "Swiften/TLS/OpenSSL/OpenSSLServerContext.h"

			




	
	
	
		
 
#include "Swiften/TLS/OpenSSL/OpenSSLCertificate.h"

			




	
	
	
		
 
#include "Swiften/TLS/PKCS12Certificate.h"

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef _MSC_VER

			




	
	
	
		
 
#pragma GCC diagnostic ignored "-Wold-style-cast"

			




	
	
	
		
 

			




	
	
	
		
 
#endif

			




	
	
	
		
 
namespace Swift {

			




	
	
	
		
 

			




	
	
	
		
 
static const int MAX_FINISHED_SIZE = 4096;

			




	
	
	
		
 
static const int SSL_READ_BUFFERSIZE = 8192;

			




	
	
	
		
 

			




	
	
	
		
 
static void freeX509Stack(STACK_OF(X509)* stack) {

			




	
	
	
		
 
	sk_X509_free(stack);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
// static int _sx_ssl_verify_callback(int preverify_ok, X509_STORE_CTX *ctx) {

			




	
	
	
		
 
// 	return 1;

			




	
	
	
		
 
// }

			




	
	
		
 
@@ -41,25 +41,25 @@ OpenSSLServerContext::OpenSSLServerContext() : state_(Start), context_(0), handl

			




	
	
	
		
 

			




	
	
	
		
 
	// Load system certs

			




	
	
	
		
 
#if defined(SWIFTEN_PLATFORM_WINDOWS)

			




	
	
	
		
 
	X509_STORE* store = SSL_CTX_get_cert_store(context_);

			




	
	
	
		
 
	HCERTSTORE systemStore = CertOpenSystemStore(0, "ROOT");

			




	
	
	
		
 
	if (systemStore) {

			




	
	
	
		
 
		PCCERT_CONTEXT certContext = NULL;

			




	
	
	
		
 
		while (true) {

			




	
	
	
		
 
			certContext = CertFindCertificateInStore(systemStore, X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, 0, CERT_FIND_ANY, NULL, certContext);

			




	
	
	
		
 
			if (!certContext) {

			




	
	
	
		
 
				break;

			




	
	
	
		
 
			}

			




	
	
	
		
 
			ByteArray certData(certContext->pbCertEncoded, certContext->cbCertEncoded);

			




	
	
	
		
 
			ByteArray certData(createByteArray(certContext->pbCertEncoded, certContext->cbCertEncoded));

			




	
	
	
		
 
			OpenSSLCertificate cert(certData);

			




	
	
	
		
 
			if (store && cert.getInternalX509()) {

			




	
	
	
		
 
				X509_STORE_add_cert(store, cert.getInternalX509().get());

			




	
	
	
		
 
			}

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 
#elif !defined(SWIFTEN_PLATFORM_MACOSX)

			




	
	
	
		
 
	SSL_CTX_load_verify_locations(context_, NULL, "/etc/ssl/certs");

			




	
	
	
		
 
#endif

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
OpenSSLServerContext::~OpenSSLServerContext() {

			




        

    


    
    

    

        

                

                    include/transport/buddy.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -78,25 +78,25 @@ class Buddy {

			




	
	
	
		
 
		/// than the previously generated one.

			




	
	
	
		
 
		/// \return Presence stanza or NULL.

			




	
	
	
		
 
		Swift::Presence::ref generatePresenceStanza(int features, bool only_new = false);

			




	
	
	
		
 

			




	
	
	
		
 
		void setBlocked(bool block) {

			




	
	
	
		
 
			if (block)

			




	
	
	
		
 
				m_flags = (BuddyFlag) (m_flags | BUDDY_BLOCKED);

			




	
	
	
		
 
			else

			




	
	
	
		
 
				m_flags = (BuddyFlag) (m_flags & ~BUDDY_BLOCKED);

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		bool isBlocked() {

			




	
	
	
		
 
			return m_flags & BUDDY_BLOCKED;

			




	
	
	
		
 
			return (m_flags & BUDDY_BLOCKED)  != 0;

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		/// Sets current subscription.

			




	
	
	
		
 

			




	
	
	
		
 
		/// \param subscription "to", "from", "both", "ask"

			




	
	
	
		
 
		void setSubscription(const std::string &subscription);

			




	
	
	
		
 

			




	
	
	
		
 
		/// Returns current subscription

			




	
	
	
		
 

			




	
	
	
		
 
		/// \return subscription "to", "from", "both", "ask"

			




	
	
	
		
 
		const std::string getSubscription();

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    include/transport/sqlite3backend.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -16,25 +16,25 @@

			




	
	
	
		
 
 * You should have received a copy of the GNU General Public License

			




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

			




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

			




	
	
	
		
 
 */

			




	
	
	
		
 

			




	
	
	
		
 
#pragma once

			




	
	
	
		
 

			




	
	
	
		
 
#include <string>

			




	
	
	
		
 
#include <map>

			




	
	
	
		
 
#include "Swiften/Swiften.h"

			




	
	
	
		
 
#include "transport/storagebackend.h"

			




	
	
	
		
 
#include "transport/config.h"

			




	
	
	
		
 
#include <sqlite3.h>

			




	
	
	
		
 
#include "sqlite3.h"

			




	
	
	
		
 

			




	
	
	
		
 
namespace Transport {

			




	
	
	
		
 

			




	
	
	
		
 
/// Used to store transport data into SQLite3 database.

			




	
	
	
		
 
class SQLite3Backend : public StorageBackend

			




	
	
	
		
 
{

			




	
	
	
		
 
	public:

			




	
	
	
		
 
		/// Creates new SQLite3Backend instance.

			




	
	
	
		
 
		/// \param config cofiguration, this class uses following Config values:

			




	
	
	
		
 
		/// 	- database.database - path to SQLite3 database file, database file is created automatically

			




	
	
	
		
 
		/// 	- service.prefix - prefix for tables created by createDatabase method

			




	
	
	
		
 
		SQLite3Backend(Config *config);

			




        

    


    
    

    

        

                

                    spectrum/src/main.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
#include "transport/config.h"

			




	
	
	
		
 
#include "transport/transport.h"

			




	
	
	
		
 
#include "transport/usermanager.h"

			




	
	
	
		
 
#include "transport/logger.h"

			




	
	
	
		
 
#include "transport/sqlite3backend.h"

			




	
	
	
		
 
#include "transport/mysqlbackend.h"

			




	
	
	
		
 
//#include "transport/mysqlbackend.h"

			




	
	
	
		
 
#include "transport/userregistration.h"

			




	
	
	
		
 
#include "transport/networkpluginserver.h"

			




	
	
	
		
 
#include "transport/admininterface.h"

			




	
	
	
		
 
#include "Swiften/EventLoop/SimpleEventLoop.h"

			




	
	
	
		
 
#ifndef WIN32

			




	
	
	
		
 
#include "sys/signal.h"

			




	
	
	
		
 
#else

			




	
	
	
		
 
#include <Windows.h>

			




	
	
	
		
 
#include <tchar.h>

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#include "log4cxx/logger.h"

			




	
	
	
		
 
#include "log4cxx/patternlayout.h"

			




	
	
	
		
 
#include "log4cxx/propertyconfigurator.h"

			




	
	
	
		
 
#include "log4cxx/consoleappender.h"

			




	
	
	
		
 

			




	
	
	
		
 
using namespace log4cxx;

			




	
	
	
		
 

			




	
	
	
		
 
using namespace Transport;

			




	
	
	
		
 

			




	
	
	
		
 
Swift::SimpleEventLoop *eventLoop_ = NULL;

			




	
	
	
		
 

			




	
	
	
		
 
static void spectrum_sigint_handler(int sig) {

			




	
	
	
		
 
	eventLoop_->stop();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
static void spectrum_sigterm_handler(int sig) {

			




	
	
	
		
 
	eventLoop_->stop();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
int main(int argc, char **argv)

			




	
	
	
		
 
{

			




	
	
	
		
 
	Config config;

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef WIN32

			




	
	
	
		
 
	if (signal(SIGINT, spectrum_sigint_handler) == SIG_ERR) {

			




	
	
	
		
 
		std::cout << "SIGINT handler can't be set\n";

			




	
	
	
		
 
		return -1;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	if (signal(SIGTERM, spectrum_sigterm_handler) == SIG_ERR) {

			




	
	
	
		
 
		std::cout << "SIGTERM handler can't be set\n";

			




	
	
	
		
 
		return -1;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
#endif

			




	
	
	
		
 
	boost::program_options::options_description desc("Usage: spectrum [OPTIONS] <config_file.cfg>\nAllowed options");

			




	
	
	
		
 
	desc.add_options()

			




	
	
	
		
 
		("help,h", "help")

			




	
	
	
		
 
		("no-daemonize,n", "Do not run spectrum as daemon")

			




	
	
	
		
 
		;

			




	
	
	
		
 
	try

			




	
	
	
		
 
	{

			




	
	
	
		
 
		boost::program_options::variables_map vm;

			




	
	
	
		
 
		boost::program_options::store(boost::program_options::parse_command_line(argc, argv, desc), vm);

			




	
	
	
		
 
		boost::program_options::notify(vm);

			




	
	
	
		
 
		if(vm.count("help"))

			




	
	
	
		
 
		{

			




	
	
		
 
@@ -73,55 +78,60 @@ int main(int argc, char **argv)

			




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

			




	
	
	
		
 
		return 1;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
	if (!config.load(argv[1])) {

			




	
	
	
		
 
		std::cerr << "Can't load configuration file.\n";

			




	
	
	
		
 
		return 1;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	if (CONFIG_STRING(&config, "logging.config").empty()) {

			




	
	
	
		
 
		LoggerPtr root = log4cxx::Logger::getRootLogger();

			




	
	
	
		
 
#ifdef WIN32

			




	
	
	
		
 
		root->addAppender(new ConsoleAppender(new PatternLayout(L"%d %-5p %c: %m%n")));

			




	
	
	
		
 
#else

			




	
	
	
		
 
		root->addAppender(new ConsoleAppender(new PatternLayout("%d %-5p %c: %m%n")));

			




	
	
	
		
 
#endif

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else {

			




	
	
	
		
 
		log4cxx::PropertyConfigurator::configure(CONFIG_STRING(&config, "logging.config"));

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	Swift::SimpleEventLoop eventLoop;

			




	
	
	
		
 

			




	
	
	
		
 
	Swift::BoostNetworkFactories *factories = new Swift::BoostNetworkFactories(&eventLoop);

			




	
	
	
		
 
	UserRegistry userRegistry(&config, factories);

			




	
	
	
		
 

			




	
	
	
		
 
	Component transport(&eventLoop, factories, &config, NULL, &userRegistry);

			




	
	
	
		
 
// 	Logger logger(&transport);

			




	
	
	
		
 

			




	
	
	
		
 
	StorageBackend *storageBackend = NULL;

			




	
	
	
		
 

			




	
	
	
		
 
	if (CONFIG_STRING(&config, "database.type") == "sqlite3") {

			




	
	
	
		
 
		storageBackend = new SQLite3Backend(&config);

			




	
	
	
		
 
		if (!storageBackend->connect()) {

			




	
	
	
		
 
			std::cerr << "Can't connect to database.\n";

			




	
	
	
		
 
			return -1;

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 
/*

			




	
	
	
		
 
	else if (CONFIG_STRING(&config, "database.type") == "mysql") {

			




	
	
	
		
 
		storageBackend = new MySQLBackend(&config);

			




	
	
	
		
 
		if (!storageBackend->connect()) {

			




	
	
	
		
 
			std::cerr << "Can't connect to database.\n";

			




	
	
	
		
 
			return -1;

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
*/

			




	
	
	
		
 
	UserManager userManager(&transport, &userRegistry, storageBackend);

			




	
	
	
		
 
	UserRegistration *userRegistration = NULL;

			




	
	
	
		
 
	if (storageBackend) {

			




	
	
	
		
 
		userRegistration = new UserRegistration(&transport, &userManager, storageBackend);

			




	
	
	
		
 
		userRegistration->start();

			




	
	
	
		
 
// 		logger.setUserRegistration(&userRegistration);

			




	
	
	
		
 
	}

			




	
	
	
		
 
// 	logger.setUserManager(&userManager);

			




	
	
	
		
 

			




	
	
	
		
 
	NetworkPluginServer plugin(&transport, &config, &userManager);

			




	
	
	
		
 

			




	
	
	
		
 
	AdminInterface adminInterface(&transport, &userManager, &plugin, storageBackend);

			




        

    


    
    

    

        

                

                    src/logger.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -24,51 +24,51 @@

			




	
	
	
		
 
#include "transport/transport.h"

			




	
	
	
		
 
#include "transport/storagebackend.h"

			




	
	
	
		
 
#include "transport/userregistration.h"

			




	
	
	
		
 
#include "transport/buddy.h"

			




	
	
	
		
 
#include "transport/rostermanager.h"

			




	
	
	
		
 
#include <boost/bind.hpp>

			




	
	
	
		
 

			




	
	
	
		
 
using namespace boost;

			




	
	
	
		
 

			




	
	
	
		
 
namespace Transport {

			




	
	
	
		
 

			




	
	
	
		
 
Logger::Logger(Component *component) {

			




	
	
	
		
 
	component->onConnected.connect(bind(&Logger::handleConnected, this));

			




	
	
	
		
 
	component->onConnectionError.connect(bind(&Logger::handleConnectionError, this, _1));

			




	
	
	
		
 
	component->onXMLIn.connect(bind(&Logger::handleXMLIn, this, _1));

			




	
	
	
		
 
	component->onXMLOut.connect(bind(&Logger::handleXMLOut, this, _1));

			




	
	
	
		
 
	component->onConnected.connect(boost::bind(&Logger::handleConnected, this));

			




	
	
	
		
 
	component->onConnectionError.connect(boost::bind(&Logger::handleConnectionError, this, _1));

			




	
	
	
		
 
	component->onXMLIn.connect(boost::bind(&Logger::handleXMLIn, this, _1));

			




	
	
	
		
 
	component->onXMLOut.connect(boost::bind(&Logger::handleXMLOut, this, _1));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
Logger::~Logger(){

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Logger::setStorageBackend(StorageBackend *storage) {

			




	
	
	
		
 
	storage->onStorageError.connect(bind(&Logger::handleStorageError, this, _1, _2));

			




	
	
	
		
 
	storage->onStorageError.connect(boost::bind(&Logger::handleStorageError, this, _1, _2));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Logger::setUserRegistration(UserRegistration *userRegistration) {

			




	
	
	
		
 
	userRegistration->onUserRegistered.connect(bind(&Logger::handleUserRegistered, this, _1));

			




	
	
	
		
 
	userRegistration->onUserUnregistered.connect(bind(&Logger::handleUserUnregistered, this, _1));

			




	
	
	
		
 
	userRegistration->onUserUpdated.connect(bind(&Logger::handleUserUpdated, this, _1));

			




	
	
	
		
 
	userRegistration->onUserRegistered.connect(boost::bind(&Logger::handleUserRegistered, this, _1));

			




	
	
	
		
 
	userRegistration->onUserUnregistered.connect(boost::bind(&Logger::handleUserUnregistered, this, _1));

			




	
	
	
		
 
	userRegistration->onUserUpdated.connect(boost::bind(&Logger::handleUserUpdated, this, _1));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Logger::setUserManager(UserManager *userManager) {

			




	
	
	
		
 
	userManager->onUserCreated.connect(bind(&Logger::handleUserCreated, this, _1));

			




	
	
	
		
 
	userManager->onUserDestroyed.connect(bind(&Logger::handleUserDestroyed, this, _1));

			




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

			




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

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Logger::setRosterManager(RosterManager *rosterManager) {

			




	
	
	
		
 
	rosterManager->onBuddySet.connect(bind(&Logger::handleBuddySet, this, _1));

			




	
	
	
		
 
	rosterManager->onBuddyUnset.connect(bind(&Logger::handleBuddyUnset, this, _1));

			




	
	
	
		
 
	rosterManager->onBuddySet.connect(boost::bind(&Logger::handleBuddySet, this, _1));

			




	
	
	
		
 
	rosterManager->onBuddyUnset.connect(boost::bind(&Logger::handleBuddyUnset, this, _1));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Logger::handleConnected() {

			




	
	
	
		
 
	std::cout << "[COMPONENT] Connected to Jabber Server!\n";

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Logger::handleConnectionError(const Swift::ComponentError &error) {

			




	
	
	
		
 
	std::cout << "[COMPONENT] Connection Error!\n";

			




	
	
	
		
 
	switch (error.getType()) {

			




	
	
	
		
 
		case Swift::ComponentError::UnknownError: std::cout << "[COMPONENT] Disconnect reason: UnknownError\n"; break;

			




	
	
	
		
 
		case Swift::ComponentError::ConnectionError: std::cout << "[COMPONENT] Disconnect reason: ConnectionError\n"; break;

			




	
	
	
		
 
		case Swift::ComponentError::ConnectionReadError: std::cout << "[COMPONENT] Disconnect reason: ConnectionReadError\n"; break;

			




        

    


    
    

    

        

                

                    src/memoryusage.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -16,25 +16,27 @@

			




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

			




	
	
	
		
 

			




	
	
	
		
 
#include <iostream>

			




	
	
	
		
 
#include <cstring>

			




	
	
	
		
 
#include <sstream>

			




	
	
	
		
 
#include <fstream>

			




	
	
	
		
 
#include <algorithm>

			




	
	
	
		
 
#ifndef WIN32

			




	
	
	
		
 
#include <sys/param.h>

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#ifdef BSD

			




	
	
	
		
 
#include <sys/types.h>

			




	
	
	
		
 
#include <sys/sysctl.h>

			




	
	
	
		
 
#include <sys/param.h>

			




	
	
	
		
 
#include <sys/sysctl.h>

			




	
	
	
		
 
#include <sys/user.h>

			




	
	
	
		
 

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
namespace Transport {

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef WIN32

			




        

    


    
    

    

        

                

                    src/networkplugin.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -51,25 +51,27 @@ NetworkPlugin::NetworkPlugin(Swift::EventLoop *loop, const std::string &host, in

			




	
	
	
		
 
	m_pingReceived = false;

			




	
	
	
		
 
	m_loop = loop;

			




	
	
	
		
 
	m_conn = m_factories->getConnectionFactory()->createConnection();

			




	
	
	
		
 
	m_conn->onDataRead.connect(boost::bind(&NetworkPlugin::handleDataRead, this, _1));

			




	
	
	
		
 
	m_conn->onConnectFinished.connect(boost::bind(&NetworkPlugin::_handleConnected, this, _1));

			




	
	
	
		
 
	m_conn->onDisconnected.connect(boost::bind(&NetworkPlugin::handleDisconnected, this));

			




	
	
	
		
 

			




	
	
	
		
 
	m_pingTimer = m_factories->getTimerFactory()->createTimer(30000);

			




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

			




	
	
	
		
 
	connect();

			




	
	
	
		
 

			




	
	
	
		
 
	double shared;

			




	
	
	
		
 
#ifndef WIN32

			




	
	
	
		
 
	process_mem_usage(shared, m_init_res);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
NetworkPlugin::~NetworkPlugin() {

			




	
	
	
		
 
	delete m_factories;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPlugin::handleMessage(const std::string &user, const std::string &legacyName, const std::string &msg, const std::string &nickname, const std::string &xhtml) {

			




	
	
	
		
 
	pbnetwork::ConversationMessage m;

			




	
	
	
		
 
	m.set_username(user);

			




	
	
	
		
 
	m.set_buddyname(legacyName);

			




	
	
	
		
 
	m.set_message(msg);

			




	
	
	
		
 
	m.set_nickname(nickname);

			




	
	
		
 
@@ -500,25 +502,27 @@ void NetworkPlugin::sendPong() {

			




	
	
	
		
 

			




	
	
	
		
 
	send(message);

			




	
	
	
		
 
	LOG4CXX_INFO(logger, "PONG");

			




	
	
	
		
 
	sendMemoryUsage();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPlugin::sendMemoryUsage() {

			




	
	
	
		
 
	pbnetwork::Stats stats;

			




	
	
	
		
 

			




	
	
	
		
 
	stats.set_init_res(m_init_res);

			




	
	
	
		
 
	double res;

			




	
	
	
		
 
	double shared;

			




	
	
	
		
 
#ifndef WIN32

			




	
	
	
		
 
	process_mem_usage(shared, res);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
	stats.set_res(res);

			




	
	
	
		
 
	stats.set_shared(shared);

			




	
	
	
		
 

			




	
	
	
		
 
	std::string message;

			




	
	
	
		
 
	stats.SerializeToString(&message);

			




	
	
	
		
 

			




	
	
	
		
 
	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_STATS);

			




	
	
	
		
 

			




	
	
	
		
 
	send(message);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPlugin::pingTimeout() {

			




        

    


    
    

    

        

                

                    src/networkpluginserver.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -115,26 +115,26 @@ static unsigned long exec_(std::string path, const char *host, const char *port,

			




	
	
	
		
 
	// Add host and port.

			




	
	
	
		
 
	path += std::string(" --host ") + host + " --port " + port + " " + config;

			




	
	
	
		
 
	LOG4CXX_INFO(logger, "Starting new backend " << path);

			




	
	
	
		
 

			




	
	
	
		
 
#ifdef _WIN32

			




	
	
	
		
 
	STARTUPINFO         si;

			




	
	
	
		
 
	PROCESS_INFORMATION pi;

			




	
	
	
		
 

			




	
	
	
		
 
	ZeroMemory (&si, sizeof(si));

			




	
	
	
		
 
	si.cb=sizeof (si);

			




	
	
	
		
 

			




	
	
	
		
 
	if (! CreateProcess(

			




	
	
	
		
 
	original_path.c_str(),

			




	
	
	
		
 
	path.c_str(),         // command line

			




	
	
	
		
 
	NULL,

			




	
	
	
		
 
	(LPSTR)path.c_str(),         // command line

			




	
	
	
		
 
	0,                    // process attributes

			




	
	
	
		
 
	0,                    // thread attributes

			




	
	
	
		
 
	0,                    // inherit handles

			




	
	
	
		
 
	0,                    // creation flags

			




	
	
	
		
 
	0,                    // environment

			




	
	
	
		
 
	0,                    // cwd

			




	
	
	
		
 
	&si,

			




	
	
	
		
 
	&pi

			




	
	
	
		
 
	)

			




	
	
	
		
 
	)  {

			




	
	
	
		
 
		LOG4CXX_ERROR(logger, "Could not start process");

			




	
	
	
		
 
	}

			




	
	
		
 
@@ -1069,25 +1069,25 @@ void NetworkPluginServer::handleBuddyAdded(Buddy *buddy, const Swift::RosterItem

			




	
	
	
		
 
	handleBuddyUpdated(buddy, item);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 
	buddy.set_blocked(not b->isBlocked());

			




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

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/rostermanager.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -23,49 +23,52 @@

			




	
	
	
		
 
#include "transport/storagebackend.h"

			




	
	
	
		
 
#include "transport/buddy.h"

			




	
	
	
		
 
#include "transport/usermanager.h"

			




	
	
	
		
 
#include "transport/buddy.h"

			




	
	
	
		
 
#include "transport/user.h"

			




	
	
	
		
 
#include "Swiften/Roster/SetRosterRequest.h"

			




	
	
	
		
 
#include "Swiften/Elements/RosterPayload.h"

			




	
	
	
		
 
#include "Swiften/Elements/RosterItemPayload.h"

			




	
	
	
		
 
#include "Swiften/Elements/RosterItemExchangePayload.h"

			




	
	
	
		
 
#include "log4cxx/logger.h"

			




	
	
	
		
 
#include <boost/foreach.hpp>

			




	
	
	
		
 

			




	
	
	
		
 
#include <map>

			




	
	
	
		
 
#include <iterator>

			




	
	
	
		
 

			




	
	
	
		
 
using namespace log4cxx;

			




	
	
	
		
 

			




	
	
	
		
 
namespace Transport {

			




	
	
	
		
 

			




	
	
	
		
 
static LoggerPtr logger = Logger::getLogger("RosterManager");

			




	
	
	
		
 

			




	
	
	
		
 
RosterManager::RosterManager(User *user, Component *component){

			




	
	
	
		
 
	m_rosterStorage = NULL;

			




	
	
	
		
 
	m_user = user;

			




	
	
	
		
 
	m_component = component;

			




	
	
	
		
 
	m_setBuddyTimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(1000);

			




	
	
	
		
 
	m_RIETimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(5000);

			




	
	
	
		
 
	m_RIETimer->onTick.connect(boost::bind(&RosterManager::sendRIE, this));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
RosterManager::~RosterManager() {

			




	
	
	
		
 
	m_setBuddyTimer->stop();

			




	
	
	
		
 
	m_RIETimer->stop();

			




	
	
	
		
 
	if (m_rosterStorage) {

			




	
	
	
		
 
		m_rosterStorage->storeBuddies();

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	sendUnavailablePresences(m_user->getJID().toBare());

			




	
	
	
		
 

			




	
	
	
		
 
	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {

			




	
	
	
		
 
	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;

			




	
	
	
		
 
		}

			




	
	
	
		
 
		delete buddy;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	if (m_requests.size() != 0) {

			




	
	
	
		
 
		LOG4CXX_INFO(logger, m_user->getJID().toString() <<  ": Removing " << m_requests.size() << " unresponded IQs");

			




	
	
	
		
 
		BOOST_FOREACH(Swift::SetRosterRequest::ref request, m_requests) {

			




	
	
	
		
 
			request->onResponse.disconnect_all_slots();

			




	
	
	
		
 
			m_component->getIQRouter()->removeHandler(request);

			




	
	
		
 
@@ -175,38 +178,38 @@ void RosterManager::handleBuddyRosterPushResponse(Swift::ErrorPayload::ref error

			




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

			




	
	
	
		
 
	return m_buddies[name];

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void RosterManager::sendRIE() {

			




	
	
	
		
 
	m_RIETimer->stop();

			




	
	
	
		
 

			




	
	
	
		
 
	// Check the feature, because proper resource could logout during RIETimer.

			




	
	
	
		
 
	Swift::JID jidWithRIE = m_user->getJIDWithFeature("http://jabber.org/protocol/rosterx");

			




	
	
	
		
 

			




	
	
	
		
 
	// fallback to normal subscribe

			




	
	
	
		
 
	if (!jidWithRIE.isValid()) {

			




	
	
	
		
 
		for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {

			




	
	
	
		
 
		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;

			




	
	
	
		
 
			}

			




	
	
	
		
 
			sendBuddySubscribePresence(buddy);

			




	
	
	
		
 
		}

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	LOG4CXX_INFO(logger, "Sending RIE stanza to " << jidWithRIE.toString());

			




	
	
	
		
 

			




	
	
	
		
 
	Swift::RosterItemExchangePayload::ref payload = Swift::RosterItemExchangePayload::ref(new Swift::RosterItemExchangePayload());

			




	
	
	
		
 
	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {

			




	
	
	
		
 
	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::RosterItemExchangePayload::Item item;

			




	
	
	
		
 
		item.setJID(buddy->getJID().toBare());

			




	
	
	
		
 
		item.setName(buddy->getAlias());

			




	
	
	
		
 
		item.setAction(Swift::RosterItemExchangePayload::Item::Add);

			




	
	
	
		
 
// 		item.setGroups(buddy->getGroups());

			




	
	
	
		
 

			




	
	
	
		
 
		payload->addItem(item);

			




	
	
	
		
 
	}

			




	
	
		
 
@@ -366,41 +369,41 @@ void RosterManager::setStorageBackend(StorageBackend *storageBackend) {

			




	
	
	
		
 

			




	
	
	
		
 
	for (std::list<BuddyInfo>::const_iterator it = roster.begin(); it != roster.end(); it++) {

			




	
	
	
		
 
		Buddy *buddy = m_component->getFactory()->createBuddy(this, *it);

			




	
	
	
		
 
		LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Adding cached buddy " << buddy->getName() << " fom database");

			




	
	
	
		
 
		m_buddies[buddy->getName()] = buddy;

			




	
	
	
		
 
		onBuddySet(buddy);

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
Swift::RosterPayload::ref RosterManager::generateRosterPayload() {

			




	
	
	
		
 
	Swift::RosterPayload::ref payload = Swift::RosterPayload::ref(new Swift::RosterPayload());

			




	
	
	
		
 

			




	
	
	
		
 
	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {

			




	
	
	
		
 
	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 *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {

			




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

			




	
	
	
		
 
			m_component->getStanzaChannel()->sendPresence(presence);

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
		
 
@@ -414,25 +417,25 @@ void RosterManager::sendCurrentPresence(const Swift::JID &from, const Swift::JID

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else {

			




	
	
	
		
 
		Swift::Presence::ref response = Swift::Presence::create();

			




	
	
	
		
 
		response->setTo(to);

			




	
	
	
		
 
		response->setFrom(from);

			




	
	
	
		
 
		response->setType(Swift::Presence::Unavailable);

			




	
	
	
		
 
		m_component->getStanzaChannel()->sendPresence(response);

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void RosterManager::sendUnavailablePresences(const Swift::JID &to) {

			




	
	
	
		
 
	for (std::map<std::string, Buddy *>::const_iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {

			




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

			




	
	
	
		
 
			presence->setType(Swift::Presence::Unavailable);

			




	
	
	
		
 
			m_component->getStanzaChannel()->sendPresence(presence);

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/sqlite3backend.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -216,25 +216,25 @@ bool SQLite3Backend::getUser(const std::string &barejid, UserInfo &user) {

			




	
	
	
		
 
// 	SELECT id, jid, uin, password, encoding, language, vip FROM " + m_prefix + "users WHERE jid=?

			




	
	
	
		
 
	sqlite3_reset(m_getUser);

			




	
	
	
		
 
	sqlite3_bind_text(m_getUser, 1, barejid.c_str(), -1, SQLITE_TRANSIENT);

			




	
	
	
		
 

			




	
	
	
		
 
	int ret;

			




	
	
	
		
 
	while((ret = sqlite3_step(m_getUser)) == SQLITE_ROW) {

			




	
	
	
		
 
		user.id = sqlite3_column_int(m_getUser, 0);

			




	
	
	
		
 
		user.jid = (const char *) sqlite3_column_text(m_getUser, 1);

			




	
	
	
		
 
		user.uin = (const char *) sqlite3_column_text(m_getUser, 2);

			




	
	
	
		
 
		user.password = (const char *) sqlite3_column_text(m_getUser, 3);

			




	
	
	
		
 
		user.encoding = (const char *) sqlite3_column_text(m_getUser, 4);

			




	
	
	
		
 
		user.language = (const char *) sqlite3_column_text(m_getUser, 5);

			




	
	
	
		
 
		user.vip = sqlite3_column_int(m_getUser, 6);

			




	
	
	
		
 
		user.vip = sqlite3_column_int(m_getUser, 6) != 0;

			




	
	
	
		
 
		return true;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	if (ret != SQLITE_DONE) {

			




	
	
	
		
 
		LOG4CXX_ERROR(logger, "getUser query"<< (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	return false;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SQLite3Backend::setUserOnline(long id, bool online) {

			




	
	
	
		
 
	

			




        

    


    
    

    

        

                

                    src/transport.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -86,35 +86,35 @@ Component::Component(Swift::EventLoop *loop, Swift::NetworkFactories *factories,

			




	
	
	
		
 

			




	
	
	
		
 
		m_server->addPayloadParserFactory(new GenericPayloadParserFactory<StorageParser>("private", "jabber:iq:private"));

			




	
	
	
		
 
		m_server->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::AttentionParser>("attention", "urn:xmpp:attention:0"));

			




	
	
	
		
 
		m_server->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::XHTMLIMParser>("html", "http://jabber.org/protocol/xhtml-im"));

			




	
	
	
		
 
		m_server->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::BlockParser>("block", "urn:xmpp:block:0"));

			




	
	
	
		
 
		m_server->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::InvisibleParser>("invisible", "urn:xmpp:invisible:0"));

			




	
	
	
		
 

			




	
	
	
		
 
		m_server->addPayloadSerializer(new Swift::AttentionSerializer());

			




	
	
	
		
 
		m_server->addPayloadSerializer(new Swift::XHTMLIMSerializer());

			




	
	
	
		
 
		m_server->addPayloadSerializer(new Swift::BlockSerializer());

			




	
	
	
		
 
		m_server->addPayloadSerializer(new Swift::InvisibleSerializer());

			




	
	
	
		
 

			




	
	
	
		
 
		m_server->onDataRead.connect(bind(&Component::handleDataRead, this, _1));

			




	
	
	
		
 
		m_server->onDataWritten.connect(bind(&Component::handleDataWritten, this, _1));

			




	
	
	
		
 
		m_server->onDataRead.connect(boost::bind(&Component::handleDataRead, this, _1));

			




	
	
	
		
 
		m_server->onDataWritten.connect(boost::bind(&Component::handleDataWritten, this, _1));

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else {

			




	
	
	
		
 
		LOG4CXX_INFO(logger, "Creating component in gateway mode");

			




	
	
	
		
 
		m_component = new Swift::Component(loop, m_factories, m_jid, CONFIG_STRING(m_config, "service.password"));

			




	
	
	
		
 
		m_component->setSoftwareVersion("", "");

			




	
	
	
		
 
		m_component->onConnected.connect(bind(&Component::handleConnected, this));

			




	
	
	
		
 
		m_component->onError.connect(bind(&Component::handleConnectionError, this, _1));

			




	
	
	
		
 
		m_component->onDataRead.connect(bind(&Component::handleDataRead, this, _1));

			




	
	
	
		
 
		m_component->onDataWritten.connect(bind(&Component::handleDataWritten, this, _1));

			




	
	
	
		
 
		m_component->onError.connect(boost::bind(&Component::handleConnectionError, this, _1));

			




	
	
	
		
 
		m_component->onDataRead.connect(boost::bind(&Component::handleDataRead, this, _1));

			




	
	
	
		
 
		m_component->onDataWritten.connect(boost::bind(&Component::handleDataWritten, this, _1));

			




	
	
	
		
 
		m_stanzaChannel = m_component->getStanzaChannel();

			




	
	
	
		
 
		m_iqRouter = m_component->getIQRouter();

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	m_capsMemoryStorage = new CapsMemoryStorage();

			




	
	
	
		
 
	m_capsManager = new CapsManager(m_capsMemoryStorage, m_stanzaChannel, m_iqRouter);

			




	
	
	
		
 
	m_entityCapsManager = new EntityCapsManager(m_capsManager, m_stanzaChannel);

			




	
	
	
		
 
 	m_entityCapsManager->onCapsChanged.connect(boost::bind(&Component::handleCapsChanged, this, _1));

			




	
	
	
		
 
	

			




	
	
	
		
 
	m_presenceOracle = new PresenceOracle(m_stanzaChannel);

			




	
	
	
		
 
	m_presenceOracle->onPresenceChange.connect(bind(&Component::handlePresence, this, _1));

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    src/user.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -21,25 +21,27 @@

			




	
	
	
		
 
#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 "Swiften/Swiften.h"

			




	
	
	
		
 
#include "Swiften/Server/ServerStanzaChannel.h"

			




	
	
	
		
 
#include "Swiften/Elements/StreamError.h"

			




	
	
	
		
 
#include "Swiften/Elements/MUCPayload.h"

			




	
	
	
		
 
#include "log4cxx/logger.h"

			




	
	
	
		
 
#include <boost/foreach.hpp>

			




	
	
	
		
 
#ifndef WIN32

			




	
	
	
		
 
#include <execinfo.h>

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#include <stdio.h>

			




	
	
	
		
 
#include <stdlib.h>

			




	
	
	
		
 

			




	
	
	
		
 
using namespace log4cxx;

			




	
	
	
		
 
using namespace boost;

			




	
	
	
		
 

			




	
	
	
		
 
#define foreach         BOOST_FOREACH

			




	
	
	
		
 

			




	
	
	
		
 
namespace Transport {

			




	
	
	
		
 

			




	
	
	
		
 
static LoggerPtr logger = Logger::getLogger("User");

			




	
	
	
		
 

			




	
	
		
 
@@ -96,38 +98,40 @@ Swift::JID User::getJIDWithFeature(const std::string &feature) {

			




	
	
	
		
 
			LOG4CXX_INFO(logger, m_jid.toString() << ": Found JID with " << feature << " feature: " << presence->getFrom().toString());

			




	
	
	
		
 
			return presence->getFrom();

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	LOG4CXX_INFO(logger, m_jid.toString() << ": No JID with " << feature << " feature");

			




	
	
	
		
 
	return jid;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
static void

			




	
	
	
		
 
print_trace (void)

			




	
	
	
		
 
{

			




	
	
	
		
 
#ifndef WIN32

			




	
	
	
		
 
void *array[80];

			




	
	
	
		
 
size_t size;

			




	
	
	
		
 
char **strings;

			




	
	
	
		
 
size_t i;

			




	
	
	
		
 

			




	
	
	
		
 
size = backtrace (array, 80);

			




	
	
	
		
 
strings = backtrace_symbols (array, size);

			




	
	
	
		
 

			




	
	
	
		
 
printf ("Obtained %zd stack frames.\n", size);

			




	
	
	
		
 

			




	
	
	
		
 
for (i = 0; i < size; i++)

			




	
	
	
		
 
	printf ("%s\n", strings[i]);

			




	
	
	
		
 

			




	
	
	
		
 
free (strings);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void User::handlePresence(Swift::Presence::ref presence) {

			




	
	
	
		
 
	std::cout << "PRESENCE " << presence->getFrom().toString() << "\n";

			




	
	
	
		
 
// 	print_trace();

			




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

			




        

    


    
    

    

        

                

                    src/usermanager.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -90,25 +90,27 @@ User *UserManager::getUser(const std::string &barejid){

			




	
	
	
		
 

			




	
	
	
		
 
void UserManager::removeUser(User *user) {

			




	
	
	
		
 
	m_users.erase(user->getJID().toBare().toString());

			




	
	
	
		
 
	if (m_cachedUser == user)

			




	
	
	
		
 
		m_cachedUser = NULL;

			




	
	
	
		
 

			




	
	
	
		
 
	if (m_component->inServerMode()) {

			




	
	
	
		
 
		disconnectUser(user->getJID());

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	onUserDestroyed(user);

			




	
	
	
		
 
	delete user;

			




	
	
	
		
 
#ifndef WIN32

			




	
	
	
		
 
	malloc_trim(0);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
// 	VALGRIND_DO_LEAK_CHECK;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
int UserManager::getUserCount() {

			




	
	
	
		
 
	return m_users.size();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void UserManager::handlePresence(Swift::Presence::ref presence) {

			




	
	
	
		
 
	std::string barejid = presence->getTo().toBare().toString();

			




	
	
	
		
 
	std::string userkey = presence->getFrom().toBare().toString();

			




	
	
	
		
 

			




	
	
	
		
 
	User *user = getUser(userkey);

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








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