KartenClient hinzugefügt

KSGNetwork/KSGNetwork.vcxproj

@@ -152,6 +152,7 @@
     <ClInclude Include="ChatClient.h" />
     <ClInclude Include="ErhaltungClient.h" />
     <ClInclude Include="InformationClient.h" />
+    <ClInclude Include="KartenClient.h" />
     <ClInclude Include="Keys.h" />
     <ClInclude Include="LoginClient.h" />
     <ClInclude Include="Main.cpp" />
@@ -166,6 +167,7 @@
     <ClCompile Include="ChatClient.cpp" />
     <ClCompile Include="ErhaltungClient.cpp" />
     <ClCompile Include="InformationClient.cpp" />
+    <ClCompile Include="KartenClient.cpp" />
     <ClCompile Include="Keys.cpp" />
     <ClCompile Include="LoginClient.cpp" />
     <ClCompile Include="MainClient.cpp" />

KSGNetwork/KSGNetwork.vcxproj.filters

@@ -54,6 +54,9 @@
     <ClInclude Include="AnmeldungClient.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
+    <ClInclude Include="KartenClient.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="MainClient.cpp">
@@ -89,5 +92,8 @@
     <ClCompile Include="AnmeldungClient.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
+    <ClCompile Include="KartenClient.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

KSGNetwork/KartenClient.cpp

