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

			}

		}

/**

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

		}

	}

	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;

// 	}

	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;

}

}