FactoryCraft-Server/FactoryCraft/Server.cpp

#include "Server.h"

#include <AsynchronCall.h>
#include <File.h>
#include <Globals.h>
#include <iostream>
#include <Logging.h>
#include <Timer.h>

#include "Game.h"
#include "PlayerRegister.h"

// Inhalt der LoginServer Klasse aus LoginServer.h
// Konstruktor
FactoryCraftServer::FactoryCraftServer(InitFile* zIni)
    : ReferenceCounter()
{
    Network::Start(100);
    runningThreads = 0;
    klients = new RCArray<FCKlient>();
    ini = dynamic_cast<InitFile*>(zIni->getThis());
    id = (int)*zIni->zValue("ServerId");
    sslServer = new SSLServer();
    sslServer->setPrivateKeyPassword(zIni->zValue("SSLPasswort")->getText());
    sslServer->setCertificateFile(zIni->zValue("SSLCert")->getText());
    Framework::Logging::info()
        << "using cert file " << zIni->zValue("SSLCert")->getText();
    sslServer->setPrivateKeyFile(zIni->zValue("SSLKey")->getText());
    Framework::Logging::info()
        << "using private key " << zIni->zValue("SSLKey")->getText();
    server = new Server();
    Framework::Logging::info()
        << "Server Port: " << ini->zValue("Port")->getText();
    if (!server->connect(
            (unsigned short)TextZuInt(ini->zValue("Port")->getText(), 10), 10))
    {
        Framework::Logging::error()
            << "Der Server konnte nicht gestartet werden.";
        exit(1);
    }

    Framework::Logging::info()
        << "SSL Server Port: " << ini->zValue("SSLPort")->getText();
    if (!sslServer->connect(
            (unsigned short)TextZuInt(ini->zValue("SSLPort")->getText(), 10),
            10))
    {
        Framework::Logging::error()
            << "Der SSL Server konnte nicht gestartet werden.";
        exit(2);
    }
    Game::initialize(
        zIni->zValue("World")->getText(), zIni->zValue("SaveDir")->getText());
    new Framework::AsynchronCall("Server", [this]() {
        runningThreads++;
        while (server->isConnected())
        {
            SClient* klient = server->getClient();
            if (!klient) continue;
            unsigned short len;
            klient->setReceiveTimeout(5000);
            klient->getMessage((char*)&len, 2);
            char* key = new char[len];
            klient->getMessage((char*)key, len);
            bool bg;
            klient->getMessage((char*)&bg, 1);
            klient->setReceiveTimeout(0);
            bool found = 0;
            cs.lock();
            for (FCKlient* client : *klients)
            {
                if (client->matchAuthKey(key, len))
                {
                    if (bg)
                    {
                        klient->send("\1", 1);
                        client->setBackgroundClient(klient);
                    }
                    else
                    {
                        klient->send("\1", 1);
                        client->setForegroundClient(klient);
                    }
                    found = 1;
                    break;
                }
            }
            cs.unlock();
            if (!found)
            {
                klient->send("\0", 1);
                Framework::Logging::error()
                    << "client failed to pass through authorisation";
                klient->release();
            }
        }
        runningThreads--;
    });
}

// Destruktor
FactoryCraftServer::~FactoryCraftServer()
{
    sslServer->disconnect();
    server->disconnect();
    while (runningThreads > 0)
        Sleep(100);
    sslServer->release();
    server->release();
    if (klients) klients->release();
    ini->release();
}

// nicht constant
void FactoryCraftServer::run()
{
    runningThreads++;
    while (sslServer->isConnected())
    {
        SSLSClient* klient = sslServer->getClient();
        if (!klient) continue;
        Framework::getThreadRegister()->cleanUpClosedThreads();
        FCKlient* clHandle = new FCKlient(
            klient, dynamic_cast<FactoryCraftServer*>(getThis()));
        cs.lock();
        klients->add(clHandle);
        cs.unlock();
        clHandle->start();
    }
    runningThreads--;
}

void FactoryCraftServer::close()
{
    Game::INSTANCE->save();
    sslServer->disconnect();
    server->disconnect();
    cs.lock();
    for (int i = 0; i < klients->getEntryCount(); i++)
        klients->z(i)->absturz();
    cs.unlock();
}

