/*

 * Copyright (c) 2010 Remko Tronçon

 * Licensed under the GNU General Public License v3.

 * See Documentation/Licenses/GPLv3.txt for more information.

 */

#include "Swiften/Base/Platform.h"

#ifdef SWIFTEN_PLATFORM_WINDOWS

#include <windows.h>

#include <wincrypt.h>

#endif

#include <vector>

#include <openssl/err.h>

#include <openssl/pkcs12.h>

#include "Swiften/TLS/OpenSSL/OpenSSLServerContext.h"

#include "Swiften/TLS/OpenSSL/OpenSSLCertificate.h"

#include "Swiften/TLS/PKCS12Certificate.h"

#pragma GCC diagnostic ignored "-Wold-style-cast"

namespace Swift {

static const int MAX_FINISHED_SIZE = 4096;

static const int SSL_READ_BUFFERSIZE = 8192;

static void freeX509Stack(STACK_OF(X509)* stack) {

	sk_X509_free(stack);

}

// static int _sx_ssl_verify_callback(int preverify_ok, X509_STORE_CTX *ctx) {

// 	return 1;

// }

OpenSSLServerContext::OpenSSLServerContext() : state_(Start), context_(0), handle_(0), readBIO_(0), writeBIO_(0) {

	ensureLibraryInitialized();

	context_ = SSL_CTX_new(SSLv23_server_method());

// 	SSL_CTX_set_verify(context_, SSL_VERIFY_PEER, _sx_ssl_verify_callback);

	// Load system certs

#if defined(SWIFTEN_PLATFORM_WINDOWS)

	X509_STORE* store = SSL_CTX_get_cert_store(context_);

	HCERTSTORE systemStore = CertOpenSystemStore(0, "ROOT");

	if (systemStore) {

		PCCERT_CONTEXT certContext = NULL;

		while (true) {

			certContext = CertFindCertificateInStore(systemStore, X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, 0, CERT_FIND_ANY, NULL, certContext);

			if (!certContext) {

				break;

			}

			OpenSSLCertificate cert(certData);

			if (store && cert.getInternalX509()) {

				X509_STORE_add_cert(store, cert.getInternalX509().get());

			}

		}

	}

#elif !defined(SWIFTEN_PLATFORM_MACOSX)

	SSL_CTX_load_verify_locations(context_, NULL, "/etc/ssl/certs");

#endif

}

OpenSSLServerContext::~OpenSSLServerContext() {

	SSL_free(handle_);

	SSL_CTX_free(context_);

}

void OpenSSLServerContext::ensureLibraryInitialized() {

	static bool isLibraryInitialized = false;

	if (!isLibraryInitialized) {

		SSL_load_error_strings();

		SSL_library_init();

		OpenSSL_add_all_algorithms();

		// Disable compression

		/// Returns full JID of this buddy.

		/// \param hostname hostname used as domain in returned JID

		/// \return full JID of this buddy

		const Swift::JID &getJID();

		/// Generates whole Presennce stanza with current status/show for this buddy.

		/// Presence stanza does not containt "to" attribute, it has to be added manually.

		/// \param features features used in returned stanza

		/// \param only_new if True, this function returns Presence stanza only if it's different

		/// than the previously generated one.

		/// \return Presence stanza or NULL.

		Swift::Presence::ref generatePresenceStanza(int features, bool only_new = false);

		void setBlocked(bool block) {

			if (block)

				m_flags = (BuddyFlag) (m_flags | BUDDY_BLOCKED);

			else

				m_flags = (BuddyFlag) (m_flags & ~BUDDY_BLOCKED);

		}

		bool isBlocked() {

		}

		/// Sets current subscription.

		/// \param subscription "to", "from", "both", "ask"

		void setSubscription(const std::string &subscription);

		/// Returns current subscription

		/// \return subscription "to", "from", "both", "ask"

		const std::string getSubscription();

		/// Sets this buddy's flags.

		/// \param flags flags

		void setFlags(BuddyFlag flags);

		/// Returns this buddy's flags.

		/// \param flags flags

		BuddyFlag getFlags();

		/// Returns RosterManager associated with this buddy.

 * 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 <string>

#include <map>

#include "Swiften/Swiften.h"

#include "transport/storagebackend.h"

#include "transport/config.h"

namespace Transport {

/// Used to store transport data into SQLite3 database.

class SQLite3Backend : public StorageBackend

{

	public:

		/// Creates new SQLite3Backend instance.

		/// \param config cofiguration, this class uses following Config values:

		/// 	- database.database - path to SQLite3 database file, database file is created automatically

		/// 	- service.prefix - prefix for tables created by createDatabase method

		SQLite3Backend(Config *config);

		/// Destructor.

		~SQLite3Backend();

		/// Connects to the database and creates it if it's needed. This method call createDatabase() function

		/// automatically.

		/// \return true if database is opened successfully.

		bool connect();

		/// Creates database structure.

		/// \see connect()

		/// \return true if database structure has been created successfully. Note that it returns True also if database structure

#include "transport/config.h"

#include "transport/transport.h"

#include "transport/usermanager.h"

#include "transport/logger.h"

#include "transport/sqlite3backend.h"

#include "transport/userregistration.h"

#include "transport/networkpluginserver.h"

#include "transport/admininterface.h"

#include "Swiften/EventLoop/SimpleEventLoop.h"

#include "sys/signal.h"

#include "log4cxx/logger.h"

#include "log4cxx/patternlayout.h"

#include "log4cxx/propertyconfigurator.h"

#include "log4cxx/consoleappender.h"

using namespace log4cxx;

using namespace Transport;

Swift::SimpleEventLoop *eventLoop_ = NULL;

static void spectrum_sigint_handler(int sig) {

	eventLoop_->stop();

}

static void spectrum_sigterm_handler(int sig) {

	eventLoop_->stop();

}

int main(int argc, char **argv)

{

	Config config;

	if (signal(SIGINT, spectrum_sigint_handler) == SIG_ERR) {

		std::cout << "SIGINT handler can't be set\n";

		return -1;

	}

	if (signal(SIGTERM, spectrum_sigterm_handler) == SIG_ERR) {

		std::cout << "SIGTERM handler can't be set\n";

		return -1;

	}

	boost::program_options::options_description desc("Usage: spectrum [OPTIONS] <config_file.cfg>\nAllowed options");

	desc.add_options()

		("help,h", "help")

		("no-daemonize,n", "Do not run spectrum as daemon")

		;

	try

	{

		boost::program_options::variables_map vm;

		boost::program_options::store(boost::program_options::parse_command_line(argc, argv, desc), vm);

		boost::program_options::notify(vm);

		if(vm.count("help"))

		{

			std::cout << desc << "\n";

			return 1;

		}

	}

	catch (std::runtime_error& e)

	{

		std::cout << desc << "\n";

		return 1;

	}

	catch (...)

	{

		std::cout << desc << "\n";

		return 1;

	}

	if (argc != 2) {

		std::cout << desc << "\n";

		return 1;

	}

	if (!config.load(argv[1])) {

		std::cerr << "Can't load configuration file.\n";

		return 1;

	}

	if (CONFIG_STRING(&config, "logging.config").empty()) {

		LoggerPtr root = log4cxx::Logger::getRootLogger();

		root->addAppender(new ConsoleAppender(new PatternLayout("%d %-5p %c: %m%n")));

	}

	else {

		log4cxx::PropertyConfigurator::configure(CONFIG_STRING(&config, "logging.config"));

	}

	Swift::SimpleEventLoop eventLoop;

	Swift::BoostNetworkFactories *factories = new Swift::BoostNetworkFactories(&eventLoop);

	UserRegistry userRegistry(&config, factories);

	Component transport(&eventLoop, factories, &config, NULL, &userRegistry);

// 	Logger logger(&transport);

	StorageBackend *storageBackend = NULL;

	if (CONFIG_STRING(&config, "database.type") == "sqlite3") {

		storageBackend = new SQLite3Backend(&config);

		if (!storageBackend->connect()) {

			std::cerr << "Can't connect to database.\n";

			return -1;

		}

	}

	else if (CONFIG_STRING(&config, "database.type") == "mysql") {

		storageBackend = new MySQLBackend(&config);

		if (!storageBackend->connect()) {

			std::cerr << "Can't connect to database.\n";

			return -1;

		}

	}

	UserManager userManager(&transport, &userRegistry, storageBackend);

	UserRegistration *userRegistration = NULL;

	if (storageBackend) {

		userRegistration = new UserRegistration(&transport, &userManager, storageBackend);

		userRegistration->start();

// 		logger.setUserRegistration(&userRegistration);

	}

// 	logger.setUserManager(&userManager);

	NetworkPluginServer plugin(&transport, &config, &userManager);

	AdminInterface adminInterface(&transport, &userManager, &plugin, storageBackend);

	eventLoop_ = &eventLoop;

	eventLoop.run();

	if (userRegistration) {

		userRegistration->stop();

		delete userRegistration;

	}

	delete storageBackend;

	delete factories;

}

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

#include "transport/usermanager.h"

#include "transport/user.h"

#include "transport/transport.h"

#include "transport/storagebackend.h"

#include "transport/userregistration.h"

#include "transport/buddy.h"

#include "transport/rostermanager.h"

#include <boost/bind.hpp>

using namespace boost;

namespace Transport {

Logger::Logger(Component *component) {

}

Logger::~Logger(){

}

void Logger::setStorageBackend(StorageBackend *storage) {

}

void Logger::setUserRegistration(UserRegistration *userRegistration) {

}

void Logger::setUserManager(UserManager *userManager) {

}

void Logger::setRosterManager(RosterManager *rosterManager) {

}

void Logger::handleConnected() {

	std::cout << "[COMPONENT] Connected to Jabber Server!\n";

}

void Logger::handleConnectionError(const Swift::ComponentError &error) {

	std::cout << "[COMPONENT] Connection Error!\n";

	switch (error.getType()) {

		case Swift::ComponentError::UnknownError: std::cout << "[COMPONENT] Disconnect reason: UnknownError\n"; break;

		case Swift::ComponentError::ConnectionError: std::cout << "[COMPONENT] Disconnect reason: ConnectionError\n"; break;

		case Swift::ComponentError::ConnectionReadError: std::cout << "[COMPONENT] Disconnect reason: ConnectionReadError\n"; break;

		case Swift::ComponentError::ConnectionWriteError: std::cout << "[COMPONENT] Disconnect reason: ConnectionWriteError\n"; break;

		case Swift::ComponentError::XMLError: std::cout << "[COMPONENT] Disconnect reason: XMLError\n"; break;

		case Swift::ComponentError::AuthenticationFailedError: std::cout << "[COMPONENT] Disconnect reason: AuthenticationFailedError\n"; break;

		case Swift::ComponentError::UnexpectedElementError: std::cout << "[COMPONENT] Disconnect reason: UnexpectedElementError\n"; break; 

	};

}

void Logger::handleXMLIn(const std::string &data) {

	std::cout << "[XML IN] " << data << "\n";

}

void Logger::handleXMLOut(const std::string &data) {

 * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>

 *

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

#include <iostream>

#include <cstring>

#include <sstream>

#include <fstream>

#include <algorithm>

#include <sys/param.h>

#ifdef BSD

#include <sys/types.h>

#include <sys/sysctl.h>

#include <sys/param.h>

#include <sys/sysctl.h>

#include <sys/user.h>

#endif

namespace Transport {

#ifndef WIN32

#ifdef BSD

void process_mem_usage(double& vm_usage, double& resident_set) {

	int mib[4];

	size_t size;

	mib[0] = CTL_KERN;

	mib[1] = KERN_PROC;

	mib[2] = KERN_PROC_PID;

	mib[3] = getpid();

	struct kinfo_proc proc;

	size = sizeof(struct kinfo_proc);

namespace Transport {

#define WRAP(MESSAGE, TYPE) 	pbnetwork::WrapperMessage wrap; \

	wrap.set_type(TYPE); \

	wrap.set_payload(MESSAGE); \

	wrap.SerializeToString(&MESSAGE);

NetworkPlugin::NetworkPlugin(Swift::EventLoop *loop, const std::string &host, int port) {

	m_factories = new Swift::BoostNetworkFactories(loop);

	m_host = host;

	m_port = port;

	m_pingReceived = false;

	m_loop = loop;

	m_conn = m_factories->getConnectionFactory()->createConnection();

	m_conn->onDataRead.connect(boost::bind(&NetworkPlugin::handleDataRead, this, _1));

	m_conn->onConnectFinished.connect(boost::bind(&NetworkPlugin::_handleConnected, this, _1));

	m_conn->onDisconnected.connect(boost::bind(&NetworkPlugin::handleDisconnected, this));

	m_pingTimer = m_factories->getTimerFactory()->createTimer(30000);

	m_pingTimer->onTick.connect(boost::bind(&NetworkPlugin::pingTimeout, this)); 

	connect();

	double shared;

	process_mem_usage(shared, m_init_res);

}

NetworkPlugin::~NetworkPlugin() {

	delete m_factories;

}

void NetworkPlugin::handleMessage(const std::string &user, const std::string &legacyName, const std::string &msg, const std::string &nickname, const std::string &xhtml) {

	pbnetwork::ConversationMessage m;

	m.set_username(user);

	m.set_buddyname(legacyName);

	m.set_message(msg);

	m.set_nickname(nickname);

	m.set_xhtml(xhtml);

	std::string message;

	m.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE);

	send(message);

}

void NetworkPlugin::handleAttention(const std::string &user, const std::string &buddyName, const std::string &msg) {

	pbnetwork::ConversationMessage m;

void NetworkPlugin::send(const std::string &data) {

	char header[4];

	*((int*)(header)) = htonl(data.size());

	m_conn->write(Swift::createSafeByteArray(std::string(header, 4) + data));

}

void NetworkPlugin::sendPong() {

	m_pingReceived = true;

	std::string message;

	pbnetwork::WrapperMessage wrap;

	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_PONG);

	wrap.SerializeToString(&message);

	send(message);

	LOG4CXX_INFO(logger, "PONG");

	sendMemoryUsage();

}

void NetworkPlugin::sendMemoryUsage() {

	pbnetwork::Stats stats;

	stats.set_init_res(m_init_res);

	double res;

	double shared;

	process_mem_usage(shared, res);

	stats.set_res(res);

	stats.set_shared(shared);

	std::string message;

	stats.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_STATS);

	send(message);

}

void NetworkPlugin::pingTimeout() {

	if (m_pingReceived == false) {

// 		LOG4CXX_ERROR(logger, "No PING received for long time. Exiting");

		handleExit();

	}

	m_pingReceived = false;

	m_pingTimer->start();

}

}

// Wraps google protobuf payload into WrapperMessage and serialize it to string

#define WRAP(MESSAGE, TYPE) 	pbnetwork::WrapperMessage wrap; \

	wrap.set_type(TYPE); \

	wrap.set_payload(MESSAGE); \

	wrap.SerializeToString(&MESSAGE);

// Executes new backend

static unsigned long exec_(std::string path, const char *host, const char *port, const char *config) {

	std::string original_path = path;

	// BACKEND_ID is replaced with unique ID. The ID is increasing for every backend.

	boost::replace_all(path, "BACKEND_ID", boost::lexical_cast<std::string>(backend_id++));

	// Add host and port.

	path += std::string(" --host ") + host + " --port " + port + " " + config;

	LOG4CXX_INFO(logger, "Starting new backend " << path);

#ifdef _WIN32

	STARTUPINFO         si;

	PROCESS_INFORMATION pi;

	ZeroMemory (&si, sizeof(si));

	si.cb=sizeof (si);

	if (! CreateProcess(

	0,                    // process attributes

	0,                    // thread attributes

	0,                    // inherit handles

	0,                    // creation flags

	0,                    // environment

	0,                    // cwd

	&si,

	&pi

	)

	)  {

		LOG4CXX_ERROR(logger, "Could not start process");

	}

	return 0;

#else

	// Create array of char * from string using -lpopt library

	char *p = (char *) malloc(path.size() + 1);

	strcpy(p, path.c_str());

	int argc;

	char **argv;

	poptParseArgvString(p, &argc, (const char ***) &argv);

	// fork and exec

	pid_t pid = fork();

	buddy.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

}

void NetworkPluginServer::handleBuddyAdded(Buddy *buddy, const Swift::RosterItemPayload &item) {

	handleBuddyUpdated(buddy, item);

}

void NetworkPluginServer::handleBlockToggled(Buddy *b) {

	User *user = b->getRosterManager()->getUser();

	pbnetwork::Buddy buddy;

	buddy.set_username(user->getJID().toBare());

	buddy.set_buddyname(b->getName());

	buddy.set_alias(b->getAlias());

	buddy.set_groups(b->getGroups().size() == 0 ? "" : b->getGroups()[0]);

	buddy.set_status(Swift::StatusShow::None);

	std::string message;

	buddy.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	send(c->connection, message);

}

void NetworkPluginServer::handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> v) {

	pbnetwork::VCard vcard;

	vcard.set_username(user->getJID().toBare());

	vcard.set_buddyname("");

	vcard.set_id(0);

	vcard.set_photo(&v->getPhoto()[0], v->getPhoto().size());

	std::string message;

	vcard.SerializeToString(&message);

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

#include "transport/rosterstorage.h"

#include "transport/storagebackend.h"

#include "transport/buddy.h"

#include "transport/usermanager.h"

#include "transport/buddy.h"

#include "transport/user.h"

#include "Swiften/Roster/SetRosterRequest.h"

#include "Swiften/Elements/RosterPayload.h"

#include "Swiften/Elements/RosterItemPayload.h"

#include "Swiften/Elements/RosterItemExchangePayload.h"

#include "log4cxx/logger.h"

#include <boost/foreach.hpp>

using namespace log4cxx;

namespace Transport {

static LoggerPtr logger = Logger::getLogger("RosterManager");

RosterManager::RosterManager(User *user, Component *component){

	m_rosterStorage = NULL;

	m_user = user;

	m_component = component;

	m_setBuddyTimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(1000);

	m_RIETimer = m_component->getNetworkFactories()->getTimerFactory()->createTimer(5000);

	m_RIETimer->onTick.connect(boost::bind(&RosterManager::sendRIE, this));

}

RosterManager::~RosterManager() {

	m_setBuddyTimer->stop();

	m_RIETimer->stop();

	if (m_rosterStorage) {

		m_rosterStorage->storeBuddies();

	}

	sendUnavailablePresences(m_user->getJID().toBare());

		Buddy *buddy = (*it).second;

		if (!buddy) {

			continue;

		}

		delete buddy;

	}

	if (m_requests.size() != 0) {

		LOG4CXX_INFO(logger, m_user->getJID().toString() <<  ": Removing " << m_requests.size() << " unresponded IQs");

		BOOST_FOREACH(Swift::SetRosterRequest::ref request, m_requests) {

			request->onResponse.disconnect_all_slots();

			m_component->getIQRouter()->removeHandler(request);

		}

		m_requests.clear();

	}

	boost::singleton_pool<boost::pool_allocator_tag, sizeof(unsigned int)>::release_memory();

	if (m_rosterStorage)

		delete m_rosterStorage;

}

void RosterManager::setBuddy(Buddy *buddy) {

// 	m_setBuddyTimer->onTick.connect(boost::bind(&RosterManager::setBuddyCallback, this, buddy));

	}

}

void RosterManager::handleBuddyRosterPushResponse(Swift::ErrorPayload::ref error, Swift::SetRosterRequest::ref request, const std::string &key) {

	if (m_buddies[key] != NULL) {

		m_buddies[key]->handleBuddyChanged();

	}