masterclient.cpp

//------------------------------------------------------------------------------
// masterclient.cpp
//------------------------------------------------------------------------------
//
// 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
// 02110-1301, USA.
//
//------------------------------------------------------------------------------
// Copyright (C) 2009 "Blzut3" <admin@maniacsvault.net>
//------------------------------------------------------------------------------
#include "masterclient.h"

#include "log.h"
#include "plugins/engineplugin.h"
#include "serverapi/message.h"
#include "serverapi/server.h"
#include "serverapi/playerslist.h"
#include "datapaths.h"

#include <QDataStream>
#include <QErrorMessage>
#include <QFile>
#include <QHostInfo>
#include <QMessageBox>
#include <QUdpSocket>

DClass<MasterClient>
{
        public:
                QHostAddress address;

                bool timeouted;
                bool enabled;
                unsigned short port;
                QList<ServerPtr> servers;

                QFile *cache;

                bool isCacheOpenForReading() const
                {
                        return cache != NULL && cache->isReadable();
                }

                bool isCacheOpenForWriting() const
                {
                        return cache != NULL && cache->isWritable();
                }

                QString (MasterClient::*masterBanHelp)() const;
};

DPointered(MasterClient)

POLYMORPHIC_DEFINE_CONST(QString, MasterClient, masterBanHelp, (), ());

MasterClient::MasterClient()
{
        d->cache = NULL;
        d->timeouted = false;
        d->enabled = true;
        d->port = 0;
        set_masterBanHelp(&MasterClient::masterBanHelp_default);
}

MasterClient::~MasterClient()
{
        emptyServerList();
        resetPacketCaching();
        if (d->cache != NULL)
        {
                delete d->cache;
        }
}

void MasterClient::clearServers()
{
        d->servers.clear();
}

bool MasterClient::isAddressSame(const QHostAddress &address, unsigned short port) const
{
        return (d->address == address && d->port == port);
}

void MasterClient::emitBannedMessage()
{
        Message msg = Message(Message::Type::BANNED_FROM_MASTERSERVER);
        QString helpMsg = masterBanHelp();
        if (!helpMsg.trimmed().isEmpty())
        {
                msg = Message(Message::Type::CUSTOM_ERROR, tr("%1 %2").arg(
                        msg.contents(), helpMsg.trimmed()));
        }
        emit message(engineName(), msg.contents(), true);
        emit messageImportant(msg);
}

void MasterClient::emptyServerList()
{
        foreach (ServerPtr server, d->servers)
        {
                server->disconnect();
        }
        d->servers.clear();
}

QString MasterClient::engineName() const
{
        if (plugin() == NULL)
        {
                return "";
        }
        return plugin()->data()->name;
}

bool MasterClient::isEnabled() const
{
        return d->enabled;
}

bool MasterClient::isTimeouted() const
{
        return d->timeouted;
}

QString MasterClient::masterBanHelp_default() const
{
        return QString();
}

void MasterClient::notifyResponse(Response response)
{
        switch(response)
        {
                default:
                        break;
                case RESPONSE_BANNED:
                {
                        emitBannedMessage();
                        break;
                }
                case RESPONSE_WAIT:
                        emit message(engineName(), tr("Could not fetch a new server list from the "
                                "master because not enough time has past."), true);
                        readPacketCache();
                        break;
                case RESPONSE_BAD:
                        emit message(engineName(), tr("Bad response from master server."), true);
                        readPacketCache();
                        break;
                case RESPONSE_OLD:
                        emit message(engineName(),
                                tr("Could not fetch a new server list. The protocol you are using is too old. "
                                "An update may be available."), true);
                        break;
        }
}

int MasterClient::numPlayers() const
{
        int players = 0;
        foreach(ServerPtr server, d->servers)
        {
                if (server != NULL)
                {
                        players += server->players().numClients();
                }
        }
        return players;
}

int MasterClient::numServers() const
{
        return d->servers.size();
}

ServerPtr MasterClient::operator[](int index) const
{
        return d->servers[index];
}

