Chat Client fertig

Include/KSGNetwork.h

@@ -143,23 +143,14 @@ namespace KSGClient
     };
 
     // Enthält eine Nachricht, die von Chat Server gesendet wurde
-    class ChatServerNachricht
+    struct ChatServerNachricht
     {
-    protected:
-        int ref; // Reference Counter
-
-    public:
         char type; // Typ der Nachricht
-        Framework::Text *message; // Text der Nachricht
+        Framework::Text message; // Text der Nachricht
         int account; // Beteiligter Account
         int gruppe; // Beteiligte Gruppe
         int chatroom; // Beteiligter Chatraum
-        Framework::Array< int > *ids; // Liste mit Account Ids
-        // Erhöht den Reference Counter um 1 un gibt this zurück
-        virtual ChatServerNachricht *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 ChatServerNachricht *release() = 0;
+        Framework::Array< int > ids; // Liste mit Account Ids
     };
 
     // Enthält alle Daten zur Team - Spieler Konstalation einer Karte
@@ -736,7 +727,8 @@ namespace KSGClient
         //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
         virtual bool trenne( bool abmelden ) = 0;
         // Wartet auf eine Nachricht vom Chatserver und gibt diese zurück.
-        virtual ChatServerNachricht *getNextMessage() = 0;
+        //  nachricht: Eine Referenz auf die Struktur, in der die Nachricht gespeichert werden soll
+        virtual bool getNextMessage( ChatServerNachricht &nachricht) = 0;
         // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
         virtual bool istVerbunden() const = 0;
         // gibt den Letzten Fehlertext zuück

KSGNetwork/ChatClient.cpp

