RegisterClient hinzugefügt

KSGNetwork/KSGNetwork.vcxproj

@@ -154,6 +154,7 @@
     <ClInclude Include="MainClient.h" />
     <ClInclude Include="NewsClient.h" />
     <ClInclude Include="PatchClient.h" />
+    <ClInclude Include="RegisterServer.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="ErhaltungClient.cpp" />
@@ -161,6 +162,7 @@
     <ClCompile Include="MainClient.cpp" />
     <ClCompile Include="NewsClient.cpp" />
     <ClCompile Include="PatchClient.cpp" />
+    <ClCompile Include="RegisterServer.cpp" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

KSGNetwork/KSGNetwork.vcxproj.filters

@@ -36,6 +36,9 @@
     <ClInclude Include="NewsClient.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
+    <ClInclude Include="RegisterServer.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="MainClient.cpp">
@@ -53,5 +56,8 @@
     <ClCompile Include="NewsClient.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
+    <ClCompile Include="RegisterServer.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

KSGNetwork/MainClient.cpp

@@ -4,6 +4,7 @@
 #include "ErhaltungClient.h"
 #include "PatchClient.h"
 #include "NewsClient.h"
+#include "RegisterServer.h"
 
 using namespace KSGClient;
 
@@ -313,7 +314,52 @@ NewsServerClient *MainClient::createNewsServerClient()
 //  Gibt bei misserfolg 0 zurück
 RegisterServerClient *MainClient::createRegisterServerClient()
 {
-
+    cs.lock();
+    bool connected = k != 0;
+    if( !connected )
+        connect();
+    if( !k )
+    {
+        err = "no connection to Main Server";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\6\1", 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 RegisterClient( 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 RegisterServer server returned: ";
+        err += f;
+        delete[]f;
+    }
+    if( !connected )
+        disconnect();
+    cs.unlock();
+    return 0;
 }
 
 // Erzeugt einen Login Server Client

KSGNetwork/RegisterServer.cpp

