Changeset - 2ae5cba932b1
Parent rev.
Child rev.
[Not reviewed]
0 3 0
HanzZ - 13 years ago 2012-12-27 15:02:21
hanzz.k@gmail.com
service.login_delay
3 files changed with 44 insertions and 14 deletions:
include/transport/networkpluginserver.h
5
1
src/config.cpp
1
src/networkpluginserver.cpp
38
13
0 comments (0 inline, 0 general)
include/transport/networkpluginserver.h
➞
Show inline comments
 
@@ -48,119 +48,123 @@ class DiscoItemsResponder;
 
class NetworkPluginServer {
 
	public:
 
		struct Backend {
 
			int pongReceived;
 
			std::list<User *> users;
 
			Swift::SafeByteArray data;
 
			boost::shared_ptr<Swift::Connection> connection;
 
			unsigned long res;
 
			unsigned long init_res;
 
			unsigned long shared;
 
			bool acceptUsers;
 
			bool longRun;
 
			bool willDie;
 
			std::string id;
 
		};
 

			




	
	
	
		
 
		NetworkPluginServer(Component *component, Config *config, UserManager *userManager, FileTransferManager *ftManager, DiscoItemsResponder *discoItemsResponder);

			




	
	
	
		
 

			




	
	
	
		
 
		virtual ~NetworkPluginServer();

			




	
	
	
		
 

			




	
	
	
		
 
		void start();

			




	
	
	
		
 

			




	
	
	
		
 
		void setAdminInterface(AdminInterface *adminInterface) {

			




	
	
	
		
 
			m_adminInterface = adminInterface;

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		int getBackendCount() {

			




	
	
	
		
 
			return m_clients.size();

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		const std::list<Backend *> &getBackends() {

			




	
	
	
		
 
			return m_clients;

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		const std::vector<std::string> &getCrashedBackends() {

			




	
	
	
		
 
			return m_crashedBackends;

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		void collectBackend();

			




	
	
	
		
 

			




	
	
	
		
 
		bool moveToLongRunBackend(User *user);

			




	
	
	
		
 

			




	
	
	
		
 
		void handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &message);

			




	
	
	
		
 

			




	
	
	
		
 
	public:

			




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

			




	
	
	
		
 
		void handleSessionFinished(Backend *c);

			




	
	
	
		
 
		void handlePongReceived(Backend *c);

			




	
	
	
		
 
		void handleDataRead(Backend *c, boost::shared_ptr<Swift::SafeByteArray> data);

			




	
	
	
		
 

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




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

			




	
	
	
		
 
		void handleChatStatePayload(const std::string &payload, Swift::ChatState::ChatStateType type);

			




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

			




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

			




	
	
	
		
 
		void handleStatsPayload(Backend *c, const std::string &payload);

			




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

			




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

			




	
	
	
		
 
		void handleFTDataPayload(Backend *b, const std::string &payload);

			




	
	
	
		
 
		void handleQueryPayload(Backend *b, const std::string &payload);

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
		void handleUserCreated(User *user);

			




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

			




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

			




	
	
	
		
 
		void handleUserReadyToConnect(User *user);

			




	
	
	
		
 
		void handleUserPresenceChanged(User *user, Swift::Presence::ref presence);

			




	
	
	
		
 
		void handleUserDestroyed(User *user);

			




	
	
	
		
 

			




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

			




	
	
	
		
 
		void handleBuddyRemoved(Buddy *buddy);

			




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

			




	
	
	
		
 

			




	
	
	
		
 
		void handleBlockToggled(Buddy *buddy);

			




	
	
	
		
 

			




	
	
	
		
 
		void handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> vcard);

			




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

			




	
	
	
		
 

			




	
	
	
		
 
		void handleFTStateChanged(Swift::FileTransfer::State state, const std::string &userName, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long id);

			




	
	
	
		
 
		void handleFTAccepted(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID);

			




	
	
	
		
 
		void handleFTRejected(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size);

			




	
	
	
		
 
		void handleFTDataNeeded(Backend *b, unsigned long ftid);

			




	
	
	
		
 

			




	
	
	
		
 
	private:

			




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

			




	
	
	
		
 

			




	
	
	
		
 
		void pingTimeout();

			




	
	
	
		
 
		void sendPing(Backend *c);

			




	
	
	
		
 
		Backend *getFreeClient(bool acceptUsers = true, bool longRun = false);

			




	
	
	
		
 
		Backend *getFreeClient(bool acceptUsers = true, bool longRun = false, bool check = false);

			




	
	
	
		
 
		void connectWaitingUsers();

			




	
	
	
		
 
		void loginDelayFinished();

			




	
	
	
		
 

			




	
	
	
		
 
		UserManager *m_userManager;

			




	
	
	
		
 
		VCardResponder *m_vcardResponder;

			




	
	
	
		
 
		RosterResponder *m_rosterResponder;

			




	
	
	
		
 
		BlockResponder *m_blockResponder;

			




	
	
	
		
 
		Config *m_config;

			




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

			




	
	
	
		
 
		std::list<Backend *>  m_clients;

			




	
	
	
		
 
		Swift::Timer::ref m_pingTimer;

			




	
	
	
		
 
		Swift::Timer::ref m_collectTimer;

			




	
	
	
		
 
		Swift::Timer::ref m_loginTimer;

			




	
	
	
		
 
		Component *m_component;

			




	
	
	
		
 
		std::list<User *> m_waitingUsers;

			




	
	
	
		
 
		bool m_isNextLongRun;

			




	
	
	
		
 
		std::map<unsigned long, FileTransferManager::Transfer> m_filetransfers;

			




	
	
	
		
 
		FileTransferManager *m_ftManager;

			




	
	
	
		
 
		std::vector<std::string> m_crashedBackends;

			




	
	
	
		
 
		AdminInterface *m_adminInterface;

			




	
	
	
		
 
		bool m_startingBackend;

			




	
	
	
		
 
		DiscoItemsResponder *m_discoItemsResponder;

			




	
	
	
		
 
		time_t m_lastLogin;

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/config.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -5,192 +5,193 @@

			




	
	
	
		
 
 *

			




	
	
	
		
 
 * This program is free software; you can redistribute it and/or modify

			




	
	
	
		
 
 * it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
 * the Free Software Foundation; either version 2 of the License, or

			




	
	
	
		
 
 * (at your option) any later version.

			




	
	
	
		
 
 *

			




	
	
	
		
 
 * This program is distributed in the hope that it will be useful,

			




	
	
	
		
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
 * GNU General Public License for more details.

			




	
	
	
		
 
 *

			




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

			




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

			




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

			




	
	
	
		
 
 */

			




	
	
	
		
 

			




	
	
	
		
 
#include "transport/config.h"

			




	
	
	
		
 
#include <fstream>

			




	
	
	
		
 
#ifdef _WIN32

			




	
	
	
		
 
#include <direct.h>

			




	
	
	
		
 
#define getcwd _getcwd

			




	
	
	
		
 
#include <windows.h>

			




	
	
	
		
 
#ifdef _MSC_VER

			




	
	
	
		
 
#define PATH_MAX MAX_PATH

			




	
	
	
		
 
#endif

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
#include "iostream"

			




	
	
	
		
 
#include "boost/version.hpp"

			




	
	
	
		
 
#include "boost/algorithm/string.hpp"

			




	
	
	
		
 

			




	
	
	
		
 
#define BOOST_MAJOR_VERSION BOOST_VERSION / 100000

			




	
	
	
		
 
#define BOOST_MINOR_VERSION BOOST_VERSION / 100 % 1000

			




	
	
	
		
 

			




	
	
	
		
 
using namespace boost::program_options;

			




	
	
	
		
 

			




	
	
	
		
 
namespace Transport {

			




	
	
	
		
 
static int getRandomPort(const std::string &s) {

			




	
	
	
		
 
	unsigned long r = 0;

			




	
	
	
		
 
	BOOST_FOREACH(char c, s) {

			




	
	
	
		
 
		r += (int) c;

			




	
	
	
		
 
	}

			




	
	
	
		
 
	srand(time(NULL) + r);

			




	
	
	
		
 
	return 30000 + rand() % 10000;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool Config::load(const std::string &configfile, boost::program_options::options_description &opts, const std::string &jid) {

			




	
	
	
		
 
	std::ifstream ifs(configfile.c_str());

			




	
	
	
		
 
	if (!ifs.is_open())

			




	
	
	
		
 
		return false;

			




	
	
	
		
 

			




	
	
	
		
 
	m_file = configfile;

			




	
	
	
		
 
	m_jid = jid;

			




	
	
	
		
 
	bool ret = load(ifs, opts, jid);

			




	
	
	
		
 
	ifs.close();

			




	
	
	
		
 
#ifndef WIN32

			




	
	
	
		
 
	char path[PATH_MAX] = "";

			




	
	
	
		
 
	if (m_file.find_first_of("/") != 0) {

			




	
	
	
		
 
		getcwd(path, PATH_MAX);

			




	
	
	
		
 
		m_file = std::string(path) + "/" + m_file;

			




	
	
	
		
 
	}

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
	return ret;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool Config::load(std::istream &ifs, boost::program_options::options_description &opts, const std::string &_jid) {

			




	
	
	
		
 
	m_unregistered.clear();

			




	
	
	
		
 
	opts.add_options()

			




	
	
	
		
 
		("service.jid", value<std::string>()->default_value(""), "Transport Jabber ID")

			




	
	
	
		
 
		("service.server", value<std::string>()->default_value(""), "Server to connect to")

			




	
	
	
		
 
		("service.password", value<std::string>()->default_value(""), "Password used to auth the server")

			




	
	
	
		
 
		("service.port", value<int>()->default_value(0), "Port the server is listening on")

			




	
	
	
		
 
		("service.user", value<std::string>()->default_value(""), "The name of user Spectrum runs as.")

			




	
	
	
		
 
		("service.group", value<std::string>()->default_value(""), "The name of group Spectrum runs as.")

			




	
	
	
		
 
		("service.backend", value<std::string>()->default_value("libpurple_backend"), "Backend")

			




	
	
	
		
 
		("service.protocol", value<std::string>()->default_value(""), "Protocol")

			




	
	
	
		
 
		("service.pidfile", value<std::string>()->default_value("/var/run/spectrum2/$jid.pid"), "Full path to pid file")

			




	
	
	
		
 
		("service.portfile", value<std::string>()->default_value("/var/run/spectrum2/$jid.port"), "File to store backend_port to. It's used by spectrum2_manager.")

			




	
	
	
		
 
		("service.working_dir", value<std::string>()->default_value("/var/lib/spectrum2/$jid"), "Working dir")

			




	
	
	
		
 
		("service.allowed_servers", value<std::vector<std::string> >()->multitoken(), "Only users from these servers can connect")

			




	
	
	
		
 
		("service.server_mode", value<bool>()->default_value(false), "True if Spectrum should behave as server")

			




	
	
	
		
 
		("service.users_per_backend", value<int>()->default_value(100), "Number of users per one legacy network backend")

			




	
	
	
		
 
		("service.backend_host", value<std::string>()->default_value("localhost"), "Host to bind backend server to")

			




	
	
	
		
 
		("service.backend_port", value<std::string>()->default_value("0"), "Port to bind backend server to")

			




	
	
	
		
 
		("service.cert", value<std::string>()->default_value(""), "PKCS#12 Certificate.")

			




	
	
	
		
 
		("service.cert_password", value<std::string>()->default_value(""), "PKCS#12 Certificate password.")

			




	
	
	
		
 
		("service.admin_jid", value<std::vector<std::string> >()->multitoken(), "Administrator jid.")

			




	
	
	
		
 
		("service.admin_password", value<std::string>()->default_value(""), "Administrator password.")

			




	
	
	
		
 
		("service.reuse_old_backends", value<bool>()->default_value(true), "True if Spectrum should use old backends which were full in the past.")

			




	
	
	
		
 
		("service.idle_reconnect_time", value<int>()->default_value(0), "Time in seconds after which idle users are reconnected to let their backend die.")

			




	
	
	
		
 
		("service.memory_collector_time", value<int>()->default_value(0), "Time in seconds after which backend with most memory is set to die.")

			




	
	
	
		
 
		("service.more_resources", value<bool>()->default_value(false), "Allow more resources to be connected in server mode at the same time.")

			




	
	
	
		
 
		("service.enable_privacy_lists", value<bool>()->default_value(true), "")

			




	
	
	
		
 
		("service.enable_xhtml", value<bool>()->default_value(true), "")

			




	
	
	
		
 
		("service.max_room_list_size", value<int>()->default_value(100), "")

			




	
	
	
		
 
		("service.login_delay", value<int>()->default_value(0), "")

			




	
	
	
		
 
		("service.jid_escaping", value<bool>()->default_value(true), "")

			




	
	
	
		
 
		("service.vip_only", value<bool>()->default_value(false), "")

			




	
	
	
		
 
		("service.vip_message", value<std::string>()->default_value(""), "")

			




	
	
	
		
 
		("vhosts.vhost", value<std::vector<std::string> >()->multitoken(), "")

			




	
	
	
		
 
		("identity.name", value<std::string>()->default_value("Spectrum 2 Transport"), "Name showed in service discovery.")

			




	
	
	
		
 
		("identity.category", value<std::string>()->default_value("gateway"), "Disco#info identity category. 'gateway' by default.")

			




	
	
	
		
 
		("identity.type", value<std::string>()->default_value(""), "Type of transport ('icq','msn','gg','irc', ...)")

			




	
	
	
		
 
		("registration.enable_public_registration", value<bool>()->default_value(true), "True if users should be able to register.")

			




	
	
	
		
 
		("registration.language", value<std::string>()->default_value("en"), "Default language for registration form")

			




	
	
	
		
 
		("registration.instructions", value<std::string>()->default_value("Enter your legacy network username and password."), "Instructions showed to user in registration form")

			




	
	
	
		
 
		("registration.username_label", value<std::string>()->default_value("Legacy network username:"), "Label for username field")

			




	
	
	
		
 
		("registration.username_mask", value<std::string>()->default_value(""), "Username mask")

			




	
	
	
		
 
		("registration.allowed_usernames", value<std::string>()->default_value(""), "Allowed usernames")

			




	
	
	
		
 
		("registration.auto_register", value<bool>()->default_value(false), "Register new user automatically when the presence arrives.")

			




	
	
	
		
 
		("registration.encoding", value<std::string>()->default_value("utf8"), "Default encoding in registration form")

			




	
	
	
		
 
		("registration.require_local_account", value<bool>()->default_value(false), "True if users have to have a local account to register to this transport from remote servers.")

			




	
	
	
		
 
		("registration.notify_jid", value<std::vector<std::string> >()->multitoken(), "Send message to this JID if user registers/unregisters")

			




	
	
	
		
 
		("registration.local_username_label", value<std::string>()->default_value("Local username:"), "Label for local usernme field")

			




	
	
	
		
 
		("registration.local_account_server", value<std::string>()->default_value("localhost"), "The server on which the local accounts will be checked for validity")

			




	
	
	
		
 
		("registration.local_account_server_timeout", value<int>()->default_value(10000), "Timeout when checking local user on local_account_server (msecs)")

			




	
	
	
		
 
		("gateway_responder.prompt", value<std::string>()->default_value("Contact ID"), "Value of <prompt> </promt> field")

			




	
	
	
		
 
		("gateway_responder.label", value<std::string>()->default_value("Enter legacy network contact ID."), "Label for add contact ID field")

			




	
	
	
		
 
		("database.type", value<std::string>()->default_value("none"), "Database type.")

			




	
	
	
		
 
		("database.database", value<std::string>()->default_value("/var/lib/spectrum2/$jid/database.sql"), "Database used to store data")

			




	
	
	
		
 
		("database.server", value<std::string>()->default_value("localhost"), "Database server.")

			




	
	
	
		
 
		("database.user", value<std::string>()->default_value(""), "Database user.")

			




	
	
	
		
 
		("database.password", value<std::string>()->default_value(""), "Database Password.")

			




	
	
	
		
 
		("database.port", value<int>()->default_value(0), "Database port.")

			




	
	
	
		
 
		("database.prefix", value<std::string>()->default_value(""), "Prefix of tables in database")

			




	
	
	
		
 
		("database.encryption_key", value<std::string>()->default_value(""), "Encryption key.")

			




	
	
	
		
 
		("database.vip_statement", value<std::string>()->default_value(""), "Encryption key.")

			




	
	
	
		
 
		("logging.config", value<std::string>()->default_value(""), "Path to log4cxx config file which is used for Spectrum 2 instance")

			




	
	
	
		
 
		("logging.backend_config", value<std::string>()->default_value(""), "Path to log4cxx config file which is used for backends")

			




	
	
	
		
 
		("backend.default_avatar", value<std::string>()->default_value(""), "Full path to default avatar")

			




	
	
	
		
 
		("backend.avatars_directory", value<std::string>()->default_value(""), "Path to directory with avatars")

			




	
	
	
		
 
		("backend.no_vcard_fetch", value<bool>()->default_value(false), "True if VCards for buddies should not be fetched. Only avatars will be forwarded.")

			




	
	
	
		
 
		("proxy.server", value<std::string>()->default_value("localhost"), "Proxy IP.")

			




	
	
	
		
 
		("proxy.user", value<std::string>()->default_value(""), "Proxy user.")

			




	
	
	
		
 
		("proxy.password", value<std::string>()->default_value(""), "Proxy Password.")

			




	
	
	
		
 
		("proxy.port", value<int>()->default_value(0), "Proxy port.")

			




	
	
	
		
 

			




	
	
	
		
 
	;

			




	
	
	
		
 

			




	
	
	
		
 
	parsed_options parsed = parse_config_file(ifs, opts, true);

			




	
	
	
		
 

			




	
	
	
		
 
	bool found_working = false;

			




	
	
	
		
 
	bool found_pidfile = false;

			




	
	
	
		
 
	bool found_portfile = false;

			




	
	
	
		
 
	bool found_backend_port = false;

			




	
	
	
		
 
	bool found_database = false;

			




	
	
	
		
 
	std::string jid = "";

			




	
	
	
		
 
	BOOST_FOREACH(option &opt, parsed.options) {

			




	
	
	
		
 
		if (opt.string_key == "service.jid") {

			




	
	
	
		
 
			if (_jid.empty()) {

			




	
	
	
		
 
				jid = opt.value[0];

			




	
	
	
		
 
			}

			




	
	
	
		
 
			else {

			




	
	
	
		
 
				opt.value[0] = _jid;

			




	
	
	
		
 
				jid = _jid;

			




	
	
	
		
 
			}

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else if (opt.string_key == "service.backend_port") {

			




	
	
	
		
 
			found_backend_port = true;

			




	
	
	
		
 
			if (opt.value[0] == "0") {

			




	
	
	
		
 
				opt.value[0] = boost::lexical_cast<std::string>(getRandomPort(_jid.empty() ? jid : _jid));

			




	
	
	
		
 
			}

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else if (opt.string_key == "service.working_dir") {

			




	
	
	
		
 
			found_working = true;

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else if (opt.string_key == "service.pidfile") {

			




	
	
	
		
 
			found_pidfile = true;

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else if (opt.string_key == "service.portfile") {

			




	
	
	
		
 
			found_portfile = true;

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else if (opt.string_key == "database.database") {

			




	
	
	
		
 
			found_database = true;

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	if (!found_working) {

			




	
	
	
		
 
		std::vector<std::string> value;

			




	
	
	
		
 
		value.push_back("/var/lib/spectrum2/$jid");

			




	
	
	
		
 
		parsed.options.push_back(boost::program_options::basic_option<char>("service.working_dir", value));

			




	
	
	
		
 
	}

			




	
	
	
		
 
	if (!found_pidfile) {

			




	
	
	
		
 
		std::vector<std::string> value;

			




	
	
	
		
 
		value.push_back("/var/run/spectrum2/$jid.pid");

			




	
	
	
		
 
		parsed.options.push_back(boost::program_options::basic_option<char>("service.pidfile", value));

			




	
	
	
		
 
	}

			




	
	
	
		
 
	if (!found_portfile) {

			




	
	
	
		
 
		std::vector<std::string> value;

			




	
	
	
		
 
		value.push_back("/var/run/spectrum2/$jid.port");

			




	
	
	
		
 
		parsed.options.push_back(boost::program_options::basic_option<char>("service.portfile", value));

			




	
	
	
		
 
	}

			




        

    


    
    

    

        

                

                    src/networkpluginserver.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -165,289 +165,299 @@ static unsigned long exec_(const std::string& exePath, const char *host, const c

			




	
	
	
		
 
		&pi

			




	
	
	
		
 
		)

			




	
	
	
		
 
	)  {

			




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

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	return 0;

			




	
	
	
		
 
#else

			




	
	
	
		
 
	// Add host and port.

			




	
	
	
		
 
	finalExePath += std::string(" --host ") + host + " --port " + port + " " + cmdlineArgs;

			




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

			




	
	
	
		
 

			




	
	
	
		
 
	// Create array of char * from string using -lpopt library

			




	
	
	
		
 
	char *p = (char *) malloc(finalExePath.size() + 1);

			




	
	
	
		
 
	strcpy(p, finalExePath.c_str());

			




	
	
	
		
 
	int argc;

			




	
	
	
		
 
	char **argv;

			




	
	
	
		
 
	poptParseArgvString(p, &argc, (const char ***) &argv);

			




	
	
	
		
 

			




	
	
	
		
 
	// fork and exec

			




	
	
	
		
 
	pid_t pid = fork();

			




	
	
	
		
 
	if ( pid == 0 ) {

			




	
	
	
		
 
		setsid();

			




	
	
	
		
 
		// close all files

			




	
	
	
		
 
		int maxfd=sysconf(_SC_OPEN_MAX);

			




	
	
	
		
 
		for(int fd=3; fd<maxfd; fd++) {

			




	
	
	
		
 
			close(fd);

			




	
	
	
		
 
		}

			




	
	
	
		
 
		// child process

			




	
	
	
		
 
		errno = 0;

			




	
	
	
		
 
		int ret = execv(argv[0], argv);

			




	
	
	
		
 
		if (ret == -1) {

			




	
	
	
		
 
			exit(errno);

			




	
	
	
		
 
		}

			




	
	
	
		
 
		exit(0);

			




	
	
	
		
 
	} else if ( pid < 0 ) {

			




	
	
	
		
 
		LOG4CXX_ERROR(logger, "Fork failed");

			




	
	
	
		
 
	}

			




	
	
	
		
 
	free(p);

			




	
	
	
		
 

			




	
	
	
		
 
	return (unsigned long) pid;

			




	
	
	
		
 
#endif

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef _WIN32

			




	
	
	
		
 
static void SigCatcher(int n) {

			




	
	
	
		
 
	pid_t result;

			




	
	
	
		
 
	int status;

			




	
	
	
		
 
	// Read exit code from all children to not have zombies arround

			




	
	
	
		
 
	// WARNING: Do not put LOG4CXX_ here, because it can lead to deadlock

			




	
	
	
		
 
	while ((result = waitpid(-1, &status, WNOHANG)) > 0) {

			




	
	
	
		
 
		if (result != 0) {

			




	
	
	
		
 
			if (WIFEXITED(status)) {

			




	
	
	
		
 
				if (WEXITSTATUS(status) != 0) {

			




	
	
	
		
 
// 					LOG4CXX_ERROR(logger, "Backend can not be started, exit_code=" << WEXITSTATUS(status));

			




	
	
	
		
 
				}

			




	
	
	
		
 
			}

			




	
	
	
		
 
			else {

			




	
	
	
		
 
// 				LOG4CXX_ERROR(logger, "Backend can not be started");

			




	
	
	
		
 
			}

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
static void handleBuddyPayload(LocalBuddy *buddy, const pbnetwork::Buddy &payload) {

			




	
	
	
		
 
	// Set alias only if it's not empty. Backends are allowed to send empty alias if it has

			




	
	
	
		
 
	// not changed.

			




	
	
	
		
 
	if (!payload.alias().empty()) {

			




	
	
	
		
 
		buddy->setAlias(payload.alias());

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	// Change groups if it's not empty. The same as above...

			




	
	
	
		
 
	std::vector<std::string> groups;

			




	
	
	
		
 
	for (int i = 0; i < payload.group_size(); i++) {

			




	
	
	
		
 
		std::string group = payload.group(i);

			




	
	
	
		
 
		utf8::replace_invalid(payload.group(i).begin(), payload.group(i).end(), group.begin(), '_');

			




	
	
	
		
 
		groups.push_back(group);

			




	
	
	
		
 
	}

			




	
	
	
		
 
	if (!groups.empty()) {

			




	
	
	
		
 
		buddy->setGroups(groups);

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	buddy->setStatus(Swift::StatusShow((Swift::StatusShow::Type) payload.status()), payload.statusmessage());

			




	
	
	
		
 
	buddy->setIconHash(payload.iconhash());

			




	
	
	
		
 
	buddy->setBlocked(payload.blocked());

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
NetworkPluginServer::NetworkPluginServer(Component *component, Config *config, UserManager *userManager, FileTransferManager *ftManager, DiscoItemsResponder *discoItemsResponder) {

			




	
	
	
		
 
	m_ftManager = ftManager;

			




	
	
	
		
 
	m_userManager = userManager;

			




	
	
	
		
 
	m_config = config;

			




	
	
	
		
 
	m_component = component;

			




	
	
	
		
 
	m_isNextLongRun = false;

			




	
	
	
		
 
	m_adminInterface = NULL;

			




	
	
	
		
 
	m_startingBackend = false;

			




	
	
	
		
 
	m_lastLogin = 0;

			




	
	
	
		
 
	m_discoItemsResponder = discoItemsResponder;

			




	
	
	
		
 
	m_component->m_factory = new NetworkFactory(this);

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
	m_pingTimer = component->getNetworkFactories()->getTimerFactory()->createTimer(20000);

			




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

			




	
	
	
		
 
	m_pingTimer->start();

			




	
	
	
		
 

			




	
	
	
		
 
	m_loginTimer = component->getNetworkFactories()->getTimerFactory()->createTimer(CONFIG_INT(config, "service.login_delay") * 1000);

			




	
	
	
		
 
	m_loginTimer->onTick.connect(boost::bind(&NetworkPluginServer::loginDelayFinished, this));

			




	
	
	
		
 
	m_loginTimer->start();

			




	
	
	
		
 

			




	
	
	
		
 
	if (CONFIG_INT(m_config, "service.memory_collector_time") != 0) {

			




	
	
	
		
 
		m_collectTimer = component->getNetworkFactories()->getTimerFactory()->createTimer(CONFIG_INT(m_config, "service.memory_collector_time"));

			




	
	
	
		
 
		m_collectTimer->onTick.connect(boost::bind(&NetworkPluginServer::collectBackend, this));

			




	
	
	
		
 
		m_collectTimer->start();

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
	m_vcardResponder->onVCardUpdated.connect(boost::bind(&NetworkPluginServer::handleVCardUpdated, this, _1, _2));

			




	
	
	
		
 
	m_vcardResponder->start();

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	m_rosterResponder->onBuddyAdded.connect(boost::bind(&NetworkPluginServer::handleBuddyAdded, this, _1, _2));

			




	
	
	
		
 
	m_rosterResponder->onBuddyRemoved.connect(boost::bind(&NetworkPluginServer::handleBuddyRemoved, this, _1));

			




	
	
	
		
 
	m_rosterResponder->onBuddyUpdated.connect(boost::bind(&NetworkPluginServer::handleBuddyUpdated, this, _1, _2));

			




	
	
	
		
 
	m_rosterResponder->start();

			




	
	
	
		
 

			




	
	
	
		
 
	m_blockResponder = new BlockResponder(component->getIQRouter(), userManager);

			




	
	
	
		
 
	m_blockResponder->onBlockToggled.connect(boost::bind(&NetworkPluginServer::handleBlockToggled, this, _1));

			




	
	
	
		
 
	m_blockResponder->start();

			




	
	
	
		
 

			




	
	
	
		
 
	m_server = component->getNetworkFactories()->getConnectionServerFactory()->createConnectionServer(Swift::HostAddress(CONFIG_STRING(m_config, "service.backend_host")), boost::lexical_cast<int>(CONFIG_STRING(m_config, "service.backend_port")));

			




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

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
NetworkPluginServer::~NetworkPluginServer() {

			




	
	
	
		
 
	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {

			




	
	
	
		
 
		LOG4CXX_INFO(logger, "Stopping backend " << *it);

			




	
	
	
		
 
		std::string message;

			




	
	
	
		
 
		pbnetwork::WrapperMessage wrap;

			




	
	
	
		
 
		wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_EXIT);

			




	
	
	
		
 
		wrap.SerializeToString(&message);

			




	
	
	
		
 

			




	
	
	
		
 
		Backend *c = (Backend *) *it;

			




	
	
	
		
 
		send(c->connection, message);

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	m_pingTimer->stop();

			




	
	
	
		
 
	m_server->stop();

			




	
	
	
		
 
	m_server.reset();

			




	
	
	
		
 
	delete m_component->m_factory;

			




	
	
	
		
 
	delete m_vcardResponder;

			




	
	
	
		
 
	delete m_rosterResponder;

			




	
	
	
		
 
	delete m_blockResponder;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::start() {

			




	
	
	
		
 
	m_server->start();

			




	
	
	
		
 

			




	
	
	
		
 
	LOG4CXX_INFO(logger, "Listening on host " << CONFIG_STRING(m_config, "service.backend_host") << " port " << CONFIG_STRING(m_config, "service.backend_port"));

			




	
	
	
		
 

			




	
	
	
		
 
	while (true) {

			




	
	
	
		
 
		unsigned long pid = exec_(CONFIG_STRING(m_config, "service.backend"), CONFIG_STRING(m_config, "service.backend_host").c_str(), CONFIG_STRING(m_config, "service.backend_port").c_str(), m_config->getCommandLineArgs().c_str());

			




	
	
	
		
 
		LOG4CXX_INFO(logger, "Tried to spawn first backend with pid " << pid);

			




	
	
	
		
 
		LOG4CXX_INFO(logger, "Backend should now connect to Spectrum2 instance. Spectrum2 won't accept any connection before backend connects");

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef _WIN32

			




	
	
	
		
 
		// wait if the backend process will still be alive after 1 second

			




	
	
	
		
 
		sleep(1);

			




	
	
	
		
 
		pid_t result;

			




	
	
	
		
 
		int status;

			




	
	
	
		
 
		result = waitpid(-1, &status, WNOHANG);

			




	
	
	
		
 
		if (result != 0) {

			




	
	
	
		
 
			if (WIFEXITED(status)) {

			




	
	
	
		
 
				if (WEXITSTATUS(status) != 0) {

			




	
	
	
		
 
					if (status == 254) {

			




	
	
	
		
 
						LOG4CXX_ERROR(logger, "Backend can not be started, because it needs database to store data, but the database backend is not configured.");

			




	
	
	
		
 
					}

			




	
	
	
		
 
					else {

			




	
	
	
		
 
						LOG4CXX_ERROR(logger, "Backend can not be started, exit_code=" << WEXITSTATUS(status) << ", possible error: " << strerror(WEXITSTATUS(status)));

			




	
	
	
		
 
					}

			




	
	
	
		
 
					LOG4CXX_ERROR(logger, "Check backend log for more details");

			




	
	
	
		
 
					continue;

			




	
	
	
		
 
				}

			




	
	
	
		
 
			}

			




	
	
	
		
 
			else {

			




	
	
	
		
 
				LOG4CXX_ERROR(logger, "Backend can not be started");

			




	
	
	
		
 
				continue;

			




	
	
	
		
 
			}

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		signal(SIGCHLD, SigCatcher);

			




	
	
	
		
 
#endif

			




	
	
	
		
 
		// quit the while loop

			




	
	
	
		
 
		break;

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::loginDelayFinished() {

			




	
	
	
		
 
	m_loginTimer->stop();

			




	
	
	
		
 
	connectWaitingUsers();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	// Create new Backend instance

			




	
	
	
		
 
	Backend *client = new Backend;

			




	
	
	
		
 
	client->pongReceived = -1;

			




	
	
	
		
 
	client->connection = c;

			




	
	
	
		
 
	client->res = 0;

			




	
	
	
		
 
	client->init_res = 0;

			




	
	
	
		
 
	client->shared = 0;

			




	
	
	
		
 
	// Until we receive first PONG from backend, backend is in willDie state.

			




	
	
	
		
 
	client->willDie = true;

			




	
	
	
		
 
	// Backend does not accept new clients automatically if it's long-running

			




	
	
	
		
 
	client->acceptUsers = !m_isNextLongRun;

			




	
	
	
		
 
	client->longRun = m_isNextLongRun;

			




	
	
	
		
 

			




	
	
	
		
 
	m_startingBackend = false;

			




	
	
	
		
 

			




	
	
	
		
 
	LOG4CXX_INFO(logger, "New" + (client->longRun ? std::string(" long-running") : "") +  " backend " << client << " connected. Current backend count=" << (m_clients.size() + 1));

			




	
	
	
		
 

			




	
	
	
		
 
	m_clients.push_front(client);

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
	sendPing(client);

			




	
	
	
		
 

			




	
	
	
		
 
	// sendPing sets pongReceived to 0, but we want to have it -1 to ignore this backend

			




	
	
	
		
 
	// in first ::pingTimeout call, because it can be called right after this function

			




	
	
	
		
 
	// and backend wouldn't have any time to response to ping.

			




	
	
	
		
 
	client->pongReceived = -1;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::handleSessionFinished(Backend *c) {

			




	
	
	
		
 
	LOG4CXX_INFO(logger, "Backend " << c << " (ID=" << c->id << ") disconnected. Current backend count=" << (m_clients.size() - 1));

			




	
	
	
		
 

			




	
	
	
		
 
	// This backend will do, so we can't reconnect users to it in User::handleDisconnected call

			




	
	
	
		
 
	c->willDie = true;

			




	
	
	
		
 

			




	
	
	
		
 
	// If there are users associated with this backend, it must have crashed, so print error output

			




	
	
	
		
 
	// and disconnect users

			




	
	
	
		
 
	if (!c->users.empty()) {

			




	
	
	
		
 
		m_crashedBackends.push_back(c->id);

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	for (std::list<User *>::const_iterator it = c->users.begin(); it != c->users.end(); it++) {

			




	
	
	
		
 
		LOG4CXX_ERROR(logger, "Backend " << c << " (ID=" << c->id << ") disconnected (probably crashed) with active user " << (*it)->getJID().toString());

			




	
	
	
		
 
		(*it)->setData(NULL);

			




	
	
	
		
 
		(*it)->handleDisconnected("Internal Server Error, please reconnect.");

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	std::string message;

			




	
	
	
		
 
	pbnetwork::WrapperMessage wrap;

			




	
	
	
		
 
	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_EXIT);

			




	
	
	
		
 
	wrap.SerializeToString(&message);

			




	
	
	
		
 

			




	
	
	
		
 
	send(c->connection, message);

			




	
	
	
		
 

			




	
	
	
		
 
	c->connection->onDisconnected.disconnect_all_slots();

			




	
	
	
		
 
	c->connection->onDataRead.disconnect_all_slots();

			




	
	
	
		
 
	c->connection->disconnect();

			




	
	
	
		
 
	c->connection.reset();

			




	
	
	
		
 

			




	
	
	
		
 
	m_clients.remove(c);

			




	
	
	
		
 
	delete c;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	pbnetwork::Connected payload;

			




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

			




	
	
	
		
 
		// TODO: ERROR

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	if (!user) {

			




	
	
	
		
 
		LOG4CXX_ERROR(logger, "Connected payload received for unknown user " << payload.user());

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	user->setConnected(true);

			




	
	
	
		
 
	m_component->m_userRegistry->onPasswordValid(payload.user());

			




	
	
	
		
 
}

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	pbnetwork::Disconnected payload;

			




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

			




	
	
	
		
 
		// TODO: ERROR

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	m_component->m_userRegistry->onPasswordInvalid(payload.user(), payload.message());

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	if (!user) {

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 
	user->handleDisconnected(payload.message(), (Swift::SpectrumErrorPayload::Error) payload.error());

			




	
	
	
		
 
}

			




	
	
		
 
@@ -764,225 +774,229 @@ void NetworkPluginServer::handleFTStartPayload(const std::string &data) {

			




	
	
	
		
 
		return;

			




	
	
	
		
 

			




	
	
	
		
 
	LOG4CXX_INFO(logger, "handleFTStartPayload " << payload.filename() << " " << payload.buddyname());

			




	
	
	
		
 
	

			




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

			




	
	
	
		
 
	if (!buddy) {

			




	
	
	
		
 
		// TODO: escape? reject?

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	Swift::StreamInitiationFileInfo fileInfo;

			




	
	
	
		
 
	fileInfo.setSize(payload.size());

			




	
	
	
		
 
	fileInfo.setName(payload.filename());

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	boost::shared_ptr<MemoryReadBytestream> bytestream(new MemoryReadBytestream(payload.size()));

			




	
	
	
		
 
	bytestream->onDataNeeded.connect(boost::bind(&NetworkPluginServer::handleFTDataNeeded, this, c, bytestream_id + 1));

			




	
	
	
		
 

			




	
	
	
		
 
	LOG4CXX_INFO(logger, "jid=" << buddy->getJID());

			




	
	
	
		
 

			




	
	
	
		
 
	FileTransferManager::Transfer transfer = m_ftManager->sendFile(user, buddy, bytestream, fileInfo);

			




	
	
	
		
 
	if (!transfer.ft) {

			




	
	
	
		
 
		handleFTRejected(user, payload.buddyname(), payload.filename(), payload.size());

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	m_filetransfers[++bytestream_id] = transfer;

			




	
	
	
		
 
	transfer.ft->onStateChange.connect(boost::bind(&NetworkPluginServer::handleFTStateChanged, this, _1, payload.username(), payload.buddyname(), payload.filename(), payload.size(), bytestream_id));

			




	
	
	
		
 
	transfer.ft->start();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	pbnetwork::File payload;

			




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

			




	
	
	
		
 
		// TODO: ERROR

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	if (payload.has_ftid()) {

			




	
	
	
		
 
		if (m_filetransfers.find(payload.ftid()) != m_filetransfers.end()) {

			




	
	
	
		
 
			FileTransferManager::Transfer &transfer = m_filetransfers[payload.ftid()];

			




	
	
	
		
 
			transfer.ft->cancel();

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else {

			




	
	
	
		
 
			LOG4CXX_ERROR(logger, "FTFinishPayload for unknown ftid=" << payload.ftid());

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::handleFTDataPayload(Backend *b, const std::string &data) {

			




	
	
	
		
 
	pbnetwork::FileTransferData payload;

			




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

			




	
	
	
		
 
		// TODO: ERROR

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




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

			




	
	
	
		
 
// 	if (!user)

			




	
	
	
		
 
// 		return;

			




	
	
	
		
 

			




	
	
	
		
 
	if (m_filetransfers.find(payload.ftid()) == m_filetransfers.end()) {

			




	
	
	
		
 
		LOG4CXX_ERROR(logger, "Uknown filetransfer with id " << payload.ftid());

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	FileTransferManager::Transfer &transfer = m_filetransfers[payload.ftid()];

			




	
	
	
		
 
	MemoryReadBytestream *bytestream = (MemoryReadBytestream *) transfer.readByteStream.get();

			




	
	
	
		
 

			




	
	
	
		
 
	if (bytestream->appendData(payload.data()) > 5000000) {

			




	
	
	
		
 
		pbnetwork::FileTransferData f;

			




	
	
	
		
 
		f.set_ftid(payload.ftid());

			




	
	
	
		
 
		f.set_data("");

			




	
	
	
		
 

			




	
	
	
		
 
		std::string message;

			




	
	
	
		
 
		f.SerializeToString(&message);

			




	
	
	
		
 

			




	
	
	
		
 
		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_PAUSE);

			




	
	
	
		
 

			




	
	
	
		
 
		send(b->connection, message);

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::handleFTDataNeeded(Backend *b, unsigned long ftid) {

			




	
	
	
		
 
	pbnetwork::FileTransferData f;

			




	
	
	
		
 
	f.set_ftid(ftid);

			




	
	
	
		
 
	f.set_data("");

			




	
	
	
		
 

			




	
	
	
		
 
	std::string message;

			




	
	
	
		
 
	f.SerializeToString(&message);

			




	
	
	
		
 

			




	
	
	
		
 
	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_CONTINUE);

			




	
	
	
		
 

			




	
	
	
		
 
	send(b->connection, message);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::handlePongReceived(Backend *c) {

			




	
	
	
		
 
	// This could be first PONG from the backend

			




	
	
	
		
 
	if (c->pongReceived == -1) {

			




	
	
	
		
 
		// Backend is fully ready to handle requests

			




	
	
	
		
 
		c->willDie = false;

			




	
	
	
		
 

			




	
	
	
		
 
		if (m_clients.size() == 1) {

			




	
	
	
		
 
			// first backend connected, start the server, we're ready.

			




	
	
	
		
 
			m_component->start();

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::connectWaitingUsers() {

			




	
	
	
		
 
	// some users are in queue waiting for this backend

			




	
	
	
		
 
	while(!m_waitingUsers.empty()) {

			




	
	
	
		
 
		// There's no new backend, so stop associating users and wait for new backend,

			




	
	
	
		
 
		// which has been already spawned in getFreeClient() call.

			




	
	
	
		
 
			if (getFreeClient() == NULL)

			




	
	
	
		
 
		if (getFreeClient(true, false, true) == NULL)

			




	
	
	
		
 
			break;

			




	
	
	
		
 

			




	
	
	
		
 
		User *u = m_waitingUsers.front();

			




	
	
	
		
 
		m_waitingUsers.pop_front();

			




	
	
	
		
 

			




	
	
	
		
 
		LOG4CXX_INFO(logger, "Associating " << u->getJID().toString() << " with this backend");

			




	
	
	
		
 

			




	
	
	
		
 
		// associate backend with user

			




	
	
	
		
 
		handleUserCreated(u);

			




	
	
	
		
 

			




	
	
	
		
 
		// connect user if it's ready

			




	
	
	
		
 
		if (u->isReadyToConnect()) {

			




	
	
	
		
 
			handleUserReadyToConnect(u);

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::handlePongReceived(Backend *c) {

			




	
	
	
		
 
	// This could be first PONG from the backend

			




	
	
	
		
 
	if (c->pongReceived == -1) {

			




	
	
	
		
 
		// Backend is fully ready to handle requests

			




	
	
	
		
 
		c->willDie = false;

			




	
	
	
		
 

			




	
	
	
		
 
		if (m_clients.size() == 1) {

			




	
	
	
		
 
			// first backend connected, start the server, we're ready.

			




	
	
	
		
 
			m_component->start();

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		connectWaitingUsers();

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	c->pongReceived = true;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::handleQueryPayload(Backend *b, const std::string &data) {

			




	
	
	
		
 
	pbnetwork::BackendConfig payload;

			




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

			




	
	
	
		
 
		// TODO: ERROR

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	if (!m_adminInterface) {

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	boost::shared_ptr<Swift::Message> msg(new Swift::Message());

			




	
	
	
		
 
	msg->setBody(payload.config());

			




	
	
	
		
 
	m_adminInterface->handleQuery(msg);

			




	
	
	
		
 

			




	
	
	
		
 
	pbnetwork::BackendConfig response;

			




	
	
	
		
 
	response.set_config(msg->getBody());

			




	
	
	
		
 

			




	
	
	
		
 
	std::string message;

			




	
	
	
		
 
	response.SerializeToString(&message);

			




	
	
	
		
 

			




	
	
	
		
 
	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_QUERY);

			




	
	
	
		
 

			




	
	
	
		
 
	send(b->connection, message);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	pbnetwork::BackendConfig payload;

			




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

			




	
	
	
		
 
		// TODO: ERROR

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	m_config->updateBackendConfig(payload.config());

			




	
	
	
		
 
}

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	pbnetwork::RoomList payload;

			




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

			




	
	
	
		
 
		// TODO: ERROR

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	m_discoItemsResponder->clearRooms();

			




	
	
	
		
 
	for (int i = 0; i < payload.room_size() && i < payload.name_size(); i++) {

			




	
	
	
		
 
		m_discoItemsResponder->addRoom(Swift::JID::getEscapedNode(payload.room(i)) + "@" + m_component->getJID().toString(), payload.name(i));

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::handleDataRead(Backend *c, boost::shared_ptr<Swift::SafeByteArray> data) {

			




	
	
	
		
 
	// Append data to buffer

			




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

			




	
	
	
		
 

			




	
	
	
		
 
	// Parse data while there are some

			




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

			




	
	
	
		
 
		// expected_size of wrapper message

			




	
	
	
		
 
		unsigned int expected_size;

			




	
	
	
		
 

			




	
	
	
		
 
		// if data is >= 4, we have whole header and we can

			




	
	
	
		
 
		// read expected_size.

			




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

			




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

			




	
	
	
		
 
			expected_size = ntohl(expected_size);

			




	
	
	
		
 
			// If we don't have whole wrapper message, wait for next

			




	
	
	
		
 
			// handleDataRead call.

			




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

			




	
	
	
		
 
				return;

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else {

			




	
	
	
		
 
			return;

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		// Parse wrapper message and erase it from buffer.

			




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

			




	
	
	
		
 

			




	
	
	
		
 
		// If backend is slow and it is sending us lot of message, there is possibility

			




	
	
	
		
 
		// that we don't receive PONG response before timeout. However, if we received

			




	
	
	
		
 
		// at least some data, it means backend is not dead and we can treat it as

			




	
	
	
		
 
		// PONG received event.

			




	
	
	
		
 
		if (c->pongReceived == false) {

			




	
	
	
		
 
			c->pongReceived = true;

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		// Handle payload in wrapper message

			




	
	
	
		
 
		switch(wrapper.type()) {

			




	
	
	
		
 
			case pbnetwork::WrapperMessage_Type_TYPE_CONNECTED:

			




	
	
	
		
 
				handleConnectedPayload(wrapper.payload());

			




	
	
		
 
@@ -1549,124 +1563,135 @@ void NetworkPluginServer::handleVCardUpdated(User *user, boost::shared_ptr<Swift

			




	
	
	
		
 
	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_VCARD);

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	if (!c) {

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 
	send(c->connection, message);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	pbnetwork::VCard vcard;

			




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

			




	
	
	
		
 
	vcard.set_buddyname(name);

			




	
	
	
		
 
	vcard.set_id(id);

			




	
	
	
		
 

			




	
	
	
		
 
	std::string message;

			




	
	
	
		
 
	vcard.SerializeToString(&message);

			




	
	
	
		
 

			




	
	
	
		
 
	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_VCARD);

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	if (!c) {

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 
	send(c->connection, message);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::handleFTAccepted(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID) {

			




	
	
	
		
 
	pbnetwork::File f;

			




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

			




	
	
	
		
 
	f.set_buddyname(buddyName);

			




	
	
	
		
 
	f.set_filename(fileName);

			




	
	
	
		
 
	f.set_size(size);

			




	
	
	
		
 
	f.set_ftid(ftID);

			




	
	
	
		
 

			




	
	
	
		
 
	std::string message;

			




	
	
	
		
 
	f.SerializeToString(&message);

			




	
	
	
		
 

			




	
	
	
		
 
	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_START);

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	if (!c) {

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 
	send(c->connection, message);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::handleFTRejected(User *user, const std::string &buddyName, const std::string &fileName, unsigned long size) {

			




	
	
	
		
 
	pbnetwork::File f;

			




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

			




	
	
	
		
 
	f.set_buddyname(buddyName);

			




	
	
	
		
 
	f.set_filename(fileName);

			




	
	
	
		
 
	f.set_size(size);

			




	
	
	
		
 
	f.set_ftid(0);

			




	
	
	
		
 

			




	
	
	
		
 
	std::string message;

			




	
	
	
		
 
	f.SerializeToString(&message);

			




	
	
	
		
 

			




	
	
	
		
 
	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_FINISH);

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	if (!c) {

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 
	send(c->connection, message);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::handleFTStateChanged(Swift::FileTransfer::State state, const std::string &userName, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long id) {

			




	
	
	
		
 
	User *user = m_userManager->getUser(userName);

			




	
	
	
		
 
	if (!user) {

			




	
	
	
		
 
		// TODO: FIXME We have to remove filetransfer when use disconnects

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 
	if (state.state == Swift::FileTransfer::State::Transferring) {

			




	
	
	
		
 
		handleFTAccepted(user, buddyName, fileName, size, id);

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else if (state.state == Swift::FileTransfer::State::Canceled) {

			




	
	
	
		
 
		handleFTRejected(user, buddyName, fileName, size);

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NetworkPluginServer::sendPing(Backend *c) {

			




	
	
	
		
 

			




	
	
	
		
 
	std::string message;

			




	
	
	
		
 
	pbnetwork::WrapperMessage wrap;

			




	
	
	
		
 
	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_PING);

			




	
	
	
		
 
	wrap.SerializeToString(&message);

			




	
	
	
		
 

			




	
	
	
		
 
	if (c->connection) {

			




	
	
	
		
 
		LOG4CXX_INFO(logger, "PING to " << c << " (ID=" << c->id << ")");

			




	
	
	
		
 
		send(c->connection, message);

			




	
	
	
		
 
		c->pongReceived = false;

			




	
	
	
		
 
	}

			




	
	
	
		
 
// 	LOG4CXX_INFO(logger, "PING to " << c);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
NetworkPluginServer::Backend *NetworkPluginServer::getFreeClient(bool acceptUsers, bool longRun) {

			




	
	
	
		
 
NetworkPluginServer::Backend *NetworkPluginServer::getFreeClient(bool acceptUsers, bool longRun, bool check) {

			




	
	
	
		
 
	NetworkPluginServer::Backend *c = NULL;

			




	
	
	
		
 

			




	
	
	
		
 
	unsigned long diff = CONFIG_INT(m_config, "service.login_delay");

			




	
	
	
		
 
	time_t now = time(NULL);

			




	
	
	
		
 
	if (diff && (now - m_lastLogin < diff)) {

			




	
	
	
		
 
		m_loginTimer->start();

			




	
	
	
		
 
		return NULL;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	if (!check) {

			




	
	
	
		
 
		m_lastLogin = time(NULL);

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	// Check all backends and find free one

			




	
	
	
		
 
	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {

			




	
	
	
		
 
		if ((*it)->willDie == false && (*it)->acceptUsers == acceptUsers && (*it)->users.size() < CONFIG_INT(m_config, "service.users_per_backend") && (*it)->connection && (*it)->longRun == longRun) {

			




	
	
	
		
 
			c = *it;

			




	
	
	
		
 
			// if we're not reusing all backends and backend is full, stop accepting new users on this backend

			




	
	
	
		
 
			if (!CONFIG_BOOL(m_config, "service.reuse_old_backends")) {

			




	
	
	
		
 
				if (c->users.size() + 1 >= CONFIG_INT(m_config, "service.users_per_backend")) {

			




	
	
	
		
 
					c->acceptUsers = false;

			




	
	
	
		
 
				}

			




	
	
	
		
 
			}

			




	
	
	
		
 
			break;

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	// there's no free backend, so spawn one.

			




	
	
	
		
 
	if (c == NULL && !m_startingBackend) {

			




	
	
	
		
 
		m_isNextLongRun = longRun;

			




	
	
	
		
 
		m_startingBackend = true;

			




	
	
	
		
 
		exec_(CONFIG_STRING(m_config, "service.backend"), CONFIG_STRING(m_config, "service.backend_host").c_str(), CONFIG_STRING(m_config, "service.backend_port").c_str(), m_config->getCommandLineArgs().c_str());

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	return c;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
}

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








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