@@ -0,0 +1,913 @@
+#include "ChatClient.h"
+#include "Keys.h"
+#include <Klient.h>
+#include <Globals.h>
+
+using namespace KSGClient;
+
+// Inhalt der ChatClient Klasse
+
+// Konstruktor
+ChatClient::ChatClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
+{
+    ref = 1;
+    this->ip = ip;
+    this->port = port;
+    cId = klientId;
+    senden = 0;
+    empfangen = 0;
+    this->key = new char[ keyLen ];
+    memcpy( this->key, key, keyLen );
+    this->keyLen = keyLen;
+}
+
+// Destruktor
+ChatClient::~ChatClient()
+{
+    trenne( 1 );
+    delete[] key;
+}
+
+// verbindet sich mit dem zugewiesenen Chat Server
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool ChatClient::verbinde()
+{
+    cs.lock();
+    if( senden )
+    {
+        cs.unlock();
+        return 1;
+    }
+    senden = new Network::Klient();
+    int keyLen = 0;
+    char *key = 0;
+    Keys::getServerKey( &key, keyLen, Keys::CHAT, Keys::SENDEN );
+    senden->setSendeKey( key, keyLen );
+    delete[] key;
+    Keys::getServerKey( &key, keyLen, Keys::CHAT, Keys::EMPFANGEN );
+    senden->setEmpfangKey( key, keyLen );
+    delete[] key;
+    if( senden->verbinde( port, ip ) )
+    {
+        if( senden->sendeEncrypted( "\1", 1 ) )
+        {
+            senden->sendeEncrypted( (char*)&cId, 4 );
+            char ret = 0;
+            senden->getNachrichtEncrypted( &ret, 1 );
+            if( ret != 1 )
+            {
+                char byte = 0;
+                senden->getNachrichtEncrypted( &byte, 1 );
+                char *f = new char[ byte + 1 ];
+                f[ byte ] = 0;
+                senden->getNachrichtEncrypted( f, byte );
+                err = f;
+                delete[]f;
+                senden->sendeEncrypted( "\3", 1 );
+                char serverReturn = 0;
+                senden->getNachrichtEncrypted( &serverReturn, 1 );
+                senden->trenne();
+                senden = senden->release();
+                cs.unlock();
+                return 0;
+            }
+            senden->setSendeKey( this->key, this->keyLen );
+            senden->setEmpfangKey( this->key, this->keyLen );
+            empfangen = new Network::Klient();
+            int keyLen = 0;
+            char *key = 0;
+            Keys::getServerKey( &key, keyLen, Keys::CHAT, Keys::SENDEN );
+            empfangen->setSendeKey( key, keyLen );
+            delete[] key;
+            Keys::getServerKey( &key, keyLen, Keys::CHAT, Keys::EMPFANGEN );
+            empfangen->setEmpfangKey( key, keyLen );
+            delete[] key;
+            if( empfangen->verbinde( senden->getServerPort(), senden->getServerIp() ) )
+            {
+                empfangen->sendeEncrypted( "\1", 1 );
+                empfangen->sendeEncrypted( (char*)&cId, 4 );
+                char res = 0;
+                empfangen->getNachrichtEncrypted( &res, 1 );
+                if( res == 1 )
+                {
+                    empfangen->setSendeKey( this->key, this->keyLen );
+                    empfangen->setEmpfangKey( this->key, this->keyLen );
+                    cs.unlock();
+                    return 1;
+                }
+                if( res == 3 )
+                {
+                    char län = 0;
+                    senden->getNachrichtEncrypted( &län, 1 );
+                    char *nachricht = new char[ län + 1 ];
+                    nachricht[ län ] = 0;
+                    senden->getNachrichtEncrypted( nachricht, län );
+                    err = nachricht;
+                    delete[]nachricht;
+                }
+                trenne( 0 );
+            }
+            else
+            {
+                err = "Der dir zugewiesene Chat Server kann dir keine Nachrichten senden.";
+                empfangen = empfangen->release();
+                senden->sendeEncrypted( "\3", 1 );
+                char serverReturn = 0;
+                senden->getNachrichtEncrypted( &serverReturn, 1 );
+                senden->trenne();
+                senden = senden->release();
+                cs.unlock();
+                return 0;
+            }
+        }
+        else
+        {
+            err = "Der dir zugewiesene Chat Server hat die Verbindung abgebrochen. Bitte versuche es Später erneut.";
+            senden = senden->release();
+            cs.unlock();
+            return 0;
+        }
+    }
+    else
+    {
+        err = "Der dir zugewiesene Chat Server antwortet nicht. Bitte versuche es Später erneut.";
+        senden = senden->release();
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// sendet eine Chat Nachricht zu einem Account
+//  zuAccount: Id des Ziel Accounts
+//  nachricht: Die Nachricht
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool ChatClient::chatNachricht( int zuAccount, const char *nachricht )
+{
+    cs.lock();
+    if( !senden )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    char län = textLength( nachricht );
+    if( !län )
+    {
+        cs.unlock();
+        return 1;
+    }
+    senden->sendeEncrypted( "\6", 1 );
+    char serverReturn = 0;
+    senden->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn )
+    {
+        senden->sendeEncrypted( (char*)&zuAccount, 4 );
+        senden->sendeEncrypted( &län, 1 );
+        senden->sendeEncrypted( nachricht, län );
+    }
+    else
+    {
+        err = "Fehler beim senden der Nachricht.";
+        cs.unlock();
+        return 0;
+    }
+    cs.unlock();
+    return 1;
+}
+
+// ändert den angezeigten Account Namen
+//  name: der neue Name
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool ChatClient::accountNameÄndern( const char *name )
+{
+    cs.lock();
+    if( !senden )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    char län = textLength( name );
+    if( !län )
+    {
+        cs.unlock();
+        return 0;
+    }
+    senden->sendeEncrypted( "\x8", 1 );
+    char serverReturn = 0;
+    senden->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn )
+    {
+        senden->sendeEncrypted( &län, 1 );
+        senden->sendeEncrypted( name, län );
+        senden->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    err = "Fehler beim ändern des Namens.";
+    cs.unlock();
+    return 0;
+}
+
+// beendet die Freundschaft mit einem Account
+//  accountId: Die Id des Accounts
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool ChatClient::freundschaftBeenden( int accountId )
+{
+    cs.lock();
+    if( !senden )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    senden->sendeEncrypted( "\x9", 1 );
+    char serverReturn = 0;
+    senden->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn )
+    {
+        senden->sendeEncrypted( (char*)&accountId, 4 );
+        senden->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    err = "Fehler beim beenden der Freundschaft.";
+    cs.unlock();
+    return 0;
+}
+
+// sendet eine Freundesanfragezu einem Account
+//  accountId: Die Id des Accounts
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool ChatClient::freundesAnfrage( int accountId )
+{
+    cs.lock();
+    if( !senden )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    senden->sendeEncrypted( "\xA", 1 );
+    char serverReturn = 0;
+    senden->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn )
+    {
+        senden->sendeEncrypted( (char*)&accountId, 4 );
+        senden->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    err = "Fehler beim senden der Freundschaftsanfrage.";
+    cs.unlock();
+    return 0;
+}
+
+// beantwortet eine Freundesanfrage
+//  accountId: Die Id des Accounts
+//  ja: 1:=annehmen,0:=ablehnen
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool ChatClient::freundesAnfrageBeantworten( int accountId, bool ja )
+{
+    cs.lock();
+    if( !senden )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    senden->sendeEncrypted( "\xB", 1 );
+    char serverReturn = 0;
+    senden->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn )
+    {
+        senden->sendeEncrypted( (char*)&accountId, 4 );
+        char ok = (char)ja;
+        senden->sendeEncrypted( &ok, 1 );
+        senden->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    err = "Fehler beim beantworten der Freundschaftsanfrage.";
+    cs.unlock();
+    return 0;
+}
+
+// erstellt ein chatroom
+//  name: Der Name des Chatrooms
+//  Gibt bei erfolg die Id des Chatrooms zurück, 0 sonst
+int ChatClient::chatroomErstellen( const char *name )
+{
+    cs.lock();
+    if( !senden )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    char län = textLength( name );
+    if( !län )
+    {
+        cs.unlock();
+        return 0;
+    }
+    senden->sendeEncrypted( "\xC", 1 );
+    char serverReturn = 0;
+    senden->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn )
+    {
+        senden->sendeEncrypted( &län, 1 );
+        senden->sendeEncrypted( name, län );
+        senden->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            int ret = 0;
+            senden->getNachrichtEncrypted( (char*)&ret, 4 );
+            cs.unlock();
+            return ret;
+        }
+    }
+    err = "Fehler beim erstellen des Chatrooms.";
+    cs.unlock();
+    return 0;
+}
+
+// Sendet eine Einladung zum Chatroom
+//  accountId: Die Id des Accounts der eingeladen werden soll
+//  chatroomId: Die Id des Chatrooms
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool ChatClient::chatroomEinladung( int accountId, int chatroomId )
+{
+    cs.lock();
+    if( !senden )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    senden->sendeEncrypted( "\xD", 1 );
+    char serverReturn = 0;
+    senden->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn )
+    {
+        senden->sendeEncrypted( (char*)&accountId, 4 );
+        senden->sendeEncrypted( (char*)&chatroomId, 4 );
+        senden->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    err = "Fehler beim senden der Chatroomeinladung.";
+    cs.unlock();
+    return 0;
+}
+
+// Einladung zum Chatroom wird abgelehnt
+//  accountId: Die Id des Accounts
+//  chatroomId: Die Id des Chatrooms
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool ChatClient::chatroomEinladungAblehnen( int accountId, int chatroomId )
+{
+    cs.lock();
+    if( !senden )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    senden->sendeEncrypted( "\xE", 1 );
+    char serverReturn = 0;
+    senden->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn )
+    {
+        senden->sendeEncrypted( (char*)&accountId, 4 );
+        senden->sendeEncrypted( (char*)&chatroomId, 4 );
+        senden->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    err = "Fehler beim beantworten der Chatroomeinladung.";
+    cs.unlock();
+    return 0;
+}
+
+// betritt ein chatroom
+//  chatroomId: Die Id des Chatrooms
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool ChatClient::chatroomBetreten( int chatroomId )
+{
+    cs.lock();
+    if( !senden )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    senden->sendeEncrypted( "\xF", 1 );
+    char serverReturn = 0;
+    senden->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn )
+    {
+        senden->sendeEncrypted( (char*)&chatroomId, 4 );
+        senden->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    err = "Fehler beim betreten des Chatrooms.";
+    cs.unlock();
+    return 0;
+}
+
+// chatroom Nachricht senden
+//  chatroomId: Die Id des Chatrooms
+//  nachricht: Die Nachricht die gesendet werden soll
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool ChatClient::chatroomNachricht( int chatroomId, const char *nachricht )
+{
+    cs.lock();
+    if( !senden )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    char län = textLength( nachricht );
+    if( !län )
+    {
+        cs.unlock();
+        return 0;
+    }
+    senden->sendeEncrypted( "\x10", 1 );
+    char serverReturn = 0;
+    senden->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn )
+    {
+        senden->sendeEncrypted( (char*)&chatroomId, 4 );
+        senden->sendeEncrypted( &län, 1 );
+        senden->sendeEncrypted( nachricht, län );
+        senden->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    err = "Fehler beim senden der Nachricht.";
+    cs.unlock();
+    return 0;
+}
+
+// verlässt chatroom
+//  chatroomId: Die Id des Chatrooms
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool ChatClient::chatroomVerlassen( int chatroomId )
+{
+    cs.lock();
+    if( !senden )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    senden->sendeEncrypted( "\x11", 1 );
+    char serverReturn = 0;
+    senden->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn )
+    {
+        senden->sendeEncrypted( (char*)&chatroomId, 4 );
+        senden->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    err = "Fehler beim verlassen des Chatrooms.";
+    cs.unlock();
+    return 0;
+}
+
+// kickt Account aus Chatroom (nur wenn als admin des Chatrooms eingeloggt)
+//  chatroomId: Die Id des Chatrooms
+//  accountId: Die Id des Accounts
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool ChatClient::chatroomKick( int chatroomId, int accountId )
+{
+    cs.lock();
+    if( !senden )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    senden->sendeEncrypted( "\x12", 1 );
+    char serverReturn = 0;
+    senden->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn )
+    {
+        senden->sendeEncrypted( (char*)&chatroomId, 4 );
+        senden->sendeEncrypted( (char*)&accountId, 4 );
+        senden->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    err = "Fehler beim kicken eines Spielers aus dem Chatroom.";
+    cs.unlock();
+    return 0;
+}
+
+// fragt nach allen freunden
+//  Die Liste der Freunde kann über getNextMessage empfangen werden
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool ChatClient::freundesListeAnfragen()
+{
+    cs.lock();
+    if( !senden )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    char serverReturn = 0;
+    senden->sendeEncrypted( "\x13", 1 );
+    senden->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        cs.unlock();
+        return 1;
+    }
+    err = "Fehler beim Anfragen der Freundesliste.";
+    cs.unlock();
+    return 0;
+}
+
+// fragt nach allen chatnachrichten, die gesendet wurden, während der Account in den der Client eingeloggt ist, offline war
+//  Die einzelnen Nachrichten können über getNextMessage empfangen werden
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool ChatClient::chatNachrichtAnfrage()
+{
+    cs.lock();
+    if( !senden )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    char serverReturn = 0;
+    senden->sendeEncrypted( "\x14", 1 );
+    senden->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        cs.unlock();
+        return 1;
+    }
+    err = "Fehler beim Anfragen der Chatnachrichten.";
+    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 ChatClient::keepAlive()
+{
+    if( !senden )
+        return 0;
+    char res = 0;
+    if( !cs.tryLock() )
+        return 1;
+    Framework::logLine( ( char* )"Verbindungstest zum Chat Server..." );
+    bool ok = senden->sendeEncrypted( "\x15", 1 );
+    ok &= senden->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 ChatClient::trenne( bool abmelden )
+{
+    if( !senden )
+        return 1;
+    cs.lock();
+    senden->sendeEncrypted( "\3", 1 );
+    char serverReturn = 0;
+    senden->getNachrichtEncrypted( &serverReturn, 1 );
+    senden->trenne();
+    senden = senden->release();
+    if( empfangen )
+    {
+        empfangen->trenne();
+        empfangen = empfangen->release();
+    }
+    cs.unlock();
+    return 1;
+}
+
+// Wartet auf eine Nachricht vom Chatserver und gibt diese zurück.
+bool ChatClient::getNextMessage( ChatServerNachricht &nachricht )
+{
+    cs.lock();
+    if( !empfangen )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    do
+    {
+        if( !empfangen->getNachrichtEncrypted( &nachricht.type, 1 ) )
+        {
+            err = "Fehler beim Empfangen der Nachricht.";
+            cs.unlock();
+            return 0;
+        }
+        switch( nachricht.type )
+        {
+        case 3: // Fehler
+            if( 1 )
+            {
+                char länge = 0;
+                empfangen->getNachrichtEncrypted( &länge, 1 );
+                char *txt = new char[ länge + 1 ];
+                txt[ länge ] = 0;
+                empfangen->getNachrichtEncrypted( txt, länge );
+                nachricht.message = txt;
+                delete[] txt;
+            }
+            break;
+        case 4: // Chat Nachricht
+            if( 1 )
+            {
+                empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+                char länge = 0;
+                empfangen->getNachrichtEncrypted( &länge, 1 );
+                char *txt = new char[ länge + 1 ];
+                txt[ länge ] = 0;
+                empfangen->getNachrichtEncrypted( txt, länge );
+                nachricht.message = txt;
+                delete[] txt;
+            }
+            break;
+        case 5: // Spiel Einladung
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
+            break;
+        case 6: // Account Status ändert sich
+            if( 1 )
+            {
+                empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+                char län = 0;
+                empfangen->getNachrichtEncrypted( &län, 1 );
+                char *status = new char[ län + 1 ];
+                status[ län ] = 0;
+                empfangen->getNachrichtEncrypted( status, län );
+                nachricht.message = status;
+                delete[] status;
+            }
+            break;
+        case 7: // Account Name ändert sich
+            if( 1 )
+            {
+                empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+                char län = 0;
+                empfangen->getNachrichtEncrypted( &län, 1 );
+                char *name = new char[ län + 1 ];
+                name[ län ] = 0;
+                empfangen->getNachrichtEncrypted( name, län );
+                nachricht.message = name;
+                delete[] name;
+            }
+            break;
+        case 8: // kein Freund mehr
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+            break;
+        case 9: // Freundesanfrage
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+            break;
+        case 0xA: // Neuer Freund
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+            break;
+        case 0xB: // Freundesanfrage abgelehnt
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+            break;
+        case 0xC: // Einladung zum Chatroom
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.chatroom, 4 );
+            break;
+        case 0xD: // Einladung zum Chatroom abgelehnt
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.chatroom, 4 );
+            break;
+        case 0xE: // Spieler betritt Chatroom
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.chatroom, 4 );
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+            break;
+        case 0xF: // Chatroom Nachricht
+            if( 1 )
+            {
+                empfangen->getNachrichtEncrypted( (char*)&nachricht.chatroom, 4 );
+                empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+                char län = 0;
+                empfangen->getNachrichtEncrypted( &län, 1 );
+                char *txt = new char[ län + 1 ];
+                txt[ län ] = 0;
+                if( län )
+                {
+                    empfangen->getNachrichtEncrypted( txt, län );
+                    nachricht.message = txt;
+                }
+                delete[] txt;
+            }
+            break;
+        case 0x10: // Spieler verlässt Chatroom
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.chatroom, 4 );
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+            break;
+        case 0x11: // Freunde
+            if( 1 )
+            {
+                char freundeAnzahl;
+                empfangen->getNachrichtEncrypted( &freundeAnzahl, 1 );
+                for( int i = 0; i < freundeAnzahl; i++ )
+                {
+                    int accountId = 0;
+                    empfangen->getNachrichtEncrypted( (char*)&accountId, 4 );
+                    nachricht.ids.add( accountId );
+                }
+            }
+            break;
+        case 0x12: // Spieler im Chatroom
+            if( 1 )
+            {
+                empfangen->getNachrichtEncrypted( (char*)&nachricht.chatroom, 4 );
+                char anzahl = 0;
+                empfangen->getNachrichtEncrypted( &anzahl, 1 );
+                for( char i = 0; i < anzahl; i++ )
+                {
+                    int accountId = 0;
+                    empfangen->getNachrichtEncrypted( (char*)&accountId, 4 );
+                    nachricht.ids.add( accountId );
+                }
+            }
+            break;
+        case 0x13: // Freund online
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+            break;
+        case 0x14: // Freund offline
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+            break;
+        case 0x15: // Chatroom Admin
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.chatroom, 4 );
+            break;
+        case 0x16: // Chatroom Kick
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.chatroom, 4 );
+            break;
+        case 0x17: // Spieler betritt Gruppe
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
+            break;
+        case 0x18: // Spieler verlässt Gruppe
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
+            break;
+        case 0x19: // gruppe Nachricht
+            if( 1 )
+            {
+                char län = 0;
+                empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
+                empfangen->getNachrichtEncrypted( &län, 1 );
+                if( län )
+                {
+                    char *txt = new char[ län + 1 ];
+                    txt[ län ] = 0;
+                    empfangen->getNachrichtEncrypted( txt, län );
+                    nachricht.message = txt;
+                    delete[] txt;
+                }
+            }
+            break;
+        case 0x1A: // gruppe Angemeldet
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
+            break;
+        case 0x1B: // gruppe Abgemeldet
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
+            break;
+        case 0x1C: // gruppe Spiel starten
+            if( 1 )
+            {
+                char starten = 0;
+                empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
+                empfangen->getNachrichtEncrypted( &starten, 1 );
+                nachricht.account = starten;
+            }
+            break;
+        case 0x1D: // kick aus Gruppe
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
+            break;
+        case 0x1E: // gruppe Admin
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+            break;
+        case 0x1F: // gruppe Einladung abgelehnt
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+            break;
+        case 0x20: // SpielServer Verbindungs Anfrage
+            if( 1 )
+            {
+                unsigned short port;
+                unsigned char *ip = new unsigned char[ 4 ];
+                empfangen->getNachrichtEncrypted( (char*)&port, 2 );
+                empfangen->getNachrichtEncrypted( (char*)ip, 4 );
+                nachricht.account = port;
+                Text *ipT = new Text( "" );
+                ipT->append( (int)ip[ 0 ] );
+                ipT->append( "." );
+                ipT->append( (int)ip[ 1 ] );
+                ipT->append( "." );
+                ipT->append( (int)ip[ 2 ] );
+                ipT->append( "." );
+                ipT->append( (int)ip[ 3 ] );
+                nachricht.message = ipT->getText();
+                delete[] ip;
+                ipT->release();
+            }
+            break;
+        case 0x21: // Gruppe Einladung abgebrochen
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+            break;
+        case 0x22: // Gruppe Einladung hinzufügen
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
+            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
+            break;
+        case 0x23: // ping
+            empfangen->sendeEncrypted( "\1", 1 );
+            break;
+        }
+    } while( nachricht.type == 0x23 );
+}
+
+// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+bool ChatClient::istVerbunden() const
+{
+    return senden != 0;
+}
+
+// gibt den Letzten Fehlertext zuück
+//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+char *ChatClient::getLetzterFehler() const
+{
+    return err;
+}
+
+// Erhöht den Reference Counter um 1 un gibt this zurück
+ChatServerClient *ChatClient::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 
+ChatServerClient *ChatClient::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

