Erhaltung Server Client hinzugefügt

Include/KSGNetwork.h

@@ -210,7 +210,7 @@ namespace KSGClient
     };
 
     // Wird benutzt, um die Verbindung mit den Servern aufrecht zu erhalten. Bei einem Verbindungsabbruch wird der Client automatisch abgemeldet
-    class ErhaltungServerClient : protected Framework::Thread
+    class ErhaltungServerClient : protected virtual Framework::Thread
     {
     protected:
         // DBeantwortet Ping - Anfragen des Servers. Falls diese 60 Sekunden lang unbeantwortet bleiben, wird der Client vom Serversystem abgemeldet
@@ -225,6 +225,9 @@ namespace KSGClient
         //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
         //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
         virtual bool trenne() = 0;
+        // gibt den Letzten Fehlertext zuück
+        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+        virtual char *getLetzterFehler() const = 0;
         // Erhöht den Reference Counter um 1 un gibt this zurück
         virtual ErhaltungServerClient *getThis() = 0;
         // Verringert den Reference Counter um 1 und gibt 0 zurück.
@@ -1373,7 +1376,7 @@ namespace KSGClient
     {
     public:
         // Meldet den neuen Client beim Serversystem an. Durch diesen Vorgang erhält der Client eine Id und den Port und die Ip Addresse des Main Servers
-        virtual bool registerSSL( Framework::Text *ip, unsigned short port ) = 0;
+        virtual bool registerSSL( char *ip, unsigned short port ) = 0;
         // Verbindet den Client mit dem Server
         //  Wird automatisch aufgerufen, falls eine Methode aufgerufen wird, die eine Verbindung erfordert. In diesem Fall wird die Verbindung auch automatisch wieder getrennt.
         virtual bool connect() = 0;
@@ -1420,19 +1423,19 @@ namespace KSGClient
         // Gibt den Port des dem Client zugewiesenen Main Servers zurück.
         //  sollte erst nach dem Aufruf von registerSSL verwendet werden.
         virtual unsigned short getServerPort() const = 0;
+        // Gibt den Zeiger auf den Schlüssel zurück
+        //  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+        virtual char *zKey() const = 0;
+        // Gibt die Länge des Schlüssels zurück
+        //  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+        virtual unsigned char getKeyLen() const = 0;
+        // gibt den Letzten Fehlertext zuück
+        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+        virtual char *getLetzterFehler() const = 0;
+        // Erhöht den Reference Counter um 1 un gibt this zurück
+        virtual MainServerClient *getThis() = 0;
+        // 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 
+        virtual MainServerClient *release() = 0;
     };
-
-    extern "C"
-    {
-        // Einstiegspunkte in die Bibliothek
-
-        // Erzeugt einen neuen Client beim Serversystem.
-        //  registerSSL Methode muss aufgerufen werden um den Client beim Serversystem anzumelden
-        MainServerClient *createMainServerClient();
-        // Erzeugt einen Client, der bereits beim Serversystem angemeldet ist
-        //  ip: Die Ip des Main Servers für angemeldete Clients
-        //  port: Der Port des Main Servers für angemeldete Clients
-        //  klientId: Die Id die der Client durch das Anmelden bekommen hat
-        MainServerClient *createMainServerClient( char *ip, unsigned short port, int klientId );
-    }
 }

KSGNetwork/ErhaltungClient.cpp

