find_package(Doxygen)

INCLUDE(FindQt4)

FIND_PACKAGE(Qt4 COMPONENTS QtCore)

# ADD_DEFINITIONS(${SWIFTEN_CFLAGS})

message("  Supported features")

message("-----------------------")

if (SQLITE3_FOUND)

	ADD_DEFINITIONS(-DWITH_SQLITE)

	include_directories(SQLITE3_INCLUDE_DIR)

	message("SQLite3           : yes")

else (SQLITE3_FOUND)

	set(SQLITE3_LIBRARIES "")

	message("SQLite3           : no")

endif (SQLITE3_FOUND)

if (PROTOBUF_FOUND)

	ADD_DEFINITIONS(-DWITH_PROTOBUF)

	include_directories(${PROTOBUF_INCLUDE_DIRS})

	message("Network plugins   : yes")

	if(PURPLE_LIBRARY AND PURPLE_INCLUDE_DIR)

		message("Libpurple plugin  : yes")

		include_directories(${PURPLE_INCLUDE_DIR})

		include_directories(${GLIB2_INCLUDE_DIR})

	else()

		message("Libpurple plugin  : no (install libpurple)")

	endif()

	if(IRC_FOUND)

		ADD_DEFINITIONS(-DIRC_SHARED)

		message("IRC plugin        : yes")

		include_directories(${IRC_INCLUDE_DIR})

		include(${QT_USE_FILE})

	else()

		message("IRC plugin        : no (install libircclient-qt and Google Protocol Buffers)")

	endif()

else()

	message("Network plugins   : no (install Google Protocol Buffers)")

	message("Libpurple plugin  : no (install libpurple and Google Protocol Buffers)")

	message("IRC plugin        : no (install libircclient-qt and Google Protocol Buffers)")

endif()

if(CMAKE_BUILD_TYPE MATCHES Debug)

	ADD_DEFINITIONS(-ggdb)

	ADD_DEFINITIONS(-DDEBUG)

	ADD_DEFINITIONS(-Wall)

	ADD_DEFINITIONS(-W)

	ADD_DEFINITIONS(-Wcast-align)

	ADD_DEFINITIONS(-Wextra -Wno-sign-compare -Wno-unused-parameter)

	ADD_DEFINITIONS(-Winit-self)

	ADD_DEFINITIONS(-Wmissing-declarations)

	ADD_DEFINITIONS(-Wpointer-arith)

	ADD_DEFINITIONS(-Wreorder)

	ADD_DEFINITIONS(-Woverloaded-virtual)

	ADD_DEFINITIONS(-Wsign-promo)

	ADD_DEFINITIONS(-Wundef -Wunused)

	message("Debug             : yes")

else(CMAKE_BUILD_TYPE MATCHES Debug)

	message("Debug             : no (run \"cmake . -DCMAKE_BUILD_TYPE=Debug\")")

endif(CMAKE_BUILD_TYPE MATCHES Debug)

SET(TRANSPORT_VERSION 2.0)

SET(PROJECT_VERSION 2.0)

include_directories(include)

include_directories(${EVENT_INCLUDE_DIRS})

include_directories(${SWIFTEN_INCLUDE_DIR})

include_directories(${Boost_INCLUDE_DIRS})

ADD_SUBDIRECTORY(src)

ADD_SUBDIRECTORY(include)

ADD_SUBDIRECTORY(spectrum)

ADD_SUBDIRECTORY(backends)

if(DOXYGEN_FOUND)

	message("Docs              : yes")

	ADD_SUBDIRECTORY(docs)

else(DOXYGEN_FOUND)

	message("Docs              : no (install doxygen)")

endif(DOXYGEN_FOUND)

message("----------------------")

/**

 * 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

 */

#pragma once

#include "Swiften/Swiften.h"

#include "Swiften/Elements/InBandRegistrationPayload.h"

namespace Transport {

struct UserInfo;

class Component;

class StorageBackend;

class UserManager;

class Config;

/// Allows users to register the transport using service discovery.

	public:

		/// Creates new UserRegistration handler.