KSGNetwork/ChatClient.h

@@ -0,0 +1,115 @@
+#pragma once
+
+#include "../Include/KSGNetwork.h"
+#include <Critical.h>
+
+namespace KSGClient
+{
+    // Wird verwendet um Chat nachrichten zu senden oder zu empfangen. Das Serversystem sendet außerdem einiege Mitteilungen über den Chat (z.B. Gefundene Spiele, Gruppeneinladungen ...)
+    //  Kann nur von eingeloggten Clients verwendet werden
+    class ChatClient : public ChatServerClient
+    {
+    private:
+        int ref;
+        Framework::Text ip;
+        unsigned short port;
+        int cId;
+        Network::Klient *senden;
+        Network::Klient *empfangen;
+        char *key;
+        unsigned char keyLen;
+        Framework::Critical cs;
+        Framework::Text err;
+
+    public:
+        // Konstruktor
+        ChatClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
+        // Destruktor
+        ~ChatClient();
+        // verbindet sich mit dem zugewiesenen Chat Server
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool verbinde() override;
+        // sendet eine Chat Nachricht zu einem Account
+        //  zuAccount: Id des Ziel Accounts
+        //  nachricht: Die Nachricht
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool chatNachricht( int zuAccount, const char *nachricht ) override;
+        // ändert den angezeigten Account Namen
+        //  name: der neue Name
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool accountNameÄndern( const char *name ) override;
+        // beendet die Freundschaft mit einem Account
+        //  accountId: Die Id des Accounts
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool freundschaftBeenden( int accountId ) override;
+        // sendet eine Freundesanfragezu einem Account
+        //  accountId: Die Id des Accounts
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool freundesAnfrage( int accountId ) override;
+        // beantwortet eine Freundesanfrage
+        //  accountId: Die Id des Accounts
+        //  ja: 1:=annehmen,0:=ablehnen
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool freundesAnfrageBeantworten( int accountId, bool ja ) override;
+        // erstellt ein chatroom
+        //  name: Der Name des Chatrooms
+        //  Gibt bei erfolg die Id des Chatrooms zurück, 0 sonst
+        int chatroomErstellen( const char *name ) override;
+        // Sendet eine Einladung zum Chatroom
+        //  accountId: Die Id des Accounts der eingeladen werden soll
+        //  chatroomId: Die Id des Chatrooms
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool chatroomEinladung( int accountId, int chatroomId ) override;
+        // Einladung zum Chatroom wird abgelehnt
+        //  accountId: Die Id des Accounts
+        //  chatroomId: Die Id des Chatrooms
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool chatroomEinladungAblehnen( int accountId, int chatroomId ) override;
+        // betritt ein chatroom
+        //  chatroomId: Die Id des Chatrooms
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool chatroomBetreten( int chatroomId ) override;
+        // chatroom Nachricht senden
+        //  chatroomId: Die Id des Chatrooms
+        //  nachricht: Die Nachricht die gesendet werden soll
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool chatroomNachricht( int chatroomId, const char *nachricht ) override;
+        // verlässt chatroom
+        //  chatroomId: Die Id des Chatrooms
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool chatroomVerlassen( int chatroomId ) override;
+        // kickt Account aus Chatroom (nur wenn als admin des Chatrooms eingeloggt)
+        //  chatroomId: Die Id des Chatrooms
+        //  accountId: Die Id des Accounts
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool chatroomKick( int chatroomId, int accountId ) override;
+        // fragt nach allen freunden
+        //  Die Liste der Freunde kann über getNextMessage empfangen werden
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool freundesListeAnfragen() override;
+        // fragt nach allen chatnachrichten, die gesendet wurden, während der Account in den der Client eingeloggt ist, offline war
+        //  Die einzelnen Nachrichten können über getNextMessage empfangen werden
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool chatNachrichtAnfrage() 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;
+        // Wartet auf eine Nachricht vom Chatserver und gibt diese zurück.
+        bool getNextMessage( ChatServerNachricht &nachricht ) 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
+        ChatServerClient *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 
+        ChatServerClient *release() override;
+    };
+}

