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.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")

		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")) {

		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

			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")) {

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

				}