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

#include "transport/memoryusage.h"

#include "transport/logging.h"

#include <sstream>

#ifndef WIN32

#include <arpa/inet.h>

#else 

#include <winsock2.h>

#include <stdint.h>

#include <process.h>

#define getpid _getpid

#endif

DEFINE_LOGGER(logger, "NetworkPlugin");

namespace Transport {

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

	wrap.set_type(TYPE); \

	wrap.set_payload(MESSAGE); \

	wrap.SerializeToString(&MESSAGE);

template <class T> std::string stringOf(T object) {

	std::ostringstream os;

	os << object;

	return (os.str());

}

NetworkPlugin::NetworkPlugin() {

	m_pingReceived = false;

	double shared;

#ifndef WIN32

	process_mem_usage(shared, m_init_res);

#endif

}

NetworkPlugin::~NetworkPlugin() {

}

void NetworkPlugin::sendConfig(const PluginConfig &cfg) {

	std::string data = "[registration]";

}

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;

	m.set_username(user);

	m.set_buddyname(buddyName);

	m.set_message(msg);

	std::string message;

	m.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_ATTENTION);

	send(message);

}

void NetworkPlugin::handleVCard(const std::string &user, unsigned int id, const std::string &legacyName, const std::string &fullName, const std::string &nickname, const std::string &photo) {

	pbnetwork::VCard vcard;

	vcard.set_username(user);

	vcard.set_buddyname(legacyName);

	vcard.set_id(id);

	vcard.set_fullname(fullName);

	vcard.set_nickname(nickname);

	vcard.set_photo(photo);

	std::string message;

	vcard.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_VCARD);

	send(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

 */

#include <string>

#include <map>

#include "Swiften/Swiften.h"

#include "Swiften/Server/UserRegistry.h"

#include "transport/userregistry.h"

#include "transport/logging.h"

namespace Transport {

DEFINE_LOGGER(logger, "UserRegistry");

UserRegistry::UserRegistry(Config *cfg, Swift::NetworkFactories *factories) {

	config = cfg;

	m_removeTimer = factories->getTimerFactory()->createTimer(1);

	m_inRemoveLater = false;

}

UserRegistry::~UserRegistry() { m_removeTimer->stop(); }

void UserRegistry::isValidUserPassword(const Swift::JID& user, Swift::ServerFromClientSession *session, const Swift::SafeByteArray& password) {

	std::vector<std::string> const &x = CONFIG_VECTOR(config,"service.admin_jid");

	if (std::find(x.begin(), x.end(), user.toBare().toString()) != x.end()) {

		if (Swift::safeByteArrayToString(password) == CONFIG_STRING(config, "service.admin_password")) {

		}

		else {

		}

		return;

	}

	std::string key = user.toBare().toString();

	// Users try to connect twice

	if (users.find(key) != users.end()) {

		// Kill the first session

		LOG4CXX_INFO(logger, key << ": Removing previous session and making this one active");

		Swift::ServerFromClientSession *tmp = users[key].session;

		users[key].session = session;

		tmp->handlePasswordInvalid();

	}

	LOG4CXX_INFO(logger, key << ": Connecting this user to find if password is valid");

	users[key].password = Swift::safeByteArrayToString(password);

	users[key].session = session;

	onConnectUser(user);

	return;

}

void UserRegistry::stopLogin(const Swift::JID& user, Swift::ServerFromClientSession *session) {

	std::string key = user.toBare().toString();

	if (users.find(key) != users.end()) {

		if (users[key].session == session) {

			LOG4CXX_INFO(logger, key << ": Stopping login process (user probably disconnected while logging in)");

			users.erase(key);

		}

		else {

			LOG4CXX_WARN(logger, key << ": Stopping login process (user probably disconnected while logging in), but this is not active session");

		}

	}

	else {

		LOG4CXX_WARN(logger, key << ": Stopping login process (user probably disconnected while logging in) for invalid user");

	}

	// ::removeLater can be called only by libtransport, not by Swift and libtransport

	// takes care about user disconnecting itself, so don't call our signal.

	if (!m_inRemoveLater)

		onDisconnectUser(user);

}

void UserRegistry::onPasswordValid(const Swift::JID &user) {

	std::string key = user.toBare().toString();

	if (users.find(key) != users.end()) {

		LOG4CXX_INFO(logger, key << ": Password is valid");