KSGNetwork/ErhaltungClient.cpp

@@ -109,8 +109,8 @@ bool ErhaltungClient::verbinde()
                 cs.unlock();
                 return 0;
             }
-            k->setSendeKey( (char*)this->key, keyLen );
-            k->setEmpfangKey( (char*)this->key, keyLen );
+            k->setSendeKey( this->key, this->keyLen );
+            k->setEmpfangKey( this->key, this->keyLen );
             start();
         }
         else

KSGNetwork/InformationClient.cpp

@@ -0,0 +1,418 @@
+#include "InformationClient.h"
+
+using namespace KSGClient;
+
+// Inhalt der InformationClient Klasse
+
+// Konstruktor
+InformationClient::InformationClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
+{
+
+}
+
+// Destruktor
+InformationClient::~InformationClient()
+{
+
+}
+
+// verbindet ich mit dem zugewiesenen Informaion Server
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool InformationClient::verbinde()
+{
+
+}
+
+// fragt nach dem Informationstext
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+//  txt: Ein Zeiger auf ein Text Objekt, welches bei einem erfolgreichen Aufruf den Informationstext enthält
+//  typ: ein Zeieger auf ein Integer, welches bei einem erfolgreichen Aufruf den Typ der Information enthält
+bool InformationClient::getInformationText( Framework::Text *txt, int *typ )
+{
+
+}
+
+// fragt, ob das entsprechende Spiel vom Server gesperrt wurde
+//  spielId: Die Id des Spiels
+//  Gibt 1 zurück, falls das Spiel gespielt werden darf, 0 sonnst
+bool InformationClient::istSpielErlaubt( int spielId )
+{
+
+}
+
+// fragt, ob die entsprechende Karte vom Server gesperrt wurde
+//  karteId: Die Id der Karte
+//  Gibt 1 zurück, falls die Karte gespielt werden darf, 0 sonnst
+bool InformationClient::istKarteErlaubt( int karteId )
+{
+
+}
+
+// Ermittelt die Id einer Karte
+//  name: Der Name der Karte
+//  Gibt bei misserfolg 0 zurück
+int InformationClient::getKarteId( char *name )
+{
+
+}
+
+// Fragt nach der Id eines Spiels
+//  name: Der Name des Spiels
+//  Gibt bei misserfolg 0 zurück
+int InformationClient::getSpielId( char *name )
+{
+
+}
+
+// fragt nach dem Namen eines Accounts
+//  accountId: Die Id des Accounts
+//  Gibt bei misserfolg 0 zurück
+Framework::Text *InformationClient::getSpielerName( int accountId )
+{
+
+}
+
+// fragt nach der Spiel Statistik eines Accounts
+//  accountId: Die Id des Accounts
+//  spielId: Die Id des Spiels
+//  werte: Nach erfolgreichem Aufruf enthält die Liste die Statistik werte (gespielt, gewonnen, verloren, punkte, bw0, bw1, bw2, bw3, bw4, bw5)
+bool InformationClient::getSpielStatistik( int accountId, int spielId, Framework::Array< int > *werte )
+{
+
+}
+
+// fragt nach dem Namen einer Karte
+//  karteId: Die id der Karte
+//  Gibt bei misserfolg 0 zurück
+Framework::Text *InformationClient::getKarteName( int karteId )
+{
+
+}
+
+// fragt nach dem Namen eines Spiels
+//  spielId: Die id des Spiels
+//  Gibt bei misserfolg 0 zurück
+Framework::Text *InformationClient::getSpielName( int spielId )
+{
+
+}
+
+// fragt nach dem Namen eines Chatrooms
+//  chatroomId: Die id des Chatrooms
+//  Gibt bei misserfolg 0 zurück
+Framework::Text *InformationClient::getChatroomName( int chatroomId )
+{
+
+}
+
+// fragt zu welcher Spielart die Karte gehört
+//  karteId: Die id der Karte
+//  Gibt bei misserfolg 0 zurück
+int InformationClient::getSpielId( int karteId )
+{
+
+}
+
+// gibt die Id eines Accounts zurück
+//  name: Der Angezeigte Name des Accounts
+//  Gibt bei misserfolg 0 zurück
+int InformationClient::getAccountId( char *name )
+{
+
+}
+
+// gibt die Id des Chatrooms zurück
+//  name: Der name des Chatrooms
+//  Gibt bei misserfolg 0 zurück
+int InformationClient::getChatroomId( char *name )
+{
+
+}
+
+// gibt die karten Id zurück, zu dem eine Gruppe erstellt wurde
+//  gruppenId: Die id der Gruppe
+//  Gibt bei misserfolg 0 zurück
+int InformationClient::getGruppenKarteId( int gruppenId )
+{
+
+}
+
+// gibt 1 zurück, wenn zu einer Gruppe Spieler hinzugefügt werden können, 0 sonnst
+//  gruppeId: Die id der Gruppe
+bool InformationClient::getGruppeSpielerHinzufügen( int gruppeId )
+{
+
+}
+
+// gibt die Account Id des Gruppen Administrators zurück
+//  gruppeId: Die Id der Gruppe
+//  Gibt bei misserfolg 0 zurück
+int InformationClient::getGruppeAdminId( int gruppeId )
+{
+
+}
+
+// gibt die Punkte eines Spielers zurück
+//  accountId: Die Accont Id des Spielers
+//  spielId: Die Id des Spiels
+//  Gibt bei misserfolg 0 zurück
+int InformationClient::getSpielerPunkte( int accountId, int spielId )
+{
+
+}
+
+// gibt eine Liste mit Ids von gekauften Spielen zurück
+//  Gibt bei misserfolg 0 zurück
+Framework::Array< int > *InformationClient::getAccountSpielArtListe()
+{
+
+}
+
+// gibt die neuste Version eines Spiels zurück
+//  spielId: Die Id des Spiels
+//  Gibt bei misserfolg 0 zurück
+int InformationClient::getSpielVersion( int spielId )
+{
+
+}
+
+// gibt das Kupfer des Accounts zurück
+//  Gibt bei misserfolg 0 zurück
+int InformationClient::getKupfer()
+{
+
+}
+
+// Gibt die Dateigruppem Id eines Spieles zurück
+//  spielId: Die Id des Spiels
+//  Gibt bei misserfolg 0 zurück
+int InformationClient::getDateiGruppeIdVonSpiel( int spielId )
+{
+
+}
+
+// Gibt den Dateigruppen Pfad zurück
+//  dgId: Die Id der Dateigruppe
+//  Gibt bei misserfolg 0 zurück
+Framework::Text *InformationClient::getDateiGruppePfad( int dgId )
+{
+
+}
+
+// gibt eine Liste mit gekauften Karten zurück
+//  spielId: Die Spiel Id zu der die Karten gehören sollen
+//  Gibt bei misserfolg 0 zurück
+Framework::Array< int > *InformationClient::getAccountKarteListe( int spielId )
+{
+
+}
+
+// Gibt die Dateigruppen Id eines Pfades zurück
+//  pfad: Der Pfad der Dateigruppe
+//  Gibt bei misserfolg 0 zurück
+int InformationClient::getDateiGruppeIdVonPfad( char *pfad )
+{
+
+}
+
+// gibt die neuste Version einer Dateigruppe zurück
+//  dg: Die Dateigruppen Id
+//  Gibt bei misserfolg 0 zurück
+int InformationClient::getDateiGruppeVersion( int dg )
+{
+
+}
+
+// Gibt eine Liste Mit Accounts zurück, die einen bestimmten Text im Namen haben und bestimmt Sortiert ist
+//  suche: Der Text, der in den Namen enthalten sein soll
+//  seite: Die gewünschte Seite der Tabelle (enthält nach einem Erfolgreichen Aufruf die korrekte Seite)
+//  maxSeite: Enthält nach erfolgreichem Aufruf die Maximale Seite
+//  sortSpalte: Die Spalte, nach der Sortiert werden soll
+//  rückwärts: 1:=Rückwärtzt Sortierung, 0:=Vorwärts Sortierung
+//  accounts: Enthält nach erfolgreichem Aufruf die Daten der Accounts
+//  Gibt die Anzahl der gefundenen Accounts zurück
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+int InformationClient::getSpielerListe( char *suche, int *seite, int *maxSeite, char sortSpalte, char rückwärts, Framework::RCArray< AccountInfo > *accounts )
+{
+
+}
+
+// ermittelt die aktivität eines Spielers
+//  accId: Die Id des Accounts
+//  info: Enthält nach erfolgreichem Aufruf die Aktivitätsinformationen der letzten 30 Tage
+bool InformationClient::getSpielerAktivität( int accId, Framework::RCArray< AccountActivityInfo > *info )
+{
+
+}
+
+// Gibt zurück, wie oft ein Spieler eine Karte schon gespielt hat
+//  account: Die Id des Accounts
+//  karte: Die Id der Karte
+int InformationClient::getAccountKarteSpiele( int account, int karte )
+{
+
+}
+
+// Gibt zurück, wie oft ein Spieler eine Karte schon gewonnen hat
+//  account: Die Id des Accounts
+//  karte: Die Id der Karte
+int InformationClient::getAccountKarteSpieleGewonnen( int account, int karte )
+{
+
+}
+
+// Gibt zurück, ob ein Spieler die Karte im Besitz hat
+//  account: Die Id des Accounts
+//  karte: Die Id der Karte
+bool InformationClient::hatAccountKarte( int account, int karte )
+{
+
+}
+
+// Gibt zurück, ob ein Spieler ein Spiel im Besitz hat
+//  account: Die Id des Accounts
+//  spiel: Die Id des Spiels
+bool InformationClient::hatAccountSpiel( int account, int spiel )
+{
+
+}
+
+// gibt eine Liste mit Ids von Karten zurück, die von einem Spieler bereits gespielt wurden
+//  account: Die Id des Accounts
+//  spiel: Die Id des Spiels 
+//  Gibt bei misserfolg 0 zurück
+Framework::Array< int > *InformationClient::getAccountKarteGespieltListe( int account, int spielId )
+{
+
+}
+
+// gibt eine Liste mit Ids von Spielen zurück, die von einem Spieler bereits gespielt wurden
+//  account: Die Id des Accounts
+//  Gibt bei misserfolg 0 zurück
+Framework::Array< int > *InformationClient::getAccountSpielGespieltListe( int account )
+{
+
+}
+
+// Gibt eine Liste von Spiel Partnern eines Spielers zurück
+//  account: Die Id des Accounts
+//  spieler: Enthält nach erfolgreichem Aufruf eine Liste mit Account Ids der Spiel Partner
+//  karten: Enthält nach erfolgreichem Aufruf eine Liste mit den Ids der gespielten Karten
+//  anzahl: Enthält nach erfolgreichem Aufruf eine Liste mit der Anzahl der Spiele
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool InformationClient::getSpielPartnerListe( int account, Framework::Array< int > *spieler, Framework::Array< int > *karten, Framework::Array< int > *anzahl )
+{
+
+}
+
+// Gibt eine Liste mit Spiel Statistiken zurück
+//  account: Die Id des Accounts zu dem die Statistik ermittelt werden soll
+//  seite: Die gewünschte Seite. Enthält nach efolgreichem Aufruf die korrekte Seite
+//  maxSeite: Enthält nach erfolgreichem Aufruf die Macimale Seite
+//  sortSpalte: Die Spalte, nach der Sortiert werden soll
+//  rückwärts: 1:=Rückwärtzt Sortierung, 0:=Vorwärts Sortierung
+//  werte: Enthält nach erfolgreichem Aufruf eine Liste mit Statistik Werten (gespielt, gewonnen, verloren, punkte, bw0, bw1, bw2, bw3, bw4, bw5)
+//  namen: Enthält nach erfolgreichem Aufruf die Namen der Spiele
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool InformationClient::getStatistikListe( int account, int *seite, int *maxSeite, char sortSpalte, char rückwärts,
+                        Framework::RCArray< Framework::Array< int > > *werte, Framework::RCArray< Framework::Text > *namen )
+{
+
+}
+
+// Gibt eine Liste mit den Daten der letzten 20 Spiele von einem Account zurück
+//  account: Die Id des Accounts
+//  Gibt bei misserfolg 0 zurück
+SpielHistorieListe *InformationClient::getSpielHistorieDaten( int account )
+{
+
+}
+
+// Erzeugt einen Client zu dem Historie Server, welcher die Aufzeichnungen und Statistiken eines Bestimmten Spiels verwaltet
+//  spielId: Die id des Spiels
+//  Gibt bei misserfolg 0 zurück
+HistorieServerClient *InformationClient::createHistorieServerClient( int spielId )
+{
+
+}
+ // sucht nach dem Historie Server von einem Spiel
+                                                                          // Prüft, ob der Account bestimmte Berechtigungen besitzt
+                                                                          //  recht: Die Id der Berechtigungen
+bool InformationClient::hatRecht( int recht )
+{
+
+}
+ // Prüft ob Berechtigung vorhanden
+                                     // Gibt eine Liste mit Karten zurück, die einen bestimmten Text im Namen enthalten und bestimmt sortiert ist
+                                     //  filter: Die Zeichenkette, die im Namen Auftreten soll
+                                     //  sortSpalte: Der Index der Spalte, nach der sortiert werden soll
+                                     //  absteigend: 1:=absteigende sortierung,0:=aufsteigende Sortierung
+                                     //  kId: Eine Liste, welche nach einem erfolgreichen Aufruf die Ids der Karten enthält
+                                     //  kName: Eine Liste, welche nach einem erfolgreichen Aufruf die Namen der Karten enthält
+                                     //  sName: Eine Liste, welche nach einem erfolgreichen Aufruf die Namen der Spiele der Karten enthält
+                                     //  kupfer: Eine Liste, welche nach einem erfolgreichen Aufruf die Preise der Karten in Kupfer
+                                     //  verkauft: Eine Liste, welche nach einem erfolgreichen Aufruf die Anzahl der Verkäufe der Karten enthält
+                                     //  maxSpieler: Eine Liste, welche nach einem erfolgreichen Aufruf die Maximalen Spieleranzahlen der Karten enthält
+int InformationClient::getKartenListe( char *filter, char sortSpalte, char absteigend, Framework::Array< int > *kId, Framework::RCArray< Framework::Text > *kName, Framework::RCArray< Framework::Text > *sName,
+                    Framework::Array< int > *kupfer, Framework::Array< int > *verkauft, Framework::Array< int > *maxSpieler )
+{
+
+}
+
+// Erzeugt einen Client zu dem Editor Server von der Karte mit einer bestimmten Id
+//  karteId: Die Id der Karte
+//  Gibt bei misserfolg 0 zurück
+EditorServerClient *InformationClient::createEditorServerClient( int karteId )
+{
+
+}
+
+// Erzeugt einen Client zu dem Karten Server von der Karte mit einer bestimmten Id
+//  karteId: Die Id der Karte
+//  Gibt bei misserfolg 0 zurück
+KartenServerClient *InformationClient::createKartenServerClient( int karteId )
+{
+
+}
+
+// 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 InformationClient::keepAlive()
+{
+
+}
+
+// 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 InformationClient::trenne( bool abmelden )
+{
+
+}
+
+// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+bool InformationClient::istVerbunden() const
+{
+
+}
+
+// gibt den Letzten Fehlertext zuück
+//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+char *InformationClient::getLetzterFehler() const
+{
+
+}
+
+// Erhöht den Reference Counter um 1 un gibt this zurück
+InformationServerClient *InformationClient::getThis()
+{
+
+}
+
+// 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 
+InformationServerClient *InformationClient::release()
+{
+
+}

