libtransport.git Changeset - 775c2a2e173c

Changeset - 775c2a2e173c

Parent rev.

Child rev.

[Not reviewed]

0 2 0

HanzZ - 13 years ago 2012-04-09 09:33:14
hanzz.k@gmail.com

fixed allowed_servers

2 files changed with 3 insertions and 3 deletions:

src/config.cpp

src/userregistration.cpp

0 comments (0 inline, 0 general)

src/config.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/config.h"
 #include <fstream>
 #ifdef _MSC_VER
 #include <direct.h>
 #define getcwd _getcwd
 #include <windows.h>
 #define PATH_MAX MAX_PATH
 #endif
 using namespace boost::program_options;
 namespace Transport {
 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.working_dir", value<std::string>()->default_value("/var/lib/spectrum2/$jid"), "Working dir")
-		("service.allowed_servers", value<std::string>()->default_value(""), "Only users from these servers can connect")
+		("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), "")
 		("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.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.")
+	;
 	parsed_options parsed = parse_config_file(ifs, opts, true);
 	bool found_working = false;
 	bool found_pidfile = 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 == "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_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) {
 		if (opt.unregistered) {
 			m_unregistered[opt.string_key] = opt.value[0];
+		}
 		else if (opt.value[0].find("$jid") != std::string::npos) {
 			boost::replace_all(opt.value[0], "$jid", jid);
+		}
+	}
 	store(parsed, m_variables);
 	notify(m_variables);
 	onConfigReloaded();
 	return true;
+}
 bool Config::load(std::istream &ifs) {
 	options_description opts("Transport options");
 	return load(ifs, opts);
+}
 bool Config::load(const std::string &configfile, const std::string &jid) {
 	try {
 		options_description opts("Transport options");
 		return load(configfile, opts, jid);
 	} catch ( const boost::program_options::multiple_occurrences& e ) {
 		std::cerr << configfile << " parsing error: " << e.what() << " from option: " << e.get_option_name() << std::endl;
 		return false;
+	}
+}
 bool Config::reload() {
 	if (m_file.empty()) {
 		return false;
+	}
 	return load(m_file);
+}
+}

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>
 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);
 	// Disconnect the user
 	User *user = m_userManager->getUser(barejid);
 	if (user) {
 		m_userManager->removeUser(user);
+	}
 	if (remoteRosterNotSupported) {
 		Swift::Presence::ref response;
 		response = Swift::Presence::create();
 		response->setTo(Swift::JID(barejid));
 		response->setFrom(m_component->getJID());
 		response->setType(Swift::Presence::Unsubscribe);
 		m_component->getStanzaChannel()->sendPresence(response);
 		response = Swift::Presence::create();
 		response->setTo(Swift::JID(barejid));
 		response->setFrom(m_component->getJID());
 		response->setType(Swift::Presence::Unsubscribed);
 		m_component->getStanzaChannel()->sendPresence(response);
+	}
 	else {
 		Swift::RosterPayload::ref payload = Swift::RosterPayload::ref(new Swift::RosterPayload());
 		Swift::RosterItemPayload item;
 		item.setJID(m_component->getJID());
 		item.setSubscription(Swift::RosterItemPayload::Remove);
 		payload->addItem(item);
 		Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, barejid, m_component->getIQRouter());
 		request->send();
