KSG-Client/KSGClient/Netzwerk/Klients/HistorieK.cpp

#include "../KSGKlient.h"
#include "../KSGServer.h"
#include "../../Global/Variablen.h"
#include <Datei.h>
#include "../Keys.h"
#include <Globals.h>

// Inhalt der HistorieKlient Klasse KSGKlient.h
// Konstruktor
HistorieKlient::HistorieKlient()
{
    klient = 0;
    fehler = new Text( "" );
    klientId = getKlientId();
    ref = 1;
}

// Destruktor
HistorieKlient::~HistorieKlient()
{
    cs.lock();
    trenne();
    fehler = fehler->release();
    cs.unlock();
}

// privat
bool HistorieKlient::verbinde( char *ip, int port ) // verbindet ich mit dem Historie Server
{
    if( klient && klient->getServerPort() == port && Text( ip ).istGleich( klient->getServerIp() ) )
        return 1;
    if( klient )
        trenne();
    klient = new Klient();
    Framework::logLine( ( ( Text( "Zugeteilter Historie Server:" ) += ip ) += ":" ) += port );
    Framework::logLine( "Verbinung mit Historie Server wird hergestellt..." );
    int keyLen = 0;
    char *key = 0;
    Keys::getServerKey( &key, keyLen, Keys::HISTORIE, Keys::SENDEN );
    klient->setSendeKey( key, keyLen );
    delete[] key;
    Keys::getServerKey( &key, keyLen, Keys::HISTORIE, Keys::EMPFANGEN );
    klient->setEmpfangKey( key, keyLen );
    delete[] key;
    if( !klient->verbinde( (unsigned short)port, ip ) )
    {
        Framework::logLine( "ERROR: Server nicht erreichbar." );
        klient = klient->release();
        fehler->setText( "Fehler beim verbinden mit dem Historie Server." );
        return 0;
    }
    klient->sendeEncrypted( "\1", 1 );
    klient->sendeEncrypted( (char*)&klientId, 4 );
    char ret = 0;
    klient->getNachrichtEncrypted( &ret, 1 );
    if( ret == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *nachricht = new char[ län + 1 ];
        nachricht[ län ] = 0;
        klient->getNachrichtEncrypted( nachricht, län );
        fehler->setText( nachricht );
        Framework::logLine( Text( "ERROR: " ) += nachricht );
        delete[]nachricht;
        trenne();
        return 0;
    }
    if( ret == 1 )
    {
        char *sl = 0;
        char slLän = getSchlüssel( &sl );
        klient->setSendeKey( sl, slLän );
        klient->setEmpfangKey( sl, slLän );
        delete[] sl;
    }
    Framework::logLine( "Erfolgreich mit Historie Server verbunden." );
    return 1;
}

bool HistorieKlient::trenne() // trennt sich von dem Historie Server
{
    if( !klient )
        return 1;
    Framework::logLine( "Verbindung zum Historie Server wird getrennt..." );
    char serverReturn;
    klient->sendeEncrypted( "\4", 1 );
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *nachricht = new char[ län + 1 ];
        nachricht[ län ] = 0;
        klient->getNachrichtEncrypted( nachricht, län );
        delete[]nachricht;
    }
    klient->sendeEncrypted( "\3", 1 );
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    klient->trenne();
    klient = klient->release();
    return 1;
}

// nicht constant
bool HistorieKlient::downloadSpielHistorie( int spielId ) // läd Spiel Historie herunter
{
    if( DateiIstVerzeichnis( Text( "data/tmp/historie/" ) += spielId ) )
        return 1;
    cs.lock();
    int port = 0;
    Text *ip = new Text();
    if( !infoKlient->getHistorieServer( spielId, &port, ip ) )
    {
        cs.unlock();
        ip->release();
        fehler->setText( infoKlient->getLetzterFehler() );
        return 0;
    }
    if( !verbinde( *ip, port ) )
    {
        cs.unlock();
        ip->release();
        return 0;
    }
    ip->release();
    klient->sendeEncrypted( "\6", 1 );
    char ret = 0;
    klient->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeEncrypted( (char*)&spielId, 4 );
        klient->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            char län = 0;
            klient->getNachrichtEncrypted( &län, 1 );
            while( län )
            {
                char *pf = new char[ län + 1 ];
                pf[ län ] = 0;
                klient->getNachrichtEncrypted( pf, län );
                __int64 gr = 0;
                klient->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;
                    klient->getNachricht( bytes, dLän );
                    d->schreibe( bytes, dLän );
                    gr -= dLän;
                }
                delete[] bytes;
                d->close();
                d->release();
                klient->getNachrichtEncrypted( &län, 1 );
            }
            trenne();
            cs.unlock();
            return 1;
        }
    }
    if( ret == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *nachricht = new char[ län + 1 ];
        nachricht[ län ] = 0;
        klient->getNachrichtEncrypted( nachricht, län );
        fehler->setText( nachricht );
        delete[]nachricht;
    }
    trenne();
    cs.unlock();
    return 0;
}

// constant
bool HistorieKlient::istVerbunden() const // prüft, ob mit Historie Server verbunden
{
    return klient != 0;
}

char *HistorieKlient::getLetzterFehler() const // gibt den Letzten Fehlertext zuück
{
    return *fehler;
}

// Reference Counting
HistorieKlient *HistorieKlient::getThis()
{
    ref++;
    return this;
}

HistorieKlient *HistorieKlient::release()
{
    ref--;
    if( !ref )
        delete this;
    return 0;
}