		/// \param component Component associated with this class

		/// \param userManager UserManager associated with this class

		/// \param storageBackend StorageBackend where the registered users will be stored

		UserRegistration(Component *component, UserManager *userManager, StorageBackend *storageBackend);

		/// Destroys UserRegistration.

		~UserRegistration();

		/// Registers new user. This function stores user into database and subscribe user to transport.

		/// \param userInfo UserInfo struct with informations about registered user

		/// \return false if user is already registered

		bool registerUser(const UserInfo &userInfo);

		/// Unregisters user. This function removes all data about user from databa, unsubscribe all buddies

		/// managed by this transport and disconnects user if he's connected.

		/// \param barejid bare JID of user to unregister

		/// \return false if there is no such user registered

		bool unregisterUser(const std::string &barejid);

		/// Called when new user has been registered.

		/// \param userInfo UserInfo struct with informations about user

		boost::signal<void (const UserInfo &userInfo)> onUserRegistered;

		/// Called when user has been unregistered.

		/// \param userInfo UserInfo struct with informations about user

		boost::signal<void (const UserInfo &userInfo)> onUserUnregistered;

		/// Called when user's registration has been updated.

		/// \param userInfo UserInfo struct with informations about user

		boost::signal<void (const UserInfo &userInfo)> onUserUpdated;

	private:

		Component *m_component;

		StorageBackend *m_storageBackend;

		UserManager *m_userManager;

		Config *m_config;

};

}

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

 */

#include "transport/sqlite3backend.h"

#include <boost/bind.hpp>

#define SQLITE_DB_VERSION 3

#define CHECK_DB_RESPONSE(stmt) \

	if(stmt) { \

		sqlite3_exec(m_db, "ROLLBACK;", NULL, NULL, NULL); \

		return 0; \

	}

// Prepare the SQL statement

#define PREP_STMT(sql, str) \

	if(sqlite3_prepare_v2(m_db, std::string(str).c_str(), -1, &sql, NULL)) { \

		onStorageError(str, (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db))); \

		return false; \

	}

// Finalize the prepared statement

#define FINALIZE_STMT(prep) \

	if(prep != NULL) { \

		sqlite3_finalize(prep); \

	}

#define BEGIN(STATEMENT) 	sqlite3_reset(STATEMENT);\

							int STATEMENT##_id = 1;\

							int STATEMENT##_id_get = 0;\

							(void)STATEMENT##_id_get;

#define BIND_INT(STATEMENT, VARIABLE) sqlite3_bind_int(STATEMENT, STATEMENT##_id++, VARIABLE)

#define BIND_STR(STATEMENT, VARIABLE) sqlite3_bind_text(STATEMENT, STATEMENT##_id++, VARIABLE.c_str(), -1, SQLITE_STATIC)

#define RESET_GET_COUNTER(STATEMENT)	STATEMENT##_id_get = 0;

#define GET_INT(STATEMENT)	sqlite3_column_int(STATEMENT, STATEMENT##_id_get++)

#define GET_STR(STATEMENT)	(const char *) sqlite3_column_text(STATEMENT, STATEMENT##_id_get++)

#define EXECUTE_STATEMENT(STATEMENT, NAME) 	if(sqlite3_step(STATEMENT) != SQLITE_DONE) {\

		onStorageError(NAME, (sqlite3_errmsg(m_db) == NULL ? "" : sqlite3_errmsg(m_db)));\

			}

using namespace boost;