bool FactoryCraftServer::removeKlient(FCKlient* zKlient)
{
    bool gefunden = 0;
    getThis();
    cs.lock();
    for (int i = 0; i < klients->getEntryCount(); i++)
    {
        if (klients->z(i) == zKlient)
        {
            klients->remove(i);
            gefunden = 1;
            break;
        }
    }
    cs.unlock();
    release();
    return gefunden;
}

bool FactoryCraftServer::hatClients() const
{
    return klients->has(0);
}

int FactoryCraftServer::getUnencryptedPort() const
{
    return server->getPort();
}

// Inhalt der LSClient aus LoginServer.h
// Konstruktor
FCKlient::FCKlient(SSLSClient* klient, FactoryCraftServer* ls)
    : Thread()
{
    this->klient = klient;
    background = 0;
    foreground = 0;
    this->ls = ls;
    zGameClient = 0;
    backgroundReader = 0;
    foregroundReader = 0;
    backgroundWriter = 0;
    foregroundWriter = 0;
    authKey = randomSecret();
}

// Destruktor
FCKlient::~FCKlient()
{
    if (zGameClient)
    {
        zGameClient->logout();
        zGameClient = (GameClient*)zGameClient->release();
    }
    if (background) background->release();
    if (foreground) foreground->release();
    delete backgroundReader;
    delete foregroundReader;
    delete backgroundWriter;
    delete foregroundWriter;
    klient->release();
    ls->release();
}

void FCKlient::onInitialized()
{
    RCArray<Text> filesToTransfer;
    checkResources("data/images", filesToTransfer);
    checkResources("data/models", filesToTransfer);
    checkResources("data/textures", filesToTransfer);
    short endSignal = 0;
    foreground->send((char*)&endSignal, 2);
    char* buffer = new char[4096];
    for (Text* path : filesToTransfer)
    {
        File file(path->getText());
        __int64 length = file.getSize();
        file.open(File::Style::read);
        int count = 0;
        while (count < length)
        {
            int l = MIN(4096, (int)length - count);
            file.read(buffer, l);
            foreground->send(buffer, l);
            count += l;
        }
        file.close();
    }
    delete[] buffer;
    zGameClient
        = Game::INSTANCE->addPlayer(dynamic_cast<FCKlient*>(getThis()), name);
}

void FCKlient::checkResources(const char* path, RCArray<Text>& filesToTransfer)
{
    File file(path);
    if (file.isDirectory())
    {
        RCArray<Text>* names = file.getFileList();
        for (Text* name : *names)
        {
            Text tmp(path);
            tmp.append() << "/" << *name;
            checkResources(tmp, filesToTransfer);
        }
        names->release();
    }
    else
    {
        short len = (short)textLength(path);
        foreground->send((char*)&len, 2);
        foreground->send(path, len);
        File resFile(path);
        Time* Time = resFile.getLastChange();
        int tmp = Time->zDate()->getJahr();
        foreground->send((char*)&tmp, 4);
        tmp = Time->zDate()->getMonat();
        foreground->send((char*)&tmp, 4);
        tmp = Time->zDate()->getTag();
        foreground->send((char*)&tmp, 4);
        tmp = (Time->zClock()->getStunde() * 60 + Time->zClock()->getMinute())
                * 60
            + Time->zClock()->getSekunde();
        foreground->send((char*)&tmp, 4);
        bool needed = 0;
        foreground->getMessage((char*)&needed, 1);
        if (needed)
        {
            __int64 size = resFile.getSize();
            foreground->send((char*)&size, 8);
            filesToTransfer.add(new Text(path));
        }
        Time->release();
    }
}

// nicht constant
void FCKlient::setForegroundClient(SClient* foreground)
{
    Framework::Logging::trace() << "foreground client connected";
    this->foreground = foreground;
    foregroundReader = new NetworkReader(foreground);
    foregroundWriter = new NetworkWriter(foreground);
    if (foreground && background)
    {
        onInitialized();
    }
    foregroundRunning = 1;
    new AsynchronCall([this]() {
        while (this->foreground->waitForNextMessage())
        {
            if (zGameClient) zGameClient->addMessage(foregroundReader);
            if (!zGameClient) Sleep(100);
        }
        cs.lock();
        foregroundRunning = 0;
        if (!backgroundRunning)
        {
            cs.unlock();
            if (zGameClient)
            {
                zGameClient->logout();
                zGameClient = (GameClient*)zGameClient->release();
            }
            ls->removeKlient(this);
        }
        else
        {
            cs.unlock();
        }
    });
}

