libtransport.git Changeset - 1c1adbd7d5d8

Changeset - 1c1adbd7d5d8

Parent rev.

Child rev.

[Not reviewed]

Merge

0 5 4

HanzZ - 13 years ago 2012-08-01 20:01:04
hanzz.k@gmail.com

Merge branch 'master' of github.com:hanzz/libtransport

3 files changed with 17 insertions and 10 deletions:

backends/libpurple/main.cpp

src/config.cpp

src/userregistration.cpp

0 comments (0 inline, 0 general)

backends/libpurple/main.cpp

➞

Show inline comments

@@ @@ -251,194 +251,199 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 				ret = g_file_get_contents (KEYFILE_STRING("backend", "default_avatar").c_str(),
 											&contents, &length, NULL);
+			}
 			if (ret) {
 				purple_buddy_icons_set_account_icon(account, (guchar *) contents, length);
+			}
+		}
 		void setDefaultAccountOptions(PurpleAccount *account) {
 			int i = 0;
 			gchar **keys = g_key_file_get_keys (keyfile, "purple", NULL, NULL);
 			while (keys && keys[i] != NULL) {
 				std::string key = keys[i];
 				if (key == "fb_api_key" || key == "fb_api_secret") {
 					purple_account_set_bool(account, "auth_fb", TRUE);
+				}
 				PurplePlugin *plugin = purple_find_prpl(purple_account_get_protocol_id(account));
 				PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(plugin);
 				bool found = false;
 				for (GList *l = prpl_info->protocol_options; l != NULL; l = l->next) {
 					PurpleAccountOption *option = (PurpleAccountOption *) l->data;
 					PurplePrefType type = purple_account_option_get_type(option);
 					std::string key2(purple_account_option_get_setting(option));
 					if (key != key2) {
 						continue;
+					}
 					found = true;
 					switch (type) {
 						case PURPLE_PREF_BOOLEAN:
 							purple_account_set_bool(account, key.c_str(), fromString<bool>(KEYFILE_STRING("purple", key)));
 							break;
 						case PURPLE_PREF_INT:
 							purple_account_set_int(account, key.c_str(), fromString<int>(KEYFILE_STRING("purple", key)));
 							break;
 						case PURPLE_PREF_STRING:
 						case PURPLE_PREF_STRING_LIST:
 							purple_account_set_string(account, key.c_str(), KEYFILE_STRING("purple", key).c_str());
 							break;
 						default:
 							continue;
+					}
 					break;
+				}
 				if (!found) {
 					purple_account_set_string(account, key.c_str(), KEYFILE_STRING("purple", key).c_str());
+				}
 				i++;
+			}
 			g_strfreev (keys);
 			char* contents;
 			gsize length;
 			gboolean ret = g_file_get_contents ("gfire.cfg", &contents, &length, NULL);
 			if (ret) {
 				purple_account_set_int(account, "version", fromString<int>(std::string(contents, length)));
+			}
 			if (KEYFILE_STRING("service", "protocol") == "prpl-novell") {
 				std::string username(purple_account_get_username(account));
 				std::vector <std::string> u = split(username, '@');
 				purple_account_set_username(account, (const char*) u.front().c_str());
 				std::vector <std::string> s = split(u.back(), ':');
 				purple_account_set_string(account, "server", s.front().c_str());
 				purple_account_set_int(account, "port", atoi(s.back().c_str()));
+			}
+		}
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 			PurpleAccount *account = NULL;
 			std::string name;
 			std::string protocol;
 			getProtocolAndName(legacyName, name, protocol);
 			if (password.empty()) {
 				LOG4CXX_INFO(logger,  name.c_str() << ": Empty password");
 				np->handleDisconnected(user, 0, "Empty password.");
 				return;
+			}
 			if (!purple_find_prpl(protocol.c_str())) {
 				LOG4CXX_INFO(logger,  name.c_str() << ": Invalid protocol '" << protocol << "'");
 				np->handleDisconnected(user, 0, "Invalid protocol " + protocol);
 				return;
+			}
 			if (purple_accounts_find(name.c_str(), protocol.c_str()) != NULL) {
 				LOG4CXX_INFO(logger, "Using previously created account with name '" << name.c_str() << "' and protocol '" << protocol << "'");
 				account = purple_accounts_find(name.c_str(), protocol.c_str());
 				if (m_accounts.find(account) != m_accounts.end() && m_accounts[account] != user) {
 					LOG4CXX_INFO(logger, "Account '" << name << "' is already used by '" << m_accounts[account] << "'");
 					np->handleDisconnected(user, 0, "Account '" + name + "' is already used by '" + m_accounts[account] + "'");
 					return;
+				}
 				LOG4CXX_INFO(logger, "Using previously created account with name '" << name.c_str() << "' and protocol '" << protocol << "'");
+			}
 			else {
 				LOG4CXX_INFO(logger, "Creating account with name '" << name.c_str() << "' and protocol '" << protocol << "'");
 				account = purple_account_new(name.c_str(), protocol.c_str());
 				purple_accounts_add(account);
+			}
 			m_sessions[user] = account;
 			m_accounts[account] = user;
 			// Default avatar
 			setDefaultAvatar(account, legacyName);
 			purple_account_set_password(account, password.c_str());
 			purple_account_set_bool(account, "custom_smileys", FALSE);
 			purple_account_set_bool(account, "direct_connect", FALSE);
 			setDefaultAccountOptions(account);
 			// Enable account + privacy lists
 			purple_account_set_enabled(account, "spectrum", TRUE);
 			if (KEYFILE_BOOL("service", "enable_privacy_lists")) {
 				purple_account_set_privacy_type(account, PURPLE_PRIVACY_DENY_USERS);
+			}
 			// Set the status
 			const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AVAILABLE);
 			if (status_type != NULL) {
 				purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, NULL);
