/**

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

#ifndef WIN32

#include <arpa/inet.h>

#include <sys/types.h>

#include <unistd.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]\n";

	data += std::string("needPassword=") + (cfg.m_needPassword ? "1" : "0") + "\n";

	data += std::string("needRegistration=") + (cfg.m_needRegistration ? "1" : "0") + "\n";

	for (std::vector<std::string>::const_iterator it = cfg.m_extraFields.begin(); it != cfg.m_extraFields.end(); it++) {

		data += std::string("extraField=") + (*it) + "\n";

	}

	data += "[features]\n";

	data += std::string("muc=") + (cfg.m_supportMUC ? "1" : "0") + "\n";

	data += std::string("rawxml=") + (cfg.m_rawXML ? "1" : "0") + "\n";

	data += std::string("disable_jid_escaping=") + (cfg.m_disableJIDEscaping ? "1" : "0") + "\n";

	pbnetwork::BackendConfig m;

	m.set_config(data);

	std::string message;

	m.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BACKEND_CONFIG);

	send(message);

}

void NetworkPlugin::sendRawXML(std::string &xml) {

	WRAP(xml, pbnetwork::WrapperMessage_Type_TYPE_RAW_XML);

	send(xml);

}

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

	pbnetwork::ConversationMessage m;

	m.set_username(user);

	m.set_buddyname(legacyName);

	m.set_message(msg);

	m.set_nickname(nickname);

	m.set_xhtml(xhtml);

	m.set_timestamp(timestamp);

	m.set_headline(headline);

	m.set_pm(pm);

	std::string message;

	m.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE);

	send(message);

}

void NetworkPlugin::handleMessageAck(const std::string &user, const std::string &legacyName, const std::string &id) {

	pbnetwork::ConversationMessage m;

	m.set_username(user);

	m.set_buddyname(legacyName);

#include "transport/Config.h"

#include "transport/Transport.h"

#include "transport/FileTransferManager.h"

#include "transport/UserManager.h"

#include "transport/SQLite3Backend.h"

#include "transport/MySQLBackend.h"

#include "transport/PQXXBackend.h"

#include "transport/UserRegistration.h"

#include "transport/UserRegistry.h"

#include "transport/NetworkPluginServer.h"

#include "transport/AdminInterface.h"

#include "transport/UsersReconnecter.h"

#include "transport/Util.h"

#include "transport/Logging.h"

#include "frontends/xmpp/XMPPFrontend.h"

#include "Swiften/EventLoop/SimpleEventLoop.h"

#include "Swiften/Network/BoostNetworkFactories.h"

#include <boost/filesystem.hpp>

#include <boost/algorithm/string.hpp>

#ifndef WIN32

#include "sys/signal.h"

#include "sys/stat.h"

#include <pwd.h>

#include <grp.h>

#include <sys/resource.h>

#include "libgen.h"

#ifndef __FreeBSD__

#ifndef __MACH__

#include <malloc.h>

#endif

#endif

#else

#include <process.h>

#define getpid _getpid

#include "win32/ServiceWrapper.h"

#endif

#include <sys/stat.h>

using namespace Transport;

using namespace Transport::Util;

DEFINE_LOGGER(logger, "Spectrum");

Swift::SimpleEventLoop *eventLoop_ = NULL;

Component *component_ = NULL;

UserManager *userManager = NULL;

Config *config_ = NULL;

static void stop_spectrum() {

	userManager->removeAllUsers(false);

	component_->stop();

	eventLoop_->stop();

}

static void spectrum_sigint_handler(int sig) {

	eventLoop_->postEvent(&stop_spectrum);

}

static void spectrum_sigterm_handler(int sig) {

	eventLoop_->postEvent(&stop_spectrum);

}

#ifdef WIN32

BOOL spectrum_control_handler( DWORD fdwCtrlType ) { 

	if (fdwCtrlType == CTRL_C_EVENT || fdwCtrlType == CTRL_CLOSE_EVENT) {

		eventLoop_->postEvent(&stop_spectrum);

		return TRUE;

	}

	return FALSE;

} 

#endif

static void removeOldIcons(std::string iconDir) {

	std::vector<std::string> dirs;

	dirs.push_back(iconDir);

	boost::thread thread(boost::bind(Util::removeEverythingOlderThan, dirs, time(NULL) - 3600*24*14));

}

#ifndef WIN32

static void daemonize(const char *cwd, const char *lock_file) {

	pid_t pid, sid;

	FILE* lock_file_f;

	char process_pid[20];

	/* already a daemon */

	if ( getppid() == 1 ) return;

	/* Fork off the parent process */

	pid = fork();

	if (pid < 0) {

		exit(1);

	}

	/* If we got a good PID, then we can exit the parent process. */

	if (pid > 0) {

		if (lock_file) {

			/* write our pid into it & close the file. */

			lock_file_f = fopen(lock_file, "w+");

			if (lock_file_f == NULL) {

				std::cerr << "Cannot create lock file " << lock_file << ". Exiting\n";

				exit(1);

			}

			sprintf(process_pid,"%d\n",pid);

			if (fwrite(process_pid,1,strlen(process_pid),lock_file_f) < strlen(process_pid)) {