void FCKlient::setBackgroundClient(SClient* background)
{
    Framework::Logging::trace() << "background client connected";
    this->background = background;
    backgroundReader = new NetworkReader(background);
    backgroundWriter = new NetworkWriter(background);
    if (foreground && background)
    {
        onInitialized();
    }
    backgroundRunning = 1;
    new AsynchronCall([this]() {
        while (this->background->waitForNextMessage())
        {
            if (zGameClient) zGameClient->addMessage(backgroundReader);
            if (!zGameClient) Sleep(100);
        }
        cs.lock();
        backgroundRunning = 0;
        if (!foregroundRunning)
        {
            cs.unlock();
            if (zGameClient)
            {
                zGameClient->logout();
                zGameClient = (GameClient*)zGameClient->release();
            }
            ls->removeKlient(this);
        }
        else
        {
            cs.unlock();
        }
    });
}

void FCKlient::absturz()
{
    klient->disconnect();
    if (background) background->disconnect();
    if (foreground) foreground->disconnect();
    waitForThread(10000);
    ende();
}

void FCKlient::thread()
{
    bool identified = 0;
    while (1)
    {
        char c = 0;
        if (!klient->getMessage(&c, 1))
            break;
        else
        {
            bool br = 0;
            switch (c)
            {
            case 1: // Klient identifikation
                {
                    char len;
                    klient->getMessage(&len, 1);
                    char* name = new char[len + 1];
                    klient->getMessage(name, len);
                    name[(int)len] = 0;
                    unsigned short sLen;
                    klient->getMessage((char*)&sLen, 2);
                    char* secret = new char[sLen + 1];
                    klient->getMessage(secret, sLen);
                    secret[sLen] = 0;
                    if (!Game::INSTANCE->checkPlayer(name, secret))
                    {
                        klient->send("\0", 1);
                        delete[] name;
                        delete[] secret;
                        break;
                    }
                    if (!Game::INSTANCE->existsPlayer(name))
                    {
                        Text secret = Game::INSTANCE->createPlayer(name);
                        klient->send("\2", 1);
                        short len = (short)secret.getLength();
                        klient->send((char*)&len, 2);
                        klient->send(secret.getText(), len);
                        identified = 1;
                    }
                    else
                    {
                        klient->send("\1", 1);
                        identified = 1;
                    }
                    short keyLen = (short)authKey.getLength();
                    klient->send((char*)&keyLen, 2);
                    klient->send(authKey, keyLen);
                    this->name = name;
                    delete[] name;
                    delete[] secret;
                    break;
                }
            case 2: // Verbindungsend
                br = 1;
                if (zGameClient)
                {
                    zGameClient->logout();
                    zGameClient = (GameClient*)zGameClient->release();
                }
                klient->send("\1", 1);
                break;
            case 3: // ping
                klient->send("\1", 1);
                break;
            case 4: // check player name valid
                {
                    klient->send("\1", 1);
                    char len;
                    klient->getMessage(&len, 1);
                    char* name = new char[len + 1];
                    klient->getMessage(name, len);
                    name[(int)len] = 0;
                    short sLen;
                    klient->getMessage((char*)&sLen, 2);
                    char* secret = new char[sLen + 1];
                    klient->getMessage(secret, sLen);
                    secret[sLen] = 0;
                    char res = 0;
                    if (Game::INSTANCE->checkPlayer(name, secret)) res = 1;
                    klient->send(&res, 1);
                    delete[] name;
                    delete[] secret;
                    break;
                }
            default:
                br = 1;
                break;
            }
            if (br) break;
        }
    }
    if (!identified)
    {
        ls->removeKlient(this);
    }
}

NetworkWriter* FCKlient::zBackgroundWriter() const
{
    return backgroundWriter;
}

NetworkWriter* FCKlient::zForegroundWriter() const
{
    return foregroundWriter;
}

bool FCKlient::matchAuthKey(char* key, int len) const
{
    if (foreground && background) return 0;
    if (len != authKey.getLength()) return 0;
    for (int i = 0; i < len; i++)
    {
        if (key[i] != authKey.getText()[i]) return 0;
    }
    return 1;
}