+			}
+		}
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				if (purple_account_get_int(account, "version", 0) != 0) {
 					std::string data = stringOf(purple_account_get_int(account, "version", 0));
 					g_file_set_contents ("gfire.cfg", data.c_str(), data.size(), NULL);
+				}
 // 				VALGRIND_DO_LEAK_CHECK;
 				m_sessions.erase(user);
 				purple_account_disconnect(account);
 				purple_account_set_enabled(account, "spectrum", FALSE);
 				m_accounts.erase(account);
 				purple_accounts_delete(account);
 #ifndef WIN32
 				malloc_trim(0);
 #endif
 // 				VALGRIND_DO_LEAK_CHECK;
+			}
+		}
 		void handleStatusChangeRequest(const std::string &user, int status, const std::string &statusMessage) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				int st;
 				switch(status) {
 					case pbnetwork::STATUS_AWAY: {
 						st = PURPLE_STATUS_AWAY;
 						if (!purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AWAY))
 							st = PURPLE_STATUS_EXTENDED_AWAY;
 						else
 							st = PURPLE_STATUS_AWAY;
 						break;
+					}
 					case pbnetwork::STATUS_DND: {
 						st = PURPLE_STATUS_UNAVAILABLE;
 						break;
+					}
 					case pbnetwork::STATUS_XA: {
 						if (!purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_EXTENDED_AWAY))
 							st = PURPLE_STATUS_AWAY;
 						else
 							st = PURPLE_STATUS_EXTENDED_AWAY;
 						break;
+					}
 					case pbnetwork::STATUS_NONE: {
 						st = PURPLE_STATUS_OFFLINE;
 						break;
+					}
 					case pbnetwork::STATUS_INVISIBLE:
 						st = PURPLE_STATUS_INVISIBLE;
 						break;
 					default:
 						st = PURPLE_STATUS_AVAILABLE;
 						break;
