KSGNetwork/KSGNetwork/HistorieClient.cpp

#include "HistorieClient.h"
#include "Keys.h"
#include <Datei.h>
#include <Klient.h>

using namespace KSGClient;

// Inhalt der HistorieClient Klasse

// Konstruktor
HistorieClient::HistorieClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen, int spielId )
    : ReferenceCounter()
{
    this->ip = ip;
    this->port = port;
    cId = klientId;
    k = 0;
    this->key = new char[ keyLen ];
    memcpy( this->key, key, keyLen );
    this->keyLen = keyLen;
    this->spielId = spielId;
}

// Destruktor
HistorieClient::~HistorieClient()
{
    trenne( 1 );
    delete[] key;
}

// verbindet sich mit dem zugewiesenen Historie Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool HistorieClient::verbinde()
{
    cs.lock();
    if( k )
    {
        cs.unlock();
        return 1;
    }
    k = new Network::Klient();
    int l = 0;
    char *key;
    Keys::getServerKey( &key, l, Keys::HISTORIE, Keys::SENDEN );
    k->setSendeKey( key, l );
    delete[] key;
    Keys::getServerKey( &key, l, Keys::HISTORIE, Keys::EMPFANGEN );
    k->setEmpfangKey( key, l );
    delete[] key;
    if( k->verbinde( port, ip ) )
    {
        if( k->sendeEncrypted( "\1", 1 ) )
        {
            k->sendeEncrypted( (char *)&cId, 4 );
            char serverReturn = 0;
            k->getNachrichtEncrypted( &serverReturn, 1 );
            if( serverReturn == 3 )
            {
                char byte = 0;
                k->getNachrichtEncrypted( &byte, 1 );
                char *f = new char[ byte + 1 ];
                f[ byte ] = 0;
                k->getNachrichtEncrypted( f, byte );
                err = "error while identifying client Historie Server returned: ";
                err += f;
                delete[]f;
                trenne( 0 );
                cs.unlock();
                return 0;
            }
            k->setSendeKey( this->key, this->keyLen );
            k->setEmpfangKey( this->key, this->keyLen );
        }
        else
        {
            err = "network error while sending to Historie Server";
            k = (Network::Klient *)k->release();
            cs.unlock();
            return 0;
        }
    }
    else
    {
        err = "network error while connecting to Historie Server";
        k = (Network::Klient *)k->release();
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

// Trennt die Verbindung zum Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
bool HistorieClient::trenne( bool abmelden )
{
    if( !k && !abmelden )
        return 1;
    if( !k && abmelden )
        verbinde();
    if( !k )
        return 0;
    char serverReturn;
    if( abmelden )
    {
        k->sendeEncrypted( "\4", 1 );
        k->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 3 )
        {
            char län = 0;
            k->getNachrichtEncrypted( &län, 1 );
            char *nachricht = new char[ län + 1 ];
            nachricht[ län ] = 0;
            k->getNachrichtEncrypted( nachricht, län );
            err = nachricht;
            delete[]nachricht;
        }
    }
    k->sendeEncrypted( "\3", 1 );
    k->getNachrichtEncrypted( &serverReturn, 1 );
    k->trenne();
    k = (Network::Klient *)k->release();
    return 1;
}

// Lädt die Spiel Aufzeichnung eines Spiels herunter und speichert sie unter data/tmp/historie/{spielId}
//  Die Spielid wurde dem Objekt zum Zeitpunkt der Erstellung vom Information Server mitgegeben
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  Diese Funktion verbindet sich selbstständig mit dem Server und trennt die Verbindung nach Beendigung des Vorgangs
bool HistorieClient::downloadSpielHistorie()
{
    if( DateiIstVerzeichnis( Text( "data/tmp/historie/" ) += spielId ) )
        return 1;
    cs.lock();
    if( !verbinde() )
    {
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\6", 1 );
    char ret = 0;
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&spielId, 4 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            char län = 0;
            k->getNachrichtEncrypted( &län, 1 );
            while( län )
            {
                char *pf = new char[ län + 1 ];
                pf[ län ] = 0;
                k->getNachrichtEncrypted( pf, län );
                __int64 gr = 0;
                k->getNachrichtEncrypted( (char *)&gr, 8 );
                Text *pfad = new Text( "data/tmp/historie/" );
                pfad->append( spielId );
                pfad->append( pf );
                delete[] pf;
                Datei *d = new Datei();
                d->setDatei( pfad );
                d->erstellen();
                d->open( Datei::Style::schreiben );
                char *bytes = new char[ 2048 ];
                while( gr )
                {
                    int dLän = gr > 2048 ? 2048 : (int)gr;
                    k->getNachricht( bytes, dLän );
                    d->schreibe( bytes, dLän );
                    gr -= dLän;
                }
                delete[] bytes;
                d->close();
                d->release();
                k->getNachrichtEncrypted( &län, 1 );
            }
            trenne( 0 );
            cs.unlock();
            return 1;
        }
    }
    if( ret == 3 )
    {
        char län = 0;
        k->getNachrichtEncrypted( &län, 1 );
        char *nachricht = new char[ län + 1 ];
        nachricht[ län ] = 0;
        k->getNachrichtEncrypted( nachricht, län );
        err = nachricht;
        delete[]nachricht;
        trenne( 0 );
        cs.unlock();
        return 0;
    }
    err = "unbekannter Fehler";
    trenne( 0 );
    cs.unlock();
    return 0;
}

// gibt den Letzten Fehlertext zuück
//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
char *HistorieClient::getLetzterFehler() const
{
    return err;
}