@@ -0,0 +1,529 @@
+#include "KartenClient.h"
+#include "Keys.h"
+#include <Klient.h>
+#include <Datei.h>
+#include <Globals.h>
+
+using namespace KSGClient;
+
+// Inhalt der KartenClient Klasse
+
+// Konstruktor
+KartenClient::KartenClient( 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
+KartenClient::~KartenClient()
+{
+    trenne( 1 );
+    delete[] key;
+}
+
+// verbindet sich mit dem zugewiesenen Karten Server
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool KartenClient::verbinde()
+{
+    cs.lock();
+    if( k )
+    {
+        cs.unlock();
+        return 1;
+    }
+    k = new Network::Klient();
+    int l = 0;
+    char *key;
+    Keys::getServerKey( &key, l, Keys::KARTEN, Keys::SENDEN );
+    k->setSendeKey( key, l );
+    delete[] key;
+    Keys::getServerKey( &key, l, Keys::KARTEN, 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 Karten 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 Karten Server";
+            k = k->release();
+            cs.unlock();
+            return 0;
+        }
+    }
+    else
+    {
+        err = "network error while connecting to Karten Server";
+        k = k->release();
+        cs.unlock();
+        return 0;
+    }
+    cs.unlock();
+    return 1;
+}
+
+// lädt eine Karte herunter und speichert sie unter data/tmp/Karten/{id}/spiel
+//  id: Die Id der Karte
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool KartenClient::downloadKarte( int id )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x6", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( (char*)&id, 4 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 2 )
+        { // update
+            err = "Die Karte wird momentan aktualisiert.";
+            cs.unlock();
+            return 0;
+        }
+        else if( ret == 1 )
+        {
+            int anz = 0;
+            k->getNachrichtEncrypted( (char*)&anz, 4 );
+            for( int i = 0; i < anz; i++ )
+            {
+                char län = 0;
+                k->getNachrichtEncrypted( &län, 1 );
+                if( !län )
+                    continue;
+                char *pf = new char[ län + 1 ];
+                pf[ län ] = 0;
+                k->getNachrichtEncrypted( pf, län );
+                __int64 größe = 0;
+                k->getNachrichtEncrypted( (char*)&größe, 8 );
+                char *buffer = new char[ 2048 ];
+                Text pfad = "data/tmp/Karten/";
+                pfad += id;
+                pfad += "/spiel";
+                pfad += pf;
+                delete[] pf;
+                Datei d;
+                d.setDatei( pfad );
+                d.erstellen();
+                d.open( Datei::Style::schreiben );
+                while( größe )
+                {
+                    int l = größe >= 2048 ? 2048 : (int)größe;
+                    k->getNachricht( buffer, l );
+                    d.schreibe( buffer, l );
+                    größe -= l;
+                }
+                d.close();
+                delete[] buffer;
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    cs.unlock();
+    return 1;
+}
+
+// lädt das Titelbild Karte herunter und speichert es unter data/tmp/Karten/{id}/titel.ltdb
+//  id: Die Id der Karte
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool KartenClient::downloadKarteTitel( int id )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x8", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( (char*)&id, 4 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 2 )
+        { // update
+            err = "Die Karte wird momentan aktualisiert.";
+            cs.unlock();
+            return 0;
+        }
+        else if( ret == 1 )
+        {
+            __int64 größe = 0;
+            k->getNachrichtEncrypted( (char*)&größe, 8 );
+            char *buffer = new char[ 2048 ];
+            Text pfad = "data/tmp/Karten/";
+            pfad += id;
+            pfad += "/titel.ltdb";
+            Datei d;
+            d.setDatei( pfad );
+            d.erstellen();
+            d.open( Datei::Style::schreiben );
+            while( größe )
+            {
+                int l = größe >= 2048 ? 2048 : (int)größe;
+                k->getNachricht( buffer, l );
+                d.schreibe( buffer, l );
+                größe -= l;
+            }
+            d.close();
+            delete[] buffer;
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    cs.unlock();
+    return 1;
+}
+
+// lädt die Beschreibung Karte herunter und speichert sie unter data/tmp/Karten/{id}/beschreibung.ksgs
+//  id: Die Id der Karte
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool KartenClient::downloadKarteBeschreibung( int id )
+{
+    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 == 1 )
+    {
+        k->sendeEncrypted( (char*)&id, 4 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 2 )
+        { // update
+            err = "Die Karte wird momentan aktualisiert.";
+            cs.unlock();
+            return 0;
+        }
+        else if( ret == 1 )
+        {
+            __int64 größe = 0;
+            k->getNachrichtEncrypted( (char*)&größe, 8 );
+            char *buffer = new char[ 2048 ];
+            Text pfad = "data/tmp/Karten/";
+            pfad += id;
+            pfad += "/beschreibung.ksgs";
+            Datei d;
+            d.setDatei( pfad );
+            d.erstellen();
+            d.open( Datei::Style::schreiben );
+            while( größe )
+            {
+                int l = größe >= 2048 ? 2048 : (int)größe;
+                k->getNachricht( buffer, l );
+                d.schreibe( buffer, l );
+                größe -= l;
+            }
+            d.close();
+            delete[] buffer;
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    cs.unlock();
+    return 1;
+}
+
+// lädt die Minimap Karte herunter und speichert es unter data/tmp/Karten/{id}/minimap.ltdb
+//  id: Die Id der Karte
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool KartenClient::downloadKarteMinimap( int id )
+{
+    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 == 1 )
+    {
+        k->sendeEncrypted( (char*)&id, 4 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 2 )
+        { // update
+            err = "Die Karte wird momentan aktualisiert.";
+            cs.unlock();
+            return 0;
+        }
+        else if( ret == 1 )
+        {
+            __int64 größe = 0;
+            k->getNachrichtEncrypted( (char*)&größe, 8 );
+            char *buffer = new char[ 2048 ];
+            Text pfad = "data/tmp/Karten/";
+            pfad += id;
+            pfad += "/minimap.ltdb";
+            Datei d;
+            d.setDatei( pfad );
+            d.erstellen();
+            d.open( Datei::Style::schreiben );
+            while( größe )
+            {
+                int l = größe >= 2048 ? 2048 : (int)größe;
+                k->getNachricht( buffer, l );
+                d.schreibe( buffer, l );
+                größe -= l;
+            }
+            d.close();
+            delete[] buffer;
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    cs.unlock();
+    return 1;
+}
+
+// lädt das Ladebild Karte herunter und speichert es unter data/tmp/Karten/{id}/ladebild.ltdb
+//  id: Die Id der Karte
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool KartenClient::downloadKarteLadebild( int id )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\xB", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( (char*)&id, 4 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 2 )
+        { // update
+            err = "Die Karte wird momentan aktualisiert.";
+            cs.unlock();
+            return 0;
+        }
+        else if( ret == 1 )
+        {
+            __int64 größe = 0;
+            k->getNachrichtEncrypted( (char*)&größe, 8 );
+            char *buffer = new char[ 2048 ];
+            Text pfad = "data/tmp/Karten/";
+            pfad += id;
+            pfad += "/ladebild.ltdb";
+            Datei d;
+            d.setDatei( pfad );
+            d.erstellen();
+            d.open( Datei::Style::schreiben );
+            while( größe )
+            {
+                int l = größe >= 2048 ? 2048 : (int)größe;
+                k->getNachricht( buffer, l );
+                d.schreibe( buffer, l );
+                größe -= l;
+            }
+            d.close();
+            delete[] buffer;
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    cs.unlock();
+    return 1;
+}
+
+// Erhält die Verbindung aufrecht
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+bool KartenClient::keepAlive()
+{
+    if( !k )
+        return 0;
+    char res = 0;
+    if( !cs.tryLock() )
+        return 1;
+    Framework::logLine( (char*)"Verbindungstest zum Karten Server..." );
+    bool ok = k->sendeEncrypted( "\x5", 1 );
+    ok &= k->getNachrichtEncrypted( &res, 1 );
+    cs.unlock();
+    if( res != 1 || !ok )
+    {
+        Framework::logLine( ( char* )"Verbindungsabbruch." );
+        trenne( 0 );
+        err = "Verbindung unterbrochen: 'Keep Alive' nicht erfolgreich.";
+    }
+    else
+        Framework::logLine( ( char* )"Verbindung besteht." );
+    return res == 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 KartenClient::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 Karten 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 Karten 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 KartenClient::istVerbunden() const
+{
+    return k != 0;
+}
+
+// gibt den Letzten Fehlertext zuück
+//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+char *KartenClient::getLetzterFehler() const
+{
+    return err;
+}
+
+// Erhöht den Reference Counter um 1 un gibt this zurück
+KartenServerClient *KartenClient::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 
+KartenServerClient *KartenClient::release()
+{
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
+}

KSGNetwork/KartenClient.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include "../Include/KSGNetwork.h"
+#include <Critical.h>
+
+namespace KSGClient
+{
+    // Wird verwendet um die aktuellen versionen der Karten vor dem Spiel herunterzuladen
+    //  Kann nur von eingeloggten Clients verwendet werden
+    class KartenClient : public KartenServerClient
+    {
+    private:
+        int ref;
+        Framework::Text ip;
+        unsigned short port;
+        int cId;
+        Network::Klient *k;
+        char *key;
+        unsigned char keyLen;
+        Framework::Critical cs;
+        Framework::Text err;
+
+    public:
+        // Konstruktor
+        KartenClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
+        // Destruktor
+        ~KartenClient();
+        // verbindet sich mit dem zugewiesenen Karten Server
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool verbinde() override;
+        // lädt eine Karte herunter und speichert sie unter data/tmp/Karten/{id}/spiel
+        //  id: Die Id der Karte
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool downloadKarte( int id ) override;
+        // lädt das Titelbild Karte herunter und speichert es unter data/tmp/Karten/{id}/titel.ltdb
+        //  id: Die Id der Karte
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool downloadKarteTitel( int id ) override;
+        // lädt die Beschreibung Karte herunter und speichert sie unter data/tmp/Karten/{id}/beschreibung.ksgs
+        //  id: Die Id der Karte
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool downloadKarteBeschreibung( int id ) override;
+        // lädt die Minimap Karte herunter und speichert es unter data/tmp/Karten/{id}/minimap.ltdb
+        //  id: Die Id der Karte
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool downloadKarteMinimap( int id ) override;
+        // lädt das Ladebild Karte herunter und speichert es unter data/tmp/Karten/{id}/ladebild.ltdb
+        //  id: Die Id der Karte
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool downloadKarteLadebild( int id ) override;
+        // Erhält die Verbindung aufrecht
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+        bool keepAlive() override;
+        // 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 trenne( bool abmelden ) override;
+        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+        bool istVerbunden() const override;
+        // gibt den Letzten Fehlertext zuück
+        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+        char *getLetzterFehler() const override;
+        // Erhöht den Reference Counter um 1 un gibt this zurück
+        KartenServerClient *getThis() override;
+        // 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 
+        KartenServerClient *release() override;
+    };
+}