+				}
 				gchar *_markup = purple_markup_escape_text(statusMessage.c_str(), -1);
 				std::string markup(_markup);
 				g_free(_markup);
 				// we are already connected so we have to change status
 				const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive(account, (PurpleStatusPrimitive) st);
 				if (status_type != NULL) {

src/config.cpp

➞

Show inline comments

@@ @@ -8,192 +8,193 @@ @@
  * 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 _MSC_VER
 #include <direct.h>
 #define getcwd _getcwd
 #include <windows.h>
 #define PATH_MAX MAX_PATH
 #endif
 #include "iostream"
 #include "boost/version.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;
 	bool ret = load(ifs, opts, jid);
 	ifs.close();
 	char path[PATH_MAX] = "";
 	if (m_file.find_first_of("/") != 0) {
 		getcwd(path, PATH_MAX);
 		m_file = std::string(path) + "/" + m_file;
+	}
 	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), "")
 		("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_usernanames", 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.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.")
 		("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.")
+	;
 	// Load configs passed by command line
 	if (m_argc != 0 && m_argv) {
 		basic_command_line_parser<char> parser = command_line_parser(m_argc, m_argv).options(opts).allow_unregistered();
 		parsed_options parsed = parser.run();
 		store(parsed, m_variables);
+	}
 	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));
