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

namespace Transport {

class Component;

class StorageBackend;

class AdminInterface {

	public:

		~AdminInterface();

	private:

		void handleMessageReceived(Swift::Message::ref message);

		Component *m_component;

		StorageBackend *m_storageBackend;

};

}

class UserManager;

class User;

class Component;

class Buddy;

class LocalBuddy;

class Config;

class NetworkConversation;

class VCardResponder;

class RosterResponder;

class NetworkPluginServer {

	public:

		struct Client {

			bool pongReceived;

			std::list<User *> users;

			Swift::SafeByteArray data;

			boost::shared_ptr<Swift::Connection> connection;

		};

		NetworkPluginServer(Component *component, Config *config, UserManager *userManager);

		virtual ~NetworkPluginServer();

		void handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &message);

	private:

		void handleNewClientConnection(boost::shared_ptr<Swift::Connection> c);

		void handleSessionFinished(Client *c);

		void handleDataRead(Client *c, const Swift::SafeByteArray&);

		void handleConnectedPayload(const std::string &payload);

		void handleDisconnectedPayload(const std::string &payload);

		void handleBuddyChangedPayload(const std::string &payload);

		void handleConvMessagePayload(const std::string &payload, bool subject = false);

		void handleParticipantChangedPayload(const std::string &payload);

		void handleRoomChangedPayload(const std::string &payload);

		void handleVCardPayload(const std::string &payload);

		void handleChatStatePayload(const std::string &payload, Swift::ChatState::ChatStateType type);

		void handleAuthorizationPayload(const std::string &payload);

		void handleAttentionPayload(const std::string &payload);

		void handleUserCreated(User *user);

		void handleRoomJoined(User *user, const std::string &room, const std::string &nickname, const std::string &password);

		void handleRoomLeft(User *user, const std::string &room);

		void handleUserReadyToConnect(User *user);

		void handleUserPresenceChanged(User *user, Swift::Presence::ref presence);

		void handleUserDestroyed(User *user);

		return 1;

	}

	Swift::SimpleEventLoop eventLoop;

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

	Logger logger(&transport);

	StorageBackend *storageBackend = NULL;

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

		storageBackend = new SQLite3Backend(&config);

		logger.setStorageBackend(storageBackend);

		if (!storageBackend->connect()) {

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

		}

	}

	UserManager userManager(&transport, storageBackend);

	if (storageBackend) {

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

		logger.setUserRegistration(&userRegistration);

	}

	logger.setUserManager(&userManager);

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

	eventLoop.run();

}

 *

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

#include "transport/transport.h"

#include "transport/storagebackend.h"

#include "transport/conversationmanager.h"

#include "transport/rostermanager.h"

#include "storageresponder.h"

#include "log4cxx/logger.h"

using namespace log4cxx;

namespace Transport {

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

	m_component = component;

	m_storageBackend = storageBackend;

	m_component->getStanzaChannel()->onMessageReceived.connect(bind(&AdminInterface::handleMessageReceived, this, _1));

}

AdminInterface::~AdminInterface() {

}

void AdminInterface::handleMessageReceived(Swift::Message::ref message) {

	if (!message->getTo().getNode().empty())

		return;

	if (message->getFrom().getNode() != CONFIG_STRING(m_component->getConfig(), "service.admin_username")) {

		LOG4CXX_WARN(logger, "Message not from admin user, but from " << message->getFrom().getNode());

		return;

	}

	LOG4CXX_INFO(logger, "Message from admin received");

	message->setTo(message->getFrom());

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

	if (message->getBody() == "status") {

	}

	else {

		message->setBody("Unknown command");

	}

	m_component->getStanzaChannel()->sendMessage(message);

}

}