@@ -0,0 +1,170 @@
+#include "ErhaltungClient.h"
+#include <Klient.h>
+#include "Keys.h"
+
+using namespace KSGClient;
+
+// Inhalt der ErhaltungClient Klasse
+
+// Konstruktor
+ErhaltungClient::ErhaltungClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
+    : Thread()
+{
+    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;
+    abmel = 0;
+    trenn = 0;
+}
+
+// Destruktor
+ErhaltungClient::~ErhaltungClient()
+{
+    if( k )
+    {
+        abmelden();
+        trenne();
+    }
+    warteAufThread( 10000 );
+    ende();
+    if( k )
+        k->release();
+    delete[] key;
+}
+
+// DBeantwortet Ping - Anfragen des Servers. Falls diese 60 Sekunden lang unbeantwortet bleiben, wird der Client vom Serversystem abgemeldet
+void ErhaltungClient::thread()
+{
+    while( 1 )
+    {
+        char n = 0;
+        k->getNachrichtEncrypted( &n, 1 );
+        if( n != 1 )
+        {
+            Sleep( 250 );
+            continue;
+        }
+        if( trenn )
+        {
+            if( abmel )
+            {
+                k->sendeEncrypted( "\1", 1 );
+                k->getNachrichtEncrypted( &n, 1 );
+            }
+            k->trenne();
+            run = 0;
+            return;
+        }
+        else
+            k->sendeEncrypted( "\0", 1 );
+    }
+}
+
+// verbindet ich mit dem Erhaltung Server
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool ErhaltungClient::verbinde()
+{
+    cs.lock();
+    if( k )
+    {
+        cs.unlock();
+        return 1;
+    }
+    k = new Network::Klient();
+    int l = 0;
+    char *key;
+    Keys::getServerKey( &key, l, Keys::ERHALTUNG, Keys::SENDEN );
+    k->setSendeKey( key, l );
+    delete[] key;
+    Keys::getServerKey( &key, l, Keys::ERHALTUNG, 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 );
+            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 identifyin client Erhaltung Server returned: ";
+                err += f;
+                delete[]f;
+                k->sendeEncrypted( "\3", 1 );
+                k->getNachrichtEncrypted( &serverReturn, 1 );
+                k->trenne();
+                k = k->release();
+                cs.unlock();
+                return 0;
+            }
+            k->setSendeKey( (char*)this->key, keyLen );
+            k->setEmpfangKey( (char*)this->key, keyLen );
+            start();
+        }
+        else
+        {
+            err = "network error while sending to Erhaltung Server";
+            k = k->release();
+            cs.unlock();
+            return 0;
+        }
+    }
+    else
+    {
+        err = "network error while connecting to Erhaltung Server";
+        k = k->release();
+        cs.unlock();
+        return 0;
+    }
+    cs.unlock();
+    return 1;
+}
+
+// Meldet sich beim Server ab und trennt die Verbindung
+void ErhaltungClient::abmelden()
+{
+    abmel = 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 ErhaltungClient::trenne()
+{
+    trenn = 1;
+}
+
+// gibt den Letzten Fehlertext zuück
+//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+char *ErhaltungClient::getLetzterFehler() const
+{
+    return err;
+}
+
+// Erhöht den Reference Counter um 1 un gibt this zurück
+ErhaltungServerClient *ErhaltungClient::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 
+ErhaltungServerClient *ErhaltungClient::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

KSGNetwork/ErhaltungClient.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "../Include/KSGNetwork.h"
+#include <Critical.h>
+
+namespace KSGClient
+{
+    class ErhaltungClient : public ErhaltungServerClient
+    {
+    private:
+        int ref;
+        Framework::Text ip;
+        unsigned short port;
+        int cId;
+        Network::Klient *k;
+        char *key;
+        unsigned char keyLen;
+        Framework::Critical cs;
+        Text err;
+        bool abmel;
+        bool trenn;
+
+        // DBeantwortet Ping - Anfragen des Servers. Falls diese 60 Sekunden lang unbeantwortet bleiben, wird der Client vom Serversystem abgemeldet
+        void thread() override;
+
+    public:
+        // Konstruktor
+        ErhaltungClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
+        // Destruktor
+        ~ErhaltungClient();
+        // verbindet ich mit dem Erhaltung Server
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool verbinde() override;
+        // Meldet sich beim Server ab und trennt die Verbindung
+        void abmelden() 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() 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
+        ErhaltungServerClient *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 
+        ErhaltungServerClient *release() override;
+    };
+}

KSGNetwork/KSGNetwork.vcxproj

@@ -146,9 +146,16 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClInclude Include="..\Include\KSGNetwork.h" />
-    <ClInclude Include="Main.h" />
+    <ClInclude Include="ErhaltungClient.h" />
+    <ClInclude Include="Keys.h" />
+    <ClInclude Include="Main.cpp" />
     <ClInclude Include="MainClient.h" />
   </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="ErhaltungClient.cpp" />
+    <ClCompile Include="Keys.cpp" />
+    <ClCompile Include="MainClient.cpp" />
+  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>

KSGNetwork/KSGNetwork.vcxproj.filters

@@ -15,14 +15,31 @@
     </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="Main.h">
-      <Filter>Quelldateien</Filter>
-    </ClInclude>
     <ClInclude Include="MainClient.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
     <ClInclude Include="..\Include\KSGNetwork.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
+    <ClInclude Include="Main.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Keys.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="ErhaltungClient.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="MainClient.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Keys.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="ErhaltungClient.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

KSGNetwork/Keys.cpp

@@ -0,0 +1,25 @@
+#include "Keys.h"
+
+void Keys::getServerKey( char **key, int &length, Keys::Server sTyp, Keys::Key kTyp )
+{
+    unsigned char keys[][ 20 ] = {
+        { 199, 164, 172, 55, 246, 16, 155, 8, 151, 176, 250, 181, 227, 133, 30, 41, 200, 26, 7, 151 }, // Main
+    { 158, 10, 37, 155, 117, 58, 28, 197, 132, 76, 252, 83, 84, 222, 11, 125, 240, 218, 25, 201 }, // Anmeldung
+    { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 }, // Chat
+    { 55, 124, 19, 204, 23, 5, 59, 75, 247, 138, 119, 111, 57, 250, 206, 187, 165, 6, 247, 151 }, // Editor
+    { 207, 30, 72, 46, 30, 50, 56, 213, 82, 107, 14, 201, 149, 58, 110, 138, 228, 241, 52, 54 }, // Historie
+    { 231, 246, 125, 32, 88, 172, 229, 223, 246, 138, 74, 64, 142, 245, 217, 218, 162, 62, 103, 50 }, // Information
+    { 24, 15, 53, 87, 38, 73, 154, 38, 246, 90, 39, 133, 11, 199, 22, 80, 26, 132, 95, 54 }, // Karten
+    { 143, 166, 245, 235, 76, 75, 116, 80, 26, 178, 142, 176, 109, 53, 106, 222, 223, 55, 139, 111 }, // Login
+    { 4, 150, 243, 145, 204, 71, 253, 88, 4, 51, 189, 207, 189, 248, 231, 40, 106, 7, 182, 5 }, // News
+    { 186, 186, 179, 126, 216, 207, 123, 154, 168, 149, 51, 221, 6, 193, 160, 141, 164, 126, 44, 242 }, // Register
+    { 218, 226, 231, 216, 68, 63, 132, 155, 49, 235, 239, 0, 19, 23, 116, 244, 235, 21, 189, 53 }, // Shop
+    { 253, 234, 211, 132, 121, 230, 95, 145, 201, 13, 43, 77, 153, 223, 253, 69, 234, 43, 52, 99 }, // Spiel
+    {}, // Patch
+    { 207, 242, 142, 161, 148, 107, 131, 33, 172, 68, 91, 169, 81, 106, 69, 131, 207, 56, 166, 248 } // Erhaltung
+    };
+    length = 20;
+    *key = new char[ 20 ];
+    for( int i = 0; i < 20; i++ )
+        ( *key )[ i ] = keys[ sTyp ][ i ];
+}

KSGNetwork/Keys.h

@@ -0,0 +1,38 @@
+#pragma once
+
+class Keys
+{
+public:
+    // Servertypen
+    enum Server
+    {
+        MAIN = 0,
+        ANMELDUNG = 1,
+        CHAT = 2,
+        EDITOR = 3,
+        HISTORIE = 4,
+        INFORMATION = 5,
+        KARTEN = 6,
+        LOGIN = 7,
+        NEWS = 8,
+        REGISTER = 9,
+        SHOP = 10,
+        SPIEL = 11,
+        PATCH = 12,
+        ERHALTUNG = 13
+    };
+
+    // Keytypen
+    enum Key
+    {
+        EMPFANGEN = 0,
+        SENDEN = 0
+    };
+
+    // Gibt den Schlüssel eines Servers zurück
+    //  key: Ein Zeiger auf ein array von bytes. Wird als ausgabe verwendet. Enthält nach aufruf den gewünschten Key
+    //  length: Enthält nach aufruf die Länge des Schlüssels
+    //  sTyp: Der Servertyp, zu dem der Schlüssel ermittelt werden soll
+    //  kTyp: Die art des Schlüssels der ermittelt werden soll
+    static void getServerKey( char **key, int &length, Server sTyp, Key kTyp );
+};

KSGNetwork/Main.cpp

@@ -0,0 +1,23 @@
+#include "MainClient.h"
+
+using namespace KSGClient;
+
+extern "C"
+{
+    // Einstiegspunkte in die Bibliothek
+
+    // Erzeugt einen neuen Client beim Serversystem.
+    //  registerSSL Methode muss aufgerufen werden um den Client beim Serversystem anzumelden
+    MainServerClient *createMainServerClient()
+    {
+        return new MainClient();
+    }
+    // Erzeugt einen Client, der bereits beim Serversystem angemeldet ist
+    //  ip: Die Ip des Main Servers für angemeldete Clients
+    //  port: Der Port des Main Servers für angemeldete Clients
+    //  klientId: Die Id die der Client durch das Anmelden bekommen hat
+    MainServerClient *createMainServerClient( char *ip, unsigned short port, int klientId, char *key, unsigned char keyLen )
+    {
+        return new MainClient( ip, port, klientId, key, keyLen );
+    }
+}

KSGNetwork/Main.h

@@ -1 +0,0 @@
-#pragma once

KSGNetwork/MainClient.cpp

@@ -0,0 +1,383 @@
+#include "MainClient.h"
+#include <Klient.h>
+#include "Keys.h"
+#include "ErhaltungClient.h"
+
+using namespace KSGClient;
+
+// Inhalt der MainClient Klasse
+
+// Konstruktor
+MainClient::MainClient()
+{
+    ref = 1;
+    port = 0;
+    cId = 0;
+    k = 0;
+    key = 0;
+    keyLen = 0;
+}
+
+MainClient::MainClient( char *ip, unsigned short port, int klientId, char *key, unsigned char keyLen )
+{
+    ref = 1;
+    this->ip = ip;
+    this->port = port;
+    cId = klientId;
+    k = 0;
+    this->keyLen = keyLen;
+    this->key = new char[ keyLen ];
+    memcpy( this->key, key, keyLen );
+}
+
+// Destruktor
+MainClient::~MainClient()
+{
+    delete[]key;
+    if( k )
+        disconnect();
+}
+
+// Meldet den neuen Client beim Serversystem an. Durch diesen Vorgang erhält der Client eine Id und den Port und die Ip Addresse des Main Servers
+bool MainClient::registerSSL( char *ip, unsigned short port )
+{
+    cs.lock();
+    if( cId )
+    {
+        cs.unlock();
+        return 0;
+    }
+    Network::SSLKlient *klientSSL = new Network::SSLKlient();
+    int l = 0;
+    if( !klientSSL->verbinde( port, ip ) )
+    {
+        err = "error while trying to connect to Main SSL Server";
+        klientSSL->release();
+        cs.unlock();
+        return 0;
+    }
+    klientSSL->sende( "\1", 5 );
+    char byte = 0;
+    klientSSL->getNachricht( &byte, 1 );
+    if( byte == 3 )
+    {
+        klientSSL->getNachricht( &byte, 1 );
+        char *message = new char[ byte + 1 ];
+        message[ byte ] = 0;
+        klientSSL->getNachricht( message, byte );
+        err = "error while register new client server returned: ";
+        err += message;
+        delete[]message;
+        klientSSL->sende( "\3", 1 );
+        klientSSL->getNachricht( &byte, 1 );
+        klientSSL->trenne();
+        klientSSL->release();
+        cs.unlock();
+        return 0;
+    }
+    if( byte == 1 )
+    {
+        klientSSL->getNachricht( (char*)&this->port, 4 );
+        klientSSL->getNachricht( (char*)&cId, 4 );
+        klientSSL->getNachricht( (char*)&keyLen, 1 );
+        this->ip = ip;
+        if( keyLen )
+        {
+            key = new char[ keyLen ];
+            klientSSL->getNachricht( key, keyLen );
+        }
+    }
+    klientSSL->sende( "\3", 1 );
+    klientSSL->getNachricht( &byte, 1 );
+    klientSSL->trenne();
+    klientSSL->release();
+    cs.unlock();
+    return 1;
+}
+
+// Verbindet den Client mit dem Server
+//  Wird automatisch aufgerufen, falls eine Methode aufgerufen wird, die eine Verbindung erfordert. In diesem Fall wird die Verbindung auch automatisch wieder getrennt.
+bool MainClient::connect()
+{
+    cs.lock();
+    if( k )
+    {
+        cs.unlock();
+        return 1;
+    }
+    k = new Network::Klient();
+    int l = 0;
+    char *key;
+    Keys::getServerKey( &key, l, Keys::MAIN, Keys::SENDEN );
+    k->setSendeKey( key, l );
+    delete[] key;
+    Keys::getServerKey( &key, l, Keys::MAIN, Keys::EMPFANGEN );
+    k->setEmpfangKey( key, l );
+    delete[] key;
+    if( !k->verbinde( port, ip ) )
+    {
+        err = "error while trying to connect to Main Server";
+        k = k->release();
+        cs.unlock();
+        return 0;
+    }
+    k->sende( "\0", 1 ); // Verschlüsselung aktivieren
+    k->sendeEncrypted( "\1", 1 );
+    k->sendeEncrypted( (char*)&cId, 4 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 3 )
+    {
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        char *message = new char[ serverReturn + 1 ];
+        message[ serverReturn ] = 0;
+        k->getNachrichtEncrypted( message, serverReturn );
+        err = "error while trying to identify registered client server returned: ";
+        err += message;
+        delete[] message;
+        k->sendeEncrypted( "\3", 1 );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        k->trenne();
+        k = k->release();
+        cs.unlock();
+        return 0;
+    }
+    else
+    {
+        k->setSendeKey( this->key, keyLen );
+        k->setEmpfangKey( this->key, keyLen );
+        cs.unlock();
+        return 1;
+    }
+}
+
+// Erzeugt einen Erhaltungs Server Client
+//  Gibt bei misserfolg 0 zurück
+ErhaltungServerClient *MainClient::createErhaltungServerClient()
+{
+    cs.lock();
+    bool connected = k != 0;
+    if( !connected )
+        connect();
+    if( !k )
+    {
+        err = "no connection to Main Server";
+        return 0;
+    }
+    k->sendeEncrypted( "\6\x8", 2 );
+    char byte = 0;
+    k->getNachrichtEncrypted( &byte, 1 );
+    if( byte == 2 )
+    {
+        unsigned char lsIp[ 4 ];
+        k->getNachrichtEncrypted( (char *)lsIp, 4 );
+        unsigned short lsPort = 0;
+        k->getNachrichtEncrypted( (char*)&lsPort, 2 );
+        Framework::Text ipT;
+        ipT += (int)lsIp[ 0 ];
+        ipT += ".";
+        ipT += (int)lsIp[ 1 ];
+        ipT += ".";
+        ipT += (int)lsIp[ 2 ];
+        ipT += ".";
+        ipT += (int)lsIp[ 3 ];
+        if( !connected )
+            disconnect();
+        cs.unlock();
+        return new ErhaltungClient( cId, lsPort, ipT, key, keyLen );
+    }
+    else if( byte == 3 )
+    {
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = "error while requesting ErhaltungServer server returned: ";
+        err += f;
+        delete[]f;
+    }
+    if( !connected )
+        disconnect();
+    cs.unlock();
+    return 0;
+}
+
+// Erzeugt einen Patch Server Client
+//  Gibt bei misserfolg 0 zurück
+PatchServerClient *MainClient::createPatchServerClient()
+{
+
+}
+
+// Erzeugt einen News Server Client
+//  Gibt bei misserfolg 0 zurück
+NewsServerClient *MainClient::createNewsServerClient()
+{
+
+}
+
+// Erzeugt einen Register Server Client
+//  Gibt bei misserfolg 0 zurück
+RegisterServerClient *MainClient::createRegisterServerClient()
+{
+
+}
+
+// Erzeugt einen Login Server Client
+//  Gibt bei misserfolg 0 zurück
+LoginServerClient *MainClient::createLoginServerClient()
+{
+
+}
+
+// Erzeugt einen Information Server Client
+//  Gibt bei misserfolg 0 zurück
+InformationServerClient *MainClient::createInformationServerClient()
+{
+
+}
+
+// Erzeugt einen Chat Server Client
+//  Gibt bei misserfolg 0 zurück
+ChatServerClient *MainClient::createChatServerClient()
+{
+
+}
+
+// Erzeugt einen Shop Server Client
+//  Gibt bei misserfolg 0 zurück
+ShopServerClient *MainClient::createShopServerClient()
+{
+
+}
+
+// Erzeugt einen Anmeldung Server Client
+//  Gibt bei misserfolg 0 zurück
+AnmeldungServerClient *MainClient::createAnmeldungServerClient()
+{
+
+}
+
+// Erzeugt einen Minigame Server Client
+//  Gibt bei misserfolg 0 zurück
+MinigameServerClient *MainClient::createMinigameServerClient()
+{
+
+}
+
+// Trennt die Verbindung zum Server. Muss nur aufgerufen werden, wenn vorher manuell connect aufgerufen wurde
+bool MainClient::disconnect()
+{
+    cs.lock();
+    if( !k )
+    {
+        cs.unlock();
+        return 1;
+    }
+    char serverReturn = 0;
+    k->sendeEncrypted( "\3", 1 );
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    k->trenne();
+    k = k->release();
+    cs.unlock();
+    return 1;
+}
+
+// Meldet den Client vom Server ab. Alle zuvor von diesem Client erzeugten Clients werden durch diesen Vorgang unbrauchbar
+bool MainClient::unregister()
+{
+    cs.lock();
+    bool connected = k != 0;
+    if( !connected )
+        connect();
+    if( !k )
+    {
+        err = "no connection to Main Server";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\7", 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 3 )
+    {
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        char *message = new char[ serverReturn + 1 ];
+        message[ serverReturn ] = 0;
+        k->getNachrichtEncrypted( message, serverReturn );
+        err = "error while trying to unregistere client server returned: ";
+        err += message;
+        delete[] message;
+        if( !connected )
+            disconnect();
+        cs.unlock();
+        return 0;
+    }
+    disconnect();
+    cId = 0;
+    delete key;
+    key = 0;
+    keyLen = 0;
+    port = 0;
+    ip = "";
+    cs.unlock();
+    return 1;
+}
+
+// Gibt die dem Client zugewiesene Id zurück.
+//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+int MainClient::getClientId() const
+{
+    return cId;
+}
+
+// Gibt die Ip Adresse des dem Client zugewiesenen Main Servers zurück.
+//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+Framework::Text *MainClient::getServerIp() const
+{
+    return new Text( ip.getText() );
+}
+
+// Gibt den Port des dem Client zugewiesenen Main Servers zurück.
+//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+unsigned short MainClient::getServerPort() const
+{
+    return port;
+}
+
+// Gibt den Zeiger auf den Schlüssel zurück
+//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+char *MainClient::zKey() const
+{
+    return key;
+}
+
+// Gibt die Länge des Schlüssels zurück
+//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+unsigned char MainClient::getKeyLen() const
+{
+    return keyLen;
+}
+
+// gibt den Letzten Fehlertext zuück
+//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+char *MainClient::getLetzterFehler() const
+{
+    return err;
+}
+
+// Erhöht den Reference Counter um 1 un gibt this zurück
+MainServerClient *MainClient::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 
+MainServerClient *MainClient::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

KSGNetwork/MainClient.h

@@ -1 +1,90 @@
 #pragma once
+
+#include "../Include/KSGNetwork.h"
+#include <Critical.h>
+
+namespace KSGClient
+{
+    class MainClient : public MainServerClient
+    {
+    private:
+        int ref;
+        Framework::Text ip;
+        unsigned short port;
+        int cId;
+        Network::Klient *k;
+        char *key;
+        unsigned char keyLen;
+        Framework::Critical cs;
+        Text err;
+
+    public:
+        // Konstruktor
+        MainClient();
+        MainClient( char *ip, unsigned short port, int klientId, char *key, unsigned char keyLen );
+        // Destruktor
+        ~MainClient();
+        // Meldet den neuen Client beim Serversystem an. Durch diesen Vorgang erhält der Client eine Id und den Port und die Ip Addresse des Main Servers
+        bool registerSSL( char *ip, unsigned short port ) override;
+        // Verbindet den Client mit dem Server
+        //  Wird automatisch aufgerufen, falls eine Methode aufgerufen wird, die eine Verbindung erfordert. In diesem Fall wird die Verbindung auch automatisch wieder getrennt.
+        bool connect() override;
+        // Erzeugt einen Erhaltungs Server Client
+        //  Gibt bei misserfolg 0 zurück
+        ErhaltungServerClient *createErhaltungServerClient() override;
+        // Erzeugt einen Patch Server Client
+        //  Gibt bei misserfolg 0 zurück
+        PatchServerClient *createPatchServerClient() override;
+        // Erzeugt einen News Server Client
+        //  Gibt bei misserfolg 0 zurück
+        NewsServerClient *createNewsServerClient() override;
+        // Erzeugt einen Register Server Client
+        //  Gibt bei misserfolg 0 zurück
+        RegisterServerClient *createRegisterServerClient() override;
+        // Erzeugt einen Login Server Client
+        //  Gibt bei misserfolg 0 zurück
+        LoginServerClient *createLoginServerClient() override;
+        // Erzeugt einen Information Server Client
+        //  Gibt bei misserfolg 0 zurück
+        InformationServerClient *createInformationServerClient() override;
+        // Erzeugt einen Chat Server Client
+        //  Gibt bei misserfolg 0 zurück
+        ChatServerClient *createChatServerClient() override;
+        // Erzeugt einen Shop Server Client
+        //  Gibt bei misserfolg 0 zurück
+        ShopServerClient *createShopServerClient() override;
+        // Erzeugt einen Anmeldung Server Client
+        //  Gibt bei misserfolg 0 zurück
+        AnmeldungServerClient *createAnmeldungServerClient() override;
+        // Erzeugt einen Minigame Server Client
+        //  Gibt bei misserfolg 0 zurück
+        MinigameServerClient *createMinigameServerClient() override;
+        // Trennt die Verbindung zum Server. Muss nur aufgerufen werden, wenn vorher manuell connect aufgerufen wurde
+        bool disconnect() override;
+        // Meldet den Client vom Server ab. Alle zuvor von diesem Client erzeugten Clients werden durch diesen Vorgang unbrauchbar
+        bool unregister() override;
+        // Gibt die dem Client zugewiesene Id zurück.
+        //  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+        int getClientId() const override;
+        // Gibt die Ip Adresse des dem Client zugewiesenen Main Servers zurück.
+        //  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+        Framework::Text *getServerIp() const override;
+        // Gibt den Port des dem Client zugewiesenen Main Servers zurück.
+        //  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+        unsigned short getServerPort() const override;
+        // Gibt den Zeiger auf den Schlüssel zurück
+        //  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+        char *zKey() const override;
+        // Gibt die Länge des Schlüssels zurück
+        //  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+        unsigned char getKeyLen() 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
+        MainServerClient *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 
+        MainServerClient *release() override;
+    };
+}