KSGNetwork/InformationClient.h

@@ -0,0 +1,238 @@
+#pragma once
+
+#include "../Include/KSGNetwork.h"
+#include <Critical.h>
+
+namespace KSGClient
+{
+    // Wird verwendet um informationen über Accounts abzufragen
+    //  Kann nur von eingeloggten Clients verwendet werden
+    class InformationClient : public InformationServerClient
+    {
+    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
+        InformationClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
+        // Destruktor
+        ~InformationClient();
+        // verbindet ich mit dem zugewiesenen Informaion Server
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool verbinde() override;
+        // fragt nach dem Informationstext
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        //  txt: Ein Zeiger auf ein Text Objekt, welches bei einem erfolgreichen Aufruf den Informationstext enthält
+        //  typ: ein Zeieger auf ein Integer, welches bei einem erfolgreichen Aufruf den Typ der Information enthält
+        bool getInformationText( Framework::Text *txt, int *typ ) override;
+        // fragt, ob das entsprechende Spiel vom Server gesperrt wurde
+        //  spielId: Die Id des Spiels
+        //  Gibt 1 zurück, falls das Spiel gespielt werden darf, 0 sonnst
+        bool istSpielErlaubt( int spielId ) override;
+        // fragt, ob die entsprechende Karte vom Server gesperrt wurde
+        //  karteId: Die Id der Karte
+        //  Gibt 1 zurück, falls die Karte gespielt werden darf, 0 sonnst
+        bool istKarteErlaubt( int karteId ) override;
+        // Ermittelt die Id einer Karte
+        //  name: Der Name der Karte
+        //  Gibt bei misserfolg 0 zurück
+        int getKarteId( char *name ) override;
+        // Fragt nach der Id eines Spiels
+        //  name: Der Name des Spiels
+        //  Gibt bei misserfolg 0 zurück
+        int getSpielId( char *name ) override;
+        // fragt nach dem Namen eines Accounts
+        //  accountId: Die Id des Accounts
+        //  Gibt bei misserfolg 0 zurück
+        Framework::Text *getSpielerName( int accountId ) override;
+        // fragt nach der Spiel Statistik eines Accounts
+        //  accountId: Die Id des Accounts
+        //  spielId: Die Id des Spiels
+        //  werte: Nach erfolgreichem Aufruf enthält die Liste die Statistik werte (gespielt, gewonnen, verloren, punkte, bw0, bw1, bw2, bw3, bw4, bw5)
+        bool getSpielStatistik( int accountId, int spielId, Framework::Array< int > *werte ) override;
+        // fragt nach dem Namen einer Karte
+        //  karteId: Die id der Karte
+        //  Gibt bei misserfolg 0 zurück
+        Framework::Text *getKarteName( int karteId ) override;
+        // fragt nach dem Namen eines Spiels
+        //  spielId: Die id des Spiels
+        //  Gibt bei misserfolg 0 zurück
+        Framework::Text *getSpielName( int spielId ) override;
+        // fragt nach dem Namen eines Chatrooms
+        //  chatroomId: Die id des Chatrooms
+        //  Gibt bei misserfolg 0 zurück
+        Framework::Text *getChatroomName( int chatroomId ) override;
+        // fragt zu welcher Spielart die Karte gehört
+        //  karteId: Die id der Karte
+        //  Gibt bei misserfolg 0 zurück
+        int getSpielId( int karteId ) override;
+        // gibt die Id eines Accounts zurück
+        //  name: Der Angezeigte Name des Accounts
+        //  Gibt bei misserfolg 0 zurück
+        int getAccountId( char *name ) override;
+        // gibt die Id des Chatrooms zurück
+        //  name: Der name des Chatrooms
+        //  Gibt bei misserfolg 0 zurück
+        int getChatroomId( char *name ) override;
+        // gibt die karten Id zurück, zu dem eine Gruppe erstellt wurde
+        //  gruppenId: Die id der Gruppe
+        //  Gibt bei misserfolg 0 zurück
+        int getGruppenKarteId( int gruppenId ) override;
+        // gibt 1 zurück, wenn zu einer Gruppe Spieler hinzugefügt werden können, 0 sonnst
+        //  gruppeId: Die id der Gruppe
+        bool getGruppeSpielerHinzufügen( int gruppeId ) override;
+        // gibt die Account Id des Gruppen Administrators zurück
+        //  gruppeId: Die Id der Gruppe
+        //  Gibt bei misserfolg 0 zurück
+        int getGruppeAdminId( int gruppeId ) override;
+        // gibt die Punkte eines Spielers zurück
+        //  accountId: Die Accont Id des Spielers
+        //  spielId: Die Id des Spiels
+        //  Gibt bei misserfolg 0 zurück
+        int getSpielerPunkte( int accountId, int spielId ) override;
+        // gibt eine Liste mit Ids von gekauften Spielen zurück
+        //  Gibt bei misserfolg 0 zurück
+        Framework::Array< int > *getAccountSpielArtListe() override;
+        // gibt die neuste Version eines Spiels zurück
+        //  spielId: Die Id des Spiels
+        //  Gibt bei misserfolg 0 zurück
+        int getSpielVersion( int spielId ) override;
+        // gibt das Kupfer des Accounts zurück
+        //  Gibt bei misserfolg 0 zurück
+        int getKupfer() override;
+        // Gibt die Dateigruppem Id eines Spieles zurück
+        //  spielId: Die Id des Spiels
+        //  Gibt bei misserfolg 0 zurück
+        int getDateiGruppeIdVonSpiel( int spielId ) override;
+        // Gibt den Dateigruppen Pfad zurück
+        //  dgId: Die Id der Dateigruppe
+        //  Gibt bei misserfolg 0 zurück
+        Framework::Text *getDateiGruppePfad( int dgId ) override;
+        // gibt eine Liste mit gekauften Karten zurück
+        //  spielId: Die Spiel Id zu der die Karten gehören sollen
+        //  Gibt bei misserfolg 0 zurück
+        Framework::Array< int > *getAccountKarteListe( int spielId ) override;
+        // Gibt die Dateigruppen Id eines Pfades zurück
+        //  pfad: Der Pfad der Dateigruppe
+        //  Gibt bei misserfolg 0 zurück
+        int getDateiGruppeIdVonPfad( char *pfad ) override;
+        // gibt die neuste Version einer Dateigruppe zurück
+        //  dg: Die Dateigruppen Id
+        //  Gibt bei misserfolg 0 zurück
+        int getDateiGruppeVersion( int dg ) override;
+        // Gibt eine Liste Mit Accounts zurück, die einen bestimmten Text im Namen haben und bestimmt Sortiert ist
+        //  suche: Der Text, der in den Namen enthalten sein soll
+        //  seite: Die gewünschte Seite der Tabelle (enthält nach einem Erfolgreichen Aufruf die korrekte Seite)
+        //  maxSeite: Enthält nach erfolgreichem Aufruf die Maximale Seite
+        //  sortSpalte: Die Spalte, nach der Sortiert werden soll
+        //  rückwärts: 1:=Rückwärtzt Sortierung, 0:=Vorwärts Sortierung
+        //  accounts: Enthält nach erfolgreichem Aufruf die Daten der Accounts
+        //  Gibt die Anzahl der gefundenen Accounts zurück
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        int getSpielerListe( char *suche, int *seite, int *maxSeite, char sortSpalte, char rückwärts, Framework::RCArray< AccountInfo > *accounts ) override;
+        // ermittelt die aktivität eines Spielers
+        //  accId: Die Id des Accounts
+        //  info: Enthält nach erfolgreichem Aufruf die Aktivitätsinformationen der letzten 30 Tage
+        bool getSpielerAktivität( int accId, Framework::RCArray< AccountActivityInfo > *info ) override;
+        // Gibt zurück, wie oft ein Spieler eine Karte schon gespielt hat
+        //  account: Die Id des Accounts
+        //  karte: Die Id der Karte
+        int getAccountKarteSpiele( int account, int karte ) override;
+        // Gibt zurück, wie oft ein Spieler eine Karte schon gewonnen hat
+        //  account: Die Id des Accounts
+        //  karte: Die Id der Karte
+        int getAccountKarteSpieleGewonnen( int account, int karte ) override;
+        // Gibt zurück, ob ein Spieler die Karte im Besitz hat
+        //  account: Die Id des Accounts
+        //  karte: Die Id der Karte
+        bool hatAccountKarte( int account, int karte ) override;
+        // Gibt zurück, ob ein Spieler ein Spiel im Besitz hat
+        //  account: Die Id des Accounts
+        //  spiel: Die Id des Spiels
+        bool hatAccountSpiel( int account, int spiel ) override;
+        // gibt eine Liste mit Ids von Karten zurück, die von einem Spieler bereits gespielt wurden
+        //  account: Die Id des Accounts
+        //  spiel: Die Id des Spiels 
+        //  Gibt bei misserfolg 0 zurück
+        Framework::Array< int > *getAccountKarteGespieltListe( int account, int spielId ) override;
+        // gibt eine Liste mit Ids von Spielen zurück, die von einem Spieler bereits gespielt wurden
+        //  account: Die Id des Accounts
+        //  Gibt bei misserfolg 0 zurück
+        Framework::Array< int > *getAccountSpielGespieltListe( int account ) override;
+        // Gibt eine Liste von Spiel Partnern eines Spielers zurück
+        //  account: Die Id des Accounts
+        //  spieler: Enthält nach erfolgreichem Aufruf eine Liste mit Account Ids der Spiel Partner
+        //  karten: Enthält nach erfolgreichem Aufruf eine Liste mit den Ids der gespielten Karten
+        //  anzahl: Enthält nach erfolgreichem Aufruf eine Liste mit der Anzahl der Spiele
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool getSpielPartnerListe( int account, Framework::Array< int > *spieler, Framework::Array< int > *karten, Framework::Array< int > *anzahl ) override;
+        // Gibt eine Liste mit Spiel Statistiken zurück
+        //  account: Die Id des Accounts zu dem die Statistik ermittelt werden soll
+        //  seite: Die gewünschte Seite. Enthält nach efolgreichem Aufruf die korrekte Seite
+        //  maxSeite: Enthält nach erfolgreichem Aufruf die Macimale Seite
+        //  sortSpalte: Die Spalte, nach der Sortiert werden soll
+        //  rückwärts: 1:=Rückwärtzt Sortierung, 0:=Vorwärts Sortierung
+        //  werte: Enthält nach erfolgreichem Aufruf eine Liste mit Statistik Werten (gespielt, gewonnen, verloren, punkte, bw0, bw1, bw2, bw3, bw4, bw5)
+        //  namen: Enthält nach erfolgreichem Aufruf die Namen der Spiele
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool getStatistikListe( int account, int *seite, int *maxSeite, char sortSpalte, char rückwärts,
+                                        Framework::RCArray< Framework::Array< int > > *werte, Framework::RCArray< Framework::Text > *namen ) override;
+        // Gibt eine Liste mit den Daten der letzten 20 Spiele von einem Account zurück
+        //  account: Die Id des Accounts
+        //  Gibt bei misserfolg 0 zurück
+        SpielHistorieListe *getSpielHistorieDaten( int account ) override;
+        // Erzeugt einen Client zu dem Historie Server, welcher die Aufzeichnungen und Statistiken eines Bestimmten Spiels verwaltet
+        //  spielId: Die id des Spiels
+        //  Gibt bei misserfolg 0 zurück
+        HistorieServerClient *createHistorieServerClient( int spielId ) override; // sucht nach dem Historie Server von einem Spiel
+                                                                                     // Prüft, ob der Account bestimmte Berechtigungen besitzt
+                                                                                     //  recht: Die Id der Berechtigungen
+        bool hatRecht( int recht ) override; // Prüft ob Berechtigung vorhanden
+                                                // Gibt eine Liste mit Karten zurück, die einen bestimmten Text im Namen enthalten und bestimmt sortiert ist
+                                                //  filter: Die Zeichenkette, die im Namen Auftreten soll
+                                                //  sortSpalte: Der Index der Spalte, nach der sortiert werden soll
+                                                //  absteigend: 1:=absteigende sortierung,0:=aufsteigende Sortierung
+                                                //  kId: Eine Liste, welche nach einem erfolgreichen Aufruf die Ids der Karten enthält
+                                                //  kName: Eine Liste, welche nach einem erfolgreichen Aufruf die Namen der Karten enthält
+                                                //  sName: Eine Liste, welche nach einem erfolgreichen Aufruf die Namen der Spiele der Karten enthält
+                                                //  kupfer: Eine Liste, welche nach einem erfolgreichen Aufruf die Preise der Karten in Kupfer
+                                                //  verkauft: Eine Liste, welche nach einem erfolgreichen Aufruf die Anzahl der Verkäufe der Karten enthält
+                                                //  maxSpieler: Eine Liste, welche nach einem erfolgreichen Aufruf die Maximalen Spieleranzahlen der Karten enthält
+        int getKartenListe( char *filter, char sortSpalte, char absteigend, Framework::Array< int > *kId, Framework::RCArray< Framework::Text > *kName, Framework::RCArray< Framework::Text > *sName,
+                                    Framework::Array< int > *kupfer, Framework::Array< int > *verkauft, Framework::Array< int > *maxSpieler ) override;
+        // Erzeugt einen Client zu dem Editor Server von der Karte mit einer bestimmten Id
+        //  karteId: Die Id der Karte
+        //  Gibt bei misserfolg 0 zurück
+        EditorServerClient *createEditorServerClient( int karteId ) override;
+        // Erzeugt einen Client zu dem Karten Server von der Karte mit einer bestimmten Id
+        //  karteId: Die Id der Karte
+        //  Gibt bei misserfolg 0 zurück
+        KartenServerClient *createKartenServerClient( int karteId ) 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
+        InformationServerClient *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 
+        InformationServerClient *release() override;
+    };
+}