namespace Transport {

SQLite3Backend::SQLite3Backend(Config *config) {

	m_config = config;

	m_db = NULL;

	m_prefix = CONFIG_STRING(m_config, "database.prefix");

}

SQLite3Backend::~SQLite3Backend(){

	if (m_db) {

		// Would be nice to use this:

		//

		//   sqlite3_stmt *pStmt;

		//   while((pStmt = sqlite3_next_stmt(db, 0)) != 0 ) {

		//    sqlite3_finalize(pStmt);

		//   }

		//

		// But requires SQLite3 >= 3.6.0 beta

		FINALIZE_STMT(m_setUser);

		FINALIZE_STMT(m_getUser);

		FINALIZE_STMT(m_removeUser);

		FINALIZE_STMT(m_removeUserBuddies);

		FINALIZE_STMT(m_removeUserSettings);

		FINALIZE_STMT(m_removeUserBuddiesSettings);

		FINALIZE_STMT(m_addBuddy);

		FINALIZE_STMT(m_updateBuddy);

		FINALIZE_STMT(m_getBuddies);

		FINALIZE_STMT(m_getBuddiesSettings);

		FINALIZE_STMT(m_getUserSetting);

		FINALIZE_STMT(m_setUserSetting);

		FINALIZE_STMT(m_updateUserSetting);

		FINALIZE_STMT(m_updateBuddySetting);

		sqlite3_close(m_db);

	}

}

bool SQLite3Backend::connect() {

	if (sqlite3_open(CONFIG_STRING(m_config, "database.database").c_str(), &m_db)) {

		sqlite3_close(m_db);

		return false;

	}

	if (createDatabase() == false)

		return false;

	PREP_STMT(m_setUser, "INSERT INTO " + m_prefix + "users (jid, uin, password, language, encoding, last_login, vip) VALUES (?, ?, ?, ?, ?, DATETIME('NOW'), ?)");

	PREP_STMT(m_getUser, "SELECT id, jid, uin, password, encoding, language, vip FROM " + m_prefix + "users WHERE jid=?");

	PREP_STMT(m_removeUser, "DELETE FROM " + m_prefix + "users WHERE id=?");

	PREP_STMT(m_removeUserBuddies, "DELETE FROM " + m_prefix + "buddies WHERE user_id=?");

	PREP_STMT(m_removeUserSettings, "DELETE FROM " + m_prefix + "users_settings WHERE user_id=?");

	PREP_STMT(m_removeUserBuddiesSettings, "DELETE FROM " + m_prefix + "buddies_settings WHERE user_id=?");

/**

 * 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/user.h"

#include "Swiften/Elements/ErrorPayload.h"

#include <boost/shared_ptr.hpp>

using namespace Swift;

namespace Transport {

	m_component = component;

	m_config = m_component->m_config;

	m_storageBackend = storageBackend;

	m_userManager = userManager;

}

UserRegistration::~UserRegistration(){

}

bool UserRegistration::registerUser(const UserInfo &row) {

	// TODO: move this check to sql()->addUser(...) and let it return bool

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

	Swift::Presence::ref response;

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

	// roster contains already escaped jids

	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 = (*u).legacyName;

		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->m_component->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->m_component->sendPresence(response);

	}

	// Remove user from database

	m_storageBackend->removeUser(userInfo.id);

	// Disconnect the user

	if (user) {

		m_userManager->removeUser(user);

	}

	response = Swift::Presence::create();

	response->setTo(Swift::JID(barejid));

	response->setFrom(m_component->getJID());

	response->setType(Swift::Presence::Unsubscribe);

	m_component->m_component->sendPresence(response);

	response = Swift::Presence::create();

	response->setTo(Swift::JID(barejid));

	response->setFrom(m_component->getJID());

	response->setType(Swift::Presence::Unsubscribed);

	m_component->m_component->sendPresence(response);

	return true;

}

bool UserRegistration::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::InBandRegistrationPayload> payload) {

	if (CONFIG_STRING(m_config, "service.protocol") == "irc") {

		return true;

	}

	std::string barejid = from.toBare().toString();

// 	User *user = m_userManager->getUserByJID(barejid);

	if (!CONFIG_BOOL(m_config,"registration.enable_public_registration")) {

		std::list<std::string> const &x = CONFIG_LIST(m_config,"service.allowed_servers");

		if (std::find(x.begin(), x.end(), from.getDomain()) == x.end()) {

// 			Log("UserRegistration", "This user has no permissions to register an account");

			return true;

		}

	}

// 	const char *_language = user ? user->getLang() : CONFIG_STRING(m_config, "registration.language").c_str();

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

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

	std::string usernameField = CONFIG_STRING(m_config, "registration.username_field");

	Form::ref form(new Form(Form::FormType));

	form->setTitle(tr(_language, _("Registration")));

	form->setInstructions(tr(_language, 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(tr(_language, 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(tr(_language, _("Password")));

		password->setRequired(true);

		form->addField(password);

	}

	ListSingleFormField::ref language = ListSingleFormField::create();

	language->setName("language");

	language->setLabel(tr(_language, _("Language")));

	if (registered)

		language->setValue(res.language);

	else

		language->setValue(CONFIG_STRING(m_config, "registration.language"));

// 	std::map <std::string, std::string> languages = localization.getLanguages();

// 	for (std::map <std::string, std::string>::iterator it = languages.begin(); it != languages.end(); it++) {

// 		language->addOption(FormField::Option((*it).second, (*it).first));

// 	}

	form->addField(language);

	TextSingleFormField::ref encoding = TextSingleFormField::create();

	encoding->setName("encoding");

	encoding->setLabel(tr(_language, _("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(tr(_language, _("Remove your registration")));

		boolean->setValue(0);

		form->addField(boolean);

	}

	reg->setForm(form);

	return true;

}

bool UserRegistration::handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::InBandRegistrationPayload> payload) {

	if (CONFIG_STRING(m_config, "service.protocol") == "irc") {

		return true;

	}

	std::string barejid = from.toBare().toString();

// 	AbstractUser *user = m_component->userManager()->getUserByJID(barejid);

	if (!CONFIG_BOOL(m_config,"registration.enable_public_registration")) {

		std::list<std::string> const &x = CONFIG_LIST(m_config,"service.allowed_servers");

		if (std::find(x.begin(), x.end(), from.getDomain()) == x.end()) {

// 			Log("UserRegistration", "This user has no permissions to register an account");

			return true;

		}

	}

	UserInfo res;

	bool registered = m_storageBackend->getUser(barejid, res);

	std::string encoding;

	std::string language;

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

				}

				continue;

			}

			TextPrivateFormField::ref textPrivate = boost::dynamic_pointer_cast<TextPrivateFormField>(*it);

			if (textPrivate) {

				if (textPrivate->getName() == "password") {

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

		return true;

	}

	if (!payload->getUsername() || !payload->getPassword()) {

		return true;

	}

	// Register or change password

	if (payload->getUsername()->empty() ||

		(payload->getPassword()->empty() && CONFIG_STRING(m_config, "service.protocol") != "twitter" && CONFIG_STRING(m_config, "service.protocol") != "bonjour")

// 		|| localization.getLanguages().find(language) == localization.getLanguages().end()

	)

	{

		return true;

	}

	if (CONFIG_STRING(m_config, "service.protocol") == "xmpp") {

		// User tries to register himself.

		if ((Swift::JID(*payload->getUsername()).toBare() == from.toBare())) {

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

			return true;

		}

	}

	std::string username = *payload->getUsername();

// 	m_component->protocol()->prepareUsername(username);

	std::string newUsername(username);

	if (!CONFIG_STRING(m_config, "registration.username_mask").empty()) {

		newUsername = CONFIG_STRING(m_config, "registration.username_mask");

// 		replace(newUsername, "$username", username.c_str());

	}

// 	if (!m_component->protocol()->isValidUsername(newUsername)) {

// 		Log("UserRegistration", "This is not valid username: "<< newUsername);

// 		return true;

// 	}

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

// 		return true;

// 	}

// #endif

	if (!registered) {

		res.jid = barejid;

		res.uin = username;

		res.password = *payload->getPassword();

		res.language = language;

		res.encoding = encoding;

		res.vip = 0;

		registerUser(res);

	}

	else {

		// change passwordhttp://soumar.jabbim.cz/phpmyadmin/index.php

// 		Log("UserRegistration", "changing user password: "<< barejid << ", " << username);

		res.jid = barejid;

		res.password = *payload->getPassword();

		res.language = language;

		res.encoding = encoding;

		m_storageBackend->setUser(res);

		onUserUpdated(res);

	}

	return true;

}

}