+	}
 	if (!found_backend_port) {
 		std::vector<std::string> value;
 		std::string p = boost::lexical_cast<std::string>(getRandomPort(_jid.empty() ? jid : _jid));
 		value.push_back(p);
 		parsed.options.push_back(boost::program_options::basic_option<char>("service.backend_port", value));
+	}
 	if (!found_database) {
 		std::vector<std::string> value;
 		value.push_back("/var/lib/spectrum2/$jid/database.sql");
 		parsed.options.push_back(boost::program_options::basic_option<char>("database.database", value));
+	}
 	BOOST_FOREACH(option &opt, parsed.options) {

src/userregistration.cpp

➞

Show inline comments

 /**
  * libtransport -- C++ library for easy XMPP Transports development
+ *
  * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>
+ *
  * 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/userregistration.h"
 #include "transport/usermanager.h"
 #include "transport/storagebackend.h"
 #include "transport/transport.h"
 #include "transport/rostermanager.h"
 #include "transport/user.h"
 #include "transport/logging.h"
 #include "Swiften/Elements/ErrorPayload.h"
 #include <boost/shared_ptr.hpp>
 #include <boost/thread.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
 #include <boost/regex.hpp>
 using namespace Swift;
 namespace Transport {
 DEFINE_LOGGER(logger, "UserRegistration");
 UserRegistration::UserRegistration(Component *component, UserManager *userManager, StorageBackend *storageBackend) : Swift::Responder<Swift::InBandRegistrationPayload>(component->m_iqRouter) {
 	m_component = component;
 	m_config = m_component->m_config;
 	m_storageBackend = storageBackend;
 	m_userManager = userManager;
+}
 UserRegistration::~UserRegistration(){
+}
 bool UserRegistration::registerUser(const UserInfo &row) {
 	UserInfo user;
 	bool registered = m_storageBackend->getUser(row.jid, user);
 	// This user is already registered
 	if (registered)
 		return false;
 	m_storageBackend->setUser(row);
 	Swift::Presence::ref response = Swift::Presence::create();
 	response->setFrom(m_component->getJID());
 	response->setTo(Swift::JID(row.jid));
 	response->setType(Swift::Presence::Subscribe);
 	m_component->getStanzaChannel()->sendPresence(response);
 	onUserRegistered(row);
 	return true;
+}
 bool UserRegistration::unregisterUser(const std::string &barejid) {
 	UserInfo userInfo;
 	bool registered = m_storageBackend->getUser(barejid, userInfo);
 	// This user is not registered
 	if (!registered)
 		return false;
 	onUserUnregistered(userInfo);
 	// We have to check if server supports remoteroster XEP and use it if it's supported or fallback to unsubscribe otherwise
 	AddressedRosterRequest::ref request = AddressedRosterRequest::ref(new AddressedRosterRequest(m_component->getIQRouter(), barejid));
 	request->onResponse.connect(boost::bind(&UserRegistration::handleUnregisterRemoteRosterResponse, this, _1, _2, barejid));
 	request->send();
 	return true;
+}
 void UserRegistration::handleUnregisterRemoteRosterResponse(boost::shared_ptr<Swift::RosterPayload> payload, Swift::ErrorPayload::ref remoteRosterNotSupported /*error*/, const std::string &barejid) {
 	UserInfo userInfo;
 	bool registered = m_storageBackend->getUser(barejid, userInfo);
 	// This user is not registered
 	if (!registered)
 		return;
 	if (remoteRosterNotSupported) {
 		std::list <BuddyInfo> roster;
 		m_storageBackend->getBuddies(userInfo.id, roster);
 		for(std::list<BuddyInfo>::iterator u = roster.begin(); u != roster.end() ; u++){
 			std::string name = Swift::JID::getEscapedNode((*u).legacyName);
 			Swift::Presence::ref response;
 			response = Swift::Presence::create();
 			response->setTo(Swift::JID(barejid));
 			response->setFrom(Swift::JID(name, m_component->getJID().toString()));
 			response->setType(Swift::Presence::Unsubscribe);
 			m_component->getStanzaChannel()->sendPresence(response);
 			response = Swift::Presence::create();
 			response->setTo(Swift::JID(barejid));
 			response->setFrom(Swift::JID(name, m_component->getJID().toString()));
 			response->setType(Swift::Presence::Unsubscribed);
 			m_component->getStanzaChannel()->sendPresence(response);
+		}
+	}
 	else {
 		BOOST_FOREACH(Swift::RosterItemPayload it, payload->getItems()) {
 			Swift::RosterPayload::ref p = Swift::RosterPayload::ref(new Swift::RosterPayload());
 			Swift::RosterItemPayload item;
 			item.setJID(it.getJID());
 			item.setSubscription(Swift::RosterItemPayload::Remove);
 			p->addItem(item);
 			Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(p, barejid, m_component->getIQRouter());
 			request->send();
+		}
+	}
 	// Remove user from database
 	m_storageBackend->removeUser(userInfo.id);
+		}
+	}
 	if (payload->isRemove()) {
 		unregisterUser(barejid);
 		sendResponse(from, id, InBandRegistrationPayload::ref());
 		return true;
+	}
 	if (CONFIG_BOOL(m_config,"registration.require_local_account")) {
 	/*	if (!local_username || !local_password) {
 			sendResponse(from, id, InBandRegistrationPayload::ref());
 			return true
 		} else */ if (local_username == "" || local_password == "") {
 			sendResponse(from, id, InBandRegistrationPayload::ref());
 			return true;
+		}
 //		Swift::logging = true;
 		bool validLocal = false;
 		std::string localLookupServer = CONFIG_STRING(m_config, "registration.local_account_server");
 		std::string localLookupJID = local_username + std::string("@") + localLookupServer;
 		SimpleEventLoop localLookupEventLoop;
 		BoostNetworkFactories localLookupNetworkFactories(&localLookupEventLoop);
 		Client localLookupClient(localLookupJID, local_password, &localLookupNetworkFactories);
 		// TODO: this is neccessary on my server ... but should maybe omitted
 		localLookupClient.setAlwaysTrustCertificates();
 		localLookupClient.connect();
 		class SimpleLoopRunner {
 			public:
 				SimpleLoopRunner() {};
 				static void run(SimpleEventLoop * loop) {
 					loop->run();
 				};
 		};
 		// TODO: Really ugly and hacky solution, any other ideas more than welcome!
 		boost::thread thread(boost::bind(&(SimpleLoopRunner::run), &localLookupEventLoop));
 		thread.timed_join(boost::posix_time::millisec(CONFIG_INT(m_config, "registration.local_account_server_timeout")));
 		localLookupEventLoop.stop();
 		thread.join();
 		validLocal = localLookupClient.isAvailable();
 		localLookupClient.disconnect();
 		if (!validLocal) {
 			sendError(from, id, ErrorPayload::NotAuthorized, ErrorPayload::Modify);
 			return true;
+		}
+	}
 	printf("here\n");
 	if (!payload->getUsername() || !payload->getPassword()) {
 		sendError(from, id, ErrorPayload::NotAcceptable, ErrorPayload::Modify);
 		return true;
+	}
 	// Register or change password
 	if (payload->getUsername()->empty()) {
 		sendError(from, id, ErrorPayload::NotAcceptable, ErrorPayload::Modify);
 		return true;
+	}
 	// TODO: Move this check to backend somehow
 	if (CONFIG_STRING(m_config, "service.protocol") == "prpl-jabber") {
 		// User tries to register himself.
 		if ((Swift::JID(*payload->getUsername()).toBare() == from.toBare())) {
 			sendError(from, id, ErrorPayload::NotAcceptable, ErrorPayload::Modify);
 			return true;
+		}
 		// User tries to register someone who's already registered.
 		UserInfo user_row;
 		bool registered = m_storageBackend->getUser(Swift::JID(*payload->getUsername()).toBare().toString(), user_row);
 		if (registered) {
 			sendError(from, id, ErrorPayload::NotAcceptable, ErrorPayload::Modify);
 			return true;
+		}
+	}
 	std::string username = *payload->getUsername();
 	std::string newUsername(username);
 	if (!CONFIG_STRING(m_config, "registration.username_mask").empty()) {
 		newUsername = CONFIG_STRING(m_config, "registration.username_mask");
 		boost::replace_all(newUsername, "$username", username);
+	}
 //TODO: Part of spectrum1 registration stuff, this should be potentially rewritten for S2 too
 // 	if (!m_component->protocol()->isValidUsername(newUsername)) {
 // 		Log("UserRegistration", "This is not valid username: "<< newUsername);
 // 		sendError(from, id, ErrorPayload::NotAcceptable, ErrorPayload::Modify);
 // 		return true;
 // 	}
 //TODO: Part of spectrum1 registration stuff, this should be potentially rewritten for S2 too
 // #if GLIB_CHECK_VERSION(2,14,0)
 // 	if (!CONFIG_STRING(m_config, "registration.reg_allowed_usernames").empty() &&
 // 		!g_regex_match_simple(CONFIG_STRING(m_config, "registration.reg_allowed_usernames"), newUsername.c_str(),(GRegexCompileFlags) (G_REGEX_CASELESS | G_REGEX_EXTENDED), (GRegexMatchFlags) 0)) {
 // 		Log("UserRegistration", "This is not valid username: "<< newUsername);
 // 		sendError(from, id, ErrorPayload::NotAcceptable, ErrorPayload::Modify);
 // 		return true;
 // 	}
 // #endif
 	if (!CONFIG_STRING(m_config, "registration.allowed_usernames").empty()) {
 		boost::regex expression(CONFIG_STRING(m_config, "registration.allowed_usernames"));
 		if (!regex_match(newUsername, expression)) {
 			LOG4CXX_INFO(logger, "This is not valid username: " << newUsername);
 			sendError(from, id, ErrorPayload::NotAcceptable, ErrorPayload::Modify);
 			return true;
+		}
+	}
 	if (!registered) {
 		res.jid = barejid;
 		res.uin = newUsername;
 		res.password = *payload->getPassword();
 		res.language = language;
 		res.encoding = encoding;
 		res.vip = 0;
 		registerUser(res);
+	}
 	else {
 		res.jid = barejid;
 		res.uin = newUsername;
 		res.password = *payload->getPassword();
 		res.language = language;
 		res.encoding = encoding;
 		m_storageBackend->setUser(res);
 		onUserUpdated(res);
+	}
 	sendResponse(from, id, InBandRegistrationPayload::ref());
 	return true;
+}
+}

0 comments (0 inline, 0 general)