KSGNetwork/KSGNetwork.vcxproj

@@ -148,7 +148,9 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClInclude Include="..\Include\KSGNetwork.h" />
+    <ClInclude Include="ChatClient.h" />
     <ClInclude Include="ErhaltungClient.h" />
+    <ClInclude Include="InformationClient.h" />
     <ClInclude Include="Keys.h" />
     <ClInclude Include="LoginClient.h" />
     <ClInclude Include="Main.cpp" />
@@ -158,7 +160,9 @@
     <ClInclude Include="RegisterServer.h" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="ChatClient.cpp" />
     <ClCompile Include="ErhaltungClient.cpp" />
+    <ClCompile Include="InformationClient.cpp" />
     <ClCompile Include="Keys.cpp" />
     <ClCompile Include="LoginClient.cpp" />
     <ClCompile Include="MainClient.cpp" />

KSGNetwork/KSGNetwork.vcxproj.filters

@@ -42,6 +42,12 @@
     <ClInclude Include="LoginClient.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
+    <ClInclude Include="InformationClient.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="ChatClient.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="MainClient.cpp">
@@ -65,5 +71,11 @@
     <ClCompile Include="LoginClient.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
+    <ClCompile Include="ChatClient.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="InformationClient.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

KSGNetwork/LoginClient.cpp