+	}
+}
 bool UserRegistration::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::InBandRegistrationPayload> payload) {
 	// TODO: backend should say itself if registration is needed or not...
 	if (CONFIG_STRING(m_config, "service.protocol") == "irc") {
 		sendError(from, id, ErrorPayload::BadRequest, ErrorPayload::Modify);
 		return true;
+	}
 	std::string barejid = from.toBare().toString();
 	if (!CONFIG_BOOL(m_config,"registration.enable_public_registration")) {
-		std::list<std::string> const &x = CONFIG_LIST(m_config,"service.allowed_servers");
+		std::vector<std::string> const &x = CONFIG_VECTOR(m_config,"service.allowed_servers");
 		if (std::find(x.begin(), x.end(), from.getDomain()) == x.end()) {
 			LOG4CXX_INFO(logger, barejid << ": This user has no permissions to register an account")
 			sendError(from, id, ErrorPayload::BadRequest, ErrorPayload::Modify);
 			return true;
+		}
+	}
 	boost::shared_ptr<InBandRegistrationPayload> reg(new InBandRegistrationPayload());
 	UserInfo res;
 	bool registered = m_storageBackend->getUser(barejid, res);
 	std::string instructions = CONFIG_STRING(m_config, "registration.instructions");
 	std::string usernameField = CONFIG_STRING(m_config, "registration.username_label");
 	// normal jabber:iq:register
 	reg->setInstructions(instructions);
 	reg->setRegistered(registered);
 	reg->setUsername(res.uin);
 	if (CONFIG_STRING(m_config, "service.protocol") != "twitter" && CONFIG_STRING(m_config, "service.protocol") != "bonjour")
 		reg->setPassword(res.password);
 	// form
 	Form::ref form(new Form(Form::FormType));
 	form->setTitle((("Registration")));
 	form->setInstructions((instructions));
 	HiddenFormField::ref type = HiddenFormField::create();
 	type->setName("FORM_TYPE");
 	type->setValue("jabber:iq:register");
 	form->addField(type);
 	TextSingleFormField::ref username = TextSingleFormField::create();
 	username->setName("username");
 	username->setLabel((usernameField));
 	username->setValue(res.uin);
 	username->setRequired(true);
 	form->addField(username);
 	if (CONFIG_STRING(m_config, "service.protocol") != "twitter" && CONFIG_STRING(m_config, "service.protocol") != "bonjour") {
 		TextPrivateFormField::ref password = TextPrivateFormField::create();
 		password->setName("password");
 		password->setLabel((("Password")));
 		password->setRequired(true);
 		form->addField(password);
+	}
 	ListSingleFormField::ref language = ListSingleFormField::create();
 	language->setName("language");
 	language->setLabel((("Language")));
 	language->addOption(Swift::FormField::Option(CONFIG_STRING(m_config, "registration.language"), CONFIG_STRING(m_config, "registration.language")));
 	if (registered)
 		language->setValue(res.language);
 	else
 		language->setValue(CONFIG_STRING(m_config, "registration.language"));
 	form->addField(language);
 //	TextSingleFormField::ref encoding = TextSingleFormField::create();
 //	encoding->setName("encoding");
 //	encoding->setLabel((("Encoding")));
 //	if (registered)
 //		encoding->setValue(res.encoding);
 //	else
 //		encoding->setValue(CONFIG_STRING(m_config, "registration.encoding"));
 //	form->addField(encoding);
 	if (registered) {
 		BooleanFormField::ref boolean = BooleanFormField::create();
 		boolean->setName("unregister");
 		boolean->setLabel((("Remove your registration")));
 		boolean->setValue(0);
 		form->addField(boolean);
 	} else {
 		if (CONFIG_BOOL(m_config,"registration.require_local_account")) {
 			std::string localUsernameField = CONFIG_STRING(m_config, "registration.local_username_label");
 			TextSingleFormField::ref local_username = TextSingleFormField::create();
 			local_username->setName("local_username");
 			local_username->setLabel((localUsernameField));
 			local_username->setRequired(true);
 			form->addField(local_username);
 			TextPrivateFormField::ref local_password = TextPrivateFormField::create();
 			local_password->setName("local_password");
 			local_password->setLabel((("Local Password")));
 			local_password->setRequired(true);
 			form->addField(local_password);
+		}
+	}
 	reg->setForm(form);
 	sendResponse(from, id, reg);
 	return true;
+}
 bool UserRegistration::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::InBandRegistrationPayload> payload) {
 	// TODO: backend should say itself if registration is needed or not...
 	if (CONFIG_STRING(m_config, "service.protocol") == "irc") {
 		sendError(from, id, ErrorPayload::BadRequest, ErrorPayload::Modify);
 		return true;
+	}
 	std::string barejid = from.toBare().toString();
 	if (!CONFIG_BOOL(m_config,"registration.enable_public_registration")) {
-		std::list<std::string> const &x = CONFIG_LIST(m_config,"service.allowed_servers");
+		std::vector<std::string> const &x = CONFIG_VECTOR(m_config,"service.allowed_servers");
 		if (std::find(x.begin(), x.end(), from.getDomain()) == x.end()) {
 			LOG4CXX_INFO(logger, barejid << ": This user has no permissions to register an account")
 			sendError(from, id, ErrorPayload::BadRequest, ErrorPayload::Modify);
 			return true;
+		}
+	}
 	UserInfo res;
 	bool registered = m_storageBackend->getUser(barejid, res);
 	std::string encoding;
 	std::string language;
 	std::string local_username("");
 	std::string local_password("");
 	Form::ref form = payload->getForm();
 	if (form) {
 		const std::vector<FormField::ref> fields = form->getFields();
 		for (std::vector<FormField::ref>::const_iterator it = fields.begin(); it != fields.end(); it++) {
 			TextSingleFormField::ref textSingle = boost::dynamic_pointer_cast<TextSingleFormField>(*it);
 			if (textSingle) {
 				if (textSingle->getName() == "username") {
 					payload->setUsername(textSingle->getValue());
+				}
 				else if (textSingle->getName() == "encoding") {
 					encoding = textSingle->getValue();
+				}
 				// Pidgin sends it as textSingle, not sure why...
 				else if (textSingle->getName() == "password") {
 					payload->setPassword(textSingle->getValue());
+				}
 				else if (textSingle->getName() == "local_username") {
 					local_username = textSingle->getValue();
+				}
 				// Pidgin sends it as textSingle, not sure why...
 				else if (textSingle->getName() == "local_password") {
 					local_password = textSingle->getValue();
+				}
 				continue;
+			}
 			TextPrivateFormField::ref textPrivate = boost::dynamic_pointer_cast<TextPrivateFormField>(*it);
 			if (textPrivate) {
 				if (textPrivate->getName() == "password") {
 					payload->setPassword(textPrivate->getValue());
+				}
 				else if (textPrivate->getName() == "local_password") {
 					local_password = textPrivate->getValue();
+				}
 				continue;
+			}
 			ListSingleFormField::ref listSingle = boost::dynamic_pointer_cast<ListSingleFormField>(*it);
 			if (listSingle) {
 				if (listSingle->getName() == "language") {
 					language = listSingle->getValue();
+				}
 				continue;
+			}
 			BooleanFormField::ref boolean = boost::dynamic_pointer_cast<BooleanFormField>(*it);
 			if (boolean) {
 				if (boolean->getName() == "unregister") {
 					if (boolean->getValue()) {
 						payload->setRemove(true);
+					}
+				}
 				continue;
+			}
+		}
+	}
 	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 (!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);
+	}

0 comments (0 inline, 0 general)