@@ -0,0 +1,685 @@
+#include "RegisterServer.h"
+#include <Klient.h>
+#include "Keys.h"
+#include <Globals.h>
+
+
+using namespace KSGClient;
+
+// Inhalt der RegisterClient Klasse
+
+
+// Konstruktor
+RegisterClient::RegisterClient( 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
+RegisterClient::~RegisterClient()
+{
+    if( k )
+        k->release();
+    delete[] key;
+}
+
+// verbindet ich mit dem Register Server
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool RegisterClient::verbinde() 
+{
+    cs.lock();
+    if( k )
+    {
+        cs.unlock();
+        return 1;
+    }
+    k = new Network::Klient();
+    int l = 0;
+    char *key;
+    Keys::getServerKey( &key, l, Keys::REGISTER, Keys::SENDEN );
+    k->setSendeKey( key, l );
+    delete[] key;
+    Keys::getServerKey( &key, l, Keys::REGISTER, 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 Register Server returned: ";
+                err += f;
+                delete[]f;
+                trenne( 0 );
+                cs.unlock();
+                return 0;
+            }
+            k->setSendeKey( (char*)key, keyLen );
+            k->setEmpfangKey( (char*)key, keyLen );
+        }
+        else
+        {
+            err = "network error while sending to Register 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;
+}
+
+// Sendet eine Anfrage auf Erstellung eines neuen Accounts. Ein neuer Account kann erst verwendet werden, wenn ein Link in der Bestätigungsemail angeklickt wurde.
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+//  name: Der Login Name des Accounts
+//  pass: Das Login Passwort des Accounts
+//  geheim: Das Geheimnis des Accounts
+//  eMail: Die EMail Adresse an die die bestätigungs EMail gesendet werden soll
+//  jahr: Das Jahr des Geburtsdatums
+//  monat: Der Monat des Geburtstages
+//  tag: Der Tag des Geburtstages
+bool RegisterClient::accountErstellen( const char *name, const char *pass, const char *geheim, const char *eMail, unsigned short jahr, char monat, char tag ) 
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\5", 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        unsigned char län[ 4 ] = {
+            (unsigned char)textLength( name ),
+            (unsigned char)textLength( pass ),
+            (unsigned char)textLength( geheim ),
+            (unsigned char)textLength( eMail )
+        };
+        k->sendeEncrypted( (char*)län, 4 );
+        k->sendeEncrypted( name, län[ 0 ] );
+        k->sendeEncrypted( pass, län[ 1 ] );
+        k->sendeEncrypted( geheim, län[ 2 ] );
+        k->sendeEncrypted( eMail, län[ 3 ] );
+        k->sendeEncrypted( (char*)&jahr, 2 );
+        k->sendeEncrypted( &monat, 1 );
+        k->sendeEncrypted( &tag, 1 );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *fehler = new char[ byte + 1 ];
+        fehler[ byte ] = 0;
+        k->getNachrichtEncrypted( fehler, byte );
+        err = fehler;
+        delete[]fehler;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Sendet eine Anfrage auf Löschung eines neuen Accounts. Ein neuer Account kann erst gelöscht werden, wenn ein Link in der Bestätigungsemail angeklickt wurde.
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+//  name: Der Login Name des Accounts
+//  pass: Das Login Passwort des Accounts
+//  geheim: Das Geheimnis des Accounts
+bool RegisterClient::accountLöschen( const char *name, const char *pass, const char *geheim ) 
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\6", 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        unsigned char län[ 3 ] = {
+            (unsigned char)textLength( name ),
+            (unsigned char)textLength( pass ),
+            (unsigned char)textLength( geheim )
+        };
+        k->sendeEncrypted( (char*)län, 3 );
+        k->sendeEncrypted( name, län[ 0 ] );
+        k->sendeEncrypted( pass, län[ 1 ] );
+        k->sendeEncrypted( geheim, län[ 2 ] );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *fehler = new char[ byte + 1 ];
+        fehler[ byte ] = 0;
+        k->getNachrichtEncrypted( fehler, byte );
+        err = fehler;
+        delete[]fehler;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Ändert das Passwort eines Accounts
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+//  name: Der Login Name des Accounts
+//  pass: Das Login Passwort des Accounts
+//  geheim: Das Geheimnis des Accounts
+//  nPass: Das neue Passwort des Accounts
+bool RegisterClient::passwortÄndern( const char *name, const char *pass, const char *geheim, const char *nPass ) 
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\7", 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        unsigned char län[ 4 ] = {
+            (unsigned char)textLength( name ),
+            (unsigned char)textLength( pass ),
+            (unsigned char)textLength( nPass ),
+            (unsigned char)textLength( geheim )
+        };
+        k->sendeEncrypted( (char*)län, 4 );
+        k->sendeEncrypted( name, län[ 0 ] );
+        k->sendeEncrypted( pass, län[ 1 ] );
+        k->sendeEncrypted( nPass, län[ 2 ] );
+        k->sendeEncrypted( geheim, län[ 3 ] );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *fehler = new char[ byte + 1 ];
+        fehler[ byte ] = 0;
+        k->getNachrichtEncrypted( fehler, byte );
+        err = fehler;
+        delete[]fehler;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Ändert die EMail Adresse eines Accounts
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+//  name: Der Login Name des Accounts
+//  pass: Das Login Passwort des Accounts
+//  geheim: Das Geheimnis des Accounts
+//  nEMail: Die neue EMail Adresse
+bool RegisterClient::eMailÄndern( const char *name, const char *pass, const char *geheim, const char *nEMail ) 
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    char byte = 8;
+    k->sendeEncrypted( &byte, 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        unsigned char län[ 4 ] = {
+            (unsigned char)textLength( name ),
+            (unsigned char)textLength( pass ),
+            (unsigned char)textLength( geheim ),
+            (unsigned char)textLength( nEMail )
+        };
+        k->sendeEncrypted( (char*)län, 4 );
+        k->sendeEncrypted( name, län[ 0 ] );
+        k->sendeEncrypted( pass, län[ 1 ] );
+        k->sendeEncrypted( geheim, län[ 2 ] );
+        k->sendeEncrypted( nEMail, län[ 3 ] );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *fehler = new char[ byte + 1 ];
+        fehler[ byte ] = 0;
+        k->getNachrichtEncrypted( fehler, byte );
+        err = fehler;
+        delete[]fehler;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Ändert das Geheimnis eines Accounts
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+//  name: Der Login Name des Accounts
+//  pass: Das Login Passwort des Accounts
+//  geheim: Das Geheimnis des Accounts
+//  nGeheim: Das neue Geheimnis
+bool RegisterClient::geheimnisÄndern( const char *name, const char *pass, const char *geheim, const char *nGeheim ) 
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    char byte = 9;
+    k->sendeEncrypted( &byte, 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        unsigned char län[ 4 ] = {
+            (unsigned char)textLength( name ),
+            (unsigned char)textLength( pass ),
+            (unsigned char)textLength( geheim ),
+            (unsigned char)textLength( nGeheim )
+        };
+        k->sendeEncrypted( (char*)län, 4 );
+        k->sendeEncrypted( name, län[ 0 ] );
+        k->sendeEncrypted( pass, län[ 1 ] );
+        k->sendeEncrypted( geheim, län[ 2 ] );
+        k->sendeEncrypted( nGeheim, län[ 3 ] );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *fehler = new char[ byte + 1 ];
+        fehler[ byte ] = 0;
+        k->getNachrichtEncrypted( fehler, byte );
+        err = fehler;
+        delete[]fehler;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Sendet eine Anfrage auf Name Vergessen. Der Name wird an die angegebene EMail Adresse gesendet
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+//  pass: Das Login Passwort des Accounts
+//  geheim: Das Geheimnis des Accounts
+bool RegisterClient::nameVergessen( const char *pass, const char *geheim ) 
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    char byte = 0xA;
+    k->sendeEncrypted( &byte, 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        unsigned char län[ 2 ] = {
+            (unsigned char)textLength( pass ),
+            (unsigned char)textLength( geheim )
+        };
+        k->sendeEncrypted( (char*)län, 2 );
+        k->sendeEncrypted( pass, län[ 0 ] );
+        k->sendeEncrypted( geheim, län[ 1 ] );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *fehler = new char[ byte + 1 ];
+        fehler[ byte ] = 0;
+        k->getNachrichtEncrypted( fehler, byte );
+        err = fehler;
+        delete[]fehler;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Sendet eine Anfrage auf Passwort Vergessen. Es wird ein Link an die angegebene Email Adresse gesendet, über den ein neues Passwort vergeben werden kann
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+//  name: Der Login Name des Accounts
+//  geheim: Das Geheimnis des Accounts
+bool RegisterClient::passwortVergessen( const char *name, const char *geheim ) 
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    char byte = 0xB;
+    k->sendeEncrypted( &byte, 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        unsigned char län[ 2 ] = {
+            (unsigned char)textLength( name ),
+            (unsigned char)textLength( geheim )
+        };
+        k->sendeEncrypted( (char*)län, 2 );
+        k->sendeEncrypted( name, län[ 0 ] );
+        k->sendeEncrypted( geheim, län[ 1 ] );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *fehler = new char[ byte + 1 ];
+        fehler[ byte ] = 0;
+        k->getNachrichtEncrypted( fehler, byte );
+        err = fehler;
+        delete[]fehler;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Sendet eine Anfrage auf Geheimnis Vergessen. Das Geheimnis wird an die angegebene EMail Adresse gesendet
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+//  name: Der Login Name des Accounts
+//  pass: Das Login Passwort des Accounts
+bool RegisterClient::geheimnisVergessen( const char *name, const char *pass ) 
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    char byte = 0xC;
+    k->sendeEncrypted( &byte, 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        unsigned char län[ 2 ] = {
+            (unsigned char)textLength( name ),
+            (unsigned char)textLength( pass )
+        };
+        k->sendeEncrypted( (char*)län, 2 );
+        k->sendeEncrypted( name, län[ 0 ] );
+        k->sendeEncrypted( pass, län[ 1 ] );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *fehler = new char[ byte + 1 ];
+        fehler[ byte ] = 0;
+        k->getNachrichtEncrypted( fehler, byte );
+        err = fehler;
+        delete[]fehler;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Sendet eine Anfrage auf EMail Vergessen. Die EMail Adresse wird direkt vom Server zurückgegeben
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+//  name: Der Login Name des Accounts
+//  pass: Das Login Passwort des Accounts
+//  geheim: Das Geheimnis des Accounts
+//  eMail: Ein Zeiger auf eine Zeichenkette. Diese wird bei einem Erfolgreichen Aufruf auf die EMail Adresse gesetzt und muss manuell mit delete[] gelöscht werden
+bool RegisterClient::eMailVergessen( const char *name, const char *pass, const char *geheim, char **eMail ) 
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    char byte2 = 0xD;
+    k->sendeEncrypted( &byte2, 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        unsigned char län[ 3 ] = {
+            (unsigned char)textLength( name ),
+            (unsigned char)textLength( pass ),
+            (unsigned char)textLength( geheim )
+        };
+        k->sendeEncrypted( (char*)län, 3 );
+        k->sendeEncrypted( name, län[ 0 ] );
+        k->sendeEncrypted( pass, län[ 1 ] );
+        k->sendeEncrypted( geheim, län[ 2 ] );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            unsigned char len = 0;
+            k->getNachrichtEncrypted( (char*)&len, 1 );
+            char *mail = new char[ len + 1 ];
+            mail[ len ] = 0;
+            k->getNachrichtEncrypted( mail, len );
+            *eMail = mail;
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *fehler = new char[ byte + 1 ];
+        fehler[ byte ] = 0;
+        k->getNachrichtEncrypted( fehler, byte );
+        err = fehler;
+        delete[]fehler;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// 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 RegisterClient::keepAlive() 
+{
+    if( !k )
+        return 0;
+    char res = 0;
+    if( !cs.tryLock() )
+        return 1;
+    Framework::logLine( (char*)"Verbindungstest zum Register Server..." );
+    bool ok = k->sendeEncrypted( "\xF", 1 );
+    ok &= k->getNachrichtEncrypted( &res, 1 );
+    cs.unlock();
+    if( res != 1 || !ok )
+    {
+        Framework::logLine( ( char* )"Verbindungsabbruch." );
+        trenne( 0 );
+    }
+    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 RegisterClient::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 Register 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 Register 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 RegisterClient::istVerbunden() const 
+{
+    return k != 0;
+}
+
+// gibt den Letzten Fehlertext zuück
+//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+char *RegisterClient::getLetzterFehler() const 
+{
+    return err;
+}
+
+// Erhöht den Reference Counter um 1 un gibt this zurück
+RegisterServerClient *RegisterClient::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 
+RegisterServerClient *RegisterClient::release() 
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

KSGNetwork/RegisterServer.h

@@ -0,0 +1,108 @@
+#pragma once
+
+#include "../Include/KSGNetwork.h"
+#include <Critical.h>
+
+namespace KSGClient
+{
+    // Wird benutzt, um Accounts zu erstellen zu ändern oder zu löschen
+    class RegisterClient : public RegisterServerClient
+    {
+    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
+        RegisterClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
+        // Destruktor
+        ~RegisterClient();
+        // verbindet ich mit dem Register Server
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool verbinde() override;
+        // Sendet eine Anfrage auf Erstellung eines neuen Accounts. Ein neuer Account kann erst verwendet werden, wenn ein Link in der Bestätigungsemail angeklickt wurde.
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        //  name: Der Login Name des Accounts
+        //  pass: Das Login Passwort des Accounts
+        //  geheim: Das Geheimnis des Accounts
+        //  eMail: Die EMail Adresse an die die bestätigungs EMail gesendet werden soll
+        //  jahr: Das Jahr des Geburtsdatums
+        //  monat: Der Monat des Geburtstages
+        //  tag: Der Tag des Geburtstages
+        bool accountErstellen( const char *name, const char *pass, const char *geheim, const char *eMail, unsigned short jahr, char monat, char tag ) override;
+        // Sendet eine Anfrage auf Löschung eines neuen Accounts. Ein neuer Account kann erst gelöscht werden, wenn ein Link in der Bestätigungsemail angeklickt wurde.
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        //  name: Der Login Name des Accounts
+        //  pass: Das Login Passwort des Accounts
+        //  geheim: Das Geheimnis des Accounts
+        bool accountLöschen( const char *name, const char *pass, const char *geheim ) override;
+        // Ändert das Passwort eines Accounts
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        //  name: Der Login Name des Accounts
+        //  pass: Das Login Passwort des Accounts
+        //  geheim: Das Geheimnis des Accounts
+        //  nPass: Das neue Passwort des Accounts
+        bool passwortÄndern( const char *name, const char *pass, const char *geheim, const char *nPass ) override;
+        // Ändert die EMail Adresse eines Accounts
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        //  name: Der Login Name des Accounts
+        //  pass: Das Login Passwort des Accounts
+        //  geheim: Das Geheimnis des Accounts
+        //  nEMail: Die neue EMail Adresse
+        bool eMailÄndern( const char *name, const char *pass, const char *geheim, const char *nEMail ) override;
+        // Ändert das Geheimnis eines Accounts
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        //  name: Der Login Name des Accounts
+        //  pass: Das Login Passwort des Accounts
+        //  geheim: Das Geheimnis des Accounts
+        //  nGeheim: Das neue Geheimnis
+        bool geheimnisÄndern( const char *name, const char *pass, const char *geheim, const char *nGeheim ) override;
+        // Sendet eine Anfrage auf Name Vergessen. Der Name wird an die angegebene EMail Adresse gesendet
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        //  pass: Das Login Passwort des Accounts
+        //  geheim: Das Geheimnis des Accounts
+        bool nameVergessen( const char *pass, const char *geheim ) override;
+        // Sendet eine Anfrage auf Passwort Vergessen. Es wird ein Link an die angegebene Email Adresse gesendet, über den ein neues Passwort vergeben werden kann
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        //  name: Der Login Name des Accounts
+        //  geheim: Das Geheimnis des Accounts
+        bool passwortVergessen( const char *name, const char *geheim ) override;
+        // Sendet eine Anfrage auf Geheimnis Vergessen. Das Geheimnis wird an die angegebene EMail Adresse gesendet
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        //  name: Der Login Name des Accounts
+        //  pass: Das Login Passwort des Accounts
+        bool geheimnisVergessen( const char *name, const char *pass ) override;
+        // Sendet eine Anfrage auf EMail Vergessen. Die EMail Adresse wird direkt vom Server zurückgegeben
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        //  name: Der Login Name des Accounts
+        //  pass: Das Login Passwort des Accounts
+        //  geheim: Das Geheimnis des Accounts
+        //  eMail: Ein Zeiger auf eine Zeichenkette. Diese wird bei einem Erfolgreichen Aufruf auf die EMail Adresse gesetzt und muss manuell mit delete[] gelöscht werden
+        bool eMailVergessen( const char *name, const char *pass, const char *geheim, char **eMail ) 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
+        RegisterServerClient *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 
+        RegisterServerClient *release() override;
+    };
+}