KSGNetwork/KSGNetwork/PatchClient.cpp

#include "PatchClient.h"
#include <Klient.h>
#include <KSGTDatei.h>
#include "Keys.h"
#include <Datei.h>
#include <Zeit.h>
#include <Fortschritt.h>

using namespace KSGClient;

// Inhalt der PatchClient Klasse

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

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

// verbindet ich mit dem Patch Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool PatchClient::verbinde()
{
    cs.lock();
    if( k )
    {
        cs.unlock();
        return 1;
    }
    k = new Network::Klient();
    int l = 0;
    char *key;
    Keys::getServerKey( &key, l, Keys::PATCH, Keys::SENDEN );
    k->setSendeKey( key, l );
    delete[] key;
    Keys::getServerKey( &key, l, Keys::PATCH, Keys::EMPFANGEN );
    k->setEmpfangKey( key, l );
    delete[] key;
    if( k->verbinde( port, ip ) )
    {
        k->sende( "\0", 1 ); // Verschlüsselung Aktivieren
        if( k->sendeEncrypted( "\1", 1 ) )
        {
            k->sendeEncrypted( (char*)&cId, 4 );
#ifdef _X64
            k->sendeEncrypted( "\2", 1 ); // 64 Bit Client
#else
            k->sendeEncrypted( "\1", 1 ); // 32 Bit Client
#endif
            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 Patch 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 Patch Server";
            k = k->release();
            cs.unlock();
            return 0;
        }
    }
    else
    {
        err = "network error while connecting to Patch Server";
        k = k->release();
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

// Gibt eine Tabelle von Dateigruppen zurück.
//  Gibt bei misserfolg 0 zurück
Framework::KSGTDatei *PatchClient::getDateiGruppenListe()
{
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\xC", 1 );
    char ret = 0;
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 3 )
    { // error
        k->getNachrichtEncrypted( &ret, 1 );
        char *msg = new char[ ret + 1 ];
        msg[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( msg, ret );
        err = msg;
        delete[] msg;
        cs.unlock();
        return 0;
    }
    Framework::KSGTDatei *dgtb = new Framework::KSGTDatei();
    int id = 0;
    k->getNachrichtEncrypted( (char*)&id, 4 );
    while( id )
    {
        RCArray< Text > *zeile = new RCArray< Text >();
        Text *idT = new Text();
        idT->append( id );
        zeile->set( idT, 0 );
        int län = 0;
        k->getNachrichtEncrypted( (char*)&län, 4 );
        char *pfad = new char[ län + 1 ];
        pfad[ län ] = 0;
        if( län )
            k->getNachrichtEncrypted( pfad, län );
        zeile->set( new Text( pfad ), 1 );
        delete[] pfad;
        int vs = 0;
        k->getNachrichtEncrypted( (char*)&vs, 4 );
        Text *vsT = new Text();
        vsT->append( vs );
        zeile->set( vsT, 2 );
        dgtb->addZeile( 3, zeile );
        zeile->release();
        k->getNachrichtEncrypted( (char*)&id, 4 );
    }
    k->sendeEncrypted( "\1", 1 );
    cs.unlock();
    return dgtb;
}

// Gibt eine Tabelle von Dateien zurück.
//  gruppe: Die Id der Dateigruppe, zu der die Dateien gehöhren sollen
//  Gibt bei misserfolg 0 zurück
Framework::KSGTDatei *PatchClient::getDateiListe( int gruppe )
{
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\x9", 1 );
    char ret = 0;
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 3 )
    { // error
        k->getNachrichtEncrypted( &ret, 1 );
        char *msg = new char[ ret + 1 ];
        msg[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( msg, ret );
        err = msg;
        delete[] msg;
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( (char*)&gruppe, 4 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 3 )
    { // error
        k->getNachrichtEncrypted( &ret, 1 );
        char *msg = new char[ ret + 1 ];
        msg[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( msg, ret );
        err = msg;
        delete[] msg;
        cs.unlock();
        return 0;
    }
    KSGTDatei *dtb = new KSGTDatei();
    int län = 0;
    k->getNachrichtEncrypted( (char*)&län, 4 );
    while( län )
    {
        RCArray< Text > *zeile = new RCArray< Text >();
        zeile->set( new Text( "1" ), 0 );
        char *pfad = new char[ län + 1 ];
        pfad[ län ] = 0;
        k->getNachrichtEncrypted( pfad, län );
        zeile->set( new Text( pfad ), 1 );
        delete[] pfad;
        int vs = 0;
        k->getNachrichtEncrypted( (char*)&vs, 4 );
        Text *vsT = new Text();
        vsT->append( vs );
        zeile->set( vsT, 2 );
        dtb->addZeile( 3, zeile );
        zeile->release();
        k->getNachrichtEncrypted( (char*)&län, 4 );
    }
    k->getNachrichtEncrypted( (char*)&län, 4 );
    while( län )
    {
        RCArray< Text > *zeile = new RCArray< Text >();
        zeile->set( new Text( "0" ), 0 );
        char *pfad = new char[ län + 1 ];
        pfad[ län ] = 0;
        k->getNachrichtEncrypted( pfad, län );
        zeile->set( new Text( pfad ), 1 );
        delete[] pfad;
        dtb->addZeile( 2, zeile );
        zeile->release();
        k->getNachrichtEncrypted( (char*)&län, 4 );
    }
    cs.unlock();
    return dtb;
}

// Gibt die Größe einer Datei in bytes zurück
//  gruppe: Die Id der Dateigruppe der Datei
//  pfad: Der Pfad der Datei
__int64 PatchClient::getDateiGröße( int gruppe, const char *pfad )
{
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\xA", 1 );
    char ret = 0;
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 3 )
    { // error
        k->getNachrichtEncrypted( &ret, 1 );
        char *msg = new char[ ret + 1 ];
        msg[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( msg, ret );
        err = msg;
        delete[] msg;
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( (char*)&gruppe, 4 );
    ret = 0;
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 3 )
    { // error
        k->getNachrichtEncrypted( &ret, 1 );
        char *msg = new char[ ret + 1 ];
        msg[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( msg, ret );
        err = msg;
        delete[] msg;
        cs.unlock();
        return 0;
    }
    if( ret == 2 )
    { // verweis auf anderen Server
        int p = 0;
        k->getNachrichtEncrypted( (char*)&p, 4 );
        port = (unsigned short)p;
        int län = 0;
        k->getNachrichtEncrypted( (char*)&län, 4 );
        delete[]ip;
        ip = new char[ län + 1 ];
        ip[ län ] = 0;
        k->getNachrichtEncrypted( ip, län );
        if( !trenne( 0 ) )
        {
            err = "Fehler beim wechseln des Servers: Die Verbindung konnte nicht getrennt werden.";
            cs.unlock();
            return 0;
        }
        if( !verbinde() )
        {
            err = "Fehler beim wechseln des Servers: Die Verbindung konnte nicht hergestellt werden.";
            cs.unlock();
            return 0;
        }
        cs.unlock();
        return getDateiGröße( gruppe, pfad );
    }
    int län = textLength( pfad );
    k->sendeEncrypted( (char*)&län, 4 );
    k->sendeEncrypted( pfad, län );
    __int64 größe = 0;
    k->getNachrichtEncrypted( (char*)&größe, 8 );
    cs.unlock();
    return größe;
}

// Lädt eine Datei herunter
//  gruppe: Die Dateigruppe der Datei
//  start: Der Index des bytes, bei dem der download begonnen werden soll (Enthält im Falle eines Abbruchs die Position, von welcher aus als nächstes heruntergeladen werden muss)
//  pfad: Der Pfad der Datei
//  zielPfad: Der Pfad, an den die Datei gespeichert werden soll
//  zFb: Ein Fortschrittsbalken, der automatisch aktualisiert wird
//  abbruch: Wenn diese Variable während des Vorgangs auf 1 gesetzt wird, so wird das Herunterladen abgebrochen.
//  maxbps: Die Anzahl der bytes pro Sekunde, die maximal übertragen werden sollen
bool PatchClient::downloadDatei( int gruppe, __int64 *start, const char *pfad, const char *zielPfad, Framework::FBalken *zFb, bool *abbruch, int maxbps )
{
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    Datei *zielD = new Datei();
    zielD->setDatei( zielPfad );
    if( !zielD->existiert() )
        zielD->erstellen();
    bool ok = 0;
    if( !( *start ) ) // datei neu erstellen
        ok = zielD->open( Datei::Style::schreiben );
    else // datei weiterschreiben
        ok = zielD->open( Datei::Style::schreiben | Datei::Style::lesen );
    if( !ok )
    {
        zielD->release();
        err = "Die Datei konnte nicht zum schreiben geöffnet werden.";
        cs.unlock();
        return 0;
    }
    zielD->setSPosition( *start, 0 );
    k->sendeEncrypted( "\xB", 1 );
    char ret = 0;
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 3 )
    { // error
        k->getNachrichtEncrypted( &ret, 1 );
        char *msg = new char[ ret + 1 ];
        msg[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( msg, ret );
        err = msg;
        delete[] msg;
        zielD->close();
        zielD->release();
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( (char*)&gruppe, 4 );
    ret = 0;
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 3 )
    { // error
        k->getNachrichtEncrypted( &ret, 1 );
        char *msg = new char[ ret + 1 ];
        msg[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( msg, ret );
        err = msg;
        delete[] msg;
        zielD->close();
        zielD->release();
        cs.unlock();
        return 0;
    }
    if( ret == 2 )
    { // verweis auf anderen Server
        int p = 0;
        k->getNachrichtEncrypted( (char*)&p, 4 );
        port = (unsigned short)p;
        int län = 0;
        k->getNachrichtEncrypted( (char*)&län, 4 );
        delete[] ip;
        ip = new char[ län + 1 ];
        ip[ län ] = 0;
        k->getNachrichtEncrypted( ip, län );
        if( !trenne( 0 ) )
        {
            zielD->close();
            zielD->release();
            err = "Fehler beim wechseln des Servers: Die Verbindung konnte nicht getrennt werden.";
            cs.unlock();
            return 0;
        }
        if( !verbinde() )
        {
            zielD->close();
            zielD->release();
            err = "Fehler beim wechseln des Servers: Die Verbindung konnte nicht hergestellt werden.";
            cs.unlock();
            return 0;
        }
        zielD->close();
        zielD->release();
        cs.unlock();
        return downloadDatei( gruppe, start, pfad, zielPfad, zFb, abbruch, maxbps );
    }
    int län = textLength( pfad );
    k->sendeEncrypted( (char*)&län, 4 );
    k->sendeEncrypted( pfad, län );
    k->sendeEncrypted( (char*)start, 8 );
    char *bytes = new char[ 2048 ];
    unsigned short byteLän = 0;
    k->getNachricht( (char*)&byteLän, 2 );
    ZeitMesser *zMess = new ZeitMesser();
    zMess->messungStart();
    if( byteLän )
    {
        int bps = 0;
        double sec = 0;
        while( 1 )
        {
            k->getNachricht( bytes, byteLän );
            zielD->schreibe( bytes, byteLän );
            if( zFb )
                zFb->aktionPlus( byteLän );
            ( *start ) += byteLän;
            bps += byteLän;
            if( byteLän == 2048 )
            {
                if( ( *abbruch ) )
                {
                    zielD->close();
                    zielD->release();
                    k->trenne();
                    k = k->release();
                    delete[] bytes;
                    zMess->release();
                    cs.unlock();
                    return 1;
                }
                k->getNachricht( (char*)&byteLän, 2 ); // sendelänge empfangen
                if( !byteLän )
                    break;
            }
            else
                break;
            if( maxbps )
            {
                zMess->messungEnde();
                sec += zMess->getSekunden();
                zMess->messungStart();
                if( sec >= 1 )
                {
                    sec = 0;
                    bps = 0;
                }
                while( bps >= maxbps )
                {
                    Sleep( 10 );
                    zMess->messungEnde();
                    sec += zMess->getSekunden();
                    zMess->messungStart();
                    if( sec >= 1 )
                    {
                        sec = 0;
                        bps = 0;
                    }
                }
            }
        }
    }
    zMess->release();
    delete[] bytes;
    k->sendeEncrypted( "\1", 1 );
    zielD->close();
    zielD->release();
    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 PatchClient::trenne( bool abmelden )
{
    cs.lock();
    verbinde();
    if( !k )
    {
        cs.unlock();
        return 1;
    }
    if( abmelden )
    {
        k->sendeEncrypted( "\4", 1 );
        char ret = 0;
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 3 )
        { // error
            k->getNachrichtEncrypted( &ret, 1 );
            char *msg = new char[ ret + 1 ];
            msg[ ret ] = 0;
            if( ret )
                k->getNachrichtEncrypted( msg, ret );
            err = "error while unregister Client Patch Server returned: ";
            err += msg;
            delete[] msg;
        }
    }
    k->sendeEncrypted( "\3", 1 );
    char ret = 0;
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 3 )
    { // error
        k->getNachrichtEncrypted( &ret, 1 );
        char *msg = new char[ ret + 1 ];
        msg[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( msg, ret );
        err = "error while trenne Patch Server returned: ";
        err += msg;
        delete[] msg;
    }
    k->trenne();
    k = k->release();
    cs.unlock();
    return 1;
}

// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
bool PatchClient::istVerbunden() const
{
    return k != 0;
}

// Gibt die Anzahl von übertragenen Bytes seit dem letzten Aufruf zurück
int PatchClient::getDownload() const
{
    return k ? k->getDownloadBytes( 1 ) : 0;
}

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

// Erhöht den Reference Counter um 1 un gibt this zurück
PatchServerClient *PatchClient::getThis()
{
    ref++;
    return this;
}

// Verringert den Reference Counter um 1 und gibt 0 zurück.
//  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
PatchServerClient *PatchClient::release()
{
    if( !--ref )
        delete this;
    return 0;
}