bool MasterClient::preparePacketCache(bool write)
{
        if (write ? !d->isCacheOpenForWriting() : !d->isCacheOpenForReading())
        {
                if(plugin() == NULL)
                {
                        return false;
                }

                if(d->cache == NULL)
                {
                        QString cacheFile = gDefaultDataPaths->programsDataDirectoryPath() + "/"
                                + QString(plugin()->data()->name).replace(' ', "");
                        d->cache = new QFile(cacheFile);
                }
                else
                {
                        d->cache->close();
                }

                if(!d->cache->open(write ? QIODevice::WriteOnly|QIODevice::Truncate : QIODevice::ReadOnly))
                {
                        resetPacketCaching();
                        return false;
                }
        }
        else if (!write && d->isCacheOpenForReading())
        {
                // If we prepare cache for reading we want to start
                // reading from the beginning.
                d->cache->seek(0);
        }
        return d->cache != NULL;
}

void MasterClient::pushPacketToCache(const QByteArray &data)
{
        if(!preparePacketCache(true))
        {
                return;
        }

        QDataStream strm(d->cache);
        strm << static_cast<quint16>(data.size());
        strm << data;
}

MasterClient::Response MasterClient::readResponse(const QByteArray &data)
{
        Response response = readMasterResponse(data);
        if (response == RESPONSE_GOOD || response == RESPONSE_PENDING)
        {
                pushPacketToCache(data);
        }
        return response;
}

void MasterClient::readPacketCache()
{
        if(!preparePacketCache(false))
        {
                // Cache didn't open? Guess we just emit the signal.
                emit listUpdated();
                return;
        }

        QDataStream strm(d->cache);
        if (strm.atEnd())
        {
                // Can't read anything from cache. Either cache is empty
                // or for some reason the file cursor is set to the
                // end of the file.
                emit listUpdated();
                return;
        }

        gLog << tr("Reloading master server results from cache for %1!").arg(plugin()->data()->name);
        bool hasGood = false;
        while(!strm.atEnd())
        {
                quint16 size;
                strm >> size;

                QByteArray data(size, '\0');
                strm >> data;

                Response response = readMasterResponse(data);
                if (response == RESPONSE_GOOD)
                {
                        hasGood = true;
                }
                if(response != RESPONSE_GOOD && response != RESPONSE_PENDING)
                {
                        // Cache was not read properly. We need to emit the signal
                        // to notify the program that this master client finished
                        // updating.
                        emit listUpdated();
                        return;
                }
        }
        if (!hasGood)
        {
                // Plugins are ought to emit listUpdated() only when RESPONSE_GOOD
                // is achieved. If that's not the case, we shall emit it here
                // to notify refreshing process that the server has completed
                // updating.
                emit listUpdated();
        }
}

void MasterClient::registerNewServer(ServerPtr server)
{
        server->setSelf(server.toWeakRef());
        d->servers << server;
}

void MasterClient::resetPacketCaching()
{
        if(d->cache != NULL)
        {
                delete d->cache;
                d->cache = NULL;
        }
}

void MasterClient::refreshStarts()
{
        setTimeouted(false);
        emptyServerList();
        resetPacketCaching();
}

bool MasterClient::sendRequest(QUdpSocket *socket)
{
        if(d->address.isNull())
                return false;

        // Make request
        QByteArray request = createServerListRequest();
        if(request.isEmpty())
                return false;
        socket->writeDatagram(request, d->address, d->port);
        return true;
}

const QList<ServerPtr> &MasterClient::servers() const
{
        return d->servers;
}

void MasterClient::setEnabled(bool b)
{
        d->enabled = b;
}

void MasterClient::setTimeouted(bool b)
{
        d->timeouted = b;
}

void MasterClient::timeoutRefresh()
{
        // Avoid timeouting more than once. This would cause errors.
        if (!isTimeouted())
        {
                setTimeouted(true);

                emit message(tr("Master server timeout"), tr("Connection timeout (%1:%2).")
                        .arg(d->address.toString()).arg(d->port), true);
                readPacketCache();

                timeoutRefreshEx();
        }
}

void MasterClient::timeoutRefreshEx()
{
}

void MasterClient::updateAddress()
{
        QString host;
        unsigned short port;
        plugin()->masterHost(host, port);

        QHostInfo info = QHostInfo::fromName(host);
        if(info.addresses().size() == 0)
                return;

        d->address = info.addresses().first();
        if (d->address.protocol() != QAbstractSocket::IPv4Protocol)
        {
                foreach(const QHostAddress &addr, info.addresses())
                {
                        if(addr.protocol() == QAbstractSocket::IPv4Protocol)
                                d->address = addr;
                }
        }
        d->port = port;
}