@@ -69,8 +69,8 @@ bool LoginClient::verbinde()
                 cs.unlock();
                 return 0;
             }
-            k->setSendeKey( (char*)key, keyLen );
-            k->setEmpfangKey( (char*)key, keyLen );
+            k->setSendeKey( this->key, this->keyLen );
+            k->setEmpfangKey( this->key, this->keyLen );
         }
         else
         {

KSGNetwork/MainClient.cpp

@@ -5,6 +5,7 @@
 #include "PatchClient.h"
 #include "NewsClient.h"
 #include "RegisterServer.h"
+#include "LoginClient.h"
 
 using namespace KSGClient;
 
@@ -36,9 +37,9 @@ MainClient::MainClient( char *ip, unsigned short port, int klientId, char *key,
 // Destruktor
 MainClient::~MainClient()
 {
-    delete[]key;
     if( k )
         disconnect();
+    delete[]key;
 }
 
 // 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
@@ -366,7 +367,52 @@ RegisterServerClient *MainClient::createRegisterServerClient()
 //  Gibt bei misserfolg 0 zurück
 LoginServerClient *MainClient::createLoginServerClient()
 {
-
+    cs.lock();
+    bool connected = k != 0;
+    if( !connected )
+        connect();
+    if( !k )
+    {
+        err = "no connection to Main Server";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\6\3", 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 LoginClient( 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 LoginServer server returned: ";
+        err += f;
+        delete[]f;
+    }
+    if( !connected )
+        disconnect();
+    cs.unlock();
+    return 0;
 }
 
 // Erzeugt einen Information Server Client

KSGNetwork/NewsClient.cpp

@@ -68,8 +68,8 @@ bool NewsClient::verbinde()
                 cs.unlock();
                 return 0;
             }
-            k->setSendeKey( (char*)key, keyLen );
-            k->setEmpfangKey( (char*)key, keyLen );
+            k->setSendeKey( this->key, this->keyLen );
+            k->setEmpfangKey( this->key, this->keyLen );
         }
         else
         {

KSGNetwork/PatchClient.cpp

@@ -76,8 +76,8 @@ bool PatchClient::verbinde()
                 cs.unlock();
                 return 0;
             }
-            k->setSendeKey( (char*)key, keyLen );
-            k->setEmpfangKey( (char*)key, keyLen );
+            k->setSendeKey( this->key, this->keyLen );
+            k->setEmpfangKey( this->key, this->keyLen );
         }
         else
         {

KSGNetwork/RegisterServer.cpp

@@ -69,8 +69,8 @@ bool RegisterClient::verbinde()
                 cs.unlock();
                 return 0;
             }
-            k->setSendeKey( (char*)key, keyLen );
-            k->setEmpfangKey( (char*)key, keyLen );
+            k->setSendeKey( this->key, this->keyLen );
+            k->setEmpfangKey( this->key, this->keyLen );
         }
         else
         {