static void conv_chat_topic_changed(PurpleConversation *conv, const char *who, const char *topic) {

	LOG4CXX_INFO(logger, "Conversation topic changed");

	PurpleAccount *account = purple_conversation_get_account_wrapped(conv);

	np->handleSubject(np->m_accounts[account], np->NameToLegacyName(account, purple_conversation_get_name_wrapped(conv)), topic ? topic : "", who ? who : "Spectrum 2");

}

static void conv_present(PurpleConversation *conv) {

	if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_CHAT) {

		LOG4CXX_INFO(logger, "Conversation presented");

		conv_chat_add_users(conv, PURPLE_CONV_CHAT_WRAPPED(conv)->in_room, TRUE);

		const char *topic = purple_conv_chat_get_topic(PURPLE_CONV_CHAT_WRAPPED(conv));

		if (topic && *topic != '\0') {

			conv_chat_topic_changed(conv, topic, PURPLE_CONV_CHAT_WRAPPED(conv)->who);

		}

		else {

			LOG4CXX_INFO(logger, "Conversation created with an empty topic");

		}

	}

}

static PurpleConversationUiOps conversation_ui_ops =

{

	NULL,

	NULL,

	conv_write_im,//conv_write_chat,                              /* write_chat           */

	conv_write_im,             /* write_im             */

	conv_write,//conv_write_conv,           /* write_conv           */

	conv_chat_add_users,       /* chat_add_users       */

	NULL,//conv_chat_rename_user,     /* chat_rename_user     */

	conv_chat_remove_users,    /* chat_remove_users    */

	NULL,//pidgin_conv_chat_update_user,     /* chat_update_user     */

	conv_present,//pidgin_conv_present_conversation, /* present              */

	conv_has_focus,//pidgin_conv_has_focus,            /* has_focus            */

	NULL,//pidgin_conv_custom_smiley_add,    /* custom_smiley_add    */

	NULL,//pidgin_conv_custom_smiley_write,  /* custom_smiley_write  */

	NULL,//pidgin_conv_custom_smiley_close,  /* custom_smiley_close  */

	NULL,//pidgin_conv_send_confirm,         /* send_confirm         */

	NULL,

	NULL,

	NULL,

	NULL

};

struct Dis {

	std::string name;

	std::string protocol;

};

static gboolean disconnectMe(void *data) {

	Dis *d = (Dis *) data;

	PurpleAccount *account = purple_accounts_find_wrapped(d->name.c_str(), d->protocol.c_str());

	delete d;

	if (account) {

		np->handleLogoutRequest(np->m_accounts[account], purple_account_get_username_wrapped(account));

	}

	return FALSE;

}

static gboolean pingTimeout(void *data) {

	np->checkPing();

	return TRUE;

}

static void connection_report_disconnect(PurpleConnection *gc, PurpleConnectionError reason, const char *text){

	PurpleAccount *account = purple_connection_get_account_wrapped(gc);

	np->handleDisconnected(np->m_accounts[account], (int) reason, text ? text : "");

// 	Dis *d = new Dis;

// 	d->name = purple_account_get_username_wrapped(account);

// 	d->protocol = purple_account_get_protocol_id_wrapped(account);

// 	purple_timeout_add_seconds_wrapped(10, disconnectMe, d);

}

static PurpleConnectionUiOps conn_ui_ops =

{

	NULL,

	NULL,

	NULL,//connection_disconnected,

	NULL,

	NULL,

	NULL,

	NULL,

	connection_report_disconnect,

	NULL,

	NULL,

	NULL

};

static void *notify_user_info(PurpleConnection *gc, const char *who, PurpleNotifyUserInfo *user_info) {

	PurpleAccount *account = purple_connection_get_account_wrapped(gc);

	std::string name(purple_normalize_wrapped(account, who));

	size_t pos = name.find("/");

	if (pos != std::string::npos)

		name.erase((int) pos, name.length() - (int) pos);

	GList *vcardEntries = purple_notify_user_info_get_entries_wrapped(user_info);

	PurpleNotifyUserInfoEntry *vcardEntry;

	std::string firstName;

	std::string lastName;

	std::string fullName;

	std::string nickname;

	std::string header;

	std::string label;

	std::string photo;

/**

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

#include "transport/AdminInterfaceCommand.h"

#include "transport/User.h"

#include "transport/Transport.h"

#include "transport/StorageBackend.h"

#include "transport/UserManager.h"

#include "transport/NetworkPluginServer.h"

#include "transport/Logging.h"

#include "transport/UserRegistration.h"

#include "transport/Frontend.h"

#include "transport/MemoryUsage.h"

#include "transport/Config.h"

#include <boost/foreach.hpp>

#include <boost/lexical_cast.hpp>

#include <Swiften/Version.h>

#define HAVE_SWIFTEN_3  (SWIFTEN_VERSION >= 0x030000)

namespace Transport {

DEFINE_LOGGER(logger, "AdminInterface");

static std::string getArg(const std::string &body) {

	std::string ret;

	if (body.find(" ") == std::string::npos)

		return ret;

	return body.substr(body.find(" ") + 1);

}

class StatusCommand : public AdminInterfaceCommand {

	public:

		StatusCommand(NetworkPluginServer *server, UserManager *userManager) :

												AdminInterfaceCommand("status",

												AdminInterfaceCommand::General,

												AdminInterfaceCommand::GlobalContext,

												AdminInterfaceCommand::AdminMode,

												AdminInterfaceCommand::Get) {

			m_server = server;

			m_userManager = userManager;

			setDescription("Shows instance status");

		}

		virtual std::string handleGetRequest(UserInfo &uinfo, User *user, std::vector<std::string> &args) {

			std::string ret = AdminInterfaceCommand::handleGetRequest(uinfo, user, args);

			if (!ret.empty()) {

				return ret;

			}

			int users = m_userManager->getUserCount();

			int backends = m_server->getBackendCount();

			ret = "Running (" + boost::lexical_cast<std::string>(users) + " users connected using " + boost::lexical_cast<std::string>(backends) + " backends)";

			return ret;

		}

	private:

		NetworkPluginServer *m_server;

		UserManager *m_userManager;

};

class UptimeCommand : public AdminInterfaceCommand {

	public:

		UptimeCommand() : AdminInterfaceCommand("uptime",

							AdminInterfaceCommand::General,

							AdminInterfaceCommand::GlobalContext,

							AdminInterfaceCommand::AdminMode,

							AdminInterfaceCommand::Get) {

			m_start = time(NULL);

			setDescription("Returns ptime in seconds");

		}

		virtual std::string handleGetRequest(UserInfo &uinfo, User *user, std::vector<std::string> &args) {

			std::string ret = AdminInterfaceCommand::handleGetRequest(uinfo, user, args);

			if (!ret.empty()) {

				return ret;

#include <malloc.h>

#endif

#endif

#else

#include <process.h>

#define getpid _getpid

#include "win32/ServiceWrapper.h"

#endif

#include <sys/stat.h>

#include <boost/dll/shared_library.hpp>         // for shared_library

#include <boost/dll/runtime_symbol_info.hpp>    // for program_location()

namespace dll = boost::dll;

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

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

				exit(1);

			}

			fclose(lock_file_f);

		}

		exit(0);

	}

	/* Change the file mode mask */

	umask(0);

	/* Create a new SID for the child process */

	sid = setsid();

	if (sid < 0) {

		exit(1);

	}

	/* Change the current working directory.  This prevents the current

		directory from being locked; hence not being able to remove it. */

	if ((chdir(cwd)) < 0) {

		exit(1);

	}